Merge 9b017a4d80 into b9685f0477

.github/workflows/llvm.yml

@@ -13,7 +13,7 @@ jobs:
           - { os: ubuntu-22.04, platform: arm64, cxx: g++-11, cc: gcc-11 }
           - { os: macos-11, platform: x64, cxx: clang++, cc: clang }
           - { os: macos-12, platform: x64, cxx: clang++, cc: clang }
-          - { os: macos-12, platform: arm64, cxx: clang++, cc: clang }
+          - { os: macos-14, platform: arm64, cxx: clang++, cc: clang }
 
     runs-on: ${{ matrix.config.os }}
 

.github/workflows/main.yml

@@ -11,6 +11,7 @@ jobs:
         config:
           - { os: ubuntu-22.04, platform: x64, cxx: g++-11, cc: gcc-11 }
           - { os: macos-12, platform: x64, cxx: clang++, cc: clang }
+          - { os: macos-14, platform: arm64, cxx: clang++, cc: clang }
           - { os: windows-2022, platform: x64, vs: "Program Files/Microsoft Visual Studio/2022" }
 
     runs-on: ${{ matrix.config.os }}
@@ -30,10 +31,10 @@ jobs:
           fetch-depth: '0'
 
       - name: Setup emsdk
-        uses: mymindstorm/setup-emsdk@v11
+        uses: mymindstorm/setup-emsdk@v14
         with:
           version: ${{ env.EMSCRIPTEN_VERSION }}
-          actions-cache-folder: emsdk-cache-${{ runner.os }}
+          actions-cache-folder: emsdk-cache-${{ runner.os }}-${{ matrix.config.platform }}
 
       - name: Setup cmake
         uses: jwlawson/actions-setup-cmake@v2

build/Helpers.lua

@@ -253,11 +253,11 @@ function AddPlatformSpecificFiles(folder, filename)
       files { path.join(folder, "i686-pc-win32-msvc", filename) }
   elseif os.istarget("macosx") then
     filter { "architecture:arm64" }
-      files { path.join(folder, "arm64-apple-darwin12.4.0", filename) }
+      files { path.join(folder, "arm64-apple-darwin", filename) }
     filter { "architecture:x86_64" }
-      files { path.join(folder, "x86_64-apple-darwin12.4.0", filename) }
+      files { path.join(folder, "x86_64-apple-darwin", filename) }
     filter {"architecture:x86" }
-      files { path.join(folder, "i686-apple-darwin12.4.0", filename) }
+      files { path.join(folder, "i686-apple-darwin", filename) }
   elseif os.istarget("linux") then
     filter { "architecture:arm64" }
       files { path.join(folder, "arm64-linux-gnu" .. (UseCxx11ABI() and "-cxx11abi" or ""), filename) }

build/build.sh

@@ -18,10 +18,6 @@ oshost=""
 os=""
 test=
 
-if [[ $(uname -m) != *"64"* ]]; then
-  platform=x86
-fi
-
 build()
 {
   if [ $ci = true ]; then
@@ -180,6 +176,33 @@ detect_os()
   os=$oshost
 }
 
+detect_arch()
+{
+  if [ "$oshost" = "linux" ] || [ "$oshost" = "macosx" ]; then
+    arch=$(uname -m)
+    if [ "$arch" = "x86_64" ]; then
+      platform="x64"
+    elif [ "$arch" = "arm64" ] || [ "$arch" = "aarch64" ]; then
+      platform="arm64"
+    elif [ "$arch" = "i686" ] || [ "$arch" = "i386" ]; then
+      platform="x86"
+    else
+      echo "Unknown architecture: $arch"
+    fi
+  elif [ "$oshost" = "windows" ]; then
+    arch=$(echo $PROCESSOR_ARCHITECTURE)
+    if [ "$arch" = "AMD64" ]; then
+      platform="x64"
+    elif [ "$arch" = "ARM64" ]; then
+      platform="arm64"
+    elif [ "$arch" = "x86" ]; then
+      platform="x86"
+    else
+      echo "Unknown architecture: $arch"
+    fi
+  fi
+}
+
 find_msbuild()
 {
   if [ -x "$(command -v MSBuild.exe)" ]; then
@@ -191,6 +214,7 @@ find_msbuild()
 
 cmd=$(tr '[:upper:]' '[:lower:]' <<< $1)
 detect_os
+detect_arch
 download_premake
 
 while [[ $# > 0 ]]; do

src/CppParser/AST.cpp

@@ -214,6 +214,8 @@ DependentNameType::DependentNameType() : Type(TypeKind::DependentName) {}
 
 DependentNameType::~DependentNameType() {}
 
+DEF_STRING(DependentNameType, Identifier)
+
 PackExpansionType::PackExpansionType() : Type(TypeKind::PackExpansion) {}
 
 UnaryTransformType::UnaryTransformType() : Type(TypeKind::UnaryTransform) {}
@@ -242,7 +244,7 @@ LayoutField::LayoutField() : offset(0), fieldPtr(0) {}
 
 LayoutField::LayoutField(const LayoutField & other)
     : offset(other.offset)
-    , name(other.name)
+    , Name(other.Name)
     , qualifiedType(other.qualifiedType)
     , fieldPtr(other.fieldPtr)
 {
@@ -250,6 +252,8 @@ LayoutField::LayoutField(const LayoutField & other)
 
 LayoutField::~LayoutField() {}
 
+DEF_STRING(LayoutField, Name)
+
 LayoutBase::LayoutBase() : offset(0), _class(0) {}
 
 LayoutBase::LayoutBase(const LayoutBase& other) : offset(other.offset), _class(other._class) {}
@@ -293,9 +297,9 @@ Declaration::Declaration(const Declaration& rhs)
     , location(rhs.location.ID)
     , lineNumberStart(rhs.lineNumberStart)
     , lineNumberEnd(rhs.lineNumberEnd)
-    , name(rhs.name)
+    , Name(rhs.Name)
     , comment(rhs.comment)
-    , debugText(rhs.debugText)
+    , DebugText(rhs.DebugText)
     , isIncomplete(rhs.isIncomplete)
     , isDependent(rhs.isDependent)
     , isImplicit(rhs.isImplicit)
@@ -312,6 +316,9 @@ Declaration::~Declaration()
 {
 }
 
+DEF_STRING(Declaration, Name)
+DEF_STRING(Declaration, USR)
+DEF_STRING(Declaration, DebugText)
 DEF_VECTOR(Declaration, PreprocessedEntity*, PreprocessedEntities)
 DEF_VECTOR(Declaration, Declaration*, Redeclarations)
 
@@ -353,7 +360,7 @@ DeclarationContext::FindNamespace(const std::vector<std::string>& Namespaces)
         auto childNamespace = std::find_if(currentNamespace->Namespaces.begin(),
             currentNamespace->Namespaces.end(),
             [&](CppSharp::CppParser::AST::Namespace* ns) {
-                return ns->name == _namespace;
+                return ns->Name == _namespace;
         });
 
         if (childNamespace == currentNamespace->Namespaces.end())
@@ -372,7 +379,7 @@ Namespace* DeclarationContext::FindCreateNamespace(const std::string& Name)
     if (!_namespace)
     {
         _namespace = new Namespace();
-        _namespace->name = Name;
+        _namespace->Name = Name;
         _namespace->_namespace = this;
 
         Namespaces.push_back(_namespace);
@@ -393,7 +400,7 @@ Class* DeclarationContext::FindClass(const void* OriginalPtr,
         auto _class = std::find_if(Classes.begin(), Classes.end(),
             [OriginalPtr, Name, IsComplete](Class* klass) {
                 return (OriginalPtr && klass->originalPtr == OriginalPtr) ||
-                    (klass->name == Name && klass->isIncomplete == !IsComplete); });
+                    (klass->Name == Name && klass->isIncomplete == !IsComplete); });
 
         return _class != Classes.end() ? *_class : nullptr;
     }
@@ -413,7 +420,7 @@ Class* DeclarationContext::FindClass(const void* OriginalPtr,
 Class* DeclarationContext::CreateClass(const std::string& Name, bool IsComplete)
 {
     auto _class = new Class();
-    _class->name = Name;
+    _class->Name = Name;
     _class->_namespace = this;
     _class->isIncomplete = !IsComplete;
 
@@ -457,7 +464,7 @@ Enumeration* DeclarationContext::FindEnum(const std::string& Name, bool Create)
     if (entries.size() == 1)
     {
         auto foundEnum = std::find_if(Enums.begin(), Enums.end(),
-            [&](Enumeration* _enum) { return _enum->name == Name; });
+            [&](Enumeration* _enum) { return _enum->Name == Name; });
 
         if (foundEnum != Enums.end())
             return *foundEnum;
@@ -466,7 +473,7 @@ Enumeration* DeclarationContext::FindEnum(const std::string& Name, bool Create)
             return nullptr;
 
         auto _enum = new Enumeration();
-        _enum->name = Name;
+        _enum->Name = Name;
         _enum->_namespace = this;
         Enums.push_back(_enum);
         return _enum;
@@ -525,7 +532,7 @@ Function* DeclarationContext::FindFunction(const std::string& USR)
 TypedefDecl* DeclarationContext::FindTypedef(const std::string& Name, bool Create)
 {
     auto foundTypedef = std::find_if(Typedefs.begin(), Typedefs.end(),
-            [&](TypedefDecl* tdef) { return tdef->name == Name; });
+            [&](TypedefDecl* tdef) { return tdef->Name == Name; });
 
     if (foundTypedef != Typedefs.end())
         return *foundTypedef;
@@ -534,7 +541,7 @@ TypedefDecl* DeclarationContext::FindTypedef(const std::string& Name, bool Creat
         return nullptr;
      
     auto tdef = new TypedefDecl();
-    tdef->name = Name;
+    tdef->Name = Name;
     tdef->_namespace = this;
 
     return tdef;
@@ -543,7 +550,7 @@ TypedefDecl* DeclarationContext::FindTypedef(const std::string& Name, bool Creat
 TypeAlias* DeclarationContext::FindTypeAlias(const std::string& Name, bool Create)
 {
     auto foundTypeAlias = std::find_if(TypeAliases.begin(), TypeAliases.end(),
-        [&](TypeAlias* talias) { return talias->name == Name; });
+        [&](TypeAlias* talias) { return talias->Name == Name; });
 
     if (foundTypeAlias != TypeAliases.end())
         return *foundTypeAlias;
@@ -552,7 +559,7 @@ TypeAlias* DeclarationContext::FindTypeAlias(const std::string& Name, bool Creat
         return nullptr;
 
     auto talias = new TypeAlias();
-    talias->name = Name;
+    talias->Name = Name;
     talias->_namespace = this;
 
     return talias;
@@ -596,13 +603,17 @@ Friend::Friend() : CppSharp::CppParser::AST::Declaration(DeclarationKind::Friend
 
 Friend::~Friend() {}
 
-StatementObsolete::StatementObsolete(const std::string& str, StatementClassObsolete stmtClass, Declaration* decl) : string(str), _class(stmtClass), decl(decl) {}
+DEF_STRING(StatementObsolete, String)
+
+StatementObsolete::StatementObsolete(const std::string& str, StatementClassObsolete stmtClass, Declaration* decl) : String(str), _class(stmtClass), decl(decl) {}
 
 ExpressionObsolete::ExpressionObsolete(const std::string& str, StatementClassObsolete stmtClass, Declaration* decl)
     : StatementObsolete(str, stmtClass, decl) {}
 
+DEF_STRING(BinaryOperatorObsolete, OpcodeStr)
+
 BinaryOperatorObsolete::BinaryOperatorObsolete(const std::string& str, ExpressionObsolete* lhs, ExpressionObsolete* rhs, const std::string& opcodeStr)
-    : ExpressionObsolete(str, StatementClassObsolete::BinaryOperator), LHS(lhs), RHS(rhs), opcodeStr(opcodeStr) {}
+    : ExpressionObsolete(str, StatementClassObsolete::BinaryOperator), LHS(lhs), RHS(rhs), OpcodeStr(opcodeStr) {}
 
 BinaryOperatorObsolete::~BinaryOperatorObsolete()
 {
@@ -610,7 +621,6 @@ BinaryOperatorObsolete::~BinaryOperatorObsolete()
     deleteExpression(RHS);
 }
 
-
 CallExprObsolete::CallExprObsolete(const std::string& str, Declaration* decl)
     : ExpressionObsolete(str, StatementClassObsolete::CallExprClass, decl) {}
 
@@ -666,6 +676,10 @@ Function::Function()
 }
 
 Function::~Function() {}
+
+DEF_STRING(Function, Mangled)
+DEF_STRING(Function, Signature)
+DEF_STRING(Function, Body)
 DEF_VECTOR(Function, Parameter*, Parameters)
 
 Method::Method() 
@@ -699,14 +713,16 @@ DEF_VECTOR(Enumeration, Enumeration::Item*, Items)
 Enumeration::Item::Item() : Declaration(DeclarationKind::EnumerationItem) {}
 
 Enumeration::Item::Item(const Item& rhs) : Declaration(rhs),
-    expression(rhs.expression), value(rhs.value) {}
+    Expression(rhs.Expression), value(rhs.value) {}
 
 Enumeration::Item::~Item() {}
 
+DEF_STRING(Enumeration::Item, Expression)
+
 Enumeration::Item* Enumeration::FindItemByName(const std::string& Name)
 {
     auto foundEnumItem = std::find_if(Items.begin(), Items.end(),
-        [&](Item* _item) { return _item->name == Name; });
+        [&](Item* _item) { return _item->Name == Name; });
     if (foundEnumItem != Items.end())
         return *foundEnumItem;
     return nullptr;
@@ -717,6 +733,8 @@ Variable::Variable() : Declaration(DeclarationKind::Variable),
 
 Variable::~Variable() {}
 
+DEF_STRING(Variable, Mangled)
+
 BaseClassSpecifier::BaseClassSpecifier() : type(0), offset(0) {}
 
 Field::Field() : Declaration(DeclarationKind::Field), _class(0),
@@ -891,13 +909,21 @@ MacroDefinition::MacroDefinition()
 
 MacroDefinition::~MacroDefinition() {}
 
+DEF_STRING(MacroDefinition, Name)
+DEF_STRING(MacroDefinition, Expression)
+
 MacroExpansion::MacroExpansion() : definition(0) { kind = DeclarationKind::MacroExpansion; }
 
 MacroExpansion::~MacroExpansion() {}
 
+DEF_STRING(MacroExpansion, Name)
+DEF_STRING(MacroExpansion, Text)
+
 TranslationUnit::TranslationUnit() { kind = DeclarationKind::TranslationUnit; }
 
 TranslationUnit::~TranslationUnit() {}
+
+DEF_STRING(TranslationUnit, FileName)
 DEF_VECTOR(TranslationUnit, MacroDefinition*, Macros)
 
 NativeLibrary::NativeLibrary()
@@ -906,6 +932,7 @@ NativeLibrary::NativeLibrary()
 NativeLibrary::~NativeLibrary() {}
 
 // NativeLibrary
+DEF_STRING(NativeLibrary, FileName)
 DEF_VECTOR_STRING(NativeLibrary, Symbols)
 DEF_VECTOR_STRING(NativeLibrary, Dependencies)
 
@@ -941,14 +968,14 @@ TranslationUnit* ASTContext::FindOrCreateModule(std::string File)
 
     auto existingUnit = std::find_if(TranslationUnits.begin(),
         TranslationUnits.end(), [&](TranslationUnit* unit) {
-            return unit && unit->fileName == normalizedFile;
+            return unit && unit->FileName == normalizedFile;
     });
 
     if (existingUnit != TranslationUnits.end())
         return *existingUnit;
 
     auto unit = new TranslationUnit();
-    unit->fileName = normalizedFile;
+    unit->FileName = normalizedFile;
     TranslationUnits.push_back(unit);
 
     return unit;
@@ -957,6 +984,9 @@ TranslationUnit* ASTContext::FindOrCreateModule(std::string File)
 // Comments
 Comment::Comment(CommentKind kind) : kind(kind) {}
 
+DEF_STRING(RawComment, Text)
+DEF_STRING(RawComment, BriefText)
+
 RawComment::RawComment() : fullCommentBlock(0) {}
 
 RawComment::~RawComment()
@@ -1007,10 +1037,12 @@ BlockContentComment::BlockContentComment(CommentKind Kind) : Comment(Kind) {}
 
 BlockCommandComment::Argument::Argument() {}
 
-BlockCommandComment::Argument::Argument(const Argument& rhs) : text(rhs.text) {}
+BlockCommandComment::Argument::Argument(const Argument& rhs) : Text(rhs.Text) {}
 
 BlockCommandComment::Argument::~Argument() {}
 
+DEF_STRING(BlockCommandComment::Argument, Text)
+
 BlockCommandComment::BlockCommandComment() : BlockContentComment(CommentKind::BlockCommandComment), commandId(0), paragraphComment(0) {}
 
 BlockCommandComment::BlockCommandComment(CommentKind Kind) : BlockContentComment(Kind), commandId(0), paragraphComment(0) {}
@@ -1028,6 +1060,8 @@ TParamCommandComment::TParamCommandComment() : BlockCommandComment(CommentKind::
 
 DEF_VECTOR(TParamCommandComment, unsigned, Position)
 
+DEF_STRING(VerbatimBlockLineComment, Text)
+
 VerbatimBlockComment::VerbatimBlockComment() : BlockCommandComment(CommentKind::VerbatimBlockComment) {}
 
 VerbatimBlockComment::~VerbatimBlockComment()
@@ -1036,10 +1070,14 @@ VerbatimBlockComment::~VerbatimBlockComment()
         delete line;
 }
 
+VerbatimBlockLineComment::VerbatimBlockLineComment() : Comment(CommentKind::VerbatimBlockLineComment) {}
+
 DEF_VECTOR(VerbatimBlockComment, VerbatimBlockLineComment*, Lines)
 
 VerbatimLineComment::VerbatimLineComment() : BlockCommandComment(CommentKind::VerbatimLineComment) {}
 
+DEF_STRING(VerbatimLineComment, Text)
+
 ParagraphComment::ParagraphComment() : BlockContentComment(CommentKind::ParagraphComment), isWhitespace(false) {}
 
 ParagraphComment::~ParagraphComment()
@@ -1079,7 +1117,11 @@ HTMLTagComment::HTMLTagComment(CommentKind Kind) : InlineContentComment(Kind) {}
 
 HTMLStartTagComment::Attribute::Attribute() {}
 
-HTMLStartTagComment::Attribute::Attribute(const Attribute& rhs) : name(rhs.name), value(rhs.value) {}
+HTMLStartTagComment::Attribute::Attribute(const Attribute& rhs) : Name(rhs.Name), Value(rhs.Value) {}
+
+DEF_STRING(HTMLStartTagComment::Attribute, Name)
+
+DEF_STRING(HTMLStartTagComment::Attribute, Value)
 
 HTMLStartTagComment::Attribute::~Attribute() {}
 
@@ -1087,17 +1129,25 @@ HTMLStartTagComment::HTMLStartTagComment() : HTMLTagComment(CommentKind::HTMLSta
 
 DEF_VECTOR(HTMLStartTagComment, HTMLStartTagComment::Attribute, Attributes)
 
+DEF_STRING(HTMLStartTagComment, TagName)
+
 HTMLEndTagComment::HTMLEndTagComment() : HTMLTagComment(CommentKind::HTMLEndTagComment) {}
 
+DEF_STRING(HTMLEndTagComment, TagName)
+
 InlineContentComment::InlineContentComment() : Comment(CommentKind::InlineContentComment), hasTrailingNewline(false) {}
 
 InlineContentComment::InlineContentComment(CommentKind Kind) : Comment(Kind), hasTrailingNewline(false) {}
 
 TextComment::TextComment() : InlineContentComment(CommentKind::TextComment) {}
 
+DEF_STRING(TextComment, Text)
+
 InlineCommandComment::Argument::Argument() {}
 
-InlineCommandComment::Argument::Argument(const Argument& rhs) : text(rhs.text) {}
+InlineCommandComment::Argument::Argument(const Argument& rhs) : Text(rhs.Text) {}
+
+DEF_STRING(InlineCommandComment::Argument, Text)
 
 InlineCommandComment::Argument::~Argument() {}
 
@@ -1106,6 +1156,4 @@ InlineCommandComment::InlineCommandComment()
 
 DEF_VECTOR(InlineCommandComment, InlineCommandComment::Argument, Arguments)
 
-VerbatimBlockLineComment::VerbatimBlockLineComment() : Comment(CommentKind::VerbatimBlockLineComment) {}
-
 } } }

src/CppParser/AST.h

@@ -31,7 +31,7 @@ class CS_API NativeLibrary
 public:
     NativeLibrary();
     ~NativeLibrary();
-    std::string fileName;
+    STRING(FileName)
     ArchType archType;
     VECTOR_STRING(Symbols)
     VECTOR_STRING(Dependencies)
@@ -108,7 +108,7 @@ public:
         Argument();
         Argument(const Argument&);
         ~Argument();
-        std::string text;
+        STRING(Text)
     };
     BlockCommandComment();
     BlockCommandComment(CommentKind Kind);
@@ -143,7 +143,7 @@ class CS_API VerbatimBlockLineComment : public Comment
 {
 public:
     VerbatimBlockLineComment();
-    std::string text;
+    STRING(Text)
 };
 
 class CS_API VerbatimBlockComment : public BlockCommandComment
@@ -158,7 +158,7 @@ class CS_API VerbatimLineComment : public BlockCommandComment
 {
 public:
     VerbatimLineComment();
-    std::string text;
+    STRING(Text)
 };
 
 class CS_API InlineCommandComment : public InlineContentComment
@@ -178,7 +178,7 @@ public:
         Argument();
         Argument(const Argument&);
         ~Argument();
-        std::string text;
+        STRING(Text)
     };
     InlineCommandComment();
     unsigned commandId;
@@ -202,11 +202,11 @@ public:
         Attribute();
         Attribute(const Attribute&);
         ~Attribute();
-        std::string name;
-        std::string value;
+        STRING(Name)
+        STRING(Value)
     };
     HTMLStartTagComment();
-    std::string tagName;
+    STRING(TagName)
     VECTOR(Attribute, Attributes)
 };
 
@@ -214,14 +214,14 @@ class CS_API HTMLEndTagComment : public HTMLTagComment
 {
 public:
     HTMLEndTagComment();
-    std::string tagName;
+    STRING(TagName)
 };
 
 class CS_API TextComment : public InlineContentComment
 {
 public:
     TextComment();
-    std::string text;
+    STRING(Text)
 };
 
 enum class RawCommentKind
@@ -242,8 +242,8 @@ public:
     RawComment();
     ~RawComment();
     RawCommentKind kind;
-    std::string text;
-    std::string briefText;
+    STRING(Text)
+    STRING(BriefText)
     FullComment* fullCommentBlock;
 };
 

src/CppParser/Bindings/CSharp/CppSharp.Parser.CSharp.csproj

@@ -9,9 +9,10 @@
     <PlatformParserFolder Condition="$(IsWindows) AND $(PlatformTarget) == x64">x86_64-pc-win32-msvc</PlatformParserFolder>
     <PlatformParserFolder Condition="$(IsLinux) AND $(PlatformTarget) == x64 AND $(UseCXX11ABI)">x86_64-linux-gnu-cxx11abi</PlatformParserFolder>
     <PlatformParserFolder Condition="$(IsLinux) AND $(PlatformTarget) == x64 AND !$(UseCXX11ABI)">x86_64-linux-gnu</PlatformParserFolder>
-    <PlatformParserFolder Condition="$(IsMacOSX) AND $(PlatformTarget) == x64">x86_64-apple-darwin12.4.0</PlatformParserFolder>
+    <PlatformParserFolder Condition="$(IsMacOSX) AND $(PlatformTarget) == x64">x86_64-apple-darwin</PlatformParserFolder>
+    <PlatformParserFolder Condition="$(IsMacOSX) AND $(PlatformTarget) == arm64">arm64-apple-darwin</PlatformParserFolder>
     <PlatformParserFolder Condition="$(IsWindows) AND $(PlatformTarget) == x86">i686-pc-win32-msvc</PlatformParserFolder>
-    <PlatformParserFolder Condition="$(IsMacOSX) AND $(PlatformTarget) == x86">i686-apple-darwin12.4.0</PlatformParserFolder>
+    <PlatformParserFolder Condition="$(IsMacOSX) AND $(PlatformTarget) == x86">i686-apple-darwin</PlatformParserFolder>
   </PropertyGroup>
   
   <ItemGroup>

src/CppParser/Bindings/CSharp/arm64-apple-darwin/Std-symbols.cpp

@@ -1,5 +1,6 @@
 #define _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
 #define _LIBCPP_HIDE_FROM_ABI
+#define _LIBCPP_NO_ABI_TAG
 
 #include <string>
 #include <new>

src/CppParser/Bindings/CSharp/arm64-apple-darwin/Std.cs

@@ -0,0 +1,584 @@
+// ----------------------------------------------------------------------------
+// <auto-generated>
+// This is autogenerated code by CppSharp.
+// Do not edit this file or all your changes will be lost after re-generation.
+// </auto-generated>
+// ----------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security;
+using __NativeMemory = global::System.Runtime.InteropServices.NativeMemory;
+using __CallingConvention = global::System.Runtime.InteropServices.CallingConvention;
+using __IntPtr = global::System.IntPtr;
+
+[assembly:InternalsVisibleTo("CppSharp.Parser.CSharp")]
+
+[assembly:InternalsVisibleTo("CppSharp.CppParser")]
+
+#pragma warning disable CS0109 // Member does not hide an inherited member; new keyword is not required
+#pragma warning disable CS9084 // Struct member returns 'this' or other instance members by reference
+
+namespace Std
+{
+}
+
+namespace Std
+{
+}
+
+namespace Std
+{
+}
+
+namespace Std
+{
+}
+
+namespace Std
+{
+}
+
+namespace Std
+{
+}
+
+namespace Std
+{
+}
+
+namespace Std
+{
+}
+
+namespace Std
+{
+}
+
+namespace Std
+{
+    namespace CharTraits
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 1)]
+        public unsafe partial struct __Internal
+        {
+        }
+    }
+
+    public unsafe partial class CharTraits<_CharT> : IDisposable
+    {
+        public __IntPtr __Instance { get; protected set; }
+
+        internal static readonly new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.CharTraits<_CharT>> NativeToManagedMap =
+            new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.CharTraits<_CharT>>();
+
+        internal static void __RecordNativeToManagedMapping(IntPtr native, global::Std.CharTraits<_CharT> managed)
+        {
+            NativeToManagedMap[native] = managed;
+        }
+
+        internal static bool __TryGetNativeToManagedMapping(IntPtr native, out global::Std.CharTraits<_CharT> managed)
+        {
+    
+            return NativeToManagedMap.TryGetValue(native, out managed);
+        }
+
+        protected bool __ownsNativeInstance;
+
+        internal static CharTraits<_CharT> __CreateInstance(__IntPtr native, bool skipVTables = false)
+        {
+            if (native == __IntPtr.Zero)
+                return null;
+            return new CharTraits<_CharT>(native.ToPointer(), skipVTables);
+        }
+
+        internal static CharTraits<_CharT> __GetOrCreateInstance(__IntPtr native, bool saveInstance = false, bool skipVTables = false)
+        {
+            if (native == __IntPtr.Zero)
+                return null;
+            if (__TryGetNativeToManagedMapping(native, out var managed))
+                return (CharTraits<_CharT>)managed;
+            var result = __CreateInstance(native, skipVTables);
+            if (saveInstance)
+                __RecordNativeToManagedMapping(native, result);
+            return result;
+        }
+
+        internal static CharTraits<_CharT> __CreateInstance(global::Std.CharTraits.__Internal native, bool skipVTables = false)
+        {
+            return new CharTraits<_CharT>(native, skipVTables);
+        }
+
+        private static void* __CopyValue(global::Std.CharTraits.__Internal native)
+        {
+            var ret = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.CharTraits.__Internal), 16);
+            *(global::Std.CharTraits.__Internal*) ret = native;
+            return ret.ToPointer();
+        }
+
+        private CharTraits(global::Std.CharTraits.__Internal native, bool skipVTables = false)
+            : this(__CopyValue(native), skipVTables)
+        {
+            __ownsNativeInstance = true;
+            __RecordNativeToManagedMapping(__Instance, this);
+        }
+
+        protected CharTraits(void* native, bool skipVTables = false)
+        {
+            if (native == null)
+                return;
+            __Instance = new __IntPtr(native);
+        }
+
+        public void Dispose()
+        {
+            Dispose(disposing: true, callNativeDtor: __ownsNativeInstance);
+        }
+
+        partial void DisposePartial(bool disposing);
+
+        internal protected virtual void Dispose(bool disposing, bool callNativeDtor)
+        {
+            if (__Instance == IntPtr.Zero)
+                return;
+            NativeToManagedMap.TryRemove(__Instance, out _);
+            DisposePartial(disposing);
+            if (__ownsNativeInstance)
+                __NativeMemory.AlignedFree((void*)__Instance);
+            __Instance = IntPtr.Zero;
+        }
+    }
+}
+
+namespace Std
+{
+}
+
+namespace Std
+{
+}
+
+namespace Std
+{
+}
+
+namespace Std
+{
+    namespace CompressedPair
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 24)]
+        public unsafe partial struct __Internalc__N_std_N___1_S___compressed_pair____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C_S___rep_S2_
+        {
+            [FieldOffset(0)]
+            internal global::Std.BasicString.Rep.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C __value_;
+        }
+
+        [StructLayout(LayoutKind.Explicit, Size = 8)]
+        public unsafe partial struct __Internalc__N_std_N___1_S___compressed_pair_____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C___N_std_N___1_S_allocator__S1_
+        {
+            [FieldOffset(0)]
+            internal __IntPtr __value_;
+        }
+
+        [StructLayout(LayoutKind.Explicit, Size = 8)]
+        public unsafe partial struct __Internalc__N_std_N___1_S___compressed_pair___i___N_std_N___1_S_allocator__i
+        {
+            [FieldOffset(0)]
+            internal __IntPtr __value_;
+        }
+    }
+}
+
+namespace Std
+{
+    namespace Allocator
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 1)]
+        public unsafe partial struct __Internal
+        {
+            [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNSt3__19allocatorIcEC2B8un170006Ev", CallingConvention = __CallingConvention.Cdecl)]
+            internal static extern __IntPtr ctorc__N_std_N___1_S_allocator__C(__IntPtr __instance);
+        }
+    }
+
+    public unsafe partial class Allocator<_Tp> : IDisposable
+    {
+        public __IntPtr __Instance { get; protected set; }
+
+        internal static readonly new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.Allocator<_Tp>> NativeToManagedMap =
+            new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.Allocator<_Tp>>();
+
+        internal static void __RecordNativeToManagedMapping(IntPtr native, global::Std.Allocator<_Tp> managed)
+        {
+            NativeToManagedMap[native] = managed;
+        }
+
+        internal static bool __TryGetNativeToManagedMapping(IntPtr native, out global::Std.Allocator<_Tp> managed)
+        {
+    
+            return NativeToManagedMap.TryGetValue(native, out managed);
+        }
+
+        protected bool __ownsNativeInstance;
+
+        internal static Allocator<_Tp> __CreateInstance(__IntPtr native, bool skipVTables = false)
+        {
+            if (native == __IntPtr.Zero)
+                return null;
+            return new Allocator<_Tp>(native.ToPointer(), skipVTables);
+        }
+
+        internal static Allocator<_Tp> __GetOrCreateInstance(__IntPtr native, bool saveInstance = false, bool skipVTables = false)
+        {
+            if (native == __IntPtr.Zero)
+                return null;
+            if (__TryGetNativeToManagedMapping(native, out var managed))
+                return (Allocator<_Tp>)managed;
+            var result = __CreateInstance(native, skipVTables);
+            if (saveInstance)
+                __RecordNativeToManagedMapping(native, result);
+            return result;
+        }
+
+        internal static Allocator<_Tp> __CreateInstance(global::Std.Allocator.__Internal native, bool skipVTables = false)
+        {
+            return new Allocator<_Tp>(native, skipVTables);
+        }
+
+        private static void* __CopyValue(global::Std.Allocator.__Internal native)
+        {
+            var ret = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.Allocator.__Internal), 16);
+            *(global::Std.Allocator.__Internal*) ret = native;
+            return ret.ToPointer();
+        }
+
+        private Allocator(global::Std.Allocator.__Internal native, bool skipVTables = false)
+            : this(__CopyValue(native), skipVTables)
+        {
+            __ownsNativeInstance = true;
+            __RecordNativeToManagedMapping(__Instance, this);
+        }
+
+        protected Allocator(void* native, bool skipVTables = false)
+        {
+            if (native == null)
+                return;
+            __Instance = new __IntPtr(native);
+        }
+
+        public Allocator()
+        {
+            var ___Tp = typeof(_Tp);
+            if (___Tp.IsAssignableFrom(typeof(sbyte)))
+            {
+                __Instance = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.Allocator.__Internal), 16);
+                __ownsNativeInstance = true;
+                __RecordNativeToManagedMapping(__Instance, this);
+                global::Std.Allocator.__Internal.ctorc__N_std_N___1_S_allocator__C(__Instance);
+                return;
+            }
+            throw new ArgumentOutOfRangeException("_Tp", string.Join(", ", new[] { typeof(_Tp).FullName }), "global::Std.Allocator<_Tp> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte>.");
+        }
+
+        public void Dispose()
+        {
+            Dispose(disposing: true, callNativeDtor: __ownsNativeInstance);
+        }
+
+        partial void DisposePartial(bool disposing);
+
+        internal protected virtual void Dispose(bool disposing, bool callNativeDtor)
+        {
+            if (__Instance == IntPtr.Zero)
+                return;
+            NativeToManagedMap.TryRemove(__Instance, out _);
+            DisposePartial(disposing);
+            if (__ownsNativeInstance)
+                __NativeMemory.AlignedFree((void*)__Instance);
+            __Instance = IntPtr.Zero;
+        }
+    }
+}
+
+namespace Std
+{
+    namespace BasicString
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 24)]
+        public unsafe partial struct __Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C
+        {
+            [FieldOffset(0)]
+            internal global::Std.CompressedPair.__Internalc__N_std_N___1_S___compressed_pair____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C_S___rep_S2_ __r_;
+
+            [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2B8un170006Ev", CallingConvention = __CallingConvention.Cdecl)]
+            internal static extern __IntPtr ctorc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C(__IntPtr __instance);
+
+            [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev", CallingConvention = __CallingConvention.Cdecl)]
+            internal static extern __IntPtr dtorc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C(__IntPtr __instance);
+
+            [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKc", CallingConvention = __CallingConvention.Cdecl)]
+            internal static extern __IntPtr Assignc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C(__IntPtr __instance, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(CppSharp.Runtime.UTF8Marshaller))] string __s);
+        }
+
+        namespace Rep
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 24)]
+            public unsafe partial struct __Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C
+            {
+                [FieldOffset(0)]
+                internal global::Std.BasicString.Long.__Internal __l;
+
+                [FieldOffset(0)]
+                internal global::Std.BasicString.Short.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C __s;
+
+                [FieldOffset(0)]
+                internal global::Std.BasicString.Raw.__Internal __r;
+            }
+
+            namespace _0
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 24)]
+                public unsafe partial struct __Internal
+                {
+                    [FieldOffset(0)]
+                    internal global::Std.BasicString.Long.__Internal __l;
+
+                    [FieldOffset(0)]
+                    internal global::Std.BasicString.Short.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C __s;
+
+                    [FieldOffset(0)]
+                    internal global::Std.BasicString.Raw.__Internal __r;
+                }
+
+            }
+
+        }
+
+        namespace Long
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 24)]
+            public unsafe partial struct __Internal
+            {
+                [FieldOffset(0)]
+                internal __IntPtr __data_;
+
+                [FieldOffset(8)]
+                internal ulong __size_;
+
+                [FieldOffset(16)]
+                internal ulong __cap_;
+
+                [FieldOffset(23)]
+                internal ulong __is_long_;
+            }
+
+        }
+
+        namespace Short
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 24)]
+            public unsafe partial struct __Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C
+            {
+                [FieldOffset(0)]
+                internal fixed sbyte __data_[23];
+
+                [FieldOffset(23)]
+                internal __IntPtr __padding_;
+
+                [FieldOffset(23)]
+                internal byte __size_;
+
+                [FieldOffset(23)]
+                internal byte __is_long_;
+            }
+
+        }
+
+        namespace Raw
+        {
+            [StructLayout(LayoutKind.Explicit, Size = 24)]
+            public unsafe partial struct __Internal
+            {
+                [FieldOffset(0)]
+                internal fixed ulong __words[3];
+            }
+        }
+
+    }
+
+    public unsafe partial class BasicString<_CharT, _Traits, _Allocator> : IDisposable
+    {
+        public __IntPtr __Instance { get; protected set; }
+
+        internal static readonly new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.BasicString<_CharT, _Traits, _Allocator>> NativeToManagedMap =
+            new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.BasicString<_CharT, _Traits, _Allocator>>();
+
+        internal static void __RecordNativeToManagedMapping(IntPtr native, global::Std.BasicString<_CharT, _Traits, _Allocator> managed)
+        {
+            NativeToManagedMap[native] = managed;
+        }
+
+        internal static bool __TryGetNativeToManagedMapping(IntPtr native, out global::Std.BasicString<_CharT, _Traits, _Allocator> managed)
+        {
+    
+            return NativeToManagedMap.TryGetValue(native, out managed);
+        }
+
+        protected bool __ownsNativeInstance;
+
+        internal static BasicString<_CharT, _Traits, _Allocator> __CreateInstance(__IntPtr native, bool skipVTables = false)
+        {
+            if (native == __IntPtr.Zero)
+                return null;
+            return new BasicString<_CharT, _Traits, _Allocator>(native.ToPointer(), skipVTables);
+        }
+
+        internal static BasicString<_CharT, _Traits, _Allocator> __GetOrCreateInstance(__IntPtr native, bool saveInstance = false, bool skipVTables = false)
+        {
+            if (native == __IntPtr.Zero)
+                return null;
+            if (__TryGetNativeToManagedMapping(native, out var managed))
+                return (BasicString<_CharT, _Traits, _Allocator>)managed;
+            var result = __CreateInstance(native, skipVTables);
+            if (saveInstance)
+                __RecordNativeToManagedMapping(native, result);
+            return result;
+        }
+
+        internal static BasicString<_CharT, _Traits, _Allocator> __CreateInstance(global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C native, bool skipVTables = false)
+        {
+            return new BasicString<_CharT, _Traits, _Allocator>(native, skipVTables);
+        }
+
+        private static void* __CopyValue(global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C native)
+        {
+            var ret = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C), 16);
+            *(global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C*) ret = native;
+            return ret.ToPointer();
+        }
+
+        private BasicString(global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C native, bool skipVTables = false)
+            : this(__CopyValue(native), skipVTables)
+        {
+            __ownsNativeInstance = true;
+            __RecordNativeToManagedMapping(__Instance, this);
+        }
+
+        protected BasicString(void* native, bool skipVTables = false)
+        {
+            if (native == null)
+                return;
+            __Instance = new __IntPtr(native);
+        }
+
+        public BasicString()
+        {
+            var ___CharT = typeof(_CharT);
+            var ___Traits = typeof(_Traits);
+            var ___Allocator = typeof(_Allocator);
+            if (___CharT.IsAssignableFrom(typeof(sbyte)) && ___Traits.IsAssignableFrom(typeof(global::Std.CharTraits<sbyte>)) && ___Allocator.IsAssignableFrom(typeof(global::Std.Allocator<sbyte>)))
+            {
+                __Instance = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C), 16);
+                __ownsNativeInstance = true;
+                __RecordNativeToManagedMapping(__Instance, this);
+                global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C.ctorc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C(__Instance);
+                return;
+            }
+            throw new ArgumentOutOfRangeException("_CharT, _Traits, _Allocator", string.Join(", ", new[] { typeof(_CharT).FullName, typeof(_Traits).FullName, typeof(_Allocator).FullName }), "global::Std.BasicString<_CharT, _Traits, _Allocator> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
+        }
+
+        public void Dispose()
+        {
+            Dispose(disposing: true, callNativeDtor: __ownsNativeInstance);
+        }
+
+        partial void DisposePartial(bool disposing);
+
+        internal protected virtual void Dispose(bool disposing, bool callNativeDtor)
+        {
+            if (__Instance == IntPtr.Zero)
+                return;
+            NativeToManagedMap.TryRemove(__Instance, out _);
+            DisposePartial(disposing);
+            if (callNativeDtor)
+            {
+                var ___CharT = typeof(_CharT);
+                var ___Traits = typeof(_Traits);
+                var ___Allocator = typeof(_Allocator);
+                if (___CharT.IsAssignableFrom(typeof(sbyte)) && ___Traits.IsAssignableFrom(typeof(global::Std.CharTraits<sbyte>)) && ___Allocator.IsAssignableFrom(typeof(global::Std.Allocator<sbyte>)))
+                {
+                    global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C.dtorc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C(__Instance);
+                }
+                throw new ArgumentOutOfRangeException("_CharT, _Traits, _Allocator", string.Join(", ", new[] { typeof(_CharT).FullName, typeof(_Traits).FullName, typeof(_Allocator).FullName }), "global::Std.BasicString<_CharT, _Traits, _Allocator> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
+            }
+            if (__ownsNativeInstance)
+                __NativeMemory.AlignedFree((void*)__Instance);
+            __Instance = IntPtr.Zero;
+        }
+    }
+
+    public unsafe static partial class BasicStringExtensions
+    {
+        public partial struct __Internal
+        {
+            [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4dataB8un170006Ev", CallingConvention = __CallingConvention.Cdecl)]
+            internal static extern __IntPtr Data(__IntPtr __instance);
+        }
+
+        public static string Data(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this)
+        {
+            var __arg0 = @this is null ? __IntPtr.Zero : @this.__Instance;
+            var ___ret = __Internal.Data(__arg0);
+            return CppSharp.Runtime.MarshalUtil.GetString(global::System.Text.Encoding.UTF8, ___ret);
+        }
+    }
+}
+
+namespace Std
+{
+    namespace Vector
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 24)]
+        public unsafe partial struct __Internalc__N_std_N___1_S_vector____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C___N_std_N___1_S_allocator__S0_
+        {
+            [FieldOffset(0)]
+            internal __IntPtr __begin_;
+
+            [FieldOffset(8)]
+            internal __IntPtr __end_;
+
+            [FieldOffset(16)]
+            internal global::Std.CompressedPair.__Internalc__N_std_N___1_S___compressed_pair_____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C___N_std_N___1_S_allocator__S1_ __end_cap_;
+        }
+
+        [StructLayout(LayoutKind.Explicit, Size = 24)]
+        public unsafe partial struct __Internalc__N_std_N___1_S_vector__i___N_std_N___1_S_allocator__i
+        {
+            [FieldOffset(0)]
+            internal __IntPtr __begin_;
+
+            [FieldOffset(8)]
+            internal __IntPtr __end_;
+
+            [FieldOffset(16)]
+            internal global::Std.CompressedPair.__Internalc__N_std_N___1_S___compressed_pair___i___N_std_N___1_S_allocator__i __end_cap_;
+        }
+    }
+}
+
+namespace Std
+{
+    namespace TreeEndNode
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 8)]
+        public unsafe partial struct __Internal_Ptr
+        {
+            [FieldOffset(0)]
+            internal __IntPtr __left_;
+        }
+    }
+}
+
+namespace Std
+{
+}

