C++反射 - 反射信息的自动生成

//-------------------------------------
//declaration
//-------------------------------------
class Vector3 {
 public:
  double x;
  double y;
  double z;
 public:
  Vector3() : x(0.0), y(0.0), z(0.0) {}
  Vector3(double _x, double _y, double _z) : x(_x), y(_y), z(_z) {}
  double DotProduct(const Vector3& vec) const;
};

//-------------------------------------
//register code
//-------------------------------------
__register_type<Vector3>("Vector3")
        .constructor()
        .constructor<double, double, double>()
        .property("x", &Vector3::x)
        .property("y", &Vector3::y)
        .property("z", &Vector3::z)
        .function("DotProduct", &Vector3::DotProduct);
        );

objCallStart = $"_{ClassName}::";

objCallStart = string.Fomart("_{0}::", ClassName);

for (int i = 0; i < file_->public_dependency_count(); i++) {
  const FileDescriptor* dep = file_->public_dependency(i);
  format("#include \"$1$.proto.h\"\n", StripProto(dep->name()));
}

__register_type<{{ this_class.name }}>("{{ this_class.name }}")
{% comment %} class export start {% endcomment %}
{%- if this_class.has_base_class -%}
    .base<{{this_class.base_class_name}}>()
{%- endif -%}
    //member fields export here
{%- for field in this_class.fields -%}
    {{ field.render }}
{%- endfor -%}
    //member properties export here
{%- for prop in this_class.properties -%}
    {{ prop.render }}
{%- endfor -%}
{% comment %} ... ignore something here {% endcomment %}

__register_type<Vector3>("Vector3")
    .property("x", &Vector3::x)
    // ... ignore something here

#include <clang/AST/Decl.h>
#include <clang/AST/DeclCXX.h>
#include <clang/AST/DeclObjC.h>
#include <clang/AST/Expr.h>
#include <clang/AST/ExprCXX.h>
#include <clang/AST/ExprObjC.h>
#include <clang/AST/Stmt.h>
#include <clang/AST/StmtCXX.h>
#include <clang/AST/StmtObjC.h>
#include <clang/AST/VTableBuilder.h>
#include <clang/Basic/Specifiers.h>
#include <clang-c/ExternC.h>
#include <clang-c/Index.h>

// ... something ignore here

enum CX_AttrKind {
    CX_AttrKind_Invalid,
#define ATTR(X) CX_AttrKind_##X,
#define ATTR_RANGE(CLASS, FIRST_NAME, LAST_NAME) CX_AttrKind_First##CLASS = CX_AttrKind_##FIRST_NAME, CX_AttrKind_Last##CLASS = CX_AttrKind_##LAST_NAME,
#include <clang/Basic/AttrList.inc>
};

// ... something ignore here
clangsharp_Cursor_getArgument(CXCursor C, unsigned i);
CXType clangsharp_Cursor_getArgumentType(CXCursor C);
int64_t clangsharp_Cursor_getArraySize(CXCursor C);
// ... something ignore here

ASTUnit* getCursorASTUnit(CXCursor Cursor);
    ASTContext& getCursorContext(CXCursor Cursor);
    CXTranslationUnit getCursorTU(CXCursor Cursor);
    const Attr* getCursorAttr(CXCursor Cursor);
    const Decl* getCursorDecl(CXCursor Cursor);
    const Expr* getCursorExpr(CXCursor Cursor);

    CXCursor MakeCXCursor(const Attr* A, const Decl* Parent, CXTranslationUnit TU);

    CXCursor MakeCXCursor(const CXXBaseSpecifier* B, CXTranslationUnit TU);

    CXCursor MakeCXCursor(const Decl* D, CXTranslationUnit TU, SourceRange RegionOfInterest = SourceRange(), bool FirstInDeclGroup = true);

    CXCursor MakeCXCursor(const Stmt* S, const Decl* Parent, CXTranslationUnit TU, SourceRange RegionOfInterest = SourceRange());

CXCursor clangsharp_Cursor_getDependentLambdaCallOperator(CXCursor C) {
    if (isDeclOrTU(C.kind)) {
        const Decl* D = getCursorDecl(C);

        if (const CXXRecordDecl* CRD = dyn_cast<CXXRecordDecl>(D)) {
            return MakeCXCursor(CRD->getDependentLambdaCallOperator(), getCursorTU(C));
        }
    }
    return clang_getNullCursor();
}

namespace ClangSharp.Interop
{
    public partial struct CXCursor
    {
        [NativeTypeName("enum CXCursorKind")]
        public CXCursorKind kind;

        public int xdata;

