diff --git a/src/clang.zig b/src/clang.zig index e93060edc5..b725d06e68 100644 --- a/src/clang.zig +++ b/src/clang.zig @@ -1,91 +1,901 @@ -const builtin = @import("builtin"); +pub const builtin = @import("builtin"); -pub const struct_ZigClangConditionalOperator = opaque {}; -pub const struct_ZigClangBinaryConditionalOperator = opaque {}; -pub const struct_ZigClangAbstractConditionalOperator = opaque {}; -pub const struct_ZigClangAPInt = opaque {}; -pub const struct_ZigClangAPSInt = opaque {}; -pub const struct_ZigClangAPFloat = opaque {}; -pub const struct_ZigClangASTContext = opaque {}; -pub const struct_ZigClangASTUnit = opaque {}; -pub const struct_ZigClangArraySubscriptExpr = opaque {}; -pub const struct_ZigClangArrayType = opaque {}; -pub const struct_ZigClangAttributedType = opaque {}; -pub const struct_ZigClangBinaryOperator = opaque {}; -pub const struct_ZigClangBreakStmt = opaque {}; -pub const struct_ZigClangBuiltinType = opaque {}; -pub const struct_ZigClangCStyleCastExpr = opaque {}; -pub const struct_ZigClangCallExpr = opaque {}; -pub const struct_ZigClangCaseStmt = opaque {}; -pub const struct_ZigClangCompoundAssignOperator = opaque {}; -pub const struct_ZigClangCompoundStmt = opaque {}; -pub const struct_ZigClangConstantArrayType = opaque {}; -pub const struct_ZigClangContinueStmt = opaque {}; -pub const struct_ZigClangDecayedType = opaque {}; -pub const ZigClangDecl = opaque {}; -pub const struct_ZigClangDeclRefExpr = opaque {}; -pub const struct_ZigClangDeclStmt = opaque {}; -pub const struct_ZigClangDefaultStmt = opaque {}; -pub const struct_ZigClangDiagnosticOptions = opaque {}; -pub const struct_ZigClangDiagnosticsEngine = opaque {}; -pub const struct_ZigClangDoStmt = opaque {}; -pub const struct_ZigClangElaboratedType = opaque {}; -pub const struct_ZigClangEnumConstantDecl = opaque {}; -pub const struct_ZigClangEnumDecl = opaque {}; -pub const struct_ZigClangEnumType = opaque {}; -pub const struct_ZigClangExpr = opaque {}; -pub const struct_ZigClangFieldDecl = opaque {}; -pub const struct_ZigClangFileID = opaque {}; -pub const struct_ZigClangForStmt = opaque {}; -pub const struct_ZigClangFullSourceLoc = opaque {}; -pub const struct_ZigClangFunctionDecl = opaque {}; -pub const struct_ZigClangFunctionProtoType = opaque {}; -pub const struct_ZigClangIfStmt = opaque {}; -pub const struct_ZigClangImplicitCastExpr = opaque {}; -pub const struct_ZigClangIncompleteArrayType = opaque {}; -pub const struct_ZigClangIntegerLiteral = opaque {}; -pub const struct_ZigClangMacroDefinitionRecord = opaque {}; -pub const struct_ZigClangMacroExpansion = opaque {}; -pub const struct_ZigClangMacroQualifiedType = opaque {}; -pub const struct_ZigClangMemberExpr = opaque {}; -pub const struct_ZigClangNamedDecl = opaque {}; -pub const struct_ZigClangNone = opaque {}; -pub const struct_ZigClangOpaqueValueExpr = opaque {}; -pub const struct_ZigClangPCHContainerOperations = opaque {}; -pub const struct_ZigClangParenExpr = opaque {}; -pub const struct_ZigClangParenType = opaque {}; -pub const struct_ZigClangParmVarDecl = opaque {}; -pub const struct_ZigClangPointerType = opaque {}; -pub const struct_ZigClangPreprocessedEntity = opaque {}; -pub const struct_ZigClangRecordDecl = opaque {}; -pub const struct_ZigClangRecordType = opaque {}; -pub const struct_ZigClangReturnStmt = opaque {}; -pub const struct_ZigClangSkipFunctionBodiesScope = opaque {}; -pub const struct_ZigClangSourceManager = opaque {}; -pub const struct_ZigClangSourceRange = opaque {}; -pub const ZigClangStmt = opaque {}; -pub const struct_ZigClangStringLiteral = opaque {}; -pub const struct_ZigClangStringRef = opaque {}; -pub const struct_ZigClangSwitchStmt = opaque {}; -pub const struct_ZigClangTagDecl = opaque {}; -pub const struct_ZigClangType = opaque {}; -pub const struct_ZigClangTypedefNameDecl = opaque {}; -pub const struct_ZigClangTypedefType = opaque {}; -pub const struct_ZigClangUnaryExprOrTypeTraitExpr = opaque {}; -pub const struct_ZigClangUnaryOperator = opaque {}; -pub const struct_ZigClangValueDecl = opaque {}; -pub const struct_ZigClangVarDecl = opaque {}; -pub const struct_ZigClangWhileStmt = opaque {}; -pub const struct_ZigClangFunctionType = opaque {}; -pub const struct_ZigClangPredefinedExpr = opaque {}; -pub const struct_ZigClangInitListExpr = opaque {}; -pub const ZigClangPreprocessingRecord = opaque {}; -pub const ZigClangFloatingLiteral = opaque {}; -pub const ZigClangConstantExpr = opaque {}; -pub const ZigClangCharacterLiteral = opaque {}; -pub const ZigClangStmtExpr = opaque {}; +pub const SourceLocation = extern struct { + ID: c_uint, -pub const ZigClangBO = extern enum { + pub const eq = ZigClangSourceLocation_eq; + extern fn ZigClangSourceLocation_eq(a: SourceLocation, b: SourceLocation) bool; +}; + +pub const QualType = extern struct { + ptr: ?*c_void, + + pub const getCanonicalType = ZigClangQualType_getCanonicalType; + extern fn ZigClangQualType_getCanonicalType(QualType) QualType; + + pub const getTypePtr = ZigClangQualType_getTypePtr; + extern fn ZigClangQualType_getTypePtr(QualType) *const Type; + + pub const getTypeClass = ZigClangQualType_getTypeClass; + extern fn ZigClangQualType_getTypeClass(QualType) TypeClass; + + pub const addConst = ZigClangQualType_addConst; + extern fn ZigClangQualType_addConst(*QualType) void; + + pub const eq = ZigClangQualType_eq; + extern fn ZigClangQualType_eq(QualType, arg1: QualType) bool; + + pub const isConstQualified = ZigClangQualType_isConstQualified; + extern fn ZigClangQualType_isConstQualified(QualType) bool; + + pub const isVolatileQualified = ZigClangQualType_isVolatileQualified; + extern fn ZigClangQualType_isVolatileQualified(QualType) bool; + + pub const isRestrictQualified = ZigClangQualType_isRestrictQualified; + extern fn ZigClangQualType_isRestrictQualified(QualType) bool; +}; + +pub const APValueLValueBase = extern struct { + Ptr: ?*c_void, + CallIndex: c_uint, + Version: c_uint, + + pub const dyn_cast_Expr = ZigClangAPValueLValueBase_dyn_cast_Expr; + extern fn ZigClangAPValueLValueBase_dyn_cast_Expr(APValueLValueBase) ?*const Expr; +}; + +pub const APValueKind = extern enum { + None, + Indeterminate, + Int, + Float, + FixedPoint, + ComplexInt, + ComplexFloat, + LValue, + Vector, + Array, + Struct, + Union, + MemberPointer, + AddrLabelDiff, +}; + +pub const APValue = extern struct { + Kind: APValueKind, + Data: if (builtin.os.tag == .windows and builtin.abi == .msvc) [52]u8 else [68]u8, + + pub const getKind = ZigClangAPValue_getKind; + extern fn ZigClangAPValue_getKind(*const APValue) APValueKind; + + pub const getInt = ZigClangAPValue_getInt; + extern fn ZigClangAPValue_getInt(*const APValue) *const APSInt; + + pub const getArrayInitializedElts = ZigClangAPValue_getArrayInitializedElts; + extern fn ZigClangAPValue_getArrayInitializedElts(*const APValue) c_uint; + + pub const getArraySize = ZigClangAPValue_getArraySize; + extern fn ZigClangAPValue_getArraySize(*const APValue) c_uint; + + pub const getLValueBase = ZigClangAPValue_getLValueBase; + extern fn ZigClangAPValue_getLValueBase(*const APValue) APValueLValueBase; +}; + +pub const ExprEvalResult = extern struct { + HasSideEffects: bool, + HasUndefinedBehavior: bool, + SmallVectorImpl: ?*c_void, + Val: APValue, +}; + +pub const AbstractConditionalOperator = opaque { + pub const getCond = ZigClangAbstractConditionalOperator_getCond; + extern fn ZigClangAbstractConditionalOperator_getCond(*const AbstractConditionalOperator) *const Expr; + + pub const getTrueExpr = ZigClangAbstractConditionalOperator_getTrueExpr; + extern fn ZigClangAbstractConditionalOperator_getTrueExpr(*const AbstractConditionalOperator) *const Expr; + + pub const getFalseExpr = ZigClangAbstractConditionalOperator_getFalseExpr; + extern fn ZigClangAbstractConditionalOperator_getFalseExpr(*const AbstractConditionalOperator) *const Expr; +}; + +pub const APFloat = opaque { + pub const toString = ZigClangAPFloat_toString; + extern fn ZigClangAPFloat_toString(*const APFloat, precision: c_uint, maxPadding: c_uint, truncateZero: bool) [*:0]const u8; +}; + +pub const APInt = opaque { + pub const getLimitedValue = ZigClangAPInt_getLimitedValue; + extern fn ZigClangAPInt_getLimitedValue(*const APInt, limit: u64) u64; +}; + +pub const APSInt = opaque { + pub const isSigned = ZigClangAPSInt_isSigned; + extern fn ZigClangAPSInt_isSigned(*const APSInt) bool; + + pub const isNegative = ZigClangAPSInt_isNegative; + extern fn ZigClangAPSInt_isNegative(*const APSInt) bool; + + pub const negate = ZigClangAPSInt_negate; + extern fn ZigClangAPSInt_negate(*const APSInt) *const APSInt; + + pub const free = ZigClangAPSInt_free; + extern fn ZigClangAPSInt_free(*const APSInt) void; + + pub const getRawData = ZigClangAPSInt_getRawData; + extern fn ZigClangAPSInt_getRawData(*const APSInt) [*:0]const u64; + + pub const getNumWords = ZigClangAPSInt_getNumWords; + extern fn ZigClangAPSInt_getNumWords(*const APSInt) c_uint; +}; + +pub const ASTContext = opaque { + pub const getPointerType = ZigClangASTContext_getPointerType; + extern fn ZigClangASTContext_getPointerType(*const ASTContext, T: QualType) QualType; +}; + +pub const ASTUnit = opaque { + pub const delete = ZigClangASTUnit_delete; + extern fn ZigClangASTUnit_delete(*ASTUnit) void; + + pub const getASTContext = ZigClangASTUnit_getASTContext; + extern fn ZigClangASTUnit_getASTContext(*ASTUnit) *ASTContext; + + pub const getSourceManager = ZigClangASTUnit_getSourceManager; + extern fn ZigClangASTUnit_getSourceManager(*ASTUnit) *SourceManager; + + pub const visitLocalTopLevelDecls = ZigClangASTUnit_visitLocalTopLevelDecls; + extern fn ZigClangASTUnit_visitLocalTopLevelDecls(*ASTUnit, context: ?*c_void, Fn: ?fn (?*c_void, *const Decl) callconv(.C) bool) bool; + + pub const getLocalPreprocessingEntities_begin = ZigClangASTUnit_getLocalPreprocessingEntities_begin; + extern fn ZigClangASTUnit_getLocalPreprocessingEntities_begin(*ASTUnit) PreprocessingRecord.iterator; + + pub const getLocalPreprocessingEntities_end = ZigClangASTUnit_getLocalPreprocessingEntities_end; + extern fn ZigClangASTUnit_getLocalPreprocessingEntities_end(*ASTUnit) PreprocessingRecord.iterator; +}; + +pub const ArraySubscriptExpr = opaque { + pub const getBase = ZigClangArraySubscriptExpr_getBase; + extern fn ZigClangArraySubscriptExpr_getBase(*const ArraySubscriptExpr) *const Expr; + + pub const getIdx = ZigClangArraySubscriptExpr_getIdx; + extern fn ZigClangArraySubscriptExpr_getIdx(*const ArraySubscriptExpr) *const Expr; +}; + +pub const ArrayType = opaque { + pub const getElementType = ZigClangArrayType_getElementType; + extern fn ZigClangArrayType_getElementType(*const ArrayType) QualType; +}; + +pub const AttributedType = opaque { + pub const getEquivalentType = ZigClangAttributedType_getEquivalentType; + extern fn ZigClangAttributedType_getEquivalentType(*const AttributedType) QualType; +}; + +pub const BinaryOperator = opaque { + pub const getOpcode = ZigClangBinaryOperator_getOpcode; + extern fn ZigClangBinaryOperator_getOpcode(*const BinaryOperator) BO; + + pub const getBeginLoc = ZigClangBinaryOperator_getBeginLoc; + extern fn ZigClangBinaryOperator_getBeginLoc(*const BinaryOperator) SourceLocation; + + pub const getLHS = ZigClangBinaryOperator_getLHS; + extern fn ZigClangBinaryOperator_getLHS(*const BinaryOperator) *const Expr; + + pub const getRHS = ZigClangBinaryOperator_getRHS; + extern fn ZigClangBinaryOperator_getRHS(*const BinaryOperator) *const Expr; + + pub const getType = ZigClangBinaryOperator_getType; + extern fn ZigClangBinaryOperator_getType(*const BinaryOperator) QualType; +}; + +pub const BinaryConditionalOperator = opaque {}; + +pub const BreakStmt = opaque {}; + +pub const BuiltinType = opaque { + pub const getKind = ZigClangBuiltinType_getKind; + extern fn ZigClangBuiltinType_getKind(*const BuiltinType) BuiltinTypeKind; +}; + +pub const CStyleCastExpr = opaque { + pub const getBeginLoc = ZigClangCStyleCastExpr_getBeginLoc; + extern fn ZigClangCStyleCastExpr_getBeginLoc(*const CStyleCastExpr) SourceLocation; + + pub const getSubExpr = ZigClangCStyleCastExpr_getSubExpr; + extern fn ZigClangCStyleCastExpr_getSubExpr(*const CStyleCastExpr) *const Expr; + + pub const getType = ZigClangCStyleCastExpr_getType; + extern fn ZigClangCStyleCastExpr_getType(*const CStyleCastExpr) QualType; +}; + +pub const CallExpr = opaque { + pub const getCallee = ZigClangCallExpr_getCallee; + extern fn ZigClangCallExpr_getCallee(*const CallExpr) *const Expr; + + pub const getNumArgs = ZigClangCallExpr_getNumArgs; + extern fn ZigClangCallExpr_getNumArgs(*const CallExpr) c_uint; + + pub const getArgs = ZigClangCallExpr_getArgs; + extern fn ZigClangCallExpr_getArgs(*const CallExpr) [*]const *const Expr; +}; + +pub const CaseStmt = opaque { + pub const getLHS = ZigClangCaseStmt_getLHS; + extern fn ZigClangCaseStmt_getLHS(*const CaseStmt) *const Expr; + + pub const getRHS = ZigClangCaseStmt_getRHS; + extern fn ZigClangCaseStmt_getRHS(*const CaseStmt) ?*const Expr; + + pub const getBeginLoc = ZigClangCaseStmt_getBeginLoc; + extern fn ZigClangCaseStmt_getBeginLoc(*const CaseStmt) SourceLocation; + + pub const getSubStmt = ZigClangCaseStmt_getSubStmt; + extern fn ZigClangCaseStmt_getSubStmt(*const CaseStmt) *const Stmt; +}; + +pub const CharacterLiteral = opaque { + pub const getBeginLoc = ZigClangCharacterLiteral_getBeginLoc; + extern fn ZigClangCharacterLiteral_getBeginLoc(*const CharacterLiteral) SourceLocation; + + pub const getKind = ZigClangCharacterLiteral_getKind; + extern fn ZigClangCharacterLiteral_getKind(*const CharacterLiteral) CharacterLiteral_CharacterKind; + + pub const getValue = ZigClangCharacterLiteral_getValue; + extern fn ZigClangCharacterLiteral_getValue(*const CharacterLiteral) c_uint; +}; + +pub const CompoundAssignOperator = opaque { + pub const getType = ZigClangCompoundAssignOperator_getType; + extern fn ZigClangCompoundAssignOperator_getType(*const CompoundAssignOperator) QualType; + + pub const getComputationLHSType = ZigClangCompoundAssignOperator_getComputationLHSType; + extern fn ZigClangCompoundAssignOperator_getComputationLHSType(*const CompoundAssignOperator) QualType; + + pub const getComputationResultType = ZigClangCompoundAssignOperator_getComputationResultType; + extern fn ZigClangCompoundAssignOperator_getComputationResultType(*const CompoundAssignOperator) QualType; + + pub const getBeginLoc = ZigClangCompoundAssignOperator_getBeginLoc; + extern fn ZigClangCompoundAssignOperator_getBeginLoc(*const CompoundAssignOperator) SourceLocation; + + pub const getOpcode = ZigClangCompoundAssignOperator_getOpcode; + extern fn ZigClangCompoundAssignOperator_getOpcode(*const CompoundAssignOperator) BO; + + pub const getLHS = ZigClangCompoundAssignOperator_getLHS; + extern fn ZigClangCompoundAssignOperator_getLHS(*const CompoundAssignOperator) *const Expr; + + pub const getRHS = ZigClangCompoundAssignOperator_getRHS; + extern fn ZigClangCompoundAssignOperator_getRHS(*const CompoundAssignOperator) *const Expr; +}; + +pub const CompoundStmt = opaque { + pub const body_begin = ZigClangCompoundStmt_body_begin; + extern fn ZigClangCompoundStmt_body_begin(*const CompoundStmt) const_body_iterator; + + pub const body_end = ZigClangCompoundStmt_body_end; + extern fn ZigClangCompoundStmt_body_end(*const CompoundStmt) const_body_iterator; + + pub const const_body_iterator = [*]const *Stmt; +}; + +pub const ConditionalOperator = opaque {}; + +pub const ConstantArrayType = opaque { + pub const getElementType = ZigClangConstantArrayType_getElementType; + extern fn ZigClangConstantArrayType_getElementType(*const ConstantArrayType) QualType; + + pub const getSize = ZigClangConstantArrayType_getSize; + extern fn ZigClangConstantArrayType_getSize(*const ConstantArrayType) *const APInt; +}; + +pub const ConstantExpr = opaque {}; + +pub const ContinueStmt = opaque {}; + +pub const DecayedType = opaque { + pub const getDecayedType = ZigClangDecayedType_getDecayedType; + extern fn ZigClangDecayedType_getDecayedType(*const DecayedType) QualType; +}; + +pub const Decl = opaque { + pub const getLocation = ZigClangDecl_getLocation; + extern fn ZigClangDecl_getLocation(*const Decl) SourceLocation; + + pub const castToNamedDecl = ZigClangDecl_castToNamedDecl; + extern fn ZigClangDecl_castToNamedDecl(decl: *const Decl) ?*const NamedDecl; + + pub const getKind = ZigClangDecl_getKind; + extern fn ZigClangDecl_getKind(decl: *const Decl) DeclKind; + + pub const getDeclKindName = ZigClangDecl_getDeclKindName; + extern fn ZigClangDecl_getDeclKindName(decl: *const Decl) [*:0]const u8; +}; + +pub const DeclRefExpr = opaque { + pub const getDecl = ZigClangDeclRefExpr_getDecl; + extern fn ZigClangDeclRefExpr_getDecl(*const DeclRefExpr) *const ValueDecl; + + pub const getFoundDecl = ZigClangDeclRefExpr_getFoundDecl; + extern fn ZigClangDeclRefExpr_getFoundDecl(*const DeclRefExpr) *const NamedDecl; +}; + +pub const DeclStmt = opaque { + pub const decl_begin = ZigClangDeclStmt_decl_begin; + extern fn ZigClangDeclStmt_decl_begin(*const DeclStmt) const_decl_iterator; + + pub const decl_end = ZigClangDeclStmt_decl_end; + extern fn ZigClangDeclStmt_decl_end(*const DeclStmt) const_decl_iterator; + + pub const const_decl_iterator = [*]const *Decl; +}; + +pub const DefaultStmt = opaque { + pub const getSubStmt = ZigClangDefaultStmt_getSubStmt; + extern fn ZigClangDefaultStmt_getSubStmt(*const DefaultStmt) *const Stmt; +}; + +pub const DiagnosticOptions = opaque {}; + +pub const DiagnosticsEngine = opaque {}; + +pub const DoStmt = opaque { + pub const getCond = ZigClangDoStmt_getCond; + extern fn ZigClangDoStmt_getCond(*const DoStmt) *const Expr; + + pub const getBody = ZigClangDoStmt_getBody; + extern fn ZigClangDoStmt_getBody(*const DoStmt) *const Stmt; +}; + +pub const ElaboratedType = opaque { + pub const getNamedType = ZigClangElaboratedType_getNamedType; + extern fn ZigClangElaboratedType_getNamedType(*const ElaboratedType) QualType; +}; + +pub const EnumConstantDecl = opaque { + pub const getInitExpr = ZigClangEnumConstantDecl_getInitExpr; + extern fn ZigClangEnumConstantDecl_getInitExpr(*const EnumConstantDecl) ?*const Expr; + + pub const getInitVal = ZigClangEnumConstantDecl_getInitVal; + extern fn ZigClangEnumConstantDecl_getInitVal(*const EnumConstantDecl) *const APSInt; +}; + +pub const EnumDecl = opaque { + pub const getCanonicalDecl = ZigClangEnumDecl_getCanonicalDecl; + extern fn ZigClangEnumDecl_getCanonicalDecl(*const EnumDecl) ?*const TagDecl; + + pub const getIntegerType = ZigClangEnumDecl_getIntegerType; + extern fn ZigClangEnumDecl_getIntegerType(*const EnumDecl) QualType; + + pub const getDefinition = ZigClangEnumDecl_getDefinition; + extern fn ZigClangEnumDecl_getDefinition(*const EnumDecl) ?*const EnumDecl; + + pub const getLocation = ZigClangEnumDecl_getLocation; + extern fn ZigClangEnumDecl_getLocation(*const EnumDecl) SourceLocation; + + pub const enumerator_begin = ZigClangEnumDecl_enumerator_begin; + extern fn ZigClangEnumDecl_enumerator_begin(*const EnumDecl) enumerator_iterator; + + pub const enumerator_end = ZigClangEnumDecl_enumerator_end; + extern fn ZigClangEnumDecl_enumerator_end(*const EnumDecl) enumerator_iterator; + + pub const enumerator_iterator = extern struct { + ptr: *c_void, + + pub const next = ZigClangEnumDecl_enumerator_iterator_next; + extern fn ZigClangEnumDecl_enumerator_iterator_next(enumerator_iterator) enumerator_iterator; + + pub const deref = ZigClangEnumDecl_enumerator_iterator_deref; + extern fn ZigClangEnumDecl_enumerator_iterator_deref(enumerator_iterator) *const EnumConstantDecl; + + pub const neq = ZigClangEnumDecl_enumerator_iterator_neq; + extern fn ZigClangEnumDecl_enumerator_iterator_neq(enumerator_iterator, enumerator_iterator) bool; + }; +}; + +pub const EnumType = opaque { + pub const getDecl = ZigClangEnumType_getDecl; + extern fn ZigClangEnumType_getDecl(*const EnumType) *const EnumDecl; +}; + +pub const Expr = opaque { + pub const getStmtClass = ZigClangExpr_getStmtClass; + extern fn ZigClangExpr_getStmtClass(*const Expr) StmtClass; + + pub const getType = ZigClangExpr_getType; + extern fn ZigClangExpr_getType(*const Expr) QualType; + + pub const getBeginLoc = ZigClangExpr_getBeginLoc; + extern fn ZigClangExpr_getBeginLoc(*const Expr) SourceLocation; + + pub const EvaluateAsConstantExpr = ZigClangExpr_EvaluateAsConstantExpr; + extern fn ZigClangExpr_EvaluateAsConstantExpr(*const Expr, *ExprEvalResult, Expr_ConstExprUsage, *const ASTContext) bool; +}; + +pub const FieldDecl = opaque { + pub const getCanonicalDecl = ZigClangFieldDecl_getCanonicalDecl; + extern fn ZigClangFieldDecl_getCanonicalDecl(*const FieldDecl) ?*const FieldDecl; + + pub const getAlignedAttribute = ZigClangFieldDecl_getAlignedAttribute; + extern fn ZigClangFieldDecl_getAlignedAttribute(*const FieldDecl, *const ASTContext) c_uint; + + pub const isAnonymousStructOrUnion = ZigClangFieldDecl_isAnonymousStructOrUnion; + extern fn ZigClangFieldDecl_isAnonymousStructOrUnion(*const FieldDecl) bool; + + pub const isBitField = ZigClangFieldDecl_isBitField; + extern fn ZigClangFieldDecl_isBitField(*const FieldDecl) bool; + + pub const getType = ZigClangFieldDecl_getType; + extern fn ZigClangFieldDecl_getType(*const FieldDecl) QualType; + + pub const getLocation = ZigClangFieldDecl_getLocation; + extern fn ZigClangFieldDecl_getLocation(*const FieldDecl) SourceLocation; +}; + +pub const FileID = opaque {}; + +pub const FloatingLiteral = opaque { + pub const getValueAsApproximateDouble = ZigClangAPFloat_getValueAsApproximateDouble; + extern fn ZigClangAPFloat_getValueAsApproximateDouble(*const FloatingLiteral) f64; +}; + +pub const ForStmt = opaque { + pub const getInit = ZigClangForStmt_getInit; + extern fn ZigClangForStmt_getInit(*const ForStmt) ?*const Stmt; + + pub const getCond = ZigClangForStmt_getCond; + extern fn ZigClangForStmt_getCond(*const ForStmt) ?*const Expr; + + pub const getInc = ZigClangForStmt_getInc; + extern fn ZigClangForStmt_getInc(*const ForStmt) ?*const Expr; + + pub const getBody = ZigClangForStmt_getBody; + extern fn ZigClangForStmt_getBody(*const ForStmt) *const Stmt; +}; + +pub const FullSourceLoc = opaque {}; + +pub const FunctionDecl = opaque { + pub const getType = ZigClangFunctionDecl_getType; + extern fn ZigClangFunctionDecl_getType(*const FunctionDecl) QualType; + + pub const getLocation = ZigClangFunctionDecl_getLocation; + extern fn ZigClangFunctionDecl_getLocation(*const FunctionDecl) SourceLocation; + + pub const hasBody = ZigClangFunctionDecl_hasBody; + extern fn ZigClangFunctionDecl_hasBody(*const FunctionDecl) bool; + + pub const getStorageClass = ZigClangFunctionDecl_getStorageClass; + extern fn ZigClangFunctionDecl_getStorageClass(*const FunctionDecl) StorageClass; + + pub const getParamDecl = ZigClangFunctionDecl_getParamDecl; + extern fn ZigClangFunctionDecl_getParamDecl(*const FunctionDecl, i: c_uint) *const ParmVarDecl; + + pub const getBody = ZigClangFunctionDecl_getBody; + extern fn ZigClangFunctionDecl_getBody(*const FunctionDecl) *const Stmt; + + pub const doesDeclarationForceExternallyVisibleDefinition = ZigClangFunctionDecl_doesDeclarationForceExternallyVisibleDefinition; + extern fn ZigClangFunctionDecl_doesDeclarationForceExternallyVisibleDefinition(*const FunctionDecl) bool; + + pub const isThisDeclarationADefinition = ZigClangFunctionDecl_isThisDeclarationADefinition; + extern fn ZigClangFunctionDecl_isThisDeclarationADefinition(*const FunctionDecl) bool; + + pub const doesThisDeclarationHaveABody = ZigClangFunctionDecl_doesThisDeclarationHaveABody; + extern fn ZigClangFunctionDecl_doesThisDeclarationHaveABody(*const FunctionDecl) bool; + + pub const isInlineSpecified = ZigClangFunctionDecl_isInlineSpecified; + extern fn ZigClangFunctionDecl_isInlineSpecified(*const FunctionDecl) bool; + + pub const isDefined = ZigClangFunctionDecl_isDefined; + extern fn ZigClangFunctionDecl_isDefined(*const FunctionDecl) bool; + + pub const getDefinition = ZigClangFunctionDecl_getDefinition; + extern fn ZigClangFunctionDecl_getDefinition(*const FunctionDecl) ?*const FunctionDecl; + + pub const getSectionAttribute = ZigClangFunctionDecl_getSectionAttribute; + extern fn ZigClangFunctionDecl_getSectionAttribute(*const FunctionDecl, len: *usize) ?[*]const u8; + + pub const getCanonicalDecl = ZigClangFunctionDecl_getCanonicalDecl; + extern fn ZigClangFunctionDecl_getCanonicalDecl(*const FunctionDecl) ?*const FunctionDecl; + + pub const getAlignedAttribute = ZigClangFunctionDecl_getAlignedAttribute; + extern fn ZigClangFunctionDecl_getAlignedAttribute(*const FunctionDecl, *const ASTContext) c_uint; +}; + +pub const FunctionProtoType = opaque { + pub const isVariadic = ZigClangFunctionProtoType_isVariadic; + extern fn ZigClangFunctionProtoType_isVariadic(*const FunctionProtoType) bool; + + pub const getNumParams = ZigClangFunctionProtoType_getNumParams; + extern fn ZigClangFunctionProtoType_getNumParams(*const FunctionProtoType) c_uint; + + pub const getParamType = ZigClangFunctionProtoType_getParamType; + extern fn ZigClangFunctionProtoType_getParamType(*const FunctionProtoType, i: c_uint) QualType; + + pub const getReturnType = ZigClangFunctionProtoType_getReturnType; + extern fn ZigClangFunctionProtoType_getReturnType(*const FunctionProtoType) QualType; +}; + +pub const FunctionType = opaque { + pub const getNoReturnAttr = ZigClangFunctionType_getNoReturnAttr; + extern fn ZigClangFunctionType_getNoReturnAttr(*const FunctionType) bool; + + pub const getCallConv = ZigClangFunctionType_getCallConv; + extern fn ZigClangFunctionType_getCallConv(*const FunctionType) CallingConv; + + pub const getReturnType = ZigClangFunctionType_getReturnType; + extern fn ZigClangFunctionType_getReturnType(*const FunctionType) QualType; +}; + +pub const IfStmt = opaque { + pub const getThen = ZigClangIfStmt_getThen; + extern fn ZigClangIfStmt_getThen(*const IfStmt) *const Stmt; + + pub const getElse = ZigClangIfStmt_getElse; + extern fn ZigClangIfStmt_getElse(*const IfStmt) ?*const Stmt; + + pub const getCond = ZigClangIfStmt_getCond; + extern fn ZigClangIfStmt_getCond(*const IfStmt) *const Stmt; +}; + +pub const ImplicitCastExpr = opaque { + pub const getBeginLoc = ZigClangImplicitCastExpr_getBeginLoc; + extern fn ZigClangImplicitCastExpr_getBeginLoc(*const ImplicitCastExpr) SourceLocation; + + pub const getCastKind = ZigClangImplicitCastExpr_getCastKind; + extern fn ZigClangImplicitCastExpr_getCastKind(*const ImplicitCastExpr) CK; + + pub const getSubExpr = ZigClangImplicitCastExpr_getSubExpr; + extern fn ZigClangImplicitCastExpr_getSubExpr(*const ImplicitCastExpr) *const Expr; +}; + +pub const IncompleteArrayType = opaque { + pub const getElementType = ZigClangIncompleteArrayType_getElementType; + extern fn ZigClangIncompleteArrayType_getElementType(*const IncompleteArrayType) QualType; +}; + +pub const IntegerLiteral = opaque { + pub const EvaluateAsInt = ZigClangIntegerLiteral_EvaluateAsInt; + extern fn ZigClangIntegerLiteral_EvaluateAsInt(*const IntegerLiteral, *ExprEvalResult, *const ASTContext) bool; + + pub const getBeginLoc = ZigClangIntegerLiteral_getBeginLoc; + extern fn ZigClangIntegerLiteral_getBeginLoc(*const IntegerLiteral) SourceLocation; + + pub const isZero = ZigClangIntegerLiteral_isZero; + extern fn ZigClangIntegerLiteral_isZero(*const IntegerLiteral, *bool, *const ASTContext) bool; +}; + +pub const MacroDefinitionRecord = opaque { + pub const getName_getNameStart = ZigClangMacroDefinitionRecord_getName_getNameStart; + extern fn ZigClangMacroDefinitionRecord_getName_getNameStart(*const MacroDefinitionRecord) [*:0]const u8; + + pub const getSourceRange_getBegin = ZigClangMacroDefinitionRecord_getSourceRange_getBegin; + extern fn ZigClangMacroDefinitionRecord_getSourceRange_getBegin(*const MacroDefinitionRecord) SourceLocation; + + pub const getSourceRange_getEnd = ZigClangMacroDefinitionRecord_getSourceRange_getEnd; + extern fn ZigClangMacroDefinitionRecord_getSourceRange_getEnd(*const MacroDefinitionRecord) SourceLocation; +}; + +pub const MacroQualifiedType = opaque { + pub const getModifiedType = ZigClangMacroQualifiedType_getModifiedType; + extern fn ZigClangMacroQualifiedType_getModifiedType(*const MacroQualifiedType) QualType; +}; + +pub const MemberExpr = opaque { + pub const getBase = ZigClangMemberExpr_getBase; + extern fn ZigClangMemberExpr_getBase(*const MemberExpr) *const Expr; + + pub const isArrow = ZigClangMemberExpr_isArrow; + extern fn ZigClangMemberExpr_isArrow(*const MemberExpr) bool; + + pub const getMemberDecl = ZigClangMemberExpr_getMemberDecl; + extern fn ZigClangMemberExpr_getMemberDecl(*const MemberExpr) *const ValueDecl; +}; + +pub const NamedDecl = opaque { + pub const getName_bytes_begin = ZigClangNamedDecl_getName_bytes_begin; + extern fn ZigClangNamedDecl_getName_bytes_begin(decl: *const NamedDecl) [*:0]const u8; +}; + +pub const None = opaque {}; + +pub const OpaqueValueExpr = opaque { + pub const getSourceExpr = ZigClangOpaqueValueExpr_getSourceExpr; + extern fn ZigClangOpaqueValueExpr_getSourceExpr(*const OpaqueValueExpr) ?*const Expr; +}; + +pub const PCHContainerOperations = opaque {}; + +pub const ParenExpr = opaque { + pub const getSubExpr = ZigClangParenExpr_getSubExpr; + extern fn ZigClangParenExpr_getSubExpr(*const ParenExpr) *const Expr; +}; + +pub const ParenType = opaque { + pub const getInnerType = ZigClangParenType_getInnerType; + extern fn ZigClangParenType_getInnerType(*const ParenType) QualType; +}; + +pub const ParmVarDecl = opaque { + pub const getOriginalType = ZigClangParmVarDecl_getOriginalType; + extern fn ZigClangParmVarDecl_getOriginalType(*const ParmVarDecl) QualType; +}; + +pub const PointerType = opaque {}; + +pub const PredefinedExpr = opaque { + pub const getFunctionName = ZigClangPredefinedExpr_getFunctionName; + extern fn ZigClangPredefinedExpr_getFunctionName(*const PredefinedExpr) *const StringLiteral; +}; + +pub const PreprocessedEntity = opaque { + pub const getKind = ZigClangPreprocessedEntity_getKind; + extern fn ZigClangPreprocessedEntity_getKind(*const PreprocessedEntity) PreprocessedEntity_EntityKind; +}; + +pub const PreprocessingRecord = opaque { + pub const iterator = extern struct { + I: c_int, + Self: *PreprocessingRecord, + + pub const deref = ZigClangPreprocessingRecord_iterator_deref; + extern fn ZigClangPreprocessingRecord_iterator_deref(iterator) *PreprocessedEntity; + }; +}; + +pub const RecordDecl = opaque { + pub const getCanonicalDecl = ZigClangRecordDecl_getCanonicalDecl; + extern fn ZigClangRecordDecl_getCanonicalDecl(*const RecordDecl) ?*const TagDecl; + + pub const isUnion = ZigClangRecordDecl_isUnion; + extern fn ZigClangRecordDecl_isUnion(*const RecordDecl) bool; + + pub const isStruct = ZigClangRecordDecl_isStruct; + extern fn ZigClangRecordDecl_isStruct(*const RecordDecl) bool; + + pub const isAnonymousStructOrUnion = ZigClangRecordDecl_isAnonymousStructOrUnion; + extern fn ZigClangRecordDecl_isAnonymousStructOrUnion(record_decl: ?*const RecordDecl) bool; + + pub const getPackedAttribute = ZigClangRecordDecl_getPackedAttribute; + extern fn ZigClangRecordDecl_getPackedAttribute(*const RecordDecl) bool; + + pub const getDefinition = ZigClangRecordDecl_getDefinition; + extern fn ZigClangRecordDecl_getDefinition(*const RecordDecl) ?*const RecordDecl; + + pub const getLocation = ZigClangRecordDecl_getLocation; + extern fn ZigClangRecordDecl_getLocation(*const RecordDecl) SourceLocation; + + pub const field_begin = ZigClangRecordDecl_field_begin; + extern fn ZigClangRecordDecl_field_begin(*const RecordDecl) field_iterator; + + pub const field_end = ZigClangRecordDecl_field_end; + extern fn ZigClangRecordDecl_field_end(*const RecordDecl) field_iterator; + + pub const field_iterator = extern struct { + ptr: *c_void, + + pub const next = ZigClangRecordDecl_field_iterator_next; + extern fn ZigClangRecordDecl_field_iterator_next(field_iterator) field_iterator; + + pub const deref = ZigClangRecordDecl_field_iterator_deref; + extern fn ZigClangRecordDecl_field_iterator_deref(field_iterator) *const FieldDecl; + + pub const neq = ZigClangRecordDecl_field_iterator_neq; + extern fn ZigClangRecordDecl_field_iterator_neq(field_iterator, field_iterator) bool; + }; +}; + +pub const RecordType = opaque { + pub const getDecl = ZigClangRecordType_getDecl; + extern fn ZigClangRecordType_getDecl(*const RecordType) *const RecordDecl; +}; + +pub const ReturnStmt = opaque { + pub const getRetValue = ZigClangReturnStmt_getRetValue; + extern fn ZigClangReturnStmt_getRetValue(*const ReturnStmt) ?*const Expr; +}; + +pub const SkipFunctionBodiesScope = opaque {}; + +pub const SourceManager = opaque { + pub const getSpellingLoc = ZigClangSourceManager_getSpellingLoc; + extern fn ZigClangSourceManager_getSpellingLoc(*const SourceManager, Loc: SourceLocation) SourceLocation; + + pub const getFilename = ZigClangSourceManager_getFilename; + extern fn ZigClangSourceManager_getFilename(*const SourceManager, SpellingLoc: SourceLocation) ?[*:0]const u8; + + pub const getSpellingLineNumber = ZigClangSourceManager_getSpellingLineNumber; + extern fn ZigClangSourceManager_getSpellingLineNumber(*const SourceManager, Loc: SourceLocation) c_uint; + + pub const getSpellingColumnNumber = ZigClangSourceManager_getSpellingColumnNumber; + extern fn ZigClangSourceManager_getSpellingColumnNumber(*const SourceManager, Loc: SourceLocation) c_uint; + + pub const getCharacterData = ZigClangSourceManager_getCharacterData; + extern fn ZigClangSourceManager_getCharacterData(*const SourceManager, SL: SourceLocation) [*:0]const u8; +}; + +pub const SourceRange = opaque {}; + +pub const Stmt = opaque { + pub const getBeginLoc = ZigClangStmt_getBeginLoc; + extern fn ZigClangStmt_getBeginLoc(*const Stmt) SourceLocation; + + pub const getStmtClass = ZigClangStmt_getStmtClass; + extern fn ZigClangStmt_getStmtClass(*const Stmt) StmtClass; + + pub const classof_Expr = ZigClangStmt_classof_Expr; + extern fn ZigClangStmt_classof_Expr(*const Stmt) bool; +}; + +pub const StmtExpr = opaque { + pub const getSubStmt = ZigClangStmtExpr_getSubStmt; + extern fn ZigClangStmtExpr_getSubStmt(*const StmtExpr) *const CompoundStmt; +}; + +pub const StringLiteral = opaque { + pub const getKind = ZigClangStringLiteral_getKind; + extern fn ZigClangStringLiteral_getKind(*const StringLiteral) StringLiteral_StringKind; + + pub const getString_bytes_begin_size = ZigClangStringLiteral_getString_bytes_begin_size; + extern fn ZigClangStringLiteral_getString_bytes_begin_size(*const StringLiteral, *usize) [*]const u8; +}; + +pub const StringRef = opaque {}; + +pub const SwitchStmt = opaque { + pub const getConditionVariableDeclStmt = ZigClangSwitchStmt_getConditionVariableDeclStmt; + extern fn ZigClangSwitchStmt_getConditionVariableDeclStmt(*const SwitchStmt) ?*const DeclStmt; + + pub const getCond = ZigClangSwitchStmt_getCond; + extern fn ZigClangSwitchStmt_getCond(*const SwitchStmt) *const Expr; + + pub const getBody = ZigClangSwitchStmt_getBody; + extern fn ZigClangSwitchStmt_getBody(*const SwitchStmt) *const Stmt; + + pub const isAllEnumCasesCovered = ZigClangSwitchStmt_isAllEnumCasesCovered; + extern fn ZigClangSwitchStmt_isAllEnumCasesCovered(*const SwitchStmt) bool; +}; + +pub const TagDecl = opaque { + pub const isThisDeclarationADefinition = ZigClangTagDecl_isThisDeclarationADefinition; + extern fn ZigClangTagDecl_isThisDeclarationADefinition(*const TagDecl) bool; +}; + +pub const Type = opaque { + pub const getTypeClass = ZigClangType_getTypeClass; + extern fn ZigClangType_getTypeClass(*const Type) TypeClass; + + pub const getPointeeType = ZigClangType_getPointeeType; + extern fn ZigClangType_getPointeeType(*const Type) QualType; + + pub const isVoidType = ZigClangType_isVoidType; + extern fn ZigClangType_isVoidType(*const Type) bool; + + pub const isConstantArrayType = ZigClangType_isConstantArrayType; + extern fn ZigClangType_isConstantArrayType(*const Type) bool; + + pub const isRecordType = ZigClangType_isRecordType; + extern fn ZigClangType_isRecordType(*const Type) bool; + + pub const isIncompleteOrZeroLengthArrayType = ZigClangType_isIncompleteOrZeroLengthArrayType; + extern fn ZigClangType_isIncompleteOrZeroLengthArrayType(*const Type, *const ASTContext) bool; + + pub const isArrayType = ZigClangType_isArrayType; + extern fn ZigClangType_isArrayType(*const Type) bool; + + pub const isBooleanType = ZigClangType_isBooleanType; + extern fn ZigClangType_isBooleanType(*const Type) bool; + + pub const getTypeClassName = ZigClangType_getTypeClassName; + extern fn ZigClangType_getTypeClassName(*const Type) [*:0]const u8; + + pub const getAsArrayTypeUnsafe = ZigClangType_getAsArrayTypeUnsafe; + extern fn ZigClangType_getAsArrayTypeUnsafe(*const Type) *const ArrayType; + + pub const getAsRecordType = ZigClangType_getAsRecordType; + extern fn ZigClangType_getAsRecordType(*const Type) ?*const RecordType; + + pub const getAsUnionType = ZigClangType_getAsUnionType; + extern fn ZigClangType_getAsUnionType(*const Type) ?*const RecordType; +}; + +pub const TypedefNameDecl = opaque { + pub const getUnderlyingType = ZigClangTypedefNameDecl_getUnderlyingType; + extern fn ZigClangTypedefNameDecl_getUnderlyingType(*const TypedefNameDecl) QualType; + + pub const getCanonicalDecl = ZigClangTypedefNameDecl_getCanonicalDecl; + extern fn ZigClangTypedefNameDecl_getCanonicalDecl(*const TypedefNameDecl) ?*const TypedefNameDecl; + + pub const getLocation = ZigClangTypedefNameDecl_getLocation; + extern fn ZigClangTypedefNameDecl_getLocation(*const TypedefNameDecl) SourceLocation; +}; + +pub const TypedefType = opaque { + pub const getDecl = ZigClangTypedefType_getDecl; + extern fn ZigClangTypedefType_getDecl(*const TypedefType) *const TypedefNameDecl; +}; + +pub const UnaryExprOrTypeTraitExpr = opaque { + pub const getTypeOfArgument = ZigClangUnaryExprOrTypeTraitExpr_getTypeOfArgument; + extern fn ZigClangUnaryExprOrTypeTraitExpr_getTypeOfArgument(*const UnaryExprOrTypeTraitExpr) QualType; + + pub const getBeginLoc = ZigClangUnaryExprOrTypeTraitExpr_getBeginLoc; + extern fn ZigClangUnaryExprOrTypeTraitExpr_getBeginLoc(*const UnaryExprOrTypeTraitExpr) SourceLocation; + + pub const getKind = ZigClangUnaryExprOrTypeTraitExpr_getKind; + extern fn ZigClangUnaryExprOrTypeTraitExpr_getKind(*const UnaryExprOrTypeTraitExpr) UnaryExprOrTypeTrait_Kind; +}; + +pub const UnaryOperator = opaque { + pub const getOpcode = ZigClangUnaryOperator_getOpcode; + extern fn ZigClangUnaryOperator_getOpcode(*const UnaryOperator) UO; + + pub const getType = ZigClangUnaryOperator_getType; + extern fn ZigClangUnaryOperator_getType(*const UnaryOperator) QualType; + + pub const getSubExpr = ZigClangUnaryOperator_getSubExpr; + extern fn ZigClangUnaryOperator_getSubExpr(*const UnaryOperator) *const Expr; + + pub const getBeginLoc = ZigClangUnaryOperator_getBeginLoc; + extern fn ZigClangUnaryOperator_getBeginLoc(*const UnaryOperator) SourceLocation; +}; + +pub const ValueDecl = opaque {}; + +pub const VarDecl = opaque { + pub const getLocation = ZigClangVarDecl_getLocation; + extern fn ZigClangVarDecl_getLocation(*const VarDecl) SourceLocation; + + pub const hasInit = ZigClangVarDecl_hasInit; + extern fn ZigClangVarDecl_hasInit(*const VarDecl) bool; + + pub const getStorageClass = ZigClangVarDecl_getStorageClass; + extern fn ZigClangVarDecl_getStorageClass(*const VarDecl) StorageClass; + + pub const getType = ZigClangVarDecl_getType; + extern fn ZigClangVarDecl_getType(*const VarDecl) QualType; + + pub const getInit = ZigClangVarDecl_getInit; + extern fn ZigClangVarDecl_getInit(*const VarDecl) ?*const Expr; + + pub const getTLSKind = ZigClangVarDecl_getTLSKind; + extern fn ZigClangVarDecl_getTLSKind(*const VarDecl) VarDecl_TLSKind; + + pub const getCanonicalDecl = ZigClangVarDecl_getCanonicalDecl; + extern fn ZigClangVarDecl_getCanonicalDecl(*const VarDecl) ?*const VarDecl; + + pub const getSectionAttribute = ZigClangVarDecl_getSectionAttribute; + extern fn ZigClangVarDecl_getSectionAttribute(*const VarDecl, len: *usize) ?[*]const u8; + + pub const getAlignedAttribute = ZigClangVarDecl_getAlignedAttribute; + extern fn ZigClangVarDecl_getAlignedAttribute(*const VarDecl, *const ASTContext) c_uint; + + pub const getTypeSourceInfo_getType = ZigClangVarDecl_getTypeSourceInfo_getType; + extern fn ZigClangVarDecl_getTypeSourceInfo_getType(*const VarDecl) QualType; +}; + +pub const WhileStmt = opaque { + pub const getCond = ZigClangWhileStmt_getCond; + extern fn ZigClangWhileStmt_getCond(*const WhileStmt) *const Expr; + + pub const getBody = ZigClangWhileStmt_getBody; + extern fn ZigClangWhileStmt_getBody(*const WhileStmt) *const Stmt; +}; + +pub const InitListExpr = opaque { + pub const getInit = ZigClangInitListExpr_getInit; + extern fn ZigClangInitListExpr_getInit(*const InitListExpr, i: c_uint) *const Expr; + + pub const getArrayFiller = ZigClangInitListExpr_getArrayFiller; + extern fn ZigClangInitListExpr_getArrayFiller(*const InitListExpr) *const Expr; + + pub const getNumInits = ZigClangInitListExpr_getNumInits; + extern fn ZigClangInitListExpr_getNumInits(*const InitListExpr) c_uint; + + pub const getInitializedFieldInUnion = ZigClangInitListExpr_getInitializedFieldInUnion; + extern fn ZigClangInitListExpr_getInitializedFieldInUnion(*const InitListExpr) ?*FieldDecl; +}; + +pub const BO = extern enum { PtrMemD, PtrMemI, Mul, @@ -121,7 +931,7 @@ pub const ZigClangBO = extern enum { Comma, }; -pub const ZigClangUO = extern enum { +pub const UO = extern enum { PostInc, PostDec, PreInc, @@ -138,7 +948,7 @@ pub const ZigClangUO = extern enum { Coawait, }; -pub const ZigClangTypeClass = extern enum { +pub const TypeClass = extern enum { Adjusted, Decayed, ConstantArray, @@ -189,7 +999,7 @@ pub const ZigClangTypeClass = extern enum { ExtVector, }; -const ZigClangStmtClass = extern enum { +const StmtClass = extern enum { NoStmtClass, GCCAsmStmtClass, MSAsmStmtClass, @@ -399,7 +1209,7 @@ const ZigClangStmtClass = extern enum { WhileStmtClass, }; -pub const ZigClangCK = extern enum { +pub const CK = extern enum { Dependent, BitCast, LValueBitCast, @@ -464,24 +1274,7 @@ pub const ZigClangCK = extern enum { IntToOCLSampler, }; -pub const ZigClangAPValueKind = extern enum { - None, - Indeterminate, - Int, - Float, - FixedPoint, - ComplexInt, - ComplexFloat, - LValue, - Vector, - Array, - Struct, - Union, - MemberPointer, - AddrLabelDiff, -}; - -pub const ZigClangDeclKind = extern enum { +pub const DeclKind = extern enum { AccessSpec, Block, Captured, @@ -563,7 +1356,7 @@ pub const ZigClangDeclKind = extern enum { TranslationUnit, }; -pub const ZigClangBuiltinTypeKind = extern enum { +pub const BuiltinTypeKind = extern enum { OCLImage1dRO, OCLImage1dArrayRO, OCLImage1dBufferRO, @@ -694,7 +1487,7 @@ pub const ZigClangBuiltinTypeKind = extern enum { OMPArraySection, }; -pub const ZigClangCallingConv = extern enum { +pub const CallingConv = extern enum { C, X86StdCall, X86FastCall, @@ -715,7 +1508,7 @@ pub const ZigClangCallingConv = extern enum { AArch64VectorCall, }; -pub const ZigClangStorageClass = extern enum { +pub const StorageClass = extern enum { None, Extern, Static, @@ -724,7 +1517,7 @@ pub const ZigClangStorageClass = extern enum { Register, }; -pub const ZigClangAPFloat_roundingMode = extern enum { +pub const APFloat_roundingMode = extern enum { NearestTiesToEven, TowardPositive, TowardNegative, @@ -732,7 +1525,7 @@ pub const ZigClangAPFloat_roundingMode = extern enum { NearestTiesToAway, }; -pub const ZigClangStringLiteral_StringKind = extern enum { +pub const StringLiteral_StringKind = extern enum { Ascii, Wide, UTF8, @@ -740,7 +1533,7 @@ pub const ZigClangStringLiteral_StringKind = extern enum { UTF32, }; -pub const ZigClangCharacterLiteral_CharacterKind = extern enum { +pub const CharacterLiteral_CharacterKind = extern enum { Ascii, Wide, UTF8, @@ -748,32 +1541,35 @@ pub const ZigClangCharacterLiteral_CharacterKind = extern enum { UTF32, }; -pub const ZigClangRecordDecl_field_iterator = extern struct { - ptr: *c_void, +pub const VarDecl_TLSKind = extern enum { + None, + Static, + Dynamic, }; -pub const ZigClangEnumDecl_enumerator_iterator = extern struct { - ptr: *c_void, +pub const ElaboratedTypeKeyword = extern enum { + Struct, + Interface, + Union, + Class, + Enum, + Typename, + None, }; -pub const ZigClangPreprocessingRecord_iterator = extern struct { - I: c_int, - Self: *ZigClangPreprocessingRecord, -}; - -pub const ZigClangPreprocessedEntity_EntityKind = extern enum { +pub const PreprocessedEntity_EntityKind = extern enum { InvalidKind, MacroExpansionKind, MacroDefinitionKind, InclusionDirectiveKind, }; -pub const ZigClangExpr_ConstExprUsage = extern enum { +pub const Expr_ConstExprUsage = extern enum { EvaluateForCodeGen, EvaluateForMangling, }; -pub const ZigClangUnaryExprOrTypeTrait_Kind = extern enum { +pub const UnaryExprOrTypeTrait_Kind = extern enum { SizeOf, AlignOf, VecStep, @@ -781,211 +1577,6 @@ pub const ZigClangUnaryExprOrTypeTrait_Kind = extern enum { PreferredAlignOf, }; -pub extern fn ZigClangSourceManager_getSpellingLoc(self: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) struct_ZigClangSourceLocation; -pub extern fn ZigClangSourceManager_getFilename(self: *const struct_ZigClangSourceManager, SpellingLoc: struct_ZigClangSourceLocation) ?[*:0]const u8; -pub extern fn ZigClangSourceManager_getSpellingLineNumber(self: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) c_uint; -pub extern fn ZigClangSourceManager_getSpellingColumnNumber(self: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) c_uint; -pub extern fn ZigClangSourceManager_getCharacterData(self: ?*const struct_ZigClangSourceManager, SL: struct_ZigClangSourceLocation) [*:0]const u8; -pub extern fn ZigClangASTContext_getPointerType(self: ?*const struct_ZigClangASTContext, T: struct_ZigClangQualType) struct_ZigClangQualType; -pub extern fn ZigClangASTUnit_getASTContext(self: ?*struct_ZigClangASTUnit) ?*struct_ZigClangASTContext; -pub extern fn ZigClangASTUnit_getSourceManager(self: *struct_ZigClangASTUnit) *struct_ZigClangSourceManager; -pub extern fn ZigClangASTUnit_visitLocalTopLevelDecls(self: *struct_ZigClangASTUnit, context: ?*c_void, Fn: ?fn (?*c_void, *const ZigClangDecl) callconv(.C) bool) bool; -pub extern fn ZigClangRecordType_getDecl(record_ty: ?*const struct_ZigClangRecordType) *const struct_ZigClangRecordDecl; -pub extern fn ZigClangTagDecl_isThisDeclarationADefinition(self: *const ZigClangTagDecl) bool; -pub extern fn ZigClangEnumType_getDecl(record_ty: ?*const struct_ZigClangEnumType) *const struct_ZigClangEnumDecl; -pub extern fn ZigClangRecordDecl_getCanonicalDecl(record_decl: ?*const struct_ZigClangRecordDecl) ?*const struct_ZigClangTagDecl; -pub extern fn ZigClangFieldDecl_getCanonicalDecl(field_decl: ?*const struct_ZigClangFieldDecl) ?*const struct_ZigClangFieldDecl; -pub extern fn ZigClangFieldDecl_getAlignedAttribute(field_decl: ?*const struct_ZigClangFieldDecl, *const ZigClangASTContext) c_uint; -pub extern fn ZigClangEnumDecl_getCanonicalDecl(self: ?*const struct_ZigClangEnumDecl) ?*const struct_ZigClangTagDecl; -pub extern fn ZigClangTypedefNameDecl_getCanonicalDecl(self: ?*const struct_ZigClangTypedefNameDecl) ?*const struct_ZigClangTypedefNameDecl; -pub extern fn ZigClangFunctionDecl_getCanonicalDecl(self: ?*const struct_ZigClangFunctionDecl) ?*const struct_ZigClangFunctionDecl; -pub extern fn ZigClangParmVarDecl_getOriginalType(self: ?*const struct_ZigClangParmVarDecl) struct_ZigClangQualType; -pub extern fn ZigClangVarDecl_getCanonicalDecl(self: ?*const struct_ZigClangVarDecl) ?*const struct_ZigClangVarDecl; -pub extern fn ZigClangVarDecl_getSectionAttribute(self: *const ZigClangVarDecl, len: *usize) ?[*]const u8; -pub extern fn ZigClangFunctionDecl_getAlignedAttribute(self: *const ZigClangFunctionDecl, *const ZigClangASTContext) c_uint; -pub extern fn ZigClangVarDecl_getAlignedAttribute(self: *const ZigClangVarDecl, *const ZigClangASTContext) c_uint; -pub extern fn ZigClangRecordDecl_getPackedAttribute(self: ?*const struct_ZigClangRecordDecl) bool; -pub extern fn ZigClangRecordDecl_getDefinition(self: ?*const struct_ZigClangRecordDecl) ?*const struct_ZigClangRecordDecl; -pub extern fn ZigClangEnumDecl_getDefinition(self: ?*const struct_ZigClangEnumDecl) ?*const struct_ZigClangEnumDecl; -pub extern fn ZigClangRecordDecl_getLocation(self: ?*const struct_ZigClangRecordDecl) struct_ZigClangSourceLocation; -pub extern fn ZigClangEnumDecl_getLocation(self: ?*const struct_ZigClangEnumDecl) struct_ZigClangSourceLocation; -pub extern fn ZigClangTypedefNameDecl_getLocation(self: ?*const struct_ZigClangTypedefNameDecl) struct_ZigClangSourceLocation; -pub extern fn ZigClangDecl_getLocation(self: *const ZigClangDecl) ZigClangSourceLocation; -pub extern fn ZigClangRecordDecl_isUnion(record_decl: ?*const struct_ZigClangRecordDecl) bool; -pub extern fn ZigClangRecordDecl_isStruct(record_decl: ?*const struct_ZigClangRecordDecl) bool; -pub extern fn ZigClangRecordDecl_isAnonymousStructOrUnion(record_decl: ?*const struct_ZigClangRecordDecl) bool; -pub extern fn ZigClangRecordDecl_field_begin(*const struct_ZigClangRecordDecl) ZigClangRecordDecl_field_iterator; -pub extern fn ZigClangRecordDecl_field_end(*const struct_ZigClangRecordDecl) ZigClangRecordDecl_field_iterator; -pub extern fn ZigClangRecordDecl_field_iterator_next(ZigClangRecordDecl_field_iterator) ZigClangRecordDecl_field_iterator; -pub extern fn ZigClangRecordDecl_field_iterator_deref(ZigClangRecordDecl_field_iterator) *const struct_ZigClangFieldDecl; -pub extern fn ZigClangRecordDecl_field_iterator_neq(ZigClangRecordDecl_field_iterator, ZigClangRecordDecl_field_iterator) bool; -pub extern fn ZigClangEnumDecl_getIntegerType(self: ?*const struct_ZigClangEnumDecl) struct_ZigClangQualType; -pub extern fn ZigClangEnumDecl_enumerator_begin(*const ZigClangEnumDecl) ZigClangEnumDecl_enumerator_iterator; -pub extern fn ZigClangEnumDecl_enumerator_end(*const ZigClangEnumDecl) ZigClangEnumDecl_enumerator_iterator; -pub extern fn ZigClangEnumDecl_enumerator_iterator_next(ZigClangEnumDecl_enumerator_iterator) ZigClangEnumDecl_enumerator_iterator; -pub extern fn ZigClangEnumDecl_enumerator_iterator_deref(ZigClangEnumDecl_enumerator_iterator) *const ZigClangEnumConstantDecl; -pub extern fn ZigClangEnumDecl_enumerator_iterator_neq(ZigClangEnumDecl_enumerator_iterator, ZigClangEnumDecl_enumerator_iterator) bool; -pub extern fn ZigClangDecl_castToNamedDecl(decl: *const ZigClangDecl) ?*const ZigClangNamedDecl; -pub extern fn ZigClangNamedDecl_getName_bytes_begin(decl: ?*const struct_ZigClangNamedDecl) [*:0]const u8; -pub extern fn ZigClangSourceLocation_eq(a: struct_ZigClangSourceLocation, b: struct_ZigClangSourceLocation) bool; -pub extern fn ZigClangTypedefType_getDecl(self: ?*const struct_ZigClangTypedefType) *const struct_ZigClangTypedefNameDecl; -pub extern fn ZigClangTypedefNameDecl_getUnderlyingType(self: ?*const struct_ZigClangTypedefNameDecl) struct_ZigClangQualType; -pub extern fn ZigClangQualType_getCanonicalType(self: struct_ZigClangQualType) struct_ZigClangQualType; -pub extern fn ZigClangQualType_getTypeClass(self: struct_ZigClangQualType) ZigClangTypeClass; -pub extern fn ZigClangQualType_getTypePtr(self: struct_ZigClangQualType) *const struct_ZigClangType; -pub extern fn ZigClangQualType_addConst(self: *struct_ZigClangQualType) void; -pub extern fn ZigClangQualType_eq(self: struct_ZigClangQualType, arg1: struct_ZigClangQualType) bool; -pub extern fn ZigClangQualType_isConstQualified(self: struct_ZigClangQualType) bool; -pub extern fn ZigClangQualType_isVolatileQualified(self: struct_ZigClangQualType) bool; -pub extern fn ZigClangQualType_isRestrictQualified(self: struct_ZigClangQualType) bool; -pub extern fn ZigClangType_getTypeClass(self: ?*const struct_ZigClangType) ZigClangTypeClass; -pub extern fn ZigClangType_getPointeeType(self: ?*const struct_ZigClangType) struct_ZigClangQualType; -pub extern fn ZigClangType_isVoidType(self: ?*const struct_ZigClangType) bool; -pub extern fn ZigClangType_isConstantArrayType(self: ?*const struct_ZigClangType) bool; -pub extern fn ZigClangType_isRecordType(self: ?*const struct_ZigClangType) bool; -pub extern fn ZigClangType_isIncompleteOrZeroLengthArrayType(self: ?*const struct_ZigClangType, *const ZigClangASTContext) bool; -pub extern fn ZigClangType_isArrayType(self: ?*const struct_ZigClangType) bool; -pub extern fn ZigClangType_isBooleanType(self: ?*const struct_ZigClangType) bool; -pub extern fn ZigClangType_getTypeClassName(self: *const struct_ZigClangType) [*:0]const u8; -pub extern fn ZigClangType_getAsArrayTypeUnsafe(self: *const ZigClangType) *const ZigClangArrayType; -pub extern fn ZigClangType_getAsRecordType(self: *const ZigClangType) ?*const ZigClangRecordType; -pub extern fn ZigClangType_getAsUnionType(self: *const ZigClangType) ?*const ZigClangRecordType; -pub extern fn ZigClangStmt_getBeginLoc(self: *const ZigClangStmt) struct_ZigClangSourceLocation; -pub extern fn ZigClangStmt_getStmtClass(self: ?*const ZigClangStmt) ZigClangStmtClass; -pub extern fn ZigClangStmt_classof_Expr(self: ?*const ZigClangStmt) bool; -pub extern fn ZigClangExpr_getStmtClass(self: *const struct_ZigClangExpr) ZigClangStmtClass; -pub extern fn ZigClangExpr_getType(self: *const struct_ZigClangExpr) struct_ZigClangQualType; -pub extern fn ZigClangExpr_getBeginLoc(self: *const struct_ZigClangExpr) struct_ZigClangSourceLocation; -pub extern fn ZigClangInitListExpr_getInit(self: ?*const struct_ZigClangInitListExpr, i: c_uint) *const ZigClangExpr; -pub extern fn ZigClangInitListExpr_getArrayFiller(self: ?*const struct_ZigClangInitListExpr) *const ZigClangExpr; -pub extern fn ZigClangInitListExpr_getNumInits(self: ?*const struct_ZigClangInitListExpr) c_uint; -pub extern fn ZigClangInitListExpr_getInitializedFieldInUnion(self: ?*const struct_ZigClangInitListExpr) ?*ZigClangFieldDecl; -pub extern fn ZigClangAPValue_getKind(self: ?*const struct_ZigClangAPValue) ZigClangAPValueKind; -pub extern fn ZigClangAPValue_getInt(self: ?*const struct_ZigClangAPValue) *const struct_ZigClangAPSInt; -pub extern fn ZigClangAPValue_getArrayInitializedElts(self: ?*const struct_ZigClangAPValue) c_uint; -pub extern fn ZigClangAPValue_getArraySize(self: ?*const struct_ZigClangAPValue) c_uint; -pub extern fn ZigClangAPValue_getLValueBase(self: ?*const struct_ZigClangAPValue) struct_ZigClangAPValueLValueBase; -pub extern fn ZigClangAPSInt_isSigned(self: *const struct_ZigClangAPSInt) bool; -pub extern fn ZigClangAPSInt_isNegative(self: *const struct_ZigClangAPSInt) bool; -pub extern fn ZigClangAPSInt_negate(self: *const struct_ZigClangAPSInt) *const struct_ZigClangAPSInt; -pub extern fn ZigClangAPSInt_free(self: *const struct_ZigClangAPSInt) void; -pub extern fn ZigClangAPSInt_getRawData(self: *const struct_ZigClangAPSInt) [*:0]const u64; -pub extern fn ZigClangAPSInt_getNumWords(self: *const struct_ZigClangAPSInt) c_uint; - -pub extern fn ZigClangAPInt_getLimitedValue(self: *const struct_ZigClangAPInt, limit: u64) u64; -pub extern fn ZigClangAPValueLValueBase_dyn_cast_Expr(self: struct_ZigClangAPValueLValueBase) ?*const struct_ZigClangExpr; -pub extern fn ZigClangASTUnit_delete(self: ?*struct_ZigClangASTUnit) void; - -pub extern fn ZigClangFunctionDecl_getType(self: *const ZigClangFunctionDecl) struct_ZigClangQualType; -pub extern fn ZigClangFunctionDecl_getLocation(self: *const ZigClangFunctionDecl) struct_ZigClangSourceLocation; -pub extern fn ZigClangFunctionDecl_hasBody(self: *const ZigClangFunctionDecl) bool; -pub extern fn ZigClangFunctionDecl_getStorageClass(self: *const ZigClangFunctionDecl) ZigClangStorageClass; -pub extern fn ZigClangFunctionDecl_getParamDecl(self: *const ZigClangFunctionDecl, i: c_uint) *const struct_ZigClangParmVarDecl; -pub extern fn ZigClangFunctionDecl_getBody(self: *const ZigClangFunctionDecl) *const ZigClangStmt; -pub extern fn ZigClangFunctionDecl_doesDeclarationForceExternallyVisibleDefinition(self: *const ZigClangFunctionDecl) bool; -pub extern fn ZigClangFunctionDecl_isThisDeclarationADefinition(self: *const ZigClangFunctionDecl) bool; -pub extern fn ZigClangFunctionDecl_doesThisDeclarationHaveABody(self: *const ZigClangFunctionDecl) bool; -pub extern fn ZigClangFunctionDecl_isInlineSpecified(self: *const ZigClangFunctionDecl) bool; -pub extern fn ZigClangFunctionDecl_isDefined(self: *const ZigClangFunctionDecl) bool; -pub extern fn ZigClangFunctionDecl_getDefinition(self: *const ZigClangFunctionDecl) ?*const struct_ZigClangFunctionDecl; -pub extern fn ZigClangFunctionDecl_getSectionAttribute(self: *const ZigClangFunctionDecl, len: *usize) ?[*]const u8; - -pub extern fn ZigClangBuiltinType_getKind(self: *const struct_ZigClangBuiltinType) ZigClangBuiltinTypeKind; - -pub extern fn ZigClangFunctionType_getNoReturnAttr(self: *const ZigClangFunctionType) bool; -pub extern fn ZigClangFunctionType_getCallConv(self: *const ZigClangFunctionType) ZigClangCallingConv; -pub extern fn ZigClangFunctionType_getReturnType(self: *const ZigClangFunctionType) ZigClangQualType; - -pub extern fn ZigClangFunctionProtoType_isVariadic(self: *const struct_ZigClangFunctionProtoType) bool; -pub extern fn ZigClangFunctionProtoType_getNumParams(self: *const struct_ZigClangFunctionProtoType) c_uint; -pub extern fn ZigClangFunctionProtoType_getParamType(self: *const struct_ZigClangFunctionProtoType, i: c_uint) ZigClangQualType; -pub extern fn ZigClangFunctionProtoType_getReturnType(self: *const ZigClangFunctionProtoType) ZigClangQualType; - -pub const ZigClangSourceLocation = struct_ZigClangSourceLocation; -pub const ZigClangQualType = struct_ZigClangQualType; -pub const ZigClangConditionalOperator = struct_ZigClangConditionalOperator; -pub const ZigClangBinaryConditionalOperator = struct_ZigClangBinaryConditionalOperator; -pub const ZigClangAbstractConditionalOperator = struct_ZigClangAbstractConditionalOperator; -pub const ZigClangAPValueLValueBase = struct_ZigClangAPValueLValueBase; -pub const ZigClangAPValue = struct_ZigClangAPValue; -pub const ZigClangAPSInt = struct_ZigClangAPSInt; -pub const ZigClangAPFloat = struct_ZigClangAPFloat; -pub const ZigClangASTContext = struct_ZigClangASTContext; -pub const ZigClangASTUnit = struct_ZigClangASTUnit; -pub const ZigClangArraySubscriptExpr = struct_ZigClangArraySubscriptExpr; -pub const ZigClangArrayType = struct_ZigClangArrayType; -pub const ZigClangAttributedType = struct_ZigClangAttributedType; -pub const ZigClangBinaryOperator = struct_ZigClangBinaryOperator; -pub const ZigClangBreakStmt = struct_ZigClangBreakStmt; -pub const ZigClangBuiltinType = struct_ZigClangBuiltinType; -pub const ZigClangCStyleCastExpr = struct_ZigClangCStyleCastExpr; -pub const ZigClangCallExpr = struct_ZigClangCallExpr; -pub const ZigClangCaseStmt = struct_ZigClangCaseStmt; -pub const ZigClangCompoundAssignOperator = struct_ZigClangCompoundAssignOperator; -pub const ZigClangCompoundStmt = struct_ZigClangCompoundStmt; -pub const ZigClangConstantArrayType = struct_ZigClangConstantArrayType; -pub const ZigClangContinueStmt = struct_ZigClangContinueStmt; -pub const ZigClangDecayedType = struct_ZigClangDecayedType; -pub const ZigClangDeclRefExpr = struct_ZigClangDeclRefExpr; -pub const ZigClangDeclStmt = struct_ZigClangDeclStmt; -pub const ZigClangDefaultStmt = struct_ZigClangDefaultStmt; -pub const ZigClangDiagnosticOptions = struct_ZigClangDiagnosticOptions; -pub const ZigClangDiagnosticsEngine = struct_ZigClangDiagnosticsEngine; -pub const ZigClangDoStmt = struct_ZigClangDoStmt; -pub const ZigClangElaboratedType = struct_ZigClangElaboratedType; -pub const ZigClangEnumConstantDecl = struct_ZigClangEnumConstantDecl; -pub const ZigClangEnumDecl = struct_ZigClangEnumDecl; -pub const ZigClangEnumType = struct_ZigClangEnumType; -pub const ZigClangExpr = struct_ZigClangExpr; -pub const ZigClangFieldDecl = struct_ZigClangFieldDecl; -pub const ZigClangFileID = struct_ZigClangFileID; -pub const ZigClangForStmt = struct_ZigClangForStmt; -pub const ZigClangFullSourceLoc = struct_ZigClangFullSourceLoc; -pub const ZigClangFunctionDecl = struct_ZigClangFunctionDecl; -pub const ZigClangFunctionProtoType = struct_ZigClangFunctionProtoType; -pub const ZigClangIfStmt = struct_ZigClangIfStmt; -pub const ZigClangImplicitCastExpr = struct_ZigClangImplicitCastExpr; -pub const ZigClangIncompleteArrayType = struct_ZigClangIncompleteArrayType; -pub const ZigClangIntegerLiteral = struct_ZigClangIntegerLiteral; -pub const ZigClangMacroDefinitionRecord = struct_ZigClangMacroDefinitionRecord; -pub const ZigClangMacroExpansion = struct_ZigClangMacroExpansion; -pub const ZigClangMacroQualifiedType = struct_ZigClangMacroQualifiedType; -pub const ZigClangMemberExpr = struct_ZigClangMemberExpr; -pub const ZigClangNamedDecl = struct_ZigClangNamedDecl; -pub const ZigClangNone = struct_ZigClangNone; -pub const ZigClangOpaqueValueExpr = struct_ZigClangOpaqueValueExpr; -pub const ZigClangPCHContainerOperations = struct_ZigClangPCHContainerOperations; -pub const ZigClangParenExpr = struct_ZigClangParenExpr; -pub const ZigClangParenType = struct_ZigClangParenType; -pub const ZigClangParmVarDecl = struct_ZigClangParmVarDecl; -pub const ZigClangPointerType = struct_ZigClangPointerType; -pub const ZigClangPreprocessedEntity = struct_ZigClangPreprocessedEntity; -pub const ZigClangRecordDecl = struct_ZigClangRecordDecl; -pub const ZigClangRecordType = struct_ZigClangRecordType; -pub const ZigClangReturnStmt = struct_ZigClangReturnStmt; -pub const ZigClangSkipFunctionBodiesScope = struct_ZigClangSkipFunctionBodiesScope; -pub const ZigClangSourceManager = struct_ZigClangSourceManager; -pub const ZigClangSourceRange = struct_ZigClangSourceRange; -pub const ZigClangStringLiteral = struct_ZigClangStringLiteral; -pub const ZigClangStringRef = struct_ZigClangStringRef; -pub const ZigClangSwitchStmt = struct_ZigClangSwitchStmt; -pub const ZigClangTagDecl = struct_ZigClangTagDecl; -pub const ZigClangType = struct_ZigClangType; -pub const ZigClangTypedefNameDecl = struct_ZigClangTypedefNameDecl; -pub const ZigClangTypedefType = struct_ZigClangTypedefType; -pub const ZigClangUnaryExprOrTypeTraitExpr = struct_ZigClangUnaryExprOrTypeTraitExpr; -pub const ZigClangUnaryOperator = struct_ZigClangUnaryOperator; -pub const ZigClangValueDecl = struct_ZigClangValueDecl; -pub const ZigClangVarDecl = struct_ZigClangVarDecl; -pub const ZigClangWhileStmt = struct_ZigClangWhileStmt; -pub const ZigClangFunctionType = struct_ZigClangFunctionType; -pub const ZigClangPredefinedExpr = struct_ZigClangPredefinedExpr; -pub const ZigClangInitListExpr = struct_ZigClangInitListExpr; - -pub const struct_ZigClangSourceLocation = extern struct { - ID: c_uint, -}; - pub const Stage2ErrorMsg = extern struct { filename_ptr: ?[*]const u8, filename_len: usize, @@ -999,199 +1590,16 @@ pub const Stage2ErrorMsg = extern struct { column: c_uint, // byte offset into source offset: c_uint, + + pub const delete = ZigClangErrorMsg_delete; + extern fn ZigClangErrorMsg_delete(ptr: [*]Stage2ErrorMsg, len: usize) void; }; -pub const struct_ZigClangQualType = extern struct { - ptr: ?*c_void, -}; - -pub const struct_ZigClangAPValueLValueBase = extern struct { - Ptr: ?*c_void, - CallIndex: c_uint, - Version: c_uint, -}; - -pub extern fn ZigClangErrorMsg_delete(ptr: [*]Stage2ErrorMsg, len: usize) void; - -pub extern fn ZigClangLoadFromCommandLine( +pub const LoadFromCommandLine = ZigClangLoadFromCommandLine; +extern fn ZigClangLoadFromCommandLine( args_begin: [*]?[*]const u8, args_end: [*]?[*]const u8, errors_ptr: *[*]Stage2ErrorMsg, errors_len: *usize, resources_path: [*:0]const u8, -) ?*ZigClangASTUnit; - -pub extern fn ZigClangDecl_getKind(decl: *const ZigClangDecl) ZigClangDeclKind; -pub extern fn ZigClangDecl_getDeclKindName(decl: *const ZigClangDecl) [*:0]const u8; - -pub const ZigClangCompoundStmt_const_body_iterator = [*]const *ZigClangStmt; - -pub extern fn ZigClangCompoundStmt_body_begin(self: *const ZigClangCompoundStmt) ZigClangCompoundStmt_const_body_iterator; -pub extern fn ZigClangCompoundStmt_body_end(self: *const ZigClangCompoundStmt) ZigClangCompoundStmt_const_body_iterator; - -pub const ZigClangDeclStmt_const_decl_iterator = [*]const *ZigClangDecl; - -pub extern fn ZigClangDeclStmt_decl_begin(self: *const ZigClangDeclStmt) ZigClangDeclStmt_const_decl_iterator; -pub extern fn ZigClangDeclStmt_decl_end(self: *const ZigClangDeclStmt) ZigClangDeclStmt_const_decl_iterator; - -pub extern fn ZigClangVarDecl_getLocation(self: *const struct_ZigClangVarDecl) ZigClangSourceLocation; -pub extern fn ZigClangVarDecl_hasInit(self: *const struct_ZigClangVarDecl) bool; -pub extern fn ZigClangVarDecl_getStorageClass(self: *const ZigClangVarDecl) ZigClangStorageClass; -pub extern fn ZigClangVarDecl_getType(self: ?*const struct_ZigClangVarDecl) struct_ZigClangQualType; -pub extern fn ZigClangVarDecl_getInit(*const ZigClangVarDecl) ?*const ZigClangExpr; -pub extern fn ZigClangVarDecl_getTLSKind(self: ?*const struct_ZigClangVarDecl) ZigClangVarDecl_TLSKind; -pub const ZigClangVarDecl_TLSKind = extern enum { - None, - Static, - Dynamic, -}; - -pub extern fn ZigClangImplicitCastExpr_getBeginLoc(*const ZigClangImplicitCastExpr) ZigClangSourceLocation; -pub extern fn ZigClangImplicitCastExpr_getCastKind(*const ZigClangImplicitCastExpr) ZigClangCK; -pub extern fn ZigClangImplicitCastExpr_getSubExpr(*const ZigClangImplicitCastExpr) *const ZigClangExpr; - -pub extern fn ZigClangArrayType_getElementType(*const ZigClangArrayType) ZigClangQualType; -pub extern fn ZigClangIncompleteArrayType_getElementType(*const ZigClangIncompleteArrayType) ZigClangQualType; - -pub extern fn ZigClangConstantArrayType_getElementType(self: *const struct_ZigClangConstantArrayType) ZigClangQualType; -pub extern fn ZigClangConstantArrayType_getSize(self: *const struct_ZigClangConstantArrayType) *const struct_ZigClangAPInt; -pub extern fn ZigClangDeclRefExpr_getDecl(*const ZigClangDeclRefExpr) *const ZigClangValueDecl; -pub extern fn ZigClangDeclRefExpr_getFoundDecl(*const ZigClangDeclRefExpr) *const ZigClangNamedDecl; - -pub extern fn ZigClangParenType_getInnerType(*const ZigClangParenType) ZigClangQualType; - -pub extern fn ZigClangElaboratedType_getNamedType(*const ZigClangElaboratedType) ZigClangQualType; - -pub extern fn ZigClangAttributedType_getEquivalentType(*const ZigClangAttributedType) ZigClangQualType; - -pub extern fn ZigClangMacroQualifiedType_getModifiedType(*const ZigClangMacroQualifiedType) ZigClangQualType; - -pub extern fn ZigClangCStyleCastExpr_getBeginLoc(*const ZigClangCStyleCastExpr) ZigClangSourceLocation; -pub extern fn ZigClangCStyleCastExpr_getSubExpr(*const ZigClangCStyleCastExpr) *const ZigClangExpr; -pub extern fn ZigClangCStyleCastExpr_getType(*const ZigClangCStyleCastExpr) ZigClangQualType; - -pub const ZigClangExprEvalResult = struct_ZigClangExprEvalResult; -pub const struct_ZigClangExprEvalResult = extern struct { - HasSideEffects: bool, - HasUndefinedBehavior: bool, - SmallVectorImpl: ?*c_void, - Val: ZigClangAPValue, -}; - -pub const struct_ZigClangAPValue = extern struct { - Kind: ZigClangAPValueKind, - Data: if (builtin.os.tag == .windows and builtin.abi == .msvc) [52]u8 else [68]u8, -}; -pub extern fn ZigClangVarDecl_getTypeSourceInfo_getType(self: *const struct_ZigClangVarDecl) struct_ZigClangQualType; - -pub extern fn ZigClangIntegerLiteral_EvaluateAsInt(*const ZigClangIntegerLiteral, *ZigClangExprEvalResult, *const ZigClangASTContext) bool; -pub extern fn ZigClangIntegerLiteral_getBeginLoc(*const ZigClangIntegerLiteral) ZigClangSourceLocation; -pub extern fn ZigClangIntegerLiteral_isZero(*const ZigClangIntegerLiteral, *bool, *const ZigClangASTContext) bool; - -pub extern fn ZigClangReturnStmt_getRetValue(*const ZigClangReturnStmt) ?*const ZigClangExpr; - -pub extern fn ZigClangBinaryOperator_getOpcode(*const ZigClangBinaryOperator) ZigClangBO; -pub extern fn ZigClangBinaryOperator_getBeginLoc(*const ZigClangBinaryOperator) ZigClangSourceLocation; -pub extern fn ZigClangBinaryOperator_getLHS(*const ZigClangBinaryOperator) *const ZigClangExpr; -pub extern fn ZigClangBinaryOperator_getRHS(*const ZigClangBinaryOperator) *const ZigClangExpr; -pub extern fn ZigClangBinaryOperator_getType(*const ZigClangBinaryOperator) ZigClangQualType; - -pub extern fn ZigClangDecayedType_getDecayedType(*const ZigClangDecayedType) ZigClangQualType; - -pub extern fn ZigClangStringLiteral_getKind(*const ZigClangStringLiteral) ZigClangStringLiteral_StringKind; -pub extern fn ZigClangStringLiteral_getString_bytes_begin_size(*const ZigClangStringLiteral, *usize) [*]const u8; - -pub extern fn ZigClangParenExpr_getSubExpr(*const ZigClangParenExpr) *const ZigClangExpr; - -pub extern fn ZigClangFieldDecl_isAnonymousStructOrUnion(*const struct_ZigClangFieldDecl) bool; -pub extern fn ZigClangFieldDecl_isBitField(*const struct_ZigClangFieldDecl) bool; -pub extern fn ZigClangFieldDecl_getType(*const struct_ZigClangFieldDecl) struct_ZigClangQualType; -pub extern fn ZigClangFieldDecl_getLocation(*const struct_ZigClangFieldDecl) struct_ZigClangSourceLocation; - -pub extern fn ZigClangEnumConstantDecl_getInitExpr(*const ZigClangEnumConstantDecl) ?*const ZigClangExpr; -pub extern fn ZigClangEnumConstantDecl_getInitVal(*const ZigClangEnumConstantDecl) *const ZigClangAPSInt; - -pub extern fn ZigClangASTUnit_getLocalPreprocessingEntities_begin(*ZigClangASTUnit) ZigClangPreprocessingRecord_iterator; -pub extern fn ZigClangASTUnit_getLocalPreprocessingEntities_end(*ZigClangASTUnit) ZigClangPreprocessingRecord_iterator; -pub extern fn ZigClangPreprocessingRecord_iterator_deref(ZigClangPreprocessingRecord_iterator) *ZigClangPreprocessedEntity; -pub extern fn ZigClangPreprocessedEntity_getKind(*const ZigClangPreprocessedEntity) ZigClangPreprocessedEntity_EntityKind; - -pub extern fn ZigClangMacroDefinitionRecord_getName_getNameStart(*const ZigClangMacroDefinitionRecord) [*:0]const u8; -pub extern fn ZigClangMacroDefinitionRecord_getSourceRange_getBegin(*const ZigClangMacroDefinitionRecord) ZigClangSourceLocation; -pub extern fn ZigClangMacroDefinitionRecord_getSourceRange_getEnd(*const ZigClangMacroDefinitionRecord) ZigClangSourceLocation; - -pub extern fn ZigClangMacroExpansion_getDefinition(*const ZigClangMacroExpansion) *const ZigClangMacroDefinitionRecord; - -pub extern fn ZigClangIfStmt_getThen(*const ZigClangIfStmt) *const ZigClangStmt; -pub extern fn ZigClangIfStmt_getElse(*const ZigClangIfStmt) ?*const ZigClangStmt; -pub extern fn ZigClangIfStmt_getCond(*const ZigClangIfStmt) *const ZigClangStmt; - -pub extern fn ZigClangWhileStmt_getCond(*const ZigClangWhileStmt) *const ZigClangExpr; -pub extern fn ZigClangWhileStmt_getBody(*const ZigClangWhileStmt) *const ZigClangStmt; - -pub extern fn ZigClangDoStmt_getCond(*const ZigClangDoStmt) *const ZigClangExpr; -pub extern fn ZigClangDoStmt_getBody(*const ZigClangDoStmt) *const ZigClangStmt; - -pub extern fn ZigClangForStmt_getInit(*const ZigClangForStmt) ?*const ZigClangStmt; -pub extern fn ZigClangForStmt_getCond(*const ZigClangForStmt) ?*const ZigClangExpr; -pub extern fn ZigClangForStmt_getInc(*const ZigClangForStmt) ?*const ZigClangExpr; -pub extern fn ZigClangForStmt_getBody(*const ZigClangForStmt) *const ZigClangStmt; - -pub extern fn ZigClangAPFloat_toString(self: *const ZigClangAPFloat, precision: c_uint, maxPadding: c_uint, truncateZero: bool) [*:0]const u8; -pub extern fn ZigClangAPFloat_getValueAsApproximateDouble(*const ZigClangFloatingLiteral) f64; - -pub extern fn ZigClangAbstractConditionalOperator_getCond(*const ZigClangAbstractConditionalOperator) *const ZigClangExpr; -pub extern fn ZigClangAbstractConditionalOperator_getTrueExpr(*const ZigClangAbstractConditionalOperator) *const ZigClangExpr; -pub extern fn ZigClangAbstractConditionalOperator_getFalseExpr(*const ZigClangAbstractConditionalOperator) *const ZigClangExpr; - -pub extern fn ZigClangSwitchStmt_getConditionVariableDeclStmt(*const ZigClangSwitchStmt) ?*const ZigClangDeclStmt; -pub extern fn ZigClangSwitchStmt_getCond(*const ZigClangSwitchStmt) *const ZigClangExpr; -pub extern fn ZigClangSwitchStmt_getBody(*const ZigClangSwitchStmt) *const ZigClangStmt; -pub extern fn ZigClangSwitchStmt_isAllEnumCasesCovered(*const ZigClangSwitchStmt) bool; - -pub extern fn ZigClangCaseStmt_getLHS(*const ZigClangCaseStmt) *const ZigClangExpr; -pub extern fn ZigClangCaseStmt_getRHS(*const ZigClangCaseStmt) ?*const ZigClangExpr; -pub extern fn ZigClangCaseStmt_getBeginLoc(*const ZigClangCaseStmt) ZigClangSourceLocation; -pub extern fn ZigClangCaseStmt_getSubStmt(*const ZigClangCaseStmt) *const ZigClangStmt; - -pub extern fn ZigClangDefaultStmt_getSubStmt(*const ZigClangDefaultStmt) *const ZigClangStmt; - -pub extern fn ZigClangExpr_EvaluateAsConstantExpr(*const ZigClangExpr, *ZigClangExprEvalResult, ZigClangExpr_ConstExprUsage, *const ZigClangASTContext) bool; - -pub extern fn ZigClangPredefinedExpr_getFunctionName(*const ZigClangPredefinedExpr) *const ZigClangStringLiteral; - -pub extern fn ZigClangCharacterLiteral_getBeginLoc(*const ZigClangCharacterLiteral) ZigClangSourceLocation; -pub extern fn ZigClangCharacterLiteral_getKind(*const ZigClangCharacterLiteral) ZigClangCharacterLiteral_CharacterKind; -pub extern fn ZigClangCharacterLiteral_getValue(*const ZigClangCharacterLiteral) c_uint; - -pub extern fn ZigClangStmtExpr_getSubStmt(*const ZigClangStmtExpr) *const ZigClangCompoundStmt; - -pub extern fn ZigClangMemberExpr_getBase(*const ZigClangMemberExpr) *const ZigClangExpr; -pub extern fn ZigClangMemberExpr_isArrow(*const ZigClangMemberExpr) bool; -pub extern fn ZigClangMemberExpr_getMemberDecl(*const ZigClangMemberExpr) *const ZigClangValueDecl; - -pub extern fn ZigClangArraySubscriptExpr_getBase(*const ZigClangArraySubscriptExpr) *const ZigClangExpr; -pub extern fn ZigClangArraySubscriptExpr_getIdx(*const ZigClangArraySubscriptExpr) *const ZigClangExpr; - -pub extern fn ZigClangCallExpr_getCallee(*const ZigClangCallExpr) *const ZigClangExpr; -pub extern fn ZigClangCallExpr_getNumArgs(*const ZigClangCallExpr) c_uint; -pub extern fn ZigClangCallExpr_getArgs(*const ZigClangCallExpr) [*]const *const ZigClangExpr; - -pub extern fn ZigClangUnaryExprOrTypeTraitExpr_getTypeOfArgument(*const ZigClangUnaryExprOrTypeTraitExpr) ZigClangQualType; -pub extern fn ZigClangUnaryExprOrTypeTraitExpr_getBeginLoc(*const ZigClangUnaryExprOrTypeTraitExpr) ZigClangSourceLocation; -pub extern fn ZigClangUnaryExprOrTypeTraitExpr_getKind(*const ZigClangUnaryExprOrTypeTraitExpr) ZigClangUnaryExprOrTypeTrait_Kind; - -pub extern fn ZigClangUnaryOperator_getOpcode(*const ZigClangUnaryOperator) ZigClangUO; -pub extern fn ZigClangUnaryOperator_getType(*const ZigClangUnaryOperator) ZigClangQualType; -pub extern fn ZigClangUnaryOperator_getSubExpr(*const ZigClangUnaryOperator) *const ZigClangExpr; -pub extern fn ZigClangUnaryOperator_getBeginLoc(*const ZigClangUnaryOperator) ZigClangSourceLocation; - -pub extern fn ZigClangOpaqueValueExpr_getSourceExpr(*const ZigClangOpaqueValueExpr) ?*const ZigClangExpr; - -pub extern fn ZigClangCompoundAssignOperator_getType(*const ZigClangCompoundAssignOperator) ZigClangQualType; -pub extern fn ZigClangCompoundAssignOperator_getComputationLHSType(*const ZigClangCompoundAssignOperator) ZigClangQualType; -pub extern fn ZigClangCompoundAssignOperator_getComputationResultType(*const ZigClangCompoundAssignOperator) ZigClangQualType; -pub extern fn ZigClangCompoundAssignOperator_getBeginLoc(*const ZigClangCompoundAssignOperator) ZigClangSourceLocation; -pub extern fn ZigClangCompoundAssignOperator_getOpcode(*const ZigClangCompoundAssignOperator) ZigClangBO; -pub extern fn ZigClangCompoundAssignOperator_getLHS(*const ZigClangCompoundAssignOperator) *const ZigClangExpr; -pub extern fn ZigClangCompoundAssignOperator_getRHS(*const ZigClangCompoundAssignOperator) *const ZigClangExpr; +) ?*ASTUnit; diff --git a/src/translate_c.zig b/src/translate_c.zig index 001521ceac..982467aa8f 100644 --- a/src/translate_c.zig +++ b/src/translate_c.zig @@ -5,7 +5,7 @@ const std = @import("std"); const assert = std.debug.assert; const ast = std.zig.ast; const Token = std.zig.Token; -usingnamespace @import("clang.zig"); +const clang = @import("clang.zig"); const ctok = std.c.tokenizer; const CToken = std.c.Token; const mem = std.mem; @@ -13,7 +13,7 @@ const math = std.math; const CallingConvention = std.builtin.CallingConvention; -pub const ClangErrMsg = Stage2ErrorMsg; +pub const ClangErrMsg = clang.Stage2ErrorMsg; pub const Error = error{OutOfMemory}; const TypeError = Error || error{UnsupportedType}; @@ -259,11 +259,11 @@ pub const Context = struct { errors: std.ArrayListUnmanaged(ast.Error), source_buffer: *std.ArrayList(u8), err: Error, - source_manager: *ZigClangSourceManager, + source_manager: *clang.SourceManager, decl_table: DeclTable, alias_list: AliasList, global_scope: *Scope.Root, - clang_context: *ZigClangASTContext, + clang_context: *clang.ASTContext, mangle_count: u32 = 0, root_decls: std.ArrayListUnmanaged(*ast.Node), @@ -284,13 +284,13 @@ pub const Context = struct { } /// Convert a clang source location to a file:line:column string - fn locStr(c: *Context, loc: ZigClangSourceLocation) ![]u8 { - const spelling_loc = ZigClangSourceManager_getSpellingLoc(c.source_manager, loc); - const filename_c = ZigClangSourceManager_getFilename(c.source_manager, spelling_loc); + fn locStr(c: *Context, loc: clang.SourceLocation) ![]u8 { + const spelling_loc = c.source_manager.getSpellingLoc(loc); + const filename_c = c.source_manager.getFilename(spelling_loc); const filename = if (filename_c) |s| try c.str(s) else @as([]const u8, "(no file)"); - const line = ZigClangSourceManager_getSpellingLineNumber(c.source_manager, spelling_loc); - const column = ZigClangSourceManager_getSpellingColumnNumber(c.source_manager, spelling_loc); + const line = c.source_manager.getSpellingLineNumber(spelling_loc); + const column = c.source_manager.getSpellingColumnNumber(spelling_loc); return std.fmt.allocPrint(c.arena, "{}:{}:{}", .{ filename, line, column }); } @@ -336,7 +336,7 @@ pub fn translate( errors: *[]ClangErrMsg, resources_path: [*:0]const u8, ) !*ast.Tree { - const ast_unit = ZigClangLoadFromCommandLine( + const ast_unit = clang.LoadFromCommandLine( args_begin, args_end, &errors.ptr, @@ -346,7 +346,7 @@ pub fn translate( if (errors.len == 0) return error.ASTUnitFailure; return error.SemanticAnalyzeFail; }; - defer ZigClangASTUnit_delete(ast_unit); + defer ast_unit.delete(); var source_buffer = std.ArrayList(u8).init(gpa); defer source_buffer.deinit(); @@ -360,12 +360,12 @@ pub fn translate( .gpa = gpa, .arena = &arena.allocator, .source_buffer = &source_buffer, - .source_manager = ZigClangASTUnit_getSourceManager(ast_unit), + .source_manager = ast_unit.getSourceManager(), .err = undefined, .decl_table = DeclTable.init(gpa), .alias_list = AliasList.init(gpa), .global_scope = try arena.allocator.create(Scope.Root), - .clang_context = ZigClangASTUnit_getASTContext(ast_unit).?, + .clang_context = ast_unit.getASTContext(), .global_names = std.StringArrayHashMap(void).init(gpa), .token_ids = .{}, .token_locs = .{}, @@ -383,7 +383,7 @@ pub fn translate( try prepopulateGlobalNameTable(ast_unit, &context); - if (!ZigClangASTUnit_visitLocalTopLevelDecls(ast_unit, &context, declVisitorC)) { + if (!ast_unit.visitLocalTopLevelDecls(&context, declVisitorC)) { return context.err; } @@ -421,21 +421,21 @@ pub fn translate( return tree; } -fn prepopulateGlobalNameTable(ast_unit: *ZigClangASTUnit, c: *Context) !void { - if (!ZigClangASTUnit_visitLocalTopLevelDecls(ast_unit, c, declVisitorNamesOnlyC)) { +fn prepopulateGlobalNameTable(ast_unit: *clang.ASTUnit, c: *Context) !void { + if (!ast_unit.visitLocalTopLevelDecls(c, declVisitorNamesOnlyC)) { return c.err; } // TODO if we see #undef, delete it from the table - var it = ZigClangASTUnit_getLocalPreprocessingEntities_begin(ast_unit); - const it_end = ZigClangASTUnit_getLocalPreprocessingEntities_end(ast_unit); + var it = ast_unit.getLocalPreprocessingEntities_begin(); + const it_end = ast_unit.getLocalPreprocessingEntities_end(); while (it.I != it_end.I) : (it.I += 1) { - const entity = ZigClangPreprocessingRecord_iterator_deref(it); - switch (ZigClangPreprocessedEntity_getKind(entity)) { + const entity = it.deref(); + switch (entity.getKind()) { .MacroDefinitionKind => { - const macro = @ptrCast(*ZigClangMacroDefinitionRecord, entity); - const raw_name = ZigClangMacroDefinitionRecord_getName_getNameStart(macro); + const macro = @ptrCast(*clang.MacroDefinitionRecord, entity); + const raw_name = macro.getName_getNameStart(); const name = try c.str(raw_name); _ = try c.global_names.put(name, {}); }, @@ -444,7 +444,7 @@ fn prepopulateGlobalNameTable(ast_unit: *ZigClangASTUnit, c: *Context) !void { } } -fn declVisitorNamesOnlyC(context: ?*c_void, decl: *const ZigClangDecl) callconv(.C) bool { +fn declVisitorNamesOnlyC(context: ?*c_void, decl: *const clang.Decl) callconv(.C) bool { const c = @ptrCast(*Context, @alignCast(@alignOf(Context), context)); declVisitorNamesOnly(c, decl) catch |err| { c.err = err; @@ -453,7 +453,7 @@ fn declVisitorNamesOnlyC(context: ?*c_void, decl: *const ZigClangDecl) callconv( return true; } -fn declVisitorC(context: ?*c_void, decl: *const ZigClangDecl) callconv(.C) bool { +fn declVisitorC(context: ?*c_void, decl: *const clang.Decl) callconv(.C) bool { const c = @ptrCast(*Context, @alignCast(@alignOf(Context), context)); declVisitor(c, decl) catch |err| { c.err = err; @@ -462,61 +462,61 @@ fn declVisitorC(context: ?*c_void, decl: *const ZigClangDecl) callconv(.C) bool return true; } -fn declVisitorNamesOnly(c: *Context, decl: *const ZigClangDecl) Error!void { - if (ZigClangDecl_castToNamedDecl(decl)) |named_decl| { - const decl_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(named_decl)); +fn declVisitorNamesOnly(c: *Context, decl: *const clang.Decl) Error!void { + if (decl.castToNamedDecl()) |named_decl| { + const decl_name = try c.str(named_decl.getName_bytes_begin()); _ = try c.global_names.put(decl_name, {}); } } -fn declVisitor(c: *Context, decl: *const ZigClangDecl) Error!void { - switch (ZigClangDecl_getKind(decl)) { +fn declVisitor(c: *Context, decl: *const clang.Decl) Error!void { + switch (decl.getKind()) { .Function => { - return visitFnDecl(c, @ptrCast(*const ZigClangFunctionDecl, decl)); + return visitFnDecl(c, @ptrCast(*const clang.FunctionDecl, decl)); }, .Typedef => { - _ = try transTypeDef(c, @ptrCast(*const ZigClangTypedefNameDecl, decl), true); + _ = try transTypeDef(c, @ptrCast(*const clang.TypedefNameDecl, decl), true); }, .Enum => { - _ = try transEnumDecl(c, @ptrCast(*const ZigClangEnumDecl, decl)); + _ = try transEnumDecl(c, @ptrCast(*const clang.EnumDecl, decl)); }, .Record => { - _ = try transRecordDecl(c, @ptrCast(*const ZigClangRecordDecl, decl)); + _ = try transRecordDecl(c, @ptrCast(*const clang.RecordDecl, decl)); }, .Var => { - return visitVarDecl(c, @ptrCast(*const ZigClangVarDecl, decl), null); + return visitVarDecl(c, @ptrCast(*const clang.VarDecl, decl), null); }, .Empty => { // Do nothing }, else => { - const decl_name = try c.str(ZigClangDecl_getDeclKindName(decl)); - try emitWarning(c, ZigClangDecl_getLocation(decl), "ignoring {} declaration", .{decl_name}); + const decl_name = try c.str(decl.getDeclKindName()); + try emitWarning(c, decl.getLocation(), "ignoring {} declaration", .{decl_name}); }, } } -fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { - const fn_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, fn_decl))); +fn visitFnDecl(c: *Context, fn_decl: *const clang.FunctionDecl) Error!void { + const fn_name = try c.str(@ptrCast(*const clang.NamedDecl, fn_decl).getName_bytes_begin()); if (c.global_scope.sym_table.contains(fn_name)) return; // Avoid processing this decl twice // Skip this declaration if a proper definition exists - if (!ZigClangFunctionDecl_isThisDeclarationADefinition(fn_decl)) { - if (ZigClangFunctionDecl_getDefinition(fn_decl)) |def| + if (!fn_decl.isThisDeclarationADefinition()) { + if (fn_decl.getDefinition()) |def| return visitFnDecl(c, def); } const rp = makeRestorePoint(c); - const fn_decl_loc = ZigClangFunctionDecl_getLocation(fn_decl); - const has_body = ZigClangFunctionDecl_hasBody(fn_decl); - const storage_class = ZigClangFunctionDecl_getStorageClass(fn_decl); + const fn_decl_loc = fn_decl.getLocation(); + const has_body = fn_decl.hasBody(); + const storage_class = fn_decl.getStorageClass(); const decl_ctx = FnDeclContext{ .fn_name = fn_name, .has_body = has_body, .storage_class = storage_class, .is_export = switch (storage_class) { - .None => has_body and !ZigClangFunctionDecl_isInlineSpecified(fn_decl), + .None => has_body and !fn_decl.isInlineSpecified(), .Extern, .Static => false, .PrivateExtern => return failDecl(c, fn_decl_loc, fn_name, "unsupported storage class: private extern", .{}), .Auto => unreachable, // Not legal on functions @@ -524,27 +524,27 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { }, }; - var fn_qt = ZigClangFunctionDecl_getType(fn_decl); + var fn_qt = fn_decl.getType(); const fn_type = while (true) { - const fn_type = ZigClangQualType_getTypePtr(fn_qt); + const fn_type = fn_qt.getTypePtr(); - switch (ZigClangType_getTypeClass(fn_type)) { + switch (fn_type.getTypeClass()) { .Attributed => { - const attr_type = @ptrCast(*const ZigClangAttributedType, fn_type); - fn_qt = ZigClangAttributedType_getEquivalentType(attr_type); + const attr_type = @ptrCast(*const clang.AttributedType, fn_type); + fn_qt = attr_type.getEquivalentType(); }, .Paren => { - const paren_type = @ptrCast(*const ZigClangParenType, fn_type); - fn_qt = ZigClangParenType_getInnerType(paren_type); + const paren_type = @ptrCast(*const clang.ParenType, fn_type); + fn_qt = paren_type.getInnerType(); }, else => break fn_type, } } else unreachable; - const proto_node = switch (ZigClangType_getTypeClass(fn_type)) { + const proto_node = switch (fn_type.getTypeClass()) { .FunctionProto => blk: { - const fn_proto_type = @ptrCast(*const ZigClangFunctionProtoType, fn_type); + const fn_proto_type = @ptrCast(*const clang.FunctionProtoType, fn_type); break :blk transFnProto(rp, fn_decl, fn_proto_type, fn_decl_loc, decl_ctx, true) catch |err| switch (err) { error.UnsupportedType => { return failDecl(c, fn_decl_loc, fn_name, "unable to resolve prototype of function", .{}); @@ -553,7 +553,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { }; }, .FunctionNoProto => blk: { - const fn_no_proto_type = @ptrCast(*const ZigClangFunctionType, fn_type); + const fn_no_proto_type = @ptrCast(*const clang.FunctionType, fn_type); break :blk transFnNoProto(rp, fn_no_proto_type, fn_decl_loc, decl_ctx, true) catch |err| switch (err) { error.UnsupportedType => { return failDecl(c, fn_decl_loc, fn_name, "unable to resolve prototype of function", .{}); @@ -561,7 +561,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { error.OutOfMemory => |e| return e, }; }, - else => return failDecl(c, fn_decl_loc, fn_name, "unable to resolve function type {}", .{ZigClangType_getTypeClass(fn_type)}), + else => return failDecl(c, fn_decl_loc, fn_name, "unable to resolve function type {}", .{fn_type.getTypeClass()}), }; if (!decl_ctx.has_body) { @@ -570,7 +570,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { } // actual function definition with body - const body_stmt = ZigClangFunctionDecl_getBody(fn_decl); + const body_stmt = fn_decl.getBody(); var block_scope = try Scope.Block.init(rp.c, &c.global_scope.base, false); defer block_scope.deinit(); var scope = &block_scope.base; @@ -582,9 +582,9 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { else return failDecl(c, fn_decl_loc, fn_name, "function {} parameter has no name", .{fn_name}); - const c_param = ZigClangFunctionDecl_getParamDecl(fn_decl, param_id); - const qual_type = ZigClangParmVarDecl_getOriginalType(c_param); - const is_const = ZigClangQualType_isConstQualified(qual_type); + const c_param = fn_decl.getParamDecl(param_id); + const qual_type = c_param.getOriginalType(); + const is_const = qual_type.isConstQualified(); const mangled_param_name = try block_scope.makeMangledName(c, param_name); @@ -613,7 +613,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { param_id += 1; } - const casted_body = @ptrCast(*const ZigClangCompoundStmt, body_stmt); + const casted_body = @ptrCast(*const clang.CompoundStmt, body_stmt); transCompoundStmtInline(rp, &block_scope.base, casted_body, &block_scope) catch |err| switch (err) { error.OutOfMemory => |e| return e, error.UnsupportedTranslation, @@ -622,10 +622,10 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { }; // add return statement if the function didn't have one blk: { - const fn_ty = @ptrCast(*const ZigClangFunctionType, fn_type); + const fn_ty = @ptrCast(*const clang.FunctionType, fn_type); - if (ZigClangFunctionType_getNoReturnAttr(fn_ty)) break :blk; - const return_qt = ZigClangFunctionType_getReturnType(fn_ty); + if (fn_ty.getNoReturnAttr()) break :blk; + const return_qt = fn_ty.getReturnType(); if (isCVoid(return_qt)) break :blk; if (block_scope.statements.items.len > 0) { @@ -649,7 +649,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { .ltoken = try appendToken(rp.c, .Keyword_return, "return"), .tag = .Return, }, .{ - .rhs = transZeroInitExpr(rp, scope, fn_decl_loc, ZigClangQualType_getTypePtr(return_qt)) catch |err| switch (err) { + .rhs = transZeroInitExpr(rp, scope, fn_decl_loc, return_qt.getTypePtr()) catch |err| switch (err) { error.OutOfMemory => |e| return e, error.UnsupportedTranslation, error.UnsupportedType, @@ -666,14 +666,14 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { } /// if mangled_name is not null, this var decl was declared in a block scope. -fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[]const u8) Error!void { - const var_name = mangled_name orelse try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, var_decl))); +fn visitVarDecl(c: *Context, var_decl: *const clang.VarDecl, mangled_name: ?[]const u8) Error!void { + const var_name = mangled_name orelse try c.str(@ptrCast(*const clang.NamedDecl, var_decl).getName_bytes_begin()); if (c.global_scope.sym_table.contains(var_name)) return; // Avoid processing this decl twice const rp = makeRestorePoint(c); const visib_tok = if (mangled_name) |_| null else try appendToken(c, .Keyword_pub, "pub"); - const thread_local_token = if (ZigClangVarDecl_getTLSKind(var_decl) == .None) + const thread_local_token = if (var_decl.getTLSKind() == .None) null else try appendToken(c, .Keyword_threadlocal, "threadlocal"); @@ -683,12 +683,12 @@ fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[] // TODO https://github.com/ziglang/zig/issues/3756 // TODO https://github.com/ziglang/zig/issues/1802 const checked_name = if (isZigPrimitiveType(var_name)) try std.fmt.allocPrint(c.arena, "{}_{}", .{ var_name, c.getMangle() }) else var_name; - const var_decl_loc = ZigClangVarDecl_getLocation(var_decl); + const var_decl_loc = var_decl.getLocation(); - const qual_type = ZigClangVarDecl_getTypeSourceInfo_getType(var_decl); - const storage_class = ZigClangVarDecl_getStorageClass(var_decl); - const is_const = ZigClangQualType_isConstQualified(qual_type); - const has_init = ZigClangVarDecl_hasInit(var_decl); + const qual_type = var_decl.getTypeSourceInfo_getType(); + const storage_class = var_decl.getStorageClass(); + const is_const = qual_type.isConstQualified(); + const has_init = var_decl.hasInit(); // In C extern variables with initializers behave like Zig exports. // extern int foo = 2; @@ -725,7 +725,7 @@ fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[] // with the variable type. if (has_init) { eq_tok = try appendToken(c, .Equal, "="); - init_node = if (ZigClangVarDecl_getInit(var_decl)) |expr| + init_node = if (var_decl.getInit()) |expr| transExprCoercing(rp, &c.global_scope.base, expr, .used, .r_value) catch |err| switch (err) { error.UnsupportedTranslation, error.UnsupportedType, @@ -758,7 +758,7 @@ fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[] const linksection_expr = blk: { var str_len: usize = undefined; - if (ZigClangVarDecl_getSectionAttribute(var_decl, &str_len)) |str_ptr| { + if (var_decl.getSectionAttribute(&str_len)) |str_ptr| { _ = try appendToken(rp.c, .Keyword_linksection, "linksection"); _ = try appendToken(rp.c, .LParen, "("); const expr = try transCreateNodeStringLiteral( @@ -773,7 +773,7 @@ fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[] }; const align_expr = blk: { - const alignment = ZigClangVarDecl_getAlignedAttribute(var_decl, rp.c.clang_context); + const alignment = var_decl.getAlignedAttribute(rp.c.clang_context); if (alignment != 0) { _ = try appendToken(rp.c, .Keyword_align, "align"); _ = try appendToken(rp.c, .LParen, "("); @@ -803,8 +803,8 @@ fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[] return addTopLevelDecl(c, checked_name, &node.base); } -fn transTypeDefAsBuiltin(c: *Context, typedef_decl: *const ZigClangTypedefNameDecl, builtin_name: []const u8) !*ast.Node { - _ = try c.decl_table.put(@ptrToInt(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl)), builtin_name); +fn transTypeDefAsBuiltin(c: *Context, typedef_decl: *const clang.TypedefNameDecl, builtin_name: []const u8) !*ast.Node { + _ = try c.decl_table.put(@ptrToInt(typedef_decl.getCanonicalDecl()), builtin_name); return transCreateNodeIdentifier(c, builtin_name); } @@ -833,12 +833,12 @@ fn checkForBuiltinTypedef(checked_name: []const u8) ?[]const u8 { return null; } -fn transTypeDef(c: *Context, typedef_decl: *const ZigClangTypedefNameDecl, top_level_visit: bool) Error!?*ast.Node { - if (c.decl_table.get(@ptrToInt(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl)))) |name| +fn transTypeDef(c: *Context, typedef_decl: *const clang.TypedefNameDecl, top_level_visit: bool) Error!?*ast.Node { + if (c.decl_table.get(@ptrToInt(typedef_decl.getCanonicalDecl()))) |name| return transCreateNodeIdentifier(c, name); // Avoid processing this decl twice const rp = makeRestorePoint(c); - const typedef_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, typedef_decl))); + const typedef_name = try c.str(@ptrCast(*const clang.NamedDecl, typedef_decl).getName_bytes_begin()); // TODO https://github.com/ziglang/zig/issues/3756 // TODO https://github.com/ziglang/zig/issues/1802 @@ -851,7 +851,7 @@ fn transTypeDef(c: *Context, typedef_decl: *const ZigClangTypedefNameDecl, top_l return transCreateNodeIdentifier(c, checked_name); } - _ = try c.decl_table.put(@ptrToInt(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl)), checked_name); + _ = try c.decl_table.put(@ptrToInt(typedef_decl.getCanonicalDecl()), checked_name); const node = (try transCreateNodeTypedef(rp, typedef_decl, true, checked_name)) orelse return null; try addTopLevelDecl(c, checked_name, node); return transCreateNodeIdentifier(c, checked_name); @@ -859,7 +859,7 @@ fn transTypeDef(c: *Context, typedef_decl: *const ZigClangTypedefNameDecl, top_l fn transCreateNodeTypedef( rp: RestorePoint, - typedef_decl: *const ZigClangTypedefNameDecl, + typedef_decl: *const clang.TypedefNameDecl, toplevel: bool, checked_name: []const u8, ) Error!?*ast.Node { @@ -867,8 +867,8 @@ fn transCreateNodeTypedef( const mut_tok = try appendToken(rp.c, .Keyword_const, "const"); const name_tok = try appendIdentifier(rp.c, checked_name); const eq_token = try appendToken(rp.c, .Equal, "="); - const child_qt = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl); - const typedef_loc = ZigClangTypedefNameDecl_getLocation(typedef_decl); + const child_qt = typedef_decl.getUnderlyingType(); + const typedef_loc = typedef_decl.getLocation(); const init_node = transQualType(rp, child_qt, typedef_loc) catch |err| switch (err) { error.UnsupportedType => { try failDecl(rp.c, typedef_loc, checked_name, "unable to resolve typedef child type", .{}); @@ -890,12 +890,12 @@ fn transCreateNodeTypedef( return &node.base; } -fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*ast.Node { - if (c.decl_table.get(@ptrToInt(ZigClangRecordDecl_getCanonicalDecl(record_decl)))) |name| +fn transRecordDecl(c: *Context, record_decl: *const clang.RecordDecl) Error!?*ast.Node { + if (c.decl_table.get(@ptrToInt(record_decl.getCanonicalDecl()))) |name| return try transCreateNodeIdentifier(c, name); // Avoid processing this decl twice - const record_loc = ZigClangRecordDecl_getLocation(record_decl); + const record_loc = record_decl.getLocation(); - var bare_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, record_decl))); + var bare_name = try c.str(@ptrCast(*const clang.NamedDecl, record_decl).getName_bytes_begin()); var is_unnamed = false; // Record declarations such as `struct {...} x` have no name but they're not // anonymous hence here isAnonymousStructOrUnion is not needed @@ -906,10 +906,10 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?* var container_kind_name: []const u8 = undefined; var container_kind: std.zig.Token.Id = undefined; - if (ZigClangRecordDecl_isUnion(record_decl)) { + if (record_decl.isUnion()) { container_kind_name = "union"; container_kind = .Keyword_union; - } else if (ZigClangRecordDecl_isStruct(record_decl)) { + } else if (record_decl.isStruct()) { container_kind_name = "struct"; container_kind = .Keyword_struct; } else { @@ -918,7 +918,7 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?* } const name = try std.fmt.allocPrint(c.arena, "{}_{}", .{ container_kind_name, bare_name }); - _ = try c.decl_table.put(@ptrToInt(ZigClangRecordDecl_getCanonicalDecl(record_decl)), name); + _ = try c.decl_table.put(@ptrToInt(record_decl.getCanonicalDecl()), name); const visib_tok = if (!is_unnamed) try appendToken(c, .Keyword_pub, "pub") else null; const mut_tok = try appendToken(c, .Keyword_const, "const"); @@ -929,13 +929,13 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?* var semicolon: ast.TokenIndex = undefined; const init_node = blk: { const rp = makeRestorePoint(c); - const record_def = ZigClangRecordDecl_getDefinition(record_decl) orelse { + const record_def = record_decl.getDefinition() orelse { const opaque_type = try transCreateNodeOpaqueType(c); semicolon = try appendToken(c, .Semicolon, ";"); break :blk opaque_type; }; - const layout_tok = try if (ZigClangRecordDecl_getPackedAttribute(record_decl)) + const layout_tok = try if (record_decl.getPackedAttribute()) appendToken(c, .Keyword_packed, "packed") else appendToken(c, .Keyword_extern, "extern"); @@ -946,21 +946,21 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?* defer fields_and_decls.deinit(); var unnamed_field_count: u32 = 0; - var it = ZigClangRecordDecl_field_begin(record_def); - const end_it = ZigClangRecordDecl_field_end(record_def); - while (ZigClangRecordDecl_field_iterator_neq(it, end_it)) : (it = ZigClangRecordDecl_field_iterator_next(it)) { - const field_decl = ZigClangRecordDecl_field_iterator_deref(it); - const field_loc = ZigClangFieldDecl_getLocation(field_decl); - const field_qt = ZigClangFieldDecl_getType(field_decl); + var it = record_def.field_begin(); + const end_it = record_def.field_end(); + while (it.neq(end_it)) : (it = it.next()) { + const field_decl = it.deref(); + const field_loc = field_decl.getLocation(); + const field_qt = field_decl.getType(); - if (ZigClangFieldDecl_isBitField(field_decl)) { + if (field_decl.isBitField()) { const opaque_type = try transCreateNodeOpaqueType(c); semicolon = try appendToken(c, .Semicolon, ";"); try emitWarning(c, field_loc, "{} demoted to opaque type - has bitfield", .{container_kind_name}); break :blk opaque_type; } - if (ZigClangType_isIncompleteOrZeroLengthArrayType(qualTypeCanon(field_qt), c.clang_context)) { + if (qualTypeCanon(field_qt).isIncompleteOrZeroLengthArrayType(c.clang_context)) { const opaque_type = try transCreateNodeOpaqueType(c); semicolon = try appendToken(c, .Semicolon, ";"); try emitWarning(c, field_loc, "{} demoted to opaque type - has variable length array", .{container_kind_name}); @@ -968,8 +968,8 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?* } var is_anon = false; - var raw_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, field_decl))); - if (ZigClangFieldDecl_isAnonymousStructOrUnion(field_decl) or raw_name.len == 0) { + var raw_name = try c.str(@ptrCast(*const clang.NamedDecl, field_decl).getName_bytes_begin()); + if (field_decl.isAnonymousStructOrUnion() or raw_name.len == 0) { // Context.getMangle() is not used here because doing so causes unpredictable field names for anonymous fields. raw_name = try std.fmt.allocPrint(c.arena, "unnamed_{}", .{unnamed_field_count}); unnamed_field_count += 1; @@ -988,7 +988,7 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?* }; const align_expr = blk_2: { - const alignment = ZigClangFieldDecl_getAlignedAttribute(field_decl, rp.c.clang_context); + const alignment = field_decl.getAlignedAttribute(rp.c.clang_context); if (alignment != 0) { _ = try appendToken(rp.c, .Keyword_align, "align"); _ = try appendToken(rp.c, .LParen, "("); @@ -1013,7 +1013,7 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?* if (is_anon) { _ = try c.decl_table.put( - @ptrToInt(ZigClangFieldDecl_getCanonicalDecl(field_decl)), + @ptrToInt(field_decl.getCanonicalDecl()), raw_name, ); } @@ -1051,13 +1051,13 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?* return transCreateNodeIdentifier(c, name); } -fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.Node { - if (c.decl_table.get(@ptrToInt(ZigClangEnumDecl_getCanonicalDecl(enum_decl)))) |name| +fn transEnumDecl(c: *Context, enum_decl: *const clang.EnumDecl) Error!?*ast.Node { + if (c.decl_table.get(@ptrToInt(enum_decl.getCanonicalDecl()))) |name| return try transCreateNodeIdentifier(c, name); // Avoid processing this decl twice const rp = makeRestorePoint(c); - const enum_loc = ZigClangEnumDecl_getLocation(enum_decl); + const enum_loc = enum_decl.getLocation(); - var bare_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, enum_decl))); + var bare_name = try c.str(@ptrCast(*const clang.NamedDecl, enum_decl).getName_bytes_begin()); var is_unnamed = false; if (bare_name.len == 0) { bare_name = try std.fmt.allocPrint(c.arena, "unnamed_{}", .{c.getMangle()}); @@ -1065,20 +1065,20 @@ fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.No } const name = try std.fmt.allocPrint(c.arena, "enum_{}", .{bare_name}); - _ = try c.decl_table.put(@ptrToInt(ZigClangEnumDecl_getCanonicalDecl(enum_decl)), name); + _ = try c.decl_table.put(@ptrToInt(enum_decl.getCanonicalDecl()), name); const visib_tok = if (!is_unnamed) try appendToken(c, .Keyword_pub, "pub") else null; const mut_tok = try appendToken(c, .Keyword_const, "const"); const name_tok = try appendIdentifier(c, name); const eq_token = try appendToken(c, .Equal, "="); - const init_node = if (ZigClangEnumDecl_getDefinition(enum_decl)) |enum_def| blk: { + const init_node = if (enum_decl.getDefinition()) |enum_def| blk: { var pure_enum = true; - var it = ZigClangEnumDecl_enumerator_begin(enum_def); - var end_it = ZigClangEnumDecl_enumerator_end(enum_def); - while (ZigClangEnumDecl_enumerator_iterator_neq(it, end_it)) : (it = ZigClangEnumDecl_enumerator_iterator_next(it)) { - const enum_const = ZigClangEnumDecl_enumerator_iterator_deref(it); - if (ZigClangEnumConstantDecl_getInitExpr(enum_const)) |_| { + var it = enum_def.enumerator_begin(); + var end_it = enum_def.enumerator_end(); + while (it.neq(end_it)) : (it = it.next()) { + const enum_const = it.deref(); + if (enum_const.getInitExpr()) |_| { pure_enum = false; break; } @@ -1090,7 +1090,7 @@ fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.No var fields_and_decls = std.ArrayList(*ast.Node).init(c.gpa); defer fields_and_decls.deinit(); - const int_type = ZigClangEnumDecl_getIntegerType(enum_decl); + const int_type = enum_decl.getIntegerType(); // The underlying type may be null in case of forward-declared enum // types, while that's not ISO-C compliant many compilers allow this and // default to the usual integer type used for all the enums. @@ -1115,12 +1115,12 @@ fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.No const lbrace_token = try appendToken(c, .LBrace, "{"); - it = ZigClangEnumDecl_enumerator_begin(enum_def); - end_it = ZigClangEnumDecl_enumerator_end(enum_def); - while (ZigClangEnumDecl_enumerator_iterator_neq(it, end_it)) : (it = ZigClangEnumDecl_enumerator_iterator_next(it)) { - const enum_const = ZigClangEnumDecl_enumerator_iterator_deref(it); + it = enum_def.enumerator_begin(); + end_it = enum_def.enumerator_end(); + while (it.neq(end_it)) : (it = it.next()) { + const enum_const = it.deref(); - const enum_val_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, enum_const))); + const enum_val_name = try c.str(@ptrCast(*const clang.NamedDecl, enum_const).getName_bytes_begin()); const field_name = if (!is_unnamed and mem.startsWith(u8, enum_val_name, bare_name)) enum_val_name[bare_name.len..] @@ -1131,7 +1131,7 @@ fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.No const int_node = if (!pure_enum) blk_2: { _ = try appendToken(c, .Colon, "="); - break :blk_2 try transCreateNodeAPInt(c, ZigClangEnumConstantDecl_getInitVal(enum_const)); + break :blk_2 try transCreateNodeAPInt(c, enum_const.getInitVal()); } else null; @@ -1257,23 +1257,23 @@ const LRValue = enum { fn transStmt( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangStmt, + stmt: *const clang.Stmt, result_used: ResultUsed, lrvalue: LRValue, ) TransError!*ast.Node { - const sc = ZigClangStmt_getStmtClass(stmt); + const sc = stmt.getStmtClass(); switch (sc) { - .BinaryOperatorClass => return transBinaryOperator(rp, scope, @ptrCast(*const ZigClangBinaryOperator, stmt), result_used), - .CompoundStmtClass => return transCompoundStmt(rp, scope, @ptrCast(*const ZigClangCompoundStmt, stmt)), - .CStyleCastExprClass => return transCStyleCastExprClass(rp, scope, @ptrCast(*const ZigClangCStyleCastExpr, stmt), result_used, lrvalue), - .DeclStmtClass => return transDeclStmt(rp, scope, @ptrCast(*const ZigClangDeclStmt, stmt)), - .DeclRefExprClass => return transDeclRefExpr(rp, scope, @ptrCast(*const ZigClangDeclRefExpr, stmt), lrvalue), - .ImplicitCastExprClass => return transImplicitCastExpr(rp, scope, @ptrCast(*const ZigClangImplicitCastExpr, stmt), result_used), - .IntegerLiteralClass => return transIntegerLiteral(rp, scope, @ptrCast(*const ZigClangIntegerLiteral, stmt), result_used, .with_as), - .ReturnStmtClass => return transReturnStmt(rp, scope, @ptrCast(*const ZigClangReturnStmt, stmt)), - .StringLiteralClass => return transStringLiteral(rp, scope, @ptrCast(*const ZigClangStringLiteral, stmt), result_used), + .BinaryOperatorClass => return transBinaryOperator(rp, scope, @ptrCast(*const clang.BinaryOperator, stmt), result_used), + .CompoundStmtClass => return transCompoundStmt(rp, scope, @ptrCast(*const clang.CompoundStmt, stmt)), + .CStyleCastExprClass => return transCStyleCastExprClass(rp, scope, @ptrCast(*const clang.CStyleCastExpr, stmt), result_used, lrvalue), + .DeclStmtClass => return transDeclStmt(rp, scope, @ptrCast(*const clang.DeclStmt, stmt)), + .DeclRefExprClass => return transDeclRefExpr(rp, scope, @ptrCast(*const clang.DeclRefExpr, stmt), lrvalue), + .ImplicitCastExprClass => return transImplicitCastExpr(rp, scope, @ptrCast(*const clang.ImplicitCastExpr, stmt), result_used), + .IntegerLiteralClass => return transIntegerLiteral(rp, scope, @ptrCast(*const clang.IntegerLiteral, stmt), result_used, .with_as), + .ReturnStmtClass => return transReturnStmt(rp, scope, @ptrCast(*const clang.ReturnStmt, stmt)), + .StringLiteralClass => return transStringLiteral(rp, scope, @ptrCast(*const clang.StringLiteral, stmt), result_used), .ParenExprClass => { - const expr = try transExpr(rp, scope, ZigClangParenExpr_getSubExpr(@ptrCast(*const ZigClangParenExpr, stmt)), .used, lrvalue); + const expr = try transExpr(rp, scope, @ptrCast(*const clang.ParenExpr, stmt).getSubExpr(), .used, lrvalue); if (expr.tag == .GroupedExpression) return maybeSuppressResult(rp, scope, result_used, expr); const node = try rp.c.arena.create(ast.Node.GroupedExpression); node.* = .{ @@ -1283,11 +1283,11 @@ fn transStmt( }; return maybeSuppressResult(rp, scope, result_used, &node.base); }, - .InitListExprClass => return transInitListExpr(rp, scope, @ptrCast(*const ZigClangInitListExpr, stmt), result_used), - .ImplicitValueInitExprClass => return transImplicitValueInitExpr(rp, scope, @ptrCast(*const ZigClangExpr, stmt), result_used), - .IfStmtClass => return transIfStmt(rp, scope, @ptrCast(*const ZigClangIfStmt, stmt)), - .WhileStmtClass => return transWhileLoop(rp, scope, @ptrCast(*const ZigClangWhileStmt, stmt)), - .DoStmtClass => return transDoWhileLoop(rp, scope, @ptrCast(*const ZigClangDoStmt, stmt)), + .InitListExprClass => return transInitListExpr(rp, scope, @ptrCast(*const clang.InitListExpr, stmt), result_used), + .ImplicitValueInitExprClass => return transImplicitValueInitExpr(rp, scope, @ptrCast(*const clang.Expr, stmt), result_used), + .IfStmtClass => return transIfStmt(rp, scope, @ptrCast(*const clang.IfStmt, stmt)), + .WhileStmtClass => return transWhileLoop(rp, scope, @ptrCast(*const clang.WhileStmt, stmt)), + .DoStmtClass => return transDoWhileLoop(rp, scope, @ptrCast(*const clang.DoStmt, stmt)), .NullStmtClass => { const block = try rp.c.createBlock(0); block.rbrace = try appendToken(rp.c, .RBrace, "}"); @@ -1295,29 +1295,29 @@ fn transStmt( }, .ContinueStmtClass => return try transCreateNodeContinue(rp.c), .BreakStmtClass => return transBreak(rp, scope), - .ForStmtClass => return transForLoop(rp, scope, @ptrCast(*const ZigClangForStmt, stmt)), - .FloatingLiteralClass => return transFloatingLiteral(rp, scope, @ptrCast(*const ZigClangFloatingLiteral, stmt), result_used), + .ForStmtClass => return transForLoop(rp, scope, @ptrCast(*const clang.ForStmt, stmt)), + .FloatingLiteralClass => return transFloatingLiteral(rp, scope, @ptrCast(*const clang.FloatingLiteral, stmt), result_used), .ConditionalOperatorClass => { - return transConditionalOperator(rp, scope, @ptrCast(*const ZigClangConditionalOperator, stmt), result_used); + return transConditionalOperator(rp, scope, @ptrCast(*const clang.ConditionalOperator, stmt), result_used); }, .BinaryConditionalOperatorClass => { - return transBinaryConditionalOperator(rp, scope, @ptrCast(*const ZigClangBinaryConditionalOperator, stmt), result_used); + return transBinaryConditionalOperator(rp, scope, @ptrCast(*const clang.BinaryConditionalOperator, stmt), result_used); }, - .SwitchStmtClass => return transSwitch(rp, scope, @ptrCast(*const ZigClangSwitchStmt, stmt)), - .CaseStmtClass => return transCase(rp, scope, @ptrCast(*const ZigClangCaseStmt, stmt)), - .DefaultStmtClass => return transDefault(rp, scope, @ptrCast(*const ZigClangDefaultStmt, stmt)), - .ConstantExprClass => return transConstantExpr(rp, scope, @ptrCast(*const ZigClangExpr, stmt), result_used), - .PredefinedExprClass => return transPredefinedExpr(rp, scope, @ptrCast(*const ZigClangPredefinedExpr, stmt), result_used), - .CharacterLiteralClass => return transCharLiteral(rp, scope, @ptrCast(*const ZigClangCharacterLiteral, stmt), result_used, .with_as), - .StmtExprClass => return transStmtExpr(rp, scope, @ptrCast(*const ZigClangStmtExpr, stmt), result_used), - .MemberExprClass => return transMemberExpr(rp, scope, @ptrCast(*const ZigClangMemberExpr, stmt), result_used), - .ArraySubscriptExprClass => return transArrayAccess(rp, scope, @ptrCast(*const ZigClangArraySubscriptExpr, stmt), result_used), - .CallExprClass => return transCallExpr(rp, scope, @ptrCast(*const ZigClangCallExpr, stmt), result_used), - .UnaryExprOrTypeTraitExprClass => return transUnaryExprOrTypeTraitExpr(rp, scope, @ptrCast(*const ZigClangUnaryExprOrTypeTraitExpr, stmt), result_used), - .UnaryOperatorClass => return transUnaryOperator(rp, scope, @ptrCast(*const ZigClangUnaryOperator, stmt), result_used), - .CompoundAssignOperatorClass => return transCompoundAssignOperator(rp, scope, @ptrCast(*const ZigClangCompoundAssignOperator, stmt), result_used), + .SwitchStmtClass => return transSwitch(rp, scope, @ptrCast(*const clang.SwitchStmt, stmt)), + .CaseStmtClass => return transCase(rp, scope, @ptrCast(*const clang.CaseStmt, stmt)), + .DefaultStmtClass => return transDefault(rp, scope, @ptrCast(*const clang.DefaultStmt, stmt)), + .ConstantExprClass => return transConstantExpr(rp, scope, @ptrCast(*const clang.Expr, stmt), result_used), + .PredefinedExprClass => return transPredefinedExpr(rp, scope, @ptrCast(*const clang.PredefinedExpr, stmt), result_used), + .CharacterLiteralClass => return transCharLiteral(rp, scope, @ptrCast(*const clang.CharacterLiteral, stmt), result_used, .with_as), + .StmtExprClass => return transStmtExpr(rp, scope, @ptrCast(*const clang.StmtExpr, stmt), result_used), + .MemberExprClass => return transMemberExpr(rp, scope, @ptrCast(*const clang.MemberExpr, stmt), result_used), + .ArraySubscriptExprClass => return transArrayAccess(rp, scope, @ptrCast(*const clang.ArraySubscriptExpr, stmt), result_used), + .CallExprClass => return transCallExpr(rp, scope, @ptrCast(*const clang.CallExpr, stmt), result_used), + .UnaryExprOrTypeTraitExprClass => return transUnaryExprOrTypeTraitExpr(rp, scope, @ptrCast(*const clang.UnaryExprOrTypeTraitExpr, stmt), result_used), + .UnaryOperatorClass => return transUnaryOperator(rp, scope, @ptrCast(*const clang.UnaryOperator, stmt), result_used), + .CompoundAssignOperatorClass => return transCompoundAssignOperator(rp, scope, @ptrCast(*const clang.CompoundAssignOperator, stmt), result_used), .OpaqueValueExprClass => { - const source_expr = ZigClangOpaqueValueExpr_getSourceExpr(@ptrCast(*const ZigClangOpaqueValueExpr, stmt)).?; + const source_expr = @ptrCast(*const clang.OpaqueValueExpr, stmt).getSourceExpr().?; const expr = try transExpr(rp, scope, source_expr, .used, lrvalue); if (expr.tag == .GroupedExpression) return maybeSuppressResult(rp, scope, result_used, expr); const node = try rp.c.arena.create(ast.Node.GroupedExpression); @@ -1332,7 +1332,7 @@ fn transStmt( return revertAndWarn( rp, error.UnsupportedTranslation, - ZigClangStmt_getBeginLoc(stmt), + stmt.getBeginLoc(), "TODO implement translation of stmt class {}", .{@tagName(sc)}, ); @@ -1343,24 +1343,24 @@ fn transStmt( fn transBinaryOperator( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangBinaryOperator, + stmt: *const clang.BinaryOperator, result_used: ResultUsed, ) TransError!*ast.Node { - const op = ZigClangBinaryOperator_getOpcode(stmt); - const qt = ZigClangBinaryOperator_getType(stmt); + const op = stmt.getOpcode(); + const qt = stmt.getType(); var op_token: ast.TokenIndex = undefined; var op_id: ast.Node.Tag = undefined; switch (op) { - .Assign => return try transCreateNodeAssign(rp, scope, result_used, ZigClangBinaryOperator_getLHS(stmt), ZigClangBinaryOperator_getRHS(stmt)), + .Assign => return try transCreateNodeAssign(rp, scope, result_used, stmt.getLHS(), stmt.getRHS()), .Comma => { const block_scope = try scope.findBlockScope(rp.c); const expr = block_scope.base.parent == scope; const lparen = if (expr) try appendToken(rp.c, .LParen, "(") else undefined; - const lhs = try transExpr(rp, &block_scope.base, ZigClangBinaryOperator_getLHS(stmt), .unused, .r_value); + const lhs = try transExpr(rp, &block_scope.base, stmt.getLHS(), .unused, .r_value); try block_scope.statements.append(lhs); - const rhs = try transExpr(rp, &block_scope.base, ZigClangBinaryOperator_getRHS(stmt), .used, .r_value); + const rhs = try transExpr(rp, &block_scope.base, stmt.getRHS(), .used, .r_value); if (expr) { _ = try appendToken(rp.c, .Semicolon, ";"); const break_node = try transCreateNodeBreak(rp.c, block_scope.label, rhs); @@ -1382,9 +1382,9 @@ fn transBinaryOperator( if (cIsSignedInteger(qt)) { // signed integer division uses @divTrunc const div_trunc_node = try rp.c.createBuiltinCall("@divTrunc", 2); - div_trunc_node.params()[0] = try transExpr(rp, scope, ZigClangBinaryOperator_getLHS(stmt), .used, .l_value); + div_trunc_node.params()[0] = try transExpr(rp, scope, stmt.getLHS(), .used, .l_value); _ = try appendToken(rp.c, .Comma, ","); - const rhs = try transExpr(rp, scope, ZigClangBinaryOperator_getRHS(stmt), .used, .r_value); + const rhs = try transExpr(rp, scope, stmt.getRHS(), .used, .r_value); div_trunc_node.params()[1] = rhs; div_trunc_node.rparen_token = try appendToken(rp.c, .RParen, ")"); return maybeSuppressResult(rp, scope, result_used, &div_trunc_node.base); @@ -1394,9 +1394,9 @@ fn transBinaryOperator( if (cIsSignedInteger(qt)) { // signed integer division uses @rem const rem_node = try rp.c.createBuiltinCall("@rem", 2); - rem_node.params()[0] = try transExpr(rp, scope, ZigClangBinaryOperator_getLHS(stmt), .used, .l_value); + rem_node.params()[0] = try transExpr(rp, scope, stmt.getLHS(), .used, .l_value); _ = try appendToken(rp.c, .Comma, ","); - const rhs = try transExpr(rp, scope, ZigClangBinaryOperator_getRHS(stmt), .used, .r_value); + const rhs = try transExpr(rp, scope, stmt.getRHS(), .used, .r_value); rem_node.params()[1] = rhs; rem_node.rparen_token = try appendToken(rp.c, .RParen, ")"); return maybeSuppressResult(rp, scope, result_used, &rem_node.base); @@ -1420,7 +1420,7 @@ fn transBinaryOperator( }, else => {}, } - const lhs_node = try transExpr(rp, scope, ZigClangBinaryOperator_getLHS(stmt), .used, .l_value); + const lhs_node = try transExpr(rp, scope, stmt.getLHS(), .used, .l_value); switch (op) { .Add => { if (cIsUnsignedInteger(qt)) { @@ -1498,7 +1498,7 @@ fn transBinaryOperator( else => unreachable, } - const rhs_node = try transExpr(rp, scope, ZigClangBinaryOperator_getRHS(stmt), .used, .r_value); + const rhs_node = try transExpr(rp, scope, stmt.getRHS(), .used, .r_value); const lhs = if (isBoolRes(lhs_node)) init: { const cast_node = try rp.c.createBuiltinCall("@boolToInt", 1); @@ -1520,18 +1520,18 @@ fn transBinaryOperator( fn transCompoundStmtInline( rp: RestorePoint, parent_scope: *Scope, - stmt: *const ZigClangCompoundStmt, + stmt: *const clang.CompoundStmt, block: *Scope.Block, ) TransError!void { - var it = ZigClangCompoundStmt_body_begin(stmt); - const end_it = ZigClangCompoundStmt_body_end(stmt); + var it = stmt.body_begin(); + const end_it = stmt.body_end(); while (it != end_it) : (it += 1) { const result = try transStmt(rp, parent_scope, it[0], .unused, .r_value); try block.statements.append(result); } } -fn transCompoundStmt(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCompoundStmt) TransError!*ast.Node { +fn transCompoundStmt(rp: RestorePoint, scope: *Scope, stmt: *const clang.CompoundStmt) TransError!*ast.Node { var block_scope = try Scope.Block.init(rp.c, scope, false); defer block_scope.deinit(); try transCompoundStmtInline(rp, &block_scope.base, stmt, &block_scope); @@ -1541,17 +1541,17 @@ fn transCompoundStmt(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCompo fn transCStyleCastExprClass( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangCStyleCastExpr, + stmt: *const clang.CStyleCastExpr, result_used: ResultUsed, lrvalue: LRValue, ) TransError!*ast.Node { - const sub_expr = ZigClangCStyleCastExpr_getSubExpr(stmt); + const sub_expr = stmt.getSubExpr(); const cast_node = (try transCCast( rp, scope, - ZigClangCStyleCastExpr_getBeginLoc(stmt), - ZigClangCStyleCastExpr_getType(stmt), - ZigClangExpr_getType(sub_expr), + stmt.getBeginLoc(), + stmt.getType(), + sub_expr.getType(), try transExpr(rp, scope, sub_expr, .used, lrvalue), )); return maybeSuppressResult(rp, scope, result_used, cast_node); @@ -1560,22 +1560,20 @@ fn transCStyleCastExprClass( fn transDeclStmtOne( rp: RestorePoint, scope: *Scope, - decl: *const ZigClangDecl, + decl: *const clang.Decl, block_scope: *Scope.Block, ) TransError!*ast.Node { const c = rp.c; - switch (ZigClangDecl_getKind(decl)) { + switch (decl.getKind()) { .Var => { - const var_decl = @ptrCast(*const ZigClangVarDecl, decl); + const var_decl = @ptrCast(*const clang.VarDecl, decl); - const qual_type = ZigClangVarDecl_getTypeSourceInfo_getType(var_decl); - const name = try c.str(ZigClangNamedDecl_getName_bytes_begin( - @ptrCast(*const ZigClangNamedDecl, var_decl), - )); + const qual_type = var_decl.getTypeSourceInfo_getType(); + const name = try c.str(@ptrCast(*const clang.NamedDecl, var_decl).getName_bytes_begin()); const mangled_name = try block_scope.makeMangledName(c, name); - switch (ZigClangVarDecl_getStorageClass(var_decl)) { + switch (var_decl.getStorageClass()) { .Extern, .Static => { // This is actually a global variable, put it in the global scope and reference it. // `_ = mangled_name;` @@ -1585,18 +1583,18 @@ fn transDeclStmtOne( else => {}, } - const mut_tok = if (ZigClangQualType_isConstQualified(qual_type)) + const mut_tok = if (qual_type.isConstQualified()) try appendToken(c, .Keyword_const, "const") else try appendToken(c, .Keyword_var, "var"); const name_tok = try appendIdentifier(c, mangled_name); _ = try appendToken(c, .Colon, ":"); - const loc = ZigClangDecl_getLocation(decl); + const loc = decl.getLocation(); const type_node = try transQualType(rp, qual_type, loc); const eq_token = try appendToken(c, .Equal, "="); - var init_node = if (ZigClangVarDecl_getInit(var_decl)) |expr| + var init_node = if (var_decl.getInit()) |expr| try transExprCoercing(rp, scope, expr, .used, .r_value) else try transCreateNodeUndefinedLiteral(c); @@ -1619,13 +1617,11 @@ fn transDeclStmtOne( return &node.base; }, .Typedef => { - const typedef_decl = @ptrCast(*const ZigClangTypedefNameDecl, decl); - const name = try c.str(ZigClangNamedDecl_getName_bytes_begin( - @ptrCast(*const ZigClangNamedDecl, typedef_decl), - )); + const typedef_decl = @ptrCast(*const clang.TypedefNameDecl, decl); + const name = try c.str(@ptrCast(*const clang.NamedDecl, typedef_decl).getName_bytes_begin()); - const underlying_qual = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl); - const underlying_type = ZigClangQualType_getTypePtr(underlying_qual); + const underlying_qual = typedef_decl.getUnderlyingType(); + const underlying_type = underlying_qual.getTypePtr(); const mangled_name = try block_scope.makeMangledName(c, name); const node = (try transCreateNodeTypedef(rp, typedef_decl, false, mangled_name)) orelse @@ -1635,18 +1631,18 @@ fn transDeclStmtOne( else => |kind| return revertAndWarn( rp, error.UnsupportedTranslation, - ZigClangDecl_getLocation(decl), + decl.getLocation(), "TODO implement translation of DeclStmt kind {}", .{@tagName(kind)}, ), } } -fn transDeclStmt(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangDeclStmt) TransError!*ast.Node { +fn transDeclStmt(rp: RestorePoint, scope: *Scope, stmt: *const clang.DeclStmt) TransError!*ast.Node { const block_scope = scope.findBlockScope(rp.c) catch unreachable; - var it = ZigClangDeclStmt_decl_begin(stmt); - const end_it = ZigClangDeclStmt_decl_end(stmt); + var it = stmt.decl_begin(); + const end_it = stmt.decl_end(); assert(it != end_it); while (true) : (it += 1) { const node = try transDeclStmtOne(rp, scope, it[0], block_scope); @@ -1663,11 +1659,11 @@ fn transDeclStmt(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangDeclStmt) fn transDeclRefExpr( rp: RestorePoint, scope: *Scope, - expr: *const ZigClangDeclRefExpr, + expr: *const clang.DeclRefExpr, lrvalue: LRValue, ) TransError!*ast.Node { - const value_decl = ZigClangDeclRefExpr_getDecl(expr); - const name = try rp.c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, value_decl))); + const value_decl = expr.getDecl(); + const name = try rp.c.str(@ptrCast(*const clang.NamedDecl, value_decl).getName_bytes_begin()); const mangled_name = scope.getAlias(name); return transCreateNodeIdentifier(rp.c, mangled_name); } @@ -1675,17 +1671,17 @@ fn transDeclRefExpr( fn transImplicitCastExpr( rp: RestorePoint, scope: *Scope, - expr: *const ZigClangImplicitCastExpr, + expr: *const clang.ImplicitCastExpr, result_used: ResultUsed, ) TransError!*ast.Node { const c = rp.c; - const sub_expr = ZigClangImplicitCastExpr_getSubExpr(expr); - const dest_type = getExprQualType(c, @ptrCast(*const ZigClangExpr, expr)); + const sub_expr = expr.getSubExpr(); + const dest_type = getExprQualType(c, @ptrCast(*const clang.Expr, expr)); const src_type = getExprQualType(c, sub_expr); - switch (ZigClangImplicitCastExpr_getCastKind(expr)) { + switch (expr.getCastKind()) { .BitCast, .FloatingCast, .FloatingToIntegral, .IntegralToFloating, .IntegralCast, .PointerToIntegral, .IntegralToPointer => { const sub_expr_node = try transExpr(rp, scope, sub_expr, .used, .r_value); - return try transCCast(rp, scope, ZigClangImplicitCastExpr_getBeginLoc(expr), dest_type, src_type, sub_expr_node); + return try transCCast(rp, scope, expr.getBeginLoc(), dest_type, src_type, sub_expr_node); }, .LValueToRValue, .NoOp, .FunctionToPointerDecay => { const sub_expr_node = try transExpr(rp, scope, sub_expr, .used, .r_value); @@ -1730,7 +1726,7 @@ fn transImplicitCastExpr( else => |kind| return revertAndWarn( rp, error.UnsupportedTranslation, - ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, expr)), + @ptrCast(*const clang.Stmt, expr).getBeginLoc(), "TODO implement translation of CastKind {}", .{@tagName(kind)}, ), @@ -1740,15 +1736,15 @@ fn transImplicitCastExpr( fn transBoolExpr( rp: RestorePoint, scope: *Scope, - expr: *const ZigClangExpr, + expr: *const clang.Expr, used: ResultUsed, lrvalue: LRValue, grouped: bool, ) TransError!*ast.Node { - if (ZigClangStmt_getStmtClass(@ptrCast(*const ZigClangStmt, expr)) == .IntegerLiteralClass) { + if (@ptrCast(*const clang.Stmt, expr).getStmtClass() == .IntegerLiteralClass) { var is_zero: bool = undefined; - if (!ZigClangIntegerLiteral_isZero(@ptrCast(*const ZigClangIntegerLiteral, expr), &is_zero, rp.c.clang_context)) { - return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangExpr_getBeginLoc(expr), "invalid integer literal", .{}); + if (!(@ptrCast(*const clang.IntegerLiteral, expr).isZero(&is_zero, rp.c.clang_context))) { + return revertAndWarn(rp, error.UnsupportedTranslation, expr.getBeginLoc(), "invalid integer literal", .{}); } return try transCreateNodeBoolLiteral(rp.c, !is_zero); } @@ -1769,8 +1765,8 @@ fn transBoolExpr( return res; } - const ty = ZigClangQualType_getTypePtr(getExprQualType(rp.c, expr)); - const node = try finishBoolExpr(rp, scope, ZigClangExpr_getBeginLoc(expr), ty, res, used); + const ty = getExprQualType(rp.c, expr).getTypePtr(); + const node = try finishBoolExpr(rp, scope, expr.getBeginLoc(), ty, res, used); if (grouped) { const rparen = try appendToken(rp.c, .RParen, ")"); @@ -1786,16 +1782,16 @@ fn transBoolExpr( } } -fn exprIsBooleanType(expr: *const ZigClangExpr) bool { - return qualTypeIsBoolean(ZigClangExpr_getType(expr)); +fn exprIsBooleanType(expr: *const clang.Expr) bool { + return qualTypeIsBoolean(expr.getType()); } -fn exprIsStringLiteral(expr: *const ZigClangExpr) bool { - switch (ZigClangExpr_getStmtClass(expr)) { +fn exprIsStringLiteral(expr: *const clang.Expr) bool { + switch (expr.getStmtClass()) { .StringLiteralClass => return true, .PredefinedExprClass => return true, .UnaryOperatorClass => { - const op_expr = ZigClangUnaryOperator_getSubExpr(@ptrCast(*const ZigClangUnaryOperator, expr)); + const op_expr = @ptrCast(*const clang.UnaryOperator, expr).getSubExpr(); return exprIsStringLiteral(op_expr); }, else => return false, @@ -1825,16 +1821,16 @@ fn isBoolRes(res: *ast.Node) bool { fn finishBoolExpr( rp: RestorePoint, scope: *Scope, - loc: ZigClangSourceLocation, - ty: *const ZigClangType, + loc: clang.SourceLocation, + ty: *const clang.Type, node: *ast.Node, used: ResultUsed, ) TransError!*ast.Node { - switch (ZigClangType_getTypeClass(ty)) { + switch (ty.getTypeClass()) { .Builtin => { - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty); + const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); - switch (ZigClangBuiltinType_getKind(builtin_ty)) { + switch (builtin_ty.getKind()) { .Bool => return node, .Char_U, .UChar, @@ -1879,10 +1875,10 @@ fn finishBoolExpr( return transCreateNodeInfixOp(rp, scope, node, .BangEqual, op_token, rhs_node, used, false); }, .Typedef => { - const typedef_ty = @ptrCast(*const ZigClangTypedefType, ty); - const typedef_decl = ZigClangTypedefType_getDecl(typedef_ty); - const underlying_type = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl); - return finishBoolExpr(rp, scope, loc, ZigClangQualType_getTypePtr(underlying_type), node, used); + const typedef_ty = @ptrCast(*const clang.TypedefType, ty); + const typedef_decl = typedef_ty.getDecl(); + const underlying_type = typedef_decl.getUnderlyingType(); + return finishBoolExpr(rp, scope, loc, underlying_type.getTypePtr(), node, used); }, .Enum => { const op_token = try appendToken(rp.c, .BangEqual, "!="); @@ -1890,9 +1886,9 @@ fn finishBoolExpr( return transCreateNodeInfixOp(rp, scope, node, .BangEqual, op_token, rhs_node, used, false); }, .Elaborated => { - const elaborated_ty = @ptrCast(*const ZigClangElaboratedType, ty); - const named_type = ZigClangElaboratedType_getNamedType(elaborated_ty); - return finishBoolExpr(rp, scope, loc, ZigClangQualType_getTypePtr(named_type), node, used); + const elaborated_ty = @ptrCast(*const clang.ElaboratedType, ty); + const named_type = elaborated_ty.getNamedType(); + return finishBoolExpr(rp, scope, loc, named_type.getTypePtr(), node, used); }, else => {}, } @@ -1906,18 +1902,18 @@ const SuppressCast = enum { fn transIntegerLiteral( rp: RestorePoint, scope: *Scope, - expr: *const ZigClangIntegerLiteral, + expr: *const clang.IntegerLiteral, result_used: ResultUsed, suppress_as: SuppressCast, ) TransError!*ast.Node { - var eval_result: ZigClangExprEvalResult = undefined; - if (!ZigClangIntegerLiteral_EvaluateAsInt(expr, &eval_result, rp.c.clang_context)) { - const loc = ZigClangIntegerLiteral_getBeginLoc(expr); + var eval_result: clang.ExprEvalResult = undefined; + if (!expr.EvaluateAsInt(&eval_result, rp.c.clang_context)) { + const loc = expr.getBeginLoc(); return revertAndWarn(rp, error.UnsupportedTranslation, loc, "invalid integer literal", .{}); } if (suppress_as == .no_as) { - const int_lit_node = try transCreateNodeAPInt(rp.c, ZigClangAPValue_getInt(&eval_result.Val)); + const int_lit_node = try transCreateNodeAPInt(rp.c, eval_result.Val.getInt()); return maybeSuppressResult(rp, scope, result_used, int_lit_node); } @@ -1932,12 +1928,12 @@ fn transIntegerLiteral( // But the first step is to be correct, and the next step is to make the output more elegant. // @as(T, x) - const expr_base = @ptrCast(*const ZigClangExpr, expr); + const expr_base = @ptrCast(*const clang.Expr, expr); const as_node = try rp.c.createBuiltinCall("@as", 2); - const ty_node = try transQualType(rp, ZigClangExpr_getType(expr_base), ZigClangExpr_getBeginLoc(expr_base)); + const ty_node = try transQualType(rp, expr_base.getType(), expr_base.getBeginLoc()); as_node.params()[0] = ty_node; _ = try appendToken(rp.c, .Comma, ","); - as_node.params()[1] = try transCreateNodeAPInt(rp.c, ZigClangAPValue_getInt(&eval_result.Val)); + as_node.params()[1] = try transCreateNodeAPInt(rp.c, eval_result.Val.getInt()); as_node.rparen_token = try appendToken(rp.c, .RParen, ")"); return maybeSuppressResult(rp, scope, result_used, &as_node.base); @@ -1946,10 +1942,10 @@ fn transIntegerLiteral( fn transReturnStmt( rp: RestorePoint, scope: *Scope, - expr: *const ZigClangReturnStmt, + expr: *const clang.ReturnStmt, ) TransError!*ast.Node { const return_kw = try appendToken(rp.c, .Keyword_return, "return"); - const rhs: ?*ast.Node = if (ZigClangReturnStmt_getRetValue(expr)) |val_expr| + const rhs: ?*ast.Node = if (expr.getRetValue()) |val_expr| try transExprCoercing(rp, scope, val_expr, .used, .r_value) else null; @@ -1966,14 +1962,14 @@ fn transReturnStmt( fn transStringLiteral( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangStringLiteral, + stmt: *const clang.StringLiteral, result_used: ResultUsed, ) TransError!*ast.Node { - const kind = ZigClangStringLiteral_getKind(stmt); + const kind = stmt.getKind(); switch (kind) { .Ascii, .UTF8 => { var len: usize = undefined; - const bytes_ptr = ZigClangStringLiteral_getString_bytes_begin_size(stmt, &len); + const bytes_ptr = stmt.getString_bytes_begin_size(&len); const str = bytes_ptr[0..len]; var char_buf: [4]u8 = undefined; @@ -1996,7 +1992,7 @@ fn transStringLiteral( .UTF16, .UTF32, .Wide => return revertAndWarn( rp, error.UnsupportedTranslation, - ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)), + @ptrCast(*const clang.Stmt, stmt).getBeginLoc(), "TODO: support string literal kind {}", .{kind}, ), @@ -2041,13 +2037,13 @@ fn escapeChar(c: u8, char_buf: *[4]u8) []const u8 { fn transCCast( rp: RestorePoint, scope: *Scope, - loc: ZigClangSourceLocation, - dst_type: ZigClangQualType, - src_type: ZigClangQualType, + loc: clang.SourceLocation, + dst_type: clang.QualType, + src_type: clang.QualType, expr: *ast.Node, ) !*ast.Node { - if (ZigClangType_isVoidType(qualTypeCanon(dst_type))) return expr; - if (ZigClangQualType_eq(dst_type, src_type)) return expr; + if (qualTypeCanon(dst_type).isVoidType()) return expr; + if (dst_type.eq(src_type)) return expr; if (qualTypeIsPtr(dst_type) and qualTypeIsPtr(src_type)) return transCPtrCast(rp, loc, dst_type, src_type, expr); if (cIsInteger(dst_type) and cIsInteger(src_type)) { @@ -2134,9 +2130,7 @@ fn transCCast( builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")"); return &builtin_node.base; } - if (ZigClangType_isBooleanType(qualTypeCanon(src_type)) and - !ZigClangType_isBooleanType(qualTypeCanon(dst_type))) - { + if (qualTypeIsBoolean(src_type) and !qualTypeIsBoolean(dst_type)) { // @boolToInt returns either a comptime_int or a u1 const builtin_node = try rp.c.createBuiltinCall("@boolToInt", 1); builtin_node.params()[0] = expr; @@ -2166,7 +2160,7 @@ fn transCCast( return &cast_node.base; } - if (ZigClangQualType_getTypeClass(ZigClangQualType_getCanonicalType(dst_type)) == .Enum) { + if (dst_type.getCanonicalType().getTypeClass() == .Enum) { const builtin_node = try rp.c.createBuiltinCall("@intToEnum", 2); builtin_node.params()[0] = try transQualType(rp, dst_type, loc); _ = try appendToken(rp.c, .Comma, ","); @@ -2174,8 +2168,8 @@ fn transCCast( builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")"); return &builtin_node.base; } - if (ZigClangQualType_getTypeClass(ZigClangQualType_getCanonicalType(src_type)) == .Enum and - ZigClangQualType_getTypeClass(ZigClangQualType_getCanonicalType(dst_type)) != .Enum) + if (src_type.getCanonicalType().getTypeClass() == .Enum and + dst_type.getCanonicalType().getTypeClass() != .Enum) { const builtin_node = try rp.c.createBuiltinCall("@enumToInt", 1); builtin_node.params()[0] = expr; @@ -2193,11 +2187,11 @@ fn transCCast( fn transExpr( rp: RestorePoint, scope: *Scope, - expr: *const ZigClangExpr, + expr: *const clang.Expr, used: ResultUsed, lrvalue: LRValue, ) TransError!*ast.Node { - return transStmt(rp, scope, @ptrCast(*const ZigClangStmt, expr), used, lrvalue); + return transStmt(rp, scope, @ptrCast(*const clang.Stmt, expr), used, lrvalue); } /// Same as `transExpr` but with the knowledge that the operand will be type coerced, and therefore @@ -2205,21 +2199,21 @@ fn transExpr( fn transExprCoercing( rp: RestorePoint, scope: *Scope, - expr: *const ZigClangExpr, + expr: *const clang.Expr, used: ResultUsed, lrvalue: LRValue, ) TransError!*ast.Node { - switch (ZigClangStmt_getStmtClass(@ptrCast(*const ZigClangStmt, expr))) { + switch (@ptrCast(*const clang.Stmt, expr).getStmtClass()) { .IntegerLiteralClass => { - return transIntegerLiteral(rp, scope, @ptrCast(*const ZigClangIntegerLiteral, expr), .used, .no_as); + return transIntegerLiteral(rp, scope, @ptrCast(*const clang.IntegerLiteral, expr), .used, .no_as); }, .CharacterLiteralClass => { - return transCharLiteral(rp, scope, @ptrCast(*const ZigClangCharacterLiteral, expr), .used, .no_as); + return transCharLiteral(rp, scope, @ptrCast(*const clang.CharacterLiteral, expr), .used, .no_as); }, .UnaryOperatorClass => { - const un_expr = @ptrCast(*const ZigClangUnaryOperator, expr); - if (ZigClangUnaryOperator_getOpcode(un_expr) == .Extension) { - return transExprCoercing(rp, scope, ZigClangUnaryOperator_getSubExpr(un_expr), used, lrvalue); + const un_expr = @ptrCast(*const clang.UnaryOperator, expr); + if (un_expr.getOpcode() == .Extension) { + return transExprCoercing(rp, scope, un_expr.getSubExpr(), used, lrvalue); } }, else => {}, @@ -2230,51 +2224,51 @@ fn transExprCoercing( fn transInitListExprRecord( rp: RestorePoint, scope: *Scope, - loc: ZigClangSourceLocation, - expr: *const ZigClangInitListExpr, - ty: *const ZigClangType, + loc: clang.SourceLocation, + expr: *const clang.InitListExpr, + ty: *const clang.Type, used: ResultUsed, ) TransError!*ast.Node { var is_union_type = false; // Unions and Structs are both represented as RecordDecl - const record_ty = ZigClangType_getAsRecordType(ty) orelse + const record_ty = ty.getAsRecordType() orelse blk: { is_union_type = true; - break :blk ZigClangType_getAsUnionType(ty); + break :blk ty.getAsUnionType(); } orelse unreachable; - const record_decl = ZigClangRecordType_getDecl(record_ty); - const record_def = ZigClangRecordDecl_getDefinition(record_decl) orelse + const record_decl = record_ty.getDecl(); + const record_def = record_decl.getDefinition() orelse unreachable; const ty_node = try transType(rp, ty, loc); - const init_count = ZigClangInitListExpr_getNumInits(expr); + const init_count = expr.getNumInits(); var field_inits = std.ArrayList(*ast.Node).init(rp.c.gpa); defer field_inits.deinit(); _ = try appendToken(rp.c, .LBrace, "{"); var init_i: c_uint = 0; - var it = ZigClangRecordDecl_field_begin(record_def); - const end_it = ZigClangRecordDecl_field_end(record_def); - while (ZigClangRecordDecl_field_iterator_neq(it, end_it)) : (it = ZigClangRecordDecl_field_iterator_next(it)) { - const field_decl = ZigClangRecordDecl_field_iterator_deref(it); + var it = record_def.field_begin(); + const end_it = record_def.field_end(); + while (it.neq(end_it)) : (it = it.next()) { + const field_decl = it.deref(); // The initializer for a union type has a single entry only - if (is_union_type and field_decl != ZigClangInitListExpr_getInitializedFieldInUnion(expr)) { + if (is_union_type and field_decl != expr.getInitializedFieldInUnion()) { continue; } assert(init_i < init_count); - const elem_expr = ZigClangInitListExpr_getInit(expr, init_i); + const elem_expr = expr.getInit(init_i); init_i += 1; // Generate the field assignment expression: // .field_name = expr const period_tok = try appendToken(rp.c, .Period, "."); - var raw_name = try rp.c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, field_decl))); - if (ZigClangFieldDecl_isAnonymousStructOrUnion(field_decl)) { - const name = rp.c.decl_table.get(@ptrToInt(ZigClangFieldDecl_getCanonicalDecl(field_decl))).?; + var raw_name = try rp.c.str(@ptrCast(*const clang.NamedDecl, field_decl).getName_bytes_begin()); + if (field_decl.isAnonymousStructOrUnion()) { + const name = rp.c.decl_table.get(@ptrToInt(field_decl.getCanonicalDecl())).?; raw_name = try mem.dupe(rp.c.arena, u8, name); } const field_name_tok = try appendIdentifier(rp.c, raw_name); @@ -2304,8 +2298,8 @@ fn transInitListExprRecord( fn transCreateNodeArrayType( rp: RestorePoint, - source_loc: ZigClangSourceLocation, - ty: *const ZigClangType, + source_loc: clang.SourceLocation, + ty: *const clang.Type, len: anytype, ) !*ast.Node { const node = try rp.c.arena.create(ast.Node.ArrayType); @@ -2323,18 +2317,18 @@ fn transCreateNodeArrayType( fn transInitListExprArray( rp: RestorePoint, scope: *Scope, - loc: ZigClangSourceLocation, - expr: *const ZigClangInitListExpr, - ty: *const ZigClangType, + loc: clang.SourceLocation, + expr: *const clang.InitListExpr, + ty: *const clang.Type, used: ResultUsed, ) TransError!*ast.Node { - const arr_type = ZigClangType_getAsArrayTypeUnsafe(ty); - const child_qt = ZigClangArrayType_getElementType(arr_type); - const init_count = ZigClangInitListExpr_getNumInits(expr); - assert(ZigClangType_isConstantArrayType(@ptrCast(*const ZigClangType, arr_type))); - const const_arr_ty = @ptrCast(*const ZigClangConstantArrayType, arr_type); - const size_ap_int = ZigClangConstantArrayType_getSize(const_arr_ty); - const all_count = ZigClangAPInt_getLimitedValue(size_ap_int, math.maxInt(usize)); + const arr_type = ty.getAsArrayTypeUnsafe(); + const child_qt = arr_type.getElementType(); + const init_count = expr.getNumInits(); + assert(@ptrCast(*const clang.Type, arr_type).isConstantArrayType()); + const const_arr_ty = @ptrCast(*const clang.ConstantArrayType, arr_type); + const size_ap_int = const_arr_ty.getSize(); + const all_count = size_ap_int.getLimitedValue(math.maxInt(usize)); const leftover_count = all_count - init_count; var init_node: *ast.Node.ArrayInitializer = undefined; @@ -2343,7 +2337,7 @@ fn transInitListExprArray( const ty_node = try transCreateNodeArrayType( rp, loc, - ZigClangQualType_getTypePtr(child_qt), + child_qt.getTypePtr(), init_count, ); _ = try appendToken(rp.c, .LBrace, "{"); @@ -2357,7 +2351,7 @@ fn transInitListExprArray( var i: c_uint = 0; while (i < init_count) : (i += 1) { - const elem_expr = ZigClangInitListExpr_getInit(expr, i); + const elem_expr = expr.getInit(i); init_list[i] = try transExpr(rp, scope, elem_expr, .used, .r_value); _ = try appendToken(rp.c, .Comma, ","); } @@ -2368,7 +2362,7 @@ fn transInitListExprArray( cat_tok = try appendToken(rp.c, .PlusPlus, "++"); } - const ty_node = try transCreateNodeArrayType(rp, loc, ZigClangQualType_getTypePtr(child_qt), 1); + const ty_node = try transCreateNodeArrayType(rp, loc, child_qt.getTypePtr(), 1); _ = try appendToken(rp.c, .LBrace, "{"); const filler_init_node = try ast.Node.ArrayInitializer.alloc(rp.c.arena, 1); filler_init_node.* = .{ @@ -2376,7 +2370,7 @@ fn transInitListExprArray( .rtoken = undefined, .list_len = 1, }; - const filler_val_expr = ZigClangInitListExpr_getArrayFiller(expr); + const filler_val_expr = expr.getArrayFiller(); filler_init_node.list()[0] = try transExpr(rp, scope, filler_val_expr, .used, .r_value); filler_init_node.rtoken = try appendToken(rp.c, .RBrace, "}"); @@ -2411,14 +2405,14 @@ fn transInitListExprArray( fn transInitListExpr( rp: RestorePoint, scope: *Scope, - expr: *const ZigClangInitListExpr, + expr: *const clang.InitListExpr, used: ResultUsed, ) TransError!*ast.Node { - const qt = getExprQualType(rp.c, @ptrCast(*const ZigClangExpr, expr)); - var qual_type = ZigClangQualType_getTypePtr(qt); - const source_loc = ZigClangExpr_getBeginLoc(@ptrCast(*const ZigClangExpr, expr)); + const qt = getExprQualType(rp.c, @ptrCast(*const clang.Expr, expr)); + var qual_type = qt.getTypePtr(); + const source_loc = @ptrCast(*const clang.Expr, expr).getBeginLoc(); - if (ZigClangType_isRecordType(qual_type)) { + if (qual_type.isRecordType()) { return transInitListExprRecord( rp, scope, @@ -2427,7 +2421,7 @@ fn transInitListExpr( qual_type, used, ); - } else if (ZigClangType_isArrayType(qual_type)) { + } else if (qual_type.isArrayType()) { return transInitListExprArray( rp, scope, @@ -2437,7 +2431,7 @@ fn transInitListExpr( used, ); } else { - const type_name = rp.c.str(ZigClangType_getTypeClassName(qual_type)); + const type_name = rp.c.str(qual_type.getTypeClassName()); return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported initlist type: '{}'", .{type_name}); } } @@ -2445,13 +2439,13 @@ fn transInitListExpr( fn transZeroInitExpr( rp: RestorePoint, scope: *Scope, - source_loc: ZigClangSourceLocation, - ty: *const ZigClangType, + source_loc: clang.SourceLocation, + ty: *const clang.Type, ) TransError!*ast.Node { - switch (ZigClangType_getTypeClass(ty)) { + switch (ty.getTypeClass()) { .Builtin => { - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty); - switch (ZigClangBuiltinType_getKind(builtin_ty)) { + const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); + switch (builtin_ty.getKind()) { .Bool => return try transCreateNodeBoolLiteral(rp.c, false), .Char_U, .UChar, @@ -2479,15 +2473,13 @@ fn transZeroInitExpr( }, .Pointer => return transCreateNodeNullLiteral(rp.c), .Typedef => { - const typedef_ty = @ptrCast(*const ZigClangTypedefType, ty); - const typedef_decl = ZigClangTypedefType_getDecl(typedef_ty); + const typedef_ty = @ptrCast(*const clang.TypedefType, ty); + const typedef_decl = typedef_ty.getDecl(); return transZeroInitExpr( rp, scope, source_loc, - ZigClangQualType_getTypePtr( - ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl), - ), + typedef_decl.getUnderlyingType().getTypePtr(), ); }, else => {}, @@ -2499,19 +2491,19 @@ fn transZeroInitExpr( fn transImplicitValueInitExpr( rp: RestorePoint, scope: *Scope, - expr: *const ZigClangExpr, + expr: *const clang.Expr, used: ResultUsed, ) TransError!*ast.Node { - const source_loc = ZigClangExpr_getBeginLoc(expr); + const source_loc = expr.getBeginLoc(); const qt = getExprQualType(rp.c, expr); - const ty = ZigClangQualType_getTypePtr(qt); + const ty = qt.getTypePtr(); return transZeroInitExpr(rp, scope, source_loc, ty); } fn transIfStmt( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangIfStmt, + stmt: *const clang.IfStmt, ) TransError!*ast.Node { // if (c) t // if (c) t else e @@ -2524,13 +2516,13 @@ fn transIfStmt( }, }; defer cond_scope.deinit(); - const cond_expr = @ptrCast(*const ZigClangExpr, ZigClangIfStmt_getCond(stmt)); + const cond_expr = @ptrCast(*const clang.Expr, stmt.getCond()); if_node.condition = try transBoolExpr(rp, &cond_scope.base, cond_expr, .used, .r_value, false); _ = try appendToken(rp.c, .RParen, ")"); - if_node.body = try transStmt(rp, scope, ZigClangIfStmt_getThen(stmt), .unused, .r_value); + if_node.body = try transStmt(rp, scope, stmt.getThen(), .unused, .r_value); - if (ZigClangIfStmt_getElse(stmt)) |expr| { + if (stmt.getElse()) |expr| { if_node.@"else" = try transCreateNodeElse(rp.c); if_node.@"else".?.body = try transStmt(rp, scope, expr, .unused, .r_value); } @@ -2541,7 +2533,7 @@ fn transIfStmt( fn transWhileLoop( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangWhileStmt, + stmt: *const clang.WhileStmt, ) TransError!*ast.Node { const while_node = try transCreateNodeWhile(rp.c); @@ -2552,7 +2544,7 @@ fn transWhileLoop( }, }; defer cond_scope.deinit(); - const cond_expr = @ptrCast(*const ZigClangExpr, ZigClangWhileStmt_getCond(stmt)); + const cond_expr = @ptrCast(*const clang.Expr, stmt.getCond()); while_node.condition = try transBoolExpr(rp, &cond_scope.base, cond_expr, .used, .r_value, false); _ = try appendToken(rp.c, .RParen, ")"); @@ -2560,7 +2552,7 @@ fn transWhileLoop( .parent = scope, .id = .Loop, }; - while_node.body = try transStmt(rp, &loop_scope, ZigClangWhileStmt_getBody(stmt), .unused, .r_value); + while_node.body = try transStmt(rp, &loop_scope, stmt.getBody(), .unused, .r_value); _ = try appendToken(rp.c, .Semicolon, ";"); return &while_node.base; } @@ -2568,7 +2560,7 @@ fn transWhileLoop( fn transDoWhileLoop( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangDoStmt, + stmt: *const clang.DoStmt, ) TransError!*ast.Node { const while_node = try transCreateNodeWhile(rp.c); @@ -2590,13 +2582,13 @@ fn transDoWhileLoop( }; defer cond_scope.deinit(); const prefix_op = try transCreateNodeSimplePrefixOp(rp.c, .BoolNot, .Bang, "!"); - prefix_op.rhs = try transBoolExpr(rp, &cond_scope.base, @ptrCast(*const ZigClangExpr, ZigClangDoStmt_getCond(stmt)), .used, .r_value, true); + prefix_op.rhs = try transBoolExpr(rp, &cond_scope.base, @ptrCast(*const clang.Expr, stmt.getCond()), .used, .r_value, true); _ = try appendToken(rp.c, .RParen, ")"); if_node.condition = &prefix_op.base; if_node.body = &(try transCreateNodeBreak(rp.c, null, null)).base; _ = try appendToken(rp.c, .Semicolon, ";"); - const body_node = if (ZigClangStmt_getStmtClass(ZigClangDoStmt_getBody(stmt)) == .CompoundStmtClass) blk: { + const body_node = if (stmt.getBody().getStmtClass() == .CompoundStmtClass) blk: { // there's already a block in C, so we'll append our condition to it. // c: do { // c: a; @@ -2607,7 +2599,7 @@ fn transDoWhileLoop( // zig: b; // zig: if (!cond) break; // zig: } - const node = try transStmt(rp, &loop_scope, ZigClangDoStmt_getBody(stmt), .unused, .r_value); + const node = try transStmt(rp, &loop_scope, stmt.getBody(), .unused, .r_value); break :blk node.castTag(.Block).?; } else blk: { // the C statement is without a block, so we need to create a block to contain it. @@ -2621,7 +2613,7 @@ fn transDoWhileLoop( new = true; const block = try rp.c.createBlock(2); block.statements_len = 1; // over-allocated so we can add another below - block.statements()[0] = try transStmt(rp, &loop_scope, ZigClangDoStmt_getBody(stmt), .unused, .r_value); + block.statements()[0] = try transStmt(rp, &loop_scope, stmt.getBody(), .unused, .r_value); break :blk block; }; @@ -2637,7 +2629,7 @@ fn transDoWhileLoop( fn transForLoop( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangForStmt, + stmt: *const clang.ForStmt, ) TransError!*ast.Node { var loop_scope = Scope{ .parent = scope, @@ -2647,7 +2639,7 @@ fn transForLoop( var block_scope: ?Scope.Block = null; defer if (block_scope) |*bs| bs.deinit(); - if (ZigClangForStmt_getInit(stmt)) |init| { + if (stmt.getInit()) |init| { block_scope = try Scope.Block.init(rp.c, scope, false); loop_scope.parent = &block_scope.?.base; const init_node = try transStmt(rp, &block_scope.?.base, init, .unused, .r_value); @@ -2662,20 +2654,20 @@ fn transForLoop( defer cond_scope.deinit(); const while_node = try transCreateNodeWhile(rp.c); - while_node.condition = if (ZigClangForStmt_getCond(stmt)) |cond| + while_node.condition = if (stmt.getCond()) |cond| try transBoolExpr(rp, &cond_scope.base, cond, .used, .r_value, false) else try transCreateNodeBoolLiteral(rp.c, true); _ = try appendToken(rp.c, .RParen, ")"); - if (ZigClangForStmt_getInc(stmt)) |incr| { + if (stmt.getInc()) |incr| { _ = try appendToken(rp.c, .Colon, ":"); _ = try appendToken(rp.c, .LParen, "("); while_node.continue_expr = try transExpr(rp, &cond_scope.base, incr, .unused, .r_value); _ = try appendToken(rp.c, .RParen, ")"); } - while_node.body = try transStmt(rp, &loop_scope, ZigClangForStmt_getBody(stmt), .unused, .r_value); + while_node.body = try transStmt(rp, &loop_scope, stmt.getBody(), .unused, .r_value); if (block_scope) |*bs| { try bs.statements.append(&while_node.base); return try bs.complete(rp.c); @@ -2685,21 +2677,21 @@ fn transForLoop( } } -fn getSwitchCaseCount(stmt: *const ZigClangSwitchStmt) usize { - const body = ZigClangSwitchStmt_getBody(stmt); - assert(ZigClangStmt_getStmtClass(body) == .CompoundStmtClass); - const comp = @ptrCast(*const ZigClangCompoundStmt, body); +fn getSwitchCaseCount(stmt: *const clang.SwitchStmt) usize { + const body = stmt.getBody(); + assert(body.getStmtClass() == .CompoundStmtClass); + const comp = @ptrCast(*const clang.CompoundStmt, body); // TODO https://github.com/ziglang/zig/issues/1738 - // return ZigClangCompoundStmt_body_end(comp) - ZigClangCompoundStmt_body_begin(comp); - const start_addr = @ptrToInt(ZigClangCompoundStmt_body_begin(comp)); - const end_addr = @ptrToInt(ZigClangCompoundStmt_body_end(comp)); - return (end_addr - start_addr) / @sizeOf(*ZigClangStmt); + // return comp.body_end() - comp.body_begin(); + const start_addr = @ptrToInt(comp.body_begin()); + const end_addr = @ptrToInt(comp.body_end()); + return (end_addr - start_addr) / @sizeOf(*clang.Stmt); } fn transSwitch( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangSwitchStmt, + stmt: *const clang.SwitchStmt, ) TransError!*ast.Node { const switch_tok = try appendToken(rp.c, .Keyword_switch, "switch"); _ = try appendToken(rp.c, .LParen, "("); @@ -2713,7 +2705,7 @@ fn transSwitch( }, }; defer cond_scope.deinit(); - const switch_expr = try transExpr(rp, &cond_scope.base, ZigClangSwitchStmt_getCond(stmt), .used, .r_value); + const switch_expr = try transExpr(rp, &cond_scope.base, stmt.getCond(), .used, .r_value); _ = try appendToken(rp.c, .RParen, ")"); _ = try appendToken(rp.c, .LBrace, "{"); // reserve +1 case in case there is no default case @@ -2748,7 +2740,7 @@ fn transSwitch( switch_scope.pending_block = try Scope.Block.init(rp.c, scope, false); try switch_scope.pending_block.statements.append(&switch_node.base); - const last = try transStmt(rp, &block_scope.base, ZigClangSwitchStmt_getBody(stmt), .unused, .r_value); + const last = try transStmt(rp, &block_scope.base, stmt.getBody(), .unused, .r_value); _ = try appendToken(rp.c, .Semicolon, ";"); // take all pending statements @@ -2776,7 +2768,7 @@ fn transSwitch( _ = try appendToken(rp.c, .Comma, ","); if (switch_scope.case_index >= switch_scope.cases.len) - return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)), "TODO complex switch cases", .{}); + return revertAndWarn(rp, error.UnsupportedTranslation, @ptrCast(*const clang.Stmt, stmt).getBeginLoc(), "TODO complex switch cases", .{}); switch_scope.cases[switch_scope.case_index] = &else_prong.base; switch_scope.case_index += 1; } @@ -2792,15 +2784,15 @@ fn transSwitch( fn transCase( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangCaseStmt, + stmt: *const clang.CaseStmt, ) TransError!*ast.Node { const block_scope = scope.findBlockScope(rp.c) catch unreachable; const switch_scope = scope.getSwitch(); const label = try block_scope.makeMangledName(rp.c, "case"); _ = try appendToken(rp.c, .Semicolon, ";"); - const expr = if (ZigClangCaseStmt_getRHS(stmt)) |rhs| blk: { - const lhs_node = try transExpr(rp, scope, ZigClangCaseStmt_getLHS(stmt), .used, .r_value); + const expr = if (stmt.getRHS()) |rhs| blk: { + const lhs_node = try transExpr(rp, scope, stmt.getLHS(), .used, .r_value); const ellips = try appendToken(rp.c, .Ellipsis3, "..."); const rhs_node = try transExpr(rp, scope, rhs, .used, .r_value); @@ -2813,7 +2805,7 @@ fn transCase( }; break :blk &node.base; } else - try transExpr(rp, scope, ZigClangCaseStmt_getLHS(stmt), .used, .r_value); + try transExpr(rp, scope, stmt.getLHS(), .used, .r_value); const switch_prong = try transCreateNodeSwitchCase(rp.c, expr); switch_prong.expr = blk: { @@ -2823,7 +2815,7 @@ fn transCase( _ = try appendToken(rp.c, .Comma, ","); if (switch_scope.case_index >= switch_scope.cases.len) - return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)), "TODO complex switch cases", .{}); + return revertAndWarn(rp, error.UnsupportedTranslation, @ptrCast(*const clang.Stmt, stmt).getBeginLoc(), "TODO complex switch cases", .{}); switch_scope.cases[switch_scope.case_index] = &switch_prong.base; switch_scope.case_index += 1; @@ -2840,13 +2832,13 @@ fn transCase( try switch_scope.pending_block.statements.append(pending_node); - return transStmt(rp, scope, ZigClangCaseStmt_getSubStmt(stmt), .unused, .r_value); + return transStmt(rp, scope, stmt.getSubStmt(), .unused, .r_value); } fn transDefault( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangDefaultStmt, + stmt: *const clang.DefaultStmt, ) TransError!*ast.Node { const block_scope = scope.findBlockScope(rp.c) catch unreachable; const switch_scope = scope.getSwitch(); @@ -2861,7 +2853,7 @@ fn transDefault( _ = try appendToken(rp.c, .Comma, ","); if (switch_scope.case_index >= switch_scope.cases.len) - return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)), "TODO complex switch cases", .{}); + return revertAndWarn(rp, error.UnsupportedTranslation, @ptrCast(*const clang.Stmt, stmt).getBeginLoc(), "TODO complex switch cases", .{}); switch_scope.cases[switch_scope.case_index] = &else_prong.base; switch_scope.case_index += 1; @@ -2877,26 +2869,26 @@ fn transDefault( switch_scope.pending_block = try Scope.Block.init(rp.c, scope, false); try switch_scope.pending_block.statements.append(pending_node); - return transStmt(rp, scope, ZigClangDefaultStmt_getSubStmt(stmt), .unused, .r_value); + return transStmt(rp, scope, stmt.getSubStmt(), .unused, .r_value); } -fn transConstantExpr(rp: RestorePoint, scope: *Scope, expr: *const ZigClangExpr, used: ResultUsed) TransError!*ast.Node { - var result: ZigClangExprEvalResult = undefined; - if (!ZigClangExpr_EvaluateAsConstantExpr(expr, &result, .EvaluateForCodeGen, rp.c.clang_context)) - return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangExpr_getBeginLoc(expr), "invalid constant expression", .{}); +fn transConstantExpr(rp: RestorePoint, scope: *Scope, expr: *const clang.Expr, used: ResultUsed) TransError!*ast.Node { + var result: clang.ExprEvalResult = undefined; + if (!expr.EvaluateAsConstantExpr(&result, .EvaluateForCodeGen, rp.c.clang_context)) + return revertAndWarn(rp, error.UnsupportedTranslation, expr.getBeginLoc(), "invalid constant expression", .{}); var val_node: ?*ast.Node = null; - switch (ZigClangAPValue_getKind(&result.Val)) { + switch (result.Val.getKind()) { .Int => { // See comment in `transIntegerLiteral` for why this code is here. // @as(T, x) - const expr_base = @ptrCast(*const ZigClangExpr, expr); + const expr_base = @ptrCast(*const clang.Expr, expr); const as_node = try rp.c.createBuiltinCall("@as", 2); - const ty_node = try transQualType(rp, ZigClangExpr_getType(expr_base), ZigClangExpr_getBeginLoc(expr_base)); + const ty_node = try transQualType(rp, expr_base.getType(), expr_base.getBeginLoc()); as_node.params()[0] = ty_node; _ = try appendToken(rp.c, .Comma, ","); - const int_lit_node = try transCreateNodeAPInt(rp.c, ZigClangAPValue_getInt(&result.Val)); + const int_lit_node = try transCreateNodeAPInt(rp.c, result.Val.getInt()); as_node.params()[1] = int_lit_node; as_node.rparen_token = try appendToken(rp.c, .RParen, ")"); @@ -2904,26 +2896,26 @@ fn transConstantExpr(rp: RestorePoint, scope: *Scope, expr: *const ZigClangExpr, return maybeSuppressResult(rp, scope, used, &as_node.base); }, else => { - return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangExpr_getBeginLoc(expr), "unsupported constant expression kind", .{}); + return revertAndWarn(rp, error.UnsupportedTranslation, expr.getBeginLoc(), "unsupported constant expression kind", .{}); }, } } -fn transPredefinedExpr(rp: RestorePoint, scope: *Scope, expr: *const ZigClangPredefinedExpr, used: ResultUsed) TransError!*ast.Node { - return transStringLiteral(rp, scope, ZigClangPredefinedExpr_getFunctionName(expr), used); +fn transPredefinedExpr(rp: RestorePoint, scope: *Scope, expr: *const clang.PredefinedExpr, used: ResultUsed) TransError!*ast.Node { + return transStringLiteral(rp, scope, expr.getFunctionName(), used); } fn transCharLiteral( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangCharacterLiteral, + stmt: *const clang.CharacterLiteral, result_used: ResultUsed, suppress_as: SuppressCast, ) TransError!*ast.Node { - const kind = ZigClangCharacterLiteral_getKind(stmt); + const kind = stmt.getKind(); const int_lit_node = switch (kind) { .Ascii, .UTF8 => blk: { - const val = ZigClangCharacterLiteral_getValue(stmt); + const val = stmt.getValue(); if (kind == .Ascii) { // C has a somewhat obscure feature called multi-character character // constant @@ -2942,7 +2934,7 @@ fn transCharLiteral( .UTF16, .UTF32, .Wide => return revertAndWarn( rp, error.UnsupportedTranslation, - ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)), + @ptrCast(*const clang.Stmt, stmt).getBeginLoc(), "TODO: support character literal kind {}", .{kind}, ), @@ -2952,9 +2944,9 @@ fn transCharLiteral( } // See comment in `transIntegerLiteral` for why this code is here. // @as(T, x) - const expr_base = @ptrCast(*const ZigClangExpr, stmt); + const expr_base = @ptrCast(*const clang.Expr, stmt); const as_node = try rp.c.createBuiltinCall("@as", 2); - const ty_node = try transQualType(rp, ZigClangExpr_getType(expr_base), ZigClangExpr_getBeginLoc(expr_base)); + const ty_node = try transQualType(rp, expr_base.getType(), expr_base.getBeginLoc()); as_node.params()[0] = ty_node; _ = try appendToken(rp.c, .Comma, ","); as_node.params()[1] = int_lit_node; @@ -2963,8 +2955,8 @@ fn transCharLiteral( return maybeSuppressResult(rp, scope, result_used, &as_node.base); } -fn transStmtExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangStmtExpr, used: ResultUsed) TransError!*ast.Node { - const comp = ZigClangStmtExpr_getSubStmt(stmt); +fn transStmtExpr(rp: RestorePoint, scope: *Scope, stmt: *const clang.StmtExpr, used: ResultUsed) TransError!*ast.Node { + const comp = stmt.getSubStmt(); if (used == .unused) { return transCompoundStmt(rp, scope, comp); } @@ -2972,8 +2964,8 @@ fn transStmtExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangStmtExpr, var block_scope = try Scope.Block.init(rp.c, scope, true); defer block_scope.deinit(); - var it = ZigClangCompoundStmt_body_begin(comp); - const end_it = ZigClangCompoundStmt_body_end(comp); + var it = comp.body_begin(); + const end_it = comp.body_end(); while (it != end_it - 1) : (it += 1) { const result = try transStmt(rp, &block_scope.base, it[0], .unused, .r_value); try block_scope.statements.append(result); @@ -2996,43 +2988,43 @@ fn transStmtExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangStmtExpr, return maybeSuppressResult(rp, scope, used, &grouped_expr.base); } -fn transMemberExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangMemberExpr, result_used: ResultUsed) TransError!*ast.Node { - var container_node = try transExpr(rp, scope, ZigClangMemberExpr_getBase(stmt), .used, .r_value); +fn transMemberExpr(rp: RestorePoint, scope: *Scope, stmt: *const clang.MemberExpr, result_used: ResultUsed) TransError!*ast.Node { + var container_node = try transExpr(rp, scope, stmt.getBase(), .used, .r_value); - if (ZigClangMemberExpr_isArrow(stmt)) { + if (stmt.isArrow()) { container_node = try transCreateNodePtrDeref(rp.c, container_node); } - const member_decl = ZigClangMemberExpr_getMemberDecl(stmt); + const member_decl = stmt.getMemberDecl(); const name = blk: { - const decl_kind = ZigClangDecl_getKind(@ptrCast(*const ZigClangDecl, member_decl)); + const decl_kind = @ptrCast(*const clang.Decl, member_decl).getKind(); // If we're referring to a anonymous struct/enum find the bogus name // we've assigned to it during the RecordDecl translation if (decl_kind == .Field) { - const field_decl = @ptrCast(*const struct_ZigClangFieldDecl, member_decl); - if (ZigClangFieldDecl_isAnonymousStructOrUnion(field_decl)) { - const name = rp.c.decl_table.get(@ptrToInt(ZigClangFieldDecl_getCanonicalDecl(field_decl))).?; + const field_decl = @ptrCast(*const clang.FieldDecl, member_decl); + if (field_decl.isAnonymousStructOrUnion()) { + const name = rp.c.decl_table.get(@ptrToInt(field_decl.getCanonicalDecl())).?; break :blk try mem.dupe(rp.c.arena, u8, name); } } - const decl = @ptrCast(*const ZigClangNamedDecl, member_decl); - break :blk try rp.c.str(ZigClangNamedDecl_getName_bytes_begin(decl)); + const decl = @ptrCast(*const clang.NamedDecl, member_decl); + break :blk try rp.c.str(decl.getName_bytes_begin()); }; const node = try transCreateNodeFieldAccess(rp.c, container_node, name); return maybeSuppressResult(rp, scope, result_used, node); } -fn transArrayAccess(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangArraySubscriptExpr, result_used: ResultUsed) TransError!*ast.Node { - var base_stmt = ZigClangArraySubscriptExpr_getBase(stmt); +fn transArrayAccess(rp: RestorePoint, scope: *Scope, stmt: *const clang.ArraySubscriptExpr, result_used: ResultUsed) TransError!*ast.Node { + var base_stmt = stmt.getBase(); // Unwrap the base statement if it's an array decayed to a bare pointer type // so that we index the array itself - if (ZigClangStmt_getStmtClass(@ptrCast(*const ZigClangStmt, base_stmt)) == .ImplicitCastExprClass) { - const implicit_cast = @ptrCast(*const ZigClangImplicitCastExpr, base_stmt); + if (@ptrCast(*const clang.Stmt, base_stmt).getStmtClass() == .ImplicitCastExprClass) { + const implicit_cast = @ptrCast(*const clang.ImplicitCastExpr, base_stmt); - if (ZigClangImplicitCastExpr_getCastKind(implicit_cast) == .ArrayToPointerDecay) { - base_stmt = ZigClangImplicitCastExpr_getSubExpr(implicit_cast); + if (implicit_cast.getCastKind() == .ArrayToPointerDecay) { + base_stmt = implicit_cast.getSubExpr(); } } @@ -3040,7 +3032,7 @@ fn transArrayAccess(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangArrayS const node = try transCreateNodeArrayAccess(rp.c, container_node); // cast if the index is long long or signed - const subscr_expr = ZigClangArraySubscriptExpr_getIdx(stmt); + const subscr_expr = stmt.getIdx(); const qt = getExprQualType(rp.c, subscr_expr); const is_longlong = cIsLongLongInteger(qt); const is_signed = cIsSignedInteger(qt); @@ -3062,23 +3054,23 @@ fn transArrayAccess(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangArrayS return maybeSuppressResult(rp, scope, result_used, &node.base); } -fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCallExpr, result_used: ResultUsed) TransError!*ast.Node { - const callee = ZigClangCallExpr_getCallee(stmt); +fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const clang.CallExpr, result_used: ResultUsed) TransError!*ast.Node { + const callee = stmt.getCallee(); var raw_fn_expr = try transExpr(rp, scope, callee, .used, .r_value); var is_ptr = false; - const fn_ty = qualTypeGetFnProto(ZigClangExpr_getType(callee), &is_ptr); + const fn_ty = qualTypeGetFnProto(callee.getType(), &is_ptr); const fn_expr = if (is_ptr and fn_ty != null) blk: { - if (ZigClangExpr_getStmtClass(callee) == .ImplicitCastExprClass) { - const implicit_cast = @ptrCast(*const ZigClangImplicitCastExpr, callee); + if (callee.getStmtClass() == .ImplicitCastExprClass) { + const implicit_cast = @ptrCast(*const clang.ImplicitCastExpr, callee); - if (ZigClangImplicitCastExpr_getCastKind(implicit_cast) == .FunctionToPointerDecay) { - const subexpr = ZigClangImplicitCastExpr_getSubExpr(implicit_cast); - if (ZigClangExpr_getStmtClass(subexpr) == .DeclRefExprClass) { - const decl_ref = @ptrCast(*const ZigClangDeclRefExpr, subexpr); - const named_decl = ZigClangDeclRefExpr_getFoundDecl(decl_ref); - if (ZigClangDecl_getKind(@ptrCast(*const ZigClangDecl, named_decl)) == .Function) { + if (implicit_cast.getCastKind() == .FunctionToPointerDecay) { + const subexpr = implicit_cast.getSubExpr(); + if (subexpr.getStmtClass() == .DeclRefExprClass) { + const decl_ref = @ptrCast(*const clang.DeclRefExpr, subexpr); + const named_decl = decl_ref.getFoundDecl(); + if (@ptrCast(*const clang.Decl, named_decl).getKind() == .Function) { break :blk raw_fn_expr; } } @@ -3088,11 +3080,11 @@ fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCallExpr, } else raw_fn_expr; - const num_args = ZigClangCallExpr_getNumArgs(stmt); + const num_args = stmt.getNumArgs(); const node = try rp.c.createCall(fn_expr, num_args); const call_params = node.params(); - const args = ZigClangCallExpr_getArgs(stmt); + const args = stmt.getArgs(); var i: usize = 0; while (i < num_args) : (i += 1) { if (i != 0) { @@ -3103,9 +3095,9 @@ fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCallExpr, node.rtoken = try appendToken(rp.c, .RParen, ")"); if (fn_ty) |ty| { - const canon = ZigClangQualType_getCanonicalType(ty.getReturnType()); - const ret_ty = ZigClangQualType_getTypePtr(canon); - if (ZigClangType_isVoidType(ret_ty)) { + const canon = ty.getReturnType().getCanonicalType(); + const ret_ty = canon.getTypePtr(); + if (ret_ty.isVoidType()) { _ = try appendToken(rp.c, .Semicolon, ";"); return &node.base; } @@ -3115,32 +3107,32 @@ fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCallExpr, } const ClangFunctionType = union(enum) { - Proto: *const ZigClangFunctionProtoType, - NoProto: *const ZigClangFunctionType, + Proto: *const clang.FunctionProtoType, + NoProto: *const clang.FunctionType, - fn getReturnType(self: @This()) ZigClangQualType { + fn getReturnType(self: @This()) clang.QualType { switch (@as(@TagType(@This()), self)) { - .Proto => return ZigClangFunctionProtoType_getReturnType(self.Proto), - .NoProto => return ZigClangFunctionType_getReturnType(self.NoProto), + .Proto => return self.Proto.getReturnType(), + .NoProto => return self.NoProto.getReturnType(), } } }; -fn qualTypeGetFnProto(qt: ZigClangQualType, is_ptr: *bool) ?ClangFunctionType { - const canon = ZigClangQualType_getCanonicalType(qt); - var ty = ZigClangQualType_getTypePtr(canon); +fn qualTypeGetFnProto(qt: clang.QualType, is_ptr: *bool) ?ClangFunctionType { + const canon = qt.getCanonicalType(); + var ty = canon.getTypePtr(); is_ptr.* = false; - if (ZigClangType_getTypeClass(ty) == .Pointer) { + if (ty.getTypeClass() == .Pointer) { is_ptr.* = true; - const child_qt = ZigClangType_getPointeeType(ty); - ty = ZigClangQualType_getTypePtr(child_qt); + const child_qt = ty.getPointeeType(); + ty = child_qt.getTypePtr(); } - if (ZigClangType_getTypeClass(ty) == .FunctionProto) { - return ClangFunctionType{ .Proto = @ptrCast(*const ZigClangFunctionProtoType, ty) }; + if (ty.getTypeClass() == .FunctionProto) { + return ClangFunctionType{ .Proto = @ptrCast(*const clang.FunctionProtoType, ty) }; } - if (ZigClangType_getTypeClass(ty) == .FunctionNoProto) { - return ClangFunctionType{ .NoProto = @ptrCast(*const ZigClangFunctionType, ty) }; + if (ty.getTypeClass() == .FunctionNoProto) { + return ClangFunctionType{ .NoProto = @ptrCast(*const clang.FunctionType, ty) }; } return null; } @@ -3148,17 +3140,17 @@ fn qualTypeGetFnProto(qt: ZigClangQualType, is_ptr: *bool) ?ClangFunctionType { fn transUnaryExprOrTypeTraitExpr( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangUnaryExprOrTypeTraitExpr, + stmt: *const clang.UnaryExprOrTypeTraitExpr, result_used: ResultUsed, ) TransError!*ast.Node { - const loc = ZigClangUnaryExprOrTypeTraitExpr_getBeginLoc(stmt); + const loc = stmt.getBeginLoc(); const type_node = try transQualType( rp, - ZigClangUnaryExprOrTypeTraitExpr_getTypeOfArgument(stmt), + stmt.getTypeOfArgument(), loc, ); - const kind = ZigClangUnaryExprOrTypeTraitExpr_getKind(stmt); + const kind = stmt.getKind(); const kind_str = switch (kind) { .SizeOf => "@sizeOf", .AlignOf => "@alignOf", @@ -3180,7 +3172,7 @@ fn transUnaryExprOrTypeTraitExpr( return maybeSuppressResult(rp, scope, result_used, &builtin_node.base); } -fn qualTypeHasWrappingOverflow(qt: ZigClangQualType) bool { +fn qualTypeHasWrappingOverflow(qt: clang.QualType) bool { if (cIsUnsignedInteger(qt)) { // unsigned integer overflow wraps around. return true; @@ -3190,22 +3182,22 @@ fn qualTypeHasWrappingOverflow(qt: ZigClangQualType) bool { } } -fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangUnaryOperator, used: ResultUsed) TransError!*ast.Node { - const op_expr = ZigClangUnaryOperator_getSubExpr(stmt); - switch (ZigClangUnaryOperator_getOpcode(stmt)) { - .PostInc => if (qualTypeHasWrappingOverflow(ZigClangUnaryOperator_getType(stmt))) +fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const clang.UnaryOperator, used: ResultUsed) TransError!*ast.Node { + const op_expr = stmt.getSubExpr(); + switch (stmt.getOpcode()) { + .PostInc => if (qualTypeHasWrappingOverflow(stmt.getType())) return transCreatePostCrement(rp, scope, stmt, .AssignAddWrap, .PlusPercentEqual, "+%=", used) else return transCreatePostCrement(rp, scope, stmt, .AssignAdd, .PlusEqual, "+=", used), - .PostDec => if (qualTypeHasWrappingOverflow(ZigClangUnaryOperator_getType(stmt))) + .PostDec => if (qualTypeHasWrappingOverflow(stmt.getType())) return transCreatePostCrement(rp, scope, stmt, .AssignSubWrap, .MinusPercentEqual, "-%=", used) else return transCreatePostCrement(rp, scope, stmt, .AssignSub, .MinusEqual, "-=", used), - .PreInc => if (qualTypeHasWrappingOverflow(ZigClangUnaryOperator_getType(stmt))) + .PreInc => if (qualTypeHasWrappingOverflow(stmt.getType())) return transCreatePreCrement(rp, scope, stmt, .AssignAddWrap, .PlusPercentEqual, "+%=", used) else return transCreatePreCrement(rp, scope, stmt, .AssignAdd, .PlusEqual, "+=", used), - .PreDec => if (qualTypeHasWrappingOverflow(ZigClangUnaryOperator_getType(stmt))) + .PreDec => if (qualTypeHasWrappingOverflow(stmt.getType())) return transCreatePreCrement(rp, scope, stmt, .AssignSubWrap, .MinusPercentEqual, "-%=", used) else return transCreatePreCrement(rp, scope, stmt, .AssignSub, .MinusEqual, "-=", used), @@ -3217,7 +3209,7 @@ fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangUnar .Deref => { const value_node = try transExpr(rp, scope, op_expr, used, .r_value); var is_ptr = false; - const fn_ty = qualTypeGetFnProto(ZigClangExpr_getType(op_expr), &is_ptr); + const fn_ty = qualTypeGetFnProto(op_expr.getType(), &is_ptr); if (fn_ty != null and is_ptr) return value_node; const unwrapped = try transCreateNodeUnwrapNull(rp.c, value_node); @@ -3225,18 +3217,18 @@ fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangUnar }, .Plus => return transExpr(rp, scope, op_expr, used, .r_value), .Minus => { - if (!qualTypeHasWrappingOverflow(ZigClangExpr_getType(op_expr))) { + if (!qualTypeHasWrappingOverflow(op_expr.getType())) { const op_node = try transCreateNodeSimplePrefixOp(rp.c, .Negation, .Minus, "-"); op_node.rhs = try transExpr(rp, scope, op_expr, .used, .r_value); return &op_node.base; - } else if (cIsUnsignedInteger(ZigClangExpr_getType(op_expr))) { + } else if (cIsUnsignedInteger(op_expr.getType())) { // we gotta emit 0 -% x const zero = try transCreateNodeInt(rp.c, 0); const token = try appendToken(rp.c, .MinusPercent, "-%"); const expr = try transExpr(rp, scope, op_expr, .used, .r_value); return transCreateNodeInfixOp(rp, scope, zero, .SubWrap, token, expr, used, true); } else - return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangUnaryOperator_getBeginLoc(stmt), "C negation with non float non integer", .{}); + return revertAndWarn(rp, error.UnsupportedTranslation, stmt.getBeginLoc(), "C negation with non float non integer", .{}); }, .Not => { const op_node = try transCreateNodeSimplePrefixOp(rp.c, .BitNot, .Tilde, "~"); @@ -3249,22 +3241,22 @@ fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangUnar return &op_node.base; }, .Extension => { - return transExpr(rp, scope, ZigClangUnaryOperator_getSubExpr(stmt), used, .l_value); + return transExpr(rp, scope, stmt.getSubExpr(), used, .l_value); }, - else => return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangUnaryOperator_getBeginLoc(stmt), "unsupported C translation {}", .{ZigClangUnaryOperator_getOpcode(stmt)}), + else => return revertAndWarn(rp, error.UnsupportedTranslation, stmt.getBeginLoc(), "unsupported C translation {}", .{stmt.getOpcode()}), } } fn transCreatePreCrement( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangUnaryOperator, + stmt: *const clang.UnaryOperator, op: ast.Node.Tag, op_tok_id: std.zig.Token.Id, bytes: []const u8, used: ResultUsed, ) TransError!*ast.Node { - const op_expr = ZigClangUnaryOperator_getSubExpr(stmt); + const op_expr = stmt.getSubExpr(); if (used == .unused) { // common case @@ -3331,13 +3323,13 @@ fn transCreatePreCrement( fn transCreatePostCrement( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangUnaryOperator, + stmt: *const clang.UnaryOperator, op: ast.Node.Tag, op_tok_id: std.zig.Token.Id, bytes: []const u8, used: ResultUsed, ) TransError!*ast.Node { - const op_expr = ZigClangUnaryOperator_getSubExpr(stmt); + const op_expr = stmt.getSubExpr(); if (used == .unused) { // common case @@ -3422,17 +3414,17 @@ fn transCreatePostCrement( return &grouped_expr.base; } -fn transCompoundAssignOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCompoundAssignOperator, used: ResultUsed) TransError!*ast.Node { - switch (ZigClangCompoundAssignOperator_getOpcode(stmt)) { - .MulAssign => if (qualTypeHasWrappingOverflow(ZigClangCompoundAssignOperator_getType(stmt))) +fn transCompoundAssignOperator(rp: RestorePoint, scope: *Scope, stmt: *const clang.CompoundAssignOperator, used: ResultUsed) TransError!*ast.Node { + switch (stmt.getOpcode()) { + .MulAssign => if (qualTypeHasWrappingOverflow(stmt.getType())) return transCreateCompoundAssign(rp, scope, stmt, .AssignMulWrap, .AsteriskPercentEqual, "*%=", .MulWrap, .AsteriskPercent, "*%", used) else return transCreateCompoundAssign(rp, scope, stmt, .AssignMul, .AsteriskEqual, "*=", .Mul, .Asterisk, "*", used), - .AddAssign => if (qualTypeHasWrappingOverflow(ZigClangCompoundAssignOperator_getType(stmt))) + .AddAssign => if (qualTypeHasWrappingOverflow(stmt.getType())) return transCreateCompoundAssign(rp, scope, stmt, .AssignAddWrap, .PlusPercentEqual, "+%=", .AddWrap, .PlusPercent, "+%", used) else return transCreateCompoundAssign(rp, scope, stmt, .AssignAdd, .PlusEqual, "+=", .Add, .Plus, "+", used), - .SubAssign => if (qualTypeHasWrappingOverflow(ZigClangCompoundAssignOperator_getType(stmt))) + .SubAssign => if (qualTypeHasWrappingOverflow(stmt.getType())) return transCreateCompoundAssign(rp, scope, stmt, .AssignSubWrap, .MinusPercentEqual, "-%=", .SubWrap, .MinusPercent, "-%", used) else return transCreateCompoundAssign(rp, scope, stmt, .AssignSub, .MinusPercentEqual, "-=", .Sub, .Minus, "-", used), @@ -3446,9 +3438,9 @@ fn transCompoundAssignOperator(rp: RestorePoint, scope: *Scope, stmt: *const Zig else => return revertAndWarn( rp, error.UnsupportedTranslation, - ZigClangCompoundAssignOperator_getBeginLoc(stmt), + stmt.getBeginLoc(), "unsupported C translation {}", - .{ZigClangCompoundAssignOperator_getOpcode(stmt)}, + .{stmt.getOpcode()}, ), } } @@ -3456,7 +3448,7 @@ fn transCompoundAssignOperator(rp: RestorePoint, scope: *Scope, stmt: *const Zig fn transCreateCompoundAssign( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangCompoundAssignOperator, + stmt: *const clang.CompoundAssignOperator, assign_op: ast.Node.Tag, assign_tok_id: std.zig.Token.Id, assign_bytes: []const u8, @@ -3468,9 +3460,9 @@ fn transCreateCompoundAssign( const is_shift = bin_op == .BitShiftLeft or bin_op == .BitShiftRight; const is_div = bin_op == .Div; const is_mod = bin_op == .Mod; - const lhs = ZigClangCompoundAssignOperator_getLHS(stmt); - const rhs = ZigClangCompoundAssignOperator_getRHS(stmt); - const loc = ZigClangCompoundAssignOperator_getBeginLoc(stmt); + const lhs = stmt.getLHS(); + const rhs = stmt.getRHS(); + const loc = stmt.getBeginLoc(); const lhs_qt = getExprQualType(rp.c, lhs); const rhs_qt = getExprQualType(rp.c, rhs); const is_signed = cIsSignedInteger(lhs_qt); @@ -3615,20 +3607,20 @@ fn transCreateCompoundAssign( fn transCPtrCast( rp: RestorePoint, - loc: ZigClangSourceLocation, - dst_type: ZigClangQualType, - src_type: ZigClangQualType, + loc: clang.SourceLocation, + dst_type: clang.QualType, + src_type: clang.QualType, expr: *ast.Node, ) !*ast.Node { - const ty = ZigClangQualType_getTypePtr(dst_type); - const child_type = ZigClangType_getPointeeType(ty); - const src_ty = ZigClangQualType_getTypePtr(src_type); - const src_child_type = ZigClangType_getPointeeType(src_ty); + const ty = dst_type.getTypePtr(); + const child_type = ty.getPointeeType(); + const src_ty = src_type.getTypePtr(); + const src_child_type = src_ty.getPointeeType(); - if ((ZigClangQualType_isConstQualified(src_child_type) and - !ZigClangQualType_isConstQualified(child_type)) or - (ZigClangQualType_isVolatileQualified(src_child_type) and - !ZigClangQualType_isVolatileQualified(child_type))) + if ((src_child_type.isConstQualified() and + !child_type.isConstQualified()) or + (src_child_type.isVolatileQualified() and + !child_type.isVolatileQualified())) { // Casting away const or volatile requires us to use @intToPtr const inttoptr_node = try rp.c.createBuiltinCall("@intToPtr", 2); @@ -3651,7 +3643,7 @@ fn transCPtrCast( ptrcast_node.params()[0] = dst_type_node; _ = try appendToken(rp.c, .Comma, ","); - if (ZigClangType_isVoidType(qualTypeCanon(child_type))) { + if (qualTypeCanon(child_type).isVoidType()) { // void has 1-byte alignment, so @alignCast is not needed ptrcast_node.params()[1] = expr; } else if (typeIsOpaque(rp.c, qualTypeCanon(child_type), loc)) { @@ -3691,9 +3683,9 @@ fn transBreak(rp: RestorePoint, scope: *Scope) TransError!*ast.Node { return &br.base; } -fn transFloatingLiteral(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangFloatingLiteral, used: ResultUsed) TransError!*ast.Node { +fn transFloatingLiteral(rp: RestorePoint, scope: *Scope, stmt: *const clang.FloatingLiteral, used: ResultUsed) TransError!*ast.Node { // TODO use something more accurate - const dbl = ZigClangAPFloat_getValueAsApproximateDouble(stmt); + const dbl = stmt.getValueAsApproximateDouble(); const node = try rp.c.arena.create(ast.Node.OneToken); node.* = .{ .base = .{ .tag = .FloatLiteral }, @@ -3702,13 +3694,13 @@ fn transFloatingLiteral(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangFl return maybeSuppressResult(rp, scope, used, &node.base); } -fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangBinaryConditionalOperator, used: ResultUsed) TransError!*ast.Node { +fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const clang.BinaryConditionalOperator, used: ResultUsed) TransError!*ast.Node { // GNU extension of the ternary operator where the middle expression is // omitted, the conditition itself is returned if it evaluates to true - const casted_stmt = @ptrCast(*const ZigClangAbstractConditionalOperator, stmt); - const cond_expr = ZigClangAbstractConditionalOperator_getCond(casted_stmt); - const true_expr = ZigClangAbstractConditionalOperator_getTrueExpr(casted_stmt); - const false_expr = ZigClangAbstractConditionalOperator_getFalseExpr(casted_stmt); + const casted_stmt = @ptrCast(*const clang.AbstractConditionalOperator, stmt); + const cond_expr = casted_stmt.getCond(); + const true_expr = casted_stmt.getTrueExpr(); + const false_expr = casted_stmt.getFalseExpr(); // c: (cond_expr)?:(false_expr) // zig: (blk: { @@ -3748,8 +3740,8 @@ fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const defer cond_scope.deinit(); const tmp_var_node = try transCreateNodeIdentifier(rp.c, mangled_name); - const ty = ZigClangQualType_getTypePtr(getExprQualType(rp.c, cond_expr)); - const cond_node = try finishBoolExpr(rp, &cond_scope.base, ZigClangExpr_getBeginLoc(cond_expr), ty, tmp_var_node, used); + const ty = getExprQualType(rp.c, cond_expr).getTypePtr(); + const cond_node = try finishBoolExpr(rp, &cond_scope.base, cond_expr.getBeginLoc(), ty, tmp_var_node, used); if_node.condition = cond_node; _ = try appendToken(rp.c, .RParen, ")"); @@ -3772,7 +3764,7 @@ fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const return maybeSuppressResult(rp, scope, used, &grouped_expr.base); } -fn transConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangConditionalOperator, used: ResultUsed) TransError!*ast.Node { +fn transConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const clang.ConditionalOperator, used: ResultUsed) TransError!*ast.Node { const grouped = scope.id == .Condition; const lparen = if (grouped) try appendToken(rp.c, .LParen, "(") else undefined; const if_node = try transCreateNodeIf(rp.c); @@ -3784,10 +3776,10 @@ fn transConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigCla }; defer cond_scope.deinit(); - const casted_stmt = @ptrCast(*const ZigClangAbstractConditionalOperator, stmt); - const cond_expr = ZigClangAbstractConditionalOperator_getCond(casted_stmt); - const true_expr = ZigClangAbstractConditionalOperator_getTrueExpr(casted_stmt); - const false_expr = ZigClangAbstractConditionalOperator_getFalseExpr(casted_stmt); + const casted_stmt = @ptrCast(*const clang.AbstractConditionalOperator, stmt); + const cond_expr = casted_stmt.getCond(); + const true_expr = casted_stmt.getTrueExpr(); + const false_expr = casted_stmt.getFalseExpr(); if_node.condition = try transBoolExpr(rp, &cond_scope.base, cond_expr, .used, .r_value, false); _ = try appendToken(rp.c, .RParen, ")"); @@ -3845,22 +3837,22 @@ fn addTopLevelDecl(c: *Context, name: []const u8, decl_node: *ast.Node) !void { _ = try c.global_scope.sym_table.put(name, decl_node); } -fn transQualType(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigClangSourceLocation) TypeError!*ast.Node { - return transType(rp, ZigClangQualType_getTypePtr(qt), source_loc); +fn transQualType(rp: RestorePoint, qt: clang.QualType, source_loc: clang.SourceLocation) TypeError!*ast.Node { + return transType(rp, qt.getTypePtr(), source_loc); } /// Produces a Zig AST node by translating a Clang QualType, respecting the width, but modifying the signed-ness. /// Asserts the type is an integer. -fn transQualTypeIntWidthOf(c: *Context, ty: ZigClangQualType, is_signed: bool) TypeError!*ast.Node { +fn transQualTypeIntWidthOf(c: *Context, ty: clang.QualType, is_signed: bool) TypeError!*ast.Node { return transTypeIntWidthOf(c, qualTypeCanon(ty), is_signed); } /// Produces a Zig AST node by translating a Clang Type, respecting the width, but modifying the signed-ness. /// Asserts the type is an integer. -fn transTypeIntWidthOf(c: *Context, ty: *const ZigClangType, is_signed: bool) TypeError!*ast.Node { - assert(ZigClangType_getTypeClass(ty) == .Builtin); - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty); - return transCreateNodeIdentifier(c, switch (ZigClangBuiltinType_getKind(builtin_ty)) { +fn transTypeIntWidthOf(c: *Context, ty: *const clang.Type, is_signed: bool) TypeError!*ast.Node { + assert(ty.getTypeClass() == .Builtin); + const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); + return transCreateNodeIdentifier(c, switch (builtin_ty.getKind()) { .Char_U, .Char_S, .UChar, .SChar, .Char8 => if (is_signed) "i8" else "u8", .UShort, .Short => if (is_signed) "c_short" else "c_ushort", .UInt, .Int => if (is_signed) "c_int" else "c_uint", @@ -3873,30 +3865,30 @@ fn transTypeIntWidthOf(c: *Context, ty: *const ZigClangType, is_signed: bool) Ty }); } -fn isCBuiltinType(qt: ZigClangQualType, kind: ZigClangBuiltinTypeKind) bool { +fn isCBuiltinType(qt: clang.QualType, kind: clang.BuiltinTypeKind) bool { const c_type = qualTypeCanon(qt); - if (ZigClangType_getTypeClass(c_type) != .Builtin) + if (c_type.getTypeClass() != .Builtin) return false; - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type); - return ZigClangBuiltinType_getKind(builtin_ty) == kind; + const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type); + return builtin_ty.getKind() == kind; } -fn qualTypeIsPtr(qt: ZigClangQualType) bool { - return ZigClangType_getTypeClass(qualTypeCanon(qt)) == .Pointer; +fn qualTypeIsPtr(qt: clang.QualType) bool { + return qualTypeCanon(qt).getTypeClass() == .Pointer; } -fn qualTypeIsBoolean(qt: ZigClangQualType) bool { - return ZigClangType_isBooleanType(qualTypeCanon(qt)); +fn qualTypeIsBoolean(qt: clang.QualType) bool { + return qualTypeCanon(qt).isBooleanType(); } -fn qualTypeIntBitWidth(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigClangSourceLocation) !u32 { - const ty = ZigClangQualType_getTypePtr(qt); +fn qualTypeIntBitWidth(rp: RestorePoint, qt: clang.QualType, source_loc: clang.SourceLocation) !u32 { + const ty = qt.getTypePtr(); - switch (ZigClangType_getTypeClass(ty)) { + switch (ty.getTypeClass()) { .Builtin => { - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty); + const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); - switch (ZigClangBuiltinType_getKind(builtin_ty)) { + switch (builtin_ty.getKind()) { .Char_U, .UChar, .Char_S, @@ -3911,9 +3903,9 @@ fn qualTypeIntBitWidth(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigCl unreachable; }, .Typedef => { - const typedef_ty = @ptrCast(*const ZigClangTypedefType, ty); - const typedef_decl = ZigClangTypedefType_getDecl(typedef_ty); - const type_name = try rp.c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, typedef_decl))); + const typedef_ty = @ptrCast(*const clang.TypedefType, ty); + const typedef_decl = typedef_ty.getDecl(); + const type_name = try rp.c.str(@ptrCast(*const clang.NamedDecl, typedef_decl).getName_bytes_begin()); if (mem.eql(u8, type_name, "uint8_t") or mem.eql(u8, type_name, "int8_t")) { return 8; @@ -3933,7 +3925,7 @@ fn qualTypeIntBitWidth(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigCl unreachable; } -fn qualTypeToLog2IntRef(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigClangSourceLocation) !*ast.Node { +fn qualTypeToLog2IntRef(rp: RestorePoint, qt: clang.QualType, source_loc: clang.SourceLocation) !*ast.Node { const int_bit_width = try qualTypeIntBitWidth(rp, qt, source_loc); if (int_bit_width != 0) { @@ -3980,83 +3972,83 @@ fn qualTypeToLog2IntRef(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigC return &log2int_fn_call.base; } -fn qualTypeChildIsFnProto(qt: ZigClangQualType) bool { +fn qualTypeChildIsFnProto(qt: clang.QualType) bool { const ty = qualTypeCanon(qt); - switch (ZigClangType_getTypeClass(ty)) { + switch (ty.getTypeClass()) { .FunctionProto, .FunctionNoProto => return true, else => return false, } } -fn qualTypeCanon(qt: ZigClangQualType) *const ZigClangType { - const canon = ZigClangQualType_getCanonicalType(qt); - return ZigClangQualType_getTypePtr(canon); +fn qualTypeCanon(qt: clang.QualType) *const clang.Type { + const canon = qt.getCanonicalType(); + return canon.getTypePtr(); } -fn getExprQualType(c: *Context, expr: *const ZigClangExpr) ZigClangQualType { +fn getExprQualType(c: *Context, expr: *const clang.Expr) clang.QualType { blk: { // If this is a C `char *`, turn it into a `const char *` - if (ZigClangExpr_getStmtClass(expr) != .ImplicitCastExprClass) break :blk; - const cast_expr = @ptrCast(*const ZigClangImplicitCastExpr, expr); - if (ZigClangImplicitCastExpr_getCastKind(cast_expr) != .ArrayToPointerDecay) break :blk; - const sub_expr = ZigClangImplicitCastExpr_getSubExpr(cast_expr); - if (ZigClangExpr_getStmtClass(sub_expr) != .StringLiteralClass) break :blk; - const array_qt = ZigClangExpr_getType(sub_expr); - const array_type = @ptrCast(*const ZigClangArrayType, ZigClangQualType_getTypePtr(array_qt)); - var pointee_qt = ZigClangArrayType_getElementType(array_type); - ZigClangQualType_addConst(&pointee_qt); - return ZigClangASTContext_getPointerType(c.clang_context, pointee_qt); + if (expr.getStmtClass() != .ImplicitCastExprClass) break :blk; + const cast_expr = @ptrCast(*const clang.ImplicitCastExpr, expr); + if (cast_expr.getCastKind() != .ArrayToPointerDecay) break :blk; + const sub_expr = cast_expr.getSubExpr(); + if (sub_expr.getStmtClass() != .StringLiteralClass) break :blk; + const array_qt = sub_expr.getType(); + const array_type = @ptrCast(*const clang.ArrayType, array_qt.getTypePtr()); + var pointee_qt = array_type.getElementType(); + pointee_qt.addConst(); + return c.clang_context.getPointerType(pointee_qt); } - return ZigClangExpr_getType(expr); + return expr.getType(); } -fn typeIsOpaque(c: *Context, ty: *const ZigClangType, loc: ZigClangSourceLocation) bool { - switch (ZigClangType_getTypeClass(ty)) { +fn typeIsOpaque(c: *Context, ty: *const clang.Type, loc: clang.SourceLocation) bool { + switch (ty.getTypeClass()) { .Builtin => { - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty); - return ZigClangBuiltinType_getKind(builtin_ty) == .Void; + const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); + return builtin_ty.getKind() == .Void; }, .Record => { - const record_ty = @ptrCast(*const ZigClangRecordType, ty); - const record_decl = ZigClangRecordType_getDecl(record_ty); - const record_def = ZigClangRecordDecl_getDefinition(record_decl) orelse + const record_ty = @ptrCast(*const clang.RecordType, ty); + const record_decl = record_ty.getDecl(); + const record_def = record_decl.getDefinition() orelse return true; - var it = ZigClangRecordDecl_field_begin(record_def); - const end_it = ZigClangRecordDecl_field_end(record_def); - while (ZigClangRecordDecl_field_iterator_neq(it, end_it)) : (it = ZigClangRecordDecl_field_iterator_next(it)) { - const field_decl = ZigClangRecordDecl_field_iterator_deref(it); + var it = record_def.field_begin(); + const end_it = record_def.field_end(); + while (it.neq(end_it)) : (it = it.next()) { + const field_decl = it.deref(); - if (ZigClangFieldDecl_isBitField(field_decl)) { + if (field_decl.isBitField()) { return true; } } return false; }, .Elaborated => { - const elaborated_ty = @ptrCast(*const ZigClangElaboratedType, ty); - const qt = ZigClangElaboratedType_getNamedType(elaborated_ty); - return typeIsOpaque(c, ZigClangQualType_getTypePtr(qt), loc); + const elaborated_ty = @ptrCast(*const clang.ElaboratedType, ty); + const qt = elaborated_ty.getNamedType(); + return typeIsOpaque(c, qt.getTypePtr(), loc); }, .Typedef => { - const typedef_ty = @ptrCast(*const ZigClangTypedefType, ty); - const typedef_decl = ZigClangTypedefType_getDecl(typedef_ty); - const underlying_type = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl); - return typeIsOpaque(c, ZigClangQualType_getTypePtr(underlying_type), loc); + const typedef_ty = @ptrCast(*const clang.TypedefType, ty); + const typedef_decl = typedef_ty.getDecl(); + const underlying_type = typedef_decl.getUnderlyingType(); + return typeIsOpaque(c, underlying_type.getTypePtr(), loc); }, else => return false, } } -fn cIsInteger(qt: ZigClangQualType) bool { +fn cIsInteger(qt: clang.QualType) bool { return cIsSignedInteger(qt) or cIsUnsignedInteger(qt); } -fn cIsUnsignedInteger(qt: ZigClangQualType) bool { +fn cIsUnsignedInteger(qt: clang.QualType) bool { const c_type = qualTypeCanon(qt); - if (ZigClangType_getTypeClass(c_type) != .Builtin) return false; - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type); - return switch (ZigClangBuiltinType_getKind(builtin_ty)) { + if (c_type.getTypeClass() != .Builtin) return false; + const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type); + return switch (builtin_ty.getKind()) { .Char_U, .UChar, .Char_S, @@ -4071,11 +4063,11 @@ fn cIsUnsignedInteger(qt: ZigClangQualType) bool { }; } -fn cIntTypeToIndex(qt: ZigClangQualType) u8 { +fn cIntTypeToIndex(qt: clang.QualType) u8 { const c_type = qualTypeCanon(qt); - assert(ZigClangType_getTypeClass(c_type) == .Builtin); - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type); - return switch (ZigClangBuiltinType_getKind(builtin_ty)) { + assert(c_type.getTypeClass() == .Builtin); + const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type); + return switch (builtin_ty.getKind()) { .Bool, .Char_U, .Char_S, .UChar, .SChar, .Char8 => 1, .WChar_U, .WChar_S => 2, .UShort, .Short, .Char16 => 3, @@ -4087,17 +4079,17 @@ fn cIntTypeToIndex(qt: ZigClangQualType) u8 { }; } -fn cIntTypeCmp(a: ZigClangQualType, b: ZigClangQualType) math.Order { +fn cIntTypeCmp(a: clang.QualType, b: clang.QualType) math.Order { const a_index = cIntTypeToIndex(a); const b_index = cIntTypeToIndex(b); return math.order(a_index, b_index); } -fn cIsSignedInteger(qt: ZigClangQualType) bool { +fn cIsSignedInteger(qt: clang.QualType) bool { const c_type = qualTypeCanon(qt); - if (ZigClangType_getTypeClass(c_type) != .Builtin) return false; - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type); - return switch (ZigClangBuiltinType_getKind(builtin_ty)) { + if (c_type.getTypeClass() != .Builtin) return false; + const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type); + return switch (builtin_ty.getKind()) { .SChar, .Short, .Int, @@ -4110,11 +4102,11 @@ fn cIsSignedInteger(qt: ZigClangQualType) bool { }; } -fn cIsFloating(qt: ZigClangQualType) bool { +fn cIsFloating(qt: clang.QualType) bool { const c_type = qualTypeCanon(qt); - if (ZigClangType_getTypeClass(c_type) != .Builtin) return false; - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type); - return switch (ZigClangBuiltinType_getKind(builtin_ty)) { + if (c_type.getTypeClass() != .Builtin) return false; + const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type); + return switch (builtin_ty.getKind()) { .Float, .Double, .Float128, @@ -4124,11 +4116,11 @@ fn cIsFloating(qt: ZigClangQualType) bool { }; } -fn cIsLongLongInteger(qt: ZigClangQualType) bool { +fn cIsLongLongInteger(qt: clang.QualType) bool { const c_type = qualTypeCanon(qt); - if (ZigClangType_getTypeClass(c_type) != .Builtin) return false; - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type); - return switch (ZigClangBuiltinType_getKind(builtin_ty)) { + if (c_type.getTypeClass() != .Builtin) return false; + const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type); + return switch (builtin_ty.getKind()) { .LongLong, .ULongLong, .Int128, .UInt128 => true, else => false, }; @@ -4137,8 +4129,8 @@ fn transCreateNodeAssign( rp: RestorePoint, scope: *Scope, result_used: ResultUsed, - lhs: *const ZigClangExpr, - rhs: *const ZigClangExpr, + lhs: *const clang.Expr, + rhs: *const clang.Expr, ) !*ast.Node { // common case // c: lhs = rhs @@ -4273,19 +4265,19 @@ fn transCreateNodeInfixOp( fn transCreateNodeBoolInfixOp( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangBinaryOperator, + stmt: *const clang.BinaryOperator, op: ast.Node.Tag, used: ResultUsed, grouped: bool, ) !*ast.Node { std.debug.assert(op == .BoolAnd or op == .BoolOr); - const lhs_hode = try transBoolExpr(rp, scope, ZigClangBinaryOperator_getLHS(stmt), .used, .l_value, true); + const lhs_hode = try transBoolExpr(rp, scope, stmt.getLHS(), .used, .l_value, true); const op_token = if (op == .BoolAnd) try appendToken(rp.c, .Keyword_and, "and") else try appendToken(rp.c, .Keyword_or, "or"); - const rhs = try transBoolExpr(rp, scope, ZigClangBinaryOperator_getRHS(stmt), .used, .r_value, true); + const rhs = try transBoolExpr(rp, scope, stmt.getRHS(), .used, .r_value, true); return transCreateNodeInfixOp( rp, @@ -4334,21 +4326,21 @@ fn transCreateNodePtrType( return node; } -fn transCreateNodeAPInt(c: *Context, int: *const ZigClangAPSInt) !*ast.Node { - const num_limbs = math.cast(usize, ZigClangAPSInt_getNumWords(int)) catch |err| switch (err) { +fn transCreateNodeAPInt(c: *Context, int: *const clang.APSInt) !*ast.Node { + const num_limbs = math.cast(usize, int.getNumWords()) catch |err| switch (err) { error.Overflow => return error.OutOfMemory, }; var aps_int = int; - const is_negative = ZigClangAPSInt_isSigned(int) and ZigClangAPSInt_isNegative(int); - if (is_negative) aps_int = ZigClangAPSInt_negate(aps_int); + const is_negative = int.isSigned() and int.isNegative(); + if (is_negative) aps_int = aps_int.negate(); defer if (is_negative) { - ZigClangAPSInt_free(aps_int); + aps_int.free(); }; const limbs = try c.arena.alloc(math.big.Limb, num_limbs); defer c.arena.free(limbs); - const data = ZigClangAPSInt_getRawData(aps_int); + const data = aps_int.getRawData(); switch (@sizeOf(math.big.Limb)) { 8 => { var i: usize = 0; @@ -4697,23 +4689,23 @@ fn transCreateNodeSwitchElse(c: *Context) !*ast.Node { fn transCreateNodeShiftOp( rp: RestorePoint, scope: *Scope, - stmt: *const ZigClangBinaryOperator, + stmt: *const clang.BinaryOperator, op: ast.Node.Tag, op_tok_id: std.zig.Token.Id, bytes: []const u8, ) !*ast.Node { std.debug.assert(op == .BitShiftLeft or op == .BitShiftRight); - const lhs_expr = ZigClangBinaryOperator_getLHS(stmt); - const rhs_expr = ZigClangBinaryOperator_getRHS(stmt); - const rhs_location = ZigClangExpr_getBeginLoc(rhs_expr); + const lhs_expr = stmt.getLHS(); + const rhs_expr = stmt.getRHS(); + const rhs_location = rhs_expr.getBeginLoc(); // lhs >> @as(u5, rh) const lhs = try transExpr(rp, scope, lhs_expr, .used, .l_value); const op_token = try appendToken(rp.c, op_tok_id, bytes); const cast_node = try rp.c.createBuiltinCall("@intCast", 2); - const rhs_type = try qualTypeToLog2IntRef(rp, ZigClangBinaryOperator_getType(stmt), rhs_location); + const rhs_type = try qualTypeToLog2IntRef(rp, stmt.getType(), rhs_location); cast_node.params()[0] = rhs_type; _ = try appendToken(rp.c, .Comma, ","); const rhs = try transExprCoercing(rp, scope, rhs_expr, .used, .r_value); @@ -4772,11 +4764,11 @@ fn makeRestorePoint(c: *Context) RestorePoint { }; } -fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSourceLocation) TypeError!*ast.Node { - switch (ZigClangType_getTypeClass(ty)) { +fn transType(rp: RestorePoint, ty: *const clang.Type, source_loc: clang.SourceLocation) TypeError!*ast.Node { + switch (ty.getTypeClass()) { .Builtin => { - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty); - return transCreateNodeIdentifier(rp.c, switch (ZigClangBuiltinType_getKind(builtin_ty)) { + const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); + return transCreateNodeIdentifier(rp.c, switch (builtin_ty.getKind()) { .Void => "c_void", .Bool => "bool", .Char_U, .UChar, .Char_S, .Char8 => "u8", @@ -4800,32 +4792,32 @@ fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSour }); }, .FunctionProto => { - const fn_proto_ty = @ptrCast(*const ZigClangFunctionProtoType, ty); + const fn_proto_ty = @ptrCast(*const clang.FunctionProtoType, ty); const fn_proto = try transFnProto(rp, null, fn_proto_ty, source_loc, null, false); return &fn_proto.base; }, .FunctionNoProto => { - const fn_no_proto_ty = @ptrCast(*const ZigClangFunctionType, ty); + const fn_no_proto_ty = @ptrCast(*const clang.FunctionType, ty); const fn_proto = try transFnNoProto(rp, fn_no_proto_ty, source_loc, null, false); return &fn_proto.base; }, .Paren => { - const paren_ty = @ptrCast(*const ZigClangParenType, ty); - return transQualType(rp, ZigClangParenType_getInnerType(paren_ty), source_loc); + const paren_ty = @ptrCast(*const clang.ParenType, ty); + return transQualType(rp, paren_ty.getInnerType(), source_loc); }, .Pointer => { - const child_qt = ZigClangType_getPointeeType(ty); + const child_qt = ty.getPointeeType(); if (qualTypeChildIsFnProto(child_qt)) { const optional_node = try transCreateNodeSimplePrefixOp(rp.c, .OptionalType, .QuestionMark, "?"); optional_node.rhs = try transQualType(rp, child_qt, source_loc); return &optional_node.base; } - if (typeIsOpaque(rp.c, ZigClangQualType_getTypePtr(child_qt), source_loc)) { + if (typeIsOpaque(rp.c, child_qt.getTypePtr(), source_loc)) { const optional_node = try transCreateNodeSimplePrefixOp(rp.c, .OptionalType, .QuestionMark, "?"); const pointer_node = try transCreateNodePtrType( rp.c, - ZigClangQualType_isConstQualified(child_qt), - ZigClangQualType_isVolatileQualified(child_qt), + child_qt.isConstQualified(), + child_qt.isVolatileQualified(), .Asterisk, ); optional_node.rhs = &pointer_node.base; @@ -4834,83 +4826,83 @@ fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSour } const pointer_node = try transCreateNodePtrType( rp.c, - ZigClangQualType_isConstQualified(child_qt), - ZigClangQualType_isVolatileQualified(child_qt), + child_qt.isConstQualified(), + child_qt.isVolatileQualified(), .Identifier, ); pointer_node.rhs = try transQualType(rp, child_qt, source_loc); return &pointer_node.base; }, .ConstantArray => { - const const_arr_ty = @ptrCast(*const ZigClangConstantArrayType, ty); + const const_arr_ty = @ptrCast(*const clang.ConstantArrayType, ty); - const size_ap_int = ZigClangConstantArrayType_getSize(const_arr_ty); - const size = ZigClangAPInt_getLimitedValue(size_ap_int, math.maxInt(usize)); - const elem_ty = ZigClangQualType_getTypePtr(ZigClangConstantArrayType_getElementType(const_arr_ty)); + const size_ap_int = const_arr_ty.getSize(); + const size = size_ap_int.getLimitedValue(math.maxInt(usize)); + const elem_ty = const_arr_ty.getElementType().getTypePtr(); return try transCreateNodeArrayType(rp, source_loc, elem_ty, size); }, .IncompleteArray => { - const incomplete_array_ty = @ptrCast(*const ZigClangIncompleteArrayType, ty); + const incomplete_array_ty = @ptrCast(*const clang.IncompleteArrayType, ty); - const child_qt = ZigClangIncompleteArrayType_getElementType(incomplete_array_ty); + const child_qt = incomplete_array_ty.getElementType(); var node = try transCreateNodePtrType( rp.c, - ZigClangQualType_isConstQualified(child_qt), - ZigClangQualType_isVolatileQualified(child_qt), + child_qt.isConstQualified(), + child_qt.isVolatileQualified(), .Identifier, ); node.rhs = try transQualType(rp, child_qt, source_loc); return &node.base; }, .Typedef => { - const typedef_ty = @ptrCast(*const ZigClangTypedefType, ty); + const typedef_ty = @ptrCast(*const clang.TypedefType, ty); - const typedef_decl = ZigClangTypedefType_getDecl(typedef_ty); + const typedef_decl = typedef_ty.getDecl(); return (try transTypeDef(rp.c, typedef_decl, false)) orelse revertAndWarn(rp, error.UnsupportedType, source_loc, "unable to translate typedef declaration", .{}); }, .Record => { - const record_ty = @ptrCast(*const ZigClangRecordType, ty); + const record_ty = @ptrCast(*const clang.RecordType, ty); - const record_decl = ZigClangRecordType_getDecl(record_ty); + const record_decl = record_ty.getDecl(); return (try transRecordDecl(rp.c, record_decl)) orelse revertAndWarn(rp, error.UnsupportedType, source_loc, "unable to resolve record declaration", .{}); }, .Enum => { - const enum_ty = @ptrCast(*const ZigClangEnumType, ty); + const enum_ty = @ptrCast(*const clang.EnumType, ty); - const enum_decl = ZigClangEnumType_getDecl(enum_ty); + const enum_decl = enum_ty.getDecl(); return (try transEnumDecl(rp.c, enum_decl)) orelse revertAndWarn(rp, error.UnsupportedType, source_loc, "unable to translate enum declaration", .{}); }, .Elaborated => { - const elaborated_ty = @ptrCast(*const ZigClangElaboratedType, ty); - return transQualType(rp, ZigClangElaboratedType_getNamedType(elaborated_ty), source_loc); + const elaborated_ty = @ptrCast(*const clang.ElaboratedType, ty); + return transQualType(rp, elaborated_ty.getNamedType(), source_loc); }, .Decayed => { - const decayed_ty = @ptrCast(*const ZigClangDecayedType, ty); - return transQualType(rp, ZigClangDecayedType_getDecayedType(decayed_ty), source_loc); + const decayed_ty = @ptrCast(*const clang.DecayedType, ty); + return transQualType(rp, decayed_ty.getDecayedType(), source_loc); }, .Attributed => { - const attributed_ty = @ptrCast(*const ZigClangAttributedType, ty); - return transQualType(rp, ZigClangAttributedType_getEquivalentType(attributed_ty), source_loc); + const attributed_ty = @ptrCast(*const clang.AttributedType, ty); + return transQualType(rp, attributed_ty.getEquivalentType(), source_loc); }, .MacroQualified => { - const macroqualified_ty = @ptrCast(*const ZigClangMacroQualifiedType, ty); - return transQualType(rp, ZigClangMacroQualifiedType_getModifiedType(macroqualified_ty), source_loc); + const macroqualified_ty = @ptrCast(*const clang.MacroQualifiedType, ty); + return transQualType(rp, macroqualified_ty.getModifiedType(), source_loc); }, else => { - const type_name = rp.c.str(ZigClangType_getTypeClassName(ty)); + const type_name = rp.c.str(ty.getTypeClassName()); return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported type: '{}'", .{type_name}); }, } } -fn isCVoid(qt: ZigClangQualType) bool { - const ty = ZigClangQualType_getTypePtr(qt); - if (ZigClangType_getTypeClass(ty) == .Builtin) { - const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty); - return ZigClangBuiltinType_getKind(builtin_ty) == .Void; +fn isCVoid(qt: clang.QualType) bool { + const ty = qt.getTypePtr(); + if (ty.getTypeClass() == .Builtin) { + const builtin_ty = @ptrCast(*const clang.BuiltinType, ty); + return builtin_ty.getKind() == .Void; } return false; } @@ -4918,16 +4910,16 @@ fn isCVoid(qt: ZigClangQualType) bool { const FnDeclContext = struct { fn_name: []const u8, has_body: bool, - storage_class: ZigClangStorageClass, + storage_class: clang.StorageClass, is_export: bool, }; fn transCC( rp: RestorePoint, - fn_ty: *const ZigClangFunctionType, - source_loc: ZigClangSourceLocation, + fn_ty: *const clang.FunctionType, + source_loc: clang.SourceLocation, ) !CallingConvention { - const clang_cc = ZigClangFunctionType_getCallConv(fn_ty); + const clang_cc = fn_ty.getCallConv(); switch (clang_cc) { .C => return CallingConvention.C, .X86StdCall => return CallingConvention.Stdcall, @@ -4948,22 +4940,22 @@ fn transCC( fn transFnProto( rp: RestorePoint, - fn_decl: ?*const ZigClangFunctionDecl, - fn_proto_ty: *const ZigClangFunctionProtoType, - source_loc: ZigClangSourceLocation, + fn_decl: ?*const clang.FunctionDecl, + fn_proto_ty: *const clang.FunctionProtoType, + source_loc: clang.SourceLocation, fn_decl_context: ?FnDeclContext, is_pub: bool, ) !*ast.Node.FnProto { - const fn_ty = @ptrCast(*const ZigClangFunctionType, fn_proto_ty); + const fn_ty = @ptrCast(*const clang.FunctionType, fn_proto_ty); const cc = try transCC(rp, fn_ty, source_loc); - const is_var_args = ZigClangFunctionProtoType_isVariadic(fn_proto_ty); + const is_var_args = fn_proto_ty.isVariadic(); return finishTransFnProto(rp, fn_decl, fn_proto_ty, fn_ty, source_loc, fn_decl_context, is_var_args, cc, is_pub); } fn transFnNoProto( rp: RestorePoint, - fn_ty: *const ZigClangFunctionType, - source_loc: ZigClangSourceLocation, + fn_ty: *const clang.FunctionType, + source_loc: clang.SourceLocation, fn_decl_context: ?FnDeclContext, is_pub: bool, ) !*ast.Node.FnProto { @@ -4974,10 +4966,10 @@ fn transFnNoProto( fn finishTransFnProto( rp: RestorePoint, - fn_decl: ?*const ZigClangFunctionDecl, - fn_proto_ty: ?*const ZigClangFunctionProtoType, - fn_ty: *const ZigClangFunctionType, - source_loc: ZigClangSourceLocation, + fn_decl: ?*const clang.FunctionDecl, + fn_proto_ty: ?*const clang.FunctionProtoType, + fn_ty: *const clang.FunctionType, + source_loc: clang.SourceLocation, fn_decl_context: ?FnDeclContext, is_var_args: bool, cc: CallingConvention, @@ -5003,19 +4995,19 @@ fn finishTransFnProto( var fn_params = std.ArrayList(ast.Node.FnProto.ParamDecl).init(rp.c.gpa); defer fn_params.deinit(); - const param_count: usize = if (fn_proto_ty != null) ZigClangFunctionProtoType_getNumParams(fn_proto_ty.?) else 0; + const param_count: usize = if (fn_proto_ty != null) fn_proto_ty.?.getNumParams() else 0; try fn_params.ensureCapacity(param_count + 1); // +1 for possible var args node var i: usize = 0; while (i < param_count) : (i += 1) { - const param_qt = ZigClangFunctionProtoType_getParamType(fn_proto_ty.?, @intCast(c_uint, i)); + const param_qt = fn_proto_ty.?.getParamType(@intCast(c_uint, i)); - const noalias_tok = if (ZigClangQualType_isRestrictQualified(param_qt)) try appendToken(rp.c, .Keyword_noalias, "noalias") else null; + const noalias_tok = if (param_qt.isRestrictQualified()) try appendToken(rp.c, .Keyword_noalias, "noalias") else null; const param_name_tok: ?ast.TokenIndex = blk: { if (fn_decl) |decl| { - const param = ZigClangFunctionDecl_getParamDecl(decl, @intCast(c_uint, i)); - const param_name: []const u8 = try rp.c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, param))); + const param = decl.getParamDecl(@intCast(c_uint, i)); + const param_name: []const u8 = try rp.c.str(@ptrCast(*const clang.NamedDecl, param).getName_bytes_begin()); if (param_name.len < 1) break :blk null; @@ -5053,7 +5045,7 @@ fn finishTransFnProto( const linksection_expr = blk: { if (fn_decl) |decl| { var str_len: usize = undefined; - if (ZigClangFunctionDecl_getSectionAttribute(decl, &str_len)) |str_ptr| { + if (decl.getSectionAttribute(&str_len)) |str_ptr| { _ = try appendToken(rp.c, .Keyword_linksection, "linksection"); _ = try appendToken(rp.c, .LParen, "("); const expr = try transCreateNodeStringLiteral( @@ -5070,7 +5062,7 @@ fn finishTransFnProto( const align_expr = blk: { if (fn_decl) |decl| { - const alignment = ZigClangFunctionDecl_getAlignedAttribute(decl, rp.c.clang_context); + const alignment = decl.getAlignedAttribute(rp.c.clang_context); if (alignment != 0) { _ = try appendToken(rp.c, .Keyword_align, "align"); _ = try appendToken(rp.c, .LParen, "("); @@ -5093,10 +5085,10 @@ fn finishTransFnProto( }; const return_type_node = blk: { - if (ZigClangFunctionType_getNoReturnAttr(fn_ty)) { + if (fn_ty.getNoReturnAttr()) { break :blk try transCreateNodeIdentifier(rp.c, "noreturn"); } else { - const return_qt = ZigClangFunctionType_getReturnType(fn_ty); + const return_qt = fn_ty.getReturnType(); if (isCVoid(return_qt)) { // convert primitive c_void to actual void (only for return type) break :blk try transCreateNodeIdentifier(rp.c, "void"); @@ -5144,7 +5136,7 @@ fn finishTransFnProto( fn revertAndWarn( rp: RestorePoint, err: anytype, - source_loc: ZigClangSourceLocation, + source_loc: clang.SourceLocation, comptime format: []const u8, args: anytype, ) (@TypeOf(err) || error{OutOfMemory}) { @@ -5153,12 +5145,12 @@ fn revertAndWarn( return err; } -fn emitWarning(c: *Context, loc: ZigClangSourceLocation, comptime format: []const u8, args: anytype) !void { +fn emitWarning(c: *Context, loc: clang.SourceLocation, comptime format: []const u8, args: anytype) !void { const args_prefix = .{c.locStr(loc)}; _ = try appendTokenFmt(c, .LineComment, "// {}: warning: " ++ format, args_prefix ++ args); } -pub fn failDecl(c: *Context, loc: ZigClangSourceLocation, name: []const u8, comptime format: []const u8, args: anytype) !void { +pub fn failDecl(c: *Context, loc: clang.SourceLocation, name: []const u8, comptime format: []const u8, args: anytype) !void { // pub const name = @compileError(msg); const pub_tok = try appendToken(c, .Keyword_pub, "pub"); const const_tok = try appendToken(c, .Keyword_const, "const"); @@ -5295,14 +5287,14 @@ fn transCreateNodeIdentifierUnchecked(c: *Context, name: []const u8) !*ast.Node } pub fn freeErrors(errors: []ClangErrMsg) void { - ZigClangErrorMsg_delete(errors.ptr, errors.len); + errors.ptr.delete(errors.len); } const MacroCtx = struct { source: []const u8, list: []const CToken, i: usize = 0, - loc: ZigClangSourceLocation, + loc: clang.SourceLocation, name: []const u8, fn peek(self: *MacroCtx) ?CToken.Id { @@ -5326,22 +5318,22 @@ const MacroCtx = struct { } }; -fn transPreprocessorEntities(c: *Context, unit: *ZigClangASTUnit) Error!void { +fn transPreprocessorEntities(c: *Context, unit: *clang.ASTUnit) Error!void { // TODO if we see #undef, delete it from the table - var it = ZigClangASTUnit_getLocalPreprocessingEntities_begin(unit); - const it_end = ZigClangASTUnit_getLocalPreprocessingEntities_end(unit); + var it = unit.getLocalPreprocessingEntities_begin(); + const it_end = unit.getLocalPreprocessingEntities_end(); var tok_list = std.ArrayList(CToken).init(c.gpa); defer tok_list.deinit(); const scope = c.global_scope; while (it.I != it_end.I) : (it.I += 1) { - const entity = ZigClangPreprocessingRecord_iterator_deref(it); + const entity = it.deref(); tok_list.items.len = 0; - switch (ZigClangPreprocessedEntity_getKind(entity)) { + switch (entity.getKind()) { .MacroDefinitionKind => { - const macro = @ptrCast(*ZigClangMacroDefinitionRecord, entity); - const raw_name = ZigClangMacroDefinitionRecord_getName_getNameStart(macro); - const begin_loc = ZigClangMacroDefinitionRecord_getSourceRange_getBegin(macro); + const macro = @ptrCast(*clang.MacroDefinitionRecord, entity); + const raw_name = macro.getName_getNameStart(); + const begin_loc = macro.getSourceRange_getBegin(); const name = try c.str(raw_name); // TODO https://github.com/ziglang/zig/issues/3756 @@ -5351,7 +5343,7 @@ fn transPreprocessorEntities(c: *Context, unit: *ZigClangASTUnit) Error!void { continue; } - const begin_c = ZigClangSourceManager_getCharacterData(c.source_manager, begin_loc); + const begin_c = c.source_manager.getCharacterData(begin_loc); const slice = begin_c[0..mem.len(begin_c)]; var tokenizer = std.c.Tokenizer{ diff --git a/src/zig_clang.h b/src/zig_clang.h index f9ce9c34ed..76d6dfadc3 100644 --- a/src/zig_clang.h +++ b/src/zig_clang.h @@ -68,16 +68,17 @@ struct ZigClangExprEvalResult { ZigClangAPValue Val; }; +struct ZigClangAbstractConditionalOperator; struct ZigClangAPFloat; struct ZigClangAPInt; struct ZigClangAPSInt; -struct ZigClangAPValue; struct ZigClangASTContext; struct ZigClangASTUnit; struct ZigClangArraySubscriptExpr; struct ZigClangArrayType; struct ZigClangAttributedType; struct ZigClangBinaryOperator; +struct ZigClangBinaryConditionalOperator; struct ZigClangBreakStmt; struct ZigClangBuiltinType; struct ZigClangCStyleCastExpr;