src/CppParser/Bindings/CSharp/i686-apple-darwin/Std-symbols.cpp

@@ -1,5 +1,6 @@
 #define _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
 #define _LIBCPP_HIDE_FROM_ABI
+#define _LIBCPP_NO_ABI_TAG
 
 #include <string>
 #include <new>

src/CppParser/Bindings/CSharp/i686-apple-darwin/Std.cs

@@ -8,6 +8,7 @@ using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Security;
+using __NativeMemory = global::System.Runtime.InteropServices.NativeMemory;
 using __CallingConvention = global::System.Runtime.InteropServices.CallingConvention;
 using __IntPtr = global::System.IntPtr;
 
@@ -36,50 +37,47 @@ namespace Std
 
 namespace Std
 {
-    namespace CompressedPair
-    {
-        [StructLayout(LayoutKind.Sequential, Size = 12)]
-        public unsafe partial struct __Internalc__N_std_N___1_S___compressed_pair____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C_S___rep_S2_
-        {
-            internal global::Std.BasicString.Rep.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C __value_;
-        }
+}
 
-        [StructLayout(LayoutKind.Sequential, Size = 4)]
-        public unsafe partial struct __Internalc__N_std_N___1_S___compressed_pair_____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C___N_std_N___1_S_allocator__S1_
-        {
-            internal __IntPtr __value_;
-        }
+namespace Std
+{
+}
 
-        [StructLayout(LayoutKind.Sequential, Size = 4)]
-        public unsafe partial struct __Internalc__N_std_N___1_S___compressed_pair___i___N_std_N___1_S_allocator__i
-        {
-            internal __IntPtr __value_;
-        }
-    }
+namespace Std
+{
+}
 
-    namespace Allocator
+namespace Std
+{
+}
+
+namespace Std
+{
+}
+
+namespace Std
+{
+    namespace CharTraits
     {
-        [StructLayout(LayoutKind.Sequential, Size = 1)]
+        [StructLayout(LayoutKind.Explicit, Size = 1)]
         public unsafe partial struct __Internal
         {
-            [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNSt3__19allocatorIcEC2Ev", CallingConvention = __CallingConvention.Cdecl)]
-            internal static extern void ctorc__N_std_N___1_S_allocator__C(__IntPtr __instance);
         }
     }
 
-    public unsafe partial class Allocator<_Tp> : IDisposable
+    public unsafe partial class CharTraits<_CharT> : IDisposable
     {
         public __IntPtr __Instance { get; protected set; }
 
-        internal static readonly new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.Allocator<_Tp>> NativeToManagedMap =
-            new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.Allocator<_Tp>>();
+        internal static readonly new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.CharTraits<_CharT>> NativeToManagedMap =
+            new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.CharTraits<_CharT>>();
 
-        internal static void __RecordNativeToManagedMapping(IntPtr native, global::Std.Allocator<_Tp> managed)
+        internal static void __RecordNativeToManagedMapping(IntPtr native, global::Std.CharTraits<_CharT> managed)
         {
             NativeToManagedMap[native] = managed;
         }
 
-        internal static bool __TryGetNativeToManagedMapping(IntPtr native, out global::Std.Allocator<_Tp> managed)
+        internal static bool __TryGetNativeToManagedMapping(IntPtr native, out global::Std.CharTraits<_CharT> managed)
         {
     
             return NativeToManagedMap.TryGetValue(native, out managed);
@@ -87,65 +85,51 @@ namespace Std
 
         protected bool __ownsNativeInstance;
 
-        internal static Allocator<_Tp> __CreateInstance(__IntPtr native, bool skipVTables = false)
+        internal static CharTraits<_CharT> __CreateInstance(__IntPtr native, bool skipVTables = false)
         {
             if (native == __IntPtr.Zero)
                 return null;
-            return new Allocator<_Tp>(native.ToPointer(), skipVTables);
+            return new CharTraits<_CharT>(native.ToPointer(), skipVTables);
         }
 
-        internal static Allocator<_Tp> __GetOrCreateInstance(__IntPtr native, bool saveInstance = false, bool skipVTables = false)
+        internal static CharTraits<_CharT> __GetOrCreateInstance(__IntPtr native, bool saveInstance = false, bool skipVTables = false)
         {
             if (native == __IntPtr.Zero)
                 return null;
             if (__TryGetNativeToManagedMapping(native, out var managed))
-                return (Allocator<_Tp>)managed;
+                return (CharTraits<_CharT>)managed;
             var result = __CreateInstance(native, skipVTables);
             if (saveInstance)
                 __RecordNativeToManagedMapping(native, result);
             return result;
         }
 
-        internal static Allocator<_Tp> __CreateInstance(global::Std.Allocator.__Internal native, bool skipVTables = false)
+        internal static CharTraits<_CharT> __CreateInstance(global::Std.CharTraits.__Internal native, bool skipVTables = false)
         {
-            return new Allocator<_Tp>(native, skipVTables);
+            return new CharTraits<_CharT>(native, skipVTables);
         }
 
-        private static void* __CopyValue(global::Std.Allocator.__Internal native)
+        private static void* __CopyValue(global::Std.CharTraits.__Internal native)
         {
-            var ret = Marshal.AllocHGlobal(sizeof(global::Std.Allocator.__Internal));
-            *(global::Std.Allocator.__Internal*) ret = native;
+            var ret = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.CharTraits.__Internal), 16);
+            *(global::Std.CharTraits.__Internal*) ret = native;
             return ret.ToPointer();
         }
 
-        private Allocator(global::Std.Allocator.__Internal native, bool skipVTables = false)
+        private CharTraits(global::Std.CharTraits.__Internal native, bool skipVTables = false)
             : this(__CopyValue(native), skipVTables)
         {
             __ownsNativeInstance = true;
             __RecordNativeToManagedMapping(__Instance, this);
         }
 
-        protected Allocator(void* native, bool skipVTables = false)
+        protected CharTraits(void* native, bool skipVTables = false)
         {
             if (native == null)
                 return;
             __Instance = new __IntPtr(native);
         }
 
-        public Allocator()
-        {
-            var ___Tp = typeof(_Tp);
-            if (___Tp.IsAssignableFrom(typeof(sbyte)))
-            {
-                __Instance = Marshal.AllocHGlobal(sizeof(global::Std.Allocator.__Internal));
-                __ownsNativeInstance = true;
-                __RecordNativeToManagedMapping(__Instance, this);
-                global::Std.Allocator.__Internal.ctorc__N_std_N___1_S_allocator__C(__Instance);
-                return;
-            }
-            throw new ArgumentOutOfRangeException("_Tp", string.Join(", ", new[] { typeof(_Tp).FullName }), "global::Std.Allocator<_Tp> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte>.");
-        }
-
         public void Dispose()
         {
             Dispose(disposing: true, callNativeDtor: __ownsNativeInstance);
@@ -160,7 +144,7 @@ namespace Std
             NativeToManagedMap.TryRemove(__Instance, out _);
             DisposePartial(disposing);
             if (__ownsNativeInstance)
-                Marshal.FreeHGlobal(__Instance);
+                __NativeMemory.AlignedFree((void*)__Instance);
             __Instance = IntPtr.Zero;
         }
     }
@@ -168,65 +152,68 @@ namespace Std
 
 namespace Std
 {
-    namespace Vector
+}
+
+namespace Std
+{
+}
+
+namespace Std
+{
+}
+
+namespace Std
+{
+    namespace CompressedPair
     {
-        [StructLayout(LayoutKind.Sequential, Size = 12)]
-        public unsafe partial struct __Internalc__N_std_N___1_S_vector____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C___N_std_N___1_S_allocator__S0_
+        [StructLayout(LayoutKind.Explicit, Size = 12)]
+        public unsafe partial struct __Internalc__N_std_N___1_S___compressed_pair____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C_S___rep_S2_
         {
-            internal __IntPtr __begin_;
-            internal __IntPtr __end_;
-            internal global::Std.CompressedPair.__Internalc__N_std_N___1_S___compressed_pair_____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C___N_std_N___1_S_allocator__S1_ __end_cap_;
+            [FieldOffset(0)]
+            internal global::Std.BasicString.Rep.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C __value_;
         }
 
-        [StructLayout(LayoutKind.Sequential, Size = 12)]
-        public unsafe partial struct __Internalc__N_std_N___1_S_vector__i___N_std_N___1_S_allocator__i
+        [StructLayout(LayoutKind.Explicit, Size = 4)]
+        public unsafe partial struct __Internalc__N_std_N___1_S___compressed_pair_____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C___N_std_N___1_S_allocator__S1_
         {
-            internal __IntPtr __begin_;
-            internal __IntPtr __end_;
-            internal global::Std.CompressedPair.__Internalc__N_std_N___1_S___compressed_pair___i___N_std_N___1_S_allocator__i __end_cap_;
+            [FieldOffset(0)]
+            internal __IntPtr __value_;
         }
-    }
-}
 
-namespace Std
-{
-    namespace TreeEndNode
-    {
-        [StructLayout(LayoutKind.Sequential, Size = 4)]
-        public unsafe partial struct __Internal_Ptr
+        [StructLayout(LayoutKind.Explicit, Size = 4)]
+        public unsafe partial struct __Internalc__N_std_N___1_S___compressed_pair___i___N_std_N___1_S_allocator__i
         {
-            internal __IntPtr __left_;
+            [FieldOffset(0)]
+            internal __IntPtr __value_;
         }
     }
 }
 
 namespace Std
 {
-}
-
-namespace Std
-{
-    namespace CharTraits
+    namespace Allocator
     {
-        [StructLayout(LayoutKind.Sequential, Size = 1)]
+        [StructLayout(LayoutKind.Explicit, Size = 1)]
         public unsafe partial struct __Internal
         {
+            [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNSt3__19allocatorIcEC2B8un170006Ev", CallingConvention = __CallingConvention.Cdecl)]
+            internal static extern void ctorc__N_std_N___1_S_allocator__C(__IntPtr __instance);
         }
     }
 
-    public unsafe partial class CharTraits<_CharT> : IDisposable
+    public unsafe partial class Allocator<_Tp> : IDisposable
     {
         public __IntPtr __Instance { get; protected set; }
 
-        internal static readonly new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.CharTraits<_CharT>> NativeToManagedMap =
-            new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.CharTraits<_CharT>>();
+        internal static readonly new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.Allocator<_Tp>> NativeToManagedMap =
+            new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.Allocator<_Tp>>();
 
-        internal static void __RecordNativeToManagedMapping(IntPtr native, global::Std.CharTraits<_CharT> managed)
+        internal static void __RecordNativeToManagedMapping(IntPtr native, global::Std.Allocator<_Tp> managed)
         {
             NativeToManagedMap[native] = managed;
         }
 
-        internal static bool __TryGetNativeToManagedMapping(IntPtr native, out global::Std.CharTraits<_CharT> managed)
+        internal static bool __TryGetNativeToManagedMapping(IntPtr native, out global::Std.Allocator<_Tp> managed)
         {
     
             return NativeToManagedMap.TryGetValue(native, out managed);
@@ -234,51 +221,65 @@ namespace Std
 
         protected bool __ownsNativeInstance;
 
-        internal static CharTraits<_CharT> __CreateInstance(__IntPtr native, bool skipVTables = false)
+        internal static Allocator<_Tp> __CreateInstance(__IntPtr native, bool skipVTables = false)
         {
             if (native == __IntPtr.Zero)
                 return null;
-            return new CharTraits<_CharT>(native.ToPointer(), skipVTables);
+            return new Allocator<_Tp>(native.ToPointer(), skipVTables);
         }
 
-        internal static CharTraits<_CharT> __GetOrCreateInstance(__IntPtr native, bool saveInstance = false, bool skipVTables = false)
+        internal static Allocator<_Tp> __GetOrCreateInstance(__IntPtr native, bool saveInstance = false, bool skipVTables = false)
         {
             if (native == __IntPtr.Zero)
                 return null;
             if (__TryGetNativeToManagedMapping(native, out var managed))
-                return (CharTraits<_CharT>)managed;
+                return (Allocator<_Tp>)managed;
             var result = __CreateInstance(native, skipVTables);
             if (saveInstance)
                 __RecordNativeToManagedMapping(native, result);
             return result;
         }
 
-        internal static CharTraits<_CharT> __CreateInstance(global::Std.CharTraits.__Internal native, bool skipVTables = false)
+        internal static Allocator<_Tp> __CreateInstance(global::Std.Allocator.__Internal native, bool skipVTables = false)
         {
-            return new CharTraits<_CharT>(native, skipVTables);
+            return new Allocator<_Tp>(native, skipVTables);
         }
 
-        private static void* __CopyValue(global::Std.CharTraits.__Internal native)
+        private static void* __CopyValue(global::Std.Allocator.__Internal native)
         {
-            var ret = Marshal.AllocHGlobal(sizeof(global::Std.CharTraits.__Internal));
-            *(global::Std.CharTraits.__Internal*) ret = native;
+            var ret = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.Allocator.__Internal), 16);
+            *(global::Std.Allocator.__Internal*) ret = native;
             return ret.ToPointer();
         }
 
-        private CharTraits(global::Std.CharTraits.__Internal native, bool skipVTables = false)
+        private Allocator(global::Std.Allocator.__Internal native, bool skipVTables = false)
             : this(__CopyValue(native), skipVTables)
         {
             __ownsNativeInstance = true;
             __RecordNativeToManagedMapping(__Instance, this);
         }
 
-        protected CharTraits(void* native, bool skipVTables = false)
+        protected Allocator(void* native, bool skipVTables = false)
         {
             if (native == null)
                 return;
             __Instance = new __IntPtr(native);
         }
 
+        public Allocator()
+        {
+            var ___Tp = typeof(_Tp);
+            if (___Tp.IsAssignableFrom(typeof(sbyte)))
+            {
+                __Instance = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.Allocator.__Internal), 16);
+                __ownsNativeInstance = true;
+                __RecordNativeToManagedMapping(__Instance, this);
+                global::Std.Allocator.__Internal.ctorc__N_std_N___1_S_allocator__C(__Instance);
+                return;
+            }
+            throw new ArgumentOutOfRangeException("_Tp", string.Join(", ", new[] { typeof(_Tp).FullName }), "global::Std.Allocator<_Tp> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte>.");
+        }
+
         public void Dispose()
         {
             Dispose(disposing: true, callNativeDtor: __ownsNativeInstance);
@@ -293,7 +294,7 @@ namespace Std
             NativeToManagedMap.TryRemove(__Instance, out _);
             DisposePartial(disposing);
             if (__ownsNativeInstance)
-                Marshal.FreeHGlobal(__Instance);
+                __NativeMemory.AlignedFree((void*)__Instance);
             __Instance = IntPtr.Zero;
         }
     }
@@ -303,16 +304,20 @@ namespace Std
 {
     namespace BasicString
     {
-        [StructLayout(LayoutKind.Sequential, Size = 12)]
+        [StructLayout(LayoutKind.Explicit, Size = 12)]
         public unsafe partial struct __Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C
         {
+            [FieldOffset(0)]
             internal global::Std.CompressedPair.__Internalc__N_std_N___1_S___compressed_pair____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C_S___rep_S2_ __r_;
 
-            [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2Ev", CallingConvention = __CallingConvention.Cdecl)]
+            [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2B8un170006Ev", CallingConvention = __CallingConvention.Cdecl)]
             internal static extern void ctorc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C(__IntPtr __instance);
 
             [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev", CallingConvention = __CallingConvention.Cdecl)]
             internal static extern void dtorc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C(__IntPtr __instance);
+
+            [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKc", CallingConvention = __CallingConvention.Cdecl)]
+            internal static extern __IntPtr Assignc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C(__IntPtr __instance, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(CppSharp.Runtime.UTF8Marshaller))] string __s);
         }
 
         namespace Rep
@@ -351,14 +356,36 @@ namespace Std
 
         namespace Long
         {
-            [StructLayout(LayoutKind.Sequential, Size = 12)]
+            [StructLayout(LayoutKind.Explicit, Size = 12)]
             public unsafe partial struct __Internal
             {
+                [FieldOffset(0)]
+                internal uint __is_long_;
+
+                [FieldOffset(0)]
                 internal uint __cap_;
+
+                [FieldOffset(4)]
                 internal uint __size_;
+
+                [FieldOffset(8)]
                 internal __IntPtr __data_;
             }
 
+            namespace _0
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 4)]
+                public unsafe partial struct __Internal
+                {
+                    [FieldOffset(0)]
+                    internal uint __is_long_;
+
+                    [FieldOffset(0)]
+                    internal uint __cap_;
+                }
+
+            }
+
         }
 
         namespace Short
@@ -367,10 +394,13 @@ namespace Std
             public unsafe partial struct __Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C
             {
                 [FieldOffset(0)]
-                internal byte __size_;
+                internal byte __is_long_;
 
                 [FieldOffset(0)]
-                internal sbyte __lx;
+                internal byte __size_;
+
+                [FieldOffset(1)]
+                internal __IntPtr __padding_;
 
                 [FieldOffset(1)]
                 internal fixed sbyte __data_[11];
@@ -382,10 +412,10 @@ namespace Std
                 public unsafe partial struct __Internal
                 {
                     [FieldOffset(0)]
-                    internal byte __size_;
+                    internal byte __is_long_;
 
                     [FieldOffset(0)]
-                    internal sbyte __lx;
+                    internal byte __size_;
                 }
 
             }
@@ -394,9 +424,10 @@ namespace Std
 
         namespace Raw
         {
-            [StructLayout(LayoutKind.Sequential, Size = 12)]
+            [StructLayout(LayoutKind.Explicit, Size = 12)]
             public unsafe partial struct __Internal
             {
+                [FieldOffset(0)]
                 internal fixed uint __words[3];
             }
         }
@@ -449,7 +480,7 @@ namespace Std
 
         private static void* __CopyValue(global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C native)
         {
-            var ret = Marshal.AllocHGlobal(sizeof(global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C));
+            var ret = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C), 16);
             *(global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C*) ret = native;
             return ret.ToPointer();
         }
@@ -475,7 +506,7 @@ namespace Std
             var ___Allocator = typeof(_Allocator);
             if (___CharT.IsAssignableFrom(typeof(sbyte)) && ___Traits.IsAssignableFrom(typeof(global::Std.CharTraits<sbyte>)) && ___Allocator.IsAssignableFrom(typeof(global::Std.Allocator<sbyte>)))
             {
-                __Instance = Marshal.AllocHGlobal(sizeof(global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C));
+                __Instance = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C), 16);
                 __ownsNativeInstance = true;
                 __RecordNativeToManagedMapping(__Instance, this);
                 global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C.ctorc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C(__Instance);
@@ -510,7 +541,7 @@ namespace Std
                 throw new ArgumentOutOfRangeException("_CharT, _Traits, _Allocator", string.Join(", ", new[] { typeof(_CharT).FullName, typeof(_Traits).FullName, typeof(_Allocator).FullName }), "global::Std.BasicString<_CharT, _Traits, _Allocator> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
             }
             if (__ownsNativeInstance)
-                Marshal.FreeHGlobal(__Instance);
+                __NativeMemory.AlignedFree((void*)__Instance);
             __Instance = IntPtr.Zero;
         }
     }
@@ -519,21 +550,10 @@ namespace Std
     {
         public partial struct __Internal
         {
-            [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKc", CallingConvention = __CallingConvention.Cdecl)]
-            internal static extern __IntPtr Assign(__IntPtr __instance, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(CppSharp.Runtime.UTF8Marshaller))] string __s);
-
-            [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4dataEv", CallingConvention = __CallingConvention.Cdecl)]
+            [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4dataB8un170006Ev", CallingConvention = __CallingConvention.Cdecl)]
             internal static extern __IntPtr Data(__IntPtr __instance);
         }
 
-        public static global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> Assign(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this, string __s)
-        {
-            var __arg0 = @this is null ? __IntPtr.Zero : @this.__Instance;
-            var ___ret = __Internal.Assign(__arg0, __s);
-            var __result0 = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__GetOrCreateInstance(___ret, false);
-            return __result0;
-        }
-
         public static string Data(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this)
         {
             var __arg0 = @this is null ? __IntPtr.Zero : @this.__Instance;
@@ -542,3 +562,52 @@ namespace Std
         }
     }
 }
+
+namespace Std
+{
+    namespace Vector
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 12)]
+        public unsafe partial struct __Internalc__N_std_N___1_S_vector____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C___N_std_N___1_S_allocator__S0_
+        {
+            [FieldOffset(0)]
+            internal __IntPtr __begin_;
+
+            [FieldOffset(4)]
+            internal __IntPtr __end_;
+
+            [FieldOffset(8)]
+            internal global::Std.CompressedPair.__Internalc__N_std_N___1_S___compressed_pair_____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C___N_std_N___1_S_allocator__S1_ __end_cap_;
+        }
+
+        [StructLayout(LayoutKind.Explicit, Size = 12)]
+        public unsafe partial struct __Internalc__N_std_N___1_S_vector__i___N_std_N___1_S_allocator__i
+        {
+            [FieldOffset(0)]
+            internal __IntPtr __begin_;
+
+            [FieldOffset(4)]
+            internal __IntPtr __end_;
+
+            [FieldOffset(8)]
+            internal global::Std.CompressedPair.__Internalc__N_std_N___1_S___compressed_pair___i___N_std_N___1_S_allocator__i __end_cap_;
+        }
+    }
+}
+
+namespace Std
+{
+    namespace TreeEndNode
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 4)]
+        public unsafe partial struct __Internal_Ptr
+        {
+            [FieldOffset(0)]
+            internal __IntPtr __left_;
+        }
+    }
+}
+
+namespace Std
+{
+}