        [NativeTypeName("const void *[3]")]
        public _data_e__FixedBuffer data;

        public unsafe partial struct _data_e__FixedBuffer
        {
            public void* e0;
            public void* e1;
            public void* e2;

            public ref void* this[int index]
            {
                get
                {
                    fixed (void** pThis = &e0)
                    {
                        return ref pThis[index];
                    }
                }
            }
        }
    }
}

namespace ClangSharp.Interop
{

    [DebuggerDisplay("{DebuggerDisplayString,nq}")]

    public unsafe partial struct CXCursor : IEquatable<CXCursor>
    {
        public static CXCursor Null => clang.getNullCursor();

        public CXType ArgumentType => clangsharp.Cursor_getArgumentType(this);

        public long ArraySize => clangsharp.Cursor_getArraySize(this);

        public CXCursor AsFunction => clangsharp.Cursor_getAsFunction(this);

        public CX_AtomicOperatorKind AtomicOperatorKind => clangsharp.Cursor_getAtomicOpcode(this);

        public CX_AttrKind AttrKind => clangsharp.Cursor_getAttrKind(this);
        
       // ... something ignore here
     };
}

public CXTranslationUnit ParseWithClangArgs(List<string> sources, string[] args)
{
    var tmpfile = Path.GetTempFileName() + ".cxx";
    var lines = new List<string>();

    foreach(var source in sources)
    {
        lines.Add(string.Format("#include \"{0}\"", source));
    }

    File.WriteAllLines(tmpfile, lines);

    // the index object
    CXIndex Index = CXIndex.Create(false, false);

    // prepare some vars for parse
    CXTranslationUnit TU;

    CXTranslationUnit_Flags tmpFlag = CXTranslationUnit_Flags.CXTranslationUnit_DetailedPreprocessingRecord;

    var error = CXTranslationUnit.TryParse(Index, tmpfile, new ReadOnlySpan<string>(args), null, tmpFlag, out TU);

    if (error != CXErrorCode.CXError_Success)
    {
        Log.Error("Failed to parse Translation Unit!");
        return null;
    }

    bool fatal = false;
    for (uint i = 0; i < TU.NumDiagnostics; ++i)
    {
        fatal |= DealingWithDiagnostic(TU.GetDiagnostic(i));
    }

    if (fatal)
    {
        Log.Error("Fatal Erros to stop!");
        return null;
    }

    Index.Dispose();
    return TU;
}

var tmpfile = Path.GetTempFileName() + ".cxx";
var lines = new List<string>();

foreach(var source in sources)
{
    lines.Add(string.Format("#include \"{0}\"", source));
}

File.WriteAllLines(tmpfile, lines);

CXTranslationUnit TU;
CXTranslationUnit_Flags tmpFlag = CXTranslationUnit_Flags.CXTranslationUnit_DetailedPreprocessingRecord;
var error = CXTranslationUnit.TryParse(Index, tmpfile, new ReadOnlySpan<string>(args), null, tmpFlag, out TU);

CXTranslationUnit_Flags tmpFlag = CXTranslationUnit_Flags.CXTranslationUnit_DetailedPreprocessingRecord;

if (error != CXErrorCode.CXError_Success)
{
    Log.Error("Failed to parse Translation Unit!");
    return null;
}

bool fatal = false;
for (uint i = 0; i < TU.NumDiagnostics; ++i)
{
    fatal |= DealingWithDiagnostic(TU.GetDiagnostic(i));
}

if (fatal)
{
    Log.Error("Fatal Erros to stop!");
    return null;
}

namespace math {

class Ray {
 protected:
  Vector3 mOrigin;
  Vector3 mDirection;
 public:
  Ray();
  Ray(const Vector3& origin, const Vector3& direction);

  /** Sets the origin of the ray. */
  void setOrigin(const Vector3& origin);
  //... something ignore here
};

} //namespace math

namespace ClangSharp.Interop
{
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    [return: NativeTypeName("enum CXChildVisitResult")]
    public unsafe delegate CXChildVisitResult CXCursorVisitor(CXCursor cursor, CXCursor parent, [NativeTypeName("CXClientData")] void* client_data);

    public CXChildVisitResult VisitChildren(CXCursorVisitor visitor, CXClientData clientData)
    {
        var pVisitor = Marshal.GetFunctionPointerForDelegate(visitor);
        var result = (CXChildVisitResult)clang.visitChildren(this, pVisitor, clientData);

        GC.KeepAlive(visitor);
        return result;
    }
}

clang -cc1 -ast-dump your_file.c
clang -cc1 -ast-view your_file.c
clang -cc1 -ast-print your_file.c

