示例#1
0
        void ProcessEnumDetail(Enumeration @enum, CXCursor cursor, CXCursor parent)
        {
            // unscoped name
            @enum.UnscopedName = clang.getCursorSpelling(cursor).ToString();

            // underlying type
            CXType    underlyingType = clang.getEnumDeclIntegerType(cursor);
            BasicType type           = ClangTraits.ToBasicType(underlyingType);

            @enum.Type = type;

            // is scoped
            @enum.IsEnumClass = clang.EnumDecl_isScoped(cursor) != 0;

            // check is parent is a class
            if (OwnerClass_ != null)
            {
                Debug.Assert(ClangTraits.IsUserDefinedTypeDecl(parent));
                OwnerClass_.AddSubEnum(new SubEnum
                {
                    Access = ClangTraits.ToAccessSpecifier(clang.getCXXAccessSpecifier(cursor)),
                    Enum   = @enum
                });
            }
        }
示例#2
0
        private static void ProcessTypeEntity(
            AST ast,
            NativeType type,
            CXType cxType,
            TypeVisitContext context)
        {
            type.IsConst = ClangTraits.IsConst(cxType);
            if (ClangTraits.IsBuiltInType(cxType))
            {
                type.SetBuiltin(ClangTraits.ToBasicType(cxType));
            }
            else
            {
                CXCursor cursor              = clang.getTypeDeclaration(cxType);
                CXType   theType             = clang.getCursorType(cursor);
                string   removeQualifierName = clang.getTypeSpelling(theType).ToString();

                if (ClangTraits.IsEnum(cxType))
                {
                    type.SetEnum(ast.GetEnum(removeQualifierName));
                }
                else if (ClangTraits.IsFunction(cxType))
                {
                    type.SetFunction(GetFunctionProto(ast, cxType, context));
                }
                else if (ClangTraits.IsUserDefiendType(cxType))
                {
                    NativeClass nativeClass = ast.GetClass(removeQualifierName);

                    // if native class is parsed already, the native class is a full specialization
                    // or the native class is a instantiation of a template or partial specialization
                    if (!nativeClass.IsClassEntity && !nativeClass.Parsed)
                    {
                        nativeClass.Parsed = true;
                        if (TemplateHelper.VisitTemplate(cursor, nativeClass, ast))
                        {
                            TemplateHelper.VisitTemplateParameter(cursor, theType, nativeClass, ast, context);
                        }
                    }

                    type.SetClass(nativeClass);
                }
            }
        }