src/CppParser/Bindings/CSharp/i686-pc-win32-msvc/Std-symbols.cpp

@@ -1,5 +1,6 @@
 #define _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
 #define _LIBCPP_HIDE_FROM_ABI
+#define _LIBCPP_NO_ABI_TAG
 
 #include <string>
 #include <new>

src/CppParser/Bindings/CSharp/x86_64-apple-darwin/CppSharp.CppParser-symbols.cpp

@@ -0,0 +1,378 @@
+#include <AST.h>
+#include <Sources.h>
+#include <CppParser.h>
+#include <new>
+
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_NativeLibrary_NativeLibrary___1__N_CppSharp_N_CppParser_N_AST_S_NativeLibrary(void* __instance, const CppSharp::CppParser::AST::NativeLibrary& _0) { ::new (__instance) CppSharp::CppParser::AST::NativeLibrary(_0); }
+class CppSharp::CppParser::AST::NativeLibrary& (CppSharp::CppParser::AST::NativeLibrary::*_0)(const class CppSharp::CppParser::AST::NativeLibrary&) = &CppSharp::CppParser::AST::NativeLibrary::operator=;
+class CppSharp::CppParser::AST::Comment& (CppSharp::CppParser::AST::Comment::*_1)(class CppSharp::CppParser::AST::Comment&&) = &CppSharp::CppParser::AST::Comment::operator=;
+class CppSharp::CppParser::AST::BlockContentComment& (CppSharp::CppParser::AST::BlockContentComment::*_2)(class CppSharp::CppParser::AST::BlockContentComment&&) = &CppSharp::CppParser::AST::BlockContentComment::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_FullComment_FullComment___1__N_CppSharp_N_CppParser_N_AST_S_FullComment(void* __instance, const CppSharp::CppParser::AST::FullComment& _0) { ::new (__instance) CppSharp::CppParser::AST::FullComment(_0); }
+class CppSharp::CppParser::AST::FullComment& (CppSharp::CppParser::AST::FullComment::*_3)(const class CppSharp::CppParser::AST::FullComment&) = &CppSharp::CppParser::AST::FullComment::operator=;
+class CppSharp::CppParser::AST::InlineContentComment& (CppSharp::CppParser::AST::InlineContentComment::*_4)(class CppSharp::CppParser::AST::InlineContentComment&&) = &CppSharp::CppParser::AST::InlineContentComment::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_ParagraphComment_ParagraphComment___1__N_CppSharp_N_CppParser_N_AST_S_ParagraphComment(void* __instance, const CppSharp::CppParser::AST::ParagraphComment& _0) { ::new (__instance) CppSharp::CppParser::AST::ParagraphComment(_0); }
+class CppSharp::CppParser::AST::ParagraphComment& (CppSharp::CppParser::AST::ParagraphComment::*_5)(const class CppSharp::CppParser::AST::ParagraphComment&) = &CppSharp::CppParser::AST::ParagraphComment::operator=;
+class CppSharp::CppParser::AST::BlockCommandComment::Argument& (CppSharp::CppParser::AST::BlockCommandComment::Argument::*_6)(const class CppSharp::CppParser::AST::BlockCommandComment::Argument&) = &CppSharp::CppParser::AST::BlockCommandComment::Argument::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_BlockCommandComment_BlockCommandComment___1__N_CppSharp_N_CppParser_N_AST_S_BlockCommandComment(void* __instance, const CppSharp::CppParser::AST::BlockCommandComment& _0) { ::new (__instance) CppSharp::CppParser::AST::BlockCommandComment(_0); }
+class CppSharp::CppParser::AST::BlockCommandComment& (CppSharp::CppParser::AST::BlockCommandComment::*_7)(const class CppSharp::CppParser::AST::BlockCommandComment&) = &CppSharp::CppParser::AST::BlockCommandComment::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_ParamCommandComment_ParamCommandComment___1__N_CppSharp_N_CppParser_N_AST_S_ParamCommandComment(void* __instance, const CppSharp::CppParser::AST::ParamCommandComment& _0) { ::new (__instance) CppSharp::CppParser::AST::ParamCommandComment(_0); }
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_ParamCommandComment__ParamCommandComment(CppSharp::CppParser::AST::ParamCommandComment*__instance) { __instance->~ParamCommandComment(); }
+class CppSharp::CppParser::AST::ParamCommandComment& (CppSharp::CppParser::AST::ParamCommandComment::*_8)(const class CppSharp::CppParser::AST::ParamCommandComment&) = &CppSharp::CppParser::AST::ParamCommandComment::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_TParamCommandComment_TParamCommandComment___1__N_CppSharp_N_CppParser_N_AST_S_TParamCommandComment(void* __instance, const CppSharp::CppParser::AST::TParamCommandComment& _0) { ::new (__instance) CppSharp::CppParser::AST::TParamCommandComment(_0); }
+class CppSharp::CppParser::AST::TParamCommandComment& (CppSharp::CppParser::AST::TParamCommandComment::*_9)(class CppSharp::CppParser::AST::TParamCommandComment&&) = &CppSharp::CppParser::AST::TParamCommandComment::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_TParamCommandComment__TParamCommandComment(CppSharp::CppParser::AST::TParamCommandComment*__instance) { __instance->~TParamCommandComment(); }
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_VerbatimBlockLineComment_VerbatimBlockLineComment___1__N_CppSharp_N_CppParser_N_AST_S_VerbatimBlockLineComment(void* __instance, const CppSharp::CppParser::AST::VerbatimBlockLineComment& _0) { ::new (__instance) CppSharp::CppParser::AST::VerbatimBlockLineComment(_0); }
+class CppSharp::CppParser::AST::VerbatimBlockLineComment& (CppSharp::CppParser::AST::VerbatimBlockLineComment::*_10)(class CppSharp::CppParser::AST::VerbatimBlockLineComment&&) = &CppSharp::CppParser::AST::VerbatimBlockLineComment::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_VerbatimBlockLineComment__VerbatimBlockLineComment(CppSharp::CppParser::AST::VerbatimBlockLineComment*__instance) { __instance->~VerbatimBlockLineComment(); }
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_VerbatimBlockComment_VerbatimBlockComment___1__N_CppSharp_N_CppParser_N_AST_S_VerbatimBlockComment(void* __instance, const CppSharp::CppParser::AST::VerbatimBlockComment& _0) { ::new (__instance) CppSharp::CppParser::AST::VerbatimBlockComment(_0); }
+class CppSharp::CppParser::AST::VerbatimBlockComment& (CppSharp::CppParser::AST::VerbatimBlockComment::*_11)(const class CppSharp::CppParser::AST::VerbatimBlockComment&) = &CppSharp::CppParser::AST::VerbatimBlockComment::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_VerbatimLineComment_VerbatimLineComment___1__N_CppSharp_N_CppParser_N_AST_S_VerbatimLineComment(void* __instance, const CppSharp::CppParser::AST::VerbatimLineComment& _0) { ::new (__instance) CppSharp::CppParser::AST::VerbatimLineComment(_0); }
+class CppSharp::CppParser::AST::VerbatimLineComment& (CppSharp::CppParser::AST::VerbatimLineComment::*_12)(class CppSharp::CppParser::AST::VerbatimLineComment&&) = &CppSharp::CppParser::AST::VerbatimLineComment::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_VerbatimLineComment__VerbatimLineComment(CppSharp::CppParser::AST::VerbatimLineComment*__instance) { __instance->~VerbatimLineComment(); }
+class CppSharp::CppParser::AST::InlineCommandComment::Argument& (CppSharp::CppParser::AST::InlineCommandComment::Argument::*_13)(const class CppSharp::CppParser::AST::InlineCommandComment::Argument&) = &CppSharp::CppParser::AST::InlineCommandComment::Argument::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_InlineCommandComment_InlineCommandComment___1__N_CppSharp_N_CppParser_N_AST_S_InlineCommandComment(void* __instance, const CppSharp::CppParser::AST::InlineCommandComment& _0) { ::new (__instance) CppSharp::CppParser::AST::InlineCommandComment(_0); }
+class CppSharp::CppParser::AST::InlineCommandComment& (CppSharp::CppParser::AST::InlineCommandComment::*_14)(class CppSharp::CppParser::AST::InlineCommandComment&&) = &CppSharp::CppParser::AST::InlineCommandComment::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_InlineCommandComment__InlineCommandComment(CppSharp::CppParser::AST::InlineCommandComment*__instance) { __instance->~InlineCommandComment(); }
+class CppSharp::CppParser::AST::HTMLTagComment& (CppSharp::CppParser::AST::HTMLTagComment::*_15)(class CppSharp::CppParser::AST::HTMLTagComment&&) = &CppSharp::CppParser::AST::HTMLTagComment::operator=;
+class CppSharp::CppParser::AST::HTMLStartTagComment::Attribute& (CppSharp::CppParser::AST::HTMLStartTagComment::Attribute::*_16)(const class CppSharp::CppParser::AST::HTMLStartTagComment::Attribute&) = &CppSharp::CppParser::AST::HTMLStartTagComment::Attribute::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_HTMLStartTagComment_HTMLStartTagComment___1__N_CppSharp_N_CppParser_N_AST_S_HTMLStartTagComment(void* __instance, const CppSharp::CppParser::AST::HTMLStartTagComment& _0) { ::new (__instance) CppSharp::CppParser::AST::HTMLStartTagComment(_0); }
+class CppSharp::CppParser::AST::HTMLStartTagComment& (CppSharp::CppParser::AST::HTMLStartTagComment::*_17)(class CppSharp::CppParser::AST::HTMLStartTagComment&&) = &CppSharp::CppParser::AST::HTMLStartTagComment::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_HTMLStartTagComment__HTMLStartTagComment(CppSharp::CppParser::AST::HTMLStartTagComment*__instance) { __instance->~HTMLStartTagComment(); }
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_HTMLEndTagComment_HTMLEndTagComment___1__N_CppSharp_N_CppParser_N_AST_S_HTMLEndTagComment(void* __instance, const CppSharp::CppParser::AST::HTMLEndTagComment& _0) { ::new (__instance) CppSharp::CppParser::AST::HTMLEndTagComment(_0); }
+class CppSharp::CppParser::AST::HTMLEndTagComment& (CppSharp::CppParser::AST::HTMLEndTagComment::*_18)(class CppSharp::CppParser::AST::HTMLEndTagComment&&) = &CppSharp::CppParser::AST::HTMLEndTagComment::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_HTMLEndTagComment__HTMLEndTagComment(CppSharp::CppParser::AST::HTMLEndTagComment*__instance) { __instance->~HTMLEndTagComment(); }
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_TextComment_TextComment___1__N_CppSharp_N_CppParser_N_AST_S_TextComment(void* __instance, const CppSharp::CppParser::AST::TextComment& _0) { ::new (__instance) CppSharp::CppParser::AST::TextComment(_0); }
+class CppSharp::CppParser::AST::TextComment& (CppSharp::CppParser::AST::TextComment::*_19)(class CppSharp::CppParser::AST::TextComment&&) = &CppSharp::CppParser::AST::TextComment::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_TextComment__TextComment(CppSharp::CppParser::AST::TextComment*__instance) { __instance->~TextComment(); }
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_RawComment_RawComment___1__N_CppSharp_N_CppParser_N_AST_S_RawComment(void* __instance, const CppSharp::CppParser::AST::RawComment& _0) { ::new (__instance) CppSharp::CppParser::AST::RawComment(_0); }
+class CppSharp::CppParser::AST::RawComment& (CppSharp::CppParser::AST::RawComment::*_20)(const class CppSharp::CppParser::AST::RawComment&) = &CppSharp::CppParser::AST::RawComment::operator=;
+struct CppSharp::CppParser::SourceLocation& (CppSharp::CppParser::SourceLocation::*_21)(struct CppSharp::CppParser::SourceLocation&&) = &CppSharp::CppParser::SourceLocation::operator=;
+struct CppSharp::CppParser::SourceRange& (CppSharp::CppParser::SourceRange::*_22)(struct CppSharp::CppParser::SourceRange&&) = &CppSharp::CppParser::SourceRange::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_S_SourceRange_SourceRange(void* __instance) { ::new (__instance) CppSharp::CppParser::SourceRange(); }
+class CppSharp::CppParser::AST::Type& (CppSharp::CppParser::AST::Type::*_23)(const class CppSharp::CppParser::AST::Type&) = &CppSharp::CppParser::AST::Type::operator=;
+struct CppSharp::CppParser::AST::TypeQualifiers& (CppSharp::CppParser::AST::TypeQualifiers::*_24)(struct CppSharp::CppParser::AST::TypeQualifiers&&) = &CppSharp::CppParser::AST::TypeQualifiers::operator=;
+struct CppSharp::CppParser::AST::QualifiedType& (CppSharp::CppParser::AST::QualifiedType::*_25)(struct CppSharp::CppParser::AST::QualifiedType&&) = &CppSharp::CppParser::AST::QualifiedType::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_TagType_TagType___1__N_CppSharp_N_CppParser_N_AST_S_TagType(void* __instance, const CppSharp::CppParser::AST::TagType& _0) { ::new (__instance) CppSharp::CppParser::AST::TagType(_0); }
+class CppSharp::CppParser::AST::TagType& (CppSharp::CppParser::AST::TagType::*_26)(const class CppSharp::CppParser::AST::TagType&) = &CppSharp::CppParser::AST::TagType::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_ArrayType_ArrayType___1__N_CppSharp_N_CppParser_N_AST_S_ArrayType(void* __instance, const CppSharp::CppParser::AST::ArrayType& _0) { ::new (__instance) CppSharp::CppParser::AST::ArrayType(_0); }
+class CppSharp::CppParser::AST::ArrayType& (CppSharp::CppParser::AST::ArrayType::*_27)(const class CppSharp::CppParser::AST::ArrayType&) = &CppSharp::CppParser::AST::ArrayType::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_FunctionType_FunctionType___1__N_CppSharp_N_CppParser_N_AST_S_FunctionType(void* __instance, const CppSharp::CppParser::AST::FunctionType& _0) { ::new (__instance) CppSharp::CppParser::AST::FunctionType(_0); }
+class CppSharp::CppParser::AST::FunctionType& (CppSharp::CppParser::AST::FunctionType::*_28)(const class CppSharp::CppParser::AST::FunctionType&) = &CppSharp::CppParser::AST::FunctionType::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_PointerType_PointerType___1__N_CppSharp_N_CppParser_N_AST_S_PointerType(void* __instance, const CppSharp::CppParser::AST::PointerType& _0) { ::new (__instance) CppSharp::CppParser::AST::PointerType(_0); }
+class CppSharp::CppParser::AST::PointerType& (CppSharp::CppParser::AST::PointerType::*_29)(const class CppSharp::CppParser::AST::PointerType&) = &CppSharp::CppParser::AST::PointerType::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_MemberPointerType_MemberPointerType___1__N_CppSharp_N_CppParser_N_AST_S_MemberPointerType(void* __instance, const CppSharp::CppParser::AST::MemberPointerType& _0) { ::new (__instance) CppSharp::CppParser::AST::MemberPointerType(_0); }
+class CppSharp::CppParser::AST::MemberPointerType& (CppSharp::CppParser::AST::MemberPointerType::*_30)(const class CppSharp::CppParser::AST::MemberPointerType&) = &CppSharp::CppParser::AST::MemberPointerType::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_TypedefType_TypedefType___1__N_CppSharp_N_CppParser_N_AST_S_TypedefType(void* __instance, const CppSharp::CppParser::AST::TypedefType& _0) { ::new (__instance) CppSharp::CppParser::AST::TypedefType(_0); }
+class CppSharp::CppParser::AST::TypedefType& (CppSharp::CppParser::AST::TypedefType::*_31)(const class CppSharp::CppParser::AST::TypedefType&) = &CppSharp::CppParser::AST::TypedefType::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_AttributedType_AttributedType___1__N_CppSharp_N_CppParser_N_AST_S_AttributedType(void* __instance, const CppSharp::CppParser::AST::AttributedType& _0) { ::new (__instance) CppSharp::CppParser::AST::AttributedType(_0); }
+class CppSharp::CppParser::AST::AttributedType& (CppSharp::CppParser::AST::AttributedType::*_32)(const class CppSharp::CppParser::AST::AttributedType&) = &CppSharp::CppParser::AST::AttributedType::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_DecayedType_DecayedType___1__N_CppSharp_N_CppParser_N_AST_S_DecayedType(void* __instance, const CppSharp::CppParser::AST::DecayedType& _0) { ::new (__instance) CppSharp::CppParser::AST::DecayedType(_0); }
+class CppSharp::CppParser::AST::DecayedType& (CppSharp::CppParser::AST::DecayedType::*_33)(const class CppSharp::CppParser::AST::DecayedType&) = &CppSharp::CppParser::AST::DecayedType::operator=;
+struct CppSharp::CppParser::AST::TemplateArgument& (CppSharp::CppParser::AST::TemplateArgument::*_34)(struct CppSharp::CppParser::AST::TemplateArgument&&) = &CppSharp::CppParser::AST::TemplateArgument::operator=;
+class CppSharp::CppParser::AST::TemplateSpecializationType& (CppSharp::CppParser::AST::TemplateSpecializationType::*_35)(const class CppSharp::CppParser::AST::TemplateSpecializationType&) = &CppSharp::CppParser::AST::TemplateSpecializationType::operator=;
+class CppSharp::CppParser::AST::DependentTemplateSpecializationType& (CppSharp::CppParser::AST::DependentTemplateSpecializationType::*_36)(const class CppSharp::CppParser::AST::DependentTemplateSpecializationType&) = &CppSharp::CppParser::AST::DependentTemplateSpecializationType::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_TemplateParameterType_TemplateParameterType___1__N_CppSharp_N_CppParser_N_AST_S_TemplateParameterType(void* __instance, const CppSharp::CppParser::AST::TemplateParameterType& _0) { ::new (__instance) CppSharp::CppParser::AST::TemplateParameterType(_0); }
+class CppSharp::CppParser::AST::TemplateParameterType& (CppSharp::CppParser::AST::TemplateParameterType::*_37)(const class CppSharp::CppParser::AST::TemplateParameterType&) = &CppSharp::CppParser::AST::TemplateParameterType::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_TemplateParameterSubstitutionType_TemplateParameterSubstitutionType___1__N_CppSharp_N_CppParser_N_AST_S_TemplateParameterSubstitutionType(void* __instance, const CppSharp::CppParser::AST::TemplateParameterSubstitutionType& _0) { ::new (__instance) CppSharp::CppParser::AST::TemplateParameterSubstitutionType(_0); }
+class CppSharp::CppParser::AST::TemplateParameterSubstitutionType& (CppSharp::CppParser::AST::TemplateParameterSubstitutionType::*_38)(const class CppSharp::CppParser::AST::TemplateParameterSubstitutionType&) = &CppSharp::CppParser::AST::TemplateParameterSubstitutionType::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_InjectedClassNameType_InjectedClassNameType___1__N_CppSharp_N_CppParser_N_AST_S_InjectedClassNameType(void* __instance, const CppSharp::CppParser::AST::InjectedClassNameType& _0) { ::new (__instance) CppSharp::CppParser::AST::InjectedClassNameType(_0); }
+class CppSharp::CppParser::AST::InjectedClassNameType& (CppSharp::CppParser::AST::InjectedClassNameType::*_39)(const class CppSharp::CppParser::AST::InjectedClassNameType&) = &CppSharp::CppParser::AST::InjectedClassNameType::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_DependentNameType_DependentNameType___1__N_CppSharp_N_CppParser_N_AST_S_DependentNameType(void* __instance, const CppSharp::CppParser::AST::DependentNameType& _0) { ::new (__instance) CppSharp::CppParser::AST::DependentNameType(_0); }
+class CppSharp::CppParser::AST::DependentNameType& (CppSharp::CppParser::AST::DependentNameType::*_40)(const class CppSharp::CppParser::AST::DependentNameType&) = &CppSharp::CppParser::AST::DependentNameType::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_PackExpansionType_PackExpansionType___1__N_CppSharp_N_CppParser_N_AST_S_PackExpansionType(void* __instance, const CppSharp::CppParser::AST::PackExpansionType& _0) { ::new (__instance) CppSharp::CppParser::AST::PackExpansionType(_0); }
+class CppSharp::CppParser::AST::PackExpansionType& (CppSharp::CppParser::AST::PackExpansionType::*_41)(const class CppSharp::CppParser::AST::PackExpansionType&) = &CppSharp::CppParser::AST::PackExpansionType::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_UnaryTransformType_UnaryTransformType___1__N_CppSharp_N_CppParser_N_AST_S_UnaryTransformType(void* __instance, const CppSharp::CppParser::AST::UnaryTransformType& _0) { ::new (__instance) CppSharp::CppParser::AST::UnaryTransformType(_0); }
+class CppSharp::CppParser::AST::UnaryTransformType& (CppSharp::CppParser::AST::UnaryTransformType::*_42)(const class CppSharp::CppParser::AST::UnaryTransformType&) = &CppSharp::CppParser::AST::UnaryTransformType::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_UnresolvedUsingType_UnresolvedUsingType___1__N_CppSharp_N_CppParser_N_AST_S_UnresolvedUsingType(void* __instance, const CppSharp::CppParser::AST::UnresolvedUsingType& _0) { ::new (__instance) CppSharp::CppParser::AST::UnresolvedUsingType(_0); }
+class CppSharp::CppParser::AST::UnresolvedUsingType& (CppSharp::CppParser::AST::UnresolvedUsingType::*_43)(const class CppSharp::CppParser::AST::UnresolvedUsingType&) = &CppSharp::CppParser::AST::UnresolvedUsingType::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_VectorType_VectorType___1__N_CppSharp_N_CppParser_N_AST_S_VectorType(void* __instance, const CppSharp::CppParser::AST::VectorType& _0) { ::new (__instance) CppSharp::CppParser::AST::VectorType(_0); }
+class CppSharp::CppParser::AST::VectorType& (CppSharp::CppParser::AST::VectorType::*_44)(const class CppSharp::CppParser::AST::VectorType&) = &CppSharp::CppParser::AST::VectorType::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_BuiltinType_BuiltinType___1__N_CppSharp_N_CppParser_N_AST_S_BuiltinType(void* __instance, const CppSharp::CppParser::AST::BuiltinType& _0) { ::new (__instance) CppSharp::CppParser::AST::BuiltinType(_0); }
+class CppSharp::CppParser::AST::BuiltinType& (CppSharp::CppParser::AST::BuiltinType::*_45)(const class CppSharp::CppParser::AST::BuiltinType&) = &CppSharp::CppParser::AST::BuiltinType::operator=;
+class CppSharp::CppParser::AST::Declaration& (CppSharp::CppParser::AST::Declaration::*_46)(const class CppSharp::CppParser::AST::Declaration&) = &CppSharp::CppParser::AST::Declaration::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_DeclarationContext_DeclarationContext___1__N_CppSharp_N_CppParser_N_AST_S_DeclarationContext(void* __instance, const CppSharp::CppParser::AST::DeclarationContext& _0) { ::new (__instance) CppSharp::CppParser::AST::DeclarationContext(_0); }
+class CppSharp::CppParser::AST::DeclarationContext& (CppSharp::CppParser::AST::DeclarationContext::*_47)(class CppSharp::CppParser::AST::DeclarationContext&&) = &CppSharp::CppParser::AST::DeclarationContext::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_DeclarationContext__DeclarationContext(CppSharp::CppParser::AST::DeclarationContext*__instance) { __instance->~DeclarationContext(); }
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_TypedefNameDecl_TypedefNameDecl___1__N_CppSharp_N_CppParser_N_AST_S_TypedefNameDecl(void* __instance, const CppSharp::CppParser::AST::TypedefNameDecl& _0) { ::new (__instance) CppSharp::CppParser::AST::TypedefNameDecl(_0); }
+class CppSharp::CppParser::AST::TypedefNameDecl& (CppSharp::CppParser::AST::TypedefNameDecl::*_48)(const class CppSharp::CppParser::AST::TypedefNameDecl&) = &CppSharp::CppParser::AST::TypedefNameDecl::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_TypedefDecl_TypedefDecl___1__N_CppSharp_N_CppParser_N_AST_S_TypedefDecl(void* __instance, const CppSharp::CppParser::AST::TypedefDecl& _0) { ::new (__instance) CppSharp::CppParser::AST::TypedefDecl(_0); }
+class CppSharp::CppParser::AST::TypedefDecl& (CppSharp::CppParser::AST::TypedefDecl::*_49)(const class CppSharp::CppParser::AST::TypedefDecl&) = &CppSharp::CppParser::AST::TypedefDecl::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_TypeAlias_TypeAlias___1__N_CppSharp_N_CppParser_N_AST_S_TypeAlias(void* __instance, const CppSharp::CppParser::AST::TypeAlias& _0) { ::new (__instance) CppSharp::CppParser::AST::TypeAlias(_0); }
+class CppSharp::CppParser::AST::TypeAlias& (CppSharp::CppParser::AST::TypeAlias::*_50)(const class CppSharp::CppParser::AST::TypeAlias&) = &CppSharp::CppParser::AST::TypeAlias::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_Friend_Friend___1__N_CppSharp_N_CppParser_N_AST_S_Friend(void* __instance, const CppSharp::CppParser::AST::Friend& _0) { ::new (__instance) CppSharp::CppParser::AST::Friend(_0); }
+class CppSharp::CppParser::AST::Friend& (CppSharp::CppParser::AST::Friend::*_51)(const class CppSharp::CppParser::AST::Friend&) = &CppSharp::CppParser::AST::Friend::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_StatementObsolete_StatementObsolete___1__N_CppSharp_N_CppParser_N_AST_S_StatementObsolete(void* __instance, const CppSharp::CppParser::AST::StatementObsolete& _0) { ::new (__instance) CppSharp::CppParser::AST::StatementObsolete(_0); }
+class CppSharp::CppParser::AST::StatementObsolete& (CppSharp::CppParser::AST::StatementObsolete::*_52)(class CppSharp::CppParser::AST::StatementObsolete&&) = &CppSharp::CppParser::AST::StatementObsolete::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_StatementObsolete__StatementObsolete(CppSharp::CppParser::AST::StatementObsolete*__instance) { __instance->~StatementObsolete(); }
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_ExpressionObsolete_ExpressionObsolete___1__N_CppSharp_N_CppParser_N_AST_S_ExpressionObsolete(void* __instance, const CppSharp::CppParser::AST::ExpressionObsolete& _0) { ::new (__instance) CppSharp::CppParser::AST::ExpressionObsolete(_0); }
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_ExpressionObsolete__ExpressionObsolete(CppSharp::CppParser::AST::ExpressionObsolete*__instance) { __instance->~ExpressionObsolete(); }
+class CppSharp::CppParser::AST::ExpressionObsolete& (CppSharp::CppParser::AST::ExpressionObsolete::*_53)(class CppSharp::CppParser::AST::ExpressionObsolete&&) = &CppSharp::CppParser::AST::ExpressionObsolete::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_BinaryOperatorObsolete_BinaryOperatorObsolete___1__N_CppSharp_N_CppParser_N_AST_S_BinaryOperatorObsolete(void* __instance, const CppSharp::CppParser::AST::BinaryOperatorObsolete& _0) { ::new (__instance) CppSharp::CppParser::AST::BinaryOperatorObsolete(_0); }
+class CppSharp::CppParser::AST::BinaryOperatorObsolete& (CppSharp::CppParser::AST::BinaryOperatorObsolete::*_54)(const class CppSharp::CppParser::AST::BinaryOperatorObsolete&) = &CppSharp::CppParser::AST::BinaryOperatorObsolete::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CallExprObsolete_CallExprObsolete___1__N_CppSharp_N_CppParser_N_AST_S_CallExprObsolete(void* __instance, const CppSharp::CppParser::AST::CallExprObsolete& _0) { ::new (__instance) CppSharp::CppParser::AST::CallExprObsolete(_0); }
+class CppSharp::CppParser::AST::CallExprObsolete& (CppSharp::CppParser::AST::CallExprObsolete::*_55)(const class CppSharp::CppParser::AST::CallExprObsolete&) = &CppSharp::CppParser::AST::CallExprObsolete::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CXXConstructExprObsolete_CXXConstructExprObsolete___1__N_CppSharp_N_CppParser_N_AST_S_CXXConstructExprObsolete(void* __instance, const CppSharp::CppParser::AST::CXXConstructExprObsolete& _0) { ::new (__instance) CppSharp::CppParser::AST::CXXConstructExprObsolete(_0); }
+class CppSharp::CppParser::AST::CXXConstructExprObsolete& (CppSharp::CppParser::AST::CXXConstructExprObsolete::*_56)(const class CppSharp::CppParser::AST::CXXConstructExprObsolete&) = &CppSharp::CppParser::AST::CXXConstructExprObsolete::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_Parameter_Parameter___1__N_CppSharp_N_CppParser_N_AST_S_Parameter(void* __instance, const CppSharp::CppParser::AST::Parameter& _0) { ::new (__instance) CppSharp::CppParser::AST::Parameter(_0); }
+class CppSharp::CppParser::AST::Parameter& (CppSharp::CppParser::AST::Parameter::*_57)(const class CppSharp::CppParser::AST::Parameter&) = &CppSharp::CppParser::AST::Parameter::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_Function_Function___1__N_CppSharp_N_CppParser_N_AST_S_Function(void* __instance, const CppSharp::CppParser::AST::Function& _0) { ::new (__instance) CppSharp::CppParser::AST::Function(_0); }
+class CppSharp::CppParser::AST::Function& (CppSharp::CppParser::AST::Function::*_58)(const class CppSharp::CppParser::AST::Function&) = &CppSharp::CppParser::AST::Function::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_Method_Method___1__N_CppSharp_N_CppParser_N_AST_S_Method(void* __instance, const CppSharp::CppParser::AST::Method& _0) { ::new (__instance) CppSharp::CppParser::AST::Method(_0); }
+class CppSharp::CppParser::AST::Method& (CppSharp::CppParser::AST::Method::*_59)(const class CppSharp::CppParser::AST::Method&) = &CppSharp::CppParser::AST::Method::operator=;
+class CppSharp::CppParser::AST::Enumeration::Item& (CppSharp::CppParser::AST::Enumeration::Item::*_60)(const class CppSharp::CppParser::AST::Enumeration::Item&) = &CppSharp::CppParser::AST::Enumeration::Item::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_Enumeration_Enumeration___1__N_CppSharp_N_CppParser_N_AST_S_Enumeration(void* __instance, const CppSharp::CppParser::AST::Enumeration& _0) { ::new (__instance) CppSharp::CppParser::AST::Enumeration(_0); }
+class CppSharp::CppParser::AST::Enumeration& (CppSharp::CppParser::AST::Enumeration::*_61)(const class CppSharp::CppParser::AST::Enumeration&) = &CppSharp::CppParser::AST::Enumeration::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_Variable_Variable___1__N_CppSharp_N_CppParser_N_AST_S_Variable(void* __instance, const CppSharp::CppParser::AST::Variable& _0) { ::new (__instance) CppSharp::CppParser::AST::Variable(_0); }
+class CppSharp::CppParser::AST::Variable& (CppSharp::CppParser::AST::Variable::*_62)(const class CppSharp::CppParser::AST::Variable&) = &CppSharp::CppParser::AST::Variable::operator=;
+struct CppSharp::CppParser::AST::BaseClassSpecifier& (CppSharp::CppParser::AST::BaseClassSpecifier::*_63)(struct CppSharp::CppParser::AST::BaseClassSpecifier&&) = &CppSharp::CppParser::AST::BaseClassSpecifier::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_Field_Field___1__N_CppSharp_N_CppParser_N_AST_S_Field(void* __instance, const CppSharp::CppParser::AST::Field& _0) { ::new (__instance) CppSharp::CppParser::AST::Field(_0); }
+class CppSharp::CppParser::AST::Field& (CppSharp::CppParser::AST::Field::*_64)(const class CppSharp::CppParser::AST::Field&) = &CppSharp::CppParser::AST::Field::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_AccessSpecifierDecl_AccessSpecifierDecl___1__N_CppSharp_N_CppParser_N_AST_S_AccessSpecifierDecl(void* __instance, const CppSharp::CppParser::AST::AccessSpecifierDecl& _0) { ::new (__instance) CppSharp::CppParser::AST::AccessSpecifierDecl(_0); }
+class CppSharp::CppParser::AST::AccessSpecifierDecl& (CppSharp::CppParser::AST::AccessSpecifierDecl::*_65)(const class CppSharp::CppParser::AST::AccessSpecifierDecl&) = &CppSharp::CppParser::AST::AccessSpecifierDecl::operator=;
+struct CppSharp::CppParser::AST::VTableComponent& (CppSharp::CppParser::AST::VTableComponent::*_66)(struct CppSharp::CppParser::AST::VTableComponent&&) = &CppSharp::CppParser::AST::VTableComponent::operator=;
+struct CppSharp::CppParser::AST::VTableLayout& (CppSharp::CppParser::AST::VTableLayout::*_67)(const struct CppSharp::CppParser::AST::VTableLayout&) = &CppSharp::CppParser::AST::VTableLayout::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_VFTableInfo__VFTableInfo(CppSharp::CppParser::AST::VFTableInfo*__instance) { __instance->~VFTableInfo(); }
+struct CppSharp::CppParser::AST::VFTableInfo& (CppSharp::CppParser::AST::VFTableInfo::*_68)(const struct CppSharp::CppParser::AST::VFTableInfo&) = &CppSharp::CppParser::AST::VFTableInfo::operator=;
+class CppSharp::CppParser::AST::LayoutField& (CppSharp::CppParser::AST::LayoutField::*_69)(const class CppSharp::CppParser::AST::LayoutField&) = &CppSharp::CppParser::AST::LayoutField::operator=;
+class CppSharp::CppParser::AST::LayoutBase& (CppSharp::CppParser::AST::LayoutBase::*_70)(const class CppSharp::CppParser::AST::LayoutBase&) = &CppSharp::CppParser::AST::LayoutBase::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_ClassLayout_ClassLayout___1__N_CppSharp_N_CppParser_N_AST_S_ClassLayout(void* __instance, const CppSharp::CppParser::AST::ClassLayout& _0) { ::new (__instance) CppSharp::CppParser::AST::ClassLayout(_0); }
+struct CppSharp::CppParser::AST::ClassLayout& (CppSharp::CppParser::AST::ClassLayout::*_71)(struct CppSharp::CppParser::AST::ClassLayout&&) = &CppSharp::CppParser::AST::ClassLayout::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_ClassLayout__ClassLayout(CppSharp::CppParser::AST::ClassLayout*__instance) { __instance->~ClassLayout(); }
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_Class_Class___1__N_CppSharp_N_CppParser_N_AST_S_Class(void* __instance, const CppSharp::CppParser::AST::Class& _0) { ::new (__instance) CppSharp::CppParser::AST::Class(_0); }
+class CppSharp::CppParser::AST::Class& (CppSharp::CppParser::AST::Class::*_72)(const class CppSharp::CppParser::AST::Class&) = &CppSharp::CppParser::AST::Class::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_Template_Template___1__N_CppSharp_N_CppParser_N_AST_S_Template(void* __instance, const CppSharp::CppParser::AST::Template& _0) { ::new (__instance) CppSharp::CppParser::AST::Template(_0); }
+class CppSharp::CppParser::AST::Template& (CppSharp::CppParser::AST::Template::*_73)(class CppSharp::CppParser::AST::Template&&) = &CppSharp::CppParser::AST::Template::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_Template__Template(CppSharp::CppParser::AST::Template*__instance) { __instance->~Template(); }
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_TypeAliasTemplate_TypeAliasTemplate___1__N_CppSharp_N_CppParser_N_AST_S_TypeAliasTemplate(void* __instance, const CppSharp::CppParser::AST::TypeAliasTemplate& _0) { ::new (__instance) CppSharp::CppParser::AST::TypeAliasTemplate(_0); }
+class CppSharp::CppParser::AST::TypeAliasTemplate& (CppSharp::CppParser::AST::TypeAliasTemplate::*_74)(const class CppSharp::CppParser::AST::TypeAliasTemplate&) = &CppSharp::CppParser::AST::TypeAliasTemplate::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_TemplateParameter_TemplateParameter___1__N_CppSharp_N_CppParser_N_AST_S_TemplateParameter(void* __instance, const CppSharp::CppParser::AST::TemplateParameter& _0) { ::new (__instance) CppSharp::CppParser::AST::TemplateParameter(_0); }
+class CppSharp::CppParser::AST::TemplateParameter& (CppSharp::CppParser::AST::TemplateParameter::*_75)(const class CppSharp::CppParser::AST::TemplateParameter&) = &CppSharp::CppParser::AST::TemplateParameter::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_TemplateTemplateParameter_TemplateTemplateParameter___1__N_CppSharp_N_CppParser_N_AST_S_TemplateTemplateParameter(void* __instance, const CppSharp::CppParser::AST::TemplateTemplateParameter& _0) { ::new (__instance) CppSharp::CppParser::AST::TemplateTemplateParameter(_0); }
+class CppSharp::CppParser::AST::TemplateTemplateParameter& (CppSharp::CppParser::AST::TemplateTemplateParameter::*_76)(const class CppSharp::CppParser::AST::TemplateTemplateParameter&) = &CppSharp::CppParser::AST::TemplateTemplateParameter::operator=;
+class CppSharp::CppParser::AST::TypeTemplateParameter& (CppSharp::CppParser::AST::TypeTemplateParameter::*_77)(const class CppSharp::CppParser::AST::TypeTemplateParameter&) = &CppSharp::CppParser::AST::TypeTemplateParameter::operator=;
+class CppSharp::CppParser::AST::NonTypeTemplateParameter& (CppSharp::CppParser::AST::NonTypeTemplateParameter::*_78)(const class CppSharp::CppParser::AST::NonTypeTemplateParameter&) = &CppSharp::CppParser::AST::NonTypeTemplateParameter::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_ClassTemplate_ClassTemplate___1__N_CppSharp_N_CppParser_N_AST_S_ClassTemplate(void* __instance, const CppSharp::CppParser::AST::ClassTemplate& _0) { ::new (__instance) CppSharp::CppParser::AST::ClassTemplate(_0); }
+class CppSharp::CppParser::AST::ClassTemplate& (CppSharp::CppParser::AST::ClassTemplate::*_79)(const class CppSharp::CppParser::AST::ClassTemplate&) = &CppSharp::CppParser::AST::ClassTemplate::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_ClassTemplateSpecialization_ClassTemplateSpecialization___1__N_CppSharp_N_CppParser_N_AST_S_ClassTemplateSpecialization(void* __instance, const CppSharp::CppParser::AST::ClassTemplateSpecialization& _0) { ::new (__instance) CppSharp::CppParser::AST::ClassTemplateSpecialization(_0); }
+class CppSharp::CppParser::AST::ClassTemplateSpecialization& (CppSharp::CppParser::AST::ClassTemplateSpecialization::*_80)(const class CppSharp::CppParser::AST::ClassTemplateSpecialization&) = &CppSharp::CppParser::AST::ClassTemplateSpecialization::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_ClassTemplatePartialSpecialization_ClassTemplatePartialSpecialization___1__N_CppSharp_N_CppParser_N_AST_S_ClassTemplatePartialSpecialization(void* __instance, const CppSharp::CppParser::AST::ClassTemplatePartialSpecialization& _0) { ::new (__instance) CppSharp::CppParser::AST::ClassTemplatePartialSpecialization(_0); }
+class CppSharp::CppParser::AST::ClassTemplatePartialSpecialization& (CppSharp::CppParser::AST::ClassTemplatePartialSpecialization::*_81)(const class CppSharp::CppParser::AST::ClassTemplatePartialSpecialization&) = &CppSharp::CppParser::AST::ClassTemplatePartialSpecialization::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_FunctionTemplate_FunctionTemplate___1__N_CppSharp_N_CppParser_N_AST_S_FunctionTemplate(void* __instance, const CppSharp::CppParser::AST::FunctionTemplate& _0) { ::new (__instance) CppSharp::CppParser::AST::FunctionTemplate(_0); }
+class CppSharp::CppParser::AST::FunctionTemplate& (CppSharp::CppParser::AST::FunctionTemplate::*_82)(const class CppSharp::CppParser::AST::FunctionTemplate&) = &CppSharp::CppParser::AST::FunctionTemplate::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_FunctionTemplateSpecialization_FunctionTemplateSpecialization___1__N_CppSharp_N_CppParser_N_AST_S_FunctionTemplateSpecialization(void* __instance, const CppSharp::CppParser::AST::FunctionTemplateSpecialization& _0) { ::new (__instance) CppSharp::CppParser::AST::FunctionTemplateSpecialization(_0); }
+class CppSharp::CppParser::AST::FunctionTemplateSpecialization& (CppSharp::CppParser::AST::FunctionTemplateSpecialization::*_83)(const class CppSharp::CppParser::AST::FunctionTemplateSpecialization&) = &CppSharp::CppParser::AST::FunctionTemplateSpecialization::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_VarTemplate_VarTemplate___1__N_CppSharp_N_CppParser_N_AST_S_VarTemplate(void* __instance, const CppSharp::CppParser::AST::VarTemplate& _0) { ::new (__instance) CppSharp::CppParser::AST::VarTemplate(_0); }
+class CppSharp::CppParser::AST::VarTemplate& (CppSharp::CppParser::AST::VarTemplate::*_84)(const class CppSharp::CppParser::AST::VarTemplate&) = &CppSharp::CppParser::AST::VarTemplate::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_VarTemplateSpecialization_VarTemplateSpecialization___1__N_CppSharp_N_CppParser_N_AST_S_VarTemplateSpecialization(void* __instance, const CppSharp::CppParser::AST::VarTemplateSpecialization& _0) { ::new (__instance) CppSharp::CppParser::AST::VarTemplateSpecialization(_0); }
+class CppSharp::CppParser::AST::VarTemplateSpecialization& (CppSharp::CppParser::AST::VarTemplateSpecialization::*_85)(const class CppSharp::CppParser::AST::VarTemplateSpecialization&) = &CppSharp::CppParser::AST::VarTemplateSpecialization::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_VarTemplatePartialSpecialization_VarTemplatePartialSpecialization___1__N_CppSharp_N_CppParser_N_AST_S_VarTemplatePartialSpecialization(void* __instance, const CppSharp::CppParser::AST::VarTemplatePartialSpecialization& _0) { ::new (__instance) CppSharp::CppParser::AST::VarTemplatePartialSpecialization(_0); }
+class CppSharp::CppParser::AST::VarTemplatePartialSpecialization& (CppSharp::CppParser::AST::VarTemplatePartialSpecialization::*_86)(const class CppSharp::CppParser::AST::VarTemplatePartialSpecialization&) = &CppSharp::CppParser::AST::VarTemplatePartialSpecialization::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_UnresolvedUsingTypename_UnresolvedUsingTypename___1__N_CppSharp_N_CppParser_N_AST_S_UnresolvedUsingTypename(void* __instance, const CppSharp::CppParser::AST::UnresolvedUsingTypename& _0) { ::new (__instance) CppSharp::CppParser::AST::UnresolvedUsingTypename(_0); }
+class CppSharp::CppParser::AST::UnresolvedUsingTypename& (CppSharp::CppParser::AST::UnresolvedUsingTypename::*_87)(const class CppSharp::CppParser::AST::UnresolvedUsingTypename&) = &CppSharp::CppParser::AST::UnresolvedUsingTypename::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_Namespace_Namespace___1__N_CppSharp_N_CppParser_N_AST_S_Namespace(void* __instance, const CppSharp::CppParser::AST::Namespace& _0) { ::new (__instance) CppSharp::CppParser::AST::Namespace(_0); }
+class CppSharp::CppParser::AST::Namespace& (CppSharp::CppParser::AST::Namespace::*_88)(const class CppSharp::CppParser::AST::Namespace&) = &CppSharp::CppParser::AST::Namespace::operator=;
+class CppSharp::CppParser::AST::PreprocessedEntity& (CppSharp::CppParser::AST::PreprocessedEntity::*_89)(class CppSharp::CppParser::AST::PreprocessedEntity&&) = &CppSharp::CppParser::AST::PreprocessedEntity::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_MacroDefinition_MacroDefinition___1__N_CppSharp_N_CppParser_N_AST_S_MacroDefinition(void* __instance, const CppSharp::CppParser::AST::MacroDefinition& _0) { ::new (__instance) CppSharp::CppParser::AST::MacroDefinition(_0); }
+class CppSharp::CppParser::AST::MacroDefinition& (CppSharp::CppParser::AST::MacroDefinition::*_90)(const class CppSharp::CppParser::AST::MacroDefinition&) = &CppSharp::CppParser::AST::MacroDefinition::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_MacroExpansion_MacroExpansion___1__N_CppSharp_N_CppParser_N_AST_S_MacroExpansion(void* __instance, const CppSharp::CppParser::AST::MacroExpansion& _0) { ::new (__instance) CppSharp::CppParser::AST::MacroExpansion(_0); }
+class CppSharp::CppParser::AST::MacroExpansion& (CppSharp::CppParser::AST::MacroExpansion::*_91)(const class CppSharp::CppParser::AST::MacroExpansion&) = &CppSharp::CppParser::AST::MacroExpansion::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_TranslationUnit_TranslationUnit___1__N_CppSharp_N_CppParser_N_AST_S_TranslationUnit(void* __instance, const CppSharp::CppParser::AST::TranslationUnit& _0) { ::new (__instance) CppSharp::CppParser::AST::TranslationUnit(_0); }
+class CppSharp::CppParser::AST::TranslationUnit& (CppSharp::CppParser::AST::TranslationUnit::*_92)(const class CppSharp::CppParser::AST::TranslationUnit&) = &CppSharp::CppParser::AST::TranslationUnit::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_ASTContext_ASTContext___1__N_CppSharp_N_CppParser_N_AST_S_ASTContext(void* __instance, const CppSharp::CppParser::AST::ASTContext& _0) { ::new (__instance) CppSharp::CppParser::AST::ASTContext(_0); }
+class CppSharp::CppParser::AST::ASTContext& (CppSharp::CppParser::AST::ASTContext::*_93)(const class CppSharp::CppParser::AST::ASTContext&) = &CppSharp::CppParser::AST::ASTContext::operator=;
+class CppSharp::CppParser::AST::Stmt& (CppSharp::CppParser::AST::Stmt::*_94)(class CppSharp::CppParser::AST::Stmt&&) = &CppSharp::CppParser::AST::Stmt::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_DeclStmt_DeclStmt___1__N_CppSharp_N_CppParser_N_AST_S_DeclStmt(void* __instance, const CppSharp::CppParser::AST::DeclStmt& _0) { ::new (__instance) CppSharp::CppParser::AST::DeclStmt(_0); }
+class CppSharp::CppParser::AST::DeclStmt& (CppSharp::CppParser::AST::DeclStmt::*_95)(class CppSharp::CppParser::AST::DeclStmt&&) = &CppSharp::CppParser::AST::DeclStmt::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_DeclStmt__DeclStmt(CppSharp::CppParser::AST::DeclStmt*__instance) { __instance->~DeclStmt(); }
+class CppSharp::CppParser::AST::NullStmt& (CppSharp::CppParser::AST::NullStmt::*_96)(class CppSharp::CppParser::AST::NullStmt&&) = &CppSharp::CppParser::AST::NullStmt::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CompoundStmt_CompoundStmt___1__N_CppSharp_N_CppParser_N_AST_S_CompoundStmt(void* __instance, const CppSharp::CppParser::AST::CompoundStmt& _0) { ::new (__instance) CppSharp::CppParser::AST::CompoundStmt(_0); }
+class CppSharp::CppParser::AST::CompoundStmt& (CppSharp::CppParser::AST::CompoundStmt::*_97)(class CppSharp::CppParser::AST::CompoundStmt&&) = &CppSharp::CppParser::AST::CompoundStmt::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CompoundStmt__CompoundStmt(CppSharp::CppParser::AST::CompoundStmt*__instance) { __instance->~CompoundStmt(); }
+class CppSharp::CppParser::AST::SwitchCase& (CppSharp::CppParser::AST::SwitchCase::*_98)(class CppSharp::CppParser::AST::SwitchCase&&) = &CppSharp::CppParser::AST::SwitchCase::operator=;
+class CppSharp::CppParser::AST::CaseStmt& (CppSharp::CppParser::AST::CaseStmt::*_99)(class CppSharp::CppParser::AST::CaseStmt&&) = &CppSharp::CppParser::AST::CaseStmt::operator=;
+class CppSharp::CppParser::AST::DefaultStmt& (CppSharp::CppParser::AST::DefaultStmt::*_100)(class CppSharp::CppParser::AST::DefaultStmt&&) = &CppSharp::CppParser::AST::DefaultStmt::operator=;
+class CppSharp::CppParser::AST::LabelStmt& (CppSharp::CppParser::AST::LabelStmt::*_101)(class CppSharp::CppParser::AST::LabelStmt&&) = &CppSharp::CppParser::AST::LabelStmt::operator=;
+class CppSharp::CppParser::AST::AttributedStmt& (CppSharp::CppParser::AST::AttributedStmt::*_102)(class CppSharp::CppParser::AST::AttributedStmt&&) = &CppSharp::CppParser::AST::AttributedStmt::operator=;
+class CppSharp::CppParser::AST::IfStmt& (CppSharp::CppParser::AST::IfStmt::*_103)(class CppSharp::CppParser::AST::IfStmt&&) = &CppSharp::CppParser::AST::IfStmt::operator=;
+class CppSharp::CppParser::AST::SwitchStmt& (CppSharp::CppParser::AST::SwitchStmt::*_104)(class CppSharp::CppParser::AST::SwitchStmt&&) = &CppSharp::CppParser::AST::SwitchStmt::operator=;
+class CppSharp::CppParser::AST::WhileStmt& (CppSharp::CppParser::AST::WhileStmt::*_105)(class CppSharp::CppParser::AST::WhileStmt&&) = &CppSharp::CppParser::AST::WhileStmt::operator=;
+class CppSharp::CppParser::AST::DoStmt& (CppSharp::CppParser::AST::DoStmt::*_106)(class CppSharp::CppParser::AST::DoStmt&&) = &CppSharp::CppParser::AST::DoStmt::operator=;
+class CppSharp::CppParser::AST::ForStmt& (CppSharp::CppParser::AST::ForStmt::*_107)(class CppSharp::CppParser::AST::ForStmt&&) = &CppSharp::CppParser::AST::ForStmt::operator=;
+class CppSharp::CppParser::AST::GotoStmt& (CppSharp::CppParser::AST::GotoStmt::*_108)(class CppSharp::CppParser::AST::GotoStmt&&) = &CppSharp::CppParser::AST::GotoStmt::operator=;
+class CppSharp::CppParser::AST::IndirectGotoStmt& (CppSharp::CppParser::AST::IndirectGotoStmt::*_109)(class CppSharp::CppParser::AST::IndirectGotoStmt&&) = &CppSharp::CppParser::AST::IndirectGotoStmt::operator=;
+class CppSharp::CppParser::AST::ContinueStmt& (CppSharp::CppParser::AST::ContinueStmt::*_110)(class CppSharp::CppParser::AST::ContinueStmt&&) = &CppSharp::CppParser::AST::ContinueStmt::operator=;
+class CppSharp::CppParser::AST::BreakStmt& (CppSharp::CppParser::AST::BreakStmt::*_111)(class CppSharp::CppParser::AST::BreakStmt&&) = &CppSharp::CppParser::AST::BreakStmt::operator=;
+class CppSharp::CppParser::AST::ReturnStmt& (CppSharp::CppParser::AST::ReturnStmt::*_112)(class CppSharp::CppParser::AST::ReturnStmt&&) = &CppSharp::CppParser::AST::ReturnStmt::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_AsmStmt_AsmStmt___1__N_CppSharp_N_CppParser_N_AST_S_AsmStmt(void* __instance, const CppSharp::CppParser::AST::AsmStmt& _0) { ::new (__instance) CppSharp::CppParser::AST::AsmStmt(_0); }
+class CppSharp::CppParser::AST::AsmStmt& (CppSharp::CppParser::AST::AsmStmt::*_113)(class CppSharp::CppParser::AST::AsmStmt&&) = &CppSharp::CppParser::AST::AsmStmt::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_AsmStmt__AsmStmt(CppSharp::CppParser::AST::AsmStmt*__instance) { __instance->~AsmStmt(); }
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_GCCAsmStmt_S_AsmStringPiece_AsmStringPiece___1__N_CppSharp_N_CppParser_N_AST_S_GCCAsmStmt_S_AsmStringPiece(void* __instance, const CppSharp::CppParser::AST::GCCAsmStmt::AsmStringPiece& _0) { ::new (__instance) CppSharp::CppParser::AST::GCCAsmStmt::AsmStringPiece(_0); }
+class CppSharp::CppParser::AST::GCCAsmStmt::AsmStringPiece& (CppSharp::CppParser::AST::GCCAsmStmt::AsmStringPiece::*_114)(class CppSharp::CppParser::AST::GCCAsmStmt::AsmStringPiece&&) = &CppSharp::CppParser::AST::GCCAsmStmt::AsmStringPiece::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_GCCAsmStmt_S_AsmStringPiece__AsmStringPiece(CppSharp::CppParser::AST::GCCAsmStmt::AsmStringPiece*__instance) { __instance->~AsmStringPiece(); }
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_GCCAsmStmt_GCCAsmStmt___1__N_CppSharp_N_CppParser_N_AST_S_GCCAsmStmt(void* __instance, const CppSharp::CppParser::AST::GCCAsmStmt& _0) { ::new (__instance) CppSharp::CppParser::AST::GCCAsmStmt(_0); }
+class CppSharp::CppParser::AST::GCCAsmStmt& (CppSharp::CppParser::AST::GCCAsmStmt::*_115)(class CppSharp::CppParser::AST::GCCAsmStmt&&) = &CppSharp::CppParser::AST::GCCAsmStmt::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_GCCAsmStmt__GCCAsmStmt(CppSharp::CppParser::AST::GCCAsmStmt*__instance) { __instance->~GCCAsmStmt(); }
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_MSAsmStmt_MSAsmStmt___1__N_CppSharp_N_CppParser_N_AST_S_MSAsmStmt(void* __instance, const CppSharp::CppParser::AST::MSAsmStmt& _0) { ::new (__instance) CppSharp::CppParser::AST::MSAsmStmt(_0); }
+class CppSharp::CppParser::AST::MSAsmStmt& (CppSharp::CppParser::AST::MSAsmStmt::*_116)(class CppSharp::CppParser::AST::MSAsmStmt&&) = &CppSharp::CppParser::AST::MSAsmStmt::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_MSAsmStmt__MSAsmStmt(CppSharp::CppParser::AST::MSAsmStmt*__instance) { __instance->~MSAsmStmt(); }
+class CppSharp::CppParser::AST::SEHExceptStmt& (CppSharp::CppParser::AST::SEHExceptStmt::*_117)(class CppSharp::CppParser::AST::SEHExceptStmt&&) = &CppSharp::CppParser::AST::SEHExceptStmt::operator=;
+class CppSharp::CppParser::AST::SEHFinallyStmt& (CppSharp::CppParser::AST::SEHFinallyStmt::*_118)(class CppSharp::CppParser::AST::SEHFinallyStmt&&) = &CppSharp::CppParser::AST::SEHFinallyStmt::operator=;
+class CppSharp::CppParser::AST::SEHTryStmt& (CppSharp::CppParser::AST::SEHTryStmt::*_119)(class CppSharp::CppParser::AST::SEHTryStmt&&) = &CppSharp::CppParser::AST::SEHTryStmt::operator=;
+class CppSharp::CppParser::AST::SEHLeaveStmt& (CppSharp::CppParser::AST::SEHLeaveStmt::*_120)(class CppSharp::CppParser::AST::SEHLeaveStmt&&) = &CppSharp::CppParser::AST::SEHLeaveStmt::operator=;
+class CppSharp::CppParser::AST::CapturedStmt::Capture& (CppSharp::CppParser::AST::CapturedStmt::Capture::*_121)(class CppSharp::CppParser::AST::CapturedStmt::Capture&&) = &CppSharp::CppParser::AST::CapturedStmt::Capture::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CapturedStmt_CapturedStmt___1__N_CppSharp_N_CppParser_N_AST_S_CapturedStmt(void* __instance, const CppSharp::CppParser::AST::CapturedStmt& _0) { ::new (__instance) CppSharp::CppParser::AST::CapturedStmt(_0); }
+class CppSharp::CppParser::AST::CapturedStmt& (CppSharp::CppParser::AST::CapturedStmt::*_122)(class CppSharp::CppParser::AST::CapturedStmt&&) = &CppSharp::CppParser::AST::CapturedStmt::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CapturedStmt__CapturedStmt(CppSharp::CppParser::AST::CapturedStmt*__instance) { __instance->~CapturedStmt(); }
+class CppSharp::CppParser::AST::CXXCatchStmt& (CppSharp::CppParser::AST::CXXCatchStmt::*_123)(class CppSharp::CppParser::AST::CXXCatchStmt&&) = &CppSharp::CppParser::AST::CXXCatchStmt::operator=;
+class CppSharp::CppParser::AST::CXXTryStmt& (CppSharp::CppParser::AST::CXXTryStmt::*_124)(class CppSharp::CppParser::AST::CXXTryStmt&&) = &CppSharp::CppParser::AST::CXXTryStmt::operator=;
+class CppSharp::CppParser::AST::CXXForRangeStmt& (CppSharp::CppParser::AST::CXXForRangeStmt::*_125)(class CppSharp::CppParser::AST::CXXForRangeStmt&&) = &CppSharp::CppParser::AST::CXXForRangeStmt::operator=;
+class CppSharp::CppParser::AST::MSDependentExistsStmt& (CppSharp::CppParser::AST::MSDependentExistsStmt::*_126)(class CppSharp::CppParser::AST::MSDependentExistsStmt&&) = &CppSharp::CppParser::AST::MSDependentExistsStmt::operator=;
+class CppSharp::CppParser::AST::CoroutineBodyStmt::CtorArgs& (CppSharp::CppParser::AST::CoroutineBodyStmt::CtorArgs::*_127)(class CppSharp::CppParser::AST::CoroutineBodyStmt::CtorArgs&&) = &CppSharp::CppParser::AST::CoroutineBodyStmt::CtorArgs::operator=;
+class CppSharp::CppParser::AST::CoroutineBodyStmt& (CppSharp::CppParser::AST::CoroutineBodyStmt::*_128)(class CppSharp::CppParser::AST::CoroutineBodyStmt&&) = &CppSharp::CppParser::AST::CoroutineBodyStmt::operator=;
+class CppSharp::CppParser::AST::CoreturnStmt& (CppSharp::CppParser::AST::CoreturnStmt::*_129)(class CppSharp::CppParser::AST::CoreturnStmt&&) = &CppSharp::CppParser::AST::CoreturnStmt::operator=;
+class CppSharp::CppParser::AST::Expr::Classification& (CppSharp::CppParser::AST::Expr::Classification::*_130)(class CppSharp::CppParser::AST::Expr::Classification&&) = &CppSharp::CppParser::AST::Expr::Classification::operator=;
+class CppSharp::CppParser::AST::Expr& (CppSharp::CppParser::AST::Expr::*_131)(class CppSharp::CppParser::AST::Expr&&) = &CppSharp::CppParser::AST::Expr::operator=;
+class CppSharp::CppParser::AST::FullExpr& (CppSharp::CppParser::AST::FullExpr::*_132)(class CppSharp::CppParser::AST::FullExpr&&) = &CppSharp::CppParser::AST::FullExpr::operator=;
+class CppSharp::CppParser::AST::ConstantExpr& (CppSharp::CppParser::AST::ConstantExpr::*_133)(class CppSharp::CppParser::AST::ConstantExpr&&) = &CppSharp::CppParser::AST::ConstantExpr::operator=;
+class CppSharp::CppParser::AST::OpaqueValueExpr& (CppSharp::CppParser::AST::OpaqueValueExpr::*_134)(class CppSharp::CppParser::AST::OpaqueValueExpr&&) = &CppSharp::CppParser::AST::OpaqueValueExpr::operator=;
+class CppSharp::CppParser::AST::DeclRefExpr& (CppSharp::CppParser::AST::DeclRefExpr::*_135)(class CppSharp::CppParser::AST::DeclRefExpr&&) = &CppSharp::CppParser::AST::DeclRefExpr::operator=;
+class CppSharp::CppParser::AST::IntegerLiteral& (CppSharp::CppParser::AST::IntegerLiteral::*_136)(class CppSharp::CppParser::AST::IntegerLiteral&&) = &CppSharp::CppParser::AST::IntegerLiteral::operator=;
+class CppSharp::CppParser::AST::FixedPointLiteral& (CppSharp::CppParser::AST::FixedPointLiteral::*_137)(class CppSharp::CppParser::AST::FixedPointLiteral&&) = &CppSharp::CppParser::AST::FixedPointLiteral::operator=;
+class CppSharp::CppParser::AST::CharacterLiteral& (CppSharp::CppParser::AST::CharacterLiteral::*_138)(class CppSharp::CppParser::AST::CharacterLiteral&&) = &CppSharp::CppParser::AST::CharacterLiteral::operator=;
+class CppSharp::CppParser::AST::FloatingLiteral& (CppSharp::CppParser::AST::FloatingLiteral::*_139)(class CppSharp::CppParser::AST::FloatingLiteral&&) = &CppSharp::CppParser::AST::FloatingLiteral::operator=;
+class CppSharp::CppParser::AST::ImaginaryLiteral& (CppSharp::CppParser::AST::ImaginaryLiteral::*_140)(class CppSharp::CppParser::AST::ImaginaryLiteral&&) = &CppSharp::CppParser::AST::ImaginaryLiteral::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_StringLiteral_StringLiteral___1__N_CppSharp_N_CppParser_N_AST_S_StringLiteral(void* __instance, const CppSharp::CppParser::AST::StringLiteral& _0) { ::new (__instance) CppSharp::CppParser::AST::StringLiteral(_0); }
+class CppSharp::CppParser::AST::StringLiteral& (CppSharp::CppParser::AST::StringLiteral::*_141)(class CppSharp::CppParser::AST::StringLiteral&&) = &CppSharp::CppParser::AST::StringLiteral::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_StringLiteral__StringLiteral(CppSharp::CppParser::AST::StringLiteral*__instance) { __instance->~StringLiteral(); }
+class CppSharp::CppParser::AST::PredefinedExpr& (CppSharp::CppParser::AST::PredefinedExpr::*_142)(class CppSharp::CppParser::AST::PredefinedExpr&&) = &CppSharp::CppParser::AST::PredefinedExpr::operator=;
+class CppSharp::CppParser::AST::ParenExpr& (CppSharp::CppParser::AST::ParenExpr::*_143)(class CppSharp::CppParser::AST::ParenExpr&&) = &CppSharp::CppParser::AST::ParenExpr::operator=;
+class CppSharp::CppParser::AST::UnaryOperator& (CppSharp::CppParser::AST::UnaryOperator::*_144)(class CppSharp::CppParser::AST::UnaryOperator&&) = &CppSharp::CppParser::AST::UnaryOperator::operator=;
+class CppSharp::CppParser::AST::OffsetOfExpr& (CppSharp::CppParser::AST::OffsetOfExpr::*_145)(class CppSharp::CppParser::AST::OffsetOfExpr&&) = &CppSharp::CppParser::AST::OffsetOfExpr::operator=;
+class CppSharp::CppParser::AST::UnaryExprOrTypeTraitExpr& (CppSharp::CppParser::AST::UnaryExprOrTypeTraitExpr::*_146)(class CppSharp::CppParser::AST::UnaryExprOrTypeTraitExpr&&) = &CppSharp::CppParser::AST::UnaryExprOrTypeTraitExpr::operator=;
+class CppSharp::CppParser::AST::ArraySubscriptExpr& (CppSharp::CppParser::AST::ArraySubscriptExpr::*_147)(class CppSharp::CppParser::AST::ArraySubscriptExpr&&) = &CppSharp::CppParser::AST::ArraySubscriptExpr::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CallExpr_CallExpr___1__N_CppSharp_N_CppParser_N_AST_S_CallExpr(void* __instance, const CppSharp::CppParser::AST::CallExpr& _0) { ::new (__instance) CppSharp::CppParser::AST::CallExpr(_0); }
+class CppSharp::CppParser::AST::CallExpr& (CppSharp::CppParser::AST::CallExpr::*_148)(class CppSharp::CppParser::AST::CallExpr&&) = &CppSharp::CppParser::AST::CallExpr::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CallExpr__CallExpr(CppSharp::CppParser::AST::CallExpr*__instance) { __instance->~CallExpr(); }
+class CppSharp::CppParser::AST::MemberExpr& (CppSharp::CppParser::AST::MemberExpr::*_149)(class CppSharp::CppParser::AST::MemberExpr&&) = &CppSharp::CppParser::AST::MemberExpr::operator=;
+class CppSharp::CppParser::AST::CompoundLiteralExpr& (CppSharp::CppParser::AST::CompoundLiteralExpr::*_150)(class CppSharp::CppParser::AST::CompoundLiteralExpr&&) = &CppSharp::CppParser::AST::CompoundLiteralExpr::operator=;
+class CppSharp::CppParser::AST::CastExpr& (CppSharp::CppParser::AST::CastExpr::*_151)(class CppSharp::CppParser::AST::CastExpr&&) = &CppSharp::CppParser::AST::CastExpr::operator=;
+class CppSharp::CppParser::AST::ImplicitCastExpr& (CppSharp::CppParser::AST::ImplicitCastExpr::*_152)(class CppSharp::CppParser::AST::ImplicitCastExpr&&) = &CppSharp::CppParser::AST::ImplicitCastExpr::operator=;
+class CppSharp::CppParser::AST::ExplicitCastExpr& (CppSharp::CppParser::AST::ExplicitCastExpr::*_153)(class CppSharp::CppParser::AST::ExplicitCastExpr&&) = &CppSharp::CppParser::AST::ExplicitCastExpr::operator=;
+class CppSharp::CppParser::AST::CStyleCastExpr& (CppSharp::CppParser::AST::CStyleCastExpr::*_154)(class CppSharp::CppParser::AST::CStyleCastExpr&&) = &CppSharp::CppParser::AST::CStyleCastExpr::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_BinaryOperator_BinaryOperator___1__N_CppSharp_N_CppParser_N_AST_S_BinaryOperator(void* __instance, const CppSharp::CppParser::AST::BinaryOperator& _0) { ::new (__instance) CppSharp::CppParser::AST::BinaryOperator(_0); }
+class CppSharp::CppParser::AST::BinaryOperator& (CppSharp::CppParser::AST::BinaryOperator::*_155)(class CppSharp::CppParser::AST::BinaryOperator&&) = &CppSharp::CppParser::AST::BinaryOperator::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_BinaryOperator__BinaryOperator(CppSharp::CppParser::AST::BinaryOperator*__instance) { __instance->~BinaryOperator(); }
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CompoundAssignOperator_CompoundAssignOperator___1__N_CppSharp_N_CppParser_N_AST_S_CompoundAssignOperator(void* __instance, const CppSharp::CppParser::AST::CompoundAssignOperator& _0) { ::new (__instance) CppSharp::CppParser::AST::CompoundAssignOperator(_0); }
+class CppSharp::CppParser::AST::CompoundAssignOperator& (CppSharp::CppParser::AST::CompoundAssignOperator::*_156)(class CppSharp::CppParser::AST::CompoundAssignOperator&&) = &CppSharp::CppParser::AST::CompoundAssignOperator::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CompoundAssignOperator__CompoundAssignOperator(CppSharp::CppParser::AST::CompoundAssignOperator*__instance) { __instance->~CompoundAssignOperator(); }
+class CppSharp::CppParser::AST::AbstractConditionalOperator& (CppSharp::CppParser::AST::AbstractConditionalOperator::*_157)(class CppSharp::CppParser::AST::AbstractConditionalOperator&&) = &CppSharp::CppParser::AST::AbstractConditionalOperator::operator=;
+class CppSharp::CppParser::AST::ConditionalOperator& (CppSharp::CppParser::AST::ConditionalOperator::*_158)(class CppSharp::CppParser::AST::ConditionalOperator&&) = &CppSharp::CppParser::AST::ConditionalOperator::operator=;
+class CppSharp::CppParser::AST::BinaryConditionalOperator& (CppSharp::CppParser::AST::BinaryConditionalOperator::*_159)(class CppSharp::CppParser::AST::BinaryConditionalOperator&&) = &CppSharp::CppParser::AST::BinaryConditionalOperator::operator=;
+class CppSharp::CppParser::AST::AddrLabelExpr& (CppSharp::CppParser::AST::AddrLabelExpr::*_160)(class CppSharp::CppParser::AST::AddrLabelExpr&&) = &CppSharp::CppParser::AST::AddrLabelExpr::operator=;
+class CppSharp::CppParser::AST::StmtExpr& (CppSharp::CppParser::AST::StmtExpr::*_161)(class CppSharp::CppParser::AST::StmtExpr&&) = &CppSharp::CppParser::AST::StmtExpr::operator=;
+class CppSharp::CppParser::AST::ShuffleVectorExpr& (CppSharp::CppParser::AST::ShuffleVectorExpr::*_162)(class CppSharp::CppParser::AST::ShuffleVectorExpr&&) = &CppSharp::CppParser::AST::ShuffleVectorExpr::operator=;
+class CppSharp::CppParser::AST::ConvertVectorExpr& (CppSharp::CppParser::AST::ConvertVectorExpr::*_163)(class CppSharp::CppParser::AST::ConvertVectorExpr&&) = &CppSharp::CppParser::AST::ConvertVectorExpr::operator=;
+class CppSharp::CppParser::AST::ChooseExpr& (CppSharp::CppParser::AST::ChooseExpr::*_164)(class CppSharp::CppParser::AST::ChooseExpr&&) = &CppSharp::CppParser::AST::ChooseExpr::operator=;
+class CppSharp::CppParser::AST::GNUNullExpr& (CppSharp::CppParser::AST::GNUNullExpr::*_165)(class CppSharp::CppParser::AST::GNUNullExpr&&) = &CppSharp::CppParser::AST::GNUNullExpr::operator=;
+class CppSharp::CppParser::AST::VAArgExpr& (CppSharp::CppParser::AST::VAArgExpr::*_166)(class CppSharp::CppParser::AST::VAArgExpr&&) = &CppSharp::CppParser::AST::VAArgExpr::operator=;
+class CppSharp::CppParser::AST::InitListExpr& (CppSharp::CppParser::AST::InitListExpr::*_167)(class CppSharp::CppParser::AST::InitListExpr&&) = &CppSharp::CppParser::AST::InitListExpr::operator=;
+class CppSharp::CppParser::AST::DesignatedInitExpr::Designator& (CppSharp::CppParser::AST::DesignatedInitExpr::Designator::*_168)(class CppSharp::CppParser::AST::DesignatedInitExpr::Designator&&) = &CppSharp::CppParser::AST::DesignatedInitExpr::Designator::operator=;
+class CppSharp::CppParser::AST::DesignatedInitExpr::FieldDesignator& (CppSharp::CppParser::AST::DesignatedInitExpr::FieldDesignator::*_169)(class CppSharp::CppParser::AST::DesignatedInitExpr::FieldDesignator&&) = &CppSharp::CppParser::AST::DesignatedInitExpr::FieldDesignator::operator=;
+class CppSharp::CppParser::AST::DesignatedInitExpr::ArrayOrRangeDesignator& (CppSharp::CppParser::AST::DesignatedInitExpr::ArrayOrRangeDesignator::*_170)(class CppSharp::CppParser::AST::DesignatedInitExpr::ArrayOrRangeDesignator&&) = &CppSharp::CppParser::AST::DesignatedInitExpr::ArrayOrRangeDesignator::operator=;
+class CppSharp::CppParser::AST::DesignatedInitExpr& (CppSharp::CppParser::AST::DesignatedInitExpr::*_171)(class CppSharp::CppParser::AST::DesignatedInitExpr&&) = &CppSharp::CppParser::AST::DesignatedInitExpr::operator=;
+class CppSharp::CppParser::AST::NoInitExpr& (CppSharp::CppParser::AST::NoInitExpr::*_172)(class CppSharp::CppParser::AST::NoInitExpr&&) = &CppSharp::CppParser::AST::NoInitExpr::operator=;
+class CppSharp::CppParser::AST::DesignatedInitUpdateExpr& (CppSharp::CppParser::AST::DesignatedInitUpdateExpr::*_173)(class CppSharp::CppParser::AST::DesignatedInitUpdateExpr&&) = &CppSharp::CppParser::AST::DesignatedInitUpdateExpr::operator=;
+class CppSharp::CppParser::AST::ArrayInitLoopExpr& (CppSharp::CppParser::AST::ArrayInitLoopExpr::*_174)(class CppSharp::CppParser::AST::ArrayInitLoopExpr&&) = &CppSharp::CppParser::AST::ArrayInitLoopExpr::operator=;
+class CppSharp::CppParser::AST::ArrayInitIndexExpr& (CppSharp::CppParser::AST::ArrayInitIndexExpr::*_175)(class CppSharp::CppParser::AST::ArrayInitIndexExpr&&) = &CppSharp::CppParser::AST::ArrayInitIndexExpr::operator=;
+class CppSharp::CppParser::AST::ImplicitValueInitExpr& (CppSharp::CppParser::AST::ImplicitValueInitExpr::*_176)(class CppSharp::CppParser::AST::ImplicitValueInitExpr&&) = &CppSharp::CppParser::AST::ImplicitValueInitExpr::operator=;
+class CppSharp::CppParser::AST::ParenListExpr& (CppSharp::CppParser::AST::ParenListExpr::*_177)(class CppSharp::CppParser::AST::ParenListExpr&&) = &CppSharp::CppParser::AST::ParenListExpr::operator=;
+class CppSharp::CppParser::AST::GenericSelectionExpr& (CppSharp::CppParser::AST::GenericSelectionExpr::*_178)(class CppSharp::CppParser::AST::GenericSelectionExpr&&) = &CppSharp::CppParser::AST::GenericSelectionExpr::operator=;
+class CppSharp::CppParser::AST::ExtVectorElementExpr& (CppSharp::CppParser::AST::ExtVectorElementExpr::*_179)(class CppSharp::CppParser::AST::ExtVectorElementExpr&&) = &CppSharp::CppParser::AST::ExtVectorElementExpr::operator=;
+class CppSharp::CppParser::AST::BlockExpr& (CppSharp::CppParser::AST::BlockExpr::*_180)(class CppSharp::CppParser::AST::BlockExpr&&) = &CppSharp::CppParser::AST::BlockExpr::operator=;
+class CppSharp::CppParser::AST::AsTypeExpr& (CppSharp::CppParser::AST::AsTypeExpr::*_181)(class CppSharp::CppParser::AST::AsTypeExpr&&) = &CppSharp::CppParser::AST::AsTypeExpr::operator=;
+class CppSharp::CppParser::AST::PseudoObjectExpr& (CppSharp::CppParser::AST::PseudoObjectExpr::*_182)(class CppSharp::CppParser::AST::PseudoObjectExpr&&) = &CppSharp::CppParser::AST::PseudoObjectExpr::operator=;
+class CppSharp::CppParser::AST::AtomicExpr& (CppSharp::CppParser::AST::AtomicExpr::*_183)(class CppSharp::CppParser::AST::AtomicExpr&&) = &CppSharp::CppParser::AST::AtomicExpr::operator=;
+class CppSharp::CppParser::AST::TypoExpr& (CppSharp::CppParser::AST::TypoExpr::*_184)(class CppSharp::CppParser::AST::TypoExpr&&) = &CppSharp::CppParser::AST::TypoExpr::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CXXOperatorCallExpr_CXXOperatorCallExpr___1__N_CppSharp_N_CppParser_N_AST_S_CXXOperatorCallExpr(void* __instance, const CppSharp::CppParser::AST::CXXOperatorCallExpr& _0) { ::new (__instance) CppSharp::CppParser::AST::CXXOperatorCallExpr(_0); }
+class CppSharp::CppParser::AST::CXXOperatorCallExpr& (CppSharp::CppParser::AST::CXXOperatorCallExpr::*_185)(class CppSharp::CppParser::AST::CXXOperatorCallExpr&&) = &CppSharp::CppParser::AST::CXXOperatorCallExpr::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CXXOperatorCallExpr__CXXOperatorCallExpr(CppSharp::CppParser::AST::CXXOperatorCallExpr*__instance) { __instance->~CXXOperatorCallExpr(); }
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CXXMemberCallExpr_CXXMemberCallExpr___1__N_CppSharp_N_CppParser_N_AST_S_CXXMemberCallExpr(void* __instance, const CppSharp::CppParser::AST::CXXMemberCallExpr& _0) { ::new (__instance) CppSharp::CppParser::AST::CXXMemberCallExpr(_0); }
+class CppSharp::CppParser::AST::CXXMemberCallExpr& (CppSharp::CppParser::AST::CXXMemberCallExpr::*_186)(class CppSharp::CppParser::AST::CXXMemberCallExpr&&) = &CppSharp::CppParser::AST::CXXMemberCallExpr::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CXXMemberCallExpr__CXXMemberCallExpr(CppSharp::CppParser::AST::CXXMemberCallExpr*__instance) { __instance->~CXXMemberCallExpr(); }
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CUDAKernelCallExpr_CUDAKernelCallExpr___1__N_CppSharp_N_CppParser_N_AST_S_CUDAKernelCallExpr(void* __instance, const CppSharp::CppParser::AST::CUDAKernelCallExpr& _0) { ::new (__instance) CppSharp::CppParser::AST::CUDAKernelCallExpr(_0); }
+class CppSharp::CppParser::AST::CUDAKernelCallExpr& (CppSharp::CppParser::AST::CUDAKernelCallExpr::*_187)(class CppSharp::CppParser::AST::CUDAKernelCallExpr&&) = &CppSharp::CppParser::AST::CUDAKernelCallExpr::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CUDAKernelCallExpr__CUDAKernelCallExpr(CppSharp::CppParser::AST::CUDAKernelCallExpr*__instance) { __instance->~CUDAKernelCallExpr(); }
+class CppSharp::CppParser::AST::CXXNamedCastExpr& (CppSharp::CppParser::AST::CXXNamedCastExpr::*_188)(class CppSharp::CppParser::AST::CXXNamedCastExpr&&) = &CppSharp::CppParser::AST::CXXNamedCastExpr::operator=;
+class CppSharp::CppParser::AST::CXXStaticCastExpr& (CppSharp::CppParser::AST::CXXStaticCastExpr::*_189)(class CppSharp::CppParser::AST::CXXStaticCastExpr&&) = &CppSharp::CppParser::AST::CXXStaticCastExpr::operator=;
+class CppSharp::CppParser::AST::CXXDynamicCastExpr& (CppSharp::CppParser::AST::CXXDynamicCastExpr::*_190)(class CppSharp::CppParser::AST::CXXDynamicCastExpr&&) = &CppSharp::CppParser::AST::CXXDynamicCastExpr::operator=;
+class CppSharp::CppParser::AST::CXXReinterpretCastExpr& (CppSharp::CppParser::AST::CXXReinterpretCastExpr::*_191)(class CppSharp::CppParser::AST::CXXReinterpretCastExpr&&) = &CppSharp::CppParser::AST::CXXReinterpretCastExpr::operator=;
+class CppSharp::CppParser::AST::CXXConstCastExpr& (CppSharp::CppParser::AST::CXXConstCastExpr::*_192)(class CppSharp::CppParser::AST::CXXConstCastExpr&&) = &CppSharp::CppParser::AST::CXXConstCastExpr::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_UserDefinedLiteral_UserDefinedLiteral___1__N_CppSharp_N_CppParser_N_AST_S_UserDefinedLiteral(void* __instance, const CppSharp::CppParser::AST::UserDefinedLiteral& _0) { ::new (__instance) CppSharp::CppParser::AST::UserDefinedLiteral(_0); }
+class CppSharp::CppParser::AST::UserDefinedLiteral& (CppSharp::CppParser::AST::UserDefinedLiteral::*_193)(class CppSharp::CppParser::AST::UserDefinedLiteral&&) = &CppSharp::CppParser::AST::UserDefinedLiteral::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_UserDefinedLiteral__UserDefinedLiteral(CppSharp::CppParser::AST::UserDefinedLiteral*__instance) { __instance->~UserDefinedLiteral(); }
+class CppSharp::CppParser::AST::CXXBoolLiteralExpr& (CppSharp::CppParser::AST::CXXBoolLiteralExpr::*_194)(class CppSharp::CppParser::AST::CXXBoolLiteralExpr&&) = &CppSharp::CppParser::AST::CXXBoolLiteralExpr::operator=;
+class CppSharp::CppParser::AST::CXXNullPtrLiteralExpr& (CppSharp::CppParser::AST::CXXNullPtrLiteralExpr::*_195)(class CppSharp::CppParser::AST::CXXNullPtrLiteralExpr&&) = &CppSharp::CppParser::AST::CXXNullPtrLiteralExpr::operator=;
+class CppSharp::CppParser::AST::CXXStdInitializerListExpr& (CppSharp::CppParser::AST::CXXStdInitializerListExpr::*_196)(class CppSharp::CppParser::AST::CXXStdInitializerListExpr&&) = &CppSharp::CppParser::AST::CXXStdInitializerListExpr::operator=;
+class CppSharp::CppParser::AST::CXXTypeidExpr& (CppSharp::CppParser::AST::CXXTypeidExpr::*_197)(class CppSharp::CppParser::AST::CXXTypeidExpr&&) = &CppSharp::CppParser::AST::CXXTypeidExpr::operator=;
+class CppSharp::CppParser::AST::MSPropertyRefExpr& (CppSharp::CppParser::AST::MSPropertyRefExpr::*_198)(class CppSharp::CppParser::AST::MSPropertyRefExpr&&) = &CppSharp::CppParser::AST::MSPropertyRefExpr::operator=;
+class CppSharp::CppParser::AST::MSPropertySubscriptExpr& (CppSharp::CppParser::AST::MSPropertySubscriptExpr::*_199)(class CppSharp::CppParser::AST::MSPropertySubscriptExpr&&) = &CppSharp::CppParser::AST::MSPropertySubscriptExpr::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CXXUuidofExpr_CXXUuidofExpr___1__N_CppSharp_N_CppParser_N_AST_S_CXXUuidofExpr(void* __instance, const CppSharp::CppParser::AST::CXXUuidofExpr& _0) { ::new (__instance) CppSharp::CppParser::AST::CXXUuidofExpr(_0); }
+class CppSharp::CppParser::AST::CXXUuidofExpr& (CppSharp::CppParser::AST::CXXUuidofExpr::*_200)(class CppSharp::CppParser::AST::CXXUuidofExpr&&) = &CppSharp::CppParser::AST::CXXUuidofExpr::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CXXUuidofExpr__CXXUuidofExpr(CppSharp::CppParser::AST::CXXUuidofExpr*__instance) { __instance->~CXXUuidofExpr(); }
+class CppSharp::CppParser::AST::CXXThisExpr& (CppSharp::CppParser::AST::CXXThisExpr::*_201)(class CppSharp::CppParser::AST::CXXThisExpr&&) = &CppSharp::CppParser::AST::CXXThisExpr::operator=;
+class CppSharp::CppParser::AST::CXXThrowExpr& (CppSharp::CppParser::AST::CXXThrowExpr::*_202)(class CppSharp::CppParser::AST::CXXThrowExpr&&) = &CppSharp::CppParser::AST::CXXThrowExpr::operator=;
+class CppSharp::CppParser::AST::CXXDefaultArgExpr& (CppSharp::CppParser::AST::CXXDefaultArgExpr::*_203)(class CppSharp::CppParser::AST::CXXDefaultArgExpr&&) = &CppSharp::CppParser::AST::CXXDefaultArgExpr::operator=;
+class CppSharp::CppParser::AST::CXXDefaultInitExpr& (CppSharp::CppParser::AST::CXXDefaultInitExpr::*_204)(class CppSharp::CppParser::AST::CXXDefaultInitExpr&&) = &CppSharp::CppParser::AST::CXXDefaultInitExpr::operator=;
+class CppSharp::CppParser::AST::CXXBindTemporaryExpr& (CppSharp::CppParser::AST::CXXBindTemporaryExpr::*_205)(class CppSharp::CppParser::AST::CXXBindTemporaryExpr&&) = &CppSharp::CppParser::AST::CXXBindTemporaryExpr::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CXXConstructExpr_CXXConstructExpr___1__N_CppSharp_N_CppParser_N_AST_S_CXXConstructExpr(void* __instance, const CppSharp::CppParser::AST::CXXConstructExpr& _0) { ::new (__instance) CppSharp::CppParser::AST::CXXConstructExpr(_0); }
+class CppSharp::CppParser::AST::CXXConstructExpr& (CppSharp::CppParser::AST::CXXConstructExpr::*_206)(class CppSharp::CppParser::AST::CXXConstructExpr&&) = &CppSharp::CppParser::AST::CXXConstructExpr::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CXXConstructExpr__CXXConstructExpr(CppSharp::CppParser::AST::CXXConstructExpr*__instance) { __instance->~CXXConstructExpr(); }
+class CppSharp::CppParser::AST::CXXInheritedCtorInitExpr& (CppSharp::CppParser::AST::CXXInheritedCtorInitExpr::*_207)(class CppSharp::CppParser::AST::CXXInheritedCtorInitExpr&&) = &CppSharp::CppParser::AST::CXXInheritedCtorInitExpr::operator=;
+class CppSharp::CppParser::AST::CXXFunctionalCastExpr& (CppSharp::CppParser::AST::CXXFunctionalCastExpr::*_208)(class CppSharp::CppParser::AST::CXXFunctionalCastExpr&&) = &CppSharp::CppParser::AST::CXXFunctionalCastExpr::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CXXTemporaryObjectExpr_CXXTemporaryObjectExpr___1__N_CppSharp_N_CppParser_N_AST_S_CXXTemporaryObjectExpr(void* __instance, const CppSharp::CppParser::AST::CXXTemporaryObjectExpr& _0) { ::new (__instance) CppSharp::CppParser::AST::CXXTemporaryObjectExpr(_0); }
+class CppSharp::CppParser::AST::CXXTemporaryObjectExpr& (CppSharp::CppParser::AST::CXXTemporaryObjectExpr::*_209)(class CppSharp::CppParser::AST::CXXTemporaryObjectExpr&&) = &CppSharp::CppParser::AST::CXXTemporaryObjectExpr::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CXXTemporaryObjectExpr__CXXTemporaryObjectExpr(CppSharp::CppParser::AST::CXXTemporaryObjectExpr*__instance) { __instance->~CXXTemporaryObjectExpr(); }
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_LambdaExpr_LambdaExpr___1__N_CppSharp_N_CppParser_N_AST_S_LambdaExpr(void* __instance, const CppSharp::CppParser::AST::LambdaExpr& _0) { ::new (__instance) CppSharp::CppParser::AST::LambdaExpr(_0); }
+class CppSharp::CppParser::AST::LambdaExpr& (CppSharp::CppParser::AST::LambdaExpr::*_210)(class CppSharp::CppParser::AST::LambdaExpr&&) = &CppSharp::CppParser::AST::LambdaExpr::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_LambdaExpr__LambdaExpr(CppSharp::CppParser::AST::LambdaExpr*__instance) { __instance->~LambdaExpr(); }
+class CppSharp::CppParser::AST::CXXScalarValueInitExpr& (CppSharp::CppParser::AST::CXXScalarValueInitExpr::*_211)(class CppSharp::CppParser::AST::CXXScalarValueInitExpr&&) = &CppSharp::CppParser::AST::CXXScalarValueInitExpr::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CXXNewExpr_CXXNewExpr___1__N_CppSharp_N_CppParser_N_AST_S_CXXNewExpr(void* __instance, const CppSharp::CppParser::AST::CXXNewExpr& _0) { ::new (__instance) CppSharp::CppParser::AST::CXXNewExpr(_0); }
+class CppSharp::CppParser::AST::CXXNewExpr& (CppSharp::CppParser::AST::CXXNewExpr::*_212)(class CppSharp::CppParser::AST::CXXNewExpr&&) = &CppSharp::CppParser::AST::CXXNewExpr::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CXXNewExpr__CXXNewExpr(CppSharp::CppParser::AST::CXXNewExpr*__instance) { __instance->~CXXNewExpr(); }
+class CppSharp::CppParser::AST::CXXDeleteExpr& (CppSharp::CppParser::AST::CXXDeleteExpr::*_213)(class CppSharp::CppParser::AST::CXXDeleteExpr&&) = &CppSharp::CppParser::AST::CXXDeleteExpr::operator=;
+class CppSharp::CppParser::AST::CXXPseudoDestructorExpr& (CppSharp::CppParser::AST::CXXPseudoDestructorExpr::*_214)(class CppSharp::CppParser::AST::CXXPseudoDestructorExpr&&) = &CppSharp::CppParser::AST::CXXPseudoDestructorExpr::operator=;
+class CppSharp::CppParser::AST::TypeTraitExpr& (CppSharp::CppParser::AST::TypeTraitExpr::*_215)(class CppSharp::CppParser::AST::TypeTraitExpr&&) = &CppSharp::CppParser::AST::TypeTraitExpr::operator=;
+class CppSharp::CppParser::AST::ArrayTypeTraitExpr& (CppSharp::CppParser::AST::ArrayTypeTraitExpr::*_216)(class CppSharp::CppParser::AST::ArrayTypeTraitExpr&&) = &CppSharp::CppParser::AST::ArrayTypeTraitExpr::operator=;
+class CppSharp::CppParser::AST::ExpressionTraitExpr& (CppSharp::CppParser::AST::ExpressionTraitExpr::*_217)(class CppSharp::CppParser::AST::ExpressionTraitExpr&&) = &CppSharp::CppParser::AST::ExpressionTraitExpr::operator=;
+class CppSharp::CppParser::AST::OverloadExpr::FindResult& (CppSharp::CppParser::AST::OverloadExpr::FindResult::*_218)(class CppSharp::CppParser::AST::OverloadExpr::FindResult&&) = &CppSharp::CppParser::AST::OverloadExpr::FindResult::operator=;
+class CppSharp::CppParser::AST::OverloadExpr& (CppSharp::CppParser::AST::OverloadExpr::*_219)(class CppSharp::CppParser::AST::OverloadExpr&&) = &CppSharp::CppParser::AST::OverloadExpr::operator=;
+class CppSharp::CppParser::AST::UnresolvedLookupExpr& (CppSharp::CppParser::AST::UnresolvedLookupExpr::*_220)(class CppSharp::CppParser::AST::UnresolvedLookupExpr&&) = &CppSharp::CppParser::AST::UnresolvedLookupExpr::operator=;
+class CppSharp::CppParser::AST::DependentScopeDeclRefExpr& (CppSharp::CppParser::AST::DependentScopeDeclRefExpr::*_221)(class CppSharp::CppParser::AST::DependentScopeDeclRefExpr&&) = &CppSharp::CppParser::AST::DependentScopeDeclRefExpr::operator=;
+class CppSharp::CppParser::AST::ExprWithCleanups& (CppSharp::CppParser::AST::ExprWithCleanups::*_222)(class CppSharp::CppParser::AST::ExprWithCleanups&&) = &CppSharp::CppParser::AST::ExprWithCleanups::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CXXUnresolvedConstructExpr_CXXUnresolvedConstructExpr___1__N_CppSharp_N_CppParser_N_AST_S_CXXUnresolvedConstructExpr(void* __instance, const CppSharp::CppParser::AST::CXXUnresolvedConstructExpr& _0) { ::new (__instance) CppSharp::CppParser::AST::CXXUnresolvedConstructExpr(_0); }
+class CppSharp::CppParser::AST::CXXUnresolvedConstructExpr& (CppSharp::CppParser::AST::CXXUnresolvedConstructExpr::*_223)(class CppSharp::CppParser::AST::CXXUnresolvedConstructExpr&&) = &CppSharp::CppParser::AST::CXXUnresolvedConstructExpr::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_N_AST_S_CXXUnresolvedConstructExpr__CXXUnresolvedConstructExpr(CppSharp::CppParser::AST::CXXUnresolvedConstructExpr*__instance) { __instance->~CXXUnresolvedConstructExpr(); }
+class CppSharp::CppParser::AST::CXXDependentScopeMemberExpr& (CppSharp::CppParser::AST::CXXDependentScopeMemberExpr::*_224)(class CppSharp::CppParser::AST::CXXDependentScopeMemberExpr&&) = &CppSharp::CppParser::AST::CXXDependentScopeMemberExpr::operator=;
+class CppSharp::CppParser::AST::UnresolvedMemberExpr& (CppSharp::CppParser::AST::UnresolvedMemberExpr::*_225)(class CppSharp::CppParser::AST::UnresolvedMemberExpr&&) = &CppSharp::CppParser::AST::UnresolvedMemberExpr::operator=;
+class CppSharp::CppParser::AST::CXXNoexceptExpr& (CppSharp::CppParser::AST::CXXNoexceptExpr::*_226)(class CppSharp::CppParser::AST::CXXNoexceptExpr&&) = &CppSharp::CppParser::AST::CXXNoexceptExpr::operator=;
+class CppSharp::CppParser::AST::PackExpansionExpr& (CppSharp::CppParser::AST::PackExpansionExpr::*_227)(class CppSharp::CppParser::AST::PackExpansionExpr&&) = &CppSharp::CppParser::AST::PackExpansionExpr::operator=;
+class CppSharp::CppParser::AST::SizeOfPackExpr& (CppSharp::CppParser::AST::SizeOfPackExpr::*_228)(class CppSharp::CppParser::AST::SizeOfPackExpr&&) = &CppSharp::CppParser::AST::SizeOfPackExpr::operator=;
+class CppSharp::CppParser::AST::SubstNonTypeTemplateParmExpr& (CppSharp::CppParser::AST::SubstNonTypeTemplateParmExpr::*_229)(class CppSharp::CppParser::AST::SubstNonTypeTemplateParmExpr&&) = &CppSharp::CppParser::AST::SubstNonTypeTemplateParmExpr::operator=;
+class CppSharp::CppParser::AST::SubstNonTypeTemplateParmPackExpr& (CppSharp::CppParser::AST::SubstNonTypeTemplateParmPackExpr::*_230)(class CppSharp::CppParser::AST::SubstNonTypeTemplateParmPackExpr&&) = &CppSharp::CppParser::AST::SubstNonTypeTemplateParmPackExpr::operator=;
+class CppSharp::CppParser::AST::FunctionParmPackExpr& (CppSharp::CppParser::AST::FunctionParmPackExpr::*_231)(class CppSharp::CppParser::AST::FunctionParmPackExpr&&) = &CppSharp::CppParser::AST::FunctionParmPackExpr::operator=;
+class CppSharp::CppParser::AST::MaterializeTemporaryExpr::ExtraState& (CppSharp::CppParser::AST::MaterializeTemporaryExpr::ExtraState::*_232)(class CppSharp::CppParser::AST::MaterializeTemporaryExpr::ExtraState&&) = &CppSharp::CppParser::AST::MaterializeTemporaryExpr::ExtraState::operator=;
+class CppSharp::CppParser::AST::MaterializeTemporaryExpr& (CppSharp::CppParser::AST::MaterializeTemporaryExpr::*_233)(class CppSharp::CppParser::AST::MaterializeTemporaryExpr&&) = &CppSharp::CppParser::AST::MaterializeTemporaryExpr::operator=;
+class CppSharp::CppParser::AST::CXXFoldExpr& (CppSharp::CppParser::AST::CXXFoldExpr::*_234)(class CppSharp::CppParser::AST::CXXFoldExpr&&) = &CppSharp::CppParser::AST::CXXFoldExpr::operator=;
+class CppSharp::CppParser::AST::CoroutineSuspendExpr& (CppSharp::CppParser::AST::CoroutineSuspendExpr::*_235)(class CppSharp::CppParser::AST::CoroutineSuspendExpr&&) = &CppSharp::CppParser::AST::CoroutineSuspendExpr::operator=;
+class CppSharp::CppParser::AST::CoawaitExpr& (CppSharp::CppParser::AST::CoawaitExpr::*_236)(class CppSharp::CppParser::AST::CoawaitExpr&&) = &CppSharp::CppParser::AST::CoawaitExpr::operator=;
+class CppSharp::CppParser::AST::DependentCoawaitExpr& (CppSharp::CppParser::AST::DependentCoawaitExpr::*_237)(class CppSharp::CppParser::AST::DependentCoawaitExpr&&) = &CppSharp::CppParser::AST::DependentCoawaitExpr::operator=;
+class CppSharp::CppParser::AST::CoyieldExpr& (CppSharp::CppParser::AST::CoyieldExpr::*_238)(class CppSharp::CppParser::AST::CoyieldExpr&&) = &CppSharp::CppParser::AST::CoyieldExpr::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_S_ParserTargetInfo_ParserTargetInfo___1__N_CppSharp_N_CppParser_S_ParserTargetInfo(void* __instance, const CppSharp::CppParser::ParserTargetInfo& _0) { ::new (__instance) CppSharp::CppParser::ParserTargetInfo(_0); }
+struct CppSharp::CppParser::ParserTargetInfo& (CppSharp::CppParser::ParserTargetInfo::*_239)(const struct CppSharp::CppParser::ParserTargetInfo&) = &CppSharp::CppParser::ParserTargetInfo::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_S_CppParserOptions_CppParserOptions___1__N_CppSharp_N_CppParser_S_CppParserOptions(void* __instance, const CppSharp::CppParser::CppParserOptions& _0) { ::new (__instance) CppSharp::CppParser::CppParserOptions(_0); }
+struct CppSharp::CppParser::CppParserOptions& (CppSharp::CppParser::CppParserOptions::*_240)(const struct CppSharp::CppParser::CppParserOptions&) = &CppSharp::CppParser::CppParserOptions::operator=;
+extern "C" void c__N_CppSharp_N_CppParser_S_CppLinkerOptions_CppLinkerOptions___1__N_CppSharp_N_CppParser_S_CppLinkerOptions(void* __instance, const CppSharp::CppParser::CppLinkerOptions& _0) { ::new (__instance) CppSharp::CppParser::CppLinkerOptions(_0); }
+struct CppSharp::CppParser::CppLinkerOptions& (CppSharp::CppParser::CppLinkerOptions::*_241)(const struct CppSharp::CppParser::CppLinkerOptions&) = &CppSharp::CppParser::CppLinkerOptions::operator=;
+struct CppSharp::CppParser::ParserDiagnostic& (CppSharp::CppParser::ParserDiagnostic::*_242)(const struct CppSharp::CppParser::ParserDiagnostic&) = &CppSharp::CppParser::ParserDiagnostic::operator=;
+struct CppSharp::CppParser::ParserResult& (CppSharp::CppParser::ParserResult::*_243)(const struct CppSharp::CppParser::ParserResult&) = &CppSharp::CppParser::ParserResult::operator=;
+class CppSharp::CppParser::ClangParser& (CppSharp::CppParser::ClangParser::*_244)(class CppSharp::CppParser::ClangParser&&) = &CppSharp::CppParser::ClangParser::operator=;