private static void PrintASTByCursor(CXCursor cursor, int level, List<string> saveList)
{
    bool needPrintChild = true;
    saveList.Add(GetOneCursorDetails(cursor, level, out needPrintChild));

    unsafe
    {
        PrintCursorInfo cursorInfo = new PrintCursorInfo();
        cursorInfo.Level = level + 1;
        cursorInfo.SaveList = saveList;
        GCHandle cursorInfoHandle = GCHandle.Alloc(cursorInfo);

        cursor.VisitChildren(VisitorForPrint,
            new CXClientData((IntPtr)cursorInfoHandle));
    }
}

private static unsafe CXChildVisitResult VisitorForPrint(CXCursor cursor, CXCursor parent, void* data)
{
    CXClientData tmpData = (CXClientData)data;
    var tmpHandle = (GCHandle)tmpData.Handle;
    var cursorInfo = tmpHandle.Target as PrintCursorInfo;
    bool needPrintChild = true;

    cursorInfo.SaveList.Add(GetOneCursorDetails(cursor, cursorInfo.Level, out needPrintChild));
    if (needPrintChild)
    {
        unsafe
        {
            PrintCursorInfo childInfo = new PrintCursorInfo();
            childInfo.Level = cursorInfo.Level + 1;
            childInfo.SaveList = cursorInfo.SaveList;

            GCHandle cursorInfoHandle = GCHandle.Alloc(childInfo);
            cursor.VisitChildren(VisitorForPrint,
                new CXClientData((IntPtr)cursorInfoHandle));
        }
    }

    return CXChildVisitResult.CXChildVisit_Continue;
}

private static string GetOneCursorDetails(CXCursor cursor, int level, out bool needPrintChild)
{
    string indentContent = GetIndentString(level);

    string declKind = "";
    if (cursor.DeclKind != CX_DeclKind.CX_DeclKind_Invalid)
    {
        declKind = cursor.DeclKind.ToString();
    }

    needPrintChild = false;

    string nodeContent;
    if (cursor.IsAttribute)
    {
        var attr = ClangSharp.Attr.Create(cursor);
        ////var attr =.GetOrCreate<ClangSharp.Attr>(cursor);
        nodeContent = $"Attr: {attr.Kind.ToString()} \"{attr.Spelling}\"";

        needPrintChild = false;
    }
    else if (cursor.IsDeclaration)
    {
        var decl = ClangSharp.Decl.Create(cursor);
        nodeContent = $"Decl: {decl.Kind.ToString()} \"{decl.Spelling}\" <{cursor.KindSpelling.CString}> ";
        needPrintChild = true;
    }
    else if (cursor.IsExpression)
    {
        // ... something ignore here
        needPrintChild = false;
    }
    else if (cursor.IsPreprocessing)
    {
        // ... something ignore here
        needPrintChild = false;
    }
    else if (cursor.IsReference)
    {
        // ... something ignore here
        needPrintChild = false;
    }
    else if (cursor.IsStatement)
    {
        // ... something ignore here
        needPrintChild = true;
    }
    else
    {
        string typeName = cursor.KindSpelling.CString;
        nodeContent = $"Others: {typeName} \"{cursor.Spelling}\"";
        needPrintChild = true;
    }

    return $"{indentContent} {cursor.Kind.ToString()} {nodeContent}[{cursor.Location.ToString()}]";
}

public class ClangAST
{
    public CXTranslationUnit NativeTranslationUnit { get; private set; }
    public ClangSharp.TranslationUnit TranslationUnit { get; private set; }

    public TranslationUnitNode RootNode { get; private set; }

    public Dictionary<string, NamespaceNode> AllNamespaceMap { get; private set; } = new Dictionary<string, NamespaceNode>();

    public Dictionary<string, ClassDeclNode> AllClassMap { get; private set; } = new Dictionary<string, ClassDeclNode>();

    public Dictionary<string, EnumDeclNode> AllEnumMap { get; private set; } = new Dictionary<string, EnumDeclNode>();

    public Dictionary<string, TypedefNode> AllGlobalTypedefMap { get; private set; } = new Dictionary<string, TypedefNode>();

    public Dictionary<string, ClassTemplateNode> AllClassTemplateMap { get; private set; } = new Dictionary<string, ClassTemplateNode>();

    public Dictionary<string, ClassTemplateSpecializationNode> AllClassTempInstanceMap { get; private set; } = new Dictionary<string, ClassTemplateSpecializationNode>();

    public Dictionary<string, UsrKeyNode> AllUsrKeyNodeMap { get; private set; } = new Dictionary<string, UsrKeyNode>();