src/CppParser/Bindings/CSharp/x86_64-apple-darwin/Std-symbols.cpp

@@ -0,0 +1,12 @@
+#define _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
+#define _LIBCPP_HIDE_FROM_ABI
+#define _LIBCPP_NO_ABI_TAG
+
+#include <string>
+#include <new>
+
+template std::allocator<char>::allocator() noexcept;
+template std::basic_string<char, std::char_traits<char>, std::allocator<char>>::basic_string() noexcept(true);
+template std::basic_string<char, std::char_traits<char>, std::allocator<char>>::~basic_string() noexcept;
+template std::basic_string<char, std::char_traits<char>, std::allocator<char>>& std::basic_string<char, std::char_traits<char>, std::allocator<char>>::assign(const char*);
+template const char* std::basic_string<char, std::char_traits<char>, std::allocator<char>>::data() const noexcept;

src/CppParser/Bindings/CSharp/x86_64-apple-darwin/Std.cs

@@ -8,6 +8,7 @@ using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Security;
+using __NativeMemory = global::System.Runtime.InteropServices.NativeMemory;
 using __CallingConvention = global::System.Runtime.InteropServices.CallingConvention;
 using __IntPtr = global::System.IntPtr;
 
@@ -36,50 +37,47 @@ namespace Std
 
 namespace Std
 {
-    namespace CompressedPair
-    {
-        [StructLayout(LayoutKind.Sequential, Size = 24)]
-        public unsafe partial struct __Internalc__N_std_N___1_S___compressed_pair____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C_S___rep_S2_
-        {
-            internal global::Std.BasicString.Rep.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C __value_;
-        }
+}
 
-        [StructLayout(LayoutKind.Sequential, Size = 8)]
-        public unsafe partial struct __Internalc__N_std_N___1_S___compressed_pair_____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C___N_std_N___1_S_allocator__S1_
-        {
-            internal __IntPtr __value_;
-        }
+namespace Std
+{
+}
 
-        [StructLayout(LayoutKind.Sequential, Size = 8)]
-        public unsafe partial struct __Internalc__N_std_N___1_S___compressed_pair___i___N_std_N___1_S_allocator__i
-        {
-            internal __IntPtr __value_;
-        }
-    }
+namespace Std
+{
+}
 
-    namespace Allocator
+namespace Std
+{
+}
+
+namespace Std
+{
+}
+
+namespace Std
+{
+    namespace CharTraits
     {
-        [StructLayout(LayoutKind.Sequential, Size = 1)]
+        [StructLayout(LayoutKind.Explicit, Size = 1)]
         public unsafe partial struct __Internal
         {
-            [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNSt3__19allocatorIcEC2Ev", CallingConvention = __CallingConvention.Cdecl)]
-            internal static extern void ctorc__N_std_N___1_S_allocator__C(__IntPtr __instance);
         }
     }
 
-    public unsafe partial class Allocator<_Tp> : IDisposable
+    public unsafe partial class CharTraits<_CharT> : IDisposable
     {
         public __IntPtr __Instance { get; protected set; }
 
-        internal static readonly new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.Allocator<_Tp>> NativeToManagedMap =
-            new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.Allocator<_Tp>>();
+        internal static readonly new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.CharTraits<_CharT>> NativeToManagedMap =
+            new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.CharTraits<_CharT>>();
 
-        internal static void __RecordNativeToManagedMapping(IntPtr native, global::Std.Allocator<_Tp> managed)
+        internal static void __RecordNativeToManagedMapping(IntPtr native, global::Std.CharTraits<_CharT> managed)
         {
             NativeToManagedMap[native] = managed;
         }
 
-        internal static bool __TryGetNativeToManagedMapping(IntPtr native, out global::Std.Allocator<_Tp> managed)
+        internal static bool __TryGetNativeToManagedMapping(IntPtr native, out global::Std.CharTraits<_CharT> managed)
         {
     
             return NativeToManagedMap.TryGetValue(native, out managed);
@@ -87,65 +85,51 @@ namespace Std
 
         protected bool __ownsNativeInstance;
 
-        internal static Allocator<_Tp> __CreateInstance(__IntPtr native, bool skipVTables = false)
+        internal static CharTraits<_CharT> __CreateInstance(__IntPtr native, bool skipVTables = false)
         {
             if (native == __IntPtr.Zero)
                 return null;
-            return new Allocator<_Tp>(native.ToPointer(), skipVTables);
+            return new CharTraits<_CharT>(native.ToPointer(), skipVTables);
         }
 
-        internal static Allocator<_Tp> __GetOrCreateInstance(__IntPtr native, bool saveInstance = false, bool skipVTables = false)
+        internal static CharTraits<_CharT> __GetOrCreateInstance(__IntPtr native, bool saveInstance = false, bool skipVTables = false)
         {
             if (native == __IntPtr.Zero)
                 return null;
             if (__TryGetNativeToManagedMapping(native, out var managed))
-                return (Allocator<_Tp>)managed;
+                return (CharTraits<_CharT>)managed;
             var result = __CreateInstance(native, skipVTables);
             if (saveInstance)
                 __RecordNativeToManagedMapping(native, result);
             return result;
         }
 
-        internal static Allocator<_Tp> __CreateInstance(global::Std.Allocator.__Internal native, bool skipVTables = false)
+        internal static CharTraits<_CharT> __CreateInstance(global::Std.CharTraits.__Internal native, bool skipVTables = false)
         {
-            return new Allocator<_Tp>(native, skipVTables);
+            return new CharTraits<_CharT>(native, skipVTables);
         }
 
-        private static void* __CopyValue(global::Std.Allocator.__Internal native)
+        private static void* __CopyValue(global::Std.CharTraits.__Internal native)
         {
-            var ret = Marshal.AllocHGlobal(sizeof(global::Std.Allocator.__Internal));
-            *(global::Std.Allocator.__Internal*) ret = native;
+            var ret = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.CharTraits.__Internal), 16);
+            *(global::Std.CharTraits.__Internal*) ret = native;
             return ret.ToPointer();
         }
 
-        private Allocator(global::Std.Allocator.__Internal native, bool skipVTables = false)
+        private CharTraits(global::Std.CharTraits.__Internal native, bool skipVTables = false)
             : this(__CopyValue(native), skipVTables)
         {
             __ownsNativeInstance = true;
             __RecordNativeToManagedMapping(__Instance, this);
         }
 
-        protected Allocator(void* native, bool skipVTables = false)
+        protected CharTraits(void* native, bool skipVTables = false)
         {
             if (native == null)
                 return;
             __Instance = new __IntPtr(native);
         }
 
-        public Allocator()
-        {
-            var ___Tp = typeof(_Tp);
-            if (___Tp.IsAssignableFrom(typeof(sbyte)))
-            {
-                __Instance = Marshal.AllocHGlobal(sizeof(global::Std.Allocator.__Internal));
-                __ownsNativeInstance = true;
-                __RecordNativeToManagedMapping(__Instance, this);
-                global::Std.Allocator.__Internal.ctorc__N_std_N___1_S_allocator__C(__Instance);
-                return;
-            }
-            throw new ArgumentOutOfRangeException("_Tp", string.Join(", ", new[] { typeof(_Tp).FullName }), "global::Std.Allocator<_Tp> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte>.");
-        }
-
         public void Dispose()
         {
             Dispose(disposing: true, callNativeDtor: __ownsNativeInstance);
@@ -160,7 +144,7 @@ namespace Std
             NativeToManagedMap.TryRemove(__Instance, out _);
             DisposePartial(disposing);
             if (__ownsNativeInstance)
-                Marshal.FreeHGlobal(__Instance);
+                __NativeMemory.AlignedFree((void*)__Instance);
             __Instance = IntPtr.Zero;
         }
     }
@@ -168,65 +152,68 @@ namespace Std
 
 namespace Std
 {
-    namespace Vector
+}
+
+namespace Std
+{
+}
+
+namespace Std
+{
+}
+
+namespace Std
+{
+    namespace CompressedPair
     {
-        [StructLayout(LayoutKind.Sequential, Size = 24)]
-        public unsafe partial struct __Internalc__N_std_N___1_S_vector____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C___N_std_N___1_S_allocator__S0_
+        [StructLayout(LayoutKind.Explicit, Size = 24)]
+        public unsafe partial struct __Internalc__N_std_N___1_S___compressed_pair____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C_S___rep_S2_
         {
-            internal __IntPtr __begin_;
-            internal __IntPtr __end_;
-            internal global::Std.CompressedPair.__Internalc__N_std_N___1_S___compressed_pair_____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C___N_std_N___1_S_allocator__S1_ __end_cap_;
+            [FieldOffset(0)]
+            internal global::Std.BasicString.Rep.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C __value_;
         }
 
-        [StructLayout(LayoutKind.Sequential, Size = 24)]
-        public unsafe partial struct __Internalc__N_std_N___1_S_vector__i___N_std_N___1_S_allocator__i
+        [StructLayout(LayoutKind.Explicit, Size = 8)]
+        public unsafe partial struct __Internalc__N_std_N___1_S___compressed_pair_____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C___N_std_N___1_S_allocator__S1_
         {
-            internal __IntPtr __begin_;
-            internal __IntPtr __end_;
-            internal global::Std.CompressedPair.__Internalc__N_std_N___1_S___compressed_pair___i___N_std_N___1_S_allocator__i __end_cap_;
+            [FieldOffset(0)]
+            internal __IntPtr __value_;
         }
-    }
-}
 
-namespace Std
-{
-    namespace TreeEndNode
-    {
-        [StructLayout(LayoutKind.Sequential, Size = 8)]
-        public unsafe partial struct __Internal_Ptr
+        [StructLayout(LayoutKind.Explicit, Size = 8)]
+        public unsafe partial struct __Internalc__N_std_N___1_S___compressed_pair___i___N_std_N___1_S_allocator__i
         {
-            internal __IntPtr __left_;
+            [FieldOffset(0)]
+            internal __IntPtr __value_;
         }
     }
 }
 
 namespace Std
 {
-}
-
-namespace Std
-{
-    namespace CharTraits
+    namespace Allocator
     {
-        [StructLayout(LayoutKind.Sequential, Size = 1)]
+        [StructLayout(LayoutKind.Explicit, Size = 1)]
         public unsafe partial struct __Internal
         {
+            [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNSt3__19allocatorIcEC2B8un170006Ev", CallingConvention = __CallingConvention.Cdecl)]
+            internal static extern void ctorc__N_std_N___1_S_allocator__C(__IntPtr __instance);
         }
     }
 
-    public unsafe partial class CharTraits<_CharT> : IDisposable
+    public unsafe partial class Allocator<_Tp> : IDisposable
     {
         public __IntPtr __Instance { get; protected set; }
 
-        internal static readonly new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.CharTraits<_CharT>> NativeToManagedMap =
-            new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.CharTraits<_CharT>>();
+        internal static readonly new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.Allocator<_Tp>> NativeToManagedMap =
+            new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::Std.Allocator<_Tp>>();
 
-        internal static void __RecordNativeToManagedMapping(IntPtr native, global::Std.CharTraits<_CharT> managed)
+        internal static void __RecordNativeToManagedMapping(IntPtr native, global::Std.Allocator<_Tp> managed)
         {
             NativeToManagedMap[native] = managed;
         }
 
-        internal static bool __TryGetNativeToManagedMapping(IntPtr native, out global::Std.CharTraits<_CharT> managed)
+        internal static bool __TryGetNativeToManagedMapping(IntPtr native, out global::Std.Allocator<_Tp> managed)
         {
     
             return NativeToManagedMap.TryGetValue(native, out managed);
@@ -234,51 +221,65 @@ namespace Std
 
         protected bool __ownsNativeInstance;
 
-        internal static CharTraits<_CharT> __CreateInstance(__IntPtr native, bool skipVTables = false)
+        internal static Allocator<_Tp> __CreateInstance(__IntPtr native, bool skipVTables = false)
         {
             if (native == __IntPtr.Zero)
                 return null;
-            return new CharTraits<_CharT>(native.ToPointer(), skipVTables);
+            return new Allocator<_Tp>(native.ToPointer(), skipVTables);
         }
 
-        internal static CharTraits<_CharT> __GetOrCreateInstance(__IntPtr native, bool saveInstance = false, bool skipVTables = false)
+        internal static Allocator<_Tp> __GetOrCreateInstance(__IntPtr native, bool saveInstance = false, bool skipVTables = false)
         {
             if (native == __IntPtr.Zero)
                 return null;
             if (__TryGetNativeToManagedMapping(native, out var managed))
-                return (CharTraits<_CharT>)managed;
+                return (Allocator<_Tp>)managed;
             var result = __CreateInstance(native, skipVTables);
             if (saveInstance)
                 __RecordNativeToManagedMapping(native, result);
             return result;
         }
 
-        internal static CharTraits<_CharT> __CreateInstance(global::Std.CharTraits.__Internal native, bool skipVTables = false)
+        internal static Allocator<_Tp> __CreateInstance(global::Std.Allocator.__Internal native, bool skipVTables = false)
         {
-            return new CharTraits<_CharT>(native, skipVTables);
+            return new Allocator<_Tp>(native, skipVTables);
         }
 
-        private static void* __CopyValue(global::Std.CharTraits.__Internal native)
+        private static void* __CopyValue(global::Std.Allocator.__Internal native)
         {
-            var ret = Marshal.AllocHGlobal(sizeof(global::Std.CharTraits.__Internal));
-            *(global::Std.CharTraits.__Internal*) ret = native;
+            var ret = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.Allocator.__Internal), 16);
+            *(global::Std.Allocator.__Internal*) ret = native;
             return ret.ToPointer();
         }
 
-        private CharTraits(global::Std.CharTraits.__Internal native, bool skipVTables = false)
+        private Allocator(global::Std.Allocator.__Internal native, bool skipVTables = false)
             : this(__CopyValue(native), skipVTables)
         {
             __ownsNativeInstance = true;
             __RecordNativeToManagedMapping(__Instance, this);
         }
 
-        protected CharTraits(void* native, bool skipVTables = false)
+        protected Allocator(void* native, bool skipVTables = false)
         {
             if (native == null)
                 return;
             __Instance = new __IntPtr(native);
         }
 
+        public Allocator()
+        {
+            var ___Tp = typeof(_Tp);
+            if (___Tp.IsAssignableFrom(typeof(sbyte)))
+            {
+                __Instance = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.Allocator.__Internal), 16);
+                __ownsNativeInstance = true;
+                __RecordNativeToManagedMapping(__Instance, this);
+                global::Std.Allocator.__Internal.ctorc__N_std_N___1_S_allocator__C(__Instance);
+                return;
+            }
+            throw new ArgumentOutOfRangeException("_Tp", string.Join(", ", new[] { typeof(_Tp).FullName }), "global::Std.Allocator<_Tp> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte>.");
+        }
+
         public void Dispose()
         {
             Dispose(disposing: true, callNativeDtor: __ownsNativeInstance);
@@ -293,7 +294,7 @@ namespace Std
             NativeToManagedMap.TryRemove(__Instance, out _);
             DisposePartial(disposing);
             if (__ownsNativeInstance)
-                Marshal.FreeHGlobal(__Instance);
+                __NativeMemory.AlignedFree((void*)__Instance);
             __Instance = IntPtr.Zero;
         }
     }