    public Dictionary<string, ClangSharp.Type> AllUsedTypeMap { get; private set; } = new Dictionary<string, ClangSharp.Type>();
    public Dictionary<string, CXType> AllBasicTypeMap { get; private set; } = new Dictionary<string, CXType>();

    public Dictionary<string, ClassDeclNode> AllWithMetaClassMap { get; private set; } = new Dictionary<string, ClassDeclNode>();

    public Dictionary<string, EnumDeclNode> AllWithMetaEnumMap { get; private set; } = new Dictionary<string, EnumDeclNode>();
};

__attribute__((annotate("custom strings")))

[[annotate("custom strings")]]

#if defined(CLANG_GENERATOR)

  #define RSTUDIO_META_KEYWORD_SEPARATOR_INTERNAL ____

  #define RSTUDIO_META_KEYWORD_SEPARATOR_ARGUMENT_INTERNAL "|"

  #define RSTUDIO_META_WORD_COMBINE(X, Y) RSTUDIO_JOIN(RSTUDIO_JOIN(X, RSTUDIO_META_KEYWORD_SEPARATOR_INTERNAL), Y)

  #define RSTUDIO_META_LEADER_WORD_INTERNAL rmeta

  #define RSTUDIO_META_COMBINE_IMPL(X) RSTUDIO_JOIN(RSTUDIO_META_LEADER_WORD_IMPL, X)

  #define RSUTDIO_META_TO_STR_IMPL2(X) #X

  #define RSUTDIO_META_TO_STR_IMPL(X) RSUTDIO_META_TO_STR_IMPL2(X)

  #define RSTUDIO_META_IMPL(X, Y)                                                                                     \
    __attribute__((annotate(RSUTDIO_META_TO_STR_IMPL(RSTUDIO_META_WORD_COMBINE(RSTUDIO_META_LEADER_WORD_INTERNAL, X)) \
                                RSTUDIO_META_KEYWORD_SEPARATOR_ARGUMENT_INTERNAL Y)))

  #define RSTUDIO_META_CLASS_LEADER_WORD_IMPL class

  #define RSTUDIO_META_FUNCTION_LEADER_WORD_IMPL function

  #define RSTUDIO_META_FIELD_LEADER_WORD_IMPL field

  #define RSTUDIO_META_ENUM_LEADER_WORD_IMPL enum

  #define RSTUDIO_META_NOT_SET_WORD_INTERNAL not_set_internal

  #define RCLASS_IMPL(FEATURE, ARGUMENT) \
    RSTUDIO_META_IMPL(RSTUDIO_META_WORD_COMBINE(RSTUDIO_META_CLASS_LEADER_WORD_IMPL, FEATURE), ARGUMENT)

  #define RCLASS(FEATURE, ...) RCLASS_IMPL(FEATURE, #__VA_ARGS__)
  #define RCLASS_LUA(...) RCLASS_IMPL(lua, #__VA_ARGS__)
#else
  #define RCLASS(FEATURE, ...)
  #define RCLASS_LUA(...)
#endif

class RCLASS_LUA(desc = "abc", id = 5, browser = false) TestVec;

__attribute__((annotate("rmeta___class___lua" "|" "desc = \"abc\", id = 5, browser = false")))

if(cursor.kind == CXCursorKind.CXCursor_AnnotateAttr)
{
    //Handle meta information
    ////var attr = ClangSharp.Attr.Create(cursor);
    var attr = ParentAST.TranslationUnit.GetOrCreate<ClangSharp.Attr>(cursor);
    string meta = attr.Spelling;

    string errorMessage;
    var metaAttr = CustomAttributeTool.ParseMetaStringFor(meta, CustomAttributeTool.kMetaClassLeaderWord, out errorMessage);
    if (metaAttr == null && !string.IsNullOrEmpty(errorMessage))
    {
        Log.Error($"[Error] handle meta not right, detail: {errorMessage}!, location:{cursor.Location.ToString()}");
    }
    else
    {
        MetaMap.MetaList.Add(metaAttr);

        if(MetaMap.MetaList.Count == 1)
        {
            //Just call here when the first meta attribute handle
            if(this is ClassDeclNode)
            {
                ParentAST.AddWithMetaClass(this as ClassDeclNode);
            }
        }
    }
}

class RCLASS_LUA(ignore_base = true) TestVec: public AllocObj {};

struct RCLASS_PB(msgid = 1) TestPBMessage {
 public:
  RFIELD_PB(id = 1)
  float x;
  RFIELD_PB(id = 2)
  double y;
  RFIELD_PB(id = 3)
  uint64_t z;
};