@@ -303,16 +304,20 @@ namespace Std
 {
     namespace BasicString
     {
-        [StructLayout(LayoutKind.Sequential, Size = 24)]
+        [StructLayout(LayoutKind.Explicit, Size = 24)]
         public unsafe partial struct __Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C
         {
+            [FieldOffset(0)]
             internal global::Std.CompressedPair.__Internalc__N_std_N___1_S___compressed_pair____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C_S___rep_S2_ __r_;
 
-            [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2Ev", CallingConvention = __CallingConvention.Cdecl)]
+            [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2B8un170006Ev", CallingConvention = __CallingConvention.Cdecl)]
             internal static extern void ctorc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C(__IntPtr __instance);
 
             [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev", CallingConvention = __CallingConvention.Cdecl)]
             internal static extern void dtorc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C(__IntPtr __instance);
+
+            [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKc", CallingConvention = __CallingConvention.Cdecl)]
+            internal static extern __IntPtr Assignc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C(__IntPtr __instance, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(CppSharp.Runtime.UTF8Marshaller))] string __s);
         }
 
         namespace Rep
@@ -351,14 +356,36 @@ namespace Std
 
         namespace Long
         {
-            [StructLayout(LayoutKind.Sequential, Size = 24)]
+            [StructLayout(LayoutKind.Explicit, Size = 24)]
             public unsafe partial struct __Internal
             {
+                [FieldOffset(0)]
+                internal ulong __is_long_;
+
+                [FieldOffset(0)]
                 internal ulong __cap_;
+
+                [FieldOffset(8)]
                 internal ulong __size_;
+
+                [FieldOffset(16)]
                 internal __IntPtr __data_;
             }
 
+            namespace _0
+            {
+                [StructLayout(LayoutKind.Explicit, Size = 8)]
+                public unsafe partial struct __Internal
+                {
+                    [FieldOffset(0)]
+                    internal ulong __is_long_;
+
+                    [FieldOffset(0)]
+                    internal ulong __cap_;
+                }
+
+            }
+
         }
 
         namespace Short
@@ -367,10 +394,13 @@ namespace Std
             public unsafe partial struct __Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C
             {
                 [FieldOffset(0)]
-                internal byte __size_;
+                internal byte __is_long_;
 
                 [FieldOffset(0)]
-                internal sbyte __lx;
+                internal byte __size_;
+
+                [FieldOffset(1)]
+                internal __IntPtr __padding_;
 
                 [FieldOffset(1)]
                 internal fixed sbyte __data_[23];
@@ -382,10 +412,10 @@ namespace Std
                 public unsafe partial struct __Internal
                 {
                     [FieldOffset(0)]
-                    internal byte __size_;
+                    internal byte __is_long_;
 
                     [FieldOffset(0)]
-                    internal sbyte __lx;
+                    internal byte __size_;
                 }
 
             }
@@ -394,9 +424,10 @@ namespace Std
 
         namespace Raw
         {
-            [StructLayout(LayoutKind.Sequential, Size = 24)]
+            [StructLayout(LayoutKind.Explicit, Size = 24)]
             public unsafe partial struct __Internal
             {
+                [FieldOffset(0)]
                 internal fixed ulong __words[3];
             }
         }
@@ -449,7 +480,7 @@ namespace Std
 
         private static void* __CopyValue(global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C native)
         {
-            var ret = Marshal.AllocHGlobal(sizeof(global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C));
+            var ret = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C), 16);
             *(global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C*) ret = native;
             return ret.ToPointer();
         }
@@ -475,7 +506,7 @@ namespace Std
             var ___Allocator = typeof(_Allocator);
             if (___CharT.IsAssignableFrom(typeof(sbyte)) && ___Traits.IsAssignableFrom(typeof(global::Std.CharTraits<sbyte>)) && ___Allocator.IsAssignableFrom(typeof(global::Std.Allocator<sbyte>)))
             {
-                __Instance = Marshal.AllocHGlobal(sizeof(global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C));
+                __Instance = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C), 16);
                 __ownsNativeInstance = true;
                 __RecordNativeToManagedMapping(__Instance, this);
                 global::Std.BasicString.__Internalc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C.ctorc__N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C(__Instance);
@@ -510,7 +541,7 @@ namespace Std
                 throw new ArgumentOutOfRangeException("_CharT, _Traits, _Allocator", string.Join(", ", new[] { typeof(_CharT).FullName, typeof(_Traits).FullName, typeof(_Allocator).FullName }), "global::Std.BasicString<_CharT, _Traits, _Allocator> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
             }
             if (__ownsNativeInstance)
-                Marshal.FreeHGlobal(__Instance);
+                __NativeMemory.AlignedFree((void*)__Instance);
             __Instance = IntPtr.Zero;
         }
     }
@@ -519,21 +550,10 @@ namespace Std
     {
         public partial struct __Internal
         {
-            [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKc", CallingConvention = __CallingConvention.Cdecl)]
-            internal static extern __IntPtr Assign(__IntPtr __instance, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(CppSharp.Runtime.UTF8Marshaller))] string __s);
-
-            [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4dataEv", CallingConvention = __CallingConvention.Cdecl)]
+            [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4dataB8un170006Ev", CallingConvention = __CallingConvention.Cdecl)]
             internal static extern __IntPtr Data(__IntPtr __instance);
         }
 
-        public static global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> Assign(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this, string __s)
-        {
-            var __arg0 = @this is null ? __IntPtr.Zero : @this.__Instance;
-            var ___ret = __Internal.Assign(__arg0, __s);
-            var __result0 = global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.__GetOrCreateInstance(___ret, false);
-            return __result0;
-        }
-
         public static string Data(this global::Std.BasicString<sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>> @this)
         {
             var __arg0 = @this is null ? __IntPtr.Zero : @this.__Instance;
@@ -542,3 +562,52 @@ namespace Std
         }
     }
 }
+
+namespace Std
+{
+    namespace Vector
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 24)]
+        public unsafe partial struct __Internalc__N_std_N___1_S_vector____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C___N_std_N___1_S_allocator__S0_
+        {
+            [FieldOffset(0)]
+            internal __IntPtr __begin_;
+
+            [FieldOffset(8)]
+            internal __IntPtr __end_;
+
+            [FieldOffset(16)]
+            internal global::Std.CompressedPair.__Internalc__N_std_N___1_S___compressed_pair_____N_std_N___1_S_basic_string__C___N_std_N___1_S_char_traits__C___N_std_N___1_S_allocator__C___N_std_N___1_S_allocator__S1_ __end_cap_;
+        }
+
+        [StructLayout(LayoutKind.Explicit, Size = 24)]
+        public unsafe partial struct __Internalc__N_std_N___1_S_vector__i___N_std_N___1_S_allocator__i
+        {
+            [FieldOffset(0)]
+            internal __IntPtr __begin_;
+
+            [FieldOffset(8)]
+            internal __IntPtr __end_;
+
+            [FieldOffset(16)]
+            internal global::Std.CompressedPair.__Internalc__N_std_N___1_S___compressed_pair___i___N_std_N___1_S_allocator__i __end_cap_;
+        }
+    }
+}
+
+namespace Std
+{
+    namespace TreeEndNode
+    {
+        [StructLayout(LayoutKind.Explicit, Size = 8)]
+        public unsafe partial struct __Internal_Ptr
+        {
+            [FieldOffset(0)]
+            internal __IntPtr __left_;
+        }
+    }
+}
+
+namespace Std
+{
+}

src/CppParser/Bindings/CSharp/x86_64-linux-gnu-cxx11abi/Std-symbols.cpp

@@ -1,5 +1,6 @@
 #define _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
 #define _LIBCPP_HIDE_FROM_ABI
+#define _LIBCPP_NO_ABI_TAG
 
 #include <string>
 #include <new>

src/CppParser/Bindings/CSharp/x86_64-linux-gnu-cxx11abi/Std.cs

@@ -8,6 +8,7 @@ using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Security;
+using __NativeMemory = global::System.Runtime.InteropServices.NativeMemory;
 using __CallingConvention = global::System.Runtime.InteropServices.CallingConvention;
 using __IntPtr = global::System.IntPtr;
 
@@ -22,7 +23,7 @@ namespace Std
 {
     namespace Allocator
     {
-        [StructLayout(LayoutKind.Sequential, Size = 1)]
+        [StructLayout(LayoutKind.Explicit, Size = 1)]
         public unsafe partial struct __Internal
         {
             [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNSaIcEC2Ev", CallingConvention = __CallingConvention.Cdecl)]
@@ -79,7 +80,7 @@ namespace Std
 
         private static void* __CopyValue(global::Std.Allocator.__Internal native)
         {
-            var ret = Marshal.AllocHGlobal(sizeof(global::Std.Allocator.__Internal));
+            var ret = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.Allocator.__Internal), 16);
             *(global::Std.Allocator.__Internal*) ret = native;
             return ret.ToPointer();
         }
@@ -103,7 +104,7 @@ namespace Std
             var ___Tp = typeof(_Tp);
             if (___Tp.IsAssignableFrom(typeof(sbyte)))
             {
-                __Instance = Marshal.AllocHGlobal(sizeof(global::Std.Allocator.__Internal));
+                __Instance = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.Allocator.__Internal), 16);
                 __ownsNativeInstance = true;
                 __RecordNativeToManagedMapping(__Instance, this);
                 global::Std.Allocator.__Internal.ctorc__N_std_S_allocator__C(__Instance);
@@ -136,7 +137,7 @@ namespace Std
                 throw new ArgumentOutOfRangeException("_Tp", string.Join(", ", new[] { typeof(_Tp).FullName }), "global::Std.Allocator<_Tp> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte>.");
             }
             if (__ownsNativeInstance)
-                Marshal.FreeHGlobal(__Instance);
+                __NativeMemory.AlignedFree((void*)__Instance);
             __Instance = IntPtr.Zero;
         }
     }
@@ -146,28 +147,35 @@ namespace Std
 {
     namespace Vector
     {
-        [StructLayout(LayoutKind.Sequential, Size = 24)]
+        [StructLayout(LayoutKind.Explicit, Size = 24)]
         public unsafe partial struct __Internal
         {
+            [FieldOffset(0)]
             internal global::Std.VectorBase.VectorImpl.__Internal _M_impl;
         }
     }
 
     namespace VectorBase
     {
-        [StructLayout(LayoutKind.Sequential, Size = 24)]
+        [StructLayout(LayoutKind.Explicit, Size = 24)]
         public unsafe partial struct __Internal
         {
+            [FieldOffset(0)]
             internal global::Std.VectorBase.VectorImpl.__Internal _M_impl;
         }
 
         namespace VectorImpl
         {
-            [StructLayout(LayoutKind.Sequential, Size = 24)]
+            [StructLayout(LayoutKind.Explicit, Size = 24)]
             public unsafe partial struct __Internal
             {
+                [FieldOffset(0)]
                 internal __IntPtr _M_start;
+
+                [FieldOffset(8)]
                 internal __IntPtr _M_finish;
+
+                [FieldOffset(16)]
                 internal __IntPtr _M_end_of_storage;
             }
 
@@ -175,11 +183,16 @@ namespace Std
 
         namespace VectorImplData
         {
-            [StructLayout(LayoutKind.Sequential, Size = 24)]
+            [StructLayout(LayoutKind.Explicit, Size = 24)]
             public unsafe partial struct __Internal
             {
+                [FieldOffset(0)]
                 internal __IntPtr _M_start;
+
+                [FieldOffset(8)]
                 internal __IntPtr _M_finish;
+
+                [FieldOffset(16)]
                 internal __IntPtr _M_end_of_storage;
             }
         }
@@ -191,7 +204,7 @@ namespace Std
 {
     namespace Less
     {
-        [StructLayout(LayoutKind.Sequential, Size = 1)]
+        [StructLayout(LayoutKind.Explicit, Size = 1)]
         public unsafe partial struct __Internal
         {
         }
@@ -206,12 +219,19 @@ namespace Std
 
     public unsafe partial class RbTreeNodeBase
     {
-        [StructLayout(LayoutKind.Sequential, Size = 32)]
+        [StructLayout(LayoutKind.Explicit, Size = 32)]
         public partial struct __Internal
         {
+            [FieldOffset(0)]
             internal global::Std.RbTreeColor _M_color;
+
+            [FieldOffset(8)]
             internal __IntPtr _M_parent;
+
+            [FieldOffset(16)]
             internal __IntPtr _M_left;
+
+            [FieldOffset(24)]
             internal __IntPtr _M_right;
         }
     }
@@ -233,7 +253,7 @@ namespace Std
 {
     namespace CharTraits
     {
-        [StructLayout(LayoutKind.Sequential, Size = 1)]
+        [StructLayout(LayoutKind.Explicit, Size = 1)]
         public unsafe partial struct __Internal
         {
         }
@@ -285,7 +305,7 @@ namespace Std
 
         private static void* __CopyValue(global::Std.CharTraits.__Internal native)
         {
-            var ret = Marshal.AllocHGlobal(sizeof(global::Std.CharTraits.__Internal));
+            var ret = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.CharTraits.__Internal), 16);
             *(global::Std.CharTraits.__Internal*) ret = native;
             return ret.ToPointer();
         }
@@ -318,7 +338,7 @@ namespace Std
             NativeToManagedMap.TryRemove(__Instance, out _);
             DisposePartial(disposing);
             if (__ownsNativeInstance)
-                Marshal.FreeHGlobal(__Instance);
+                __NativeMemory.AlignedFree((void*)__Instance);
             __Instance = IntPtr.Zero;
         }
     }
@@ -352,9 +372,10 @@ namespace Std
 
         namespace AllocHider
         {
-            [StructLayout(LayoutKind.Sequential, Size = 8)]
+            [StructLayout(LayoutKind.Explicit, Size = 8)]
             public unsafe partial struct __Internal
             {
+                [FieldOffset(0)]
                 internal __IntPtr _M_p;
             }
 
@@ -421,7 +442,7 @@ namespace Std
 
         private static void* __CopyValue(global::Std.BasicString.__Internalc__N_std_N___cxx11_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C native)
         {
-            var ret = Marshal.AllocHGlobal(sizeof(global::Std.BasicString.__Internalc__N_std_N___cxx11_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C));
+            var ret = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.BasicString.__Internalc__N_std_N___cxx11_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C), 16);
             *(global::Std.BasicString.__Internalc__N_std_N___cxx11_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C*) ret = native;
             return ret.ToPointer();
         }
@@ -447,7 +468,7 @@ namespace Std
             var ___Alloc = typeof(_Alloc);
             if (___CharT.IsAssignableFrom(typeof(sbyte)) && ___Traits.IsAssignableFrom(typeof(global::Std.CharTraits<sbyte>)) && ___Alloc.IsAssignableFrom(typeof(global::Std.Allocator<sbyte>)))
             {
-                __Instance = Marshal.AllocHGlobal(sizeof(global::Std.BasicString.__Internalc__N_std_N___cxx11_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C));
+                __Instance = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.BasicString.__Internalc__N_std_N___cxx11_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C), 16);
                 __ownsNativeInstance = true;
                 __RecordNativeToManagedMapping(__Instance, this);
                 global::Std.BasicString.__Internalc__N_std_N___cxx11_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C.ctorc__N_std_N___cxx11_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C(__Instance);
@@ -482,7 +503,7 @@ namespace Std
                 throw new ArgumentOutOfRangeException("_CharT, _Traits, _Alloc", string.Join(", ", new[] { typeof(_CharT).FullName, typeof(_Traits).FullName, typeof(_Alloc).FullName }), "global::Std.BasicString<_CharT, _Traits, _Alloc> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
             }
             if (__ownsNativeInstance)
-                Marshal.FreeHGlobal(__Instance);
+                __NativeMemory.AlignedFree((void*)__Instance);
             __Instance = IntPtr.Zero;
         }
     }

src/CppParser/Bindings/CSharp/x86_64-linux-gnu/Std-symbols.cpp

@@ -1,5 +1,6 @@
 #define _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
 #define _LIBCPP_HIDE_FROM_ABI
+#define _LIBCPP_NO_ABI_TAG
 
 #include <string>
 #include <new>

src/CppParser/Bindings/CSharp/x86_64-linux-gnu/Std.cs

@@ -8,6 +8,7 @@ using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Security;
+using __NativeMemory = global::System.Runtime.InteropServices.NativeMemory;
 using __CallingConvention = global::System.Runtime.InteropServices.CallingConvention;
 using __IntPtr = global::System.IntPtr;
 
@@ -22,7 +23,7 @@ namespace Std
 {
     namespace Allocator
     {
-        [StructLayout(LayoutKind.Sequential, Size = 1)]
+        [StructLayout(LayoutKind.Explicit, Size = 1)]
         public unsafe partial struct __Internal
         {
             [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNSaIcEC2Ev", CallingConvention = __CallingConvention.Cdecl)]
@@ -79,7 +80,7 @@ namespace Std
 
         private static void* __CopyValue(global::Std.Allocator.__Internal native)
         {
-            var ret = Marshal.AllocHGlobal(sizeof(global::Std.Allocator.__Internal));
+            var ret = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.Allocator.__Internal), 16);
             *(global::Std.Allocator.__Internal*) ret = native;
             return ret.ToPointer();
         }
@@ -103,7 +104,7 @@ namespace Std
             var ___Tp = typeof(_Tp);
             if (___Tp.IsAssignableFrom(typeof(sbyte)))
             {
-                __Instance = Marshal.AllocHGlobal(sizeof(global::Std.Allocator.__Internal));
+                __Instance = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.Allocator.__Internal), 16);
                 __ownsNativeInstance = true;
                 __RecordNativeToManagedMapping(__Instance, this);
                 global::Std.Allocator.__Internal.ctorc__N_std_S_allocator__C(__Instance);
@@ -136,7 +137,7 @@ namespace Std
                 throw new ArgumentOutOfRangeException("_Tp", string.Join(", ", new[] { typeof(_Tp).FullName }), "global::Std.Allocator<_Tp> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte>.");
             }
             if (__ownsNativeInstance)
-                Marshal.FreeHGlobal(__Instance);
+                __NativeMemory.AlignedFree((void*)__Instance);
             __Instance = IntPtr.Zero;
         }
     }
@@ -146,28 +147,35 @@ namespace Std
 {
     namespace Vector
     {
-        [StructLayout(LayoutKind.Sequential, Size = 24)]
+        [StructLayout(LayoutKind.Explicit, Size = 24)]
         public unsafe partial struct __Internal
         {
+            [FieldOffset(0)]
             internal global::Std.VectorBase.VectorImpl.__Internal _M_impl;
         }
     }
 
     namespace VectorBase
     {
-        [StructLayout(LayoutKind.Sequential, Size = 24)]
+        [StructLayout(LayoutKind.Explicit, Size = 24)]
         public unsafe partial struct __Internal
         {
+            [FieldOffset(0)]
             internal global::Std.VectorBase.VectorImpl.__Internal _M_impl;
         }
 
         namespace VectorImpl
         {
-            [StructLayout(LayoutKind.Sequential, Size = 24)]
+            [StructLayout(LayoutKind.Explicit, Size = 24)]
             public unsafe partial struct __Internal
             {
+                [FieldOffset(0)]
                 internal __IntPtr _M_start;
+
+                [FieldOffset(8)]
                 internal __IntPtr _M_finish;
+
+                [FieldOffset(16)]
                 internal __IntPtr _M_end_of_storage;
             }
 
@@ -175,11 +183,16 @@ namespace Std
 
         namespace VectorImplData
         {
-            [StructLayout(LayoutKind.Sequential, Size = 24)]
+            [StructLayout(LayoutKind.Explicit, Size = 24)]
             public unsafe partial struct __Internal
             {
+                [FieldOffset(0)]
                 internal __IntPtr _M_start;
+
+                [FieldOffset(8)]
                 internal __IntPtr _M_finish;
+
+                [FieldOffset(16)]
                 internal __IntPtr _M_end_of_storage;
             }
         }
@@ -191,7 +204,7 @@ namespace Std
 {
     namespace Less
     {
-        [StructLayout(LayoutKind.Sequential, Size = 1)]
+        [StructLayout(LayoutKind.Explicit, Size = 1)]
         public unsafe partial struct __Internal
         {
         }
@@ -206,12 +219,19 @@ namespace Std
 
     public unsafe partial class RbTreeNodeBase
     {
-        [StructLayout(LayoutKind.Sequential, Size = 32)]
+        [StructLayout(LayoutKind.Explicit, Size = 32)]
         public partial struct __Internal
         {
+            [FieldOffset(0)]
             internal global::Std.RbTreeColor _M_color;
+
+            [FieldOffset(8)]
             internal __IntPtr _M_parent;
+
+            [FieldOffset(16)]
             internal __IntPtr _M_left;
+
+            [FieldOffset(24)]
             internal __IntPtr _M_right;
         }
     }
@@ -233,7 +253,7 @@ namespace Std
 {
     namespace CharTraits
     {
-        [StructLayout(LayoutKind.Sequential, Size = 1)]
+        [StructLayout(LayoutKind.Explicit, Size = 1)]
         public unsafe partial struct __Internal
         {
         }
@@ -285,7 +305,7 @@ namespace Std
 
         private static void* __CopyValue(global::Std.CharTraits.__Internal native)
         {
-            var ret = Marshal.AllocHGlobal(sizeof(global::Std.CharTraits.__Internal));
+            var ret = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.CharTraits.__Internal), 16);
             *(global::Std.CharTraits.__Internal*) ret = native;
             return ret.ToPointer();
         }
@@ -318,7 +338,7 @@ namespace Std
             NativeToManagedMap.TryRemove(__Instance, out _);
             DisposePartial(disposing);
             if (__ownsNativeInstance)
-                Marshal.FreeHGlobal(__Instance);
+                __NativeMemory.AlignedFree((void*)__Instance);
             __Instance = IntPtr.Zero;
         }
     }
@@ -328,9 +348,10 @@ namespace Std
 {
     namespace BasicString
     {
-        [StructLayout(LayoutKind.Sequential, Size = 8)]
+        [StructLayout(LayoutKind.Explicit, Size = 8)]
         public unsafe partial struct __Internal
         {
+            [FieldOffset(0)]
             internal global::Std.BasicString.AllocHider.__Internal _M_dataplus;
 
             [SuppressUnmanagedCodeSecurity, DllImport("Std-symbols", EntryPoint = "_ZNSsC2Ev", CallingConvention = __CallingConvention.Cdecl)]
@@ -342,9 +363,10 @@ namespace Std
 
         namespace AllocHider
         {
-            [StructLayout(LayoutKind.Sequential, Size = 8)]
+            [StructLayout(LayoutKind.Explicit, Size = 8)]
             public unsafe partial struct __Internal
             {
+                [FieldOffset(0)]
                 internal __IntPtr _M_p;
             }
         }
@@ -397,7 +419,7 @@ namespace Std
 
         private static void* __CopyValue(global::Std.BasicString.__Internal native)
         {
-            var ret = Marshal.AllocHGlobal(sizeof(global::Std.BasicString.__Internal));
+            var ret = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.BasicString.__Internal), 16);
             *(global::Std.BasicString.__Internal*) ret = native;
             return ret.ToPointer();
         }
@@ -423,7 +445,7 @@ namespace Std
             var ___Alloc = typeof(_Alloc);
             if (___CharT.IsAssignableFrom(typeof(sbyte)) && ___Traits.IsAssignableFrom(typeof(global::Std.CharTraits<sbyte>)) && ___Alloc.IsAssignableFrom(typeof(global::Std.Allocator<sbyte>)))
             {
-                __Instance = Marshal.AllocHGlobal(sizeof(global::Std.BasicString.__Internal));
+                __Instance = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof(global::Std.BasicString.__Internal), 16);
                 __ownsNativeInstance = true;
                 __RecordNativeToManagedMapping(__Instance, this);
                 global::Std.BasicString.__Internal.ctorc__N_std_S_basic_string__C___N_std_S_char_traits__C___N_std_S_allocator__C(__Instance);
@@ -458,7 +480,7 @@ namespace Std
                 throw new ArgumentOutOfRangeException("_CharT, _Traits, _Alloc", string.Join(", ", new[] { typeof(_CharT).FullName, typeof(_Traits).FullName, typeof(_Alloc).FullName }), "global::Std.BasicString<_CharT, _Traits, _Alloc> maps a C++ template class and therefore it only supports a limited set of types and their subclasses: <sbyte, global::Std.CharTraits<sbyte>, global::Std.Allocator<sbyte>>.");
             }
             if (__ownsNativeInstance)
-                Marshal.FreeHGlobal(__Instance);
+                __NativeMemory.AlignedFree((void*)__Instance);
             __Instance = IntPtr.Zero;
         }
     }

src/CppParser/Bindings/CSharp/x86_64-pc-win32-msvc/Std-symbols.cpp

@@ -1,5 +1,6 @@
 #define _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
 #define _LIBCPP_HIDE_FROM_ABI
+#define _LIBCPP_NO_ABI_TAG
 
 #include <string>
 #include <new>

src/CppParser/Comments.cpp

@@ -41,8 +41,8 @@ RawComment* Parser::WalkRawComment(const clang::RawComment* RC)
     auto& SM = c->getSourceManager();
     auto Comment = new RawComment();
     Comment->kind = ConvertRawCommentKind(RC->getKind());
-    Comment->text = RC->getRawText(SM).str();
-    Comment->briefText = RC->getBriefText(c->getASTContext());
+    Comment->Text = RC->getRawText(SM).str();
+    Comment->BriefText = RC->getBriefText(c->getASTContext());
 
     return Comment;
 }
@@ -96,7 +96,7 @@ static void HandleBlockCommand(const clang::comments::BlockCommandComment *CK,
     for (unsigned I = 0, E = CK->getNumArgs(); I != E; ++I)
     {
         auto Arg = BlockCommandComment::Argument();
-        Arg.text = CK->getArgText(I).str();
+        Arg.Text = CK->getArgText(I).str();
         BC->Arguments.push_back(Arg);
     }
 }
@@ -174,7 +174,7 @@ static Comment* ConvertCommentBlock(clang::comments::Comment* C)
         auto CK = cast<clang::comments::VerbatimLineComment>(C);
         auto VL = new VerbatimLineComment();
         _Comment = VL;
-        VL->text = CK->getText().str();
+        VL->Text = CK->getText().str();
         break;
     }
     case Comment::ParagraphCommentKind:
@@ -196,13 +196,13 @@ static Comment* ConvertCommentBlock(clang::comments::Comment* C)
         auto TC = new HTMLStartTagComment();
         _Comment = TC;
         HandleInlineContent(CK, TC);
-        TC->tagName = CK->getTagName().str();
+        TC->TagName = CK->getTagName().str();
         for (unsigned I = 0, E = CK->getNumAttrs(); I != E; ++I)
         {
             auto A = CK->getAttr(I);
             auto Attr = HTMLStartTagComment::Attribute();
-            Attr.name = A.Name.str();
-            Attr.value = A.Value.str();
+            Attr.Name = A.Name.str();
+            Attr.Value = A.Value.str();
             TC->Attributes.push_back(Attr);
         }
         break;
@@ -213,7 +213,7 @@ static Comment* ConvertCommentBlock(clang::comments::Comment* C)
         auto TC = new HTMLEndTagComment();
         _Comment = TC;
         HandleInlineContent(CK, TC);
-        TC->tagName = CK->getTagName().str();
+        TC->TagName = CK->getTagName().str();
         break;
     }
     case Comment::TextCommentKind:
@@ -222,7 +222,7 @@ static Comment* ConvertCommentBlock(clang::comments::Comment* C)
         auto TC = new TextComment();
         _Comment = TC;
         HandleInlineContent(CK, TC);
-        TC->text = CK->getText().str();
+        TC->Text = CK->getText().str();
         break;
     }
     case Comment::InlineCommandCommentKind:
@@ -236,7 +236,7 @@ static Comment* ConvertCommentBlock(clang::comments::Comment* C)
         for (unsigned I = 0, E = CK->getNumArgs(); I != E; ++I)
         {
             auto Arg = InlineCommandComment::Argument();
-            Arg.text = CK->getArgText(I).str();
+            Arg.Text = CK->getArgText(I).str();
             IC->Arguments.push_back(Arg);
         }       
         break;
@@ -246,7 +246,7 @@ static Comment* ConvertCommentBlock(clang::comments::Comment* C)
         auto CK = cast<clang::comments::VerbatimBlockLineComment>(C);
         auto VL = new VerbatimBlockLineComment();
         _Comment = VL;
-        VL->text = CK->getText().str();
+        VL->Text = CK->getText().str();
         break;
     }
     case Comment::NoCommentKind: return nullptr;

src/CppParser/CppParser.cpp

@@ -23,16 +23,19 @@ CppParserOptions::CppParserOptions()
     , skipPrivateDeclarations(true)
     , skipLayoutInfo(false)
     , skipFunctionBodies(true)
-    , clangVersion(CLANG_VERSION_STRING)
 {
 }
 
 CppParserOptions::~CppParserOptions() {}
 
-std::string CppParserOptions::getClangVersion() { return clangVersion; }
+const char * CppParserOptions::getClangVersion()
+{
+    return CLANG_VERSION_STRING;
+}
 
 DEF_VECTOR_STRING(CppParserOptions, Arguments)
 DEF_VECTOR_STRING(CppParserOptions, CompilationOptions)
+DEF_STRING(CppParserOptions, LibraryFile)
 DEF_VECTOR_STRING(CppParserOptions, SourceFiles)
 DEF_VECTOR_STRING(CppParserOptions, IncludeDirs)
 DEF_VECTOR_STRING(CppParserOptions, SystemIncludeDirs)
@@ -40,6 +43,8 @@ DEF_VECTOR_STRING(CppParserOptions, Defines)
 DEF_VECTOR_STRING(CppParserOptions, Undefines)
 DEF_VECTOR_STRING(CppParserOptions, SupportedStdTypes)
 DEF_VECTOR_STRING(CppParserOptions, SupportedFunctionTemplates)
+DEF_STRING(CppParserOptions, TargetTriple)
+DEF_STRING(ParserTargetInfo, ABI)
 
 ParserResult::ParserResult()
     : targetInfo(0)
@@ -77,8 +82,8 @@ DEF_VECTOR_STRING(CppLinkerOptions, Libraries)
 ParserDiagnostic::ParserDiagnostic() {}
 
 ParserDiagnostic::ParserDiagnostic(const ParserDiagnostic& rhs)
-    : fileName(rhs.fileName)
-    , message(rhs.message)
+    : FileName(rhs.FileName)
+    , Message(rhs.Message)
     , level(rhs.level)
     , lineNumber(rhs.lineNumber)
     , columnNumber(rhs.columnNumber)
@@ -86,4 +91,7 @@ ParserDiagnostic::ParserDiagnostic(const ParserDiagnostic& rhs)
 
 ParserDiagnostic::~ParserDiagnostic() {}
 
+DEF_STRING(ParserDiagnostic, FileName)
+DEF_STRING(ParserDiagnostic, Message)
+
 } }

src/CppParser/CppParser.h

@@ -23,10 +23,12 @@ struct CS_API CppParserOptions
     CppParserOptions();
     ~CppParserOptions();
 
-    std::string getClangVersion();
+    static const char * getClangVersion();
 
     VECTOR_STRING(Arguments)
     VECTOR_STRING(CompilationOptions)
+
+    STRING(LibraryFile)
     // C/C++ header file names.
     VECTOR_STRING(SourceFiles)
 
@@ -41,7 +43,8 @@ struct CS_API CppParserOptions
     CppSharp::CppParser::AST::ASTContext* ASTContext;
 
     int toolSetToUse;
-    std::string targetTriple;
+    STRING(TargetTriple)
+    CppAbi abi;
 
     bool noStandardIncludes;
     bool noBuiltinIncludes;
@@ -51,9 +54,6 @@ struct CS_API CppParserOptions
     bool skipPrivateDeclarations;
     bool skipLayoutInfo;
     bool skipFunctionBodies;
-
-private:
-    std::string clangVersion;
 };
 
 struct CS_API CppLinkerOptions
@@ -80,8 +80,8 @@ struct CS_API ParserDiagnostic
     ParserDiagnostic();
     ParserDiagnostic(const ParserDiagnostic&);
     ~ParserDiagnostic();
-    std::string fileName;
-    std::string message;
+    STRING(FileName)
+    STRING(Message)
     ParserDiagnosticLevel level { ParserDiagnosticLevel::Ignored };
     int lineNumber {0};
     int columnNumber {0};
@@ -124,10 +124,10 @@ public:
     static ParserResult* ParseHeader(CppParserOptions* Opts);
     static ParserResult* ParseLibrary(CppLinkerOptions* Opts);
     static ParserResult* Build(CppParserOptions* Opts,
-        const CppLinkerOptions* LinkerOptions, const std::string& File, bool Last);
-    static ParserResult* Compile(CppParserOptions* Opts, const std::string& File);
+        const CppLinkerOptions* LinkerOptions, const char * File, bool Last);
+    static ParserResult* Compile(CppParserOptions* Opts, const char * File);
     static ParserResult* Link(CppParserOptions* Opts,
-        const CppLinkerOptions* LinkerOptions, const std::string& File, bool Last);
+        const CppLinkerOptions* LinkerOptions, const char * File, bool Last);
 };
 
 } }

src/CppParser/Decl.h

@@ -84,9 +84,9 @@ namespace CppSharp
                 SourceLocation location;
                 int lineNumberStart;
                 int lineNumberEnd;
-                std::string name;
-                std::string USR;
-                std::string debugText;
+                STRING(Name);
+                STRING(USR);
+                STRING(DebugText);
                 bool isIncomplete;
                 bool isDependent;
                 bool isImplicit;
@@ -207,16 +207,16 @@ namespace CppSharp
             class CS_API StatementObsolete
             {
             public:
-                StatementObsolete(const std::string &str, StatementClassObsolete Class = StatementClassObsolete::Any, Declaration *decl = 0);
+                CS_IGNORE StatementObsolete(const std::string &str, StatementClassObsolete Class = StatementClassObsolete::Any, Declaration *decl = 0);
                 StatementClassObsolete _class;
                 Declaration *decl;
-                std::string string;
+                STRING(String);
             };
 
             class CS_API ExpressionObsolete : public StatementObsolete
             {
             public:
-                ExpressionObsolete(const std::string &str, StatementClassObsolete Class = StatementClassObsolete::Any, Declaration *decl = 0);
+                CS_IGNORE ExpressionObsolete(const std::string &str, StatementClassObsolete Class = StatementClassObsolete::Any, Declaration *decl = 0);
             };
 
             class Expr;
@@ -224,17 +224,17 @@ namespace CppSharp
             class CS_API BinaryOperatorObsolete : public ExpressionObsolete
             {
             public:
-                BinaryOperatorObsolete(const std::string &str, ExpressionObsolete *lhs, ExpressionObsolete *rhs, const std::string &opcodeStr);
+                CS_IGNORE BinaryOperatorObsolete(const std::string &str, ExpressionObsolete *lhs, ExpressionObsolete *rhs, const std::string &opcodeStr);
                 ~BinaryOperatorObsolete();
                 ExpressionObsolete *LHS;
                 ExpressionObsolete *RHS;
-                std::string opcodeStr;
+                STRING(OpcodeStr);
             };
 
             class CS_API CallExprObsolete : public ExpressionObsolete
             {
             public:
-                CallExprObsolete(const std::string &str, Declaration *decl);
+                CS_IGNORE CallExprObsolete(const std::string &str, Declaration *decl);
                 ~CallExprObsolete();
                 VECTOR(ExpressionObsolete *, Arguments)
             };
@@ -242,7 +242,7 @@ namespace CppSharp
             class CS_API CXXConstructExprObsolete : public ExpressionObsolete
             {
             public:
-                CXXConstructExprObsolete(const std::string &str, Declaration *decl = 0);
+                CS_IGNORE CXXConstructExprObsolete(const std::string &str, Declaration *decl = 0);
                 ~CXXConstructExprObsolete();
                 VECTOR(ExpressionObsolete *, Arguments)
             };
@@ -350,9 +350,9 @@ namespace CppSharp
                 bool isDefaulted;
                 FriendKind friendKind;
                 CXXOperatorKind operatorKind;
-                std::string mangled;
-                std::string signature;
-                std::string body;
+                STRING(Mangled);
+                STRING(Signature);
+                STRING(Body);
                 Stmt *bodyStmt;
                 CallingConvention callingConvention;
                 VECTOR(Parameter *, Parameters)
@@ -405,7 +405,7 @@ namespace CppSharp
                     DECLARE_DECL_KIND(Item, EnumerationItem)
                     Item(const Item &);
                     ~Item();
-                    std::string expression;
+                    STRING(Expression);
                     uint64_t value;
                 };
 
@@ -421,7 +421,7 @@ namespace CppSharp
                 BuiltinType *builtinType;
                 VECTOR(Item *, Items)
 
-                Item *FindItemByName(const std::string &Name);
+                CS_IGNORE Item *FindItemByName(const std::string &Name);
             };
 
             class CS_API Variable : public Declaration
@@ -430,7 +430,7 @@ namespace CppSharp
                 DECLARE_DECL_KIND(Variable, Variable)
                 ~Variable();
                 bool isConstExpr;
-                std::string mangled;
+                STRING(Mangled);
                 QualifiedType qualifiedType;
                 ExpressionObsolete *initializer;
             };
@@ -522,7 +522,7 @@ namespace CppSharp
                 LayoutField(const LayoutField &other);
                 ~LayoutField();
                 unsigned offset;
-                std::string name;
+                STRING(Name);
                 QualifiedType qualifiedType;
                 void *fieldPtr;
             };
@@ -537,6 +537,9 @@ namespace CppSharp
                 ~LayoutBase();
                 unsigned offset;
                 Class *_class;
+#ifdef __aarch64__
+                unsigned padding;
+#endif
             };
 
             enum class RecordArgABI
@@ -688,8 +691,8 @@ namespace CppSharp
                 ClassTemplate();
                 ~ClassTemplate();
                 VECTOR(ClassTemplateSpecialization *, Specializations)
-                ClassTemplateSpecialization *FindSpecialization(const std::string &usr);
-                ClassTemplatePartialSpecialization *FindPartialSpecialization(const std::string &usr);
+                CS_IGNORE ClassTemplateSpecialization *FindSpecialization(const std::string &usr);
+                CS_IGNORE ClassTemplatePartialSpecialization *FindPartialSpecialization(const std::string &usr);
             };
 
             enum class TemplateSpecializationKind
@@ -725,7 +728,7 @@ namespace CppSharp
                 FunctionTemplate();
                 ~FunctionTemplate();
                 VECTOR(FunctionTemplateSpecialization *, Specializations)
-                FunctionTemplateSpecialization *FindSpecialization(const std::string &usr);
+                CS_IGNORE FunctionTemplateSpecialization *FindSpecialization(const std::string &usr);
             };
 
             class CS_API FunctionTemplateSpecialization
@@ -748,8 +751,8 @@ namespace CppSharp
                 VarTemplate();
                 ~VarTemplate();
                 VECTOR(VarTemplateSpecialization *, Specializations)
-                VarTemplateSpecialization *FindSpecialization(const std::string &usr);
-                VarTemplatePartialSpecialization *FindPartialSpecialization(const std::string &usr);
+                CS_IGNORE VarTemplateSpecialization *FindSpecialization(const std::string &usr);
+                CS_IGNORE VarTemplatePartialSpecialization *FindPartialSpecialization(const std::string &usr);
             };
 
             class CS_API VarTemplateSpecialization : public Variable
@@ -808,8 +811,8 @@ namespace CppSharp
             public:
                 MacroDefinition();
                 ~MacroDefinition();
-                std::string name;
-                std::string expression;
+                STRING(Name);
+                STRING(Expression);
                 int lineNumberStart;
                 int lineNumberEnd;
             };
@@ -819,8 +822,8 @@ namespace CppSharp
             public:
                 MacroExpansion();
                 ~MacroExpansion();
-                std::string name;
-                std::string text;
+                STRING(Name);
+                STRING(Text);
                 MacroDefinition *definition;
             };
 
@@ -829,7 +832,7 @@ namespace CppSharp
             public:
                 TranslationUnit();
                 ~TranslationUnit();
-                std::string fileName;
+                STRING(FileName);
                 bool isSystemHeader;
                 VECTOR(MacroDefinition *, Macros)
             };

src/CppParser/Expr.cpp

@@ -131,6 +131,9 @@ ImaginaryLiteral::ImaginaryLiteral()
 {
 }
 
+DEF_STRING(StringLiteral, String)
+DEF_STRING(StringLiteral, Bytes)
+
 StringLiteral::StringLiteral()
     : Expr(StmtClass::StringLiteral)
     , byteLength(0)
@@ -314,6 +317,8 @@ CStyleCastExpr::CStyleCastExpr()
 {
 }
 
+DEF_STRING(BinaryOperator, OpcodeStr)
+
 BinaryOperator::BinaryOperator()
     : Expr(StmtClass::BinaryOperator)
     , operatorLoc(SourceLocation())
@@ -722,6 +727,8 @@ MSPropertySubscriptExpr::MSPropertySubscriptExpr()
 {
 }
 
+DEF_STRING(CXXUuidofExpr, UuidStr)
+
 CXXUuidofExpr::CXXUuidofExpr()
     : Expr(StmtClass::CXXUuidofExpr)
     , exprOperand(nullptr)

src/CppParser/Expr.h

@@ -7,6 +7,7 @@
 
 #pragma once
 
+#include "Helpers.h"
 #include "Sources.h"
 #include "Types.h"
 #include "Stmt.h"
@@ -438,8 +439,8 @@ public:
     };
 
     StringLiteral();
-    std::string string;
-    std::string bytes;
+    STRING(String);
+    STRING(Bytes);
     unsigned int byteLength;
     unsigned int length;
     unsigned int charByteWidth;
@@ -630,7 +631,7 @@ public:
     BinaryOperatorKind opcode;
     Expr* lHS;
     Expr* rHS;
-    std::string opcodeStr;
+    STRING(OpcodeStr);
     bool isPtrMemOp;
     bool isMultiplicativeOp;
     bool isAdditiveOp;
@@ -1116,7 +1117,7 @@ class CS_API CXXUuidofExpr : public Expr
 public:
     CXXUuidofExpr();
     Expr* exprOperand;
-    std::string uuidStr;
+    STRING(UuidStr);
     bool isTypeOperand;
 };
 

src/CppParser/Helpers.h

@@ -53,3 +53,13 @@
     void klass::add##name (const char* s) { return name.push_back(std::string(s)); } \
     unsigned klass::get##name##Count () { return name.size(); } \
     void klass::clear##name() { name.clear(); }
+
+#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; }
+

src/CppParser/Link.cpp

@@ -18,7 +18,7 @@ LLD_HAS_DRIVER(macho)
 
 using namespace CppSharp::CppParser;
 
-bool Parser::Link(const std::string& File, const CppLinkerOptions* LinkerOptions)
+bool Parser::Link(const char * File, const CppLinkerOptions* LinkerOptions)
 {
     std::vector<const char*> args;
     llvm::StringRef Dir(llvm::sys::path::parent_path(File));

src/CppParser/ParseExpr.cpp

@@ -217,8 +217,8 @@ AST::Expr* Parser::WalkExpression(const clang::Expr* Expr)
         _S->sourceBitField = static_cast<AST::Field*>(WalkDeclaration(S->getSourceBitField()));
         _S->referencedDeclOfCallee = static_cast<AST::Declaration*>(WalkDeclaration(S->getReferencedDeclOfCallee()));
         _S->hasPlaceholderType = S->hasPlaceholderType();
-        _S->string = S->getString().str();
-        _S->bytes = S->getBytes().str();
+        _S->String = S->getString();
+        _S->Bytes = S->getBytes();
         _S->byteLength = S->getByteLength();
         _S->length = S->getLength();
         _S->charByteWidth = S->getCharByteWidth();
@@ -537,7 +537,7 @@ AST::Expr* Parser::WalkExpression(const clang::Expr* Expr)
         _S->opcode = (BinaryOperatorKind) S->getOpcode();
         _S->lHS = static_cast<AST::Expr*>(WalkExpression(S->getLHS()));
         _S->rHS = static_cast<AST::Expr*>(WalkExpression(S->getRHS()));
-        _S->opcodeStr = S->getOpcodeStr().str();
+        _S->OpcodeStr = S->getOpcodeStr();
         _S->isPtrMemOp = S->isPtrMemOp();
         _S->isMultiplicativeOp = S->isMultiplicativeOp();
         _S->isAdditiveOp = S->isAdditiveOp();
@@ -575,7 +575,7 @@ AST::Expr* Parser::WalkExpression(const clang::Expr* Expr)
         _S->opcode = (BinaryOperatorKind) S->getOpcode();
         _S->lHS = static_cast<AST::Expr*>(WalkExpression(S->getLHS()));
         _S->rHS = static_cast<AST::Expr*>(WalkExpression(S->getRHS()));
-        _S->opcodeStr = S->getOpcodeStr().str();
+        _S->OpcodeStr = S->getOpcodeStr();
         _S->isPtrMemOp = S->isPtrMemOp();
         _S->isMultiplicativeOp = S->isMultiplicativeOp();
         _S->isAdditiveOp = S->isAdditiveOp();
@@ -1552,7 +1552,7 @@ AST::Expr* Parser::WalkExpression(const clang::Expr* Expr)
         _S->referencedDeclOfCallee = static_cast<AST::Declaration*>(WalkDeclaration(S->getReferencedDeclOfCallee()));
         _S->hasPlaceholderType = S->hasPlaceholderType();
         _S->exprOperand = static_cast<AST::Expr*>(WalkExpression(S->getExprOperand()));
-        _S->uuidStr = S->getGuidDecl()->getNameAsString();
+        _S->UuidStr = S->getGuidDecl()->getNameAsString();
         _S->isTypeOperand = S->isTypeOperand();
         _Expr = _S;
         break;

src/CppParser/ParseStmt.cpp

@@ -244,7 +244,7 @@ AST::Stmt* Parser::WalkStatement(const clang::Stmt* Stmt)
         }
         _S->hasBraces = S->hasBraces();
         _S->numAsmToks = S->getNumAsmToks();
-        _S->asmString = S->getAsmString().str();
+        _S->AsmString = S->getAsmString();
         _Stmt = _S;
         break;
     }

src/CppParser/Parser.cpp

@@ -142,7 +142,7 @@ LayoutField Parser::WalkVTablePointer(Class* Class,
 {
     LayoutField LayoutField;
     LayoutField.offset = Offset.getQuantity();
-    LayoutField.name = prefix + "_" + Class->name;
+    LayoutField.Name = prefix + "_" + Class->Name;
     LayoutField.qualifiedType = GetQualifiedType(c->getASTContext().VoidPtrTy);
     return LayoutField;
 }
@@ -246,7 +246,7 @@ void Parser::ReadClassLayout(Class* Class, const clang::RecordDecl* RD,
         auto F = WalkFieldCXX(Field, Parent);
         LayoutField LayoutField;
         LayoutField.offset = FieldOffset.getQuantity();
-        LayoutField.name = F->name;
+        LayoutField.Name = F->Name;
         LayoutField.qualifiedType = GetQualifiedType(Field->getType());
         LayoutField.fieldPtr = (void*)Field;
         Class->layout->Fields.push_back(LayoutField);
@@ -343,9 +343,9 @@ void Parser::Setup(bool Compile)
 
     auto& TO = Inv->TargetOpts;
 
-    if (opts->targetTriple.empty())
-        opts->targetTriple = llvm::sys::getDefaultTargetTriple();
-    TO->Triple = llvm::Triple::normalize(opts->targetTriple);
+    if (opts->TargetTriple.empty())
+        opts->TargetTriple = llvm::sys::getDefaultTargetTriple();
+    TO->Triple = llvm::Triple::normalize(opts->TargetTriple);
 
     if (opts->verbose)
         printf("Target triple: %s\n", TO->Triple.c_str());
@@ -355,8 +355,8 @@ void Parser::Setup(bool Compile)
     {
         // We might have no target info due to an invalid user-provided triple.
         // Try again with the default triple.
-        opts->targetTriple = llvm::sys::getDefaultTargetTriple();
-        TO->Triple = llvm::Triple::normalize(opts->targetTriple);
+        opts->TargetTriple = llvm::sys::getDefaultTargetTriple();
+        TO->Triple = llvm::Triple::normalize(opts->TargetTriple);
         TI = TargetInfo::CreateTargetInfo(c->getDiagnostics(), TO);
     }
 
@@ -1317,7 +1317,7 @@ Parser::WalkClassTemplateSpecialization(const clang::ClassTemplateSpecialization
     auto NS = GetNamespace(CTS);
     assertm(NS, "Expected a valid namespace!\n");
     TS->_namespace = NS;
-    TS->name = CTS->getName().str();
+    TS->Name = CTS->getName().str();
     TS->templatedDecl = CT;
     TS->specializationKind = WalkTemplateSpecializationKind(CTS->getSpecializationKind());
     CT->Specializations.push_back(TS);
@@ -1372,7 +1372,7 @@ Parser::WalkClassTemplatePartialSpecialization(const clang::ClassTemplatePartial
     auto NS = GetNamespace(CTS);
     assertm(NS, "Expected a valid namespace!\n");
     TS->_namespace = NS;
-    TS->name = CTS->getName().str();
+    TS->Name = CTS->getName();
     TS->templatedDecl = CT;
     TS->specializationKind = WalkTemplateSpecializationKind(CTS->getSpecializationKind());
     CT->Specializations.push_back(TS);
@@ -1436,7 +1436,7 @@ ClassTemplate* Parser::WalkClassTemplate(const clang::ClassTemplateDecl* TD)
     CT = new ClassTemplate();
     HandleDeclaration(TD, CT);
 
-    CT->name = GetDeclName(TD);
+    CT->Name = GetDeclName(TD);
     CT->_namespace = NS;
     NS->Templates.push_back(CT);
 
@@ -1484,7 +1484,7 @@ TypeTemplateParameter* Parser::WalkTypeTemplateParameter(const clang::TemplateTy
         return TP;
 
     TP = new CppSharp::CppParser::TypeTemplateParameter();
-    TP->name = GetDeclName(TTPD);
+    TP->Name = GetDeclName(TTPD);
     HandleDeclaration(TTPD, TP);
     if (TTPD->hasDefaultArgument())
         TP->defaultArgument = GetQualifiedType(TTPD->getDefaultArgument());
@@ -1504,7 +1504,7 @@ NonTypeTemplateParameter* Parser::WalkNonTypeTemplateParameter(const clang::NonT
         return NTP;
 
     NTP = new CppSharp::CppParser::NonTypeTemplateParameter();
-    NTP->name = GetDeclName(NTTPD);
+    NTP->Name = GetDeclName(NTTPD);
     HandleDeclaration(NTTPD, NTP);
     if (NTTPD->hasDefaultArgument())
         NTP->defaultArgument = WalkExpressionObsolete(NTTPD->getDefaultArgument());
@@ -1665,7 +1665,7 @@ TypeAliasTemplate* Parser::WalkTypeAliasTemplate(
     TA = new TypeAliasTemplate();
     HandleDeclaration(TD, TA);
 
-    TA->name = GetDeclName(TD);
+    TA->Name = GetDeclName(TD);
     NS->Templates.push_back(TA);
 
     TA->TemplatedDecl = WalkDeclaration(TD->getTemplatedDecl());
@@ -1703,7 +1703,7 @@ FunctionTemplate* Parser::WalkFunctionTemplate(const clang::FunctionTemplateDecl
     FT = new FunctionTemplate();
     HandleDeclaration(TD, FT);
 
-    FT->name = GetDeclName(TD);
+    FT->Name = GetDeclName(TD);
     FT->_namespace = NS;
     FT->TemplatedDecl = F;
     FT->Parameters = WalkTemplateParameterList(TD->getTemplateParameters());
@@ -1777,7 +1777,7 @@ VarTemplate* Parser::WalkVarTemplate(const clang::VarTemplateDecl* TD)
     VT = new VarTemplate();
     HandleDeclaration(TD, VT);
 
-    VT->name = GetDeclName(TD);
+    VT->Name = GetDeclName(TD);
     VT->_namespace = NS;
     NS->Templates.push_back(VT);
 
@@ -1805,7 +1805,7 @@ Parser::WalkVarTemplateSpecialization(const clang::VarTemplateSpecializationDecl
     auto NS = GetNamespace(VTS);
     assertm(NS, "Expected a valid namespace!\n");
     TS->_namespace = NS;
-    TS->name = VTS->getName().str();
+    TS->Name = VTS->getName();
     TS->templatedDecl = VT;
     TS->specializationKind = WalkTemplateSpecializationKind(VTS->getSpecializationKind());
     VT->Specializations.push_back(TS);
@@ -1845,7 +1845,7 @@ Parser::WalkVarTemplatePartialSpecialization(const clang::VarTemplatePartialSpec
     auto NS = GetNamespace(VTS);
     assertm(NS, "Expected a valid namespace!\n");
     TS->_namespace = NS;
-    TS->name = VTS->getName().str();
+    TS->Name = VTS->getName();
     TS->templatedDecl = VT;
     TS->specializationKind = WalkTemplateSpecializationKind(VTS->getSpecializationKind());
     VT->Specializations.push_back(TS);
@@ -2022,7 +2022,7 @@ Field* Parser::WalkFieldCXX(const clang::FieldDecl* FD, Class* Class)
     HandleDeclaration(FD, F);
 
     F->_namespace = Class;
-    F->name = FD->getName().str();
+    F->Name = FD->getName();
     auto TL = FD->getTypeSourceInfo()->getTypeLoc();
     F->qualifiedType = GetQualifiedType(FD->getType(), &TL);
     F->access = ConvertToAccess(FD->getAccess());
@@ -2648,7 +2648,7 @@ Type* Parser::WalkType(clang::QualType QualType, const clang::TypeLoc* TL,
             {
                 auto FA = new Parameter();
                 auto Arg = FP->getParamType(i);
-                FA->name = "";
+                FA->Name = "";
                 FA->qualifiedType = GetQualifiedType(Arg);
 
                 // In this case we have no valid value to use as a pointer so
@@ -2784,7 +2784,7 @@ Type* Parser::WalkType(clang::QualType QualType, const clang::TypeLoc* TL,
         auto TPT = new CppSharp::CppParser::TemplateParameterType();
 
         if (auto Ident = TP->getIdentifier())
-            TPT->parameter->name = Ident->getName().str();
+            TPT->parameter->Name = Ident->getName();
 
         TypeLoc UTL, ETL, ITL, Next;
 
@@ -2885,7 +2885,7 @@ Type* Parser::WalkType(clang::QualType QualType, const clang::TypeLoc* TL,
         }
         default: break;
         }
-        DNT->identifier = DN->getIdentifier()->getName().str();
+        DNT->Identifier = DN->getIdentifier()->getName();
 
         Ty = DNT;
         break;
@@ -3036,7 +3036,7 @@ Enumeration* Parser::WalkEnum(const clang::EnumDecl* ED)
         else
         {
             E = new Enumeration();
-            E->name = Name;
+            E->Name = Name;
             E->_namespace = NS;
             NS->Enums.push_back(E);
         }
@@ -3073,7 +3073,7 @@ Enumeration::Item* Parser::WalkEnumItem(clang::EnumConstantDecl* ECD)
     auto EnumItem = new Enumeration::Item();
     HandleDeclaration(ECD, EnumItem);
 
-    EnumItem->name = ECD->getNameAsString();
+    EnumItem->Name = ECD->getNameAsString();
     auto Value = ECD->getInitVal();
     EnumItem->value = Value.isSigned() ? Value.getSExtValue()
         : Value.getZExtValue();
@@ -3081,7 +3081,7 @@ Enumeration::Item* Parser::WalkEnumItem(clang::EnumConstantDecl* ECD)
 
     std::string Text;
     if (GetDeclText(ECD->getSourceRange(), Text))
-        EnumItem->expression = Text;
+        EnumItem->Expression = Text;
 
     return EnumItem;
 }
@@ -3213,7 +3213,7 @@ Parameter* Parser::WalkParameter(const clang::ParmVarDecl* PVD,
         return P;
 
     P = new Parameter();
-    P->name = PVD->getNameAsString();
+    P->Name = PVD->getNameAsString();
 
     TypeLoc PTL;
     if (auto TSI = PVD->getTypeSourceInfo())
@@ -3248,16 +3248,16 @@ Parameter* Parser::WalkParameter(const clang::ParmVarDecl* PVD,
 
 void Parser::SetBody(const clang::FunctionDecl* FD, Function* F)
 {
-    F->body = GetFunctionBody(FD);
+    F->Body = GetFunctionBody(FD);
     F->isInline = FD->isInlined();
-    if (!F->body.empty() && F->isInline)
+    if (!F->Body.empty() && F->isInline)
         return;
     for (const auto& R : FD->redecls())
     {
-        if (F->body.empty())
-            F->body = GetFunctionBody(R);
+        if (F->Body.empty())
+            F->Body = GetFunctionBody(R);
         F->isInline |= R->isInlined();
-        if (!F->body.empty() && F->isInline)
+        if (!F->Body.empty() && F->isInline)
             break;
     }
 }
@@ -3353,7 +3353,7 @@ void Parser::WalkFunction(const clang::FunctionDecl* FD, Function* F)
     auto NS = GetNamespace(FD);
     assertm(NS, "Expected a valid namespace!\n");
 
-    F->name = FD->getNameAsString();
+    F->Name = FD->getNameAsString();
     F->_namespace = NS;
     F->isConstExpr = FD->isConstexpr();
     F->isVariadic = FD->isVariadic();
@@ -3398,10 +3398,10 @@ void Parser::WalkFunction(const clang::FunctionDecl* FD, Function* F)
     F->returnType = GetQualifiedType(ReturnType, &RTL);
 
     const auto& Mangled = GetDeclMangledName(FD);
-    F->mangled = Mangled;
+    F->Mangled = Mangled;
 
     const auto& Body = GetFunctionBody(FD);
-    F->body = Body;
+    F->Body = Body;
 
     clang::SourceLocation ParamStartLoc = FD->getBeginLoc();
     clang::SourceLocation ResultLoc;
@@ -3431,7 +3431,7 @@ void Parser::WalkFunction(const clang::FunctionDecl* FD, Function* F)
 
     std::string Sig;
     if (GetDeclText(Range, Sig))
-        F->signature = Sig;
+        F->Signature = Sig;
 
     for (auto VD : FD->parameters())
     {
@@ -3561,7 +3561,7 @@ void Parser::WalkVariable(const clang::VarDecl* VD, Variable* Var)
     HandleDeclaration(VD, Var);
 
     Var->isConstExpr = VD->isConstexpr();
-    Var->name = VD->getName().str();
+    Var->Name = VD->getName();
     Var->access = ConvertToAccess(VD->getAccess());
 
     auto Init = VD->getAnyInitializer();
@@ -3572,7 +3572,7 @@ void Parser::WalkVariable(const clang::VarDecl* VD, Variable* Var)
     Var->qualifiedType = GetQualifiedType(VD->getType(), &TL);
 
     auto Mangled = GetDeclMangledName(VD);
-    Var->mangled = Mangled;
+    Var->Mangled = Mangled;
 }
 
 Variable* Parser::WalkVariable(const clang::VarDecl *VD)
@@ -3675,7 +3675,7 @@ PreprocessedEntity* Parser::WalkPreprocessedEntity(
         std::string Text;
         GetDeclText(PPEntity->getSourceRange(), Text);
 
-        static_cast<MacroExpansion*>(Entity)->text = Text;
+        static_cast<MacroExpansion*>(Entity)->Text = Text;
         break;
     }
     case clang::PreprocessedEntity::MacroDefinitionKind:
@@ -3719,8 +3719,8 @@ PreprocessedEntity* Parser::WalkPreprocessedEntity(
         Definition->lineNumberEnd = SM.getExpansionLineNumber(MD->getLocation());
         Entity = Definition;
 
-        Definition->name = II->getName().trim().str();
-        Definition->expression = Expression.trim().str();
+        Definition->Name = II->getName().trim();
+        Definition->Expression = Expression.trim();
     }
     case clang::PreprocessedEntity::InclusionDirectiveKind:
         // nothing to be done for InclusionDirectiveKind
@@ -3770,7 +3770,7 @@ AST::ExpressionObsolete* Parser::WalkExpressionObsolete(const clang::Expr* Expr)
         auto BinaryOperator = cast<clang::BinaryOperator>(Expr);
         return new AST::BinaryOperatorObsolete(GetStringFromStatement(Expr),
             WalkExpressionObsolete(BinaryOperator->getLHS()), WalkExpressionObsolete(BinaryOperator->getRHS()),
-            BinaryOperator->getOpcodeStr().str());
+            BinaryOperator->getOpcodeStr().str().c_str());
     }
     case clang::Stmt::CallExprClass:
     {
@@ -3987,7 +3987,7 @@ void Parser::HandleOriginalText(const clang::Decl* D, Declaration* Decl)
     auto DeclText = clang::Lexer::getSourceText(Range, SM, LangOpts, &Invalid);
     
     if (!Invalid)
-        Decl->debugText = DeclText.str();
+        Decl->DebugText = DeclText;
 }
 
 void Parser::HandleDeclaration(const clang::Decl* D, Declaration* Decl)
@@ -4396,8 +4396,8 @@ void Parser::HandleDiagnostics(ParserResult* res)
         auto FileName = Source.getFilename(Source.getFileLoc(Diag.Location));
 
         auto PDiag = ParserDiagnostic();
-        PDiag.fileName = FileName.str();
-        PDiag.message = Diag.Message.str().str();
+        PDiag.FileName = FileName.str();
+        PDiag.Message = Diag.Message.str();
         PDiag.lineNumber = 0;
         PDiag.columnNumber = 0;
 
@@ -4567,7 +4567,7 @@ ParserResultKind Parser::ParseArchive(const std::string& File,
                                       std::vector<CppSharp::CppParser::NativeLibrary*>& NativeLibs)
 {
     auto NativeLib = new NativeLibrary();
-    NativeLib->fileName = File;
+    NativeLib->FileName = File;
 
     for (const auto& Symbol : Archive->symbols())
     {
@@ -4604,7 +4604,7 @@ ParserResultKind Parser::ParseSharedLib(const std::string& File,
                                         std::vector<CppSharp::CppParser::NativeLibrary*>& NativeLibs)
 {
     auto NativeLib = new NativeLibrary();
-    NativeLib->fileName = File;
+    NativeLib->FileName = File;
     NativeLib->archType = ConvertArchType(ObjectFile->getArch());
     NativeLibs.push_back(NativeLib);
 
@@ -4702,7 +4702,7 @@ ParserResultKind Parser::ReadSymbols(llvm::StringRef File,
 {
     auto LibName = File;
     NativeLib = new NativeLibrary();
-    NativeLib->fileName = LibName.str();
+    NativeLib->FileName = LibName;
 
     for (auto it = Begin; it != End; ++it)
     {
@@ -4771,8 +4771,8 @@ ParserResult* Parser::ParseLibrary(const CppLinkerOptions* Opts)
         {
             auto ErrMsg = llvm::toString(BinaryOrErr.takeError());
             auto Diag = ParserDiagnostic();
-            Diag.fileName = FileEntry;
-            Diag.message = ErrMsg;
+            Diag.FileName = FileEntry;
+            Diag.Message = ErrMsg;
             Diag.level = ParserDiagnosticLevel::Error;
             res->Diagnostics.push_back(Diag);
 
@@ -4800,7 +4800,7 @@ ParserResult* Parser::ParseLibrary(const CppLinkerOptions* Opts)
     return res;
 }
 
-ParserResult* Parser::Build(const CppLinkerOptions* LinkerOptions, const std::string& File, bool Last)
+ParserResult* Parser::Build(const CppLinkerOptions* LinkerOptions, const char * File, bool Last)
 {
     ParserResult* error = Compile(File);
     if (error)
@@ -4863,7 +4863,7 @@ ParserResult* ClangParser::ParseLibrary(CppLinkerOptions* Opts)
 }
 
 ParserResult* ClangParser::Build(CppParserOptions* Opts,
-    const CppLinkerOptions* LinkerOptions, const std::string& File, bool Last)
+    const CppLinkerOptions* LinkerOptions, const char * File, bool Last)
 {
     if (!Opts)
         return 0;
@@ -4873,7 +4873,7 @@ ParserResult* ClangParser::Build(CppParserOptions* Opts,
 }
 
 ParserResult* ClangParser::Compile(CppParserOptions* Opts,
-    const std::string& File)
+    const char * File)
 {
     if (!Opts)
         return 0;
@@ -4883,7 +4883,7 @@ ParserResult* ClangParser::Compile(CppParserOptions* Opts,
 }
 
 ParserResult* ClangParser::Link(CppParserOptions* Opts,
-    const CppLinkerOptions* LinkerOptions, const std::string& File, bool Last)
+    const CppLinkerOptions* LinkerOptions, const char * File, bool Last)
 {
     if (!Opts)
         return 0;
@@ -4905,7 +4905,7 @@ ParserResult* ClangParser::Link(CppParserOptions* Opts,
     return res;
 }
 
-ParserResult* Parser::Compile(const std::string& File)
+ParserResult* Parser::Compile(const char * File)
 {
     llvm::InitializeAllAsmPrinters();
     llvm::StringRef Stem = llvm::sys::path::stem(File);

src/CppParser/Parser.h

@@ -56,9 +56,9 @@ public:
     void Setup(bool Compile = false);
     ParserResult* Parse(const std::vector<std::string>& SourceFiles);
     static ParserResult* ParseLibrary(const CppLinkerOptions* Opts);
-    ParserResult* Build(const CppLinkerOptions* LinkerOptions, const std::string& File, bool Last);
-    ParserResult* Compile(const std::string& File);
-    bool Link(const std::string& File, const CppLinkerOptions* LinkerOptions);
+    ParserResult* Build(const CppLinkerOptions* LinkerOptions, const char * File, bool Last);
+    ParserResult* Compile(const char * File);
+    bool Link(const char * File, const CppLinkerOptions* LinkerOptions);
     void WalkAST(clang::TranslationUnitDecl* TU);
     void HandleDeclaration(const clang::Decl* D, Declaration* Decl);
     CppParserOptions* opts;

src/CppParser/ParserGen/ParserGen.cs

@@ -4,6 +4,7 @@ using System.IO;
 using System.Linq;
 using CppSharp.AST;
 using CppSharp.Generators;
+using CppSharp.Generators.C;
 using CppSharp.Parser;
 using CppSharp.Passes;
 using CppAbi = CppSharp.Parser.AST.CppAbi;
@@ -120,6 +121,7 @@ namespace CppSharp
 
         public void SetupPasses(Driver driver)
         {
+            driver.AddTranslationUnitPass(new IgnoreStdFieldsPass());
         }
 
         public void Preprocess(Driver driver, ASTContext ctx)
@@ -166,24 +168,32 @@ namespace CppSharp
                 ConsoleDriver.Run(new ParserGen(GeneratorKind.CSharp, "x86_64-pc-win32-msvc"));
                 Console.WriteLine();
             }
+            else
+            {
+                Console.WriteLine("Skipping generation for Windows due to missing headers, only supported on Windows platform.");
+            }
 
-            var osxHeadersPath = Path.Combine(GetSourceDirectory("build"), @"headers\osx");
+            var osxHeadersPath = Path.Combine(GetSourceDirectory("build"), @"headers", "osx");
             if (Directory.Exists(osxHeadersPath) || Platform.IsMacOS)
             {
-                Console.WriteLine("Generating the C# parser bindings for OSX x86...");
-                ConsoleDriver.Run(new ParserGen(GeneratorKind.CSharp, "i686-apple-darwin12.4.0"));
+                Console.WriteLine("Generating the C# parser bindings for macOS x86...");
+                ConsoleDriver.Run(new ParserGen(GeneratorKind.CSharp, "i686-apple-darwin"));
                 Console.WriteLine();
 
-                Console.WriteLine("Generating the C# parser bindings for OSX x64...");
-                ConsoleDriver.Run(new ParserGen(GeneratorKind.CSharp, "x86_64-apple-darwin12.4.0"));
+                Console.WriteLine("Generating the C# parser bindings for macOS x64...");
+                ConsoleDriver.Run(new ParserGen(GeneratorKind.CSharp, "x86_64-apple-darwin"));
                 Console.WriteLine();
 
-                Console.WriteLine("Generating the C# parser bindings for OSX ARM64...");
-                ConsoleDriver.Run(new ParserGen(GeneratorKind.CSharp, "arm64-apple-darwin12.4.0"));
+                Console.WriteLine("Generating the C# parser bindings for macOS ARM64...");
+                ConsoleDriver.Run(new ParserGen(GeneratorKind.CSharp, "arm64-apple-darwin"));
                 Console.WriteLine();
             }
+            else
+            {
+                Console.WriteLine("Skipping generation for macOS due to missing headers.");
+            }
 
-            var linuxHeadersPath = Path.Combine(GetSourceDirectory("build"), @"headers\x86_64-linux-gnu");
+            var linuxHeadersPath = Path.Combine(GetSourceDirectory("build"), @"headers", "x86_64-linux-gnu");
             if (Directory.Exists(linuxHeadersPath) || Platform.IsLinux)
             {
                 Console.WriteLine("Generating the C# parser bindings for Linux...");
@@ -204,6 +214,46 @@ namespace CppSharp
                     isGnuCpp11Abi: true));
                 Console.WriteLine();
             }
+            else
+            {
+                Console.WriteLine("Skipping generation for Linux due to missing headers.");
+            }
+        }
+    }
+
+    public class IgnoreStdFieldsPass : TranslationUnitPass
+    {
+        public override bool VisitFieldDecl(Field field)
+        {
+            if (!field.IsGenerated)
+                return false;
+
+            if (!IsStdType(field.QualifiedType)) return false;
+
+            field.ExplicitlyIgnore();
+            return true;
+        }
+
+        public override bool VisitFunctionDecl(Function function)
+        {
+            if (function.GenerationKind == GenerationKind.None)
+                return false;
+
+            if (function.Parameters.Any(param => IsStdType(param.QualifiedType)))
+            {
+                function.ExplicitlyIgnore();
+                return false;
+            }
+
+            return true;
+        }
+
+        private bool IsStdType(QualifiedType type)
+        {
+            var typePrinter = new CppTypePrinter(Context);
+            var typeName = type.Visit(typePrinter);
+
+            return typeName.Type.Contains("std::");
         }
     }
 }

src/CppParser/Stmt.cpp

@@ -228,6 +228,8 @@ DEF_VECTOR(AsmStmt, Expr*, inputs)
 
 DEF_VECTOR(AsmStmt, Expr*, outputs)
 
+DEF_STRING(GCCAsmStmt::AsmStringPiece, String)
+
 GCCAsmStmt::AsmStringPiece::AsmStringPiece()
 {
 }
@@ -238,6 +240,8 @@ GCCAsmStmt::GCCAsmStmt()
 {
 }
 
+DEF_STRING(MSAsmStmt, AsmString)
+
 MSAsmStmt::MSAsmStmt()
     : AsmStmt(StmtClass::MSAsmStmt)
     , lBraceLoc(SourceLocation())

src/CppParser/Stmt.h

@@ -372,7 +372,7 @@ public:
         AsmStringPiece();
         bool isString;
         bool isOperand;
-        std::string string;
+        STRING(String);
         unsigned int operandNo;
         char modifier;
     };
@@ -388,7 +388,7 @@ public:
     SourceLocation lBraceLoc;
     bool hasBraces;
     unsigned int numAsmToks;
-    std::string asmString;
+    STRING(AsmString);
 };
 
 class CS_API SEHExceptStmt : public Stmt

src/CppParser/Target.h

@@ -30,7 +30,8 @@ struct CS_API ParserTargetInfo
 {
     ParserTargetInfo();
     ~ParserTargetInfo();
-    std::string ABI;
+
+    STRING(ABI);
 
     ParserIntType char16Type;
     ParserIntType char32Type;

src/CppParser/Types.h

@@ -45,6 +45,9 @@ public:
 
     TypeKind kind;
     bool isDependent;
+#ifdef __aarch64__
+    unsigned padding;
+#endif
 };
 
 struct CS_API TypeQualifiers
@@ -259,7 +262,7 @@ public:
     DECLARE_TYPE_KIND(DependentName)
     ~DependentNameType();
     QualifiedType qualifier;
-    std::string identifier;
+    STRING(Identifier);
 };
 
 class CS_API PackExpansionType : public Type

src/Generator/Generators/CSharp/CSharpSources.cs

@@ -172,6 +172,7 @@ namespace CppSharp.Generators.CSharp
             foreach (var @namespace in requiredNameSpaces.Union(Options.DependentNameSpaces).OrderBy(x => x))
                 WriteLine($"using {@namespace};");
 
+            WriteLine("using __NativeMemory = global::System.Runtime.InteropServices.NativeMemory;");
             WriteLine("using __CallingConvention = global::System.Runtime.InteropServices.CallingConvention;");
             WriteLine("using __IntPtr = global::System.IntPtr;");
 
@@ -2394,7 +2395,7 @@ internal static bool {Helpers.TryGetNativeToManagedMappingIdentifier}(IntPtr nat
             {
                 string name = prop.Field.OriginalName;
                 WriteLine($"if (__{name}_OwnsNativeMemory)");
-                WriteLineIndent($"Marshal.FreeHGlobal({ptr}->{name});");
+                WriteLineIndent($"__NativeMemory.AlignedFree((void*){ptr}->{name});");
             }
 
             if (@class.IsValueType)
@@ -2404,7 +2405,7 @@ internal static bool {Helpers.TryGetNativeToManagedMappingIdentifier}(IntPtr nat
             else
             {
                 WriteLine("if ({0})", Helpers.OwnsNativeInstanceIdentifier);
-                WriteLineIndent("Marshal.FreeHGlobal({0});", Helpers.InstanceIdentifier);
+                WriteLineIndent("__NativeMemory.AlignedFree((void*){0});", Helpers.InstanceIdentifier);
 
                 WriteLine("{0} = IntPtr.Zero;", Helpers.InstanceIdentifier);
             }
@@ -2606,14 +2607,14 @@ internal static{(@new ? " new" : string.Empty)} {printedClass} __GetInstance({Ty
                     string defaultValue = string.Empty;
                     if (copyCtorMethod.Parameters.Count > 1)
                         defaultValue = $", {ExpressionPrinter.VisitParameter(copyCtorMethod.Parameters.Last())}";
-                    WriteLine($@"var ret = Marshal.AllocHGlobal(sizeof({@internal}));");
+                    WriteLine($@"var ret = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof({@internal}), 16);");
                     WriteLine($@"{printed}.{GetFunctionNativeIdentifier(copyCtorMethod)}(ret, new {TypePrinter.IntPtrType}(&native){defaultValue});",
                         printed, GetFunctionNativeIdentifier(copyCtorMethod));
                     WriteLine("return ret.ToPointer();");
                 }
                 else
                 {
-                    WriteLine($"var ret = Marshal.AllocHGlobal(sizeof({@internal}));");
+                    WriteLine($"var ret = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof({@internal}), 16);");
                     WriteLine($"*({@internal}*) ret = native;");
                     WriteLine("return ret.ToPointer();");
                 }
@@ -3041,7 +3042,7 @@ internal static{(@new ? " new" : string.Empty)} {printedClass} __GetInstance({Ty
 
             var @internal = TypePrinter.PrintNative(
                 @class.IsAbstractImpl ? @class.BaseClass : @class);
-            WriteLine($"{Helpers.InstanceIdentifier} = Marshal.AllocHGlobal(sizeof({@internal}));");
+            WriteLine($"{Helpers.InstanceIdentifier} = (nint)__NativeMemory.AlignedAlloc((nuint)sizeof({@internal}), 16);");
             WriteLine($"{Helpers.OwnsNativeInstanceIdentifier} = true;");
 
             if (generateNativeToManaged)
@@ -3223,7 +3224,7 @@ internal static{(@new ? " new" : string.Empty)} {printedClass} __GetInstance({Ty
             if (method != null && !method.IsConstructor && method.OriginalFunction != null &&
                 ((Method)method.OriginalFunction).IsConstructor)
             {
-                WriteLine($@"Marshal.AllocHGlobal({((Class)method.OriginalNamespace).Layout.Size});");
+                WriteLine($@"(nint)__NativeMemory.AlignedAlloc((nuint){((Class)method.OriginalNamespace).Layout.Size}, 16);");
                 names.Insert(0, Helpers.ReturnIdentifier);
             }
             WriteLine("{0}({1});", functionName, string.Join(", ", names));

src/Generator/Options.cs

@@ -95,7 +95,7 @@ namespace CppSharp
         /// </value>
         public bool GenerateClassTemplates { get; set; }
         public bool GenerateInternalImports;
-        public bool GenerateSequentialLayout { get; set; } = true;
+        public bool GenerateSequentialLayout { get; set; } = false;
         public bool UseHeaderDirectories;
 
         /// <summary>

src/Generator/Passes/CheckAbiParameters.cs

@@ -31,15 +31,19 @@ namespace CppSharp.Passes
             if (!VisitDeclaration(function))
                 return false;
 
+            function.ReturnType.Type.Desugar().TryGetDeclaration(out Class returnTypeDecl);
+
             var isReturnIndirect = function.IsReturnIndirect || (
                     Context.ParserOptions.IsMicrosoftAbi &&
                     function is Method m && m.IsNativeMethod() &&
                     !function.ReturnType.Type.Desugar().IsAddress() &&
-                    function.ReturnType.Type.Desugar().TryGetDeclaration(out Class returnTypeDecl) &&
                     returnTypeDecl.IsPOD &&
                     returnTypeDecl.Layout.Size <= 8);
 
-            if (isReturnIndirect)
+            var triple = Context.ParserOptions.TargetTriple;
+            var isArm64 = triple.Contains("arm64") || triple.Contains("aarch64");
+
+            if (isReturnIndirect && !isArm64)
             {
                 var indirectParam = new Parameter()
                 {
@@ -54,6 +58,13 @@ namespace CppSharp.Passes
                     PrimitiveType.Void));
             }
 
+            // .NET cannot deal with non-POD with size <= 16 types being passed by value.
+            // https://github.com/dotnet/runtime/issues/106471
+            if (isArm64 && NeedsArm64IndirectReturn(returnTypeDecl))
+            {
+                Diagnostics.Error($"Non-POD return type {returnTypeDecl.Name} with size <= 16 is not supported in ARM64 target.");
+            }
+
             var method = function as Method;
 
             if (function.HasThisReturn)
@@ -66,7 +77,7 @@ namespace CppSharp.Passes
 
             // Deleting destructors (default in v-table) accept an i32 bitfield as a
             // second parameter in MS ABI.
-            if (method != null && method.IsDestructor && method.IsVirtual && Context.ParserOptions.IsMicrosoftAbi)
+            if (method is { IsDestructor: true } && method.IsVirtual && Context.ParserOptions.IsMicrosoftAbi)
             {
                 method.Parameters.Add(new Parameter
                 {
@@ -77,12 +88,26 @@ namespace CppSharp.Passes
                 });
             }
 
-            foreach (var param in function.Parameters.Where(p => p.IsIndirect))
+            foreach (var param in function.Parameters)
             {
-                param.QualifiedType = new QualifiedType(new PointerType(param.QualifiedType));
+                param.QualifiedType.Type.Desugar().TryGetDeclaration(out Class paramTypeDecl);
+                if (isArm64 && NeedsArm64IndirectReturn(paramTypeDecl))
+                {
+                    Diagnostics.Error($"Non-POD parameter type {paramTypeDecl.Name} with size <= 16 is not supported in ARM64 target.");
+                }
+
+                if (param.IsIndirect)
+                    param.QualifiedType = new QualifiedType(new PointerType(param.QualifiedType));
             }
 
             return true;
         }
+
+        public static bool NeedsArm64IndirectReturn(Class @class)
+        {
+            if (@class == null)
+                return false;
+            return (@class.HasNonTrivialCopyConstructor || @class.HasNonTrivialDestructor || @class.IsDynamic) && @class.Layout.Size <= 16;
+        }
     }
 }

src/Generator/Passes/SymbolsCodeGenerator.cs

@@ -32,6 +32,7 @@ namespace CppSharp.Passes
             {
                 WriteLine("#define _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS");
                 WriteLine("#define _LIBCPP_HIDE_FROM_ABI");
+                WriteLine("#define _LIBCPP_NO_ABI_TAG");
                 NewLine();
                 WriteLine("#include <string>");
             }