From dff201540f91bb41b44d7f73a11f4082f928cff7 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 11 Apr 2019 03:57:53 -0400 Subject: translate-c: move some code to the C API See #1964 --- src/zig_clang.cpp | 45 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) (limited to 'src/zig_clang.cpp') diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp index 230c3c3116..7c0c787e43 100644 --- a/src/zig_clang.cpp +++ b/src/zig_clang.cpp @@ -212,3 +212,48 @@ bool ZigClangASTUnit_visitLocalTopLevelDecls(ZigClangASTUnit *self, void *contex return reinterpret_cast(self)->visitLocalTopLevelDecls(context, reinterpret_cast(Fn)); } + +const ZigClangRecordDecl *ZigClangRecordType_getDecl(const ZigClangRecordType *record_ty) { + const clang::RecordDecl *record_decl = reinterpret_cast(record_ty)->getDecl(); + return reinterpret_cast(record_decl); +} + +const ZigClangTagDecl *ZigClangRecordDecl_getCanonicalDecl(const ZigClangRecordDecl *record_decl) { + const clang::TagDecl *tag_decl = reinterpret_cast(record_decl)->getCanonicalDecl(); + return reinterpret_cast(tag_decl); +} + +const ZigClangRecordDecl *ZigClangRecordDecl_getDefinition(const ZigClangRecordDecl *zig_record_decl) { + const clang::RecordDecl *record_decl = reinterpret_cast(zig_record_decl); + const clang::RecordDecl *definition = record_decl->getDefinition(); + return reinterpret_cast(definition); +} + +bool ZigClangRecordDecl_isUnion(const ZigClangRecordDecl *record_decl) { + return reinterpret_cast(record_decl)->isUnion(); +} + +bool ZigClangRecordDecl_isStruct(const ZigClangRecordDecl *record_decl) { + return reinterpret_cast(record_decl)->isStruct(); +} + +bool ZigClangRecordDecl_isAnonymousStructOrUnion(const ZigClangRecordDecl *record_decl) { + return reinterpret_cast(record_decl)->isAnonymousStructOrUnion(); +} + +const char *ZigClangDecl_getName_bytes_begin(const ZigClangDecl *zig_decl) { + const clang::Decl *decl = reinterpret_cast(zig_decl); + const clang::NamedDecl *named_decl = static_cast(decl); + return (const char *)named_decl->getName().bytes_begin(); +} + +ZigClangSourceLocation ZigClangRecordDecl_getLocation(const ZigClangRecordDecl *zig_record_decl) { + const clang::RecordDecl *record_decl = reinterpret_cast(zig_record_decl); + return bitcast(record_decl->getLocation()); +} + +bool ZigClangSourceLocation_eq(ZigClangSourceLocation zig_a, ZigClangSourceLocation zig_b) { + clang::SourceLocation a = bitcast(zig_a); + clang::SourceLocation b = bitcast(zig_b); + return a == b; +} -- cgit v1.2.3 From b960f1d92275057e8db1fc2cfee77abebf9e4c3e Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 11 Apr 2019 15:33:05 -0400 Subject: translate-c: move some code to the C API See #1964 --- src/translate_c.cpp | 46 ++++++++++++++++++++++++---------------------- src/zig_clang.cpp | 25 +++++++++++++++++++++++++ src/zig_clang.h | 13 +++++++++++-- 3 files changed, 60 insertions(+), 24 deletions(-) (limited to 'src/zig_clang.cpp') diff --git a/src/translate_c.cpp b/src/translate_c.cpp index 5307e3030d..0e4d21475b 100644 --- a/src/translate_c.cpp +++ b/src/translate_c.cpp @@ -113,7 +113,7 @@ static TransScopeSwitch *trans_scope_switch_create(Context *c, TransScope *paren static TransScopeBlock *trans_scope_block_find(TransScope *scope); static AstNode *resolve_record_decl(Context *c, const ZigClangRecordDecl *record_decl); -static AstNode *resolve_enum_decl(Context *c, const clang::EnumDecl *enum_decl); +static AstNode *resolve_enum_decl(Context *c, const ZigClangEnumDecl *enum_decl); static AstNode *resolve_typedef_decl(Context *c, const clang::TypedefNameDecl *typedef_decl); static int trans_stmt_extra(Context *c, TransScope *scope, const clang::Stmt *stmt, @@ -1128,8 +1128,8 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, ZigClangSourceLoca } case clang::Type::Enum: { - const clang::EnumType *enum_ty = static_cast(ty); - return resolve_enum_decl(c, enum_ty->getDecl()); + const ZigClangEnumType *enum_ty = reinterpret_cast(ty); + return resolve_enum_decl(c, ZigClangEnumType_getDecl(enum_ty)); } case clang::Type::ConstantArray: { @@ -2673,8 +2673,8 @@ static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope * case clang::Type::Enum: { - const clang::EnumType *enum_ty = static_cast(ty); - AstNode *enum_type = resolve_enum_decl(c, enum_ty->getDecl()); + const ZigClangEnumType *enum_ty = reinterpret_cast(ty); + AstNode *enum_type = resolve_enum_decl(c, ZigClangEnumType_getDecl(enum_ty)); return to_enum_zero_cmp(c, res, enum_type); } @@ -4013,23 +4013,23 @@ static AstNode *resolve_typedef_decl(Context *c, const clang::TypedefNameDecl *t return symbol_node; } -struct AstNode *demote_enum_to_opaque(Context *c, const clang::EnumDecl *enum_decl, - Buf *full_type_name, Buf *bare_name) +struct AstNode *demote_enum_to_opaque(Context *c, const ZigClangEnumDecl *enum_decl, Buf *full_type_name, + Buf *bare_name) { AstNode *opaque_node = trans_create_node_opaque(c); if (full_type_name == nullptr) { - c->decl_table.put(enum_decl->getCanonicalDecl(), opaque_node); + c->decl_table.put(ZigClangEnumDecl_getCanonicalDecl(enum_decl), opaque_node); return opaque_node; } AstNode *symbol_node = trans_create_node_symbol(c, full_type_name); add_global_weak_alias(c, bare_name, full_type_name); add_global_var(c, full_type_name, opaque_node); - c->decl_table.put(enum_decl->getCanonicalDecl(), symbol_node); + c->decl_table.put(ZigClangEnumDecl_getCanonicalDecl(enum_decl), symbol_node); return symbol_node; } -static AstNode *resolve_enum_decl(Context *c, const clang::EnumDecl *enum_decl) { - auto existing_entry = c->decl_table.maybe_get((void*)enum_decl->getCanonicalDecl()); +static AstNode *resolve_enum_decl(Context *c, const ZigClangEnumDecl *enum_decl) { + auto existing_entry = c->decl_table.maybe_get(ZigClangEnumDecl_getCanonicalDecl(enum_decl)); if (existing_entry) { return existing_entry->value; } @@ -4039,7 +4039,7 @@ static AstNode *resolve_enum_decl(Context *c, const clang::EnumDecl *enum_decl) Buf *bare_name = is_anonymous ? nullptr : buf_create_from_str(raw_name); Buf *full_type_name = is_anonymous ? nullptr : buf_sprintf("enum_%s", buf_ptr(bare_name)); - const clang::EnumDecl *enum_def = enum_decl->getDefinition(); + const ZigClangEnumDecl *enum_def = ZigClangEnumDecl_getDefinition(enum_decl); if (!enum_def) { return demote_enum_to_opaque(c, enum_decl, full_type_name, bare_name); } @@ -4047,8 +4047,8 @@ static AstNode *resolve_enum_decl(Context *c, const clang::EnumDecl *enum_decl) bool pure_enum = true; uint32_t field_count = 0; - for (auto it = enum_def->enumerator_begin(), - it_end = enum_def->enumerator_end(); + for (auto it = reinterpret_cast(enum_def)->enumerator_begin(), + it_end = reinterpret_cast(enum_def)->enumerator_end(); it != it_end; ++it, field_count += 1) { const clang::EnumConstantDecl *enum_const = *it; @@ -4056,7 +4056,9 @@ static AstNode *resolve_enum_decl(Context *c, const clang::EnumDecl *enum_decl) pure_enum = false; } } - AstNode *tag_int_type = trans_qual_type(c, enum_decl->getIntegerType(), bitcast(enum_decl->getLocation())); + AstNode *tag_int_type = trans_qual_type(c, + bitcast(ZigClangEnumDecl_getIntegerType(enum_decl)), + ZigClangEnumDecl_getLocation(enum_decl)); assert(tag_int_type); AstNode *enum_node = trans_create_node(c, NodeTypeContainerDecl); @@ -4065,15 +4067,15 @@ static AstNode *resolve_enum_decl(Context *c, const clang::EnumDecl *enum_decl) // TODO only emit this tag type if the enum tag type is not the default. // I don't know what the default is, need to figure out how clang is deciding. // it appears to at least be different across gcc/msvc - if (!c_is_builtin_type(c, enum_decl->getIntegerType(), clang::BuiltinType::UInt) && - !c_is_builtin_type(c, enum_decl->getIntegerType(), clang::BuiltinType::Int)) + if (!c_is_builtin_type(c, bitcast(ZigClangEnumDecl_getIntegerType(enum_decl)), clang::BuiltinType::UInt) && + !c_is_builtin_type(c, bitcast(ZigClangEnumDecl_getIntegerType(enum_decl)), clang::BuiltinType::Int)) { enum_node->data.container_decl.init_arg_expr = tag_int_type; } enum_node->data.container_decl.fields.resize(field_count); uint32_t i = 0; - for (auto it = enum_def->enumerator_begin(), - it_end = enum_def->enumerator_end(); + for (auto it = reinterpret_cast(enum_def)->enumerator_begin(), + it_end = reinterpret_cast(enum_def)->enumerator_end(); it != it_end; ++it, i += 1) { const clang::EnumConstantDecl *enum_const = *it; @@ -4106,13 +4108,13 @@ static AstNode *resolve_enum_decl(Context *c, const clang::EnumDecl *enum_decl) } if (is_anonymous) { - c->decl_table.put(enum_decl->getCanonicalDecl(), enum_node); + c->decl_table.put(ZigClangEnumDecl_getCanonicalDecl(enum_decl), enum_node); return enum_node; } else { AstNode *symbol_node = trans_create_node_symbol(c, full_type_name); add_global_weak_alias(c, bare_name, full_type_name); add_global_var(c, full_type_name, enum_node); - c->decl_table.put(enum_decl->getCanonicalDecl(), symbol_node); + c->decl_table.put(ZigClangEnumDecl_getCanonicalDecl(enum_decl), symbol_node); return enum_node; } } @@ -4398,7 +4400,7 @@ static bool decl_visitor(void *context, const ZigClangDecl *zdecl) { resolve_typedef_decl(c, static_cast(decl)); break; case clang::Decl::Enum: - resolve_enum_decl(c, static_cast(decl)); + resolve_enum_decl(c, reinterpret_cast(decl)); break; case clang::Decl::Record: resolve_record_decl(c, (const ZigClangRecordDecl *)(decl)); diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp index 7c0c787e43..7493208450 100644 --- a/src/zig_clang.cpp +++ b/src/zig_clang.cpp @@ -218,17 +218,33 @@ const ZigClangRecordDecl *ZigClangRecordType_getDecl(const ZigClangRecordType *r return reinterpret_cast(record_decl); } +const ZigClangEnumDecl *ZigClangEnumType_getDecl(const ZigClangEnumType *enum_ty) { + const clang::EnumDecl *enum_decl = reinterpret_cast(enum_ty)->getDecl(); + return reinterpret_cast(enum_decl); +} + const ZigClangTagDecl *ZigClangRecordDecl_getCanonicalDecl(const ZigClangRecordDecl *record_decl) { const clang::TagDecl *tag_decl = reinterpret_cast(record_decl)->getCanonicalDecl(); return reinterpret_cast(tag_decl); } +const ZigClangTagDecl *ZigClangEnumDecl_getCanonicalDecl(const ZigClangEnumDecl *enum_decl) { + const clang::TagDecl *tag_decl = reinterpret_cast(enum_decl)->getCanonicalDecl(); + return reinterpret_cast(tag_decl); +} + const ZigClangRecordDecl *ZigClangRecordDecl_getDefinition(const ZigClangRecordDecl *zig_record_decl) { const clang::RecordDecl *record_decl = reinterpret_cast(zig_record_decl); const clang::RecordDecl *definition = record_decl->getDefinition(); return reinterpret_cast(definition); } +const ZigClangEnumDecl *ZigClangEnumDecl_getDefinition(const ZigClangEnumDecl *zig_enum_decl) { + const clang::EnumDecl *enum_decl = reinterpret_cast(zig_enum_decl); + const clang::EnumDecl *definition = enum_decl->getDefinition(); + return reinterpret_cast(definition); +} + bool ZigClangRecordDecl_isUnion(const ZigClangRecordDecl *record_decl) { return reinterpret_cast(record_decl)->isUnion(); } @@ -252,8 +268,17 @@ ZigClangSourceLocation ZigClangRecordDecl_getLocation(const ZigClangRecordDecl * return bitcast(record_decl->getLocation()); } +ZigClangSourceLocation ZigClangEnumDecl_getLocation(const ZigClangEnumDecl *self) { + auto casted = reinterpret_cast(self); + return bitcast(casted->getLocation()); +} + bool ZigClangSourceLocation_eq(ZigClangSourceLocation zig_a, ZigClangSourceLocation zig_b) { clang::SourceLocation a = bitcast(zig_a); clang::SourceLocation b = bitcast(zig_b); return a == b; } + +ZigClangQualType ZigClangEnumDecl_getIntegerType(const ZigClangEnumDecl *self) { + return bitcast(reinterpret_cast(self)->getIntegerType()); +} diff --git a/src/zig_clang.h b/src/zig_clang.h index 03c20c62d6..c15fe84d97 100644 --- a/src/zig_clang.h +++ b/src/zig_clang.h @@ -260,13 +260,22 @@ ZIG_EXTERN_C bool ZigClangASTUnit_visitLocalTopLevelDecls(ZigClangASTUnit *, voi bool (*Fn)(void *context, const ZigClangDecl *decl)); ZIG_EXTERN_C const ZigClangRecordDecl *ZigClangRecordType_getDecl(const ZigClangRecordType *record_ty); +ZIG_EXTERN_C const ZigClangEnumDecl *ZigClangEnumType_getDecl(const ZigClangEnumType *record_ty); ZIG_EXTERN_C const ZigClangTagDecl *ZigClangRecordDecl_getCanonicalDecl(const ZigClangRecordDecl *record_decl); +ZIG_EXTERN_C const ZigClangTagDecl *ZigClangEnumDecl_getCanonicalDecl(const ZigClangEnumDecl *); + +ZIG_EXTERN_C const ZigClangRecordDecl *ZigClangRecordDecl_getDefinition(const ZigClangRecordDecl *); +ZIG_EXTERN_C const ZigClangEnumDecl *ZigClangEnumDecl_getDefinition(const ZigClangEnumDecl *); + +ZIG_EXTERN_C ZigClangSourceLocation ZigClangRecordDecl_getLocation(const ZigClangRecordDecl *); +ZIG_EXTERN_C ZigClangSourceLocation ZigClangEnumDecl_getLocation(const ZigClangEnumDecl *); + ZIG_EXTERN_C bool ZigClangRecordDecl_isUnion(const ZigClangRecordDecl *record_decl); ZIG_EXTERN_C bool ZigClangRecordDecl_isStruct(const ZigClangRecordDecl *record_decl); ZIG_EXTERN_C bool ZigClangRecordDecl_isAnonymousStructOrUnion(const ZigClangRecordDecl *record_decl); -ZIG_EXTERN_C const ZigClangRecordDecl *ZigClangRecordDecl_getDefinition(const ZigClangRecordDecl *); -ZIG_EXTERN_C ZigClangSourceLocation ZigClangRecordDecl_getLocation(const ZigClangRecordDecl *); + +ZIG_EXTERN_C ZigClangQualType ZigClangEnumDecl_getIntegerType(const ZigClangEnumDecl *); ZIG_EXTERN_C const char *ZigClangDecl_getName_bytes_begin(const ZigClangDecl *decl); -- cgit v1.2.3 From 6f34d08aedb4c89257de04da1e4f8d162188d247 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 11 Apr 2019 23:38:41 -0400 Subject: translate-c: move some code to the C API See #1964 --- src/translate_c.cpp | 47 +++++++++++++++++++++++++---------------------- src/zig_clang.cpp | 22 ++++++++++++++++++++++ src/zig_clang.h | 5 +++++ 3 files changed, 52 insertions(+), 22 deletions(-) (limited to 'src/zig_clang.cpp') diff --git a/src/translate_c.cpp b/src/translate_c.cpp index 0e4d21475b..cfa0e7efef 100644 --- a/src/translate_c.cpp +++ b/src/translate_c.cpp @@ -114,7 +114,7 @@ static TransScopeBlock *trans_scope_block_find(TransScope *scope); static AstNode *resolve_record_decl(Context *c, const ZigClangRecordDecl *record_decl); static AstNode *resolve_enum_decl(Context *c, const ZigClangEnumDecl *enum_decl); -static AstNode *resolve_typedef_decl(Context *c, const clang::TypedefNameDecl *typedef_decl); +static AstNode *resolve_typedef_decl(Context *c, const ZigClangTypedefNameDecl *typedef_decl); static int trans_stmt_extra(Context *c, TransScope *scope, const clang::Stmt *stmt, ResultUsed result_used, TransLRValue lrval, @@ -592,7 +592,7 @@ static bool qual_type_is_fn_ptr(clang::QualType qt) { return false; } -static uint32_t qual_type_int_bit_width(Context *c, const clang::QualType &qt, ZigClangSourceLocation source_loc) { +static uint32_t qual_type_int_bit_width(Context *c, const clang::QualType qt, ZigClangSourceLocation source_loc) { const clang::Type *ty = qt.getTypePtr(); switch (ty->getTypeClass()) { case clang::Type::Builtin: @@ -614,8 +614,8 @@ static uint32_t qual_type_int_bit_width(Context *c, const clang::QualType &qt, Z } case clang::Type::Typedef: { - const clang::TypedefType *typedef_ty = static_cast(ty); - const clang::TypedefNameDecl *typedef_decl = typedef_ty->getDecl(); + const ZigClangTypedefType *typedef_ty = reinterpret_cast(ty); + const ZigClangTypedefNameDecl *typedef_decl = ZigClangTypedefType_getDecl(typedef_ty); const char *type_name = ZigClangDecl_getName_bytes_begin((const ZigClangDecl *)typedef_decl); if (strcmp(type_name, "uint8_t") == 0 || strcmp(type_name, "int8_t") == 0) { return 8; @@ -636,7 +636,7 @@ static uint32_t qual_type_int_bit_width(Context *c, const clang::QualType &qt, Z } -static AstNode *qual_type_to_log2_int_ref(Context *c, const clang::QualType &qt, +static AstNode *qual_type_to_log2_int_ref(Context *c, const clang::QualType qt, ZigClangSourceLocation source_loc) { uint32_t int_bit_width = qual_type_int_bit_width(c, qt, source_loc); @@ -669,7 +669,7 @@ static AstNode *qual_type_to_log2_int_ref(Context *c, const clang::QualType &qt, return log2int_fn_call; } -static bool qual_type_child_is_fn_proto(const clang::QualType &qt) { +static bool qual_type_child_is_fn_proto(const clang::QualType qt) { if (qt.getTypePtr()->getTypeClass() == clang::Type::Paren) { const clang::ParenType *paren_type = static_cast(qt.getTypePtr()); if (paren_type->getInnerType()->getTypeClass() == clang::Type::FunctionProto) { @@ -797,9 +797,11 @@ static bool type_is_opaque(Context *c, const clang::Type *ty, ZigClangSourceLoca return type_is_opaque(c, elaborated_ty->getNamedType().getTypePtr(), source_loc); } case clang::Type::Typedef: { - const clang::TypedefType *typedef_ty = static_cast(ty); - const clang::TypedefNameDecl *typedef_decl = typedef_ty->getDecl(); - return type_is_opaque(c, typedef_decl->getUnderlyingType().getTypePtr(), source_loc); + const ZigClangTypedefType *typedef_ty = reinterpret_cast(ty); + const ZigClangTypedefNameDecl *typedef_decl = ZigClangTypedefType_getDecl(typedef_ty); + ZigClangQualType underlying_type = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl); + clang::QualType qt = bitcast(underlying_type); + return type_is_opaque(c, qt.getTypePtr(), source_loc); } default: return false; @@ -978,8 +980,8 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, ZigClangSourceLoca } case clang::Type::Typedef: { - const clang::TypedefType *typedef_ty = static_cast(ty); - const clang::TypedefNameDecl *typedef_decl = typedef_ty->getDecl(); + const ZigClangTypedefType *typedef_ty = reinterpret_cast(ty); + const ZigClangTypedefNameDecl *typedef_decl = ZigClangTypedefType_getDecl(typedef_ty); return resolve_typedef_decl(c, typedef_decl); } case clang::Type::Elaborated: @@ -2661,9 +2663,9 @@ static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope * case clang::Type::Typedef: { - const clang::TypedefType *typedef_ty = static_cast(ty); - const clang::TypedefNameDecl *typedef_decl = typedef_ty->getDecl(); - auto existing_entry = c->decl_table.maybe_get((void*)typedef_decl->getCanonicalDecl()); + const ZigClangTypedefType *typedef_ty = reinterpret_cast(ty); + const ZigClangTypedefNameDecl *typedef_decl = ZigClangTypedefType_getDecl(typedef_ty); + auto existing_entry = c->decl_table.maybe_get((void*)ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl)); if (existing_entry) { return existing_entry->value; } @@ -3952,19 +3954,19 @@ static void visit_fn_decl(Context *c, const clang::FunctionDecl *fn_decl) { add_top_level_decl(c, fn_def_node->data.fn_def.fn_proto->data.fn_proto.name, fn_def_node); } -static AstNode *resolve_typdef_as_builtin(Context *c, const clang::TypedefNameDecl *typedef_decl, const char *primitive_name) { +static AstNode *resolve_typdef_as_builtin(Context *c, const ZigClangTypedefNameDecl *typedef_decl, const char *primitive_name) { AstNode *node = trans_create_node_symbol_str(c, primitive_name); c->decl_table.put(typedef_decl, node); return node; } -static AstNode *resolve_typedef_decl(Context *c, const clang::TypedefNameDecl *typedef_decl) { - auto existing_entry = c->decl_table.maybe_get((void*)typedef_decl->getCanonicalDecl()); +static AstNode *resolve_typedef_decl(Context *c, const ZigClangTypedefNameDecl *typedef_decl) { + auto existing_entry = c->decl_table.maybe_get((void*)ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl)); if (existing_entry) { return existing_entry->value; } - clang::QualType child_qt = typedef_decl->getUnderlyingType(); + ZigClangQualType child_qt = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl); Buf *type_name = buf_create_from_str(ZigClangDecl_getName_bytes_begin((const ZigClangDecl *)typedef_decl)); if (buf_eql_str(type_name, "uint8_t")) { @@ -3999,11 +4001,12 @@ static AstNode *resolve_typedef_decl(Context *c, const clang::TypedefNameDecl *t // trans_qual_type here might cause us to look at this typedef again so we put the item in the map first AstNode *symbol_node = trans_create_node_symbol(c, type_name); - c->decl_table.put(typedef_decl->getCanonicalDecl(), symbol_node); + c->decl_table.put(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl), symbol_node); - AstNode *type_node = trans_qual_type(c, child_qt, bitcast(typedef_decl->getLocation())); + AstNode *type_node = trans_qual_type(c, bitcast(child_qt), ZigClangTypedefNameDecl_getLocation(typedef_decl)); if (type_node == nullptr) { - emit_warning(c, bitcast(typedef_decl->getLocation()), "typedef %s - unresolved child type", buf_ptr(type_name)); + emit_warning(c, ZigClangTypedefNameDecl_getLocation(typedef_decl), + "typedef %s - unresolved child type", buf_ptr(type_name)); c->decl_table.put(typedef_decl, nullptr); // TODO add global var with type_name equal to @compileError("unable to resolve C type") return nullptr; @@ -4397,7 +4400,7 @@ static bool decl_visitor(void *context, const ZigClangDecl *zdecl) { visit_fn_decl(c, static_cast(decl)); break; case clang::Decl::Typedef: - resolve_typedef_decl(c, static_cast(decl)); + resolve_typedef_decl(c, reinterpret_cast(decl)); break; case clang::Decl::Enum: resolve_enum_decl(c, reinterpret_cast(decl)); diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp index 7493208450..4f50c5d3d3 100644 --- a/src/zig_clang.cpp +++ b/src/zig_clang.cpp @@ -233,6 +233,11 @@ const ZigClangTagDecl *ZigClangEnumDecl_getCanonicalDecl(const ZigClangEnumDecl return reinterpret_cast(tag_decl); } +const ZigClangTypedefNameDecl *ZigClangTypedefNameDecl_getCanonicalDecl(const ZigClangTypedefNameDecl *self) { + const clang::TypedefNameDecl *decl = reinterpret_cast(self)->getCanonicalDecl(); + return reinterpret_cast(decl); +} + const ZigClangRecordDecl *ZigClangRecordDecl_getDefinition(const ZigClangRecordDecl *zig_record_decl) { const clang::RecordDecl *record_decl = reinterpret_cast(zig_record_decl); const clang::RecordDecl *definition = record_decl->getDefinition(); @@ -273,6 +278,11 @@ ZigClangSourceLocation ZigClangEnumDecl_getLocation(const ZigClangEnumDecl *self return bitcast(casted->getLocation()); } +ZigClangSourceLocation ZigClangTypedefNameDecl_getLocation(const ZigClangTypedefNameDecl *self) { + auto casted = reinterpret_cast(self); + return bitcast(casted->getLocation()); +} + bool ZigClangSourceLocation_eq(ZigClangSourceLocation zig_a, ZigClangSourceLocation zig_b) { clang::SourceLocation a = bitcast(zig_a); clang::SourceLocation b = bitcast(zig_b); @@ -282,3 +292,15 @@ bool ZigClangSourceLocation_eq(ZigClangSourceLocation zig_a, ZigClangSourceLocat ZigClangQualType ZigClangEnumDecl_getIntegerType(const ZigClangEnumDecl *self) { return bitcast(reinterpret_cast(self)->getIntegerType()); } + +const ZigClangTypedefNameDecl *ZigClangTypedefType_getDecl(const ZigClangTypedefType *self) { + auto casted = reinterpret_cast(self); + const clang::TypedefNameDecl *name_decl = casted->getDecl(); + return reinterpret_cast(name_decl); +} + +ZigClangQualType ZigClangTypedefNameDecl_getUnderlyingType(const ZigClangTypedefNameDecl *self) { + auto casted = reinterpret_cast(self); + clang::QualType ty = casted->getUnderlyingType(); + return bitcast(ty); +} diff --git a/src/zig_clang.h b/src/zig_clang.h index c15fe84d97..c534addf9e 100644 --- a/src/zig_clang.h +++ b/src/zig_clang.h @@ -264,12 +264,14 @@ ZIG_EXTERN_C const ZigClangEnumDecl *ZigClangEnumType_getDecl(const ZigClangEnum ZIG_EXTERN_C const ZigClangTagDecl *ZigClangRecordDecl_getCanonicalDecl(const ZigClangRecordDecl *record_decl); ZIG_EXTERN_C const ZigClangTagDecl *ZigClangEnumDecl_getCanonicalDecl(const ZigClangEnumDecl *); +ZIG_EXTERN_C const ZigClangTypedefNameDecl *ZigClangTypedefNameDecl_getCanonicalDecl(const ZigClangTypedefNameDecl *); ZIG_EXTERN_C const ZigClangRecordDecl *ZigClangRecordDecl_getDefinition(const ZigClangRecordDecl *); ZIG_EXTERN_C const ZigClangEnumDecl *ZigClangEnumDecl_getDefinition(const ZigClangEnumDecl *); ZIG_EXTERN_C ZigClangSourceLocation ZigClangRecordDecl_getLocation(const ZigClangRecordDecl *); ZIG_EXTERN_C ZigClangSourceLocation ZigClangEnumDecl_getLocation(const ZigClangEnumDecl *); +ZIG_EXTERN_C ZigClangSourceLocation ZigClangTypedefNameDecl_getLocation(const ZigClangTypedefNameDecl *); ZIG_EXTERN_C bool ZigClangRecordDecl_isUnion(const ZigClangRecordDecl *record_decl); ZIG_EXTERN_C bool ZigClangRecordDecl_isStruct(const ZigClangRecordDecl *record_decl); @@ -280,4 +282,7 @@ ZIG_EXTERN_C ZigClangQualType ZigClangEnumDecl_getIntegerType(const ZigClangEnum ZIG_EXTERN_C const char *ZigClangDecl_getName_bytes_begin(const ZigClangDecl *decl); ZIG_EXTERN_C bool ZigClangSourceLocation_eq(ZigClangSourceLocation a, ZigClangSourceLocation b); + +ZIG_EXTERN_C const ZigClangTypedefNameDecl *ZigClangTypedefType_getDecl(const ZigClangTypedefType *); +ZIG_EXTERN_C ZigClangQualType ZigClangTypedefNameDecl_getUnderlyingType(const ZigClangTypedefNameDecl *); #endif -- cgit v1.2.3 From f860493f23f0c438e76268b412f85e7b9843ea89 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Fri, 12 Apr 2019 03:12:22 -0400 Subject: translate-c: move some code to the C API See #1964 --- src/translate_c.cpp | 537 ++++++++++++++++++++++++++-------------------------- src/zig_clang.cpp | 262 ++++++++++++++++++++----- src/zig_clang.h | 62 ++++++ 3 files changed, 544 insertions(+), 317 deletions(-) (limited to 'src/zig_clang.cpp') diff --git a/src/translate_c.cpp b/src/translate_c.cpp index cfa0e7efef..84770844b7 100644 --- a/src/translate_c.cpp +++ b/src/translate_c.cpp @@ -122,9 +122,9 @@ static int trans_stmt_extra(Context *c, TransScope *scope, const clang::Stmt *st TransScope **out_node_scope); static TransScope *trans_stmt(Context *c, TransScope *scope, const clang::Stmt *stmt, AstNode **out_node); static AstNode *trans_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::Expr *expr, TransLRValue lrval); -static AstNode *trans_qual_type(Context *c, clang::QualType qt, ZigClangSourceLocation source_loc); +static AstNode *trans_qual_type(Context *c, ZigClangQualType qt, ZigClangSourceLocation source_loc); static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::Expr *expr, TransLRValue lrval); -static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, clang::QualType qt, ZigClangSourceLocation source_loc); +static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, ZigClangQualType qt, ZigClangSourceLocation source_loc); static ZigClangSourceLocation bitcast(clang::SourceLocation src) { ZigClangSourceLocation dest; @@ -136,11 +136,11 @@ static ZigClangQualType bitcast(clang::QualType src) { memcpy(&dest, static_cast(&src), sizeof(ZigClangQualType)); return dest; } -static clang::QualType bitcast(ZigClangQualType src) { - clang::QualType dest; - memcpy(&dest, static_cast(&src), sizeof(ZigClangQualType)); - return dest; -} +//static clang::QualType bitcast(ZigClangQualType src) { +// clang::QualType dest; +// memcpy(&dest, static_cast(&src), sizeof(ZigClangQualType)); +// return dest; +//} ATTRIBUTE_PRINTF(3, 4) static void emit_warning(Context *c, ZigClangSourceLocation sl, const char *format, ...) { @@ -502,88 +502,77 @@ static AstNode *trans_create_node_apint(Context *c, const llvm::APSInt &aps_int) } -static const clang::Type *qual_type_canon(clang::QualType qt) { - return qt.getCanonicalType().getTypePtr(); +static const ZigClangType *qual_type_canon(ZigClangQualType qt) { + ZigClangQualType canon = ZigClangQualType_getCanonicalType(qt); + return ZigClangQualType_getTypePtr(canon); } -static clang::QualType get_expr_qual_type(Context *c, const clang::Expr *expr) { +static ZigClangQualType get_expr_qual_type(Context *c, const clang::Expr *expr) { // String literals in C are `char *` but they should really be `const char *`. if (expr->getStmtClass() == clang::Stmt::ImplicitCastExprClass) { const clang::ImplicitCastExpr *cast_expr = static_cast(expr); if (cast_expr->getCastKind() == clang::CK_ArrayToPointerDecay) { const clang::Expr *sub_expr = cast_expr->getSubExpr(); if (sub_expr->getStmtClass() == clang::Stmt::StringLiteralClass) { - clang::QualType array_qt = sub_expr->getType(); - const clang::ArrayType *array_type = static_cast(array_qt.getTypePtr()); - clang::QualType pointee_qt = array_type->getElementType(); - pointee_qt.addConst(); - return bitcast(ZigClangASTContext_getPointerType(c->ctx, bitcast(pointee_qt))); + ZigClangQualType array_qt = bitcast(sub_expr->getType()); + const clang::ArrayType *array_type = reinterpret_cast( + ZigClangQualType_getTypePtr(array_qt)); + ZigClangQualType pointee_qt = bitcast(array_type->getElementType()); + ZigClangQualType_addConst(&pointee_qt); + return ZigClangASTContext_getPointerType(c->ctx, pointee_qt); } } } - return expr->getType(); + return bitcast(expr->getType()); } -static clang::QualType get_expr_qual_type_before_implicit_cast(Context *c, const clang::Expr *expr) { +static ZigClangQualType get_expr_qual_type_before_implicit_cast(Context *c, const clang::Expr *expr) { if (expr->getStmtClass() == clang::Stmt::ImplicitCastExprClass) { const clang::ImplicitCastExpr *cast_expr = static_cast(expr); return get_expr_qual_type(c, cast_expr->getSubExpr()); } - return expr->getType(); + return bitcast(expr->getType()); } static AstNode *get_expr_type(Context *c, const clang::Expr *expr) { return trans_qual_type(c, get_expr_qual_type(c, expr), bitcast(expr->getBeginLoc())); } -static bool qual_types_equal(clang::QualType t1, clang::QualType t2) { - if (t1.isConstQualified() != t2.isConstQualified()) { - return false; - } - if (t1.isVolatileQualified() != t2.isVolatileQualified()) { - return false; - } - if (t1.isRestrictQualified() != t2.isRestrictQualified()) { - return false; - } - return t1.getTypePtr() == t2.getTypePtr(); -} - static bool is_c_void_type(AstNode *node) { return (node->type == NodeTypeSymbol && buf_eql_str(node->data.symbol_expr.symbol, "c_void")); } static bool expr_types_equal(Context *c, const clang::Expr *expr1, const clang::Expr *expr2) { - clang::QualType t1 = get_expr_qual_type(c, expr1); - clang::QualType t2 = get_expr_qual_type(c, expr2); + ZigClangQualType t1 = get_expr_qual_type(c, expr1); + ZigClangQualType t2 = get_expr_qual_type(c, expr2); - return qual_types_equal(t1, t2); + return ZigClangQualType_eq(t1, t2); } -static bool qual_type_is_ptr(clang::QualType qt) { - const clang::Type *ty = qual_type_canon(qt); - return ty->getTypeClass() == clang::Type::Pointer; +static bool qual_type_is_ptr(ZigClangQualType qt) { + const ZigClangType *ty = qual_type_canon(qt); + return ZigClangType_getTypeClass(ty) == ZigClangType_Pointer; } -static const clang::FunctionProtoType *qual_type_get_fn_proto(clang::QualType qt, bool *is_ptr) { - const clang::Type *ty = qual_type_canon(qt); +static const clang::FunctionProtoType *qual_type_get_fn_proto(ZigClangQualType qt, bool *is_ptr) { + const ZigClangType *ty = qual_type_canon(qt); *is_ptr = false; - if (ty->getTypeClass() == clang::Type::Pointer) { + if (ZigClangType_getTypeClass(ty) == ZigClangType_Pointer) { *is_ptr = true; - const clang::PointerType *pointer_ty = static_cast(ty); - clang::QualType child_qt = pointer_ty->getPointeeType(); - ty = child_qt.getTypePtr(); + const clang::PointerType *pointer_ty = reinterpret_cast(ty); + ZigClangQualType child_qt = bitcast(pointer_ty->getPointeeType()); + ty = ZigClangQualType_getTypePtr(child_qt); } - if (ty->getTypeClass() == clang::Type::FunctionProto) { - return static_cast(ty); + if (ZigClangType_getTypeClass(ty) == ZigClangType_FunctionProto) { + return reinterpret_cast(ty); } return nullptr; } -static bool qual_type_is_fn_ptr(clang::QualType qt) { +static bool qual_type_is_fn_ptr(ZigClangQualType qt) { bool is_ptr; if (qual_type_get_fn_proto(qt, &is_ptr)) { return is_ptr; @@ -592,12 +581,12 @@ static bool qual_type_is_fn_ptr(clang::QualType qt) { return false; } -static uint32_t qual_type_int_bit_width(Context *c, const clang::QualType qt, ZigClangSourceLocation source_loc) { - const clang::Type *ty = qt.getTypePtr(); - switch (ty->getTypeClass()) { - case clang::Type::Builtin: +static uint32_t qual_type_int_bit_width(Context *c, const ZigClangQualType qt, ZigClangSourceLocation source_loc) { + const ZigClangType *ty = ZigClangQualType_getTypePtr(qt); + switch (ZigClangType_getTypeClass(ty)) { + case ZigClangType_Builtin: { - const clang::BuiltinType *builtin_ty = static_cast(ty); + const clang::BuiltinType *builtin_ty = reinterpret_cast(ty); switch (builtin_ty->getKind()) { case clang::BuiltinType::Char_U: case clang::BuiltinType::UChar: @@ -612,7 +601,7 @@ static uint32_t qual_type_int_bit_width(Context *c, const clang::QualType qt, Zi } zig_unreachable(); } - case clang::Type::Typedef: + case ZigClangType_Typedef: { const ZigClangTypedefType *typedef_ty = reinterpret_cast(ty); const ZigClangTypedefNameDecl *typedef_decl = ZigClangTypedefType_getDecl(typedef_ty); @@ -636,7 +625,7 @@ static uint32_t qual_type_int_bit_width(Context *c, const clang::QualType qt, Zi } -static AstNode *qual_type_to_log2_int_ref(Context *c, const clang::QualType qt, +static AstNode *qual_type_to_log2_int_ref(Context *c, const ZigClangQualType qt, ZigClangSourceLocation source_loc) { uint32_t int_bit_width = qual_type_int_bit_width(c, qt, source_loc); @@ -669,30 +658,31 @@ static AstNode *qual_type_to_log2_int_ref(Context *c, const clang::QualType qt, return log2int_fn_call; } -static bool qual_type_child_is_fn_proto(const clang::QualType qt) { - if (qt.getTypePtr()->getTypeClass() == clang::Type::Paren) { - const clang::ParenType *paren_type = static_cast(qt.getTypePtr()); +static bool qual_type_child_is_fn_proto(ZigClangQualType qt) { + const ZigClangType *ty = ZigClangQualType_getTypePtr(qt); + if (ZigClangType_getTypeClass(ty) == ZigClangType_Paren) { + const clang::ParenType *paren_type = reinterpret_cast(ty); if (paren_type->getInnerType()->getTypeClass() == clang::Type::FunctionProto) { return true; } - } else if (qt.getTypePtr()->getTypeClass() == clang::Type::Attributed) { - const clang::AttributedType *attr_type = static_cast(qt.getTypePtr()); - return qual_type_child_is_fn_proto(attr_type->getEquivalentType()); + } else if (ZigClangType_getTypeClass(ty) == ZigClangType_Attributed) { + const clang::AttributedType *attr_type = reinterpret_cast(ty); + return qual_type_child_is_fn_proto(bitcast(attr_type->getEquivalentType())); } return false; } -static AstNode* trans_c_cast(Context *c, ZigClangSourceLocation source_location, clang::QualType dest_type, - clang::QualType src_type, AstNode *expr) +static AstNode* trans_c_cast(Context *c, ZigClangSourceLocation source_location, ZigClangQualType dest_type, + ZigClangQualType src_type, AstNode *expr) { // The only way void pointer casts are valid C code, is if // the value of the expression is ignored. We therefore just // return the expr, and let the system that ignores values // translate this correctly. - if (qual_type_canon(dest_type)->isVoidType()) { + if (ZigClangType_isVoidType(qual_type_canon(dest_type))) { return expr; } - if (qual_types_equal(dest_type, src_type)) { + if (ZigClangQualType_eq(dest_type, src_type)) { return expr; } if (qual_type_is_ptr(dest_type) && qual_type_is_ptr(src_type)) { @@ -707,11 +697,11 @@ static AstNode* trans_c_cast(Context *c, ZigClangSourceLocation source_location, return trans_create_node_fn_call_1(c, trans_qual_type(c, dest_type, source_location), expr); } -static bool c_is_signed_integer(Context *c, clang::QualType qt) { - const clang::Type *c_type = qual_type_canon(qt); - if (c_type->getTypeClass() != clang::Type::Builtin) +static bool c_is_signed_integer(Context *c, ZigClangQualType qt) { + const ZigClangType *c_type = qual_type_canon(qt); + if (ZigClangType_getTypeClass(c_type) != ZigClangType_Builtin) return false; - const clang::BuiltinType *builtin_ty = static_cast(c_type); + const clang::BuiltinType *builtin_ty = reinterpret_cast(c_type); switch (builtin_ty->getKind()) { case clang::BuiltinType::SChar: case clang::BuiltinType::Short: @@ -726,11 +716,11 @@ static bool c_is_signed_integer(Context *c, clang::QualType qt) { } } -static bool c_is_unsigned_integer(Context *c, clang::QualType qt) { - const clang::Type *c_type = qual_type_canon(qt); - if (c_type->getTypeClass() != clang::Type::Builtin) +static bool c_is_unsigned_integer(Context *c, ZigClangQualType qt) { + const ZigClangType *c_type = qual_type_canon(qt); + if (ZigClangType_getTypeClass(c_type) != ZigClangType_Builtin) return false; - const clang::BuiltinType *builtin_ty = static_cast(c_type); + const clang::BuiltinType *builtin_ty = reinterpret_cast(c_type); switch (builtin_ty->getKind()) { case clang::BuiltinType::Char_U: case clang::BuiltinType::UChar: @@ -747,19 +737,19 @@ static bool c_is_unsigned_integer(Context *c, clang::QualType qt) { } } -static bool c_is_builtin_type(Context *c, clang::QualType qt, clang::BuiltinType::Kind kind) { - const clang::Type *c_type = qual_type_canon(qt); - if (c_type->getTypeClass() != clang::Type::Builtin) +static bool c_is_builtin_type(Context *c, ZigClangQualType qt, clang::BuiltinType::Kind kind) { + const ZigClangType *c_type = qual_type_canon(qt); + if (ZigClangType_getTypeClass(c_type) != ZigClangType_Builtin) return false; - const clang::BuiltinType *builtin_ty = static_cast(c_type); + const clang::BuiltinType *builtin_ty = reinterpret_cast(c_type); return builtin_ty->getKind() == kind; } -static bool c_is_float(Context *c, clang::QualType qt) { - const clang::Type *c_type = qt.getTypePtr(); - if (c_type->getTypeClass() != clang::Type::Builtin) +static bool c_is_float(Context *c, ZigClangQualType qt) { + const ZigClangType *c_type = ZigClangQualType_getTypePtr(qt); + if (ZigClangType_getTypeClass(c_type) != ZigClangType_Builtin) return false; - const clang::BuiltinType *builtin_ty = static_cast(c_type); + const clang::BuiltinType *builtin_ty = reinterpret_cast(c_type); switch (builtin_ty->getKind()) { case clang::BuiltinType::Half: case clang::BuiltinType::Float: @@ -772,7 +762,7 @@ static bool c_is_float(Context *c, clang::QualType qt) { } } -static bool qual_type_has_wrapping_overflow(Context *c, clang::QualType qt) { +static bool qual_type_has_wrapping_overflow(Context *c, ZigClangQualType qt) { if (c_is_signed_integer(c, qt) || c_is_float(c, qt)) { // float and signed integer overflow is undefined behavior. return false; @@ -782,37 +772,37 @@ static bool qual_type_has_wrapping_overflow(Context *c, clang::QualType qt) { } } -static bool type_is_opaque(Context *c, const clang::Type *ty, ZigClangSourceLocation source_loc) { - switch (ty->getTypeClass()) { - case clang::Type::Builtin: { - const clang::BuiltinType *builtin_ty = static_cast(ty); +static bool type_is_opaque(Context *c, const ZigClangType *ty, ZigClangSourceLocation source_loc) { + switch (ZigClangType_getTypeClass(ty)) { + case ZigClangType_Builtin: { + const clang::BuiltinType *builtin_ty = reinterpret_cast(ty); return builtin_ty->getKind() == clang::BuiltinType::Void; } - case clang::Type::Record: { - const clang::RecordType *record_ty = static_cast(ty); + case ZigClangType_Record: { + const clang::RecordType *record_ty = reinterpret_cast(ty); return record_ty->getDecl()->getDefinition() == nullptr; } - case clang::Type::Elaborated: { - const clang::ElaboratedType *elaborated_ty = static_cast(ty); - return type_is_opaque(c, elaborated_ty->getNamedType().getTypePtr(), source_loc); + case ZigClangType_Elaborated: { + const clang::ElaboratedType *elaborated_ty = reinterpret_cast(ty); + ZigClangQualType qt = bitcast(elaborated_ty->getNamedType()); + return type_is_opaque(c, ZigClangQualType_getTypePtr(qt), source_loc); } - case clang::Type::Typedef: { + case ZigClangType_Typedef: { const ZigClangTypedefType *typedef_ty = reinterpret_cast(ty); const ZigClangTypedefNameDecl *typedef_decl = ZigClangTypedefType_getDecl(typedef_ty); ZigClangQualType underlying_type = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl); - clang::QualType qt = bitcast(underlying_type); - return type_is_opaque(c, qt.getTypePtr(), source_loc); + return type_is_opaque(c, ZigClangQualType_getTypePtr(underlying_type), source_loc); } default: return false; } } -static AstNode *trans_type(Context *c, const clang::Type *ty, ZigClangSourceLocation source_loc) { - switch (ty->getTypeClass()) { - case clang::Type::Builtin: +static AstNode *trans_type(Context *c, const ZigClangType *ty, ZigClangSourceLocation source_loc) { + switch (ZigClangType_getTypeClass(ty)) { + case ZigClangType_Builtin: { - const clang::BuiltinType *builtin_ty = static_cast(ty); + const clang::BuiltinType *builtin_ty = reinterpret_cast(ty); switch (builtin_ty->getKind()) { case clang::BuiltinType::Void: return trans_create_node_symbol_str(c, "c_void"); @@ -955,10 +945,10 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, ZigClangSourceLoca } break; } - case clang::Type::Pointer: + case ZigClangType_Pointer: { - const clang::PointerType *pointer_ty = static_cast(ty); - clang::QualType child_qt = pointer_ty->getPointeeType(); + const clang::PointerType *pointer_ty = reinterpret_cast(ty); + ZigClangQualType child_qt = bitcast(pointer_ty->getPointeeType()); AstNode *child_node = trans_qual_type(c, child_qt, source_loc); if (child_node == nullptr) { emit_warning(c, source_loc, "pointer to unsupported type"); @@ -969,29 +959,33 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, ZigClangSourceLoca return trans_create_node_prefix_op(c, PrefixOpOptional, child_node); } - if (type_is_opaque(c, child_qt.getTypePtr(), source_loc)) { - AstNode *pointer_node = trans_create_node_ptr_type(c, child_qt.isConstQualified(), - child_qt.isVolatileQualified(), child_node, PtrLenSingle); + if (type_is_opaque(c, ZigClangQualType_getTypePtr(child_qt), source_loc)) { + AstNode *pointer_node = trans_create_node_ptr_type(c, + ZigClangQualType_isConstQualified(child_qt), + ZigClangQualType_isVolatileQualified(child_qt), + child_node, PtrLenSingle); return trans_create_node_prefix_op(c, PrefixOpOptional, pointer_node); } else { - return trans_create_node_ptr_type(c, child_qt.isConstQualified(), - child_qt.isVolatileQualified(), child_node, PtrLenC); + return trans_create_node_ptr_type(c, + ZigClangQualType_isConstQualified(child_qt), + ZigClangQualType_isVolatileQualified(child_qt), + child_node, PtrLenC); } } - case clang::Type::Typedef: + case ZigClangType_Typedef: { const ZigClangTypedefType *typedef_ty = reinterpret_cast(ty); const ZigClangTypedefNameDecl *typedef_decl = ZigClangTypedefType_getDecl(typedef_ty); return resolve_typedef_decl(c, typedef_decl); } - case clang::Type::Elaborated: + case ZigClangType_Elaborated: { - const clang::ElaboratedType *elaborated_ty = static_cast(ty); + const clang::ElaboratedType *elaborated_ty = reinterpret_cast(ty); switch (elaborated_ty->getKeyword()) { case clang::ETK_Struct: case clang::ETK_Enum: case clang::ETK_Union: - return trans_qual_type(c, elaborated_ty->getNamedType(), source_loc); + return trans_qual_type(c, bitcast(elaborated_ty->getNamedType()), source_loc); case clang::ETK_Interface: case clang::ETK_Class: case clang::ETK_Typename: @@ -1000,10 +994,10 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, ZigClangSourceLoca return nullptr; } } - case clang::Type::FunctionProto: - case clang::Type::FunctionNoProto: + case ZigClangType_FunctionProto: + case ZigClangType_FunctionNoProto: { - const clang::FunctionType *fn_ty = static_cast(ty); + const clang::FunctionType *fn_ty = reinterpret_cast(ty); AstNode *proto_node = trans_create_node(c, NodeTypeFnProto); switch (fn_ty->getCallConv()) { @@ -1067,14 +1061,14 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, ZigClangSourceLoca if (fn_ty->getNoReturnAttr()) { proto_node->data.fn_proto.return_type = trans_create_node_symbol_str(c, "noreturn"); } else { - proto_node->data.fn_proto.return_type = trans_qual_type(c, fn_ty->getReturnType(), + proto_node->data.fn_proto.return_type = trans_qual_type(c, bitcast(fn_ty->getReturnType()), source_loc); if (proto_node->data.fn_proto.return_type == nullptr) { emit_warning(c, source_loc, "unsupported function proto return type"); return nullptr; } // convert c_void to actual void (only for return type) - // we do want to look at the AstNode instead of clang::QualType, because + // we do want to look at the AstNode instead of ZigClangQualType, because // if they do something like: // typedef Foo void; // void foo(void) -> Foo; @@ -1090,17 +1084,17 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, ZigClangSourceLoca proto_node->data.fn_proto.name = buf_create_from_str(fn_name); } - if (ty->getTypeClass() == clang::Type::FunctionNoProto) { + if (ZigClangType_getTypeClass(ty) == ZigClangType_FunctionNoProto) { return proto_node; } - const clang::FunctionProtoType *fn_proto_ty = static_cast(ty); + const clang::FunctionProtoType *fn_proto_ty = reinterpret_cast(ty); proto_node->data.fn_proto.is_var_args = fn_proto_ty->isVariadic(); size_t param_count = fn_proto_ty->getNumParams(); for (size_t i = 0; i < param_count; i += 1) { - clang::QualType qt = fn_proto_ty->getParamType(i); + ZigClangQualType qt = bitcast(fn_proto_ty->getParamType(i)); AstNode *param_type_node = trans_qual_type(c, qt, source_loc); if (param_type_node == nullptr) { @@ -1114,7 +1108,7 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, ZigClangSourceLoca if (param_name != nullptr) { param_node->data.param_decl.name = buf_create_from_str(param_name); } - param_node->data.param_decl.is_noalias = qt.isRestrictQualified(); + param_node->data.param_decl.is_noalias = ZigClangQualType_isRestrictQualified(qt); param_node->data.param_decl.type = param_type_node; proto_node->data.fn_proto.params.append(param_node); } @@ -1123,20 +1117,20 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, ZigClangSourceLoca return proto_node; } - case clang::Type::Record: + case ZigClangType_Record: { const ZigClangRecordType *record_ty = reinterpret_cast(ty); return resolve_record_decl(c, ZigClangRecordType_getDecl(record_ty)); } - case clang::Type::Enum: + case ZigClangType_Enum: { const ZigClangEnumType *enum_ty = reinterpret_cast(ty); return resolve_enum_decl(c, ZigClangEnumType_getDecl(enum_ty)); } - case clang::Type::ConstantArray: + case ZigClangType_ConstantArray: { - const clang::ConstantArrayType *const_arr_ty = static_cast(ty); - AstNode *child_type_node = trans_qual_type(c, const_arr_ty->getElementType(), source_loc); + const clang::ConstantArrayType *const_arr_ty = reinterpret_cast(ty); + AstNode *child_type_node = trans_qual_type(c, bitcast(const_arr_ty->getElementType()), source_loc); if (child_type_node == nullptr) { emit_warning(c, source_loc, "unresolved array element type"); return nullptr; @@ -1145,76 +1139,78 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, ZigClangSourceLoca AstNode *size_node = trans_create_node_unsigned(c, size); return trans_create_node_array_type(c, size_node, child_type_node); } - case clang::Type::Paren: + case ZigClangType_Paren: { - const clang::ParenType *paren_ty = static_cast(ty); - return trans_qual_type(c, paren_ty->getInnerType(), source_loc); + const clang::ParenType *paren_ty = reinterpret_cast(ty); + return trans_qual_type(c, bitcast(paren_ty->getInnerType()), source_loc); } - case clang::Type::Decayed: + case ZigClangType_Decayed: { - const clang::DecayedType *decayed_ty = static_cast(ty); - return trans_qual_type(c, decayed_ty->getDecayedType(), source_loc); + const clang::DecayedType *decayed_ty = reinterpret_cast(ty); + return trans_qual_type(c, bitcast(decayed_ty->getDecayedType()), source_loc); } - case clang::Type::Attributed: + case ZigClangType_Attributed: { - const clang::AttributedType *attributed_ty = static_cast(ty); - return trans_qual_type(c, attributed_ty->getEquivalentType(), source_loc); + const clang::AttributedType *attributed_ty = reinterpret_cast(ty); + return trans_qual_type(c, bitcast(attributed_ty->getEquivalentType()), source_loc); } - case clang::Type::IncompleteArray: + case ZigClangType_IncompleteArray: { - const clang::IncompleteArrayType *incomplete_array_ty = static_cast(ty); - clang::QualType child_qt = incomplete_array_ty->getElementType(); + const clang::IncompleteArrayType *incomplete_array_ty = reinterpret_cast(ty); + ZigClangQualType child_qt = bitcast(incomplete_array_ty->getElementType()); AstNode *child_type_node = trans_qual_type(c, child_qt, source_loc); if (child_type_node == nullptr) { emit_warning(c, source_loc, "unresolved array element type"); return nullptr; } - AstNode *pointer_node = trans_create_node_ptr_type(c, child_qt.isConstQualified(), - child_qt.isVolatileQualified(), child_type_node, PtrLenC); + AstNode *pointer_node = trans_create_node_ptr_type(c, + ZigClangQualType_isConstQualified(child_qt), + ZigClangQualType_isVolatileQualified(child_qt), + child_type_node, PtrLenC); return pointer_node; } - case clang::Type::BlockPointer: - case clang::Type::LValueReference: - case clang::Type::RValueReference: - case clang::Type::MemberPointer: - case clang::Type::VariableArray: - case clang::Type::DependentSizedArray: - case clang::Type::DependentSizedExtVector: - case clang::Type::Vector: - case clang::Type::ExtVector: - case clang::Type::UnresolvedUsing: - case clang::Type::Adjusted: - case clang::Type::TypeOfExpr: - case clang::Type::TypeOf: - case clang::Type::Decltype: - case clang::Type::UnaryTransform: - case clang::Type::TemplateTypeParm: - case clang::Type::SubstTemplateTypeParm: - case clang::Type::SubstTemplateTypeParmPack: - case clang::Type::TemplateSpecialization: - case clang::Type::Auto: - case clang::Type::InjectedClassName: - case clang::Type::DependentName: - case clang::Type::DependentTemplateSpecialization: - case clang::Type::PackExpansion: - case clang::Type::ObjCObject: - case clang::Type::ObjCInterface: - case clang::Type::Complex: - case clang::Type::ObjCObjectPointer: - case clang::Type::Atomic: - case clang::Type::Pipe: - case clang::Type::ObjCTypeParam: - case clang::Type::DeducedTemplateSpecialization: - case clang::Type::DependentAddressSpace: - case clang::Type::DependentVector: - emit_warning(c, source_loc, "unsupported type: '%s'", ty->getTypeClassName()); + case ZigClangType_BlockPointer: + case ZigClangType_LValueReference: + case ZigClangType_RValueReference: + case ZigClangType_MemberPointer: + case ZigClangType_VariableArray: + case ZigClangType_DependentSizedArray: + case ZigClangType_DependentSizedExtVector: + case ZigClangType_Vector: + case ZigClangType_ExtVector: + case ZigClangType_UnresolvedUsing: + case ZigClangType_Adjusted: + case ZigClangType_TypeOfExpr: + case ZigClangType_TypeOf: + case ZigClangType_Decltype: + case ZigClangType_UnaryTransform: + case ZigClangType_TemplateTypeParm: + case ZigClangType_SubstTemplateTypeParm: + case ZigClangType_SubstTemplateTypeParmPack: + case ZigClangType_TemplateSpecialization: + case ZigClangType_Auto: + case ZigClangType_InjectedClassName: + case ZigClangType_DependentName: + case ZigClangType_DependentTemplateSpecialization: + case ZigClangType_PackExpansion: + case ZigClangType_ObjCObject: + case ZigClangType_ObjCInterface: + case ZigClangType_Complex: + case ZigClangType_ObjCObjectPointer: + case ZigClangType_Atomic: + case ZigClangType_Pipe: + case ZigClangType_ObjCTypeParam: + case ZigClangType_DeducedTemplateSpecialization: + case ZigClangType_DependentAddressSpace: + case ZigClangType_DependentVector: + emit_warning(c, source_loc, "unsupported type: '%s'", ZigClangType_getTypeClassName(ty)); return nullptr; } zig_unreachable(); } -static AstNode *trans_qual_type(Context *c, clang::QualType qt, ZigClangSourceLocation source_loc) { - return trans_type(c, qt.getTypePtr(), source_loc); +static AstNode *trans_qual_type(Context *c, ZigClangQualType qt, ZigClangSourceLocation source_loc) { + return trans_type(c, ZigClangQualType_getTypePtr(qt), source_loc); } static int trans_compound_stmt_inline(Context *c, TransScope *scope, const clang::CompoundStmt *stmt, @@ -1300,7 +1296,7 @@ static AstNode *trans_constant_expr(Context *c, ResultUsed result_used, const cl emit_warning(c, bitcast(expr->getBeginLoc()), "invalid constant expression"); return nullptr; } - AstNode *node = trans_ap_value(c, &result.Val, expr->getType(), bitcast(expr->getBeginLoc())); + AstNode *node = trans_ap_value(c, &result.Val, bitcast(expr->getType()), bitcast(expr->getBeginLoc())); return maybe_suppress_result(c, result_used, node); } @@ -1410,7 +1406,7 @@ static AstNode *trans_create_assign(Context *c, ResultUsed result_used, TransSco } } -static AstNode *trans_create_shift_op(Context *c, TransScope *scope, clang::QualType result_type, +static AstNode *trans_create_shift_op(Context *c, TransScope *scope, ZigClangQualType result_type, clang::Expr *lhs_expr, BinOpType bin_op, clang::Expr *rhs_expr) { ZigClangSourceLocation rhs_location = bitcast(rhs_expr->getBeginLoc()); @@ -1440,12 +1436,12 @@ static AstNode *trans_binary_operator(Context *c, ResultUsed result_used, TransS return nullptr; case clang::BO_Mul: { AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), - qual_type_has_wrapping_overflow(c, stmt->getType()) ? BinOpTypeMultWrap : BinOpTypeMult, + qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())) ? BinOpTypeMultWrap : BinOpTypeMult, stmt->getRHS()); return maybe_suppress_result(c, result_used, node); } case clang::BO_Div: - if (qual_type_has_wrapping_overflow(c, stmt->getType())) { + if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType()))) { // unsigned/float division uses the operator AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeDiv, stmt->getRHS()); return maybe_suppress_result(c, result_used, node); @@ -1461,7 +1457,7 @@ static AstNode *trans_binary_operator(Context *c, ResultUsed result_used, TransS return maybe_suppress_result(c, result_used, fn_call); } case clang::BO_Rem: - if (qual_type_has_wrapping_overflow(c, stmt->getType())) { + if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType()))) { // unsigned/float division uses the operator AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeMod, stmt->getRHS()); return maybe_suppress_result(c, result_used, node); @@ -1478,22 +1474,22 @@ static AstNode *trans_binary_operator(Context *c, ResultUsed result_used, TransS } case clang::BO_Add: { AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), - qual_type_has_wrapping_overflow(c, stmt->getType()) ? BinOpTypeAddWrap : BinOpTypeAdd, + qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())) ? BinOpTypeAddWrap : BinOpTypeAdd, stmt->getRHS()); return maybe_suppress_result(c, result_used, node); } case clang::BO_Sub: { AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), - qual_type_has_wrapping_overflow(c, stmt->getType()) ? BinOpTypeSubWrap : BinOpTypeSub, + qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())) ? BinOpTypeSubWrap : BinOpTypeSub, stmt->getRHS()); return maybe_suppress_result(c, result_used, node); } case clang::BO_Shl: { - AstNode *node = trans_create_shift_op(c, scope, stmt->getType(), stmt->getLHS(), BinOpTypeBitShiftLeft, stmt->getRHS()); + AstNode *node = trans_create_shift_op(c, scope, bitcast(stmt->getType()), stmt->getLHS(), BinOpTypeBitShiftLeft, stmt->getRHS()); return maybe_suppress_result(c, result_used, node); } case clang::BO_Shr: { - AstNode *node = trans_create_shift_op(c, scope, stmt->getType(), stmt->getLHS(), BinOpTypeBitShiftRight, stmt->getRHS()); + AstNode *node = trans_create_shift_op(c, scope, bitcast(stmt->getType()), stmt->getLHS(), BinOpTypeBitShiftRight, stmt->getRHS()); return maybe_suppress_result(c, result_used, node); } case clang::BO_LT: { @@ -1581,7 +1577,7 @@ static AstNode *trans_create_compound_assign_shift(Context *c, ResultUsed result const clang::CompoundAssignOperator *stmt, BinOpType assign_op, BinOpType bin_op) { ZigClangSourceLocation rhs_location = bitcast(stmt->getRHS()->getBeginLoc()); - AstNode *rhs_type = qual_type_to_log2_int_ref(c, stmt->getComputationLHSType(), rhs_location); + AstNode *rhs_type = qual_type_to_log2_int_ref(c, bitcast(stmt->getComputationLHSType()), rhs_location); bool use_intermediate_casts = stmt->getComputationLHSType().getTypePtr() != stmt->getComputationResultType().getTypePtr(); if (!use_intermediate_casts && result_used == ResultUsedNo) { @@ -1626,14 +1622,14 @@ static AstNode *trans_create_compound_assign_shift(Context *c, ResultUsed result // operation_type(*_ref) AstNode *operation_type_cast = trans_c_cast(c, rhs_location, - stmt->getComputationLHSType(), - stmt->getLHS()->getType(), + bitcast(stmt->getComputationLHSType()), + bitcast(stmt->getLHS()->getType()), trans_create_node_ptr_deref(c, trans_create_node_symbol(c, tmp_var_name))); // result_type(... >> u5(rhs)) AstNode *result_type_cast = trans_c_cast(c, rhs_location, - stmt->getComputationResultType(), - stmt->getComputationLHSType(), + bitcast(stmt->getComputationResultType()), + bitcast(stmt->getComputationLHSType()), trans_create_node_bin_op(c, operation_type_cast, bin_op, @@ -1724,7 +1720,7 @@ static AstNode *trans_compound_assign_operator(Context *c, ResultUsed result_use { switch (stmt->getOpcode()) { case clang::BO_MulAssign: - if (qual_type_has_wrapping_overflow(c, stmt->getType())) + if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType()))) return trans_create_compound_assign(c, result_used, scope, stmt, BinOpTypeAssignTimesWrap, BinOpTypeMultWrap); else return trans_create_compound_assign(c, result_used, scope, stmt, BinOpTypeAssignTimes, BinOpTypeMult); @@ -1738,12 +1734,12 @@ static AstNode *trans_compound_assign_operator(Context *c, ResultUsed result_use emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle more C compound assign operators: BO_Cmp"); return nullptr; case clang::BO_AddAssign: - if (qual_type_has_wrapping_overflow(c, stmt->getType())) + if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType()))) return trans_create_compound_assign(c, result_used, scope, stmt, BinOpTypeAssignPlusWrap, BinOpTypeAddWrap); else return trans_create_compound_assign(c, result_used, scope, stmt, BinOpTypeAssignPlus, BinOpTypeAdd); case clang::BO_SubAssign: - if (qual_type_has_wrapping_overflow(c, stmt->getType())) + if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType()))) return trans_create_compound_assign(c, result_used, scope, stmt, BinOpTypeAssignMinusWrap, BinOpTypeSubWrap); else return trans_create_compound_assign(c, result_used, scope, stmt, BinOpTypeAssignMinus, BinOpTypeSub); @@ -1794,8 +1790,8 @@ static AstNode *trans_implicit_cast_expr(Context *c, ResultUsed result_used, Tra AstNode *target_node = trans_expr(c, ResultUsedYes, scope, stmt->getSubExpr(), TransRValue); if (target_node == nullptr) return nullptr; - AstNode *node = trans_c_cast(c, bitcast(stmt->getExprLoc()), stmt->getType(), - stmt->getSubExpr()->getType(), target_node); + AstNode *node = trans_c_cast(c, bitcast(stmt->getExprLoc()), bitcast(stmt->getType()), + bitcast(stmt->getSubExpr()->getType()), target_node); return maybe_suppress_result(c, result_used, node); } case clang::CK_FunctionToPointerDecay: @@ -2106,22 +2102,22 @@ static AstNode *trans_create_pre_crement(Context *c, ResultUsed result_used, Tra static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransScope *scope, const clang::UnaryOperator *stmt) { switch (stmt->getOpcode()) { case clang::UO_PostInc: - if (qual_type_has_wrapping_overflow(c, stmt->getType())) + if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType()))) return trans_create_post_crement(c, result_used, scope, stmt, BinOpTypeAssignPlusWrap); else return trans_create_post_crement(c, result_used, scope, stmt, BinOpTypeAssignPlus); case clang::UO_PostDec: - if (qual_type_has_wrapping_overflow(c, stmt->getType())) + if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType()))) return trans_create_post_crement(c, result_used, scope, stmt, BinOpTypeAssignMinusWrap); else return trans_create_post_crement(c, result_used, scope, stmt, BinOpTypeAssignMinus); case clang::UO_PreInc: - if (qual_type_has_wrapping_overflow(c, stmt->getType())) + if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType()))) return trans_create_pre_crement(c, result_used, scope, stmt, BinOpTypeAssignPlusWrap); else return trans_create_pre_crement(c, result_used, scope, stmt, BinOpTypeAssignPlus); case clang::UO_PreDec: - if (qual_type_has_wrapping_overflow(c, stmt->getType())) + if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType()))) return trans_create_pre_crement(c, result_used, scope, stmt, BinOpTypeAssignMinusWrap); else return trans_create_pre_crement(c, result_used, scope, stmt, BinOpTypeAssignMinus); @@ -2137,7 +2133,7 @@ static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransSc AstNode *value_node = trans_expr(c, result_used, scope, stmt->getSubExpr(), TransRValue); if (value_node == nullptr) return nullptr; - bool is_fn_ptr = qual_type_is_fn_ptr(stmt->getSubExpr()->getType()); + bool is_fn_ptr = qual_type_is_fn_ptr(bitcast(stmt->getSubExpr()->getType())); if (is_fn_ptr) return value_node; AstNode *unwrapped = trans_create_node_unwrap_null(c, value_node); @@ -2149,7 +2145,7 @@ static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransSc case clang::UO_Minus: { clang::Expr *op_expr = stmt->getSubExpr(); - if (!qual_type_has_wrapping_overflow(c, op_expr->getType())) { + if (!qual_type_has_wrapping_overflow(c, bitcast(op_expr->getType()))) { AstNode *node = trans_create_node(c, NodeTypePrefixOpExpr); node->data.prefix_op_expr.prefix_op = PrefixOpNegation; @@ -2158,7 +2154,7 @@ static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransSc return nullptr; return node; - } else if (c_is_unsigned_integer(c, op_expr->getType())) { + } else if (c_is_unsigned_integer(c, bitcast(op_expr->getType()))) { // we gotta emit 0 -% x AstNode *node = trans_create_node(c, NodeTypeBinOpExpr); node->data.bin_op_expr.op1 = trans_create_node_unsigned(c, 0); @@ -2221,7 +2217,7 @@ static int trans_local_declaration(Context *c, TransScope *scope, const clang::D switch (decl->getKind()) { case clang::Decl::Var: { clang::VarDecl *var_decl = (clang::VarDecl *)decl; - clang::QualType qual_type = var_decl->getTypeSourceInfo()->getType(); + ZigClangQualType qual_type = bitcast(var_decl->getTypeSourceInfo()->getType()); AstNode *init_node = nullptr; if (var_decl->hasInit()) { init_node = trans_expr(c, ResultUsedYes, scope, var_decl->getInit(), TransRValue); @@ -2240,7 +2236,8 @@ static int trans_local_declaration(Context *c, TransScope *scope, const clang::D TransScopeVar *var_scope = trans_scope_var_create(c, scope, c_symbol_name); scope = &var_scope->base; - AstNode *node = trans_create_node_var_decl_local(c, qual_type.isConstQualified(), + AstNode *node = trans_create_node_var_decl_local(c, + ZigClangQualType_isConstQualified(qual_type), var_scope->zig_name, type_node, init_node); scope_block->node->data.block.statements.append(node); @@ -2526,12 +2523,12 @@ static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope * } - const clang::Type *ty = get_expr_qual_type_before_implicit_cast(c, expr).getTypePtr(); - auto classs = ty->getTypeClass(); + const ZigClangType *ty = ZigClangQualType_getTypePtr(get_expr_qual_type_before_implicit_cast(c, expr)); + auto classs = ZigClangType_getTypeClass(ty); switch (classs) { - case clang::Type::Builtin: + case ZigClangType_Builtin: { - const clang::BuiltinType *builtin_ty = static_cast(ty); + const clang::BuiltinType *builtin_ty = reinterpret_cast(ty); switch (builtin_ty->getKind()) { case clang::BuiltinType::Bool: case clang::BuiltinType::Char_U: @@ -2657,11 +2654,11 @@ static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope * } break; } - case clang::Type::Pointer: + case ZigClangType_Pointer: return trans_create_node_bin_op(c, res, BinOpTypeCmpNotEq, trans_create_node_unsigned(c, 0)); - case clang::Type::Typedef: + case ZigClangType_Typedef: { const ZigClangTypedefType *typedef_ty = reinterpret_cast(ty); const ZigClangTypedefNameDecl *typedef_decl = ZigClangTypedefType_getDecl(typedef_ty); @@ -2673,19 +2670,20 @@ static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope * return res; } - case clang::Type::Enum: + case ZigClangType_Enum: { const ZigClangEnumType *enum_ty = reinterpret_cast(ty); AstNode *enum_type = resolve_enum_decl(c, ZigClangEnumType_getDecl(enum_ty)); return to_enum_zero_cmp(c, res, enum_type); } - case clang::Type::Elaborated: + case ZigClangType_Elaborated: { - const clang::ElaboratedType *elaborated_ty = static_cast(ty); + const clang::ElaboratedType *elaborated_ty = reinterpret_cast(ty); switch (elaborated_ty->getKeyword()) { case clang::ETK_Enum: { - AstNode *enum_type = trans_qual_type(c, elaborated_ty->getNamedType(), bitcast(expr->getBeginLoc())); + AstNode *enum_type = trans_qual_type(c, bitcast(elaborated_ty->getNamedType()), + bitcast(expr->getBeginLoc())); return to_enum_zero_cmp(c, res, enum_type); } case clang::ETK_Struct: @@ -2698,48 +2696,48 @@ static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope * } } - case clang::Type::FunctionProto: - case clang::Type::Record: - case clang::Type::ConstantArray: - case clang::Type::Paren: - case clang::Type::Decayed: - case clang::Type::Attributed: - case clang::Type::IncompleteArray: - case clang::Type::BlockPointer: - case clang::Type::LValueReference: - case clang::Type::RValueReference: - case clang::Type::MemberPointer: - case clang::Type::VariableArray: - case clang::Type::DependentSizedArray: - case clang::Type::DependentSizedExtVector: - case clang::Type::Vector: - case clang::Type::ExtVector: - case clang::Type::FunctionNoProto: - case clang::Type::UnresolvedUsing: - case clang::Type::Adjusted: - case clang::Type::TypeOfExpr: - case clang::Type::TypeOf: - case clang::Type::Decltype: - case clang::Type::UnaryTransform: - case clang::Type::TemplateTypeParm: - case clang::Type::SubstTemplateTypeParm: - case clang::Type::SubstTemplateTypeParmPack: - case clang::Type::TemplateSpecialization: - case clang::Type::Auto: - case clang::Type::InjectedClassName: - case clang::Type::DependentName: - case clang::Type::DependentTemplateSpecialization: - case clang::Type::PackExpansion: - case clang::Type::ObjCObject: - case clang::Type::ObjCInterface: - case clang::Type::Complex: - case clang::Type::ObjCObjectPointer: - case clang::Type::Atomic: - case clang::Type::Pipe: - case clang::Type::ObjCTypeParam: - case clang::Type::DeducedTemplateSpecialization: - case clang::Type::DependentAddressSpace: - case clang::Type::DependentVector: + case ZigClangType_FunctionProto: + case ZigClangType_Record: + case ZigClangType_ConstantArray: + case ZigClangType_Paren: + case ZigClangType_Decayed: + case ZigClangType_Attributed: + case ZigClangType_IncompleteArray: + case ZigClangType_BlockPointer: + case ZigClangType_LValueReference: + case ZigClangType_RValueReference: + case ZigClangType_MemberPointer: + case ZigClangType_VariableArray: + case ZigClangType_DependentSizedArray: + case ZigClangType_DependentSizedExtVector: + case ZigClangType_Vector: + case ZigClangType_ExtVector: + case ZigClangType_FunctionNoProto: + case ZigClangType_UnresolvedUsing: + case ZigClangType_Adjusted: + case ZigClangType_TypeOfExpr: + case ZigClangType_TypeOf: + case ZigClangType_Decltype: + case ZigClangType_UnaryTransform: + case ZigClangType_TemplateTypeParm: + case ZigClangType_SubstTemplateTypeParm: + case ZigClangType_SubstTemplateTypeParmPack: + case ZigClangType_TemplateSpecialization: + case ZigClangType_Auto: + case ZigClangType_InjectedClassName: + case ZigClangType_DependentName: + case ZigClangType_DependentTemplateSpecialization: + case ZigClangType_PackExpansion: + case ZigClangType_ObjCObject: + case ZigClangType_ObjCInterface: + case ZigClangType_Complex: + case ZigClangType_ObjCObjectPointer: + case ZigClangType_Atomic: + case ZigClangType_Pipe: + case ZigClangType_ObjCTypeParam: + case ZigClangType_DeducedTemplateSpecialization: + case ZigClangType_DependentAddressSpace: + case ZigClangType_DependentVector: return res; } zig_unreachable(); @@ -2790,7 +2788,7 @@ static AstNode *trans_call_expr(Context *c, ResultUsed result_used, TransScope * return nullptr; bool is_ptr = false; - const clang::FunctionProtoType *fn_ty = qual_type_get_fn_proto(stmt->getCallee()->getType(), &is_ptr); + const clang::FunctionProtoType *fn_ty = qual_type_get_fn_proto(bitcast(stmt->getCallee()->getType()), &is_ptr); AstNode *callee_node = nullptr; if (is_ptr && fn_ty) { if (stmt->getCallee()->getStmtClass() == clang::Stmt::ImplicitCastExprClass) { @@ -2824,7 +2822,9 @@ static AstNode *trans_call_expr(Context *c, ResultUsed result_used, TransScope * node->data.fn_call_expr.params.append(arg_node); } - if (result_used == ResultUsedNo && fn_ty && !qual_type_canon(fn_ty->getReturnType())->isVoidType()) { + if (result_used == ResultUsedNo && fn_ty && + !ZigClangType_isVoidType(qual_type_canon(bitcast(fn_ty->getReturnType())))) + { node = trans_create_node_bin_op(c, trans_create_node_symbol_str(c, "_"), BinOpTypeAssign, node); } @@ -2871,7 +2871,8 @@ static AstNode *trans_c_style_cast_expr(Context *c, ResultUsed result_used, Tran if (sub_expr_node == nullptr) return nullptr; - AstNode *cast = trans_c_cast(c, bitcast(stmt->getBeginLoc()), stmt->getType(), stmt->getSubExpr()->getType(), sub_expr_node); + AstNode *cast = trans_c_cast(c, bitcast(stmt->getBeginLoc()), bitcast(stmt->getType()), + bitcast(stmt->getSubExpr()->getType()), sub_expr_node); if (cast == nullptr) return nullptr; @@ -2881,7 +2882,7 @@ static AstNode *trans_c_style_cast_expr(Context *c, ResultUsed result_used, Tran static AstNode *trans_unary_expr_or_type_trait_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::UnaryExprOrTypeTraitExpr *stmt) { - AstNode *type_node = trans_qual_type(c, stmt->getTypeOfArgument(), bitcast(stmt->getBeginLoc())); + AstNode *type_node = trans_qual_type(c, bitcast(stmt->getTypeOfArgument()), bitcast(stmt->getBeginLoc())); if (type_node == nullptr) return nullptr; @@ -3858,7 +3859,7 @@ static void visit_fn_decl(Context *c, const clang::FunctionDecl *fn_decl) { return; } - AstNode *proto_node = trans_qual_type(c, fn_decl->getType(), bitcast(fn_decl->getLocation())); + AstNode *proto_node = trans_qual_type(c, bitcast(fn_decl->getType()), bitcast(fn_decl->getLocation())); if (proto_node == nullptr) { emit_warning(c, bitcast(fn_decl->getLocation()), "unable to resolve prototype of function '%s'", buf_ptr(fn_name)); return; @@ -4003,7 +4004,7 @@ static AstNode *resolve_typedef_decl(Context *c, const ZigClangTypedefNameDecl * AstNode *symbol_node = trans_create_node_symbol(c, type_name); c->decl_table.put(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl), symbol_node); - AstNode *type_node = trans_qual_type(c, bitcast(child_qt), ZigClangTypedefNameDecl_getLocation(typedef_decl)); + AstNode *type_node = trans_qual_type(c, child_qt, ZigClangTypedefNameDecl_getLocation(typedef_decl)); if (type_node == nullptr) { emit_warning(c, ZigClangTypedefNameDecl_getLocation(typedef_decl), "typedef %s - unresolved child type", buf_ptr(type_name)); @@ -4059,8 +4060,7 @@ static AstNode *resolve_enum_decl(Context *c, const ZigClangEnumDecl *enum_decl) pure_enum = false; } } - AstNode *tag_int_type = trans_qual_type(c, - bitcast(ZigClangEnumDecl_getIntegerType(enum_decl)), + AstNode *tag_int_type = trans_qual_type(c, ZigClangEnumDecl_getIntegerType(enum_decl), ZigClangEnumDecl_getLocation(enum_decl)); assert(tag_int_type); @@ -4070,8 +4070,8 @@ static AstNode *resolve_enum_decl(Context *c, const ZigClangEnumDecl *enum_decl) // TODO only emit this tag type if the enum tag type is not the default. // I don't know what the default is, need to figure out how clang is deciding. // it appears to at least be different across gcc/msvc - if (!c_is_builtin_type(c, bitcast(ZigClangEnumDecl_getIntegerType(enum_decl)), clang::BuiltinType::UInt) && - !c_is_builtin_type(c, bitcast(ZigClangEnumDecl_getIntegerType(enum_decl)), clang::BuiltinType::Int)) + if (!c_is_builtin_type(c, ZigClangEnumDecl_getIntegerType(enum_decl), clang::BuiltinType::UInt) && + !c_is_builtin_type(c, ZigClangEnumDecl_getIntegerType(enum_decl), clang::BuiltinType::Int)) { enum_node->data.container_decl.init_arg_expr = tag_int_type; } @@ -4209,7 +4209,7 @@ static AstNode *resolve_record_decl(Context *c, const ZigClangRecordDecl *record AstNode *field_node = trans_create_node(c, NodeTypeStructField); field_node->data.struct_field.name = buf_create_from_str(ZigClangDecl_getName_bytes_begin((const ZigClangDecl *)field_decl)); - field_node->data.struct_field.type = trans_qual_type(c, field_decl->getType(), + field_node->data.struct_field.type = trans_qual_type(c, bitcast(field_decl->getType()), bitcast(field_decl->getLocation())); if (field_node->data.struct_field.type == nullptr) { @@ -4233,7 +4233,7 @@ static AstNode *resolve_record_decl(Context *c, const ZigClangRecordDecl *record } } -static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, clang::QualType qt, ZigClangSourceLocation source_loc) { +static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, ZigClangQualType qt, ZigClangSourceLocation source_loc) { switch (ap_value->getKind()) { case clang::APValue::Int: return trans_create_node_apint(c, ap_value->getInt()); @@ -4253,7 +4253,8 @@ static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, clang::Qual init_node->data.container_init_expr.type = arr_type_node; init_node->data.container_init_expr.kind = ContainerInitKindArray; - clang::QualType child_qt = qt.getTypePtr()->getAsArrayTypeUnsafe()->getElementType(); + const clang::Type *qt_type = reinterpret_cast(ZigClangQualType_getTypePtr(qt)); + ZigClangQualType child_qt = bitcast(qt_type->getAsArrayTypeUnsafe()->getElementType()); for (size_t i = 0; i < init_count; i += 1) { clang::APValue &elem_ap_val = ap_value->getArrayInitializedElt(i); @@ -4347,7 +4348,7 @@ static void visit_var_decl(Context *c, const clang::VarDecl *var_decl) { return; } - clang::QualType qt = var_decl->getType(); + ZigClangQualType qt = bitcast(var_decl->getType()); AstNode *var_type = trans_qual_type(c, qt, bitcast(var_decl->getLocation())); if (var_type == nullptr) { emit_warning(c, bitcast(var_decl->getLocation()), "ignoring variable '%s' - unresolved type", buf_ptr(name)); @@ -4356,7 +4357,7 @@ static void visit_var_decl(Context *c, const clang::VarDecl *var_decl) { bool is_extern = var_decl->hasExternalStorage(); bool is_static = var_decl->isFileVarDecl(); - bool is_const = qt.isConstQualified(); + bool is_const = ZigClangQualType_isConstQualified(qt); if (is_static && !is_extern) { AstNode *init_node; diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp index 4f50c5d3d3..265a37d82a 100644 --- a/src/zig_clang.cpp +++ b/src/zig_clang.cpp @@ -28,41 +28,41 @@ #endif // Detect additions to the enum -void zig2clang_BO(ZigClangBO op) { +void zig2clang_BO(clang::BinaryOperatorKind op) { switch (op) { - case ZigClangBO_PtrMemD: - case ZigClangBO_PtrMemI: - case ZigClangBO_Cmp: - case ZigClangBO_Mul: - case ZigClangBO_Div: - case ZigClangBO_Rem: - case ZigClangBO_Add: - case ZigClangBO_Sub: - case ZigClangBO_Shl: - case ZigClangBO_Shr: - case ZigClangBO_LT: - case ZigClangBO_GT: - case ZigClangBO_LE: - case ZigClangBO_GE: - case ZigClangBO_EQ: - case ZigClangBO_NE: - case ZigClangBO_And: - case ZigClangBO_Xor: - case ZigClangBO_Or: - case ZigClangBO_LAnd: - case ZigClangBO_LOr: - case ZigClangBO_Assign: - case ZigClangBO_Comma: - case ZigClangBO_MulAssign: - case ZigClangBO_DivAssign: - case ZigClangBO_RemAssign: - case ZigClangBO_AddAssign: - case ZigClangBO_SubAssign: - case ZigClangBO_ShlAssign: - case ZigClangBO_ShrAssign: - case ZigClangBO_AndAssign: - case ZigClangBO_XorAssign: - case ZigClangBO_OrAssign: + case clang::BO_PtrMemD: + case clang::BO_PtrMemI: + case clang::BO_Cmp: + case clang::BO_Mul: + case clang::BO_Div: + case clang::BO_Rem: + case clang::BO_Add: + case clang::BO_Sub: + case clang::BO_Shl: + case clang::BO_Shr: + case clang::BO_LT: + case clang::BO_GT: + case clang::BO_LE: + case clang::BO_GE: + case clang::BO_EQ: + case clang::BO_NE: + case clang::BO_And: + case clang::BO_Xor: + case clang::BO_Or: + case clang::BO_LAnd: + case clang::BO_LOr: + case clang::BO_Assign: + case clang::BO_Comma: + case clang::BO_MulAssign: + case clang::BO_DivAssign: + case clang::BO_RemAssign: + case clang::BO_AddAssign: + case clang::BO_SubAssign: + case clang::BO_ShlAssign: + case clang::BO_ShrAssign: + case clang::BO_AndAssign: + case clang::BO_XorAssign: + case clang::BO_OrAssign: break; } } @@ -102,22 +102,22 @@ static_assert((clang::BinaryOperatorKind)ZigClangBO_Xor == clang::BO_Xor, ""); static_assert((clang::BinaryOperatorKind)ZigClangBO_XorAssign == clang::BO_XorAssign, ""); // This function detects additions to the enum -void zig2clang_UO(ZigClangUO op) { +void zig2clang_UO(clang::UnaryOperatorKind op) { switch (op) { - case ZigClangUO_AddrOf: - case ZigClangUO_Coawait: - case ZigClangUO_Deref: - case ZigClangUO_Extension: - case ZigClangUO_Imag: - case ZigClangUO_LNot: - case ZigClangUO_Minus: - case ZigClangUO_Not: - case ZigClangUO_Plus: - case ZigClangUO_PostDec: - case ZigClangUO_PostInc: - case ZigClangUO_PreDec: - case ZigClangUO_PreInc: - case ZigClangUO_Real: + case clang::UO_AddrOf: + case clang::UO_Coawait: + case clang::UO_Deref: + case clang::UO_Extension: + case clang::UO_Imag: + case clang::UO_LNot: + case clang::UO_Minus: + case clang::UO_Not: + case clang::UO_Plus: + case clang::UO_PostDec: + case clang::UO_PostInc: + case clang::UO_PreDec: + case clang::UO_PreInc: + case clang::UO_Real: break; } } @@ -137,6 +137,108 @@ static_assert((clang::UnaryOperatorKind)ZigClangUO_PreDec == clang::UO_PreDec, " static_assert((clang::UnaryOperatorKind)ZigClangUO_PreInc == clang::UO_PreInc, ""); static_assert((clang::UnaryOperatorKind)ZigClangUO_Real == clang::UO_Real, ""); +void zig2clang_TypeClass(clang::Type::TypeClass ty) { + switch (ty) { + case clang::Type::Builtin: + case clang::Type::Complex: + case clang::Type::Pointer: + case clang::Type::BlockPointer: + case clang::Type::LValueReference: + case clang::Type::RValueReference: + case clang::Type::MemberPointer: + case clang::Type::ConstantArray: + case clang::Type::IncompleteArray: + case clang::Type::VariableArray: + case clang::Type::DependentSizedArray: + case clang::Type::DependentSizedExtVector: + case clang::Type::DependentAddressSpace: + case clang::Type::Vector: + case clang::Type::DependentVector: + case clang::Type::ExtVector: + case clang::Type::FunctionProto: + case clang::Type::FunctionNoProto: + case clang::Type::UnresolvedUsing: + case clang::Type::Paren: + case clang::Type::Typedef: + case clang::Type::Adjusted: + case clang::Type::Decayed: + case clang::Type::TypeOfExpr: + case clang::Type::TypeOf: + case clang::Type::Decltype: + case clang::Type::UnaryTransform: + case clang::Type::Record: + case clang::Type::Enum: + case clang::Type::Elaborated: + case clang::Type::Attributed: + case clang::Type::TemplateTypeParm: + case clang::Type::SubstTemplateTypeParm: + case clang::Type::SubstTemplateTypeParmPack: + case clang::Type::TemplateSpecialization: + case clang::Type::Auto: + case clang::Type::DeducedTemplateSpecialization: + case clang::Type::InjectedClassName: + case clang::Type::DependentName: + case clang::Type::DependentTemplateSpecialization: + case clang::Type::PackExpansion: + case clang::Type::ObjCTypeParam: + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: + case clang::Type::ObjCObjectPointer: + case clang::Type::Pipe: + case clang::Type::Atomic: + break; + } +} + +static_assert((clang::Type::TypeClass)ZigClangType_Builtin == clang::Type::Builtin, ""); +static_assert((clang::Type::TypeClass)ZigClangType_Complex == clang::Type::Complex, ""); +static_assert((clang::Type::TypeClass)ZigClangType_Pointer == clang::Type::Pointer, ""); +static_assert((clang::Type::TypeClass)ZigClangType_BlockPointer == clang::Type::BlockPointer, ""); +static_assert((clang::Type::TypeClass)ZigClangType_LValueReference == clang::Type::LValueReference, ""); +static_assert((clang::Type::TypeClass)ZigClangType_RValueReference == clang::Type::RValueReference, ""); +static_assert((clang::Type::TypeClass)ZigClangType_MemberPointer == clang::Type::MemberPointer, ""); +static_assert((clang::Type::TypeClass)ZigClangType_ConstantArray == clang::Type::ConstantArray, ""); +static_assert((clang::Type::TypeClass)ZigClangType_IncompleteArray == clang::Type::IncompleteArray, ""); +static_assert((clang::Type::TypeClass)ZigClangType_VariableArray == clang::Type::VariableArray, ""); +static_assert((clang::Type::TypeClass)ZigClangType_DependentSizedArray == clang::Type::DependentSizedArray, ""); +static_assert((clang::Type::TypeClass)ZigClangType_DependentSizedExtVector == clang::Type::DependentSizedExtVector, ""); +static_assert((clang::Type::TypeClass)ZigClangType_DependentAddressSpace == clang::Type::DependentAddressSpace, ""); +static_assert((clang::Type::TypeClass)ZigClangType_Vector == clang::Type::Vector, ""); +static_assert((clang::Type::TypeClass)ZigClangType_DependentVector == clang::Type::DependentVector, ""); +static_assert((clang::Type::TypeClass)ZigClangType_ExtVector == clang::Type::ExtVector, ""); +static_assert((clang::Type::TypeClass)ZigClangType_FunctionProto == clang::Type::FunctionProto, ""); +static_assert((clang::Type::TypeClass)ZigClangType_FunctionNoProto == clang::Type::FunctionNoProto, ""); +static_assert((clang::Type::TypeClass)ZigClangType_UnresolvedUsing == clang::Type::UnresolvedUsing, ""); +static_assert((clang::Type::TypeClass)ZigClangType_Paren == clang::Type::Paren, ""); +static_assert((clang::Type::TypeClass)ZigClangType_Typedef == clang::Type::Typedef, ""); +static_assert((clang::Type::TypeClass)ZigClangType_Adjusted == clang::Type::Adjusted, ""); +static_assert((clang::Type::TypeClass)ZigClangType_Decayed == clang::Type::Decayed, ""); +static_assert((clang::Type::TypeClass)ZigClangType_TypeOfExpr == clang::Type::TypeOfExpr, ""); +static_assert((clang::Type::TypeClass)ZigClangType_TypeOf == clang::Type::TypeOf, ""); +static_assert((clang::Type::TypeClass)ZigClangType_Decltype == clang::Type::Decltype, ""); +static_assert((clang::Type::TypeClass)ZigClangType_UnaryTransform == clang::Type::UnaryTransform, ""); +static_assert((clang::Type::TypeClass)ZigClangType_Record == clang::Type::Record, ""); +static_assert((clang::Type::TypeClass)ZigClangType_Enum == clang::Type::Enum, ""); +static_assert((clang::Type::TypeClass)ZigClangType_Elaborated == clang::Type::Elaborated, ""); +static_assert((clang::Type::TypeClass)ZigClangType_Attributed == clang::Type::Attributed, ""); +static_assert((clang::Type::TypeClass)ZigClangType_TemplateTypeParm == clang::Type::TemplateTypeParm, ""); +static_assert((clang::Type::TypeClass)ZigClangType_SubstTemplateTypeParm == clang::Type::SubstTemplateTypeParm, ""); +static_assert((clang::Type::TypeClass)ZigClangType_SubstTemplateTypeParmPack == clang::Type::SubstTemplateTypeParmPack, ""); +static_assert((clang::Type::TypeClass)ZigClangType_TemplateSpecialization == clang::Type::TemplateSpecialization, ""); +static_assert((clang::Type::TypeClass)ZigClangType_Auto == clang::Type::Auto, ""); +static_assert((clang::Type::TypeClass)ZigClangType_DeducedTemplateSpecialization == clang::Type::DeducedTemplateSpecialization, ""); +static_assert((clang::Type::TypeClass)ZigClangType_InjectedClassName == clang::Type::InjectedClassName, ""); +static_assert((clang::Type::TypeClass)ZigClangType_DependentName == clang::Type::DependentName, ""); +static_assert((clang::Type::TypeClass)ZigClangType_DependentTemplateSpecialization == clang::Type::DependentTemplateSpecialization, ""); +static_assert((clang::Type::TypeClass)ZigClangType_PackExpansion == clang::Type::PackExpansion, ""); +static_assert((clang::Type::TypeClass)ZigClangType_ObjCTypeParam == clang::Type::ObjCTypeParam, ""); +static_assert((clang::Type::TypeClass)ZigClangType_ObjCObject == clang::Type::ObjCObject, ""); +static_assert((clang::Type::TypeClass)ZigClangType_ObjCInterface == clang::Type::ObjCInterface, ""); +static_assert((clang::Type::TypeClass)ZigClangType_ObjCObjectPointer == clang::Type::ObjCObjectPointer, ""); +static_assert((clang::Type::TypeClass)ZigClangType_Pipe == clang::Type::Pipe, ""); +static_assert((clang::Type::TypeClass)ZigClangType_Atomic == clang::Type::Atomic, ""); + + static_assert(sizeof(ZigClangSourceLocation) == sizeof(clang::SourceLocation), ""); static ZigClangSourceLocation bitcast(clang::SourceLocation src) { ZigClangSourceLocation dest; @@ -304,3 +406,65 @@ ZigClangQualType ZigClangTypedefNameDecl_getUnderlyingType(const ZigClangTypedef clang::QualType ty = casted->getUnderlyingType(); return bitcast(ty); } + +ZigClangQualType ZigClangQualType_getCanonicalType(ZigClangQualType self) { + clang::QualType qt = bitcast(self); + return bitcast(qt.getCanonicalType()); +} + +const ZigClangType *ZigClangQualType_getTypePtr(ZigClangQualType self) { + clang::QualType qt = bitcast(self); + const clang::Type *ty = qt.getTypePtr(); + return reinterpret_cast(ty); +} + +void ZigClangQualType_addConst(ZigClangQualType *self) { + reinterpret_cast(self)->addConst(); +} + +bool ZigClangQualType_eq(ZigClangQualType zig_t1, ZigClangQualType zig_t2) { + clang::QualType t1 = bitcast(zig_t1); + clang::QualType t2 = bitcast(zig_t2); + if (t1.isConstQualified() != t2.isConstQualified()) { + return false; + } + if (t1.isVolatileQualified() != t2.isVolatileQualified()) { + return false; + } + if (t1.isRestrictQualified() != t2.isRestrictQualified()) { + return false; + } + return t1.getTypePtr() == t2.getTypePtr(); +} + +bool ZigClangQualType_isConstQualified(ZigClangQualType self) { + clang::QualType qt = bitcast(self); + return qt.isConstQualified(); +} + +bool ZigClangQualType_isVolatileQualified(ZigClangQualType self) { + clang::QualType qt = bitcast(self); + return qt.isVolatileQualified(); +} + +bool ZigClangQualType_isRestrictQualified(ZigClangQualType self) { + clang::QualType qt = bitcast(self); + return qt.isRestrictQualified(); +} + +ZigClangTypeClass ZigClangType_getTypeClass(const ZigClangType *self) { + auto casted = reinterpret_cast(self); + clang::Type::TypeClass tc = casted->getTypeClass(); + return (ZigClangTypeClass)tc; +} + +bool ZigClangType_isVoidType(const ZigClangType *self) { + auto casted = reinterpret_cast(self); + return casted->isVoidType(); +} + +const char *ZigClangType_getTypeClassName(const ZigClangType *self) { + auto casted = reinterpret_cast(self); + return casted->getTypeClassName(); +} + diff --git a/src/zig_clang.h b/src/zig_clang.h index c534addf9e..1e96e9a8e7 100644 --- a/src/zig_clang.h +++ b/src/zig_clang.h @@ -150,6 +150,56 @@ enum ZigClangUO { ZigClangUO_Coawait, }; +enum ZigClangTypeClass { + ZigClangType_Builtin, + ZigClangType_Complex, + ZigClangType_Pointer, + ZigClangType_BlockPointer, + ZigClangType_LValueReference, + ZigClangType_RValueReference, + ZigClangType_MemberPointer, + ZigClangType_ConstantArray, + ZigClangType_IncompleteArray, + ZigClangType_VariableArray, + ZigClangType_DependentSizedArray, + ZigClangType_DependentSizedExtVector, + ZigClangType_DependentAddressSpace, + ZigClangType_Vector, + ZigClangType_DependentVector, + ZigClangType_ExtVector, + ZigClangType_FunctionProto, + ZigClangType_FunctionNoProto, + ZigClangType_UnresolvedUsing, + ZigClangType_Paren, + ZigClangType_Typedef, + ZigClangType_Adjusted, + ZigClangType_Decayed, + ZigClangType_TypeOfExpr, + ZigClangType_TypeOf, + ZigClangType_Decltype, + ZigClangType_UnaryTransform, + ZigClangType_Record, + ZigClangType_Enum, + ZigClangType_Elaborated, + ZigClangType_Attributed, + ZigClangType_TemplateTypeParm, + ZigClangType_SubstTemplateTypeParm, + ZigClangType_SubstTemplateTypeParmPack, + ZigClangType_TemplateSpecialization, + ZigClangType_Auto, + ZigClangType_DeducedTemplateSpecialization, + ZigClangType_InjectedClassName, + ZigClangType_DependentName, + ZigClangType_DependentTemplateSpecialization, + ZigClangType_PackExpansion, + ZigClangType_ObjCTypeParam, + ZigClangType_ObjCObject, + ZigClangType_ObjCInterface, + ZigClangType_ObjCObjectPointer, + ZigClangType_Pipe, + ZigClangType_Atomic, +}; + //struct ZigClangCC_AAPCS; //struct ZigClangCC_AAPCS_VFP; //struct ZigClangCC_C; @@ -285,4 +335,16 @@ ZIG_EXTERN_C bool ZigClangSourceLocation_eq(ZigClangSourceLocation a, ZigClangSo ZIG_EXTERN_C const ZigClangTypedefNameDecl *ZigClangTypedefType_getDecl(const ZigClangTypedefType *); ZIG_EXTERN_C ZigClangQualType ZigClangTypedefNameDecl_getUnderlyingType(const ZigClangTypedefNameDecl *); + +ZIG_EXTERN_C ZigClangQualType ZigClangQualType_getCanonicalType(ZigClangQualType); +ZIG_EXTERN_C const ZigClangType *ZigClangQualType_getTypePtr(ZigClangQualType); +ZIG_EXTERN_C void ZigClangQualType_addConst(ZigClangQualType *); +ZIG_EXTERN_C bool ZigClangQualType_eq(ZigClangQualType, ZigClangQualType); +ZIG_EXTERN_C bool ZigClangQualType_isConstQualified(ZigClangQualType); +ZIG_EXTERN_C bool ZigClangQualType_isVolatileQualified(ZigClangQualType); +ZIG_EXTERN_C bool ZigClangQualType_isRestrictQualified(ZigClangQualType); + +ZIG_EXTERN_C ZigClangTypeClass ZigClangType_getTypeClass(const ZigClangType *self); +ZIG_EXTERN_C bool ZigClangType_isVoidType(const ZigClangType *self); +ZIG_EXTERN_C const char *ZigClangType_getTypeClassName(const ZigClangType *self); #endif -- cgit v1.2.3 From 6284a4c534771797406ceb945e5b7985d591d62b Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Fri, 12 Apr 2019 03:56:38 -0400 Subject: translate-c: move some code to the C API See #1964 --- src/translate_c.cpp | 412 ++++++++++++++++++++++++++-------------------------- src/zig_clang.cpp | 405 ++++++++++++++++++++++++++++++++++++++++++++++++++- src/zig_clang.h | 200 +++++++++++++++++++++++++ 3 files changed, 810 insertions(+), 207 deletions(-) (limited to 'src/zig_clang.cpp') diff --git a/src/translate_c.cpp b/src/translate_c.cpp index 84770844b7..006b4e330f 100644 --- a/src/translate_c.cpp +++ b/src/translate_c.cpp @@ -509,11 +509,11 @@ static const ZigClangType *qual_type_canon(ZigClangQualType qt) { static ZigClangQualType get_expr_qual_type(Context *c, const clang::Expr *expr) { // String literals in C are `char *` but they should really be `const char *`. - if (expr->getStmtClass() == clang::Stmt::ImplicitCastExprClass) { + if ((ZigClangStmtClass)expr->getStmtClass() == ZigClangStmt_ImplicitCastExprClass) { const clang::ImplicitCastExpr *cast_expr = static_cast(expr); if (cast_expr->getCastKind() == clang::CK_ArrayToPointerDecay) { const clang::Expr *sub_expr = cast_expr->getSubExpr(); - if (sub_expr->getStmtClass() == clang::Stmt::StringLiteralClass) { + if ((ZigClangStmtClass)sub_expr->getStmtClass() == ZigClangStmt_StringLiteralClass) { ZigClangQualType array_qt = bitcast(sub_expr->getType()); const clang::ArrayType *array_type = reinterpret_cast( ZigClangQualType_getTypePtr(array_qt)); @@ -527,7 +527,7 @@ static ZigClangQualType get_expr_qual_type(Context *c, const clang::Expr *expr) } static ZigClangQualType get_expr_qual_type_before_implicit_cast(Context *c, const clang::Expr *expr) { - if (expr->getStmtClass() == clang::Stmt::ImplicitCastExprClass) { + if ((ZigClangStmtClass)expr->getStmtClass() == ZigClangStmt_ImplicitCastExprClass) { const clang::ImplicitCastExpr *cast_expr = static_cast(expr); return get_expr_qual_type(c, cast_expr->getSubExpr()); } @@ -2791,10 +2791,10 @@ static AstNode *trans_call_expr(Context *c, ResultUsed result_used, TransScope * const clang::FunctionProtoType *fn_ty = qual_type_get_fn_proto(bitcast(stmt->getCallee()->getType()), &is_ptr); AstNode *callee_node = nullptr; if (is_ptr && fn_ty) { - if (stmt->getCallee()->getStmtClass() == clang::Stmt::ImplicitCastExprClass) { + if ((ZigClangStmtClass)stmt->getCallee()->getStmtClass() == ZigClangStmt_ImplicitCastExprClass) { const clang::ImplicitCastExpr *implicit_cast = static_cast(stmt->getCallee()); if (implicit_cast->getCastKind() == clang::CK_FunctionToPointerDecay) { - if (implicit_cast->getSubExpr()->getStmtClass() == clang::Stmt::DeclRefExprClass) { + if ((ZigClangStmtClass)implicit_cast->getSubExpr()->getStmtClass() == ZigClangStmt_DeclRefExprClass) { const clang::DeclRefExpr *decl_ref = static_cast(implicit_cast->getSubExpr()); const clang::Decl *decl = decl_ref->getFoundDecl(); if (decl->getKind() == clang::Decl::Function) { @@ -2898,7 +2898,7 @@ static AstNode *trans_do_loop(Context *c, TransScope *parent_scope, const clang: AstNode *body_node; TransScope *child_scope; - if (stmt->getBody()->getStmtClass() == clang::Stmt::CompoundStmtClass) { + if ((ZigClangStmtClass)stmt->getBody()->getStmtClass() == ZigClangStmt_CompoundStmtClass) { // there's already a block in C, so we'll append our condition to it. // c: do { // c: a; @@ -3051,7 +3051,7 @@ static AstNode *trans_switch_stmt(Context *c, TransScope *parent_scope, const cl AstNode *body_node; const clang::Stmt *body_stmt = stmt->getBody(); - if (body_stmt->getStmtClass() == clang::Stmt::CompoundStmtClass) { + if ((ZigClangStmtClass)body_stmt->getStmtClass() == ZigClangStmt_CompoundStmtClass) { if (trans_compound_stmt_inline(c, &switch_scope->base, (const clang::CompoundStmt *)body_stmt, block_scope->node, nullptr)) { @@ -3224,40 +3224,40 @@ static int trans_stmt_extra(Context *c, TransScope *scope, const clang::Stmt *st AstNode **out_node, TransScope **out_child_scope, TransScope **out_node_scope) { - clang::Stmt::StmtClass sc = stmt->getStmtClass(); + ZigClangStmtClass sc = (ZigClangStmtClass)stmt->getStmtClass(); switch (sc) { - case clang::Stmt::ReturnStmtClass: + case ZigClangStmt_ReturnStmtClass: return wrap_stmt(out_node, out_child_scope, scope, trans_return_stmt(c, scope, (const clang::ReturnStmt *)stmt)); - case clang::Stmt::CompoundStmtClass: + case ZigClangStmt_CompoundStmtClass: return wrap_stmt(out_node, out_child_scope, scope, trans_compound_stmt(c, scope, (const clang::CompoundStmt *)stmt, out_node_scope)); - case clang::Stmt::IntegerLiteralClass: + case ZigClangStmt_IntegerLiteralClass: return wrap_stmt(out_node, out_child_scope, scope, trans_integer_literal(c, result_used, (const clang::IntegerLiteral *)stmt)); - case clang::Stmt::ConditionalOperatorClass: + case ZigClangStmt_ConditionalOperatorClass: return wrap_stmt(out_node, out_child_scope, scope, trans_conditional_operator(c, result_used, scope, (const clang::ConditionalOperator *)stmt)); - case clang::Stmt::BinaryOperatorClass: + case ZigClangStmt_BinaryOperatorClass: return wrap_stmt(out_node, out_child_scope, scope, trans_binary_operator(c, result_used, scope, (const clang::BinaryOperator *)stmt)); - case clang::Stmt::CompoundAssignOperatorClass: + case ZigClangStmt_CompoundAssignOperatorClass: return wrap_stmt(out_node, out_child_scope, scope, trans_compound_assign_operator(c, result_used, scope, (const clang::CompoundAssignOperator *)stmt)); - case clang::Stmt::ImplicitCastExprClass: + case ZigClangStmt_ImplicitCastExprClass: return wrap_stmt(out_node, out_child_scope, scope, trans_implicit_cast_expr(c, result_used, scope, (const clang::ImplicitCastExpr *)stmt)); - case clang::Stmt::DeclRefExprClass: + case ZigClangStmt_DeclRefExprClass: return wrap_stmt(out_node, out_child_scope, scope, trans_decl_ref_expr(c, scope, (const clang::DeclRefExpr *)stmt, lrvalue)); - case clang::Stmt::UnaryOperatorClass: + case ZigClangStmt_UnaryOperatorClass: return wrap_stmt(out_node, out_child_scope, scope, trans_unary_operator(c, result_used, scope, (const clang::UnaryOperator *)stmt)); - case clang::Stmt::DeclStmtClass: + case ZigClangStmt_DeclStmtClass: return trans_local_declaration(c, scope, (const clang::DeclStmt *)stmt, out_node, out_child_scope); - case clang::Stmt::DoStmtClass: - case clang::Stmt::WhileStmtClass: { - AstNode *while_node = sc == clang::Stmt::DoStmtClass + case ZigClangStmt_DoStmtClass: + case ZigClangStmt_WhileStmtClass: { + AstNode *while_node = sc == ZigClangStmt_DoStmtClass ? trans_do_loop(c, scope, (const clang::DoStmt *)stmt) : trans_while_loop(c, scope, (const clang::WhileStmt *)stmt); @@ -3270,559 +3270,559 @@ static int trans_stmt_extra(Context *c, TransScope *scope, const clang::Stmt *st return wrap_stmt(out_node, out_child_scope, scope, while_node); } - case clang::Stmt::IfStmtClass: + case ZigClangStmt_IfStmtClass: return wrap_stmt(out_node, out_child_scope, scope, trans_if_statement(c, scope, (const clang::IfStmt *)stmt)); - case clang::Stmt::CallExprClass: + case ZigClangStmt_CallExprClass: return wrap_stmt(out_node, out_child_scope, scope, trans_call_expr(c, result_used, scope, (const clang::CallExpr *)stmt)); - case clang::Stmt::NullStmtClass: + case ZigClangStmt_NullStmtClass: *out_node = trans_create_node(c, NodeTypeBlock); *out_child_scope = scope; return ErrorNone; - case clang::Stmt::MemberExprClass: + case ZigClangStmt_MemberExprClass: return wrap_stmt(out_node, out_child_scope, scope, trans_member_expr(c, result_used, scope, (const clang::MemberExpr *)stmt)); - case clang::Stmt::ArraySubscriptExprClass: + case ZigClangStmt_ArraySubscriptExprClass: return wrap_stmt(out_node, out_child_scope, scope, trans_array_subscript_expr(c, result_used, scope, (const clang::ArraySubscriptExpr *)stmt)); - case clang::Stmt::CStyleCastExprClass: + case ZigClangStmt_CStyleCastExprClass: return wrap_stmt(out_node, out_child_scope, scope, trans_c_style_cast_expr(c, result_used, scope, (const clang::CStyleCastExpr *)stmt, lrvalue)); - case clang::Stmt::UnaryExprOrTypeTraitExprClass: + case ZigClangStmt_UnaryExprOrTypeTraitExprClass: return wrap_stmt(out_node, out_child_scope, scope, trans_unary_expr_or_type_trait_expr(c, result_used, scope, (const clang::UnaryExprOrTypeTraitExpr *)stmt)); - case clang::Stmt::ForStmtClass: { + case ZigClangStmt_ForStmtClass: { AstNode *node = trans_for_loop(c, scope, (const clang::ForStmt *)stmt); return wrap_stmt(out_node, out_child_scope, scope, node); } - case clang::Stmt::StringLiteralClass: + case ZigClangStmt_StringLiteralClass: return wrap_stmt(out_node, out_child_scope, scope, trans_string_literal(c, result_used, scope, (const clang::StringLiteral *)stmt)); - case clang::Stmt::BreakStmtClass: + case ZigClangStmt_BreakStmtClass: return wrap_stmt(out_node, out_child_scope, scope, trans_break_stmt(c, scope, (const clang::BreakStmt *)stmt)); - case clang::Stmt::ContinueStmtClass: + case ZigClangStmt_ContinueStmtClass: return wrap_stmt(out_node, out_child_scope, scope, trans_continue_stmt(c, scope, (const clang::ContinueStmt *)stmt)); - case clang::Stmt::ParenExprClass: + case ZigClangStmt_ParenExprClass: return wrap_stmt(out_node, out_child_scope, scope, trans_expr(c, result_used, scope, ((const clang::ParenExpr*)stmt)->getSubExpr(), lrvalue)); - case clang::Stmt::SwitchStmtClass: + case ZigClangStmt_SwitchStmtClass: return wrap_stmt(out_node, out_child_scope, scope, trans_switch_stmt(c, scope, (const clang::SwitchStmt *)stmt)); - case clang::Stmt::CaseStmtClass: + case ZigClangStmt_CaseStmtClass: return trans_switch_case(c, scope, (const clang::CaseStmt *)stmt, out_node, out_child_scope); - case clang::Stmt::DefaultStmtClass: + case ZigClangStmt_DefaultStmtClass: return trans_switch_default(c, scope, (const clang::DefaultStmt *)stmt, out_node, out_child_scope); - case clang::Stmt::ConstantExprClass: + case ZigClangStmt_ConstantExprClass: return wrap_stmt(out_node, out_child_scope, scope, trans_constant_expr(c, result_used, (const clang::ConstantExpr *)stmt)); - case clang::Stmt::PredefinedExprClass: + case ZigClangStmt_PredefinedExprClass: return wrap_stmt(out_node, out_child_scope, scope, trans_predefined_expr(c, result_used, scope, (const clang::PredefinedExpr *)stmt)); - case clang::Stmt::StmtExprClass: + case ZigClangStmt_StmtExprClass: return wrap_stmt(out_node, out_child_scope, scope, trans_stmt_expr(c, result_used, scope, (const clang::StmtExpr *)stmt, out_node_scope)); - case clang::Stmt::NoStmtClass: + case ZigClangStmt_NoStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C NoStmtClass"); return ErrorUnexpected; - case clang::Stmt::GCCAsmStmtClass: + case ZigClangStmt_GCCAsmStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C GCCAsmStmtClass"); return ErrorUnexpected; - case clang::Stmt::MSAsmStmtClass: + case ZigClangStmt_MSAsmStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C MSAsmStmtClass"); return ErrorUnexpected; - case clang::Stmt::AttributedStmtClass: + case ZigClangStmt_AttributedStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C AttributedStmtClass"); return ErrorUnexpected; - case clang::Stmt::CXXCatchStmtClass: + case ZigClangStmt_CXXCatchStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXCatchStmtClass"); return ErrorUnexpected; - case clang::Stmt::CXXForRangeStmtClass: + case ZigClangStmt_CXXForRangeStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXForRangeStmtClass"); return ErrorUnexpected; - case clang::Stmt::CXXTryStmtClass: + case ZigClangStmt_CXXTryStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXTryStmtClass"); return ErrorUnexpected; - case clang::Stmt::CapturedStmtClass: + case ZigClangStmt_CapturedStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CapturedStmtClass"); return ErrorUnexpected; - case clang::Stmt::CoreturnStmtClass: + case ZigClangStmt_CoreturnStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CoreturnStmtClass"); return ErrorUnexpected; - case clang::Stmt::CoroutineBodyStmtClass: + case ZigClangStmt_CoroutineBodyStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CoroutineBodyStmtClass"); return ErrorUnexpected; - case clang::Stmt::BinaryConditionalOperatorClass: + case ZigClangStmt_BinaryConditionalOperatorClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C BinaryConditionalOperatorClass"); return ErrorUnexpected; - case clang::Stmt::AddrLabelExprClass: + case ZigClangStmt_AddrLabelExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C AddrLabelExprClass"); return ErrorUnexpected; - case clang::Stmt::ArrayInitIndexExprClass: + case ZigClangStmt_ArrayInitIndexExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ArrayInitIndexExprClass"); return ErrorUnexpected; - case clang::Stmt::ArrayInitLoopExprClass: + case ZigClangStmt_ArrayInitLoopExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ArrayInitLoopExprClass"); return ErrorUnexpected; - case clang::Stmt::ArrayTypeTraitExprClass: + case ZigClangStmt_ArrayTypeTraitExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ArrayTypeTraitExprClass"); return ErrorUnexpected; - case clang::Stmt::AsTypeExprClass: + case ZigClangStmt_AsTypeExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C AsTypeExprClass"); return ErrorUnexpected; - case clang::Stmt::AtomicExprClass: + case ZigClangStmt_AtomicExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C AtomicExprClass"); return ErrorUnexpected; - case clang::Stmt::BlockExprClass: + case ZigClangStmt_BlockExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C BlockExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXBindTemporaryExprClass: + case ZigClangStmt_CXXBindTemporaryExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXBindTemporaryExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXBoolLiteralExprClass: + case ZigClangStmt_CXXBoolLiteralExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXBoolLiteralExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXConstructExprClass: + case ZigClangStmt_CXXConstructExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXConstructExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXTemporaryObjectExprClass: + case ZigClangStmt_CXXTemporaryObjectExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXTemporaryObjectExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXDefaultArgExprClass: + case ZigClangStmt_CXXDefaultArgExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXDefaultArgExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXDefaultInitExprClass: + case ZigClangStmt_CXXDefaultInitExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXDefaultInitExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXDeleteExprClass: + case ZigClangStmt_CXXDeleteExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXDeleteExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXDependentScopeMemberExprClass: + case ZigClangStmt_CXXDependentScopeMemberExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXDependentScopeMemberExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXFoldExprClass: + case ZigClangStmt_CXXFoldExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXFoldExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXInheritedCtorInitExprClass: + case ZigClangStmt_CXXInheritedCtorInitExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXInheritedCtorInitExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXNewExprClass: + case ZigClangStmt_CXXNewExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXNewExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXNoexceptExprClass: + case ZigClangStmt_CXXNoexceptExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXNoexceptExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXNullPtrLiteralExprClass: + case ZigClangStmt_CXXNullPtrLiteralExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXNullPtrLiteralExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXPseudoDestructorExprClass: + case ZigClangStmt_CXXPseudoDestructorExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXPseudoDestructorExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXScalarValueInitExprClass: + case ZigClangStmt_CXXScalarValueInitExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXScalarValueInitExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXStdInitializerListExprClass: + case ZigClangStmt_CXXStdInitializerListExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXStdInitializerListExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXThisExprClass: + case ZigClangStmt_CXXThisExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXThisExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXThrowExprClass: + case ZigClangStmt_CXXThrowExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXThrowExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXTypeidExprClass: + case ZigClangStmt_CXXTypeidExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXTypeidExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXUnresolvedConstructExprClass: + case ZigClangStmt_CXXUnresolvedConstructExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXUnresolvedConstructExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXUuidofExprClass: + case ZigClangStmt_CXXUuidofExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXUuidofExprClass"); return ErrorUnexpected; - case clang::Stmt::CUDAKernelCallExprClass: + case ZigClangStmt_CUDAKernelCallExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CUDAKernelCallExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXMemberCallExprClass: + case ZigClangStmt_CXXMemberCallExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXMemberCallExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXOperatorCallExprClass: + case ZigClangStmt_CXXOperatorCallExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXOperatorCallExprClass"); return ErrorUnexpected; - case clang::Stmt::UserDefinedLiteralClass: + case ZigClangStmt_UserDefinedLiteralClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C UserDefinedLiteralClass"); return ErrorUnexpected; - case clang::Stmt::CXXFunctionalCastExprClass: + case ZigClangStmt_CXXFunctionalCastExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXFunctionalCastExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXConstCastExprClass: + case ZigClangStmt_CXXConstCastExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXConstCastExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXDynamicCastExprClass: + case ZigClangStmt_CXXDynamicCastExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXDynamicCastExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXReinterpretCastExprClass: + case ZigClangStmt_CXXReinterpretCastExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXReinterpretCastExprClass"); return ErrorUnexpected; - case clang::Stmt::CXXStaticCastExprClass: + case ZigClangStmt_CXXStaticCastExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXStaticCastExprClass"); return ErrorUnexpected; - case clang::Stmt::ObjCBridgedCastExprClass: + case ZigClangStmt_ObjCBridgedCastExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCBridgedCastExprClass"); return ErrorUnexpected; - case clang::Stmt::CharacterLiteralClass: + case ZigClangStmt_CharacterLiteralClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CharacterLiteralClass"); return ErrorUnexpected; - case clang::Stmt::ChooseExprClass: + case ZigClangStmt_ChooseExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ChooseExprClass"); return ErrorUnexpected; - case clang::Stmt::CompoundLiteralExprClass: + case ZigClangStmt_CompoundLiteralExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CompoundLiteralExprClass"); return ErrorUnexpected; - case clang::Stmt::ConvertVectorExprClass: + case ZigClangStmt_ConvertVectorExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ConvertVectorExprClass"); return ErrorUnexpected; - case clang::Stmt::CoawaitExprClass: + case ZigClangStmt_CoawaitExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CoawaitExprClass"); return ErrorUnexpected; - case clang::Stmt::CoyieldExprClass: + case ZigClangStmt_CoyieldExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CoyieldExprClass"); return ErrorUnexpected; - case clang::Stmt::DependentCoawaitExprClass: + case ZigClangStmt_DependentCoawaitExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C DependentCoawaitExprClass"); return ErrorUnexpected; - case clang::Stmt::DependentScopeDeclRefExprClass: + case ZigClangStmt_DependentScopeDeclRefExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C DependentScopeDeclRefExprClass"); return ErrorUnexpected; - case clang::Stmt::DesignatedInitExprClass: + case ZigClangStmt_DesignatedInitExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C DesignatedInitExprClass"); return ErrorUnexpected; - case clang::Stmt::DesignatedInitUpdateExprClass: + case ZigClangStmt_DesignatedInitUpdateExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C DesignatedInitUpdateExprClass"); return ErrorUnexpected; - case clang::Stmt::ExpressionTraitExprClass: + case ZigClangStmt_ExpressionTraitExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ExpressionTraitExprClass"); return ErrorUnexpected; - case clang::Stmt::ExtVectorElementExprClass: + case ZigClangStmt_ExtVectorElementExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ExtVectorElementExprClass"); return ErrorUnexpected; - case clang::Stmt::FixedPointLiteralClass: + case ZigClangStmt_FixedPointLiteralClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C FixedPointLiteralClass"); return ErrorUnexpected; - case clang::Stmt::FloatingLiteralClass: + case ZigClangStmt_FloatingLiteralClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C FloatingLiteralClass"); return ErrorUnexpected; - case clang::Stmt::ExprWithCleanupsClass: + case ZigClangStmt_ExprWithCleanupsClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ExprWithCleanupsClass"); return ErrorUnexpected; - case clang::Stmt::FunctionParmPackExprClass: + case ZigClangStmt_FunctionParmPackExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C FunctionParmPackExprClass"); return ErrorUnexpected; - case clang::Stmt::GNUNullExprClass: + case ZigClangStmt_GNUNullExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C GNUNullExprClass"); return ErrorUnexpected; - case clang::Stmt::GenericSelectionExprClass: + case ZigClangStmt_GenericSelectionExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C GenericSelectionExprClass"); return ErrorUnexpected; - case clang::Stmt::ImaginaryLiteralClass: + case ZigClangStmt_ImaginaryLiteralClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ImaginaryLiteralClass"); return ErrorUnexpected; - case clang::Stmt::ImplicitValueInitExprClass: + case ZigClangStmt_ImplicitValueInitExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ImplicitValueInitExprClass"); return ErrorUnexpected; - case clang::Stmt::InitListExprClass: + case ZigClangStmt_InitListExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C InitListExprClass"); return ErrorUnexpected; - case clang::Stmt::LambdaExprClass: + case ZigClangStmt_LambdaExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C LambdaExprClass"); return ErrorUnexpected; - case clang::Stmt::MSPropertyRefExprClass: + case ZigClangStmt_MSPropertyRefExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C MSPropertyRefExprClass"); return ErrorUnexpected; - case clang::Stmt::MSPropertySubscriptExprClass: + case ZigClangStmt_MSPropertySubscriptExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C MSPropertySubscriptExprClass"); return ErrorUnexpected; - case clang::Stmt::MaterializeTemporaryExprClass: + case ZigClangStmt_MaterializeTemporaryExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C MaterializeTemporaryExprClass"); return ErrorUnexpected; - case clang::Stmt::NoInitExprClass: + case ZigClangStmt_NoInitExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C NoInitExprClass"); return ErrorUnexpected; - case clang::Stmt::OMPArraySectionExprClass: + case ZigClangStmt_OMPArraySectionExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPArraySectionExprClass"); return ErrorUnexpected; - case clang::Stmt::ObjCArrayLiteralClass: + case ZigClangStmt_ObjCArrayLiteralClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCArrayLiteralClass"); return ErrorUnexpected; - case clang::Stmt::ObjCAvailabilityCheckExprClass: + case ZigClangStmt_ObjCAvailabilityCheckExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCAvailabilityCheckExprClass"); return ErrorUnexpected; - case clang::Stmt::ObjCBoolLiteralExprClass: + case ZigClangStmt_ObjCBoolLiteralExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCBoolLiteralExprClass"); return ErrorUnexpected; - case clang::Stmt::ObjCBoxedExprClass: + case ZigClangStmt_ObjCBoxedExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCBoxedExprClass"); return ErrorUnexpected; - case clang::Stmt::ObjCDictionaryLiteralClass: + case ZigClangStmt_ObjCDictionaryLiteralClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCDictionaryLiteralClass"); return ErrorUnexpected; - case clang::Stmt::ObjCEncodeExprClass: + case ZigClangStmt_ObjCEncodeExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCEncodeExprClass"); return ErrorUnexpected; - case clang::Stmt::ObjCIndirectCopyRestoreExprClass: + case ZigClangStmt_ObjCIndirectCopyRestoreExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCIndirectCopyRestoreExprClass"); return ErrorUnexpected; - case clang::Stmt::ObjCIsaExprClass: + case ZigClangStmt_ObjCIsaExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCIsaExprClass"); return ErrorUnexpected; - case clang::Stmt::ObjCIvarRefExprClass: + case ZigClangStmt_ObjCIvarRefExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCIvarRefExprClass"); return ErrorUnexpected; - case clang::Stmt::ObjCMessageExprClass: + case ZigClangStmt_ObjCMessageExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCMessageExprClass"); return ErrorUnexpected; - case clang::Stmt::ObjCPropertyRefExprClass: + case ZigClangStmt_ObjCPropertyRefExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCPropertyRefExprClass"); return ErrorUnexpected; - case clang::Stmt::ObjCProtocolExprClass: + case ZigClangStmt_ObjCProtocolExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCProtocolExprClass"); return ErrorUnexpected; - case clang::Stmt::ObjCSelectorExprClass: + case ZigClangStmt_ObjCSelectorExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCSelectorExprClass"); return ErrorUnexpected; - case clang::Stmt::ObjCStringLiteralClass: + case ZigClangStmt_ObjCStringLiteralClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCStringLiteralClass"); return ErrorUnexpected; - case clang::Stmt::ObjCSubscriptRefExprClass: + case ZigClangStmt_ObjCSubscriptRefExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCSubscriptRefExprClass"); return ErrorUnexpected; - case clang::Stmt::OffsetOfExprClass: + case ZigClangStmt_OffsetOfExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OffsetOfExprClass"); return ErrorUnexpected; - case clang::Stmt::OpaqueValueExprClass: + case ZigClangStmt_OpaqueValueExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OpaqueValueExprClass"); return ErrorUnexpected; - case clang::Stmt::UnresolvedLookupExprClass: + case ZigClangStmt_UnresolvedLookupExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C UnresolvedLookupExprClass"); return ErrorUnexpected; - case clang::Stmt::UnresolvedMemberExprClass: + case ZigClangStmt_UnresolvedMemberExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C UnresolvedMemberExprClass"); return ErrorUnexpected; - case clang::Stmt::PackExpansionExprClass: + case ZigClangStmt_PackExpansionExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C PackExpansionExprClass"); return ErrorUnexpected; - case clang::Stmt::ParenListExprClass: + case ZigClangStmt_ParenListExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ParenListExprClass"); return ErrorUnexpected; - case clang::Stmt::PseudoObjectExprClass: + case ZigClangStmt_PseudoObjectExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C PseudoObjectExprClass"); return ErrorUnexpected; - case clang::Stmt::ShuffleVectorExprClass: + case ZigClangStmt_ShuffleVectorExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ShuffleVectorExprClass"); return ErrorUnexpected; - case clang::Stmt::SizeOfPackExprClass: + case ZigClangStmt_SizeOfPackExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C SizeOfPackExprClass"); return ErrorUnexpected; - case clang::Stmt::SubstNonTypeTemplateParmExprClass: + case ZigClangStmt_SubstNonTypeTemplateParmExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C SubstNonTypeTemplateParmExprClass"); return ErrorUnexpected; - case clang::Stmt::SubstNonTypeTemplateParmPackExprClass: + case ZigClangStmt_SubstNonTypeTemplateParmPackExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C SubstNonTypeTemplateParmPackExprClass"); return ErrorUnexpected; - case clang::Stmt::TypeTraitExprClass: + case ZigClangStmt_TypeTraitExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C TypeTraitExprClass"); return ErrorUnexpected; - case clang::Stmt::TypoExprClass: + case ZigClangStmt_TypoExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C TypoExprClass"); return ErrorUnexpected; - case clang::Stmt::VAArgExprClass: + case ZigClangStmt_VAArgExprClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C VAArgExprClass"); return ErrorUnexpected; - case clang::Stmt::GotoStmtClass: + case ZigClangStmt_GotoStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C GotoStmtClass"); return ErrorUnexpected; - case clang::Stmt::IndirectGotoStmtClass: + case ZigClangStmt_IndirectGotoStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C IndirectGotoStmtClass"); return ErrorUnexpected; - case clang::Stmt::LabelStmtClass: + case ZigClangStmt_LabelStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C LabelStmtClass"); return ErrorUnexpected; - case clang::Stmt::MSDependentExistsStmtClass: + case ZigClangStmt_MSDependentExistsStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C MSDependentExistsStmtClass"); return ErrorUnexpected; - case clang::Stmt::OMPAtomicDirectiveClass: + case ZigClangStmt_OMPAtomicDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPAtomicDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPBarrierDirectiveClass: + case ZigClangStmt_OMPBarrierDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPBarrierDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPCancelDirectiveClass: + case ZigClangStmt_OMPCancelDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPCancelDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPCancellationPointDirectiveClass: + case ZigClangStmt_OMPCancellationPointDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPCancellationPointDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPCriticalDirectiveClass: + case ZigClangStmt_OMPCriticalDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPCriticalDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPFlushDirectiveClass: + case ZigClangStmt_OMPFlushDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPFlushDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPDistributeDirectiveClass: + case ZigClangStmt_OMPDistributeDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPDistributeDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPDistributeParallelForDirectiveClass: + case ZigClangStmt_OMPDistributeParallelForDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPDistributeParallelForDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPDistributeParallelForSimdDirectiveClass: + case ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPDistributeParallelForSimdDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPDistributeSimdDirectiveClass: + case ZigClangStmt_OMPDistributeSimdDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPDistributeSimdDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPForDirectiveClass: + case ZigClangStmt_OMPForDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPForDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPForSimdDirectiveClass: + case ZigClangStmt_OMPForSimdDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPForSimdDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPParallelForDirectiveClass: + case ZigClangStmt_OMPParallelForDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPParallelForDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPParallelForSimdDirectiveClass: + case ZigClangStmt_OMPParallelForSimdDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPParallelForSimdDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPSimdDirectiveClass: + case ZigClangStmt_OMPSimdDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPSimdDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTargetParallelForSimdDirectiveClass: + case ZigClangStmt_OMPTargetParallelForSimdDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetParallelForSimdDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTargetSimdDirectiveClass: + case ZigClangStmt_OMPTargetSimdDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetSimdDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTargetTeamsDistributeDirectiveClass: + case ZigClangStmt_OMPTargetTeamsDistributeDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetTeamsDistributeDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass: + case ZigClangStmt_OMPTargetTeamsDistributeParallelForDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetTeamsDistributeParallelForDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass: + case ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetTeamsDistributeParallelForSimdDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTargetTeamsDistributeSimdDirectiveClass: + case ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetTeamsDistributeSimdDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTaskLoopDirectiveClass: + case ZigClangStmt_OMPTaskLoopDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTaskLoopDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTaskLoopSimdDirectiveClass: + case ZigClangStmt_OMPTaskLoopSimdDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTaskLoopSimdDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTeamsDistributeDirectiveClass: + case ZigClangStmt_OMPTeamsDistributeDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTeamsDistributeDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTeamsDistributeParallelForDirectiveClass: + case ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTeamsDistributeParallelForDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass: + case ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTeamsDistributeParallelForSimdDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTeamsDistributeSimdDirectiveClass: + case ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTeamsDistributeSimdDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPMasterDirectiveClass: + case ZigClangStmt_OMPMasterDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPMasterDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPOrderedDirectiveClass: + case ZigClangStmt_OMPOrderedDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPOrderedDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPParallelDirectiveClass: + case ZigClangStmt_OMPParallelDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPParallelDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPParallelSectionsDirectiveClass: + case ZigClangStmt_OMPParallelSectionsDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPParallelSectionsDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPSectionDirectiveClass: + case ZigClangStmt_OMPSectionDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPSectionDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPSectionsDirectiveClass: + case ZigClangStmt_OMPSectionsDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPSectionsDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPSingleDirectiveClass: + case ZigClangStmt_OMPSingleDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPSingleDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTargetDataDirectiveClass: + case ZigClangStmt_OMPTargetDataDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetDataDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTargetDirectiveClass: + case ZigClangStmt_OMPTargetDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTargetEnterDataDirectiveClass: + case ZigClangStmt_OMPTargetEnterDataDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetEnterDataDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTargetExitDataDirectiveClass: + case ZigClangStmt_OMPTargetExitDataDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetExitDataDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTargetParallelDirectiveClass: + case ZigClangStmt_OMPTargetParallelDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetParallelDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTargetParallelForDirectiveClass: + case ZigClangStmt_OMPTargetParallelForDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetParallelForDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTargetTeamsDirectiveClass: + case ZigClangStmt_OMPTargetTeamsDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetTeamsDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTargetUpdateDirectiveClass: + case ZigClangStmt_OMPTargetUpdateDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetUpdateDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTaskDirectiveClass: + case ZigClangStmt_OMPTaskDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTaskDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTaskgroupDirectiveClass: + case ZigClangStmt_OMPTaskgroupDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTaskgroupDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTaskwaitDirectiveClass: + case ZigClangStmt_OMPTaskwaitDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTaskwaitDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTaskyieldDirectiveClass: + case ZigClangStmt_OMPTaskyieldDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTaskyieldDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::OMPTeamsDirectiveClass: + case ZigClangStmt_OMPTeamsDirectiveClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTeamsDirectiveClass"); return ErrorUnexpected; - case clang::Stmt::ObjCAtCatchStmtClass: + case ZigClangStmt_ObjCAtCatchStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCAtCatchStmtClass"); return ErrorUnexpected; - case clang::Stmt::ObjCAtFinallyStmtClass: + case ZigClangStmt_ObjCAtFinallyStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCAtFinallyStmtClass"); return ErrorUnexpected; - case clang::Stmt::ObjCAtSynchronizedStmtClass: + case ZigClangStmt_ObjCAtSynchronizedStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCAtSynchronizedStmtClass"); return ErrorUnexpected; - case clang::Stmt::ObjCAtThrowStmtClass: + case ZigClangStmt_ObjCAtThrowStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCAtThrowStmtClass"); return ErrorUnexpected; - case clang::Stmt::ObjCAtTryStmtClass: + case ZigClangStmt_ObjCAtTryStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCAtTryStmtClass"); return ErrorUnexpected; - case clang::Stmt::ObjCAutoreleasePoolStmtClass: + case ZigClangStmt_ObjCAutoreleasePoolStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCAutoreleasePoolStmtClass"); return ErrorUnexpected; - case clang::Stmt::ObjCForCollectionStmtClass: + case ZigClangStmt_ObjCForCollectionStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCForCollectionStmtClass"); return ErrorUnexpected; - case clang::Stmt::SEHExceptStmtClass: + case ZigClangStmt_SEHExceptStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C SEHExceptStmtClass"); return ErrorUnexpected; - case clang::Stmt::SEHFinallyStmtClass: + case ZigClangStmt_SEHFinallyStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C SEHFinallyStmtClass"); return ErrorUnexpected; - case clang::Stmt::SEHLeaveStmtClass: + case ZigClangStmt_SEHLeaveStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C SEHLeaveStmtClass"); return ErrorUnexpected; - case clang::Stmt::SEHTryStmtClass: + case ZigClangStmt_SEHTryStmtClass: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C SEHTryStmtClass"); return ErrorUnexpected; } diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp index 265a37d82a..c892426363 100644 --- a/src/zig_clang.cpp +++ b/src/zig_clang.cpp @@ -101,7 +101,7 @@ static_assert((clang::BinaryOperatorKind)ZigClangBO_SubAssign == clang::BO_SubAs static_assert((clang::BinaryOperatorKind)ZigClangBO_Xor == clang::BO_Xor, ""); static_assert((clang::BinaryOperatorKind)ZigClangBO_XorAssign == clang::BO_XorAssign, ""); -// This function detects additions to the enum +// Detect additions to the enum void zig2clang_UO(clang::UnaryOperatorKind op) { switch (op) { case clang::UO_AddrOf: @@ -137,6 +137,7 @@ static_assert((clang::UnaryOperatorKind)ZigClangUO_PreDec == clang::UO_PreDec, " static_assert((clang::UnaryOperatorKind)ZigClangUO_PreInc == clang::UO_PreInc, ""); static_assert((clang::UnaryOperatorKind)ZigClangUO_Real == clang::UO_Real, ""); +// Detect additions to the enum void zig2clang_TypeClass(clang::Type::TypeClass ty) { switch (ty) { case clang::Type::Builtin: @@ -238,6 +239,408 @@ static_assert((clang::Type::TypeClass)ZigClangType_ObjCObjectPointer == clang::T static_assert((clang::Type::TypeClass)ZigClangType_Pipe == clang::Type::Pipe, ""); static_assert((clang::Type::TypeClass)ZigClangType_Atomic == clang::Type::Atomic, ""); +// Detect additions to the enum +void zig2clang_StmtClass(clang::Stmt::StmtClass x) { + switch (x) { + case clang::Stmt::NoStmtClass: + case clang::Stmt::NullStmtClass: + case clang::Stmt::CompoundStmtClass: + case clang::Stmt::LabelStmtClass: + case clang::Stmt::AttributedStmtClass: + case clang::Stmt::IfStmtClass: + case clang::Stmt::SwitchStmtClass: + case clang::Stmt::WhileStmtClass: + case clang::Stmt::DoStmtClass: + case clang::Stmt::ForStmtClass: + case clang::Stmt::GotoStmtClass: + case clang::Stmt::IndirectGotoStmtClass: + case clang::Stmt::ContinueStmtClass: + case clang::Stmt::BreakStmtClass: + case clang::Stmt::ReturnStmtClass: + case clang::Stmt::DeclStmtClass: + case clang::Stmt::CaseStmtClass: + case clang::Stmt::DefaultStmtClass: + case clang::Stmt::CapturedStmtClass: + case clang::Stmt::GCCAsmStmtClass: + case clang::Stmt::MSAsmStmtClass: + case clang::Stmt::ObjCAtTryStmtClass: + case clang::Stmt::ObjCAtCatchStmtClass: + case clang::Stmt::ObjCAtFinallyStmtClass: + case clang::Stmt::ObjCAtThrowStmtClass: + case clang::Stmt::ObjCAtSynchronizedStmtClass: + case clang::Stmt::ObjCForCollectionStmtClass: + case clang::Stmt::ObjCAutoreleasePoolStmtClass: + case clang::Stmt::CXXCatchStmtClass: + case clang::Stmt::CXXTryStmtClass: + case clang::Stmt::CXXForRangeStmtClass: + case clang::Stmt::CoroutineBodyStmtClass: + case clang::Stmt::CoreturnStmtClass: + case clang::Stmt::PredefinedExprClass: + case clang::Stmt::DeclRefExprClass: + case clang::Stmt::IntegerLiteralClass: + case clang::Stmt::FixedPointLiteralClass: + case clang::Stmt::FloatingLiteralClass: + case clang::Stmt::ImaginaryLiteralClass: + case clang::Stmt::StringLiteralClass: + case clang::Stmt::CharacterLiteralClass: + case clang::Stmt::ParenExprClass: + case clang::Stmt::UnaryOperatorClass: + case clang::Stmt::OffsetOfExprClass: + case clang::Stmt::UnaryExprOrTypeTraitExprClass: + case clang::Stmt::ArraySubscriptExprClass: + case clang::Stmt::OMPArraySectionExprClass: + case clang::Stmt::CallExprClass: + case clang::Stmt::MemberExprClass: + case clang::Stmt::BinaryOperatorClass: + case clang::Stmt::CompoundAssignOperatorClass: + case clang::Stmt::ConditionalOperatorClass: + case clang::Stmt::BinaryConditionalOperatorClass: + case clang::Stmt::ImplicitCastExprClass: + case clang::Stmt::CStyleCastExprClass: + case clang::Stmt::CompoundLiteralExprClass: + case clang::Stmt::ExtVectorElementExprClass: + case clang::Stmt::InitListExprClass: + case clang::Stmt::DesignatedInitExprClass: + case clang::Stmt::DesignatedInitUpdateExprClass: + case clang::Stmt::ImplicitValueInitExprClass: + case clang::Stmt::NoInitExprClass: + case clang::Stmt::ArrayInitLoopExprClass: + case clang::Stmt::ArrayInitIndexExprClass: + case clang::Stmt::ParenListExprClass: + case clang::Stmt::VAArgExprClass: + case clang::Stmt::GenericSelectionExprClass: + case clang::Stmt::PseudoObjectExprClass: + case clang::Stmt::ConstantExprClass: + case clang::Stmt::AtomicExprClass: + case clang::Stmt::AddrLabelExprClass: + case clang::Stmt::StmtExprClass: + case clang::Stmt::ChooseExprClass: + case clang::Stmt::GNUNullExprClass: + case clang::Stmt::CXXOperatorCallExprClass: + case clang::Stmt::CXXMemberCallExprClass: + case clang::Stmt::CXXStaticCastExprClass: + case clang::Stmt::CXXDynamicCastExprClass: + case clang::Stmt::CXXReinterpretCastExprClass: + case clang::Stmt::CXXConstCastExprClass: + case clang::Stmt::CXXFunctionalCastExprClass: + case clang::Stmt::CXXTypeidExprClass: + case clang::Stmt::UserDefinedLiteralClass: + case clang::Stmt::CXXBoolLiteralExprClass: + case clang::Stmt::CXXNullPtrLiteralExprClass: + case clang::Stmt::CXXThisExprClass: + case clang::Stmt::CXXThrowExprClass: + case clang::Stmt::CXXDefaultArgExprClass: + case clang::Stmt::CXXDefaultInitExprClass: + case clang::Stmt::CXXScalarValueInitExprClass: + case clang::Stmt::CXXStdInitializerListExprClass: + case clang::Stmt::CXXNewExprClass: + case clang::Stmt::CXXDeleteExprClass: + case clang::Stmt::CXXPseudoDestructorExprClass: + case clang::Stmt::TypeTraitExprClass: + case clang::Stmt::ArrayTypeTraitExprClass: + case clang::Stmt::ExpressionTraitExprClass: + case clang::Stmt::DependentScopeDeclRefExprClass: + case clang::Stmt::CXXConstructExprClass: + case clang::Stmt::CXXInheritedCtorInitExprClass: + case clang::Stmt::CXXBindTemporaryExprClass: + case clang::Stmt::ExprWithCleanupsClass: + case clang::Stmt::CXXTemporaryObjectExprClass: + case clang::Stmt::CXXUnresolvedConstructExprClass: + case clang::Stmt::CXXDependentScopeMemberExprClass: + case clang::Stmt::UnresolvedLookupExprClass: + case clang::Stmt::UnresolvedMemberExprClass: + case clang::Stmt::CXXNoexceptExprClass: + case clang::Stmt::PackExpansionExprClass: + case clang::Stmt::SizeOfPackExprClass: + case clang::Stmt::SubstNonTypeTemplateParmExprClass: + case clang::Stmt::SubstNonTypeTemplateParmPackExprClass: + case clang::Stmt::FunctionParmPackExprClass: + case clang::Stmt::MaterializeTemporaryExprClass: + case clang::Stmt::LambdaExprClass: + case clang::Stmt::CXXFoldExprClass: + case clang::Stmt::CoawaitExprClass: + case clang::Stmt::DependentCoawaitExprClass: + case clang::Stmt::CoyieldExprClass: + case clang::Stmt::ObjCStringLiteralClass: + case clang::Stmt::ObjCBoxedExprClass: + case clang::Stmt::ObjCArrayLiteralClass: + case clang::Stmt::ObjCDictionaryLiteralClass: + case clang::Stmt::ObjCEncodeExprClass: + case clang::Stmt::ObjCMessageExprClass: + case clang::Stmt::ObjCSelectorExprClass: + case clang::Stmt::ObjCProtocolExprClass: + case clang::Stmt::ObjCIvarRefExprClass: + case clang::Stmt::ObjCPropertyRefExprClass: + case clang::Stmt::ObjCIsaExprClass: + case clang::Stmt::ObjCIndirectCopyRestoreExprClass: + case clang::Stmt::ObjCBoolLiteralExprClass: + case clang::Stmt::ObjCSubscriptRefExprClass: + case clang::Stmt::ObjCAvailabilityCheckExprClass: + case clang::Stmt::ObjCBridgedCastExprClass: + case clang::Stmt::CUDAKernelCallExprClass: + case clang::Stmt::ShuffleVectorExprClass: + case clang::Stmt::ConvertVectorExprClass: + case clang::Stmt::BlockExprClass: + case clang::Stmt::OpaqueValueExprClass: + case clang::Stmt::TypoExprClass: + case clang::Stmt::MSPropertyRefExprClass: + case clang::Stmt::MSPropertySubscriptExprClass: + case clang::Stmt::CXXUuidofExprClass: + case clang::Stmt::SEHTryStmtClass: + case clang::Stmt::SEHExceptStmtClass: + case clang::Stmt::SEHFinallyStmtClass: + case clang::Stmt::SEHLeaveStmtClass: + case clang::Stmt::MSDependentExistsStmtClass: + case clang::Stmt::AsTypeExprClass: + case clang::Stmt::OMPParallelDirectiveClass: + case clang::Stmt::OMPSimdDirectiveClass: + case clang::Stmt::OMPForDirectiveClass: + case clang::Stmt::OMPForSimdDirectiveClass: + case clang::Stmt::OMPSectionsDirectiveClass: + case clang::Stmt::OMPSectionDirectiveClass: + case clang::Stmt::OMPSingleDirectiveClass: + case clang::Stmt::OMPMasterDirectiveClass: + case clang::Stmt::OMPCriticalDirectiveClass: + case clang::Stmt::OMPParallelForDirectiveClass: + case clang::Stmt::OMPParallelForSimdDirectiveClass: + case clang::Stmt::OMPParallelSectionsDirectiveClass: + case clang::Stmt::OMPTaskDirectiveClass: + case clang::Stmt::OMPTaskyieldDirectiveClass: + case clang::Stmt::OMPBarrierDirectiveClass: + case clang::Stmt::OMPTaskwaitDirectiveClass: + case clang::Stmt::OMPTaskgroupDirectiveClass: + case clang::Stmt::OMPFlushDirectiveClass: + case clang::Stmt::OMPOrderedDirectiveClass: + case clang::Stmt::OMPAtomicDirectiveClass: + case clang::Stmt::OMPTargetDirectiveClass: + case clang::Stmt::OMPTargetDataDirectiveClass: + case clang::Stmt::OMPTargetEnterDataDirectiveClass: + case clang::Stmt::OMPTargetExitDataDirectiveClass: + case clang::Stmt::OMPTargetParallelDirectiveClass: + case clang::Stmt::OMPTargetParallelForDirectiveClass: + case clang::Stmt::OMPTargetUpdateDirectiveClass: + case clang::Stmt::OMPTeamsDirectiveClass: + case clang::Stmt::OMPCancellationPointDirectiveClass: + case clang::Stmt::OMPCancelDirectiveClass: + case clang::Stmt::OMPTaskLoopDirectiveClass: + case clang::Stmt::OMPTaskLoopSimdDirectiveClass: + case clang::Stmt::OMPDistributeDirectiveClass: + case clang::Stmt::OMPDistributeParallelForDirectiveClass: + case clang::Stmt::OMPDistributeParallelForSimdDirectiveClass: + case clang::Stmt::OMPDistributeSimdDirectiveClass: + case clang::Stmt::OMPTargetParallelForSimdDirectiveClass: + case clang::Stmt::OMPTargetSimdDirectiveClass: + case clang::Stmt::OMPTeamsDistributeDirectiveClass: + case clang::Stmt::OMPTeamsDistributeSimdDirectiveClass: + case clang::Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass: + case clang::Stmt::OMPTeamsDistributeParallelForDirectiveClass: + case clang::Stmt::OMPTargetTeamsDirectiveClass: + case clang::Stmt::OMPTargetTeamsDistributeDirectiveClass: + case clang::Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass: + case clang::Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass: + case clang::Stmt::OMPTargetTeamsDistributeSimdDirectiveClass: + break; + } +} + +static_assert((clang::Stmt::StmtClass)ZigClangStmt_NoStmtClass == clang::Stmt::NoStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_NullStmtClass == clang::Stmt::NullStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CompoundStmtClass == clang::Stmt::CompoundStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_LabelStmtClass == clang::Stmt::LabelStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_AttributedStmtClass == clang::Stmt::AttributedStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_IfStmtClass == clang::Stmt::IfStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_SwitchStmtClass == clang::Stmt::SwitchStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_WhileStmtClass == clang::Stmt::WhileStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_DoStmtClass == clang::Stmt::DoStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ForStmtClass == clang::Stmt::ForStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_GotoStmtClass == clang::Stmt::GotoStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_IndirectGotoStmtClass == clang::Stmt::IndirectGotoStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ContinueStmtClass == clang::Stmt::ContinueStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_BreakStmtClass == clang::Stmt::BreakStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ReturnStmtClass == clang::Stmt::ReturnStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_DeclStmtClass == clang::Stmt::DeclStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CaseStmtClass == clang::Stmt::CaseStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_DefaultStmtClass == clang::Stmt::DefaultStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CapturedStmtClass == clang::Stmt::CapturedStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_GCCAsmStmtClass == clang::Stmt::GCCAsmStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_MSAsmStmtClass == clang::Stmt::MSAsmStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCAtTryStmtClass == clang::Stmt::ObjCAtTryStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCAtCatchStmtClass == clang::Stmt::ObjCAtCatchStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCAtFinallyStmtClass == clang::Stmt::ObjCAtFinallyStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCAtThrowStmtClass == clang::Stmt::ObjCAtThrowStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCAtSynchronizedStmtClass == clang::Stmt::ObjCAtSynchronizedStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCForCollectionStmtClass == clang::Stmt::ObjCForCollectionStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCAutoreleasePoolStmtClass == clang::Stmt::ObjCAutoreleasePoolStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXCatchStmtClass == clang::Stmt::CXXCatchStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXTryStmtClass == clang::Stmt::CXXTryStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXForRangeStmtClass == clang::Stmt::CXXForRangeStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CoroutineBodyStmtClass == clang::Stmt::CoroutineBodyStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CoreturnStmtClass == clang::Stmt::CoreturnStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_PredefinedExprClass == clang::Stmt::PredefinedExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_DeclRefExprClass == clang::Stmt::DeclRefExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_IntegerLiteralClass == clang::Stmt::IntegerLiteralClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_FixedPointLiteralClass == clang::Stmt::FixedPointLiteralClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_FloatingLiteralClass == clang::Stmt::FloatingLiteralClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ImaginaryLiteralClass == clang::Stmt::ImaginaryLiteralClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_StringLiteralClass == clang::Stmt::StringLiteralClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CharacterLiteralClass == clang::Stmt::CharacterLiteralClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ParenExprClass == clang::Stmt::ParenExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_UnaryOperatorClass == clang::Stmt::UnaryOperatorClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OffsetOfExprClass == clang::Stmt::OffsetOfExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_UnaryExprOrTypeTraitExprClass == clang::Stmt::UnaryExprOrTypeTraitExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ArraySubscriptExprClass == clang::Stmt::ArraySubscriptExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPArraySectionExprClass == clang::Stmt::OMPArraySectionExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CallExprClass == clang::Stmt::CallExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_MemberExprClass == clang::Stmt::MemberExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_BinaryOperatorClass == clang::Stmt::BinaryOperatorClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CompoundAssignOperatorClass == clang::Stmt::CompoundAssignOperatorClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ConditionalOperatorClass == clang::Stmt::ConditionalOperatorClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_BinaryConditionalOperatorClass == clang::Stmt::BinaryConditionalOperatorClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ImplicitCastExprClass == clang::Stmt::ImplicitCastExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CStyleCastExprClass == clang::Stmt::CStyleCastExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CompoundLiteralExprClass == clang::Stmt::CompoundLiteralExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ExtVectorElementExprClass == clang::Stmt::ExtVectorElementExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_InitListExprClass == clang::Stmt::InitListExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_DesignatedInitExprClass == clang::Stmt::DesignatedInitExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_DesignatedInitUpdateExprClass == clang::Stmt::DesignatedInitUpdateExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ImplicitValueInitExprClass == clang::Stmt::ImplicitValueInitExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_NoInitExprClass == clang::Stmt::NoInitExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ArrayInitLoopExprClass == clang::Stmt::ArrayInitLoopExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ArrayInitIndexExprClass == clang::Stmt::ArrayInitIndexExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ParenListExprClass == clang::Stmt::ParenListExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_VAArgExprClass == clang::Stmt::VAArgExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_GenericSelectionExprClass == clang::Stmt::GenericSelectionExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_PseudoObjectExprClass == clang::Stmt::PseudoObjectExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ConstantExprClass == clang::Stmt::ConstantExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_AtomicExprClass == clang::Stmt::AtomicExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_AddrLabelExprClass == clang::Stmt::AddrLabelExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_StmtExprClass == clang::Stmt::StmtExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ChooseExprClass == clang::Stmt::ChooseExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_GNUNullExprClass == clang::Stmt::GNUNullExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXOperatorCallExprClass == clang::Stmt::CXXOperatorCallExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXMemberCallExprClass == clang::Stmt::CXXMemberCallExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXStaticCastExprClass == clang::Stmt::CXXStaticCastExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXDynamicCastExprClass == clang::Stmt::CXXDynamicCastExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXReinterpretCastExprClass == clang::Stmt::CXXReinterpretCastExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXConstCastExprClass == clang::Stmt::CXXConstCastExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXFunctionalCastExprClass == clang::Stmt::CXXFunctionalCastExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXTypeidExprClass == clang::Stmt::CXXTypeidExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_UserDefinedLiteralClass == clang::Stmt::UserDefinedLiteralClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXBoolLiteralExprClass == clang::Stmt::CXXBoolLiteralExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXNullPtrLiteralExprClass == clang::Stmt::CXXNullPtrLiteralExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXThisExprClass == clang::Stmt::CXXThisExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXThrowExprClass == clang::Stmt::CXXThrowExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXDefaultArgExprClass == clang::Stmt::CXXDefaultArgExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXDefaultInitExprClass == clang::Stmt::CXXDefaultInitExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXScalarValueInitExprClass == clang::Stmt::CXXScalarValueInitExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXStdInitializerListExprClass == clang::Stmt::CXXStdInitializerListExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXNewExprClass == clang::Stmt::CXXNewExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXDeleteExprClass == clang::Stmt::CXXDeleteExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXPseudoDestructorExprClass == clang::Stmt::CXXPseudoDestructorExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_TypeTraitExprClass == clang::Stmt::TypeTraitExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ArrayTypeTraitExprClass == clang::Stmt::ArrayTypeTraitExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ExpressionTraitExprClass == clang::Stmt::ExpressionTraitExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_DependentScopeDeclRefExprClass == clang::Stmt::DependentScopeDeclRefExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXConstructExprClass == clang::Stmt::CXXConstructExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXInheritedCtorInitExprClass == clang::Stmt::CXXInheritedCtorInitExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXBindTemporaryExprClass == clang::Stmt::CXXBindTemporaryExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ExprWithCleanupsClass == clang::Stmt::ExprWithCleanupsClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXTemporaryObjectExprClass == clang::Stmt::CXXTemporaryObjectExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXUnresolvedConstructExprClass == clang::Stmt::CXXUnresolvedConstructExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXDependentScopeMemberExprClass == clang::Stmt::CXXDependentScopeMemberExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_UnresolvedLookupExprClass == clang::Stmt::UnresolvedLookupExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_UnresolvedMemberExprClass == clang::Stmt::UnresolvedMemberExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXNoexceptExprClass == clang::Stmt::CXXNoexceptExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_PackExpansionExprClass == clang::Stmt::PackExpansionExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_SizeOfPackExprClass == clang::Stmt::SizeOfPackExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_SubstNonTypeTemplateParmExprClass == clang::Stmt::SubstNonTypeTemplateParmExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_SubstNonTypeTemplateParmPackExprClass == clang::Stmt::SubstNonTypeTemplateParmPackExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_FunctionParmPackExprClass == clang::Stmt::FunctionParmPackExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_MaterializeTemporaryExprClass == clang::Stmt::MaterializeTemporaryExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_LambdaExprClass == clang::Stmt::LambdaExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXFoldExprClass == clang::Stmt::CXXFoldExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CoawaitExprClass == clang::Stmt::CoawaitExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_DependentCoawaitExprClass == clang::Stmt::DependentCoawaitExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CoyieldExprClass == clang::Stmt::CoyieldExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCStringLiteralClass == clang::Stmt::ObjCStringLiteralClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCBoxedExprClass == clang::Stmt::ObjCBoxedExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCArrayLiteralClass == clang::Stmt::ObjCArrayLiteralClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCDictionaryLiteralClass == clang::Stmt::ObjCDictionaryLiteralClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCEncodeExprClass == clang::Stmt::ObjCEncodeExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCMessageExprClass == clang::Stmt::ObjCMessageExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCSelectorExprClass == clang::Stmt::ObjCSelectorExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCProtocolExprClass == clang::Stmt::ObjCProtocolExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCIvarRefExprClass == clang::Stmt::ObjCIvarRefExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCPropertyRefExprClass == clang::Stmt::ObjCPropertyRefExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCIsaExprClass == clang::Stmt::ObjCIsaExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCIndirectCopyRestoreExprClass == clang::Stmt::ObjCIndirectCopyRestoreExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCBoolLiteralExprClass == clang::Stmt::ObjCBoolLiteralExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCSubscriptRefExprClass == clang::Stmt::ObjCSubscriptRefExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCAvailabilityCheckExprClass == clang::Stmt::ObjCAvailabilityCheckExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ObjCBridgedCastExprClass == clang::Stmt::ObjCBridgedCastExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CUDAKernelCallExprClass == clang::Stmt::CUDAKernelCallExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ShuffleVectorExprClass == clang::Stmt::ShuffleVectorExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_ConvertVectorExprClass == clang::Stmt::ConvertVectorExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_BlockExprClass == clang::Stmt::BlockExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OpaqueValueExprClass == clang::Stmt::OpaqueValueExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_TypoExprClass == clang::Stmt::TypoExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_MSPropertyRefExprClass == clang::Stmt::MSPropertyRefExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_MSPropertySubscriptExprClass == clang::Stmt::MSPropertySubscriptExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_CXXUuidofExprClass == clang::Stmt::CXXUuidofExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_SEHTryStmtClass == clang::Stmt::SEHTryStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_SEHExceptStmtClass == clang::Stmt::SEHExceptStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_SEHFinallyStmtClass == clang::Stmt::SEHFinallyStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_SEHLeaveStmtClass == clang::Stmt::SEHLeaveStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_MSDependentExistsStmtClass == clang::Stmt::MSDependentExistsStmtClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_AsTypeExprClass == clang::Stmt::AsTypeExprClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPParallelDirectiveClass == clang::Stmt::OMPParallelDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPSimdDirectiveClass == clang::Stmt::OMPSimdDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPForDirectiveClass == clang::Stmt::OMPForDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPForSimdDirectiveClass == clang::Stmt::OMPForSimdDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPSectionsDirectiveClass == clang::Stmt::OMPSectionsDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPSectionDirectiveClass == clang::Stmt::OMPSectionDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPSingleDirectiveClass == clang::Stmt::OMPSingleDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPMasterDirectiveClass == clang::Stmt::OMPMasterDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPCriticalDirectiveClass == clang::Stmt::OMPCriticalDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPParallelForDirectiveClass == clang::Stmt::OMPParallelForDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPParallelForSimdDirectiveClass == clang::Stmt::OMPParallelForSimdDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPParallelSectionsDirectiveClass == clang::Stmt::OMPParallelSectionsDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTaskDirectiveClass == clang::Stmt::OMPTaskDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTaskyieldDirectiveClass == clang::Stmt::OMPTaskyieldDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPBarrierDirectiveClass == clang::Stmt::OMPBarrierDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTaskwaitDirectiveClass == clang::Stmt::OMPTaskwaitDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTaskgroupDirectiveClass == clang::Stmt::OMPTaskgroupDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPFlushDirectiveClass == clang::Stmt::OMPFlushDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPOrderedDirectiveClass == clang::Stmt::OMPOrderedDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPAtomicDirectiveClass == clang::Stmt::OMPAtomicDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetDirectiveClass == clang::Stmt::OMPTargetDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetDataDirectiveClass == clang::Stmt::OMPTargetDataDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetEnterDataDirectiveClass == clang::Stmt::OMPTargetEnterDataDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetExitDataDirectiveClass == clang::Stmt::OMPTargetExitDataDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetParallelDirectiveClass == clang::Stmt::OMPTargetParallelDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetParallelForDirectiveClass == clang::Stmt::OMPTargetParallelForDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetUpdateDirectiveClass == clang::Stmt::OMPTargetUpdateDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTeamsDirectiveClass == clang::Stmt::OMPTeamsDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPCancellationPointDirectiveClass == clang::Stmt::OMPCancellationPointDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPCancelDirectiveClass == clang::Stmt::OMPCancelDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTaskLoopDirectiveClass == clang::Stmt::OMPTaskLoopDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTaskLoopSimdDirectiveClass == clang::Stmt::OMPTaskLoopSimdDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPDistributeDirectiveClass == clang::Stmt::OMPDistributeDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPDistributeParallelForDirectiveClass == clang::Stmt::OMPDistributeParallelForDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass == clang::Stmt::OMPDistributeParallelForSimdDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPDistributeSimdDirectiveClass == clang::Stmt::OMPDistributeSimdDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetParallelForSimdDirectiveClass == clang::Stmt::OMPTargetParallelForSimdDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetSimdDirectiveClass == clang::Stmt::OMPTargetSimdDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTeamsDistributeDirectiveClass == clang::Stmt::OMPTeamsDistributeDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass == clang::Stmt::OMPTeamsDistributeSimdDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass == clang::Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass == clang::Stmt::OMPTeamsDistributeParallelForDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetTeamsDirectiveClass == clang::Stmt::OMPTargetTeamsDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetTeamsDistributeDirectiveClass == clang::Stmt::OMPTargetTeamsDistributeDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetTeamsDistributeParallelForDirectiveClass == clang::Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass == clang::Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass, ""); +static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass == clang::Stmt::OMPTargetTeamsDistributeSimdDirectiveClass, ""); + static_assert(sizeof(ZigClangSourceLocation) == sizeof(clang::SourceLocation), ""); static ZigClangSourceLocation bitcast(clang::SourceLocation src) { diff --git a/src/zig_clang.h b/src/zig_clang.h index 1e96e9a8e7..6f3f14a4e1 100644 --- a/src/zig_clang.h +++ b/src/zig_clang.h @@ -200,6 +200,206 @@ enum ZigClangTypeClass { ZigClangType_Atomic, }; +enum ZigClangStmtClass { + ZigClangStmt_NoStmtClass = 0, + ZigClangStmt_GCCAsmStmtClass, + ZigClangStmt_MSAsmStmtClass, + ZigClangStmt_AttributedStmtClass, + ZigClangStmt_BreakStmtClass, + ZigClangStmt_CXXCatchStmtClass, + ZigClangStmt_CXXForRangeStmtClass, + ZigClangStmt_CXXTryStmtClass, + ZigClangStmt_CapturedStmtClass, + ZigClangStmt_CompoundStmtClass, + ZigClangStmt_ContinueStmtClass, + ZigClangStmt_CoreturnStmtClass, + ZigClangStmt_CoroutineBodyStmtClass, + ZigClangStmt_DeclStmtClass, + ZigClangStmt_DoStmtClass, + ZigClangStmt_BinaryConditionalOperatorClass, + ZigClangStmt_ConditionalOperatorClass, + ZigClangStmt_AddrLabelExprClass, + ZigClangStmt_ArrayInitIndexExprClass, + ZigClangStmt_ArrayInitLoopExprClass, + ZigClangStmt_ArraySubscriptExprClass, + ZigClangStmt_ArrayTypeTraitExprClass, + ZigClangStmt_AsTypeExprClass, + ZigClangStmt_AtomicExprClass, + ZigClangStmt_BinaryOperatorClass, + ZigClangStmt_CompoundAssignOperatorClass, + ZigClangStmt_BlockExprClass, + ZigClangStmt_CXXBindTemporaryExprClass, + ZigClangStmt_CXXBoolLiteralExprClass, + ZigClangStmt_CXXConstructExprClass, + ZigClangStmt_CXXTemporaryObjectExprClass, + ZigClangStmt_CXXDefaultArgExprClass, + ZigClangStmt_CXXDefaultInitExprClass, + ZigClangStmt_CXXDeleteExprClass, + ZigClangStmt_CXXDependentScopeMemberExprClass, + ZigClangStmt_CXXFoldExprClass, + ZigClangStmt_CXXInheritedCtorInitExprClass, + ZigClangStmt_CXXNewExprClass, + ZigClangStmt_CXXNoexceptExprClass, + ZigClangStmt_CXXNullPtrLiteralExprClass, + ZigClangStmt_CXXPseudoDestructorExprClass, + ZigClangStmt_CXXScalarValueInitExprClass, + ZigClangStmt_CXXStdInitializerListExprClass, + ZigClangStmt_CXXThisExprClass, + ZigClangStmt_CXXThrowExprClass, + ZigClangStmt_CXXTypeidExprClass, + ZigClangStmt_CXXUnresolvedConstructExprClass, + ZigClangStmt_CXXUuidofExprClass, + ZigClangStmt_CallExprClass, + ZigClangStmt_CUDAKernelCallExprClass, + ZigClangStmt_CXXMemberCallExprClass, + ZigClangStmt_CXXOperatorCallExprClass, + ZigClangStmt_UserDefinedLiteralClass, + ZigClangStmt_CStyleCastExprClass, + ZigClangStmt_CXXFunctionalCastExprClass, + ZigClangStmt_CXXConstCastExprClass, + ZigClangStmt_CXXDynamicCastExprClass, + ZigClangStmt_CXXReinterpretCastExprClass, + ZigClangStmt_CXXStaticCastExprClass, + ZigClangStmt_ObjCBridgedCastExprClass, + ZigClangStmt_ImplicitCastExprClass, + ZigClangStmt_CharacterLiteralClass, + ZigClangStmt_ChooseExprClass, + ZigClangStmt_CompoundLiteralExprClass, + ZigClangStmt_ConvertVectorExprClass, + ZigClangStmt_CoawaitExprClass, + ZigClangStmt_CoyieldExprClass, + ZigClangStmt_DeclRefExprClass, + ZigClangStmt_DependentCoawaitExprClass, + ZigClangStmt_DependentScopeDeclRefExprClass, + ZigClangStmt_DesignatedInitExprClass, + ZigClangStmt_DesignatedInitUpdateExprClass, + ZigClangStmt_ExpressionTraitExprClass, + ZigClangStmt_ExtVectorElementExprClass, + ZigClangStmt_FixedPointLiteralClass, + ZigClangStmt_FloatingLiteralClass, + ZigClangStmt_ConstantExprClass, + ZigClangStmt_ExprWithCleanupsClass, + ZigClangStmt_FunctionParmPackExprClass, + ZigClangStmt_GNUNullExprClass, + ZigClangStmt_GenericSelectionExprClass, + ZigClangStmt_ImaginaryLiteralClass, + ZigClangStmt_ImplicitValueInitExprClass, + ZigClangStmt_InitListExprClass, + ZigClangStmt_IntegerLiteralClass, + ZigClangStmt_LambdaExprClass, + ZigClangStmt_MSPropertyRefExprClass, + ZigClangStmt_MSPropertySubscriptExprClass, + ZigClangStmt_MaterializeTemporaryExprClass, + ZigClangStmt_MemberExprClass, + ZigClangStmt_NoInitExprClass, + ZigClangStmt_OMPArraySectionExprClass, + ZigClangStmt_ObjCArrayLiteralClass, + ZigClangStmt_ObjCAvailabilityCheckExprClass, + ZigClangStmt_ObjCBoolLiteralExprClass, + ZigClangStmt_ObjCBoxedExprClass, + ZigClangStmt_ObjCDictionaryLiteralClass, + ZigClangStmt_ObjCEncodeExprClass, + ZigClangStmt_ObjCIndirectCopyRestoreExprClass, + ZigClangStmt_ObjCIsaExprClass, + ZigClangStmt_ObjCIvarRefExprClass, + ZigClangStmt_ObjCMessageExprClass, + ZigClangStmt_ObjCPropertyRefExprClass, + ZigClangStmt_ObjCProtocolExprClass, + ZigClangStmt_ObjCSelectorExprClass, + ZigClangStmt_ObjCStringLiteralClass, + ZigClangStmt_ObjCSubscriptRefExprClass, + ZigClangStmt_OffsetOfExprClass, + ZigClangStmt_OpaqueValueExprClass, + ZigClangStmt_UnresolvedLookupExprClass, + ZigClangStmt_UnresolvedMemberExprClass, + ZigClangStmt_PackExpansionExprClass, + ZigClangStmt_ParenExprClass, + ZigClangStmt_ParenListExprClass, + ZigClangStmt_PredefinedExprClass, + ZigClangStmt_PseudoObjectExprClass, + ZigClangStmt_ShuffleVectorExprClass, + ZigClangStmt_SizeOfPackExprClass, + ZigClangStmt_StmtExprClass, + ZigClangStmt_StringLiteralClass, + ZigClangStmt_SubstNonTypeTemplateParmExprClass, + ZigClangStmt_SubstNonTypeTemplateParmPackExprClass, + ZigClangStmt_TypeTraitExprClass, + ZigClangStmt_TypoExprClass, + ZigClangStmt_UnaryExprOrTypeTraitExprClass, + ZigClangStmt_UnaryOperatorClass, + ZigClangStmt_VAArgExprClass, + ZigClangStmt_ForStmtClass, + ZigClangStmt_GotoStmtClass, + ZigClangStmt_IfStmtClass, + ZigClangStmt_IndirectGotoStmtClass, + ZigClangStmt_LabelStmtClass, + ZigClangStmt_MSDependentExistsStmtClass, + ZigClangStmt_NullStmtClass, + ZigClangStmt_OMPAtomicDirectiveClass, + ZigClangStmt_OMPBarrierDirectiveClass, + ZigClangStmt_OMPCancelDirectiveClass, + ZigClangStmt_OMPCancellationPointDirectiveClass, + ZigClangStmt_OMPCriticalDirectiveClass, + ZigClangStmt_OMPFlushDirectiveClass, + ZigClangStmt_OMPDistributeDirectiveClass, + ZigClangStmt_OMPDistributeParallelForDirectiveClass, + ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass, + ZigClangStmt_OMPDistributeSimdDirectiveClass, + ZigClangStmt_OMPForDirectiveClass, + ZigClangStmt_OMPForSimdDirectiveClass, + ZigClangStmt_OMPParallelForDirectiveClass, + ZigClangStmt_OMPParallelForSimdDirectiveClass, + ZigClangStmt_OMPSimdDirectiveClass, + ZigClangStmt_OMPTargetParallelForSimdDirectiveClass, + ZigClangStmt_OMPTargetSimdDirectiveClass, + ZigClangStmt_OMPTargetTeamsDistributeDirectiveClass, + ZigClangStmt_OMPTargetTeamsDistributeParallelForDirectiveClass, + ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass, + ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass, + ZigClangStmt_OMPTaskLoopDirectiveClass, + ZigClangStmt_OMPTaskLoopSimdDirectiveClass, + ZigClangStmt_OMPTeamsDistributeDirectiveClass, + ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass, + ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass, + ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass, + ZigClangStmt_OMPMasterDirectiveClass, + ZigClangStmt_OMPOrderedDirectiveClass, + ZigClangStmt_OMPParallelDirectiveClass, + ZigClangStmt_OMPParallelSectionsDirectiveClass, + ZigClangStmt_OMPSectionDirectiveClass, + ZigClangStmt_OMPSectionsDirectiveClass, + ZigClangStmt_OMPSingleDirectiveClass, + ZigClangStmt_OMPTargetDataDirectiveClass, + ZigClangStmt_OMPTargetDirectiveClass, + ZigClangStmt_OMPTargetEnterDataDirectiveClass, + ZigClangStmt_OMPTargetExitDataDirectiveClass, + ZigClangStmt_OMPTargetParallelDirectiveClass, + ZigClangStmt_OMPTargetParallelForDirectiveClass, + ZigClangStmt_OMPTargetTeamsDirectiveClass, + ZigClangStmt_OMPTargetUpdateDirectiveClass, + ZigClangStmt_OMPTaskDirectiveClass, + ZigClangStmt_OMPTaskgroupDirectiveClass, + ZigClangStmt_OMPTaskwaitDirectiveClass, + ZigClangStmt_OMPTaskyieldDirectiveClass, + ZigClangStmt_OMPTeamsDirectiveClass, + ZigClangStmt_ObjCAtCatchStmtClass, + ZigClangStmt_ObjCAtFinallyStmtClass, + ZigClangStmt_ObjCAtSynchronizedStmtClass, + ZigClangStmt_ObjCAtThrowStmtClass, + ZigClangStmt_ObjCAtTryStmtClass, + ZigClangStmt_ObjCAutoreleasePoolStmtClass, + ZigClangStmt_ObjCForCollectionStmtClass, + ZigClangStmt_ReturnStmtClass, + ZigClangStmt_SEHExceptStmtClass, + ZigClangStmt_SEHFinallyStmtClass, + ZigClangStmt_SEHLeaveStmtClass, + ZigClangStmt_SEHTryStmtClass, + ZigClangStmt_CaseStmtClass, + ZigClangStmt_DefaultStmtClass, + ZigClangStmt_SwitchStmtClass, + ZigClangStmt_WhileStmtClass, +}; + //struct ZigClangCC_AAPCS; //struct ZigClangCC_AAPCS_VFP; //struct ZigClangCC_C; -- cgit v1.2.3 From 9d229791c68827f8890f0715dc05e3380693645d Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Fri, 12 Apr 2019 14:38:15 -0400 Subject: translate-c: move some code to the C API See #1964 --- src/translate_c.cpp | 390 ++++++++++++++++++++++++++-------------------------- src/zig_clang.cpp | 14 ++ src/zig_clang.h | 5 + 3 files changed, 217 insertions(+), 192 deletions(-) (limited to 'src/zig_clang.cpp') diff --git a/src/translate_c.cpp b/src/translate_c.cpp index 006b4e330f..f2e6f7fac6 100644 --- a/src/translate_c.cpp +++ b/src/translate_c.cpp @@ -116,16 +116,20 @@ static AstNode *resolve_record_decl(Context *c, const ZigClangRecordDecl *record static AstNode *resolve_enum_decl(Context *c, const ZigClangEnumDecl *enum_decl); static AstNode *resolve_typedef_decl(Context *c, const ZigClangTypedefNameDecl *typedef_decl); -static int trans_stmt_extra(Context *c, TransScope *scope, const clang::Stmt *stmt, +static int trans_stmt_extra(Context *c, TransScope *scope, const ZigClangStmt *stmt, ResultUsed result_used, TransLRValue lrval, AstNode **out_node, TransScope **out_child_scope, TransScope **out_node_scope); -static TransScope *trans_stmt(Context *c, TransScope *scope, const clang::Stmt *stmt, AstNode **out_node); +static TransScope *trans_stmt(Context *c, TransScope *scope, const ZigClangStmt *stmt, AstNode **out_node); static AstNode *trans_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::Expr *expr, TransLRValue lrval); static AstNode *trans_qual_type(Context *c, ZigClangQualType qt, ZigClangSourceLocation source_loc); static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::Expr *expr, TransLRValue lrval); static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, ZigClangQualType qt, ZigClangSourceLocation source_loc); +static const ZigClangStmt *bitcast(const clang::Stmt *src) { + return reinterpret_cast(src); +} + static ZigClangSourceLocation bitcast(clang::SourceLocation src) { ZigClangSourceLocation dest; memcpy(&dest, static_cast(&src), sizeof(ZigClangSourceLocation)); @@ -1217,9 +1221,11 @@ static int trans_compound_stmt_inline(Context *c, TransScope *scope, const clang AstNode *block_node, TransScope **out_node_scope) { assert(block_node->type == NodeTypeBlock); - for (clang::CompoundStmt::const_body_iterator it = stmt->body_begin(), end_it = stmt->body_end(); it != end_it; ++it) { + for (clang::CompoundStmt::const_body_iterator it = stmt->body_begin(), end_it = stmt->body_end(); + it != end_it; ++it) + { AstNode *child_node; - scope = trans_stmt(c, scope, *it, &child_node); + scope = trans_stmt(c, scope, bitcast(*it), &child_node); if (scope == nullptr) return ErrorUnexpected; if (child_node != nullptr) @@ -2750,7 +2756,7 @@ static AstNode *trans_while_loop(Context *c, TransScope *scope, const clang::Whi if (while_scope->node->data.while_expr.condition == nullptr) return nullptr; - TransScope *body_scope = trans_stmt(c, &while_scope->base, stmt->getBody(), + TransScope *body_scope = trans_stmt(c, &while_scope->base, bitcast(stmt->getBody()), &while_scope->node->data.while_expr.body); if (body_scope == nullptr) return nullptr; @@ -2763,12 +2769,12 @@ static AstNode *trans_if_statement(Context *c, TransScope *scope, const clang::I // if (c) t else e AstNode *if_node = trans_create_node(c, NodeTypeIfBoolExpr); - TransScope *then_scope = trans_stmt(c, scope, stmt->getThen(), &if_node->data.if_bool_expr.then_block); + TransScope *then_scope = trans_stmt(c, scope, bitcast(stmt->getThen()), &if_node->data.if_bool_expr.then_block); if (then_scope == nullptr) return nullptr; if (stmt->getElse() != nullptr) { - TransScope *else_scope = trans_stmt(c, scope, stmt->getElse(), &if_node->data.if_bool_expr.else_node); + TransScope *else_scope = trans_stmt(c, scope, bitcast(stmt->getElse()), &if_node->data.if_bool_expr.else_node); if (else_scope == nullptr) return nullptr; } @@ -2911,7 +2917,7 @@ static AstNode *trans_do_loop(Context *c, TransScope *parent_scope, const clang: // zig: } // We call the low level function so that we can set child_scope to the scope of the generated block. - if (trans_stmt_extra(c, &while_scope->base, stmt->getBody(), ResultUsedNo, TransRValue, &body_node, + if (trans_stmt_extra(c, &while_scope->base, bitcast(stmt->getBody()), ResultUsedNo, TransRValue, &body_node, nullptr, &child_scope)) { return nullptr; @@ -2929,7 +2935,7 @@ static AstNode *trans_do_loop(Context *c, TransScope *parent_scope, const clang: TransScopeBlock *child_block_scope = trans_scope_block_create(c, &while_scope->base); body_node = child_block_scope->node; AstNode *child_statement; - child_scope = trans_stmt(c, &child_block_scope->base, stmt->getBody(), &child_statement); + child_scope = trans_stmt(c, &child_block_scope->base, bitcast(stmt->getBody()), &child_statement); if (child_scope == nullptr) return nullptr; if (child_statement != nullptr) { body_node->data.block.statements.append(child_statement); @@ -2955,7 +2961,7 @@ static AstNode *trans_for_loop(Context *c, TransScope *parent_scope, const clang AstNode *loop_block_node; TransScopeWhile *while_scope; TransScope *cond_scope; - const clang::Stmt *init_stmt = stmt->getInit(); + const ZigClangStmt *init_stmt = bitcast(stmt->getInit()); if (init_stmt == nullptr) { while_scope = trans_scope_while_create(c, parent_scope); loop_block_node = while_scope->node; @@ -2976,12 +2982,12 @@ static AstNode *trans_for_loop(Context *c, TransScope *parent_scope, const clang child_scope->node->data.block.statements.append(while_scope->node); } - const clang::Stmt *cond_stmt = stmt->getCond(); + const ZigClangStmt *cond_stmt = bitcast(stmt->getCond()); if (cond_stmt == nullptr) { while_scope->node->data.while_expr.condition = trans_create_node_bool(c, true); } else { - if (clang::Expr::classof(cond_stmt)) { - const clang::Expr *cond_expr = static_cast(cond_stmt); + if (ZigClangStmt_classof_Expr(cond_stmt)) { + const clang::Expr *cond_expr = reinterpret_cast(cond_stmt); while_scope->node->data.while_expr.condition = trans_bool_expr(c, ResultUsedYes, cond_scope, cond_expr, TransRValue); if (while_scope->node->data.while_expr.condition == nullptr) @@ -2994,7 +3000,7 @@ static AstNode *trans_for_loop(Context *c, TransScope *parent_scope, const clang } } - const clang::Stmt *inc_stmt = stmt->getInc(); + const ZigClangStmt *inc_stmt = bitcast(stmt->getInc()); if (inc_stmt != nullptr) { AstNode *inc_node; TransScope *inc_scope = trans_stmt(c, cond_scope, inc_stmt, &inc_node); @@ -3004,7 +3010,7 @@ static AstNode *trans_for_loop(Context *c, TransScope *parent_scope, const clang } AstNode *body_statement; - TransScope *body_scope = trans_stmt(c, &while_scope->base, stmt->getBody(), &body_statement); + TransScope *body_scope = trans_stmt(c, &while_scope->base, bitcast(stmt->getBody()), &body_statement); if (body_scope == nullptr) return nullptr; @@ -3027,7 +3033,7 @@ static AstNode *trans_switch_stmt(Context *c, TransScope *parent_scope, const cl switch_scope = trans_scope_switch_create(c, &block_scope->base); } else { AstNode *vars_node; - TransScope *var_scope = trans_stmt(c, &block_scope->base, var_decl_stmt, &vars_node); + TransScope *var_scope = trans_stmt(c, &block_scope->base, (const ZigClangStmt *)var_decl_stmt, &vars_node); if (var_scope == nullptr) return nullptr; if (vars_node != nullptr) @@ -3050,8 +3056,8 @@ static AstNode *trans_switch_stmt(Context *c, TransScope *parent_scope, const cl switch_scope->switch_node->data.switch_expr.expr = expr_node; AstNode *body_node; - const clang::Stmt *body_stmt = stmt->getBody(); - if ((ZigClangStmtClass)body_stmt->getStmtClass() == ZigClangStmt_CompoundStmtClass) { + const ZigClangStmt *body_stmt = bitcast(stmt->getBody()); + if (ZigClangStmt_getStmtClass(body_stmt) == ZigClangStmt_CompoundStmtClass) { if (trans_compound_stmt_inline(c, &switch_scope->base, (const clang::CompoundStmt *)body_stmt, block_scope->node, nullptr)) { @@ -3119,7 +3125,7 @@ static int trans_switch_case(Context *c, TransScope *parent_scope, const clang:: scope_block->node->data.block.statements.append(case_block); AstNode *sub_stmt_node; - TransScope *new_scope = trans_stmt(c, parent_scope, stmt->getSubStmt(), &sub_stmt_node); + TransScope *new_scope = trans_stmt(c, parent_scope, bitcast(stmt->getSubStmt()), &sub_stmt_node); if (new_scope == nullptr) return ErrorUnexpected; if (sub_stmt_node != nullptr) @@ -3156,7 +3162,7 @@ static int trans_switch_default(Context *c, TransScope *parent_scope, const clan scope_block->node->data.block.statements.append(case_block); AstNode *sub_stmt_node; - TransScope *new_scope = trans_stmt(c, parent_scope, stmt->getSubStmt(), &sub_stmt_node); + TransScope *new_scope = trans_stmt(c, parent_scope, bitcast(stmt->getSubStmt()), &sub_stmt_node); if (new_scope == nullptr) return ErrorUnexpected; if (sub_stmt_node != nullptr) @@ -3219,12 +3225,12 @@ static int wrap_stmt(AstNode **out_node, TransScope **out_scope, TransScope *in_ return ErrorNone; } -static int trans_stmt_extra(Context *c, TransScope *scope, const clang::Stmt *stmt, +static int trans_stmt_extra(Context *c, TransScope *scope, const ZigClangStmt *stmt, ResultUsed result_used, TransLRValue lrvalue, AstNode **out_node, TransScope **out_child_scope, TransScope **out_node_scope) { - ZigClangStmtClass sc = (ZigClangStmtClass)stmt->getStmtClass(); + ZigClangStmtClass sc = ZigClangStmt_getStmtClass(stmt); switch (sc) { case ZigClangStmt_ReturnStmtClass: return wrap_stmt(out_node, out_child_scope, scope, @@ -3325,505 +3331,505 @@ static int trans_stmt_extra(Context *c, TransScope *scope, const clang::Stmt *st return wrap_stmt(out_node, out_child_scope, scope, trans_stmt_expr(c, result_used, scope, (const clang::StmtExpr *)stmt, out_node_scope)); case ZigClangStmt_NoStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C NoStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C NoStmtClass"); return ErrorUnexpected; case ZigClangStmt_GCCAsmStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C GCCAsmStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C GCCAsmStmtClass"); return ErrorUnexpected; case ZigClangStmt_MSAsmStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C MSAsmStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C MSAsmStmtClass"); return ErrorUnexpected; case ZigClangStmt_AttributedStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C AttributedStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C AttributedStmtClass"); return ErrorUnexpected; case ZigClangStmt_CXXCatchStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXCatchStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXCatchStmtClass"); return ErrorUnexpected; case ZigClangStmt_CXXForRangeStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXForRangeStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXForRangeStmtClass"); return ErrorUnexpected; case ZigClangStmt_CXXTryStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXTryStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXTryStmtClass"); return ErrorUnexpected; case ZigClangStmt_CapturedStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CapturedStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CapturedStmtClass"); return ErrorUnexpected; case ZigClangStmt_CoreturnStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CoreturnStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CoreturnStmtClass"); return ErrorUnexpected; case ZigClangStmt_CoroutineBodyStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CoroutineBodyStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CoroutineBodyStmtClass"); return ErrorUnexpected; case ZigClangStmt_BinaryConditionalOperatorClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C BinaryConditionalOperatorClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C BinaryConditionalOperatorClass"); return ErrorUnexpected; case ZigClangStmt_AddrLabelExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C AddrLabelExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C AddrLabelExprClass"); return ErrorUnexpected; case ZigClangStmt_ArrayInitIndexExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ArrayInitIndexExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ArrayInitIndexExprClass"); return ErrorUnexpected; case ZigClangStmt_ArrayInitLoopExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ArrayInitLoopExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ArrayInitLoopExprClass"); return ErrorUnexpected; case ZigClangStmt_ArrayTypeTraitExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ArrayTypeTraitExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ArrayTypeTraitExprClass"); return ErrorUnexpected; case ZigClangStmt_AsTypeExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C AsTypeExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C AsTypeExprClass"); return ErrorUnexpected; case ZigClangStmt_AtomicExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C AtomicExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C AtomicExprClass"); return ErrorUnexpected; case ZigClangStmt_BlockExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C BlockExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C BlockExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXBindTemporaryExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXBindTemporaryExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXBindTemporaryExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXBoolLiteralExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXBoolLiteralExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXBoolLiteralExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXConstructExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXConstructExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXConstructExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXTemporaryObjectExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXTemporaryObjectExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXTemporaryObjectExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXDefaultArgExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXDefaultArgExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXDefaultArgExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXDefaultInitExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXDefaultInitExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXDefaultInitExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXDeleteExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXDeleteExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXDeleteExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXDependentScopeMemberExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXDependentScopeMemberExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXDependentScopeMemberExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXFoldExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXFoldExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXFoldExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXInheritedCtorInitExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXInheritedCtorInitExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXInheritedCtorInitExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXNewExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXNewExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXNewExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXNoexceptExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXNoexceptExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXNoexceptExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXNullPtrLiteralExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXNullPtrLiteralExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXNullPtrLiteralExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXPseudoDestructorExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXPseudoDestructorExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXPseudoDestructorExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXScalarValueInitExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXScalarValueInitExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXScalarValueInitExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXStdInitializerListExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXStdInitializerListExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXStdInitializerListExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXThisExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXThisExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXThisExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXThrowExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXThrowExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXThrowExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXTypeidExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXTypeidExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXTypeidExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXUnresolvedConstructExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXUnresolvedConstructExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXUnresolvedConstructExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXUuidofExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXUuidofExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXUuidofExprClass"); return ErrorUnexpected; case ZigClangStmt_CUDAKernelCallExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CUDAKernelCallExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CUDAKernelCallExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXMemberCallExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXMemberCallExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXMemberCallExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXOperatorCallExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXOperatorCallExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXOperatorCallExprClass"); return ErrorUnexpected; case ZigClangStmt_UserDefinedLiteralClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C UserDefinedLiteralClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C UserDefinedLiteralClass"); return ErrorUnexpected; case ZigClangStmt_CXXFunctionalCastExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXFunctionalCastExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXFunctionalCastExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXConstCastExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXConstCastExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXConstCastExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXDynamicCastExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXDynamicCastExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXDynamicCastExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXReinterpretCastExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXReinterpretCastExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXReinterpretCastExprClass"); return ErrorUnexpected; case ZigClangStmt_CXXStaticCastExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CXXStaticCastExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CXXStaticCastExprClass"); return ErrorUnexpected; case ZigClangStmt_ObjCBridgedCastExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCBridgedCastExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCBridgedCastExprClass"); return ErrorUnexpected; case ZigClangStmt_CharacterLiteralClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CharacterLiteralClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CharacterLiteralClass"); return ErrorUnexpected; case ZigClangStmt_ChooseExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ChooseExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ChooseExprClass"); return ErrorUnexpected; case ZigClangStmt_CompoundLiteralExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CompoundLiteralExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CompoundLiteralExprClass"); return ErrorUnexpected; case ZigClangStmt_ConvertVectorExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ConvertVectorExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ConvertVectorExprClass"); return ErrorUnexpected; case ZigClangStmt_CoawaitExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CoawaitExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CoawaitExprClass"); return ErrorUnexpected; case ZigClangStmt_CoyieldExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CoyieldExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C CoyieldExprClass"); return ErrorUnexpected; case ZigClangStmt_DependentCoawaitExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C DependentCoawaitExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C DependentCoawaitExprClass"); return ErrorUnexpected; case ZigClangStmt_DependentScopeDeclRefExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C DependentScopeDeclRefExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C DependentScopeDeclRefExprClass"); return ErrorUnexpected; case ZigClangStmt_DesignatedInitExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C DesignatedInitExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C DesignatedInitExprClass"); return ErrorUnexpected; case ZigClangStmt_DesignatedInitUpdateExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C DesignatedInitUpdateExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C DesignatedInitUpdateExprClass"); return ErrorUnexpected; case ZigClangStmt_ExpressionTraitExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ExpressionTraitExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ExpressionTraitExprClass"); return ErrorUnexpected; case ZigClangStmt_ExtVectorElementExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ExtVectorElementExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ExtVectorElementExprClass"); return ErrorUnexpected; case ZigClangStmt_FixedPointLiteralClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C FixedPointLiteralClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C FixedPointLiteralClass"); return ErrorUnexpected; case ZigClangStmt_FloatingLiteralClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C FloatingLiteralClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C FloatingLiteralClass"); return ErrorUnexpected; case ZigClangStmt_ExprWithCleanupsClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ExprWithCleanupsClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ExprWithCleanupsClass"); return ErrorUnexpected; case ZigClangStmt_FunctionParmPackExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C FunctionParmPackExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C FunctionParmPackExprClass"); return ErrorUnexpected; case ZigClangStmt_GNUNullExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C GNUNullExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C GNUNullExprClass"); return ErrorUnexpected; case ZigClangStmt_GenericSelectionExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C GenericSelectionExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C GenericSelectionExprClass"); return ErrorUnexpected; case ZigClangStmt_ImaginaryLiteralClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ImaginaryLiteralClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ImaginaryLiteralClass"); return ErrorUnexpected; case ZigClangStmt_ImplicitValueInitExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ImplicitValueInitExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ImplicitValueInitExprClass"); return ErrorUnexpected; case ZigClangStmt_InitListExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C InitListExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C InitListExprClass"); return ErrorUnexpected; case ZigClangStmt_LambdaExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C LambdaExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C LambdaExprClass"); return ErrorUnexpected; case ZigClangStmt_MSPropertyRefExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C MSPropertyRefExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C MSPropertyRefExprClass"); return ErrorUnexpected; case ZigClangStmt_MSPropertySubscriptExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C MSPropertySubscriptExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C MSPropertySubscriptExprClass"); return ErrorUnexpected; case ZigClangStmt_MaterializeTemporaryExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C MaterializeTemporaryExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C MaterializeTemporaryExprClass"); return ErrorUnexpected; case ZigClangStmt_NoInitExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C NoInitExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C NoInitExprClass"); return ErrorUnexpected; case ZigClangStmt_OMPArraySectionExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPArraySectionExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPArraySectionExprClass"); return ErrorUnexpected; case ZigClangStmt_ObjCArrayLiteralClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCArrayLiteralClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCArrayLiteralClass"); return ErrorUnexpected; case ZigClangStmt_ObjCAvailabilityCheckExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCAvailabilityCheckExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCAvailabilityCheckExprClass"); return ErrorUnexpected; case ZigClangStmt_ObjCBoolLiteralExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCBoolLiteralExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCBoolLiteralExprClass"); return ErrorUnexpected; case ZigClangStmt_ObjCBoxedExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCBoxedExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCBoxedExprClass"); return ErrorUnexpected; case ZigClangStmt_ObjCDictionaryLiteralClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCDictionaryLiteralClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCDictionaryLiteralClass"); return ErrorUnexpected; case ZigClangStmt_ObjCEncodeExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCEncodeExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCEncodeExprClass"); return ErrorUnexpected; case ZigClangStmt_ObjCIndirectCopyRestoreExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCIndirectCopyRestoreExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCIndirectCopyRestoreExprClass"); return ErrorUnexpected; case ZigClangStmt_ObjCIsaExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCIsaExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCIsaExprClass"); return ErrorUnexpected; case ZigClangStmt_ObjCIvarRefExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCIvarRefExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCIvarRefExprClass"); return ErrorUnexpected; case ZigClangStmt_ObjCMessageExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCMessageExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCMessageExprClass"); return ErrorUnexpected; case ZigClangStmt_ObjCPropertyRefExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCPropertyRefExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCPropertyRefExprClass"); return ErrorUnexpected; case ZigClangStmt_ObjCProtocolExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCProtocolExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCProtocolExprClass"); return ErrorUnexpected; case ZigClangStmt_ObjCSelectorExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCSelectorExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCSelectorExprClass"); return ErrorUnexpected; case ZigClangStmt_ObjCStringLiteralClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCStringLiteralClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCStringLiteralClass"); return ErrorUnexpected; case ZigClangStmt_ObjCSubscriptRefExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCSubscriptRefExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCSubscriptRefExprClass"); return ErrorUnexpected; case ZigClangStmt_OffsetOfExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OffsetOfExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OffsetOfExprClass"); return ErrorUnexpected; case ZigClangStmt_OpaqueValueExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OpaqueValueExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OpaqueValueExprClass"); return ErrorUnexpected; case ZigClangStmt_UnresolvedLookupExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C UnresolvedLookupExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C UnresolvedLookupExprClass"); return ErrorUnexpected; case ZigClangStmt_UnresolvedMemberExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C UnresolvedMemberExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C UnresolvedMemberExprClass"); return ErrorUnexpected; case ZigClangStmt_PackExpansionExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C PackExpansionExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C PackExpansionExprClass"); return ErrorUnexpected; case ZigClangStmt_ParenListExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ParenListExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ParenListExprClass"); return ErrorUnexpected; case ZigClangStmt_PseudoObjectExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C PseudoObjectExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C PseudoObjectExprClass"); return ErrorUnexpected; case ZigClangStmt_ShuffleVectorExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ShuffleVectorExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ShuffleVectorExprClass"); return ErrorUnexpected; case ZigClangStmt_SizeOfPackExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C SizeOfPackExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C SizeOfPackExprClass"); return ErrorUnexpected; case ZigClangStmt_SubstNonTypeTemplateParmExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C SubstNonTypeTemplateParmExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C SubstNonTypeTemplateParmExprClass"); return ErrorUnexpected; case ZigClangStmt_SubstNonTypeTemplateParmPackExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C SubstNonTypeTemplateParmPackExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C SubstNonTypeTemplateParmPackExprClass"); return ErrorUnexpected; case ZigClangStmt_TypeTraitExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C TypeTraitExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C TypeTraitExprClass"); return ErrorUnexpected; case ZigClangStmt_TypoExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C TypoExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C TypoExprClass"); return ErrorUnexpected; case ZigClangStmt_VAArgExprClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C VAArgExprClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C VAArgExprClass"); return ErrorUnexpected; case ZigClangStmt_GotoStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C GotoStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C GotoStmtClass"); return ErrorUnexpected; case ZigClangStmt_IndirectGotoStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C IndirectGotoStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C IndirectGotoStmtClass"); return ErrorUnexpected; case ZigClangStmt_LabelStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C LabelStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C LabelStmtClass"); return ErrorUnexpected; case ZigClangStmt_MSDependentExistsStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C MSDependentExistsStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C MSDependentExistsStmtClass"); return ErrorUnexpected; case ZigClangStmt_OMPAtomicDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPAtomicDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPAtomicDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPBarrierDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPBarrierDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPBarrierDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPCancelDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPCancelDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPCancelDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPCancellationPointDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPCancellationPointDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPCancellationPointDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPCriticalDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPCriticalDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPCriticalDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPFlushDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPFlushDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPFlushDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPDistributeDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPDistributeDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPDistributeDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPDistributeParallelForDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPDistributeParallelForDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPDistributeParallelForDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPDistributeParallelForSimdDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPDistributeParallelForSimdDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPDistributeSimdDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPDistributeSimdDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPDistributeSimdDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPForDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPForDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPForDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPForSimdDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPForSimdDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPForSimdDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPParallelForDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPParallelForDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPParallelForDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPParallelForSimdDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPParallelForSimdDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPParallelForSimdDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPSimdDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPSimdDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPSimdDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTargetParallelForSimdDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetParallelForSimdDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetParallelForSimdDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTargetSimdDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetSimdDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetSimdDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTargetTeamsDistributeDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetTeamsDistributeDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetTeamsDistributeDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTargetTeamsDistributeParallelForDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetTeamsDistributeParallelForDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetTeamsDistributeParallelForDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetTeamsDistributeParallelForSimdDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetTeamsDistributeParallelForSimdDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetTeamsDistributeSimdDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetTeamsDistributeSimdDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTaskLoopDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTaskLoopDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTaskLoopDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTaskLoopSimdDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTaskLoopSimdDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTaskLoopSimdDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTeamsDistributeDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTeamsDistributeDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTeamsDistributeDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTeamsDistributeParallelForDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTeamsDistributeParallelForDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTeamsDistributeParallelForSimdDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTeamsDistributeParallelForSimdDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTeamsDistributeSimdDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTeamsDistributeSimdDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPMasterDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPMasterDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPMasterDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPOrderedDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPOrderedDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPOrderedDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPParallelDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPParallelDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPParallelDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPParallelSectionsDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPParallelSectionsDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPParallelSectionsDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPSectionDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPSectionDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPSectionDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPSectionsDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPSectionsDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPSectionsDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPSingleDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPSingleDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPSingleDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTargetDataDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetDataDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetDataDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTargetDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTargetEnterDataDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetEnterDataDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetEnterDataDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTargetExitDataDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetExitDataDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetExitDataDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTargetParallelDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetParallelDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetParallelDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTargetParallelForDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetParallelForDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetParallelForDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTargetTeamsDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetTeamsDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetTeamsDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTargetUpdateDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTargetUpdateDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTargetUpdateDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTaskDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTaskDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTaskDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTaskgroupDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTaskgroupDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTaskgroupDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTaskwaitDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTaskwaitDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTaskwaitDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTaskyieldDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTaskyieldDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTaskyieldDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_OMPTeamsDirectiveClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C OMPTeamsDirectiveClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C OMPTeamsDirectiveClass"); return ErrorUnexpected; case ZigClangStmt_ObjCAtCatchStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCAtCatchStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCAtCatchStmtClass"); return ErrorUnexpected; case ZigClangStmt_ObjCAtFinallyStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCAtFinallyStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCAtFinallyStmtClass"); return ErrorUnexpected; case ZigClangStmt_ObjCAtSynchronizedStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCAtSynchronizedStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCAtSynchronizedStmtClass"); return ErrorUnexpected; case ZigClangStmt_ObjCAtThrowStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCAtThrowStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCAtThrowStmtClass"); return ErrorUnexpected; case ZigClangStmt_ObjCAtTryStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCAtTryStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCAtTryStmtClass"); return ErrorUnexpected; case ZigClangStmt_ObjCAutoreleasePoolStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCAutoreleasePoolStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCAutoreleasePoolStmtClass"); return ErrorUnexpected; case ZigClangStmt_ObjCForCollectionStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C ObjCForCollectionStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C ObjCForCollectionStmtClass"); return ErrorUnexpected; case ZigClangStmt_SEHExceptStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C SEHExceptStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C SEHExceptStmtClass"); return ErrorUnexpected; case ZigClangStmt_SEHFinallyStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C SEHFinallyStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C SEHFinallyStmtClass"); return ErrorUnexpected; case ZigClangStmt_SEHLeaveStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C SEHLeaveStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C SEHLeaveStmtClass"); return ErrorUnexpected; case ZigClangStmt_SEHTryStmtClass: - emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C SEHTryStmtClass"); + emit_warning(c, ZigClangStmt_getBeginLoc(stmt), "TODO handle C SEHTryStmtClass"); return ErrorUnexpected; } zig_unreachable(); @@ -3835,7 +3841,7 @@ static AstNode *trans_expr(Context *c, ResultUsed result_used, TransScope *scope { AstNode *result_node; TransScope *result_scope; - if (trans_stmt_extra(c, scope, expr, result_used, lrval, &result_node, &result_scope, nullptr)) { + if (trans_stmt_extra(c, scope, (const ZigClangStmt *)expr, result_used, lrval, &result_node, &result_scope, nullptr)) { return nullptr; } return result_node; @@ -3843,7 +3849,7 @@ static AstNode *trans_expr(Context *c, ResultUsed result_used, TransScope *scope // Statements have no result and no concept of L or R value. // Returns child scope, or null if there was an error -static TransScope *trans_stmt(Context *c, TransScope *scope, const clang::Stmt *stmt, AstNode **out_node) { +static TransScope *trans_stmt(Context *c, TransScope *scope, const ZigClangStmt *stmt, AstNode **out_node) { TransScope *child_scope; if (trans_stmt_extra(c, scope, stmt, ResultUsedNo, TransRValue, out_node, &child_scope, nullptr)) { return nullptr; @@ -3913,7 +3919,7 @@ static void visit_fn_decl(Context *c, const clang::FunctionDecl *fn_decl) { // actual function definition with body c->ptr_params.clear(); - clang::Stmt *body = fn_decl->getBody(); + const ZigClangStmt *body = bitcast(fn_decl->getBody()); AstNode *actual_body_node; TransScope *result_scope = trans_stmt(c, scope, body, &actual_body_node); if (result_scope == nullptr) { diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp index c892426363..003fd0cc7d 100644 --- a/src/zig_clang.cpp +++ b/src/zig_clang.cpp @@ -871,3 +871,17 @@ const char *ZigClangType_getTypeClassName(const ZigClangType *self) { return casted->getTypeClassName(); } +ZigClangSourceLocation ZigClangStmt_getBeginLoc(const ZigClangStmt *self) { + auto casted = reinterpret_cast(self); + return bitcast(casted->getBeginLoc()); +} + +bool ZigClangStmt_classof_Expr(const ZigClangStmt *self) { + auto casted = reinterpret_cast(self); + return clang::Expr::classof(casted); +} + +ZigClangStmtClass ZigClangStmt_getStmtClass(const ZigClangStmt *self) { + auto casted = reinterpret_cast(self); + return (ZigClangStmtClass)casted->getStmtClass(); +} diff --git a/src/zig_clang.h b/src/zig_clang.h index 6f3f14a4e1..544cc7e4d7 100644 --- a/src/zig_clang.h +++ b/src/zig_clang.h @@ -547,4 +547,9 @@ ZIG_EXTERN_C bool ZigClangQualType_isRestrictQualified(ZigClangQualType); ZIG_EXTERN_C ZigClangTypeClass ZigClangType_getTypeClass(const ZigClangType *self); ZIG_EXTERN_C bool ZigClangType_isVoidType(const ZigClangType *self); ZIG_EXTERN_C const char *ZigClangType_getTypeClassName(const ZigClangType *self); + +ZIG_EXTERN_C ZigClangSourceLocation ZigClangStmt_getBeginLoc(const ZigClangStmt *self); +ZIG_EXTERN_C ZigClangStmtClass ZigClangStmt_getStmtClass(const ZigClangStmt *self); +ZIG_EXTERN_C bool ZigClangStmt_classof_Expr(const ZigClangStmt *self); + #endif -- cgit v1.2.3 From 5cb18e9c6f5ee49541579ba3e45d9de4fcec8bcb Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Mon, 15 Apr 2019 00:32:27 -0400 Subject: translate-c: move some code to the C API See #1964 --- src/translate_c.cpp | 358 ++++++++++++++++++++++++++-------------------------- src/zig_clang.cpp | 141 +++++++++++++++++++++ src/zig_clang.h | 122 +++++++++--------- 3 files changed, 387 insertions(+), 234 deletions(-) (limited to 'src/zig_clang.cpp') diff --git a/src/translate_c.cpp b/src/translate_c.cpp index f2e6f7fac6..13d9251e6b 100644 --- a/src/translate_c.cpp +++ b/src/translate_c.cpp @@ -121,15 +121,20 @@ static int trans_stmt_extra(Context *c, TransScope *scope, const ZigClangStmt *s AstNode **out_node, TransScope **out_child_scope, TransScope **out_node_scope); static TransScope *trans_stmt(Context *c, TransScope *scope, const ZigClangStmt *stmt, AstNode **out_node); -static AstNode *trans_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::Expr *expr, TransLRValue lrval); +static AstNode *trans_expr(Context *c, ResultUsed result_used, TransScope *scope, const ZigClangExpr *expr, TransLRValue lrval); static AstNode *trans_qual_type(Context *c, ZigClangQualType qt, ZigClangSourceLocation source_loc); -static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::Expr *expr, TransLRValue lrval); +static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *scope, + const ZigClangExpr *expr, TransLRValue lrval); static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, ZigClangQualType qt, ZigClangSourceLocation source_loc); static const ZigClangStmt *bitcast(const clang::Stmt *src) { return reinterpret_cast(src); } +static const ZigClangExpr *bitcast(const clang::Expr *src) { + return reinterpret_cast(src); +} + static ZigClangSourceLocation bitcast(clang::SourceLocation src) { ZigClangSourceLocation dest; memcpy(&dest, static_cast(&src), sizeof(ZigClangSourceLocation)); @@ -511,14 +516,14 @@ static const ZigClangType *qual_type_canon(ZigClangQualType qt) { return ZigClangQualType_getTypePtr(canon); } -static ZigClangQualType get_expr_qual_type(Context *c, const clang::Expr *expr) { +static ZigClangQualType get_expr_qual_type(Context *c, const ZigClangExpr *expr) { // String literals in C are `char *` but they should really be `const char *`. - if ((ZigClangStmtClass)expr->getStmtClass() == ZigClangStmt_ImplicitCastExprClass) { - const clang::ImplicitCastExpr *cast_expr = static_cast(expr); - if (cast_expr->getCastKind() == clang::CK_ArrayToPointerDecay) { - const clang::Expr *sub_expr = cast_expr->getSubExpr(); - if ((ZigClangStmtClass)sub_expr->getStmtClass() == ZigClangStmt_StringLiteralClass) { - ZigClangQualType array_qt = bitcast(sub_expr->getType()); + if (ZigClangExpr_getStmtClass(expr) == ZigClangStmt_ImplicitCastExprClass) { + const clang::ImplicitCastExpr *cast_expr = reinterpret_cast(expr); + if ((ZigClangCK)cast_expr->getCastKind() == ZigClangCK_ArrayToPointerDecay) { + const ZigClangExpr *sub_expr = bitcast(cast_expr->getSubExpr()); + if (ZigClangExpr_getStmtClass(sub_expr) == ZigClangStmt_StringLiteralClass) { + ZigClangQualType array_qt = ZigClangExpr_getType(sub_expr); const clang::ArrayType *array_type = reinterpret_cast( ZigClangQualType_getTypePtr(array_qt)); ZigClangQualType pointee_qt = bitcast(array_type->getElementType()); @@ -527,26 +532,26 @@ static ZigClangQualType get_expr_qual_type(Context *c, const clang::Expr *expr) } } } - return bitcast(expr->getType()); + return ZigClangExpr_getType(expr); } -static ZigClangQualType get_expr_qual_type_before_implicit_cast(Context *c, const clang::Expr *expr) { - if ((ZigClangStmtClass)expr->getStmtClass() == ZigClangStmt_ImplicitCastExprClass) { - const clang::ImplicitCastExpr *cast_expr = static_cast(expr); - return get_expr_qual_type(c, cast_expr->getSubExpr()); +static ZigClangQualType get_expr_qual_type_before_implicit_cast(Context *c, const ZigClangExpr *expr) { + if (ZigClangExpr_getStmtClass(expr) == ZigClangStmt_ImplicitCastExprClass) { + const clang::ImplicitCastExpr *cast_expr = reinterpret_cast(expr); + return get_expr_qual_type(c, bitcast(cast_expr->getSubExpr())); } - return bitcast(expr->getType()); + return ZigClangExpr_getType(expr); } -static AstNode *get_expr_type(Context *c, const clang::Expr *expr) { - return trans_qual_type(c, get_expr_qual_type(c, expr), bitcast(expr->getBeginLoc())); +static AstNode *get_expr_type(Context *c, const ZigClangExpr *expr) { + return trans_qual_type(c, get_expr_qual_type(c, expr), ZigClangExpr_getBeginLoc(expr)); } static bool is_c_void_type(AstNode *node) { return (node->type == NodeTypeSymbol && buf_eql_str(node->data.symbol_expr.symbol, "c_void")); } -static bool expr_types_equal(Context *c, const clang::Expr *expr1, const clang::Expr *expr2) { +static bool expr_types_equal(Context *c, const ZigClangExpr *expr1, const ZigClangExpr *expr2) { ZigClangQualType t1 = get_expr_qual_type(c, expr1); ZigClangQualType t2 = get_expr_qual_type(c, expr2); @@ -1272,7 +1277,7 @@ static AstNode *trans_stmt_expr(Context *c, ResultUsed result_used, TransScope * } static AstNode *trans_return_stmt(Context *c, TransScope *scope, const clang::ReturnStmt *stmt) { - const clang::Expr *value_expr = stmt->getRetValue(); + const ZigClangExpr *value_expr = bitcast(stmt->getRetValue()); if (value_expr == nullptr) { return trans_create_node(c, NodeTypeReturnExpr); } else { @@ -1311,9 +1316,9 @@ static AstNode *trans_conditional_operator(Context *c, ResultUsed result_used, T { AstNode *node = trans_create_node(c, NodeTypeIfBoolExpr); - clang::Expr *cond_expr = stmt->getCond(); - clang::Expr *true_expr = stmt->getTrueExpr(); - clang::Expr *false_expr = stmt->getFalseExpr(); + const ZigClangExpr *cond_expr = bitcast(stmt->getCond()); + const ZigClangExpr *true_expr = bitcast(stmt->getTrueExpr()); + const ZigClangExpr *false_expr = bitcast(stmt->getFalseExpr()); node->data.if_bool_expr.condition = trans_expr(c, ResultUsedYes, scope, cond_expr, TransRValue); if (node->data.if_bool_expr.condition == nullptr) @@ -1330,7 +1335,9 @@ static AstNode *trans_conditional_operator(Context *c, ResultUsed result_used, T return maybe_suppress_result(c, result_used, node); } -static AstNode *trans_create_bin_op(Context *c, TransScope *scope, clang::Expr *lhs, BinOpType bin_op, clang::Expr *rhs) { +static AstNode *trans_create_bin_op(Context *c, TransScope *scope, const ZigClangExpr *lhs, + BinOpType bin_op, const ZigClangExpr *rhs) +{ AstNode *node = trans_create_node(c, NodeTypeBinOpExpr); node->data.bin_op_expr.bin_op = bin_op; @@ -1345,7 +1352,9 @@ static AstNode *trans_create_bin_op(Context *c, TransScope *scope, clang::Expr * return node; } -static AstNode *trans_create_bool_bin_op(Context *c, TransScope *scope, clang::Expr *lhs, BinOpType bin_op, clang::Expr *rhs) { +static AstNode *trans_create_bool_bin_op(Context *c, TransScope *scope, const ZigClangExpr *lhs, + BinOpType bin_op, const ZigClangExpr *rhs) +{ assert(bin_op == BinOpTypeBoolAnd || bin_op == BinOpTypeBoolOr); AstNode *node = trans_create_node(c, NodeTypeBinOpExpr); node->data.bin_op_expr.bin_op = bin_op; @@ -1361,7 +1370,9 @@ static AstNode *trans_create_bool_bin_op(Context *c, TransScope *scope, clang::E return node; } -static AstNode *trans_create_assign(Context *c, ResultUsed result_used, TransScope *scope, clang::Expr *lhs, clang::Expr *rhs) { +static AstNode *trans_create_assign(Context *c, ResultUsed result_used, TransScope *scope, + const ZigClangExpr *lhs, const ZigClangExpr *rhs) +{ if (result_used == ResultUsedNo) { // common case AstNode *node = trans_create_node(c, NodeTypeBinOpExpr); @@ -1413,9 +1424,9 @@ static AstNode *trans_create_assign(Context *c, ResultUsed result_used, TransSco } static AstNode *trans_create_shift_op(Context *c, TransScope *scope, ZigClangQualType result_type, - clang::Expr *lhs_expr, BinOpType bin_op, clang::Expr *rhs_expr) + const ZigClangExpr *lhs_expr, BinOpType bin_op, const ZigClangExpr *rhs_expr) { - ZigClangSourceLocation rhs_location = bitcast(rhs_expr->getBeginLoc()); + ZigClangSourceLocation rhs_location = ZigClangExpr_getBeginLoc(rhs_expr); AstNode *rhs_type = qual_type_to_log2_int_ref(c, result_type, rhs_location); // lhs >> u5(rh) @@ -1441,23 +1452,23 @@ static AstNode *trans_binary_operator(Context *c, ResultUsed result_used, TransS emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle more C binary operators: BO_Cmp"); return nullptr; case clang::BO_Mul: { - AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), + AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())) ? BinOpTypeMultWrap : BinOpTypeMult, - stmt->getRHS()); + bitcast(stmt->getRHS())); return maybe_suppress_result(c, result_used, node); } case clang::BO_Div: if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType()))) { // unsigned/float division uses the operator - AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeDiv, stmt->getRHS()); + AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeDiv, bitcast(stmt->getRHS())); return maybe_suppress_result(c, result_used, node); } else { // signed integer division uses @divTrunc AstNode *fn_call = trans_create_node_builtin_fn_call_str(c, "divTrunc"); - AstNode *lhs = trans_expr(c, ResultUsedYes, scope, stmt->getLHS(), TransLValue); + AstNode *lhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getLHS()), TransLValue); if (lhs == nullptr) return nullptr; fn_call->data.fn_call_expr.params.append(lhs); - AstNode *rhs = trans_expr(c, ResultUsedYes, scope, stmt->getRHS(), TransLValue); + AstNode *rhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getRHS()), TransLValue); if (rhs == nullptr) return nullptr; fn_call->data.fn_call_expr.params.append(rhs); return maybe_suppress_result(c, result_used, fn_call); @@ -1465,97 +1476,97 @@ static AstNode *trans_binary_operator(Context *c, ResultUsed result_used, TransS case clang::BO_Rem: if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType()))) { // unsigned/float division uses the operator - AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeMod, stmt->getRHS()); + AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeMod, bitcast(stmt->getRHS())); return maybe_suppress_result(c, result_used, node); } else { // signed integer division uses @rem AstNode *fn_call = trans_create_node_builtin_fn_call_str(c, "rem"); - AstNode *lhs = trans_expr(c, ResultUsedYes, scope, stmt->getLHS(), TransLValue); + AstNode *lhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getLHS()), TransLValue); if (lhs == nullptr) return nullptr; fn_call->data.fn_call_expr.params.append(lhs); - AstNode *rhs = trans_expr(c, ResultUsedYes, scope, stmt->getRHS(), TransLValue); + AstNode *rhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getRHS()), TransLValue); if (rhs == nullptr) return nullptr; fn_call->data.fn_call_expr.params.append(rhs); return maybe_suppress_result(c, result_used, fn_call); } case clang::BO_Add: { - AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), + AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())) ? BinOpTypeAddWrap : BinOpTypeAdd, - stmt->getRHS()); + bitcast(stmt->getRHS())); return maybe_suppress_result(c, result_used, node); } case clang::BO_Sub: { - AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), + AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())) ? BinOpTypeSubWrap : BinOpTypeSub, - stmt->getRHS()); + bitcast(stmt->getRHS())); return maybe_suppress_result(c, result_used, node); } case clang::BO_Shl: { - AstNode *node = trans_create_shift_op(c, scope, bitcast(stmt->getType()), stmt->getLHS(), BinOpTypeBitShiftLeft, stmt->getRHS()); + AstNode *node = trans_create_shift_op(c, scope, bitcast(stmt->getType()), bitcast(stmt->getLHS()), BinOpTypeBitShiftLeft, bitcast(stmt->getRHS())); return maybe_suppress_result(c, result_used, node); } case clang::BO_Shr: { - AstNode *node = trans_create_shift_op(c, scope, bitcast(stmt->getType()), stmt->getLHS(), BinOpTypeBitShiftRight, stmt->getRHS()); + AstNode *node = trans_create_shift_op(c, scope, bitcast(stmt->getType()), bitcast(stmt->getLHS()), BinOpTypeBitShiftRight, bitcast(stmt->getRHS())); return maybe_suppress_result(c, result_used, node); } case clang::BO_LT: { - AstNode *node =trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeCmpLessThan, stmt->getRHS()); + AstNode *node =trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeCmpLessThan, bitcast(stmt->getRHS())); return maybe_suppress_result(c, result_used, node); } case clang::BO_GT: { - AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeCmpGreaterThan, stmt->getRHS()); + AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeCmpGreaterThan, bitcast(stmt->getRHS())); return maybe_suppress_result(c, result_used, node); } case clang::BO_LE: { - AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeCmpLessOrEq, stmt->getRHS()); + AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeCmpLessOrEq, bitcast(stmt->getRHS())); return maybe_suppress_result(c, result_used, node); } case clang::BO_GE: { - AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeCmpGreaterOrEq, stmt->getRHS()); + AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeCmpGreaterOrEq, bitcast(stmt->getRHS())); return maybe_suppress_result(c, result_used, node); } case clang::BO_EQ: { - AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeCmpEq, stmt->getRHS()); + AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeCmpEq, bitcast(stmt->getRHS())); return maybe_suppress_result(c, result_used, node); } case clang::BO_NE: { - AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeCmpNotEq, stmt->getRHS()); + AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeCmpNotEq, bitcast(stmt->getRHS())); return maybe_suppress_result(c, result_used, node); } case clang::BO_And: { - AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeBinAnd, stmt->getRHS()); + AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeBinAnd, bitcast(stmt->getRHS())); return maybe_suppress_result(c, result_used, node); } case clang::BO_Xor: { - AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeBinXor, stmt->getRHS()); + AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeBinXor, bitcast(stmt->getRHS())); return maybe_suppress_result(c, result_used, node); } case clang::BO_Or: { - AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeBinOr, stmt->getRHS()); + AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeBinOr, bitcast(stmt->getRHS())); return maybe_suppress_result(c, result_used, node); } case clang::BO_LAnd: { - AstNode *node = trans_create_bool_bin_op(c, scope, stmt->getLHS(), BinOpTypeBoolAnd, stmt->getRHS()); + AstNode *node = trans_create_bool_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeBoolAnd, bitcast(stmt->getRHS())); return maybe_suppress_result(c, result_used, node); } case clang::BO_LOr: { - AstNode *node = trans_create_bool_bin_op(c, scope, stmt->getLHS(), BinOpTypeBoolOr, stmt->getRHS()); + AstNode *node = trans_create_bool_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeBoolOr, bitcast(stmt->getRHS())); return maybe_suppress_result(c, result_used, node); } case clang::BO_Assign: - return trans_create_assign(c, result_used, scope, stmt->getLHS(), stmt->getRHS()); + return trans_create_assign(c, result_used, scope, bitcast(stmt->getLHS()), bitcast(stmt->getRHS())); case clang::BO_Comma: { TransScopeBlock *scope_block = trans_scope_block_create(c, scope); Buf *label_name = buf_create_from_str("x"); scope_block->node->data.block.name = label_name; - AstNode *lhs = trans_expr(c, ResultUsedNo, &scope_block->base, stmt->getLHS(), TransRValue); + AstNode *lhs = trans_expr(c, ResultUsedNo, &scope_block->base, bitcast(stmt->getLHS()), TransRValue); if (lhs == nullptr) return nullptr; scope_block->node->data.block.statements.append(lhs); - AstNode *rhs = trans_expr(c, ResultUsedYes, &scope_block->base, stmt->getRHS(), TransRValue); + AstNode *rhs = trans_expr(c, ResultUsedYes, &scope_block->base, bitcast(stmt->getRHS()), TransRValue); if (rhs == nullptr) return nullptr; @@ -1589,10 +1600,10 @@ static AstNode *trans_create_compound_assign_shift(Context *c, ResultUsed result if (!use_intermediate_casts && result_used == ResultUsedNo) { // simple common case, where the C and Zig are identical: // lhs >>= rhs - AstNode *lhs = trans_expr(c, ResultUsedYes, scope, stmt->getLHS(), TransLValue); + AstNode *lhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getLHS()), TransLValue); if (lhs == nullptr) return nullptr; - AstNode *rhs = trans_expr(c, ResultUsedYes, scope, stmt->getRHS(), TransRValue); + AstNode *rhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getRHS()), TransRValue); if (rhs == nullptr) return nullptr; AstNode *coerced_rhs = trans_create_node_fn_call_1(c, rhs_type, rhs); @@ -1612,7 +1623,7 @@ static AstNode *trans_create_compound_assign_shift(Context *c, ResultUsed result child_scope->node->data.block.name = label_name; // const _ref = &lhs; - AstNode *lhs = trans_expr(c, ResultUsedYes, &child_scope->base, stmt->getLHS(), TransLValue); + AstNode *lhs = trans_expr(c, ResultUsedYes, &child_scope->base, bitcast(stmt->getLHS()), TransLValue); if (lhs == nullptr) return nullptr; AstNode *addr_of_lhs = trans_create_node_addr_of(c, lhs); // TODO: avoid name collisions with generated variable names @@ -1622,7 +1633,7 @@ static AstNode *trans_create_compound_assign_shift(Context *c, ResultUsed result // *_ref = result_type(operation_type(*_ref) >> u5(rhs)); - AstNode *rhs = trans_expr(c, ResultUsedYes, &child_scope->base, stmt->getRHS(), TransRValue); + AstNode *rhs = trans_expr(c, ResultUsedYes, &child_scope->base, bitcast(stmt->getRHS()), TransRValue); if (rhs == nullptr) return nullptr; AstNode *coerced_rhs = trans_create_node_fn_call_1(c, rhs_type, rhs); @@ -1667,9 +1678,9 @@ static AstNode *trans_create_compound_assign(Context *c, ResultUsed result_used, if (result_used == ResultUsedNo) { // simple common case, where the C and Zig are identical: // lhs += rhs - AstNode *lhs = trans_expr(c, ResultUsedYes, scope, stmt->getLHS(), TransLValue); + AstNode *lhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getLHS()), TransLValue); if (lhs == nullptr) return nullptr; - AstNode *rhs = trans_expr(c, ResultUsedYes, scope, stmt->getRHS(), TransRValue); + AstNode *rhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getRHS()), TransRValue); if (rhs == nullptr) return nullptr; return trans_create_node_bin_op(c, lhs, assign_op, rhs); } else { @@ -1686,7 +1697,7 @@ static AstNode *trans_create_compound_assign(Context *c, ResultUsed result_used, child_scope->node->data.block.name = label_name; // const _ref = &lhs; - AstNode *lhs = trans_expr(c, ResultUsedYes, &child_scope->base, stmt->getLHS(), TransLValue); + AstNode *lhs = trans_expr(c, ResultUsedYes, &child_scope->base, bitcast(stmt->getLHS()), TransLValue); if (lhs == nullptr) return nullptr; AstNode *addr_of_lhs = trans_create_node_addr_of(c, lhs); // TODO: avoid name collisions with generated variable names @@ -1696,7 +1707,7 @@ static AstNode *trans_create_compound_assign(Context *c, ResultUsed result_used, // *_ref = *_ref + rhs; - AstNode *rhs = trans_expr(c, ResultUsedYes, &child_scope->base, stmt->getRHS(), TransRValue); + AstNode *rhs = trans_expr(c, ResultUsedYes, &child_scope->base, bitcast(stmt->getRHS()), TransRValue); if (rhs == nullptr) return nullptr; AstNode *assign_statement = trans_create_node_bin_op(c, @@ -1788,201 +1799,201 @@ static AstNode *trans_compound_assign_operator(Context *c, ResultUsed result_use } static AstNode *trans_implicit_cast_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::ImplicitCastExpr *stmt) { - switch (stmt->getCastKind()) { - case clang::CK_LValueToRValue: - return trans_expr(c, ResultUsedYes, scope, stmt->getSubExpr(), TransRValue); - case clang::CK_IntegralCast: + switch ((ZigClangCK)stmt->getCastKind()) { + case ZigClangCK_LValueToRValue: + return trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getSubExpr()), TransRValue); + case ZigClangCK_IntegralCast: { - AstNode *target_node = trans_expr(c, ResultUsedYes, scope, stmt->getSubExpr(), TransRValue); + AstNode *target_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getSubExpr()), TransRValue); if (target_node == nullptr) return nullptr; AstNode *node = trans_c_cast(c, bitcast(stmt->getExprLoc()), bitcast(stmt->getType()), bitcast(stmt->getSubExpr()->getType()), target_node); return maybe_suppress_result(c, result_used, node); } - case clang::CK_FunctionToPointerDecay: - case clang::CK_ArrayToPointerDecay: + case ZigClangCK_FunctionToPointerDecay: + case ZigClangCK_ArrayToPointerDecay: { - AstNode *target_node = trans_expr(c, ResultUsedYes, scope, stmt->getSubExpr(), TransRValue); + AstNode *target_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getSubExpr()), TransRValue); if (target_node == nullptr) return nullptr; return maybe_suppress_result(c, result_used, target_node); } - case clang::CK_BitCast: + case ZigClangCK_BitCast: { - AstNode *target_node = trans_expr(c, ResultUsedYes, scope, stmt->getSubExpr(), TransRValue); + AstNode *target_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getSubExpr()), TransRValue); if (target_node == nullptr) return nullptr; - if (expr_types_equal(c, stmt, stmt->getSubExpr())) { + if (expr_types_equal(c, (const ZigClangExpr *)stmt, bitcast(stmt->getSubExpr()))) { return target_node; } - AstNode *dest_type_node = get_expr_type(c, stmt); + AstNode *dest_type_node = get_expr_type(c, (const ZigClangExpr *)stmt); AstNode *node = trans_create_node_builtin_fn_call_str(c, "ptrCast"); node->data.fn_call_expr.params.append(dest_type_node); node->data.fn_call_expr.params.append(target_node); return maybe_suppress_result(c, result_used, node); } - case clang::CK_NullToPointer: + case ZigClangCK_NullToPointer: return trans_create_node_unsigned(c, 0); - case clang::CK_NoOp: - return trans_expr(c, ResultUsedYes, scope, stmt->getSubExpr(), TransRValue); - case clang::CK_Dependent: + case ZigClangCK_NoOp: + return trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getSubExpr()), TransRValue); + case ZigClangCK_Dependent: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_Dependent"); return nullptr; - case clang::CK_LValueBitCast: + case ZigClangCK_LValueBitCast: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_LValueBitCast"); return nullptr; - case clang::CK_BaseToDerived: + case ZigClangCK_BaseToDerived: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_BaseToDerived"); return nullptr; - case clang::CK_DerivedToBase: + case ZigClangCK_DerivedToBase: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_DerivedToBase"); return nullptr; - case clang::CK_UncheckedDerivedToBase: + case ZigClangCK_UncheckedDerivedToBase: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_UncheckedDerivedToBase"); return nullptr; - case clang::CK_Dynamic: + case ZigClangCK_Dynamic: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_Dynamic"); return nullptr; - case clang::CK_ToUnion: + case ZigClangCK_ToUnion: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_ToUnion"); return nullptr; - case clang::CK_NullToMemberPointer: + case ZigClangCK_NullToMemberPointer: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_NullToMemberPointer"); return nullptr; - case clang::CK_BaseToDerivedMemberPointer: + case ZigClangCK_BaseToDerivedMemberPointer: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_BaseToDerivedMemberPointer"); return nullptr; - case clang::CK_DerivedToBaseMemberPointer: + case ZigClangCK_DerivedToBaseMemberPointer: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_DerivedToBaseMemberPointer"); return nullptr; - case clang::CK_MemberPointerToBoolean: + case ZigClangCK_MemberPointerToBoolean: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_MemberPointerToBoolean"); return nullptr; - case clang::CK_ReinterpretMemberPointer: + case ZigClangCK_ReinterpretMemberPointer: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_ReinterpretMemberPointer"); return nullptr; - case clang::CK_UserDefinedConversion: + case ZigClangCK_UserDefinedConversion: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_UserDefinedConversion"); return nullptr; - case clang::CK_ConstructorConversion: + case ZigClangCK_ConstructorConversion: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ConstructorConversion"); return nullptr; - case clang::CK_IntegralToPointer: + case ZigClangCK_IntegralToPointer: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralToPointer"); return nullptr; - case clang::CK_PointerToIntegral: + case ZigClangCK_PointerToIntegral: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_PointerToIntegral"); return nullptr; - case clang::CK_PointerToBoolean: + case ZigClangCK_PointerToBoolean: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_PointerToBoolean"); return nullptr; - case clang::CK_ToVoid: + case ZigClangCK_ToVoid: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ToVoid"); return nullptr; - case clang::CK_VectorSplat: + case ZigClangCK_VectorSplat: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_VectorSplat"); return nullptr; - case clang::CK_IntegralToBoolean: + case ZigClangCK_IntegralToBoolean: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralToBoolean"); return nullptr; - case clang::CK_IntegralToFloating: + case ZigClangCK_IntegralToFloating: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralToFloating"); return nullptr; - case clang::CK_FixedPointCast: + case ZigClangCK_FixedPointCast: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FixedPointCast"); return nullptr; - case clang::CK_FixedPointToBoolean: + case ZigClangCK_FixedPointToBoolean: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FixedPointToBoolean"); return nullptr; - case clang::CK_FloatingToIntegral: + case ZigClangCK_FloatingToIntegral: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingToIntegral"); return nullptr; - case clang::CK_FloatingToBoolean: + case ZigClangCK_FloatingToBoolean: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingToBoolean"); return nullptr; - case clang::CK_BooleanToSignedIntegral: + case ZigClangCK_BooleanToSignedIntegral: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_BooleanToSignedIntegral"); return nullptr; - case clang::CK_FloatingCast: + case ZigClangCK_FloatingCast: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingCast"); return nullptr; - case clang::CK_CPointerToObjCPointerCast: + case ZigClangCK_CPointerToObjCPointerCast: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_CPointerToObjCPointerCast"); return nullptr; - case clang::CK_BlockPointerToObjCPointerCast: + case ZigClangCK_BlockPointerToObjCPointerCast: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_BlockPointerToObjCPointerCast"); return nullptr; - case clang::CK_AnyPointerToBlockPointerCast: + case ZigClangCK_AnyPointerToBlockPointerCast: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_AnyPointerToBlockPointerCast"); return nullptr; - case clang::CK_ObjCObjectLValueCast: + case ZigClangCK_ObjCObjectLValueCast: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ObjCObjectLValueCast"); return nullptr; - case clang::CK_FloatingRealToComplex: + case ZigClangCK_FloatingRealToComplex: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingRealToComplex"); return nullptr; - case clang::CK_FloatingComplexToReal: + case ZigClangCK_FloatingComplexToReal: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingComplexToReal"); return nullptr; - case clang::CK_FloatingComplexToBoolean: + case ZigClangCK_FloatingComplexToBoolean: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingComplexToBoolean"); return nullptr; - case clang::CK_FloatingComplexCast: + case ZigClangCK_FloatingComplexCast: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingComplexCast"); return nullptr; - case clang::CK_FloatingComplexToIntegralComplex: + case ZigClangCK_FloatingComplexToIntegralComplex: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingComplexToIntegralComplex"); return nullptr; - case clang::CK_IntegralRealToComplex: + case ZigClangCK_IntegralRealToComplex: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralRealToComplex"); return nullptr; - case clang::CK_IntegralComplexToReal: + case ZigClangCK_IntegralComplexToReal: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralComplexToReal"); return nullptr; - case clang::CK_IntegralComplexToBoolean: + case ZigClangCK_IntegralComplexToBoolean: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralComplexToBoolean"); return nullptr; - case clang::CK_IntegralComplexCast: + case ZigClangCK_IntegralComplexCast: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralComplexCast"); return nullptr; - case clang::CK_IntegralComplexToFloatingComplex: + case ZigClangCK_IntegralComplexToFloatingComplex: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralComplexToFloatingComplex"); return nullptr; - case clang::CK_ARCProduceObject: + case ZigClangCK_ARCProduceObject: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ARCProduceObject"); return nullptr; - case clang::CK_ARCConsumeObject: + case ZigClangCK_ARCConsumeObject: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ARCConsumeObject"); return nullptr; - case clang::CK_ARCReclaimReturnedObject: + case ZigClangCK_ARCReclaimReturnedObject: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ARCReclaimReturnedObject"); return nullptr; - case clang::CK_ARCExtendBlockObject: + case ZigClangCK_ARCExtendBlockObject: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ARCExtendBlockObject"); return nullptr; - case clang::CK_AtomicToNonAtomic: + case ZigClangCK_AtomicToNonAtomic: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_AtomicToNonAtomic"); return nullptr; - case clang::CK_NonAtomicToAtomic: + case ZigClangCK_NonAtomicToAtomic: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_NonAtomicToAtomic"); return nullptr; - case clang::CK_CopyAndAutoreleaseBlockObject: + case ZigClangCK_CopyAndAutoreleaseBlockObject: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_CopyAndAutoreleaseBlockObject"); return nullptr; - case clang::CK_BuiltinFnToFnPtr: + case ZigClangCK_BuiltinFnToFnPtr: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_BuiltinFnToFnPtr"); return nullptr; - case clang::CK_ZeroToOCLOpaqueType: + case ZigClangCK_ZeroToOCLOpaqueType: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ZeroToOCLOpaqueType"); return nullptr; - case clang::CK_AddressSpaceConversion: + case ZigClangCK_AddressSpaceConversion: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_AddressSpaceConversion"); return nullptr; - case clang::CK_IntToOCLSampler: + case ZigClangCK_IntToOCLSampler: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntToOCLSampler"); return nullptr; } @@ -2002,7 +2013,7 @@ static AstNode *trans_decl_ref_expr(Context *c, TransScope *scope, const clang:: static AstNode *trans_create_post_crement(Context *c, ResultUsed result_used, TransScope *scope, const clang::UnaryOperator *stmt, BinOpType assign_op) { - clang::Expr *op_expr = stmt->getSubExpr(); + const ZigClangExpr *op_expr = bitcast(stmt->getSubExpr()); if (result_used == ResultUsedNo) { // common case @@ -2058,7 +2069,7 @@ static AstNode *trans_create_post_crement(Context *c, ResultUsed result_used, Tr static AstNode *trans_create_pre_crement(Context *c, ResultUsed result_used, TransScope *scope, const clang::UnaryOperator *stmt, BinOpType assign_op) { - clang::Expr *op_expr = stmt->getSubExpr(); + const ZigClangExpr *op_expr = bitcast(stmt->getSubExpr()); if (result_used == ResultUsedNo) { // common case @@ -2129,14 +2140,14 @@ static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransSc return trans_create_pre_crement(c, result_used, scope, stmt, BinOpTypeAssignMinus); case clang::UO_AddrOf: { - AstNode *value_node = trans_expr(c, result_used, scope, stmt->getSubExpr(), TransLValue); + AstNode *value_node = trans_expr(c, result_used, scope, bitcast(stmt->getSubExpr()), TransLValue); if (value_node == nullptr) return value_node; return trans_create_node_addr_of(c, value_node); } case clang::UO_Deref: { - AstNode *value_node = trans_expr(c, result_used, scope, stmt->getSubExpr(), TransRValue); + AstNode *value_node = trans_expr(c, result_used, scope, bitcast(stmt->getSubExpr()), TransRValue); if (value_node == nullptr) return nullptr; bool is_fn_ptr = qual_type_is_fn_ptr(bitcast(stmt->getSubExpr()->getType())); @@ -2150,8 +2161,8 @@ static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransSc return nullptr; case clang::UO_Minus: { - clang::Expr *op_expr = stmt->getSubExpr(); - if (!qual_type_has_wrapping_overflow(c, bitcast(op_expr->getType()))) { + const ZigClangExpr *op_expr = bitcast(stmt->getSubExpr()); + if (!qual_type_has_wrapping_overflow(c, ZigClangExpr_getType(op_expr))) { AstNode *node = trans_create_node(c, NodeTypePrefixOpExpr); node->data.prefix_op_expr.prefix_op = PrefixOpNegation; @@ -2160,7 +2171,7 @@ static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransSc return nullptr; return node; - } else if (c_is_unsigned_integer(c, bitcast(op_expr->getType()))) { + } else if (c_is_unsigned_integer(c, ZigClangExpr_getType(op_expr))) { // we gotta emit 0 -% x AstNode *node = trans_create_node(c, NodeTypeBinOpExpr); node->data.bin_op_expr.op1 = trans_create_node_unsigned(c, 0); @@ -2178,7 +2189,7 @@ static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransSc } case clang::UO_Not: { - clang::Expr *op_expr = stmt->getSubExpr(); + const ZigClangExpr *op_expr = bitcast(stmt->getSubExpr()); AstNode *sub_node = trans_expr(c, ResultUsedYes, scope, op_expr, TransRValue); if (sub_node == nullptr) return nullptr; @@ -2187,7 +2198,7 @@ static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransSc } case clang::UO_LNot: { - clang::Expr *op_expr = stmt->getSubExpr(); + const ZigClangExpr *op_expr = bitcast(stmt->getSubExpr()); AstNode *sub_node = trans_bool_expr(c, ResultUsedYes, scope, op_expr, TransRValue); if (sub_node == nullptr) return nullptr; @@ -2201,7 +2212,7 @@ static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransSc emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation UO_Imag"); return nullptr; case clang::UO_Extension: - return trans_expr(c, result_used, scope, stmt->getSubExpr(), TransLValue); + return trans_expr(c, result_used, scope, bitcast(stmt->getSubExpr()), TransLValue); case clang::UO_Coawait: emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation UO_Coawait"); return nullptr; @@ -2226,7 +2237,7 @@ static int trans_local_declaration(Context *c, TransScope *scope, const clang::D ZigClangQualType qual_type = bitcast(var_decl->getTypeSourceInfo()->getType()); AstNode *init_node = nullptr; if (var_decl->hasInit()) { - init_node = trans_expr(c, ResultUsedYes, scope, var_decl->getInit(), TransRValue); + init_node = trans_expr(c, ResultUsedYes, scope, bitcast(var_decl->getInit()), TransRValue); if (init_node == nullptr) return ErrorUnexpected; @@ -2492,7 +2503,7 @@ static AstNode *to_enum_zero_cmp(Context *c, AstNode *expr, AstNode *enum_type) return trans_create_node_bin_op(c, expr, BinOpTypeCmpNotEq, bitcast); } -static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::Expr *expr, TransLRValue lrval) { +static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *scope, const ZigClangExpr *expr, TransLRValue lrval) { AstNode *res = trans_expr(c, result_used, scope, expr, lrval); if (res == nullptr) return nullptr; @@ -2689,7 +2700,7 @@ static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope * switch (elaborated_ty->getKeyword()) { case clang::ETK_Enum: { AstNode *enum_type = trans_qual_type(c, bitcast(elaborated_ty->getNamedType()), - bitcast(expr->getBeginLoc())); + ZigClangExpr_getBeginLoc(expr)); return to_enum_zero_cmp(c, res, enum_type); } case clang::ETK_Struct: @@ -2752,7 +2763,8 @@ static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope * static AstNode *trans_while_loop(Context *c, TransScope *scope, const clang::WhileStmt *stmt) { TransScopeWhile *while_scope = trans_scope_while_create(c, scope); - while_scope->node->data.while_expr.condition = trans_bool_expr(c, ResultUsedYes, scope, stmt->getCond(), TransRValue); + while_scope->node->data.while_expr.condition = trans_bool_expr(c, ResultUsedYes, scope, + bitcast(stmt->getCond()), TransRValue); if (while_scope->node->data.while_expr.condition == nullptr) return nullptr; @@ -2779,7 +2791,8 @@ static AstNode *trans_if_statement(Context *c, TransScope *scope, const clang::I return nullptr; } - if_node->data.if_bool_expr.condition = trans_bool_expr(c, ResultUsedYes, scope, stmt->getCond(), TransRValue); + if_node->data.if_bool_expr.condition = trans_bool_expr(c, ResultUsedYes, scope, bitcast(stmt->getCond()), + TransRValue); if (if_node->data.if_bool_expr.condition == nullptr) return nullptr; @@ -2789,7 +2802,7 @@ static AstNode *trans_if_statement(Context *c, TransScope *scope, const clang::I static AstNode *trans_call_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::CallExpr *stmt) { AstNode *node = trans_create_node(c, NodeTypeFnCallExpr); - AstNode *callee_raw_node = trans_expr(c, ResultUsedYes, scope, stmt->getCallee(), TransRValue); + AstNode *callee_raw_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getCallee()), TransRValue); if (callee_raw_node == nullptr) return nullptr; @@ -2799,7 +2812,7 @@ static AstNode *trans_call_expr(Context *c, ResultUsed result_used, TransScope * if (is_ptr && fn_ty) { if ((ZigClangStmtClass)stmt->getCallee()->getStmtClass() == ZigClangStmt_ImplicitCastExprClass) { const clang::ImplicitCastExpr *implicit_cast = static_cast(stmt->getCallee()); - if (implicit_cast->getCastKind() == clang::CK_FunctionToPointerDecay) { + if ((ZigClangCK)implicit_cast->getCastKind() == ZigClangCK_FunctionToPointerDecay) { if ((ZigClangStmtClass)implicit_cast->getSubExpr()->getStmtClass() == ZigClangStmt_DeclRefExprClass) { const clang::DeclRefExpr *decl_ref = static_cast(implicit_cast->getSubExpr()); const clang::Decl *decl = decl_ref->getFoundDecl(); @@ -2819,7 +2832,7 @@ static AstNode *trans_call_expr(Context *c, ResultUsed result_used, TransScope * node->data.fn_call_expr.fn_ref_expr = callee_node; unsigned num_args = stmt->getNumArgs(); - const clang::Expr * const* args = stmt->getArgs(); + const ZigClangExpr * const* args = reinterpret_cast(stmt->getArgs()); for (unsigned i = 0; i < num_args; i += 1) { AstNode *arg_node = trans_expr(c, ResultUsedYes, scope, args[i], TransRValue); if (arg_node == nullptr) @@ -2840,7 +2853,7 @@ static AstNode *trans_call_expr(Context *c, ResultUsed result_used, TransScope * static AstNode *trans_member_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::MemberExpr *stmt) { - AstNode *container_node = trans_expr(c, ResultUsedYes, scope, stmt->getBase(), TransRValue); + AstNode *container_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getBase()), TransRValue); if (container_node == nullptr) return nullptr; @@ -2855,11 +2868,11 @@ static AstNode *trans_member_expr(Context *c, ResultUsed result_used, TransScope } static AstNode *trans_array_subscript_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::ArraySubscriptExpr *stmt) { - AstNode *container_node = trans_expr(c, ResultUsedYes, scope, stmt->getBase(), TransRValue); + AstNode *container_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getBase()), TransRValue); if (container_node == nullptr) return nullptr; - AstNode *idx_node = trans_expr(c, ResultUsedYes, scope, stmt->getIdx(), TransRValue); + AstNode *idx_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getIdx()), TransRValue); if (idx_node == nullptr) return nullptr; @@ -2873,7 +2886,7 @@ static AstNode *trans_array_subscript_expr(Context *c, ResultUsed result_used, T static AstNode *trans_c_style_cast_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::CStyleCastExpr *stmt, TransLRValue lrvalue) { - AstNode *sub_expr_node = trans_expr(c, ResultUsedYes, scope, stmt->getSubExpr(), lrvalue); + AstNode *sub_expr_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getSubExpr()), lrvalue); if (sub_expr_node == nullptr) return nullptr; @@ -2943,7 +2956,7 @@ static AstNode *trans_do_loop(Context *c, TransScope *parent_scope, const clang: } // if (!cond) break; - AstNode *condition_node = trans_expr(c, ResultUsedYes, child_scope, stmt->getCond(), TransRValue); + AstNode *condition_node = trans_expr(c, ResultUsedYes, child_scope, bitcast(stmt->getCond()), TransRValue); if (condition_node == nullptr) return nullptr; AstNode *terminator_node = trans_create_node(c, NodeTypeIfBoolExpr); terminator_node->data.if_bool_expr.condition = trans_create_node_prefix_op(c, PrefixOpBoolNot, condition_node); @@ -2982,29 +2995,21 @@ static AstNode *trans_for_loop(Context *c, TransScope *parent_scope, const clang child_scope->node->data.block.statements.append(while_scope->node); } - const ZigClangStmt *cond_stmt = bitcast(stmt->getCond()); - if (cond_stmt == nullptr) { + const ZigClangExpr *cond_expr = bitcast(stmt->getCond()); + if (cond_expr == nullptr) { while_scope->node->data.while_expr.condition = trans_create_node_bool(c, true); } else { - if (ZigClangStmt_classof_Expr(cond_stmt)) { - const clang::Expr *cond_expr = reinterpret_cast(cond_stmt); - while_scope->node->data.while_expr.condition = trans_bool_expr(c, ResultUsedYes, cond_scope, cond_expr, TransRValue); + while_scope->node->data.while_expr.condition = trans_bool_expr(c, ResultUsedYes, cond_scope, + cond_expr, TransRValue); - if (while_scope->node->data.while_expr.condition == nullptr) - return nullptr; - } else { - TransScope *end_cond_scope = trans_stmt(c, cond_scope, cond_stmt, - &while_scope->node->data.while_expr.condition); - if (end_cond_scope == nullptr) - return nullptr; - } + if (while_scope->node->data.while_expr.condition == nullptr) + return nullptr; } - const ZigClangStmt *inc_stmt = bitcast(stmt->getInc()); - if (inc_stmt != nullptr) { - AstNode *inc_node; - TransScope *inc_scope = trans_stmt(c, cond_scope, inc_stmt, &inc_node); - if (inc_scope == nullptr) + const ZigClangExpr *inc_expr = bitcast(stmt->getInc()); + if (inc_expr != nullptr) { + AstNode *inc_node = trans_expr(c, ResultUsedNo, cond_scope, inc_expr, TransRValue); + if (inc_node == nullptr) return nullptr; while_scope->node->data.while_expr.continue_expr = inc_node; } @@ -3047,7 +3052,7 @@ static AstNode *trans_switch_stmt(Context *c, TransScope *parent_scope, const cl switch_scope->end_label_name = end_label_name; block_scope->node->data.block.name = end_label_name; - const clang::Expr *cond_expr = stmt->getCond(); + const ZigClangExpr *cond_expr = bitcast(stmt->getCond()); assert(cond_expr != nullptr); AstNode *expr_node = trans_expr(c, ResultUsedYes, &block_scope->base, cond_expr, TransRValue); @@ -3108,7 +3113,7 @@ static int trans_switch_case(Context *c, TransScope *parent_scope, const clang:: { // Add the prong AstNode *prong_node = trans_create_node(c, NodeTypeSwitchProng); - AstNode *item_node = trans_expr(c, ResultUsedYes, &switch_scope->base, stmt->getLHS(), TransRValue); + AstNode *item_node = trans_expr(c, ResultUsedYes, &switch_scope->base, bitcast(stmt->getLHS()), TransRValue); if (item_node == nullptr) return ErrorUnexpected; prong_node->data.switch_prong.items.append(item_node); @@ -3313,7 +3318,8 @@ static int trans_stmt_extra(Context *c, TransScope *scope, const ZigClangStmt *s trans_continue_stmt(c, scope, (const clang::ContinueStmt *)stmt)); case ZigClangStmt_ParenExprClass: return wrap_stmt(out_node, out_child_scope, scope, - trans_expr(c, result_used, scope, ((const clang::ParenExpr*)stmt)->getSubExpr(), lrvalue)); + trans_expr(c, result_used, scope, + bitcast(((const clang::ParenExpr*)stmt)->getSubExpr()), lrvalue)); case ZigClangStmt_SwitchStmtClass: return wrap_stmt(out_node, out_child_scope, scope, trans_switch_stmt(c, scope, (const clang::SwitchStmt *)stmt)); @@ -3836,7 +3842,7 @@ static int trans_stmt_extra(Context *c, TransScope *scope, const ZigClangStmt *s } // Returns null if there was an error -static AstNode *trans_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::Expr *expr, +static AstNode *trans_expr(Context *c, ResultUsed result_used, TransScope *scope, const ZigClangExpr *expr, TransLRValue lrval) { AstNode *result_node; @@ -4304,7 +4310,7 @@ static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, ZigClangQua case clang::APValue::LValue: { const clang::APValue::LValueBase lval_base = ap_value->getLValueBase(); if (const clang::Expr *expr = lval_base.dyn_cast()) { - return trans_expr(c, ResultUsedYes, &c->global_scope->base, expr, TransRValue); + return trans_expr(c, ResultUsedYes, &c->global_scope->base, bitcast(expr), TransRValue); } //const clang::ValueDecl *value_decl = lval_base.get(); emit_warning(c, source_loc, "TODO handle initializer LValue clang::ValueDecl"); diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp index 003fd0cc7d..49385ae35b 100644 --- a/src/zig_clang.cpp +++ b/src/zig_clang.cpp @@ -137,6 +137,132 @@ static_assert((clang::UnaryOperatorKind)ZigClangUO_PreDec == clang::UO_PreDec, " static_assert((clang::UnaryOperatorKind)ZigClangUO_PreInc == clang::UO_PreInc, ""); static_assert((clang::UnaryOperatorKind)ZigClangUO_Real == clang::UO_Real, ""); +// Detect additions to the enum +void zig2clang_CK(clang::CastKind x) { + switch (x) { + case clang::CK_ARCConsumeObject: + case clang::CK_ARCExtendBlockObject: + case clang::CK_ARCProduceObject: + case clang::CK_ARCReclaimReturnedObject: + case clang::CK_AddressSpaceConversion: + case clang::CK_AnyPointerToBlockPointerCast: + case clang::CK_ArrayToPointerDecay: + case clang::CK_AtomicToNonAtomic: + case clang::CK_BaseToDerived: + case clang::CK_BaseToDerivedMemberPointer: + case clang::CK_BitCast: + case clang::CK_BlockPointerToObjCPointerCast: + case clang::CK_BooleanToSignedIntegral: + case clang::CK_BuiltinFnToFnPtr: + case clang::CK_CPointerToObjCPointerCast: + case clang::CK_ConstructorConversion: + case clang::CK_CopyAndAutoreleaseBlockObject: + case clang::CK_Dependent: + case clang::CK_DerivedToBase: + case clang::CK_DerivedToBaseMemberPointer: + case clang::CK_Dynamic: + case clang::CK_FloatingCast: + case clang::CK_FloatingComplexCast: + case clang::CK_FloatingComplexToBoolean: + case clang::CK_FloatingComplexToIntegralComplex: + case clang::CK_FloatingComplexToReal: + case clang::CK_FloatingRealToComplex: + case clang::CK_FloatingToBoolean: + case clang::CK_FloatingToIntegral: + case clang::CK_FunctionToPointerDecay: + case clang::CK_IntToOCLSampler: + case clang::CK_IntegralCast: + case clang::CK_IntegralComplexCast: + case clang::CK_IntegralComplexToBoolean: + case clang::CK_IntegralComplexToFloatingComplex: + case clang::CK_IntegralComplexToReal: + case clang::CK_IntegralRealToComplex: + case clang::CK_IntegralToBoolean: + case clang::CK_IntegralToFloating: + case clang::CK_IntegralToPointer: + case clang::CK_LValueBitCast: + case clang::CK_LValueToRValue: + case clang::CK_MemberPointerToBoolean: + case clang::CK_NoOp: + case clang::CK_NonAtomicToAtomic: + case clang::CK_NullToMemberPointer: + case clang::CK_NullToPointer: + case clang::CK_ObjCObjectLValueCast: + case clang::CK_PointerToBoolean: + case clang::CK_PointerToIntegral: + case clang::CK_ReinterpretMemberPointer: + case clang::CK_ToUnion: + case clang::CK_ToVoid: + case clang::CK_UncheckedDerivedToBase: + case clang::CK_UserDefinedConversion: + case clang::CK_VectorSplat: + case clang::CK_ZeroToOCLOpaqueType: + case clang::CK_FixedPointCast: + case clang::CK_FixedPointToBoolean: + break; + } +}; + +static_assert((clang::CastKind)ZigClangCK_Dependent == clang::CK_Dependent, ""); +static_assert((clang::CastKind)ZigClangCK_BitCast == clang::CK_BitCast, ""); +static_assert((clang::CastKind)ZigClangCK_LValueBitCast == clang::CK_LValueBitCast, ""); +static_assert((clang::CastKind)ZigClangCK_LValueToRValue == clang::CK_LValueToRValue, ""); +static_assert((clang::CastKind)ZigClangCK_NoOp == clang::CK_NoOp, ""); +static_assert((clang::CastKind)ZigClangCK_BaseToDerived == clang::CK_BaseToDerived, ""); +static_assert((clang::CastKind)ZigClangCK_DerivedToBase == clang::CK_DerivedToBase, ""); +static_assert((clang::CastKind)ZigClangCK_UncheckedDerivedToBase == clang::CK_UncheckedDerivedToBase, ""); +static_assert((clang::CastKind)ZigClangCK_Dynamic == clang::CK_Dynamic, ""); +static_assert((clang::CastKind)ZigClangCK_ToUnion == clang::CK_ToUnion, ""); +static_assert((clang::CastKind)ZigClangCK_ArrayToPointerDecay == clang::CK_ArrayToPointerDecay, ""); +static_assert((clang::CastKind)ZigClangCK_FunctionToPointerDecay == clang::CK_FunctionToPointerDecay, ""); +static_assert((clang::CastKind)ZigClangCK_NullToPointer == clang::CK_NullToPointer, ""); +static_assert((clang::CastKind)ZigClangCK_NullToMemberPointer == clang::CK_NullToMemberPointer, ""); +static_assert((clang::CastKind)ZigClangCK_BaseToDerivedMemberPointer == clang::CK_BaseToDerivedMemberPointer, ""); +static_assert((clang::CastKind)ZigClangCK_DerivedToBaseMemberPointer == clang::CK_DerivedToBaseMemberPointer, ""); +static_assert((clang::CastKind)ZigClangCK_MemberPointerToBoolean == clang::CK_MemberPointerToBoolean, ""); +static_assert((clang::CastKind)ZigClangCK_ReinterpretMemberPointer == clang::CK_ReinterpretMemberPointer, ""); +static_assert((clang::CastKind)ZigClangCK_UserDefinedConversion == clang::CK_UserDefinedConversion, ""); +static_assert((clang::CastKind)ZigClangCK_ConstructorConversion == clang::CK_ConstructorConversion, ""); +static_assert((clang::CastKind)ZigClangCK_IntegralToPointer == clang::CK_IntegralToPointer, ""); +static_assert((clang::CastKind)ZigClangCK_PointerToIntegral == clang::CK_PointerToIntegral, ""); +static_assert((clang::CastKind)ZigClangCK_PointerToBoolean == clang::CK_PointerToBoolean, ""); +static_assert((clang::CastKind)ZigClangCK_ToVoid == clang::CK_ToVoid, ""); +static_assert((clang::CastKind)ZigClangCK_VectorSplat == clang::CK_VectorSplat, ""); +static_assert((clang::CastKind)ZigClangCK_IntegralCast == clang::CK_IntegralCast, ""); +static_assert((clang::CastKind)ZigClangCK_IntegralToBoolean == clang::CK_IntegralToBoolean, ""); +static_assert((clang::CastKind)ZigClangCK_IntegralToFloating == clang::CK_IntegralToFloating, ""); +static_assert((clang::CastKind)ZigClangCK_FixedPointCast == clang::CK_FixedPointCast, ""); +static_assert((clang::CastKind)ZigClangCK_FixedPointToBoolean == clang::CK_FixedPointToBoolean, ""); +static_assert((clang::CastKind)ZigClangCK_FloatingToIntegral == clang::CK_FloatingToIntegral, ""); +static_assert((clang::CastKind)ZigClangCK_FloatingToBoolean == clang::CK_FloatingToBoolean, ""); +static_assert((clang::CastKind)ZigClangCK_BooleanToSignedIntegral == clang::CK_BooleanToSignedIntegral, ""); +static_assert((clang::CastKind)ZigClangCK_FloatingCast == clang::CK_FloatingCast, ""); +static_assert((clang::CastKind)ZigClangCK_CPointerToObjCPointerCast == clang::CK_CPointerToObjCPointerCast, ""); +static_assert((clang::CastKind)ZigClangCK_BlockPointerToObjCPointerCast == clang::CK_BlockPointerToObjCPointerCast, ""); +static_assert((clang::CastKind)ZigClangCK_AnyPointerToBlockPointerCast == clang::CK_AnyPointerToBlockPointerCast, ""); +static_assert((clang::CastKind)ZigClangCK_ObjCObjectLValueCast == clang::CK_ObjCObjectLValueCast, ""); +static_assert((clang::CastKind)ZigClangCK_FloatingRealToComplex == clang::CK_FloatingRealToComplex, ""); +static_assert((clang::CastKind)ZigClangCK_FloatingComplexToReal == clang::CK_FloatingComplexToReal, ""); +static_assert((clang::CastKind)ZigClangCK_FloatingComplexToBoolean == clang::CK_FloatingComplexToBoolean, ""); +static_assert((clang::CastKind)ZigClangCK_FloatingComplexCast == clang::CK_FloatingComplexCast, ""); +static_assert((clang::CastKind)ZigClangCK_FloatingComplexToIntegralComplex == clang::CK_FloatingComplexToIntegralComplex, ""); +static_assert((clang::CastKind)ZigClangCK_IntegralRealToComplex == clang::CK_IntegralRealToComplex, ""); +static_assert((clang::CastKind)ZigClangCK_IntegralComplexToReal == clang::CK_IntegralComplexToReal, ""); +static_assert((clang::CastKind)ZigClangCK_IntegralComplexToBoolean == clang::CK_IntegralComplexToBoolean, ""); +static_assert((clang::CastKind)ZigClangCK_IntegralComplexCast == clang::CK_IntegralComplexCast, ""); +static_assert((clang::CastKind)ZigClangCK_IntegralComplexToFloatingComplex == clang::CK_IntegralComplexToFloatingComplex, ""); +static_assert((clang::CastKind)ZigClangCK_ARCProduceObject == clang::CK_ARCProduceObject, ""); +static_assert((clang::CastKind)ZigClangCK_ARCConsumeObject == clang::CK_ARCConsumeObject, ""); +static_assert((clang::CastKind)ZigClangCK_ARCReclaimReturnedObject == clang::CK_ARCReclaimReturnedObject, ""); +static_assert((clang::CastKind)ZigClangCK_ARCExtendBlockObject == clang::CK_ARCExtendBlockObject, ""); +static_assert((clang::CastKind)ZigClangCK_AtomicToNonAtomic == clang::CK_AtomicToNonAtomic, ""); +static_assert((clang::CastKind)ZigClangCK_NonAtomicToAtomic == clang::CK_NonAtomicToAtomic, ""); +static_assert((clang::CastKind)ZigClangCK_CopyAndAutoreleaseBlockObject == clang::CK_CopyAndAutoreleaseBlockObject, ""); +static_assert((clang::CastKind)ZigClangCK_BuiltinFnToFnPtr == clang::CK_BuiltinFnToFnPtr, ""); +static_assert((clang::CastKind)ZigClangCK_ZeroToOCLOpaqueType == clang::CK_ZeroToOCLOpaqueType, ""); +static_assert((clang::CastKind)ZigClangCK_AddressSpaceConversion == clang::CK_AddressSpaceConversion, ""); +static_assert((clang::CastKind)ZigClangCK_IntToOCLSampler == clang::CK_IntToOCLSampler, ""); + // Detect additions to the enum void zig2clang_TypeClass(clang::Type::TypeClass ty) { switch (ty) { @@ -885,3 +1011,18 @@ ZigClangStmtClass ZigClangStmt_getStmtClass(const ZigClangStmt *self) { auto casted = reinterpret_cast(self); return (ZigClangStmtClass)casted->getStmtClass(); } + +ZigClangStmtClass ZigClangExpr_getStmtClass(const ZigClangExpr *self) { + auto casted = reinterpret_cast(self); + return (ZigClangStmtClass)casted->getStmtClass(); +} + +ZigClangQualType ZigClangExpr_getType(const ZigClangExpr *self) { + auto casted = reinterpret_cast(self); + return bitcast(casted->getType()); +} + +ZigClangSourceLocation ZigClangExpr_getBeginLoc(const ZigClangExpr *self) { + auto casted = reinterpret_cast(self); + return bitcast(casted->getBeginLoc()); +} diff --git a/src/zig_clang.h b/src/zig_clang.h index 544cc7e4d7..a02cdee45d 100644 --- a/src/zig_clang.h +++ b/src/zig_clang.h @@ -418,64 +418,67 @@ enum ZigClangStmtClass { //struct ZigClangCC_X86VectorCall; //struct ZigClangCC_X86_64SysV; -//struct ZigClangCK_ARCConsumeObject; -//struct ZigClangCK_ARCExtendBlockObject; -//struct ZigClangCK_ARCProduceObject; -//struct ZigClangCK_ARCReclaimReturnedObject; -//struct ZigClangCK_AddressSpaceConversion; -//struct ZigClangCK_AnyPointerToBlockPointerCast; -//struct ZigClangCK_ArrayToPointerDecay; -//struct ZigClangCK_AtomicToNonAtomic; -//struct ZigClangCK_BaseToDerived; -//struct ZigClangCK_BaseToDerivedMemberPointer; -//struct ZigClangCK_BitCast; -//struct ZigClangCK_BlockPointerToObjCPointerCast; -//struct ZigClangCK_BooleanToSignedIntegral; -//struct ZigClangCK_BuiltinFnToFnPtr; -//struct ZigClangCK_CPointerToObjCPointerCast; -//struct ZigClangCK_ConstructorConversion; -//struct ZigClangCK_CopyAndAutoreleaseBlockObject; -//struct ZigClangCK_Dependent; -//struct ZigClangCK_DerivedToBase; -//struct ZigClangCK_DerivedToBaseMemberPointer; -//struct ZigClangCK_Dynamic; -//struct ZigClangCK_FloatingCast; -//struct ZigClangCK_FloatingComplexCast; -//struct ZigClangCK_FloatingComplexToBoolean; -//struct ZigClangCK_FloatingComplexToIntegralComplex; -//struct ZigClangCK_FloatingComplexToReal; -//struct ZigClangCK_FloatingRealToComplex; -//struct ZigClangCK_FloatingToBoolean; -//struct ZigClangCK_FloatingToIntegral; -//struct ZigClangCK_FunctionToPointerDecay; -//struct ZigClangCK_IntToOCLSampler; -//struct ZigClangCK_IntegralCast; -//struct ZigClangCK_IntegralComplexCast; -//struct ZigClangCK_IntegralComplexToBoolean; -//struct ZigClangCK_IntegralComplexToFloatingComplex; -//struct ZigClangCK_IntegralComplexToReal; -//struct ZigClangCK_IntegralRealToComplex; -//struct ZigClangCK_IntegralToBoolean; -//struct ZigClangCK_IntegralToFloating; -//struct ZigClangCK_IntegralToPointer; -//struct ZigClangCK_LValueBitCast; -//struct ZigClangCK_LValueToRValue; -//struct ZigClangCK_MemberPointerToBoolean; -//struct ZigClangCK_NoOp; -//struct ZigClangCK_NonAtomicToAtomic; -//struct ZigClangCK_NullToMemberPointer; -//struct ZigClangCK_NullToPointer; -//struct ZigClangCK_ObjCObjectLValueCast; -//struct ZigClangCK_PointerToBoolean; -//struct ZigClangCK_PointerToIntegral; -//struct ZigClangCK_ReinterpretMemberPointer; -//struct ZigClangCK_ToUnion; -//struct ZigClangCK_ToVoid; -//struct ZigClangCK_UncheckedDerivedToBase; -//struct ZigClangCK_UserDefinedConversion; -//struct ZigClangCK_VectorSplat; -//struct ZigClangCK_ZeroToOCLEvent; -//struct ZigClangCK_ZeroToOCLQueue; +enum ZigClangCK { + ZigClangCK_Dependent, + ZigClangCK_BitCast, + ZigClangCK_LValueBitCast, + ZigClangCK_LValueToRValue, + ZigClangCK_NoOp, + ZigClangCK_BaseToDerived, + ZigClangCK_DerivedToBase, + ZigClangCK_UncheckedDerivedToBase, + ZigClangCK_Dynamic, + ZigClangCK_ToUnion, + ZigClangCK_ArrayToPointerDecay, + ZigClangCK_FunctionToPointerDecay, + ZigClangCK_NullToPointer, + ZigClangCK_NullToMemberPointer, + ZigClangCK_BaseToDerivedMemberPointer, + ZigClangCK_DerivedToBaseMemberPointer, + ZigClangCK_MemberPointerToBoolean, + ZigClangCK_ReinterpretMemberPointer, + ZigClangCK_UserDefinedConversion, + ZigClangCK_ConstructorConversion, + ZigClangCK_IntegralToPointer, + ZigClangCK_PointerToIntegral, + ZigClangCK_PointerToBoolean, + ZigClangCK_ToVoid, + ZigClangCK_VectorSplat, + ZigClangCK_IntegralCast, + ZigClangCK_IntegralToBoolean, + ZigClangCK_IntegralToFloating, + ZigClangCK_FixedPointCast, + ZigClangCK_FixedPointToBoolean, + ZigClangCK_FloatingToIntegral, + ZigClangCK_FloatingToBoolean, + ZigClangCK_BooleanToSignedIntegral, + ZigClangCK_FloatingCast, + ZigClangCK_CPointerToObjCPointerCast, + ZigClangCK_BlockPointerToObjCPointerCast, + ZigClangCK_AnyPointerToBlockPointerCast, + ZigClangCK_ObjCObjectLValueCast, + ZigClangCK_FloatingRealToComplex, + ZigClangCK_FloatingComplexToReal, + ZigClangCK_FloatingComplexToBoolean, + ZigClangCK_FloatingComplexCast, + ZigClangCK_FloatingComplexToIntegralComplex, + ZigClangCK_IntegralRealToComplex, + ZigClangCK_IntegralComplexToReal, + ZigClangCK_IntegralComplexToBoolean, + ZigClangCK_IntegralComplexCast, + ZigClangCK_IntegralComplexToFloatingComplex, + ZigClangCK_ARCProduceObject, + ZigClangCK_ARCConsumeObject, + ZigClangCK_ARCReclaimReturnedObject, + ZigClangCK_ARCExtendBlockObject, + ZigClangCK_AtomicToNonAtomic, + ZigClangCK_NonAtomicToAtomic, + ZigClangCK_CopyAndAutoreleaseBlockObject, + ZigClangCK_BuiltinFnToFnPtr, + ZigClangCK_ZeroToOCLOpaqueType, + ZigClangCK_AddressSpaceConversion, + ZigClangCK_IntToOCLSampler, +}; //struct ZigClangETK_Class; //struct ZigClangETK_Enum; @@ -552,4 +555,7 @@ ZIG_EXTERN_C ZigClangSourceLocation ZigClangStmt_getBeginLoc(const ZigClangStmt ZIG_EXTERN_C ZigClangStmtClass ZigClangStmt_getStmtClass(const ZigClangStmt *self); ZIG_EXTERN_C bool ZigClangStmt_classof_Expr(const ZigClangStmt *self); +ZIG_EXTERN_C ZigClangStmtClass ZigClangExpr_getStmtClass(const ZigClangExpr *self); +ZIG_EXTERN_C ZigClangQualType ZigClangExpr_getType(const ZigClangExpr *self); +ZIG_EXTERN_C ZigClangSourceLocation ZigClangExpr_getBeginLoc(const ZigClangExpr *self); #endif -- cgit v1.2.3 From 3226b5315e4caa8fc8aaffaa258b07b212f230b1 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Tue, 16 Apr 2019 04:32:26 -0400 Subject: translate-c: move some code to the C API See #1964 --- src/translate_c.cpp | 85 ++++++++++++++++++++-------------- src/zig_clang.cpp | 131 ++++++++++++++++++++++++++++++++++++++++++++++++++-- src/zig_clang.h | 72 ++++++++++++++++------------- 3 files changed, 218 insertions(+), 70 deletions(-) (limited to 'src/zig_clang.cpp') diff --git a/src/translate_c.cpp b/src/translate_c.cpp index 13d9251e6b..659b5ef0cc 100644 --- a/src/translate_c.cpp +++ b/src/translate_c.cpp @@ -125,7 +125,16 @@ static AstNode *trans_expr(Context *c, ResultUsed result_used, TransScope *scope static AstNode *trans_qual_type(Context *c, ZigClangQualType qt, ZigClangSourceLocation source_loc); static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *scope, const ZigClangExpr *expr, TransLRValue lrval); -static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, ZigClangQualType qt, ZigClangSourceLocation source_loc); +static AstNode *trans_ap_value(Context *c, const ZigClangAPValue *ap_value, ZigClangQualType qt, + ZigClangSourceLocation source_loc); + +static const ZigClangAPSInt *bitcast(const llvm::APSInt *src) { + return reinterpret_cast(src); +} + +static const ZigClangAPValue *bitcast(const clang::APValue *src) { + return reinterpret_cast(src); +} static const ZigClangStmt *bitcast(const clang::Stmt *src) { return reinterpret_cast(src); @@ -497,16 +506,21 @@ static Buf *string_ref_to_buf(llvm::StringRef string_ref) { return buf_create_from_mem((const char *)string_ref.bytes_begin(), string_ref.size()); } -static AstNode *trans_create_node_apint(Context *c, const llvm::APSInt &aps_int) { +static AstNode *trans_create_node_apint(Context *c, const ZigClangAPSInt *aps_int) { AstNode *node = trans_create_node(c, NodeTypeIntLiteral); node->data.int_literal.bigint = allocate(1); - bool is_negative = aps_int.isSigned() && aps_int.isNegative(); + bool is_negative = ZigClangAPSInt_isSigned(aps_int) && ZigClangAPSInt_isNegative(aps_int); if (!is_negative) { - bigint_init_data(node->data.int_literal.bigint, aps_int.getRawData(), aps_int.getNumWords(), false); + bigint_init_data(node->data.int_literal.bigint, + ZigClangAPSInt_getRawData(aps_int), + ZigClangAPSInt_getNumWords(aps_int), + false); return node; } - llvm::APSInt negated = -aps_int; - bigint_init_data(node->data.int_literal.bigint, negated.getRawData(), negated.getNumWords(), true); + const ZigClangAPSInt *negated = ZigClangAPSInt_negate(aps_int); + bigint_init_data(node->data.int_literal.bigint, ZigClangAPSInt_getRawData(negated), + ZigClangAPSInt_getNumWords(negated), true); + ZigClangAPSInt_free(negated); return node; } @@ -1295,7 +1309,7 @@ static AstNode *trans_integer_literal(Context *c, ResultUsed result_used, const emit_warning(c, bitcast(stmt->getBeginLoc()), "invalid integer literal"); return nullptr; } - AstNode *node = trans_create_node_apint(c, result.Val.getInt()); + AstNode *node = trans_create_node_apint(c, bitcast(&result.Val.getInt())); return maybe_suppress_result(c, result_used, node); } @@ -1307,7 +1321,7 @@ static AstNode *trans_constant_expr(Context *c, ResultUsed result_used, const cl emit_warning(c, bitcast(expr->getBeginLoc()), "invalid constant expression"); return nullptr; } - AstNode *node = trans_ap_value(c, &result.Val, bitcast(expr->getType()), bitcast(expr->getBeginLoc())); + AstNode *node = trans_ap_value(c, bitcast(&result.Val), bitcast(expr->getType()), bitcast(expr->getBeginLoc())); return maybe_suppress_result(c, result_used, node); } @@ -4103,7 +4117,8 @@ static AstNode *resolve_enum_decl(Context *c, const ZigClangEnumDecl *enum_decl) field_name = enum_val_name; } - AstNode *int_node = pure_enum && !is_anonymous ? nullptr : trans_create_node_apint(c, enum_const->getInitVal()); + AstNode *int_node = pure_enum && !is_anonymous ? + nullptr : trans_create_node_apint(c, bitcast(&enum_const->getInitVal())); AstNode *field_node = trans_create_node(c, NodeTypeStructField); field_node->data.struct_field.name = field_name; field_node->data.struct_field.type = nullptr; @@ -4245,17 +4260,19 @@ static AstNode *resolve_record_decl(Context *c, const ZigClangRecordDecl *record } } -static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, ZigClangQualType qt, ZigClangSourceLocation source_loc) { - switch (ap_value->getKind()) { - case clang::APValue::Int: - return trans_create_node_apint(c, ap_value->getInt()); - case clang::APValue::Uninitialized: +static AstNode *trans_ap_value(Context *c, const ZigClangAPValue *ap_value, ZigClangQualType qt, + ZigClangSourceLocation source_loc) +{ + switch (ZigClangAPValue_getKind(ap_value)) { + case ZigClangAPValueInt: + return trans_create_node_apint(c, ZigClangAPValue_getInt(ap_value)); + case ZigClangAPValueUninitialized: return trans_create_node(c, NodeTypeUndefinedLiteral); - case clang::APValue::Array: { + case ZigClangAPValueArray: { emit_warning(c, source_loc, "TODO add a test case for this code"); - unsigned init_count = ap_value->getArrayInitializedElts(); - unsigned all_count = ap_value->getArraySize(); + unsigned init_count = ZigClangAPValue_getArrayInitializedElts(ap_value); + unsigned all_count = ZigClangAPValue_getArraySize(ap_value); unsigned leftover_count = all_count - init_count; AstNode *init_node = trans_create_node(c, NodeTypeContainerInitExpr); AstNode *arr_type_node = trans_qual_type(c, qt, source_loc); @@ -4269,8 +4286,8 @@ static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, ZigClangQua ZigClangQualType child_qt = bitcast(qt_type->getAsArrayTypeUnsafe()->getElementType()); for (size_t i = 0; i < init_count; i += 1) { - clang::APValue &elem_ap_val = ap_value->getArrayInitializedElt(i); - AstNode *elem_node = trans_ap_value(c, &elem_ap_val, child_qt, source_loc); + const ZigClangAPValue *elem_ap_val = ZigClangAPValue_getArrayInitializedElt(ap_value, i); + AstNode *elem_node = trans_ap_value(c, elem_ap_val, child_qt, source_loc); if (elem_node == nullptr) return nullptr; init_node->data.container_init_expr.entries.append(elem_node); @@ -4279,8 +4296,8 @@ static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, ZigClangQua return init_node; } - clang::APValue &filler_ap_val = ap_value->getArrayFiller(); - AstNode *filler_node = trans_ap_value(c, &filler_ap_val, child_qt, source_loc); + const ZigClangAPValue *filler_ap_val = ZigClangAPValue_getArrayFiller(ap_value); + AstNode *filler_node = trans_ap_value(c, filler_ap_val, child_qt, source_loc); if (filler_node == nullptr) return nullptr; @@ -4307,37 +4324,37 @@ static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, ZigClangQua return trans_create_node_bin_op(c, init_node, BinOpTypeArrayCat, rhs_node); } - case clang::APValue::LValue: { - const clang::APValue::LValueBase lval_base = ap_value->getLValueBase(); - if (const clang::Expr *expr = lval_base.dyn_cast()) { - return trans_expr(c, ResultUsedYes, &c->global_scope->base, bitcast(expr), TransRValue); + case ZigClangAPValueLValue: { + const ZigClangAPValueLValueBase lval_base = ZigClangAPValue_getLValueBase(ap_value); + if (const ZigClangExpr *expr = ZigClangAPValueLValueBase_dyn_cast_Expr(lval_base)) { + return trans_expr(c, ResultUsedYes, &c->global_scope->base, expr, TransRValue); } //const clang::ValueDecl *value_decl = lval_base.get(); emit_warning(c, source_loc, "TODO handle initializer LValue clang::ValueDecl"); return nullptr; } - case clang::APValue::Float: + case ZigClangAPValueFloat: emit_warning(c, source_loc, "unsupported initializer value kind: Float"); return nullptr; - case clang::APValue::ComplexInt: + case ZigClangAPValueComplexInt: emit_warning(c, source_loc, "unsupported initializer value kind: ComplexInt"); return nullptr; - case clang::APValue::ComplexFloat: + case ZigClangAPValueComplexFloat: emit_warning(c, source_loc, "unsupported initializer value kind: ComplexFloat"); return nullptr; - case clang::APValue::Vector: + case ZigClangAPValueVector: emit_warning(c, source_loc, "unsupported initializer value kind: Vector"); return nullptr; - case clang::APValue::Struct: + case ZigClangAPValueStruct: emit_warning(c, source_loc, "unsupported initializer value kind: Struct"); return nullptr; - case clang::APValue::Union: + case ZigClangAPValueUnion: emit_warning(c, source_loc, "unsupported initializer value kind: Union"); return nullptr; - case clang::APValue::MemberPointer: + case ZigClangAPValueMemberPointer: emit_warning(c, source_loc, "unsupported initializer value kind: MemberPointer"); return nullptr; - case clang::APValue::AddrLabelDiff: + case ZigClangAPValueAddrLabelDiff: emit_warning(c, source_loc, "unsupported initializer value kind: AddrLabelDiff"); return nullptr; } @@ -4374,7 +4391,7 @@ static void visit_var_decl(Context *c, const clang::VarDecl *var_decl) { if (is_static && !is_extern) { AstNode *init_node; if (var_decl->hasInit()) { - clang::APValue *ap_value = var_decl->evaluateValue(); + const ZigClangAPValue *ap_value = bitcast(var_decl->evaluateValue()); if (ap_value == nullptr) { emit_warning(c, bitcast(var_decl->getLocation()), "ignoring variable '%s' - unable to evaluate initializer", buf_ptr(name)); diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp index 49385ae35b..6142c808ad 100644 --- a/src/zig_clang.cpp +++ b/src/zig_clang.cpp @@ -28,7 +28,7 @@ #endif // Detect additions to the enum -void zig2clang_BO(clang::BinaryOperatorKind op) { +void ZigClang_detect_enum_BO(clang::BinaryOperatorKind op) { switch (op) { case clang::BO_PtrMemD: case clang::BO_PtrMemI: @@ -102,7 +102,7 @@ static_assert((clang::BinaryOperatorKind)ZigClangBO_Xor == clang::BO_Xor, ""); static_assert((clang::BinaryOperatorKind)ZigClangBO_XorAssign == clang::BO_XorAssign, ""); // Detect additions to the enum -void zig2clang_UO(clang::UnaryOperatorKind op) { +void ZigClang_detect_enum_UO(clang::UnaryOperatorKind op) { switch (op) { case clang::UO_AddrOf: case clang::UO_Coawait: @@ -138,7 +138,7 @@ static_assert((clang::UnaryOperatorKind)ZigClangUO_PreInc == clang::UO_PreInc, " static_assert((clang::UnaryOperatorKind)ZigClangUO_Real == clang::UO_Real, ""); // Detect additions to the enum -void zig2clang_CK(clang::CastKind x) { +void ZigClang_detect_enum_CK(clang::CastKind x) { switch (x) { case clang::CK_ARCConsumeObject: case clang::CK_ARCExtendBlockObject: @@ -264,7 +264,7 @@ static_assert((clang::CastKind)ZigClangCK_AddressSpaceConversion == clang::CK_Ad static_assert((clang::CastKind)ZigClangCK_IntToOCLSampler == clang::CK_IntToOCLSampler, ""); // Detect additions to the enum -void zig2clang_TypeClass(clang::Type::TypeClass ty) { +void ZigClang_detect_enum_TypeClass(clang::Type::TypeClass ty) { switch (ty) { case clang::Type::Builtin: case clang::Type::Complex: @@ -366,7 +366,7 @@ static_assert((clang::Type::TypeClass)ZigClangType_Pipe == clang::Type::Pipe, "" static_assert((clang::Type::TypeClass)ZigClangType_Atomic == clang::Type::Atomic, ""); // Detect additions to the enum -void zig2clang_StmtClass(clang::Stmt::StmtClass x) { +void ZigClang_detect_enum_StmtClass(clang::Stmt::StmtClass x) { switch (x) { case clang::Stmt::NoStmtClass: case clang::Stmt::NullStmtClass: @@ -767,6 +767,37 @@ static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetTeamsDistributeParal static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass == clang::Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass, ""); static_assert((clang::Stmt::StmtClass)ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass == clang::Stmt::OMPTargetTeamsDistributeSimdDirectiveClass, ""); +void ZigClang_detect_enum_APValueKind(clang::APValue::ValueKind x) { + switch (x) { + case clang::APValue::Uninitialized: + case clang::APValue::Int: + case clang::APValue::Float: + case clang::APValue::ComplexInt: + case clang::APValue::ComplexFloat: + case clang::APValue::LValue: + case clang::APValue::Vector: + case clang::APValue::Array: + case clang::APValue::Struct: + case clang::APValue::Union: + case clang::APValue::MemberPointer: + case clang::APValue::AddrLabelDiff: + break; + } +} + +static_assert((clang::APValue::ValueKind)ZigClangAPValueUninitialized == clang::APValue::Uninitialized, ""); +static_assert((clang::APValue::ValueKind)ZigClangAPValueInt == clang::APValue::Int, ""); +static_assert((clang::APValue::ValueKind)ZigClangAPValueFloat == clang::APValue::Float, ""); +static_assert((clang::APValue::ValueKind)ZigClangAPValueComplexInt == clang::APValue::ComplexInt, ""); +static_assert((clang::APValue::ValueKind)ZigClangAPValueComplexFloat == clang::APValue::ComplexFloat, ""); +static_assert((clang::APValue::ValueKind)ZigClangAPValueLValue == clang::APValue::LValue, ""); +static_assert((clang::APValue::ValueKind)ZigClangAPValueVector == clang::APValue::Vector, ""); +static_assert((clang::APValue::ValueKind)ZigClangAPValueArray == clang::APValue::Array, ""); +static_assert((clang::APValue::ValueKind)ZigClangAPValueStruct == clang::APValue::Struct, ""); +static_assert((clang::APValue::ValueKind)ZigClangAPValueUnion == clang::APValue::Union, ""); +static_assert((clang::APValue::ValueKind)ZigClangAPValueMemberPointer == clang::APValue::MemberPointer, ""); +static_assert((clang::APValue::ValueKind)ZigClangAPValueAddrLabelDiff == clang::APValue::AddrLabelDiff, ""); + static_assert(sizeof(ZigClangSourceLocation) == sizeof(clang::SourceLocation), ""); static ZigClangSourceLocation bitcast(clang::SourceLocation src) { @@ -792,6 +823,18 @@ static clang::QualType bitcast(ZigClangQualType src) { return dest; } +static_assert(sizeof(ZigClangAPValueLValueBase) == sizeof(clang::APValue::LValueBase), ""); +static ZigClangAPValueLValueBase bitcast(clang::APValue::LValueBase src) { + ZigClangAPValueLValueBase dest; + memcpy(&dest, static_cast(&src), sizeof(ZigClangAPValueLValueBase)); + return dest; +} +static clang::APValue::LValueBase bitcast(ZigClangAPValueLValueBase src) { + clang::APValue::LValueBase dest; + memcpy(&dest, static_cast(&src), sizeof(ZigClangAPValueLValueBase)); + return dest; +} + ZigClangSourceLocation ZigClangSourceManager_getSpellingLoc(const ZigClangSourceManager *self, ZigClangSourceLocation Loc) { @@ -1026,3 +1069,81 @@ ZigClangSourceLocation ZigClangExpr_getBeginLoc(const ZigClangExpr *self) { auto casted = reinterpret_cast(self); return bitcast(casted->getBeginLoc()); } + +ZigClangAPValueKind ZigClangAPValue_getKind(const ZigClangAPValue *self) { + auto casted = reinterpret_cast(self); + return (ZigClangAPValueKind)casted->getKind(); +} + +const ZigClangAPSInt *ZigClangAPValue_getInt(const ZigClangAPValue *self) { + auto casted = reinterpret_cast(self); + const llvm::APSInt *result = &casted->getInt(); + return reinterpret_cast(result); +} + +unsigned ZigClangAPValue_getArrayInitializedElts(const ZigClangAPValue *self) { + auto casted = reinterpret_cast(self); + return casted->getArrayInitializedElts(); +} + +const ZigClangAPValue *ZigClangAPValue_getArrayInitializedElt(const ZigClangAPValue *self, unsigned i) { + auto casted = reinterpret_cast(self); + const clang::APValue *result = &casted->getArrayInitializedElt(i); + return reinterpret_cast(result); +} + +const ZigClangAPValue *ZigClangAPValue_getArrayFiller(const ZigClangAPValue *self) { + auto casted = reinterpret_cast(self); + const clang::APValue *result = &casted->getArrayFiller(); + return reinterpret_cast(result); +} + +unsigned ZigClangAPValue_getArraySize(const ZigClangAPValue *self) { + auto casted = reinterpret_cast(self); + return casted->getArraySize(); +} + +const ZigClangAPSInt *ZigClangAPSInt_negate(const ZigClangAPSInt *self) { + auto casted = reinterpret_cast(self); + llvm::APSInt *result = new llvm::APSInt(); + *result = *casted; + *result = -*result; + return reinterpret_cast(result); +} + +void ZigClangAPSInt_free(const ZigClangAPSInt *self) { + auto casted = reinterpret_cast(self); + delete casted; +} + +bool ZigClangAPSInt_isSigned(const ZigClangAPSInt *self) { + auto casted = reinterpret_cast(self); + return casted->isSigned(); +} + +bool ZigClangAPSInt_isNegative(const ZigClangAPSInt *self) { + auto casted = reinterpret_cast(self); + return casted->isNegative(); +} + +const uint64_t *ZigClangAPSInt_getRawData(const ZigClangAPSInt *self) { + auto casted = reinterpret_cast(self); + return casted->getRawData(); +} + +unsigned ZigClangAPSInt_getNumWords(const ZigClangAPSInt *self) { + auto casted = reinterpret_cast(self); + return casted->getNumWords(); +} + +const ZigClangExpr *ZigClangAPValueLValueBase_dyn_cast_Expr(ZigClangAPValueLValueBase self) { + clang::APValue::LValueBase casted = bitcast(self); + const clang::Expr *expr = casted.dyn_cast(); + return reinterpret_cast(expr); +} + +ZigClangAPValueLValueBase ZigClangAPValue_getLValueBase(const ZigClangAPValue *self) { + auto casted = reinterpret_cast(self); + clang::APValue::LValueBase lval_base = casted->getLValueBase(); + return bitcast(lval_base); +} diff --git a/src/zig_clang.h b/src/zig_clang.h index a02cdee45d..78d6e1589d 100644 --- a/src/zig_clang.h +++ b/src/zig_clang.h @@ -8,6 +8,8 @@ #ifndef ZIG_ZIG_CLANG_H #define ZIG_ZIG_CLANG_H +#include + #ifdef __cplusplus #define ZIG_EXTERN_C extern "C" #else @@ -26,7 +28,14 @@ struct ZigClangQualType { void *ptr; }; +struct ZigClangAPValueLValueBase { + void *Ptr; + unsigned CallIndex; + unsigned Version; +}; + struct ZigClangAPValue; +struct ZigClangAPSInt; struct ZigClangASTContext; struct ZigClangASTUnit; struct ZigClangArraySubscriptExpr; @@ -400,24 +409,6 @@ enum ZigClangStmtClass { ZigClangStmt_WhileStmtClass, }; -//struct ZigClangCC_AAPCS; -//struct ZigClangCC_AAPCS_VFP; -//struct ZigClangCC_C; -//struct ZigClangCC_IntelOclBicc; -//struct ZigClangCC_OpenCLKernel; -//struct ZigClangCC_PreserveAll; -//struct ZigClangCC_PreserveMost; -//struct ZigClangCC_SpirFunction; -//struct ZigClangCC_Swift; -//struct ZigClangCC_Win64; -//struct ZigClangCC_X86FastCall; -//struct ZigClangCC_X86Pascal; -//struct ZigClangCC_X86RegCall; -//struct ZigClangCC_X86StdCall; -//struct ZigClangCC_X86ThisCall; -//struct ZigClangCC_X86VectorCall; -//struct ZigClangCC_X86_64SysV; - enum ZigClangCK { ZigClangCK_Dependent, ZigClangCK_BitCast, @@ -480,19 +471,20 @@ enum ZigClangCK { ZigClangCK_IntToOCLSampler, }; -//struct ZigClangETK_Class; -//struct ZigClangETK_Enum; -//struct ZigClangETK_Interface; -//struct ZigClangETK_None; -//struct ZigClangETK_Struct; -//struct ZigClangETK_Typename; -//struct ZigClangETK_Union; - -//struct ZigClangSC_None; -//struct ZigClangSC_PrivateExtern; -//struct ZigClangSC_Static; - -//struct ZigClangTU_Complete; +enum ZigClangAPValueKind { + ZigClangAPValueUninitialized, + ZigClangAPValueInt, + ZigClangAPValueFloat, + ZigClangAPValueComplexInt, + ZigClangAPValueComplexFloat, + ZigClangAPValueLValue, + ZigClangAPValueVector, + ZigClangAPValueArray, + ZigClangAPValueStruct, + ZigClangAPValueUnion, + ZigClangAPValueMemberPointer, + ZigClangAPValueAddrLabelDiff, +}; ZIG_EXTERN_C ZigClangSourceLocation ZigClangSourceManager_getSpellingLoc(const ZigClangSourceManager *, ZigClangSourceLocation Loc); @@ -558,4 +550,22 @@ ZIG_EXTERN_C bool ZigClangStmt_classof_Expr(const ZigClangStmt *self); ZIG_EXTERN_C ZigClangStmtClass ZigClangExpr_getStmtClass(const ZigClangExpr *self); ZIG_EXTERN_C ZigClangQualType ZigClangExpr_getType(const ZigClangExpr *self); ZIG_EXTERN_C ZigClangSourceLocation ZigClangExpr_getBeginLoc(const ZigClangExpr *self); + +ZIG_EXTERN_C ZigClangAPValueKind ZigClangAPValue_getKind(const ZigClangAPValue *self); +ZIG_EXTERN_C const ZigClangAPSInt *ZigClangAPValue_getInt(const ZigClangAPValue *self); +ZIG_EXTERN_C unsigned ZigClangAPValue_getArrayInitializedElts(const ZigClangAPValue *self); +ZIG_EXTERN_C const ZigClangAPValue *ZigClangAPValue_getArrayInitializedElt(const ZigClangAPValue *self, unsigned i); +ZIG_EXTERN_C const ZigClangAPValue *ZigClangAPValue_getArrayFiller(const ZigClangAPValue *self); +ZIG_EXTERN_C unsigned ZigClangAPValue_getArraySize(const ZigClangAPValue *self); +ZIG_EXTERN_C ZigClangAPValueLValueBase ZigClangAPValue_getLValueBase(const ZigClangAPValue *self); + +ZIG_EXTERN_C bool ZigClangAPSInt_isSigned(const ZigClangAPSInt *self); +ZIG_EXTERN_C bool ZigClangAPSInt_isNegative(const ZigClangAPSInt *self); +ZIG_EXTERN_C const ZigClangAPSInt *ZigClangAPSInt_negate(const ZigClangAPSInt *self); +ZIG_EXTERN_C void ZigClangAPSInt_free(const ZigClangAPSInt *self); +ZIG_EXTERN_C const uint64_t *ZigClangAPSInt_getRawData(const ZigClangAPSInt *self); +ZIG_EXTERN_C unsigned ZigClangAPSInt_getNumWords(const ZigClangAPSInt *self); + +ZIG_EXTERN_C const ZigClangExpr *ZigClangAPValueLValueBase_dyn_cast_Expr(ZigClangAPValueLValueBase self); + #endif -- cgit v1.2.3 From 712274997e80a93bdfe204f2238c4cfaac72a5b8 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Sun, 21 Apr 2019 19:37:39 -0400 Subject: translate-c: unify API for self-hosted and C++ translate-c See #1964 --- src-self-hosted/clang.zig | 17 ++++++ src-self-hosted/main.zig | 18 ++++++- src-self-hosted/stage1.zig | 35 ++++++------- src-self-hosted/translate_c.zig | 13 ++++- src/codegen.cpp | 49 +++++++++++------- src/ir.cpp | 19 ++++--- src/translate_c.cpp | 86 ++++-------------------------- src/translate_c.hpp | 6 ++- src/userland.cpp | 9 +++- src/userland.h | 46 +++++++++++++---- src/zig_clang.cpp | 112 ++++++++++++++++++++++++++++++++++++++++ src/zig_clang.h | 14 ++--- 12 files changed, 281 insertions(+), 143 deletions(-) (limited to 'src/zig_clang.cpp') diff --git a/src-self-hosted/clang.zig b/src-self-hosted/clang.zig index 6f7c7eb853..a9cf06f8a5 100644 --- a/src-self-hosted/clang.zig +++ b/src-self-hosted/clang.zig @@ -862,6 +862,7 @@ pub extern fn ZigClangAPSInt_free(self: ?*const struct_ZigClangAPSInt) void; pub extern fn ZigClangAPSInt_getRawData(self: ?*const struct_ZigClangAPSInt) [*c]const u64; pub extern fn ZigClangAPSInt_getNumWords(self: ?*const struct_ZigClangAPSInt) c_uint; pub extern fn ZigClangAPValueLValueBase_dyn_cast_Expr(self: struct_ZigClangAPValueLValueBase) ?*const struct_ZigClangExpr; +pub extern fn ZigClangASTUnit_delete(arg0: ?*struct_ZigClangASTUnit) void; pub const ZigClangSourceLocation = struct_ZigClangSourceLocation; pub const ZigClangQualType = struct_ZigClangQualType; pub const ZigClangAPValueLValueBase = struct_ZigClangAPValueLValueBase; @@ -942,3 +943,19 @@ pub const ZigClangTypeClass = enum_ZigClangTypeClass; pub const ZigClangStmtClass = enum_ZigClangStmtClass; pub const ZigClangCK = enum_ZigClangCK; pub const ZigClangAPValueKind = enum_ZigClangAPValueKind; + +pub const Stage2ErrorMsg = extern struct { + filename_ptr: ?[*]const u8, + filename_len: usize, + msg_ptr: [*]const u8, + msg_len: usize, + // valid until the ASTUnit is freed + source: ?[*]const u8, + // 0 based + line: c_uint, + // 0 based + column: c_uint, + // byte offset into source + offset: c_uint, +}; +pub extern fn ZigClangErrorMsg_delete(ptr: [*c]Stage2ErrorMsg, len: usize) void; diff --git a/src-self-hosted/main.zig b/src-self-hosted/main.zig index 361afc80e3..759a84cb34 100644 --- a/src-self-hosted/main.zig +++ b/src-self-hosted/main.zig @@ -858,7 +858,23 @@ fn cmdHelp(allocator: *Allocator, args: []const []const u8) !void { try stdout.write(usage); } -const info_zen = @import("stage1.zig").info_zen; +pub const info_zen = + \\ + \\ * Communicate intent precisely. + \\ * Edge cases matter. + \\ * Favor reading code over writing code. + \\ * Only one obvious way to do things. + \\ * Runtime crashes are better than bugs. + \\ * Compile errors are better than runtime crashes. + \\ * Incremental improvements. + \\ * Avoid local maximums. + \\ * Reduce the amount one must remember. + \\ * Minimize energy spent on coding style. + \\ * Together we serve end users. + \\ + \\ +; + fn cmdZen(allocator: *Allocator, args: []const []const u8) !void { try stdout.write(info_zen); } diff --git a/src-self-hosted/stage1.zig b/src-self-hosted/stage1.zig index cf5f06c285..53bc1eeb69 100644 --- a/src-self-hosted/stage1.zig +++ b/src-self-hosted/stage1.zig @@ -3,37 +3,25 @@ const std = @import("std"); -pub const info_zen = - \\ - \\ * Communicate intent precisely. - \\ * Edge cases matter. - \\ * Favor reading code over writing code. - \\ * Only one obvious way to do things. - \\ * Runtime crashes are better than bugs. - \\ * Compile errors are better than runtime crashes. - \\ * Incremental improvements. - \\ * Avoid local maximums. - \\ * Reduce the amount one must remember. - \\ * Minimize energy spent on coding style. - \\ * Together we serve end users. - \\ - \\ -; - +// ABI warning export fn stage2_zen(ptr: *[*]const u8, len: *usize) void { + const info_zen = @import("main.zig").info_zen; ptr.* = &info_zen; len.* = info_zen.len; } +// ABI warning export fn stage2_panic(ptr: [*]const u8, len: usize) void { @panic(ptr[0..len]); } +// ABI warning const TranslateMode = extern enum { import, translate, }; +// ABI warning const Error = extern enum { None, OutOfMemory, @@ -84,24 +72,33 @@ const Error = extern enum { const FILE = std.c.FILE; const ast = std.zig.ast; +const translate_c = @import("translate_c.zig"); /// Args should have a null terminating last arg. export fn stage2_translate_c( out_ast: **ast.Tree, + out_errors_ptr: *[*]translate_c.ClangErrMsg, + out_errors_len: *usize, args_begin: [*]?[*]const u8, args_end: [*]?[*]const u8, mode: TranslateMode, + resources_path: [*]const u8, ) Error { - const translate_c = @import("translate_c.zig"); + var errors: []translate_c.ClangErrMsg = undefined; out_ast.* = translate_c.translate(args_begin, args_end, switch (mode) { .import => translate_c.Mode.import, .translate => translate_c.Mode.translate, - }) catch |err| switch (err) { + }, &errors) catch |err| switch (err) { error.Unimplemented => return Error.Unimplemented, }; + return Error.None; } +export fn stage2_free_clang_errors(errors_ptr: [*]translate_c.ClangErrMsg, errors_len: usize) void { + translate_c.freeErrors(errors_ptr[0..errors_len]); +} + export fn stage2_render_ast(tree: *ast.Tree, output_file: *FILE) Error { const c_out_stream = &std.io.COutStream.init(output_file).stream; _ = std.zig.render(std.heap.c_allocator, c_out_stream, tree) catch |e| switch (e) { diff --git a/src-self-hosted/translate_c.zig b/src-self-hosted/translate_c.zig index c2d943b1ff..b2dcfffeb3 100644 --- a/src-self-hosted/translate_c.zig +++ b/src-self-hosted/translate_c.zig @@ -10,6 +10,17 @@ pub const Mode = enum { translate, }; -pub fn translate(args_begin: [*]?[*]const u8, args_end: [*]?[*]const u8, mode: Mode) !*ast.Tree { +pub const ClangErrMsg = Stage2ErrorMsg; + +pub fn translate( + args_begin: [*]?[*]const u8, + args_end: [*]?[*]const u8, + mode: Mode, + errors: *[]ClangErrMsg, +) !*ast.Tree { return error.Unimplemented; } + +pub fn freeErrors(errors: []ClangErrMsg) void { + ZigClangErrorMsg_delete(errors.ptr, errors.len); +} diff --git a/src/codegen.cpp b/src/codegen.cpp index b4ea0a9a96..27e2195a3c 100644 --- a/src/codegen.cpp +++ b/src/codegen.cpp @@ -8298,31 +8298,42 @@ void codegen_translate_c(CodeGen *g, Buf *full_path, FILE *out_file, bool use_us clang_argv.append(nullptr); // to make the [start...end] argument work + const char *resources_path = buf_ptr(g->zig_c_headers_dir); + Stage2ErrorMsg *errors_ptr; + size_t errors_len; + Stage2Ast *ast; + AstNode *root_node; + if (use_userland_implementation) { - Stage2Ast *ast; - if ((err = stage2_translate_c(&ast, &clang_argv.at(0), &clang_argv.last(), trans_mode))) { - zig_panic("TODO"); - } - stage2_render_ast(ast, out_file); + err = stage2_translate_c(&ast, &errors_ptr, &errors_len, + &clang_argv.at(0), &clang_argv.last(), trans_mode, resources_path); } else { - ZigList errors = {0}; - AstNode *root_node; - - err = parse_h_file(g, &root_node, &clang_argv.at(0), &clang_argv.last(), trans_mode, &errors); + err = parse_h_file(g, &root_node, &errors_ptr, &errors_len, &clang_argv.at(0), &clang_argv.last(), + trans_mode, resources_path); + } - if (err == ErrorCCompileErrors && errors.length > 0) { - for (size_t i = 0; i < errors.length; i += 1) { - ErrorMsg *err_msg = errors.at(i); - print_err_msg(err_msg, g->err_color); - } - exit(1); + if (err == ErrorCCompileErrors && errors_len > 0) { + for (size_t i = 0; i < errors_len; i += 1) { + Stage2ErrorMsg *clang_err = &errors_ptr[i]; + ErrorMsg *err_msg = err_msg_create_with_offset( + clang_err->filename_ptr ? + buf_create_from_mem(clang_err->filename_ptr, clang_err->filename_len) : buf_alloc(), + clang_err->line, clang_err->column, clang_err->offset, clang_err->source, + buf_create_from_mem(clang_err->msg_ptr, clang_err->msg_len)); + print_err_msg(err_msg, g->err_color); } + exit(1); + } - if (err) { - fprintf(stderr, "unable to parse C file: %s\n", err_str(err)); - exit(1); - } + if (err) { + fprintf(stderr, "unable to parse C file: %s\n", err_str(err)); + exit(1); + } + + if (use_userland_implementation) { + stage2_render_ast(ast, out_file); + } else { ast_render(out_file, root_node, 4); } } diff --git a/src/ir.cpp b/src/ir.cpp index 105dd0c3d6..3f74741995 100644 --- a/src/ir.cpp +++ b/src/ir.cpp @@ -19103,25 +19103,32 @@ static IrInstruction *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstruct clang_argv.append(nullptr); // to make the [start...end] argument work - ZigList errors = {0}; AstNode *root_node; + Stage2ErrorMsg *errors_ptr; + size_t errors_len; - if ((err = parse_h_file(ira->codegen, &root_node, &clang_argv.at(0), &clang_argv.last(), - Stage2TranslateModeImport, &errors))) + const char *resources_path = buf_ptr(ira->codegen->zig_c_headers_dir); + + if ((err = parse_h_file(ira->codegen, &root_node, &errors_ptr, &errors_len, + &clang_argv.at(0), &clang_argv.last(), Stage2TranslateModeImport, resources_path))) { if (err != ErrorCCompileErrors) { ir_add_error_node(ira, node, buf_sprintf("C import failed: %s", err_str(err))); return ira->codegen->invalid_instruction; } - assert(errors.length > 0); ErrorMsg *parent_err_msg = ir_add_error_node(ira, node, buf_sprintf("C import failed")); if (ira->codegen->libc_link_lib == nullptr) { add_error_note(ira->codegen, parent_err_msg, node, buf_sprintf("libc headers not available; compilation does not link against libc")); } - for (size_t i = 0; i < errors.length; i += 1) { - ErrorMsg *err_msg = errors.at(i); + for (size_t i = 0; i < errors_len; i += 1) { + Stage2ErrorMsg *clang_err = &errors_ptr[i]; + ErrorMsg *err_msg = err_msg_create_with_offset( + clang_err->filename_ptr ? + buf_create_from_mem(clang_err->filename_ptr, clang_err->filename_len) : buf_alloc(), + clang_err->line, clang_err->column, clang_err->offset, clang_err->source, + buf_create_from_mem(clang_err->msg_ptr, clang_err->msg_len)); err_msg_add_note(parent_err_msg, err_msg); } diff --git a/src/translate_c.cpp b/src/translate_c.cpp index d19083ce73..1c8d8e51b3 100644 --- a/src/translate_c.cpp +++ b/src/translate_c.cpp @@ -76,10 +76,9 @@ struct TransScopeWhile { }; struct Context { - ZigList *errors; + AstNode *root; VisibMod visib_mod; bool want_export; - AstNode *root; HashMap decl_table; HashMap macro_table; HashMap global_table; @@ -5018,13 +5017,14 @@ static void process_preprocessor_entities(Context *c, ZigClangASTUnit *zunit) { } } -Error parse_h_file(CodeGen *codegen, AstNode **out_root_node, const char **args_begin, const char **args_end, - Stage2TranslateMode mode, ZigList *errors) +Error parse_h_file(CodeGen *codegen, AstNode **out_root_node, + Stage2ErrorMsg **errors_ptr, size_t *errors_len, + const char **args_begin, const char **args_end, + Stage2TranslateMode mode, const char *resources_path) { Context context = {0}; Context *c = &context; c->warnings_on = codegen->verbose_cimport; - c->errors = errors; if (mode == Stage2TranslateModeImport) { c->visib_mod = VisibModPub; c->want_export = false; @@ -5039,78 +5039,10 @@ Error parse_h_file(CodeGen *codegen, AstNode **out_root_node, const char **args_ c->codegen = codegen; c->global_scope = trans_scope_root_create(c); - - clang::IntrusiveRefCntPtr diags(clang::CompilerInstance::createDiagnostics(new clang::DiagnosticOptions)); - - std::shared_ptr pch_container_ops = std::make_shared(); - - bool only_local_decls = true; - bool capture_diagnostics = true; - bool user_files_are_volatile = true; - bool allow_pch_with_compiler_errors = false; - bool single_file_parse = false; - bool for_serialization = false; - const char *resources_path = buf_ptr(codegen->zig_c_headers_dir); - std::unique_ptr err_unit; - ZigClangASTUnit *ast_unit = reinterpret_cast(clang::ASTUnit::LoadFromCommandLine( - args_begin, args_end, - pch_container_ops, diags, resources_path, - only_local_decls, capture_diagnostics, clang::None, true, 0, clang::TU_Complete, - false, false, allow_pch_with_compiler_errors, clang::SkipFunctionBodiesScope::None, - single_file_parse, user_files_are_volatile, for_serialization, clang::None, &err_unit, - nullptr)); - - // Early failures in LoadFromCommandLine may return with ErrUnit unset. - if (!ast_unit && !err_unit) { - return ErrorFileSystem; - } - - if (diags->getClient()->getNumErrors() > 0) { - if (ast_unit) { - err_unit = std::unique_ptr(reinterpret_cast(ast_unit)); - } - - for (clang::ASTUnit::stored_diag_iterator it = err_unit->stored_diag_begin(), - it_end = err_unit->stored_diag_end(); - it != it_end; ++it) - { - switch (it->getLevel()) { - case clang::DiagnosticsEngine::Ignored: - case clang::DiagnosticsEngine::Note: - case clang::DiagnosticsEngine::Remark: - case clang::DiagnosticsEngine::Warning: - continue; - case clang::DiagnosticsEngine::Error: - case clang::DiagnosticsEngine::Fatal: - break; - } - llvm::StringRef msg_str_ref = it->getMessage(); - Buf *msg = string_ref_to_buf(msg_str_ref); - clang::FullSourceLoc fsl = it->getLocation(); - if (fsl.hasManager()) { - clang::FileID file_id = fsl.getFileID(); - clang::StringRef filename = fsl.getManager().getFilename(fsl); - unsigned line = fsl.getSpellingLineNumber() - 1; - unsigned column = fsl.getSpellingColumnNumber() - 1; - unsigned offset = fsl.getManager().getFileOffset(fsl); - const char *source = (const char *)fsl.getManager().getBufferData(file_id).bytes_begin(); - Buf *path; - if (filename.empty()) { - path = buf_alloc(); - } else { - path = string_ref_to_buf(filename); - } - - ErrorMsg *err_msg = err_msg_create_with_offset(path, line, column, offset, source, msg); - - c->errors->append(err_msg); - } else { - // NOTE the only known way this gets triggered right now is if you have a lot of errors - // clang emits "too many errors emitted, stopping now" - fprintf(stderr, "unexpected error from clang: %s\n", buf_ptr(msg)); - } - } - + ZigClangASTUnit *ast_unit = ZigClangLoadFromCommandLine(args_begin, args_end, errors_ptr, errors_len, + resources_path); + if (ast_unit == nullptr) { + if (*errors_len == 0) return ErrorNoMem; return ErrorCCompileErrors; } diff --git a/src/translate_c.hpp b/src/translate_c.hpp index b6e4b6bcbb..4eac26ddb5 100644 --- a/src/translate_c.hpp +++ b/src/translate_c.hpp @@ -11,7 +11,9 @@ #include "all_types.hpp" -Error parse_h_file(CodeGen *codegen, AstNode **out_root_node, const char **args_begin, const char **args_end, - Stage2TranslateMode mode, ZigList *errors); +Error parse_h_file(CodeGen *codegen, AstNode **out_root_node, + Stage2ErrorMsg **errors_ptr, size_t *errors_len, + const char **args_begin, const char **args_end, + Stage2TranslateMode mode, const char *resources_path); #endif diff --git a/src/userland.cpp b/src/userland.cpp index 9935d5c04a..fad1450f0d 100644 --- a/src/userland.cpp +++ b/src/userland.cpp @@ -8,12 +8,19 @@ #include Error stage2_translate_c(struct Stage2Ast **out_ast, - const char **args_begin, const char **args_end, enum Stage2TranslateMode mode) + struct Stage2ErrorMsg **out_errors_ptr, size_t *out_errors_len, + const char **args_begin, const char **args_end, enum Stage2TranslateMode mode, + const char *resources_path) { const char *msg = "stage0 called stage2_translate_c"; stage2_panic(msg, strlen(msg)); } +void stage2_free_clang_errors(struct Stage2ErrorMsg *ptr, size_t len) { + const char *msg = "stage0 called stage2_free_clang_errors"; + stage2_panic(msg, strlen(msg)); +} + void stage2_zen(const char **ptr, size_t *len) { const char *msg = "stage0 called stage2_zen"; stage2_panic(msg, strlen(msg)); diff --git a/src/userland.h b/src/userland.h index 35fd46942b..ba797d8b25 100644 --- a/src/userland.h +++ b/src/userland.h @@ -12,20 +12,21 @@ #include #ifdef __cplusplus -#define ZIG_USERLAND_EXTERN_C extern "C" +#define ZIG_EXTERN_C extern "C" #else -#define ZIG_USERLAND_EXTERN_C +#define ZIG_EXTERN_C #endif #if defined(_MSC_VER) -#define ZIG_USERLAND_ATTRIBUTE_NORETURN __declspec(noreturn) +#define ZIG_ATTRIBUTE_NORETURN __declspec(noreturn) #else -#define ZIG_USERLAND_ATTRIBUTE_NORETURN __attribute__((noreturn)) +#define ZIG_ATTRIBUTE_NORETURN __attribute__((noreturn)) #endif -// The types and declarations in this file must match both those in userland.cpp and -// src-self-hosted/stage1.zig. +// ABI warning: the types and declarations in this file must match both those in +// userland.cpp and src-self-hosted/stage1.zig. +// ABI warning enum Error { ErrorNone, ErrorNoMem, @@ -74,20 +75,43 @@ enum Error { ErrorNoSpaceLeft, }; +// ABI warning enum Stage2TranslateMode { Stage2TranslateModeImport, Stage2TranslateModeTranslate, }; +// ABI warning +struct Stage2ErrorMsg { + const char *filename_ptr; // can be null + size_t filename_len; + const char *msg_ptr; + size_t msg_len; + const char *source; // valid until the ASTUnit is freed. can be null + unsigned line; // 0 based + unsigned column; // 0 based + unsigned offset; // byte offset into source +}; + +// ABI warning struct Stage2Ast; -ZIG_USERLAND_EXTERN_C Error stage2_translate_c(struct Stage2Ast **out_ast, - const char **args_begin, const char **args_end, enum Stage2TranslateMode mode); +// ABI warning +ZIG_EXTERN_C enum Error stage2_translate_c(struct Stage2Ast **out_ast, + struct Stage2ErrorMsg **out_errors_ptr, size_t *out_errors_len, + const char **args_begin, const char **args_end, enum Stage2TranslateMode mode, + const char *resources_path); + +// ABI warning +ZIG_EXTERN_C void stage2_free_clang_errors(struct Stage2ErrorMsg *ptr, size_t len); -ZIG_USERLAND_EXTERN_C void stage2_render_ast(struct Stage2Ast *ast, FILE *output_file); +// ABI warning +ZIG_EXTERN_C void stage2_render_ast(struct Stage2Ast *ast, FILE *output_file); -ZIG_USERLAND_EXTERN_C void stage2_zen(const char **ptr, size_t *len); +// ABI warning +ZIG_EXTERN_C void stage2_zen(const char **ptr, size_t *len); -ZIG_USERLAND_EXTERN_C ZIG_USERLAND_ATTRIBUTE_NORETURN void stage2_panic(const char *ptr, size_t len); +// ABI warning +ZIG_EXTERN_C ZIG_ATTRIBUTE_NORETURN void stage2_panic(const char *ptr, size_t len); #endif diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp index 6142c808ad..cc79941190 100644 --- a/src/zig_clang.cpp +++ b/src/zig_clang.cpp @@ -1147,3 +1147,115 @@ ZigClangAPValueLValueBase ZigClangAPValue_getLValueBase(const ZigClangAPValue *s clang::APValue::LValueBase lval_base = casted->getLValueBase(); return bitcast(lval_base); } + +ZigClangASTUnit *ZigClangLoadFromCommandLine(const char **args_begin, const char **args_end, + struct Stage2ErrorMsg **errors_ptr, size_t *errors_len, const char *resources_path) +{ + clang::IntrusiveRefCntPtr diags(clang::CompilerInstance::createDiagnostics(new clang::DiagnosticOptions)); + + std::shared_ptr pch_container_ops = std::make_shared(); + + bool only_local_decls = true; + bool capture_diagnostics = true; + bool user_files_are_volatile = true; + bool allow_pch_with_compiler_errors = false; + bool single_file_parse = false; + bool for_serialization = false; + std::unique_ptr *err_unit = new std::unique_ptr(); + clang::ASTUnit *ast_unit = clang::ASTUnit::LoadFromCommandLine( + args_begin, args_end, + pch_container_ops, diags, resources_path, + only_local_decls, capture_diagnostics, clang::None, true, 0, clang::TU_Complete, + false, false, allow_pch_with_compiler_errors, clang::SkipFunctionBodiesScope::None, + single_file_parse, user_files_are_volatile, for_serialization, clang::None, err_unit, + nullptr); + + // Early failures in LoadFromCommandLine may return with ErrUnit unset. + if (!ast_unit && !err_unit) { + return nullptr; + } + + if (diags->getClient()->getNumErrors() > 0) { + if (ast_unit) { + *err_unit = std::unique_ptr(ast_unit); + } + + size_t cap = 4; + *errors_len = 0; + *errors_ptr = reinterpret_cast(malloc(cap * sizeof(Stage2ErrorMsg))); + if (*errors_ptr == nullptr) { + return nullptr; + } + + for (clang::ASTUnit::stored_diag_iterator it = (*err_unit)->stored_diag_begin(), + it_end = (*err_unit)->stored_diag_end(); + it != it_end; ++it) + { + switch (it->getLevel()) { + case clang::DiagnosticsEngine::Ignored: + case clang::DiagnosticsEngine::Note: + case clang::DiagnosticsEngine::Remark: + case clang::DiagnosticsEngine::Warning: + continue; + case clang::DiagnosticsEngine::Error: + case clang::DiagnosticsEngine::Fatal: + break; + } + llvm::StringRef msg_str_ref = it->getMessage(); + if (*errors_len >= cap) { + cap *= 2; + Stage2ErrorMsg *new_errors = reinterpret_cast( + realloc(*errors_ptr, cap * sizeof(Stage2ErrorMsg))); + if (new_errors == nullptr) { + free(*errors_ptr); + *errors_ptr = nullptr; + *errors_len = 0; + return nullptr; + } + *errors_ptr = new_errors; + } + Stage2ErrorMsg *msg = *errors_ptr + *errors_len; + *errors_len += 1; + msg->msg_ptr = (const char *)msg_str_ref.bytes_begin(); + msg->msg_len = msg_str_ref.size(); + + clang::FullSourceLoc fsl = it->getLocation(); + if (fsl.hasManager()) { + clang::FileID file_id = fsl.getFileID(); + clang::StringRef filename = fsl.getManager().getFilename(fsl); + if (filename.empty()) { + msg->filename_ptr = nullptr; + } else { + msg->filename_ptr = (const char *)filename.bytes_begin(); + msg->filename_len = filename.size(); + } + msg->source = (const char *)fsl.getManager().getBufferData(file_id).bytes_begin(); + msg->line = fsl.getSpellingLineNumber() - 1; + msg->column = fsl.getSpellingColumnNumber() - 1; + msg->offset = fsl.getManager().getFileOffset(fsl); + } else { + // The only known way this gets triggered right now is if you have a lot of errors + // clang emits "too many errors emitted, stopping now" + msg->filename_ptr = nullptr; + msg->source = nullptr; + } + } + + if (*errors_len == 0) { + free(*errors_ptr); + *errors_ptr = nullptr; + } + + return nullptr; + } + + return reinterpret_cast(ast_unit); +} + +void ZigClangErrorMsg_delete(Stage2ErrorMsg *ptr, size_t len) { + free(ptr); +} + +void ZigClangASTUnit_delete(struct ZigClangASTUnit *self) { + delete reinterpret_cast(self); +} diff --git a/src/zig_clang.h b/src/zig_clang.h index 148ee34f51..f237449527 100644 --- a/src/zig_clang.h +++ b/src/zig_clang.h @@ -8,15 +8,10 @@ #ifndef ZIG_ZIG_CLANG_H #define ZIG_ZIG_CLANG_H +#include "userland.h" #include #include -#ifdef __cplusplus -#define ZIG_EXTERN_C extern "C" -#else -#define ZIG_EXTERN_C -#endif - // ATTENTION: If you modify this file, be sure to update the corresponding // extern function declarations in the self-hosted compiler file // src-self-hosted/clang.zig. @@ -500,6 +495,13 @@ ZIG_EXTERN_C const char* ZigClangSourceManager_getCharacterData(const struct Zig ZIG_EXTERN_C struct ZigClangQualType ZigClangASTContext_getPointerType(const struct ZigClangASTContext*, struct ZigClangQualType T); + +// Can return null. +ZIG_EXTERN_C struct ZigClangASTUnit *ZigClangLoadFromCommandLine(const char **args_begin, const char **args_end, + struct Stage2ErrorMsg **errors_ptr, size_t *errors_len, const char *resources_path); +ZIG_EXTERN_C void ZigClangASTUnit_delete(struct ZigClangASTUnit *); +ZIG_EXTERN_C void ZigClangErrorMsg_delete(struct Stage2ErrorMsg *ptr, size_t len); + ZIG_EXTERN_C struct ZigClangASTContext *ZigClangASTUnit_getASTContext(struct ZigClangASTUnit *); ZIG_EXTERN_C struct ZigClangSourceManager *ZigClangASTUnit_getSourceManager(struct ZigClangASTUnit *); ZIG_EXTERN_C bool ZigClangASTUnit_visitLocalTopLevelDecls(struct ZigClangASTUnit *, void *context, -- cgit v1.2.3 From 77383f968dde1e0d5d98865db8f560691d5f2afe Mon Sep 17 00:00:00 2001 From: LemonBoy Date: Sat, 20 Apr 2019 22:43:53 +0200 Subject: translate-c: Emit @ptrCast + @alignPtr sequence Avoid producing Zig code that doesn't compile due to mismatched alignments between pointers. Always emit a @alignOf instead of hardcoding the alignment value returned by LLVM for portability sake of the generated code. --- src/translate_c.cpp | 61 +++++++++++++++++++++++++++++++--------------------- src/zig_clang.cpp | 9 ++++++++ src/zig_clang.h | 1 + test/translate_c.zig | 36 ++++++++++++++++++++++++++++++- 4 files changed, 82 insertions(+), 25 deletions(-) (limited to 'src/zig_clang.cpp') diff --git a/src/translate_c.cpp b/src/translate_c.cpp index f8e57098a6..409e65cf47 100644 --- a/src/translate_c.cpp +++ b/src/translate_c.cpp @@ -121,6 +121,7 @@ static int trans_stmt_extra(Context *c, TransScope *scope, const ZigClangStmt *s TransScope **out_node_scope); static TransScope *trans_stmt(Context *c, TransScope *scope, const ZigClangStmt *stmt, AstNode **out_node); static AstNode *trans_expr(Context *c, ResultUsed result_used, TransScope *scope, const ZigClangExpr *expr, TransLRValue lrval); +static AstNode *trans_type(Context *c, const ZigClangType *ty, ZigClangSourceLocation source_loc); static AstNode *trans_qual_type(Context *c, ZigClangQualType qt, ZigClangSourceLocation source_loc); static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *scope, const ZigClangExpr *expr, TransLRValue lrval); @@ -575,13 +576,6 @@ static bool is_c_void_type(AstNode *node) { return (node->type == NodeTypeSymbol && buf_eql_str(node->data.symbol_expr.symbol, "c_void")); } -static bool expr_types_equal(Context *c, const ZigClangExpr *expr1, const ZigClangExpr *expr2) { - ZigClangQualType t1 = get_expr_qual_type(c, expr1); - ZigClangQualType t2 = get_expr_qual_type(c, expr2); - - return ZigClangQualType_eq(t1, t2); -} - static bool qual_type_is_ptr(ZigClangQualType qt) { const ZigClangType *ty = qual_type_canon(qt); return ZigClangType_getTypeClass(ty) == ZigClangType_Pointer; @@ -593,8 +587,7 @@ static const clang::FunctionProtoType *qual_type_get_fn_proto(ZigClangQualType q if (ZigClangType_getTypeClass(ty) == ZigClangType_Pointer) { *is_ptr = true; - const clang::PointerType *pointer_ty = reinterpret_cast(ty); - ZigClangQualType child_qt = bitcast(pointer_ty->getPointeeType()); + ZigClangQualType child_qt = ZigClangType_getPointeeType(ty); ty = ZigClangQualType_getTypePtr(child_qt); } @@ -705,6 +698,36 @@ static bool qual_type_child_is_fn_proto(ZigClangQualType qt) { return false; } +static AstNode* trans_c_ptr_cast(Context *c, ZigClangSourceLocation source_location, ZigClangQualType dest_type, + ZigClangQualType src_type, AstNode *expr) +{ + const ZigClangType *ty = ZigClangQualType_getTypePtr(dest_type); + const ZigClangQualType child_type = ZigClangType_getPointeeType(ty); + + AstNode *dest_type_node = trans_type(c, ty, source_location); + AstNode *child_type_node = trans_qual_type(c, child_type, source_location); + + // Implicit downcasting from higher to lower alignment values is forbidden, + // use @alignCast to side-step this problem + AstNode *ptrcast_node = trans_create_node_builtin_fn_call_str(c, "ptrCast"); + ptrcast_node->data.fn_call_expr.params.append(dest_type_node); + + if (ZigClangType_isVoidType(qual_type_canon(child_type))) { + // void has 1-byte alignment + ptrcast_node->data.fn_call_expr.params.append(expr); + } else { + AstNode *alignof_node = trans_create_node_builtin_fn_call_str(c, "alignOf"); + alignof_node->data.fn_call_expr.params.append(child_type_node); + AstNode *aligncast_node = trans_create_node_builtin_fn_call_str(c, "alignCast"); + aligncast_node->data.fn_call_expr.params.append(alignof_node); + aligncast_node->data.fn_call_expr.params.append(expr); + + ptrcast_node->data.fn_call_expr.params.append(aligncast_node); + } + + return ptrcast_node; +} + static AstNode* trans_c_cast(Context *c, ZigClangSourceLocation source_location, ZigClangQualType dest_type, ZigClangQualType src_type, AstNode *expr) { @@ -719,10 +742,7 @@ static AstNode* trans_c_cast(Context *c, ZigClangSourceLocation source_location, return expr; } if (qual_type_is_ptr(dest_type) && qual_type_is_ptr(src_type)) { - AstNode *ptr_cast_node = trans_create_node_builtin_fn_call_str(c, "ptrCast"); - ptr_cast_node->data.fn_call_expr.params.append(trans_qual_type(c, dest_type, source_location)); - ptr_cast_node->data.fn_call_expr.params.append(expr); - return ptr_cast_node; + return trans_c_ptr_cast(c, source_location, dest_type, src_type, expr); } // TODO: maybe widen to increase size // TODO: maybe bitcast to change sign @@ -980,8 +1000,7 @@ static AstNode *trans_type(Context *c, const ZigClangType *ty, ZigClangSourceLoc } case ZigClangType_Pointer: { - const clang::PointerType *pointer_ty = reinterpret_cast(ty); - ZigClangQualType child_qt = bitcast(pointer_ty->getPointeeType()); + ZigClangQualType child_qt = ZigClangType_getPointeeType(ty); AstNode *child_node = trans_qual_type(c, child_qt, source_loc); if (child_node == nullptr) { emit_warning(c, source_loc, "pointer to unsupported type"); @@ -1889,16 +1908,10 @@ static AstNode *trans_implicit_cast_expr(Context *c, ResultUsed result_used, Tra if (target_node == nullptr) return nullptr; - if (expr_types_equal(c, (const ZigClangExpr *)stmt, bitcast(stmt->getSubExpr()))) { - return target_node; - } + const ZigClangQualType dest_type = get_expr_qual_type(c, bitcast(stmt)); + const ZigClangQualType src_type = get_expr_qual_type(c, bitcast(stmt->getSubExpr())); - AstNode *dest_type_node = get_expr_type(c, (const ZigClangExpr *)stmt); - - AstNode *node = trans_create_node_builtin_fn_call_str(c, "ptrCast"); - node->data.fn_call_expr.params.append(dest_type_node); - node->data.fn_call_expr.params.append(target_node); - return maybe_suppress_result(c, result_used, node); + return trans_c_cast(c, bitcast(stmt->getBeginLoc()), dest_type, src_type, target_node); } case ZigClangCK_NullToPointer: return trans_create_node_unsigned(c, 0); diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp index cc79941190..37c8008969 100644 --- a/src/zig_clang.cpp +++ b/src/zig_clang.cpp @@ -870,6 +870,10 @@ ZigClangQualType ZigClangASTContext_getPointerType(const ZigClangASTContext* sel return bitcast(reinterpret_cast(self)->getPointerType(bitcast(T))); } +unsigned ZigClangASTContext_getTypeAlign(const ZigClangASTContext* self, ZigClangQualType T) { + return reinterpret_cast(self)->getTypeAlign(bitcast(T)); +} + ZigClangASTContext *ZigClangASTUnit_getASTContext(ZigClangASTUnit *self) { clang::ASTContext *result = &reinterpret_cast(self)->getASTContext(); return reinterpret_cast(result); @@ -1030,6 +1034,11 @@ ZigClangTypeClass ZigClangType_getTypeClass(const ZigClangType *self) { return (ZigClangTypeClass)tc; } +ZigClangQualType ZigClangType_getPointeeType(const ZigClangType *self) { + auto casted = reinterpret_cast(self); + return bitcast(casted->getPointeeType()); +} + bool ZigClangType_isVoidType(const ZigClangType *self) { auto casted = reinterpret_cast(self); return casted->isVoidType(); diff --git a/src/zig_clang.h b/src/zig_clang.h index f237449527..6c892d745c 100644 --- a/src/zig_clang.h +++ b/src/zig_clang.h @@ -543,6 +543,7 @@ ZIG_EXTERN_C bool ZigClangQualType_isVolatileQualified(struct ZigClangQualType); ZIG_EXTERN_C bool ZigClangQualType_isRestrictQualified(struct ZigClangQualType); ZIG_EXTERN_C enum ZigClangTypeClass ZigClangType_getTypeClass(const struct ZigClangType *self); +ZIG_EXTERN_C ZigClangQualType ZigClangType_getPointeeType(const ZigClangType *self); ZIG_EXTERN_C bool ZigClangType_isVoidType(const struct ZigClangType *self); ZIG_EXTERN_C const char *ZigClangType_getTypeClassName(const struct ZigClangType *self); diff --git a/test/translate_c.zig b/test/translate_c.zig index 7c0331fe35..7339130b86 100644 --- a/test/translate_c.zig +++ b/test/translate_c.zig @@ -1334,7 +1334,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void { \\} , \\fn ptrcast(a: [*c]c_int) [*c]f32 { - \\ return @ptrCast([*c]f32, a); + \\ return @ptrCast([*c]f32, @alignCast(@alignOf(f32), a)); \\} ); @@ -1608,6 +1608,40 @@ pub fn addCases(cases: *tests.TranslateCContext) void { \\} ); + cases.addC("pointer conversion with different alignment", + \\void test_ptr_cast() { + \\ void *p; + \\ { + \\ char *to_char = (char *)p; + \\ short *to_short = (short *)p; + \\ int *to_int = (int *)p; + \\ long long *to_longlong = (long long *)p; + \\ } + \\ { + \\ char *to_char = p; + \\ short *to_short = p; + \\ int *to_int = p; + \\ long long *to_longlong = p; + \\ } + \\} + , + \\pub export fn test_ptr_cast() void { + \\ var p: ?*c_void = undefined; + \\ { + \\ var to_char: [*c]u8 = @ptrCast([*c]u8, @alignCast(@alignOf(u8), p)); + \\ var to_short: [*c]c_short = @ptrCast([*c]c_short, @alignCast(@alignOf(c_short), p)); + \\ var to_int: [*c]c_int = @ptrCast([*c]c_int, @alignCast(@alignOf(c_int), p)); + \\ var to_longlong: [*c]c_longlong = @ptrCast([*c]c_longlong, @alignCast(@alignOf(c_longlong), p)); + \\ } + \\ { + \\ var to_char: [*c]u8 = @ptrCast([*c]u8, @alignCast(@alignOf(u8), p)); + \\ var to_short: [*c]c_short = @ptrCast([*c]c_short, @alignCast(@alignOf(c_short), p)); + \\ var to_int: [*c]c_int = @ptrCast([*c]c_int, @alignCast(@alignOf(c_int), p)); + \\ var to_longlong: [*c]c_longlong = @ptrCast([*c]c_longlong, @alignCast(@alignOf(c_longlong), p)); + \\ } + \\} + ); + // cases.add("empty array with initializer", // "int a[4] = {};" // , -- cgit v1.2.3 From a7f99c8ee9b53212b5cf4a5e76329ab53566084b Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Tue, 30 Apr 2019 00:21:45 -0400 Subject: self-hosted translate-c: iterate over top level decls See #1964 --- src-self-hosted/clang.zig | 82 ++++++++++++++++++- src-self-hosted/translate_c.zig | 68 ++++++++++++++-- src/translate_c.cpp | 23 +++--- src/zig_clang.cpp | 171 ++++++++++++++++++++++++++++++++++++++++ src/zig_clang.h | 82 ++++++++++++++++++- 5 files changed, 404 insertions(+), 22 deletions(-) (limited to 'src/zig_clang.cpp') diff --git a/src-self-hosted/clang.zig b/src-self-hosted/clang.zig index 15e480919b..62310e8bea 100644 --- a/src-self-hosted/clang.zig +++ b/src-self-hosted/clang.zig @@ -813,7 +813,7 @@ pub extern fn ZigClangSourceManager_getCharacterData(arg0: ?*const struct_ZigCla pub extern fn ZigClangASTContext_getPointerType(arg0: ?*const struct_ZigClangASTContext, T: struct_ZigClangQualType) struct_ZigClangQualType; pub extern fn ZigClangASTUnit_getASTContext(arg0: ?*struct_ZigClangASTUnit) ?*struct_ZigClangASTContext; pub extern fn ZigClangASTUnit_getSourceManager(arg0: ?*struct_ZigClangASTUnit) ?*struct_ZigClangSourceManager; -pub extern fn ZigClangASTUnit_visitLocalTopLevelDecls(arg0: ?*struct_ZigClangASTUnit, context: ?*c_void, Fn: ?extern fn (?*c_void, ?*const struct_ZigClangDecl) bool) bool; +pub extern fn ZigClangASTUnit_visitLocalTopLevelDecls(self: *struct_ZigClangASTUnit, context: ?*c_void, Fn: ?extern fn (?*c_void, *const struct_ZigClangDecl) bool) bool; pub extern fn ZigClangRecordType_getDecl(record_ty: ?*const struct_ZigClangRecordType) ?*const struct_ZigClangRecordDecl; 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; @@ -967,3 +967,83 @@ pub extern fn ZigClangLoadFromCommandLine( errors_len: *usize, resources_path: [*c]const u8, ) ?*ZigClangASTUnit; + + +pub extern fn ZigClangDecl_getKind(decl: *const ZigClangDecl) ZigClangDeclKind; + +pub const ZigClangDeclKind = extern enum { + AccessSpec, + Block, + Captured, + ClassScopeFunctionSpecialization, + Empty, + Export, + ExternCContext, + FileScopeAsm, + Friend, + FriendTemplate, + Import, + LinkageSpec, + Label, + Namespace, + NamespaceAlias, + ObjCCompatibleAlias, + ObjCCategory, + ObjCCategoryImpl, + ObjCImplementation, + ObjCInterface, + ObjCProtocol, + ObjCMethod, + ObjCProperty, + BuiltinTemplate, + ClassTemplate, + FunctionTemplate, + TypeAliasTemplate, + VarTemplate, + TemplateTemplateParm, + Enum, + Record, + CXXRecord, + ClassTemplateSpecialization, + ClassTemplatePartialSpecialization, + TemplateTypeParm, + ObjCTypeParam, + TypeAlias, + Typedef, + UnresolvedUsingTypename, + Using, + UsingDirective, + UsingPack, + UsingShadow, + ConstructorUsingShadow, + Binding, + Field, + ObjCAtDefsField, + ObjCIvar, + Function, + CXXDeductionGuide, + CXXMethod, + CXXConstructor, + CXXConversion, + CXXDestructor, + MSProperty, + NonTypeTemplateParm, + Var, + Decomposition, + ImplicitParam, + OMPCapturedExpr, + ParmVar, + VarTemplateSpecialization, + VarTemplatePartialSpecialization, + EnumConstant, + IndirectField, + OMPDeclareReduction, + UnresolvedUsingValue, + OMPRequires, + OMPThreadPrivate, + ObjCPropertyImpl, + PragmaComment, + PragmaDetectMismatch, + StaticAssert, + TranslationUnit, +}; diff --git a/src-self-hosted/translate_c.zig b/src-self-hosted/translate_c.zig index 31be0abdc4..afe4ab0945 100644 --- a/src-self-hosted/translate_c.zig +++ b/src-self-hosted/translate_c.zig @@ -1,5 +1,5 @@ // This is the userland implementation of translate-c which will be used by both stage1 -// and stage2. Currently it's not used by anything, as it's not feature complete. +// and stage2. Currently the only way it is used is with `zig translate-c-2`. const std = @import("std"); const ast = std.zig.ast; @@ -13,6 +13,16 @@ pub const Mode = enum { pub const ClangErrMsg = Stage2ErrorMsg; +pub const Error = error { + OutOfMemory, +}; + +const Context = struct { + tree: *ast.Tree, + source_buffer: *std.Buffer, + err: Error, +}; + pub fn translate( backing_allocator: *std.mem.Allocator, args_begin: [*]?[*]const u8, @@ -57,23 +67,65 @@ pub fn translate( var source_buffer = try std.Buffer.initSize(arena, 0); - try appendToken(tree, &source_buffer, "// TODO: implement more than just an empty source file", .LineComment); + var context = Context{ + .tree = tree, + .source_buffer = &source_buffer, + .err = undefined, + }; + + if (!ZigClangASTUnit_visitLocalTopLevelDecls(ast_unit, &context, declVisitorC)) { + return context.err; + } - try appendToken(tree, &source_buffer, "", .Eof); + try appendToken(&context, .Eof, ""); tree.source = source_buffer.toOwnedSlice(); return tree; } -fn appendToken(tree: *ast.Tree, source_buffer: *std.Buffer, src_text: []const u8, token_id: Token.Id) !void { - const start_index = source_buffer.len(); - try source_buffer.append(src_text); - const end_index = source_buffer.len(); - const new_token = try tree.tokens.addOne(); +extern fn declVisitorC(context: ?*c_void, decl: *const ZigClangDecl) bool { + const c = @ptrCast(*Context, @alignCast(@alignOf(Context), context)); + declVisitor(c, decl) catch |err| { + c.err = err; + return false; + }; + return true; +} + +fn declVisitor(c: *Context, decl: *const ZigClangDecl) Error!void { + switch (ZigClangDecl_getKind(decl)) { + .Function => { + try appendToken(c, .LineComment, "// TODO translate function decl"); + }, + .Typedef => { + try appendToken(c, .LineComment, "// TODO translate typedef"); + }, + .Enum => { + try appendToken(c, .LineComment, "// TODO translate enum"); + }, + .Record => { + try appendToken(c, .LineComment, "// TODO translate struct"); + }, + .Var => { + try appendToken(c, .LineComment, "// TODO translate variable"); + }, + else => { + // TODO emit_warning(c, bitcast(decl->getLocation()), "ignoring %s decl", decl->getDeclKindName()); + try appendToken(c, .LineComment, "// TODO translate unknown decl"); + }, + } +} + +fn appendToken(c: *Context, token_id: Token.Id, src_text: []const u8) !void { + const start_index = c.source_buffer.len(); + try c.source_buffer.append(src_text); + const end_index = c.source_buffer.len(); + const new_token = try c.tree.tokens.addOne(); new_token.* = Token{ .id = token_id, .start = start_index, .end = end_index, }; + try c.source_buffer.appendByte('\n'); } pub fn freeErrors(errors: []ClangErrMsg) void { diff --git a/src/translate_c.cpp b/src/translate_c.cpp index 409e65cf47..2389f55cb8 100644 --- a/src/translate_c.cpp +++ b/src/translate_c.cpp @@ -4554,28 +4554,27 @@ static void visit_var_decl(Context *c, const clang::VarDecl *var_decl) { return; } -static bool decl_visitor(void *context, const ZigClangDecl *zdecl) { - const clang::Decl *decl = reinterpret_cast(zdecl); +static bool decl_visitor(void *context, const ZigClangDecl *decl) { Context *c = (Context*)context; - switch (decl->getKind()) { - case clang::Decl::Function: - visit_fn_decl(c, static_cast(decl)); + switch (ZigClangDecl_getKind(decl)) { + case ZigClangDeclFunction: + visit_fn_decl(c, reinterpret_cast(decl)); break; - case clang::Decl::Typedef: + case ZigClangDeclTypedef: resolve_typedef_decl(c, reinterpret_cast(decl)); break; - case clang::Decl::Enum: + case ZigClangDeclEnum: resolve_enum_decl(c, reinterpret_cast(decl)); break; - case clang::Decl::Record: - resolve_record_decl(c, (const ZigClangRecordDecl *)(decl)); + case ZigClangDeclRecord: + resolve_record_decl(c, reinterpret_cast(decl)); break; - case clang::Decl::Var: - visit_var_decl(c, static_cast(decl)); + case ZigClangDeclVar: + visit_var_decl(c, reinterpret_cast(decl)); break; default: - emit_warning(c, bitcast(decl->getLocation()), "ignoring %s decl", decl->getDeclKindName()); + emit_warning(c, ZigClangDecl_getLocation(decl), "ignoring %s decl", ZigClangDecl_getDeclKindName(decl)); } return true; diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp index 37c8008969..901f702275 100644 --- a/src/zig_clang.cpp +++ b/src/zig_clang.cpp @@ -799,6 +799,162 @@ static_assert((clang::APValue::ValueKind)ZigClangAPValueMemberPointer == clang:: static_assert((clang::APValue::ValueKind)ZigClangAPValueAddrLabelDiff == clang::APValue::AddrLabelDiff, ""); +void ZigClang_detect_enum_DeclKind(clang::Decl::Kind x) { + switch (x) { + case ZigClangDeclAccessSpec: + case ZigClangDeclBlock: + case ZigClangDeclCaptured: + case ZigClangDeclClassScopeFunctionSpecialization: + case ZigClangDeclEmpty: + case ZigClangDeclExport: + case ZigClangDeclExternCContext: + case ZigClangDeclFileScopeAsm: + case ZigClangDeclFriend: + case ZigClangDeclFriendTemplate: + case ZigClangDeclImport: + case ZigClangDeclLinkageSpec: + case ZigClangDeclLabel: + case ZigClangDeclNamespace: + case ZigClangDeclNamespaceAlias: + case ZigClangDeclObjCCompatibleAlias: + case ZigClangDeclObjCCategory: + case ZigClangDeclObjCCategoryImpl: + case ZigClangDeclObjCImplementation: + case ZigClangDeclObjCInterface: + case ZigClangDeclObjCProtocol: + case ZigClangDeclObjCMethod: + case ZigClangDeclObjCProperty: + case ZigClangDeclBuiltinTemplate: + case ZigClangDeclClassTemplate: + case ZigClangDeclFunctionTemplate: + case ZigClangDeclTypeAliasTemplate: + case ZigClangDeclVarTemplate: + case ZigClangDeclTemplateTemplateParm: + case ZigClangDeclEnum: + case ZigClangDeclRecord: + case ZigClangDeclCXXRecord: + case ZigClangDeclClassTemplateSpecialization: + case ZigClangDeclClassTemplatePartialSpecialization: + case ZigClangDeclTemplateTypeParm: + case ZigClangDeclObjCTypeParam: + case ZigClangDeclTypeAlias: + case ZigClangDeclTypedef: + case ZigClangDeclUnresolvedUsingTypename: + case ZigClangDeclUsing: + case ZigClangDeclUsingDirective: + case ZigClangDeclUsingPack: + case ZigClangDeclUsingShadow: + case ZigClangDeclConstructorUsingShadow: + case ZigClangDeclBinding: + case ZigClangDeclField: + case ZigClangDeclObjCAtDefsField: + case ZigClangDeclObjCIvar: + case ZigClangDeclFunction: + case ZigClangDeclCXXDeductionGuide: + case ZigClangDeclCXXMethod: + case ZigClangDeclCXXConstructor: + case ZigClangDeclCXXConversion: + case ZigClangDeclCXXDestructor: + case ZigClangDeclMSProperty: + case ZigClangDeclNonTypeTemplateParm: + case ZigClangDeclVar: + case ZigClangDeclDecomposition: + case ZigClangDeclImplicitParam: + case ZigClangDeclOMPCapturedExpr: + case ZigClangDeclParmVar: + case ZigClangDeclVarTemplateSpecialization: + case ZigClangDeclVarTemplatePartialSpecialization: + case ZigClangDeclEnumConstant: + case ZigClangDeclIndirectField: + case ZigClangDeclOMPDeclareReduction: + case ZigClangDeclUnresolvedUsingValue: + case ZigClangDeclOMPRequires: + case ZigClangDeclOMPThreadPrivate: + case ZigClangDeclObjCPropertyImpl: + case ZigClangDeclPragmaComment: + case ZigClangDeclPragmaDetectMismatch: + case ZigClangDeclStaticAssert: + case ZigClangDeclTranslationUnit: + break; + } +} + +static_assert((clang::Decl::Kind)ZigClangDeclAccessSpec == clang::Decl::AccessSpec, ""); +static_assert((clang::Decl::Kind)ZigClangDeclBlock == clang::Decl::Block, ""); +static_assert((clang::Decl::Kind)ZigClangDeclCaptured == clang::Decl::Captured, ""); +static_assert((clang::Decl::Kind)ZigClangDeclClassScopeFunctionSpecialization == clang::Decl::ClassScopeFunctionSpecialization, ""); +static_assert((clang::Decl::Kind)ZigClangDeclEmpty == clang::Decl::Empty, ""); +static_assert((clang::Decl::Kind)ZigClangDeclExport == clang::Decl::Export, ""); +static_assert((clang::Decl::Kind)ZigClangDeclExternCContext == clang::Decl::ExternCContext, ""); +static_assert((clang::Decl::Kind)ZigClangDeclFileScopeAsm == clang::Decl::FileScopeAsm, ""); +static_assert((clang::Decl::Kind)ZigClangDeclFriend == clang::Decl::Friend, ""); +static_assert((clang::Decl::Kind)ZigClangDeclFriendTemplate == clang::Decl::FriendTemplate, ""); +static_assert((clang::Decl::Kind)ZigClangDeclImport == clang::Decl::Import, ""); +static_assert((clang::Decl::Kind)ZigClangDeclLinkageSpec == clang::Decl::LinkageSpec, ""); +static_assert((clang::Decl::Kind)ZigClangDeclLabel == clang::Decl::Label, ""); +static_assert((clang::Decl::Kind)ZigClangDeclNamespace == clang::Decl::Namespace, ""); +static_assert((clang::Decl::Kind)ZigClangDeclNamespaceAlias == clang::Decl::NamespaceAlias, ""); +static_assert((clang::Decl::Kind)ZigClangDeclObjCCompatibleAlias == clang::Decl::ObjCCompatibleAlias, ""); +static_assert((clang::Decl::Kind)ZigClangDeclObjCCategory == clang::Decl::ObjCCategory, ""); +static_assert((clang::Decl::Kind)ZigClangDeclObjCCategoryImpl == clang::Decl::ObjCCategoryImpl, ""); +static_assert((clang::Decl::Kind)ZigClangDeclObjCImplementation == clang::Decl::ObjCImplementation, ""); +static_assert((clang::Decl::Kind)ZigClangDeclObjCInterface == clang::Decl::ObjCInterface, ""); +static_assert((clang::Decl::Kind)ZigClangDeclObjCProtocol == clang::Decl::ObjCProtocol, ""); +static_assert((clang::Decl::Kind)ZigClangDeclObjCMethod == clang::Decl::ObjCMethod, ""); +static_assert((clang::Decl::Kind)ZigClangDeclObjCProperty == clang::Decl::ObjCProperty, ""); +static_assert((clang::Decl::Kind)ZigClangDeclBuiltinTemplate == clang::Decl::BuiltinTemplate, ""); +static_assert((clang::Decl::Kind)ZigClangDeclClassTemplate == clang::Decl::ClassTemplate, ""); +static_assert((clang::Decl::Kind)ZigClangDeclFunctionTemplate == clang::Decl::FunctionTemplate, ""); +static_assert((clang::Decl::Kind)ZigClangDeclTypeAliasTemplate == clang::Decl::TypeAliasTemplate, ""); +static_assert((clang::Decl::Kind)ZigClangDeclVarTemplate == clang::Decl::VarTemplate, ""); +static_assert((clang::Decl::Kind)ZigClangDeclTemplateTemplateParm == clang::Decl::TemplateTemplateParm, ""); +static_assert((clang::Decl::Kind)ZigClangDeclEnum == clang::Decl::Enum, ""); +static_assert((clang::Decl::Kind)ZigClangDeclRecord == clang::Decl::Record, ""); +static_assert((clang::Decl::Kind)ZigClangDeclCXXRecord == clang::Decl::CXXRecord, ""); +static_assert((clang::Decl::Kind)ZigClangDeclClassTemplateSpecialization == clang::Decl::ClassTemplateSpecialization, ""); +static_assert((clang::Decl::Kind)ZigClangDeclClassTemplatePartialSpecialization == clang::Decl::ClassTemplatePartialSpecialization, ""); +static_assert((clang::Decl::Kind)ZigClangDeclTemplateTypeParm == clang::Decl::TemplateTypeParm, ""); +static_assert((clang::Decl::Kind)ZigClangDeclObjCTypeParam == clang::Decl::ObjCTypeParam, ""); +static_assert((clang::Decl::Kind)ZigClangDeclTypeAlias == clang::Decl::TypeAlias, ""); +static_assert((clang::Decl::Kind)ZigClangDeclTypedef == clang::Decl::Typedef, ""); +static_assert((clang::Decl::Kind)ZigClangDeclUnresolvedUsingTypename == clang::Decl::UnresolvedUsingTypename, ""); +static_assert((clang::Decl::Kind)ZigClangDeclUsing == clang::Decl::Using, ""); +static_assert((clang::Decl::Kind)ZigClangDeclUsingDirective == clang::Decl::UsingDirective, ""); +static_assert((clang::Decl::Kind)ZigClangDeclUsingPack == clang::Decl::UsingPack, ""); +static_assert((clang::Decl::Kind)ZigClangDeclUsingShadow == clang::Decl::UsingShadow, ""); +static_assert((clang::Decl::Kind)ZigClangDeclConstructorUsingShadow == clang::Decl::ConstructorUsingShadow, ""); +static_assert((clang::Decl::Kind)ZigClangDeclBinding == clang::Decl::Binding, ""); +static_assert((clang::Decl::Kind)ZigClangDeclField == clang::Decl::Field, ""); +static_assert((clang::Decl::Kind)ZigClangDeclObjCAtDefsField == clang::Decl::ObjCAtDefsField, ""); +static_assert((clang::Decl::Kind)ZigClangDeclObjCIvar == clang::Decl::ObjCIvar, ""); +static_assert((clang::Decl::Kind)ZigClangDeclFunction == clang::Decl::Function, ""); +static_assert((clang::Decl::Kind)ZigClangDeclCXXDeductionGuide == clang::Decl::CXXDeductionGuide, ""); +static_assert((clang::Decl::Kind)ZigClangDeclCXXMethod == clang::Decl::CXXMethod, ""); +static_assert((clang::Decl::Kind)ZigClangDeclCXXConstructor == clang::Decl::CXXConstructor, ""); +static_assert((clang::Decl::Kind)ZigClangDeclCXXConversion == clang::Decl::CXXConversion, ""); +static_assert((clang::Decl::Kind)ZigClangDeclCXXDestructor == clang::Decl::CXXDestructor, ""); +static_assert((clang::Decl::Kind)ZigClangDeclMSProperty == clang::Decl::MSProperty, ""); +static_assert((clang::Decl::Kind)ZigClangDeclNonTypeTemplateParm == clang::Decl::NonTypeTemplateParm, ""); +static_assert((clang::Decl::Kind)ZigClangDeclVar == clang::Decl::Var, ""); +static_assert((clang::Decl::Kind)ZigClangDeclDecomposition == clang::Decl::Decomposition, ""); +static_assert((clang::Decl::Kind)ZigClangDeclImplicitParam == clang::Decl::ImplicitParam, ""); +static_assert((clang::Decl::Kind)ZigClangDeclOMPCapturedExpr == clang::Decl::OMPCapturedExpr, ""); +static_assert((clang::Decl::Kind)ZigClangDeclParmVar == clang::Decl::ParmVar, ""); +static_assert((clang::Decl::Kind)ZigClangDeclVarTemplateSpecialization == clang::Decl::VarTemplateSpecialization, ""); +static_assert((clang::Decl::Kind)ZigClangDeclVarTemplatePartialSpecialization == clang::Decl::VarTemplatePartialSpecialization, ""); +static_assert((clang::Decl::Kind)ZigClangDeclEnumConstant == clang::Decl::EnumConstant, ""); +static_assert((clang::Decl::Kind)ZigClangDeclIndirectField == clang::Decl::IndirectField, ""); +static_assert((clang::Decl::Kind)ZigClangDeclOMPDeclareReduction == clang::Decl::OMPDeclareReduction, ""); +static_assert((clang::Decl::Kind)ZigClangDeclUnresolvedUsingValue == clang::Decl::UnresolvedUsingValue, ""); +static_assert((clang::Decl::Kind)ZigClangDeclOMPRequires == clang::Decl::OMPRequires, ""); +static_assert((clang::Decl::Kind)ZigClangDeclOMPThreadPrivate == clang::Decl::OMPThreadPrivate, ""); +static_assert((clang::Decl::Kind)ZigClangDeclObjCPropertyImpl == clang::Decl::ObjCPropertyImpl, ""); +static_assert((clang::Decl::Kind)ZigClangDeclPragmaComment == clang::Decl::PragmaComment, ""); +static_assert((clang::Decl::Kind)ZigClangDeclPragmaDetectMismatch == clang::Decl::PragmaDetectMismatch, ""); +static_assert((clang::Decl::Kind)ZigClangDeclStaticAssert == clang::Decl::StaticAssert, ""); +static_assert((clang::Decl::Kind)ZigClangDeclTranslationUnit == clang::Decl::TranslationUnit, ""); + + static_assert(sizeof(ZigClangSourceLocation) == sizeof(clang::SourceLocation), ""); static ZigClangSourceLocation bitcast(clang::SourceLocation src) { ZigClangSourceLocation dest; @@ -946,6 +1102,16 @@ const char *ZigClangDecl_getName_bytes_begin(const ZigClangDecl *zig_decl) { return (const char *)named_decl->getName().bytes_begin(); } +ZigClangDeclKind ZigClangDecl_getKind(const struct ZigClangDecl *self) { + auto casted = reinterpret_cast(self); + return (ZigClangDeclKind)casted->getKind(); +} + +const char *ZigClangDecl_getDeclKindName(const struct ZigClangDecl *self) { + auto casted = reinterpret_cast(self); + return casted->getDeclKindName(); +} + ZigClangSourceLocation ZigClangRecordDecl_getLocation(const ZigClangRecordDecl *zig_record_decl) { const clang::RecordDecl *record_decl = reinterpret_cast(zig_record_decl); return bitcast(record_decl->getLocation()); @@ -961,6 +1127,11 @@ ZigClangSourceLocation ZigClangTypedefNameDecl_getLocation(const ZigClangTypedef return bitcast(casted->getLocation()); } +ZigClangSourceLocation ZigClangDecl_getLocation(const ZigClangDecl *self) { + auto casted = reinterpret_cast(self); + return bitcast(casted->getLocation()); +} + bool ZigClangSourceLocation_eq(ZigClangSourceLocation zig_a, ZigClangSourceLocation zig_b) { clang::SourceLocation a = bitcast(zig_a); clang::SourceLocation b = bitcast(zig_b); diff --git a/src/zig_clang.h b/src/zig_clang.h index 6c892d745c..777ad8c34b 100644 --- a/src/zig_clang.h +++ b/src/zig_clang.h @@ -482,6 +482,83 @@ enum ZigClangAPValueKind { ZigClangAPValueAddrLabelDiff, }; +enum ZigClangDeclKind { + ZigClangDeclAccessSpec, + ZigClangDeclBlock, + ZigClangDeclCaptured, + ZigClangDeclClassScopeFunctionSpecialization, + ZigClangDeclEmpty, + ZigClangDeclExport, + ZigClangDeclExternCContext, + ZigClangDeclFileScopeAsm, + ZigClangDeclFriend, + ZigClangDeclFriendTemplate, + ZigClangDeclImport, + ZigClangDeclLinkageSpec, + ZigClangDeclLabel, + ZigClangDeclNamespace, + ZigClangDeclNamespaceAlias, + ZigClangDeclObjCCompatibleAlias, + ZigClangDeclObjCCategory, + ZigClangDeclObjCCategoryImpl, + ZigClangDeclObjCImplementation, + ZigClangDeclObjCInterface, + ZigClangDeclObjCProtocol, + ZigClangDeclObjCMethod, + ZigClangDeclObjCProperty, + ZigClangDeclBuiltinTemplate, + ZigClangDeclClassTemplate, + ZigClangDeclFunctionTemplate, + ZigClangDeclTypeAliasTemplate, + ZigClangDeclVarTemplate, + ZigClangDeclTemplateTemplateParm, + ZigClangDeclEnum, + ZigClangDeclRecord, + ZigClangDeclCXXRecord, + ZigClangDeclClassTemplateSpecialization, + ZigClangDeclClassTemplatePartialSpecialization, + ZigClangDeclTemplateTypeParm, + ZigClangDeclObjCTypeParam, + ZigClangDeclTypeAlias, + ZigClangDeclTypedef, + ZigClangDeclUnresolvedUsingTypename, + ZigClangDeclUsing, + ZigClangDeclUsingDirective, + ZigClangDeclUsingPack, + ZigClangDeclUsingShadow, + ZigClangDeclConstructorUsingShadow, + ZigClangDeclBinding, + ZigClangDeclField, + ZigClangDeclObjCAtDefsField, + ZigClangDeclObjCIvar, + ZigClangDeclFunction, + ZigClangDeclCXXDeductionGuide, + ZigClangDeclCXXMethod, + ZigClangDeclCXXConstructor, + ZigClangDeclCXXConversion, + ZigClangDeclCXXDestructor, + ZigClangDeclMSProperty, + ZigClangDeclNonTypeTemplateParm, + ZigClangDeclVar, + ZigClangDeclDecomposition, + ZigClangDeclImplicitParam, + ZigClangDeclOMPCapturedExpr, + ZigClangDeclParmVar, + ZigClangDeclVarTemplateSpecialization, + ZigClangDeclVarTemplatePartialSpecialization, + ZigClangDeclEnumConstant, + ZigClangDeclIndirectField, + ZigClangDeclOMPDeclareReduction, + ZigClangDeclUnresolvedUsingValue, + ZigClangDeclOMPRequires, + ZigClangDeclOMPThreadPrivate, + ZigClangDeclObjCPropertyImpl, + ZigClangDeclPragmaComment, + ZigClangDeclPragmaDetectMismatch, + ZigClangDeclStaticAssert, + ZigClangDeclTranslationUnit, +}; + ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangSourceManager_getSpellingLoc(const struct ZigClangSourceManager *, struct ZigClangSourceLocation Loc); ZIG_EXTERN_C const char *ZigClangSourceManager_getFilename(const struct ZigClangSourceManager *, @@ -520,6 +597,7 @@ ZIG_EXTERN_C const struct ZigClangEnumDecl *ZigClangEnumDecl_getDefinition(const ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangRecordDecl_getLocation(const struct ZigClangRecordDecl *); ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangEnumDecl_getLocation(const struct ZigClangEnumDecl *); ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangTypedefNameDecl_getLocation(const struct ZigClangTypedefNameDecl *); +ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangDecl_getLocation(const struct ZigClangDecl *); ZIG_EXTERN_C bool ZigClangRecordDecl_isUnion(const struct ZigClangRecordDecl *record_decl); ZIG_EXTERN_C bool ZigClangRecordDecl_isStruct(const struct ZigClangRecordDecl *record_decl); @@ -528,6 +606,8 @@ ZIG_EXTERN_C bool ZigClangRecordDecl_isAnonymousStructOrUnion(const struct ZigCl ZIG_EXTERN_C struct ZigClangQualType ZigClangEnumDecl_getIntegerType(const struct ZigClangEnumDecl *); ZIG_EXTERN_C const char *ZigClangDecl_getName_bytes_begin(const struct ZigClangDecl *decl); +ZIG_EXTERN_C enum ZigClangDeclKind ZigClangDecl_getKind(const struct ZigClangDecl *decl); +ZIG_EXTERN_C const char *ZigClangDecl_getDeclKindName(const struct ZigClangDecl *decl); ZIG_EXTERN_C bool ZigClangSourceLocation_eq(struct ZigClangSourceLocation a, struct ZigClangSourceLocation b); @@ -543,7 +623,7 @@ ZIG_EXTERN_C bool ZigClangQualType_isVolatileQualified(struct ZigClangQualType); ZIG_EXTERN_C bool ZigClangQualType_isRestrictQualified(struct ZigClangQualType); ZIG_EXTERN_C enum ZigClangTypeClass ZigClangType_getTypeClass(const struct ZigClangType *self); -ZIG_EXTERN_C ZigClangQualType ZigClangType_getPointeeType(const ZigClangType *self); +ZIG_EXTERN_C struct ZigClangQualType ZigClangType_getPointeeType(const struct ZigClangType *self); ZIG_EXTERN_C bool ZigClangType_isVoidType(const struct ZigClangType *self); ZIG_EXTERN_C const char *ZigClangType_getTypeClassName(const struct ZigClangType *self); -- cgit v1.2.3 From b4f8d68e2e48a27ff2a6eea6155873cdbfc8ad38 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Tue, 30 Apr 2019 03:14:45 -0400 Subject: translate-c: fix using wrong enum closes #2385 --- src/zig_clang.cpp | 148 +++++++++++++++++++++++++++--------------------------- 1 file changed, 74 insertions(+), 74 deletions(-) (limited to 'src/zig_clang.cpp') diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp index 901f702275..17ee800059 100644 --- a/src/zig_clang.cpp +++ b/src/zig_clang.cpp @@ -801,80 +801,80 @@ static_assert((clang::APValue::ValueKind)ZigClangAPValueAddrLabelDiff == clang:: void ZigClang_detect_enum_DeclKind(clang::Decl::Kind x) { switch (x) { - case ZigClangDeclAccessSpec: - case ZigClangDeclBlock: - case ZigClangDeclCaptured: - case ZigClangDeclClassScopeFunctionSpecialization: - case ZigClangDeclEmpty: - case ZigClangDeclExport: - case ZigClangDeclExternCContext: - case ZigClangDeclFileScopeAsm: - case ZigClangDeclFriend: - case ZigClangDeclFriendTemplate: - case ZigClangDeclImport: - case ZigClangDeclLinkageSpec: - case ZigClangDeclLabel: - case ZigClangDeclNamespace: - case ZigClangDeclNamespaceAlias: - case ZigClangDeclObjCCompatibleAlias: - case ZigClangDeclObjCCategory: - case ZigClangDeclObjCCategoryImpl: - case ZigClangDeclObjCImplementation: - case ZigClangDeclObjCInterface: - case ZigClangDeclObjCProtocol: - case ZigClangDeclObjCMethod: - case ZigClangDeclObjCProperty: - case ZigClangDeclBuiltinTemplate: - case ZigClangDeclClassTemplate: - case ZigClangDeclFunctionTemplate: - case ZigClangDeclTypeAliasTemplate: - case ZigClangDeclVarTemplate: - case ZigClangDeclTemplateTemplateParm: - case ZigClangDeclEnum: - case ZigClangDeclRecord: - case ZigClangDeclCXXRecord: - case ZigClangDeclClassTemplateSpecialization: - case ZigClangDeclClassTemplatePartialSpecialization: - case ZigClangDeclTemplateTypeParm: - case ZigClangDeclObjCTypeParam: - case ZigClangDeclTypeAlias: - case ZigClangDeclTypedef: - case ZigClangDeclUnresolvedUsingTypename: - case ZigClangDeclUsing: - case ZigClangDeclUsingDirective: - case ZigClangDeclUsingPack: - case ZigClangDeclUsingShadow: - case ZigClangDeclConstructorUsingShadow: - case ZigClangDeclBinding: - case ZigClangDeclField: - case ZigClangDeclObjCAtDefsField: - case ZigClangDeclObjCIvar: - case ZigClangDeclFunction: - case ZigClangDeclCXXDeductionGuide: - case ZigClangDeclCXXMethod: - case ZigClangDeclCXXConstructor: - case ZigClangDeclCXXConversion: - case ZigClangDeclCXXDestructor: - case ZigClangDeclMSProperty: - case ZigClangDeclNonTypeTemplateParm: - case ZigClangDeclVar: - case ZigClangDeclDecomposition: - case ZigClangDeclImplicitParam: - case ZigClangDeclOMPCapturedExpr: - case ZigClangDeclParmVar: - case ZigClangDeclVarTemplateSpecialization: - case ZigClangDeclVarTemplatePartialSpecialization: - case ZigClangDeclEnumConstant: - case ZigClangDeclIndirectField: - case ZigClangDeclOMPDeclareReduction: - case ZigClangDeclUnresolvedUsingValue: - case ZigClangDeclOMPRequires: - case ZigClangDeclOMPThreadPrivate: - case ZigClangDeclObjCPropertyImpl: - case ZigClangDeclPragmaComment: - case ZigClangDeclPragmaDetectMismatch: - case ZigClangDeclStaticAssert: - case ZigClangDeclTranslationUnit: + case clang::Decl::AccessSpec: + case clang::Decl::Block: + case clang::Decl::Captured: + case clang::Decl::ClassScopeFunctionSpecialization: + case clang::Decl::Empty: + case clang::Decl::Export: + case clang::Decl::ExternCContext: + case clang::Decl::FileScopeAsm: + case clang::Decl::Friend: + case clang::Decl::FriendTemplate: + case clang::Decl::Import: + case clang::Decl::LinkageSpec: + case clang::Decl::Label: + case clang::Decl::Namespace: + case clang::Decl::NamespaceAlias: + case clang::Decl::ObjCCompatibleAlias: + case clang::Decl::ObjCCategory: + case clang::Decl::ObjCCategoryImpl: + case clang::Decl::ObjCImplementation: + case clang::Decl::ObjCInterface: + case clang::Decl::ObjCProtocol: + case clang::Decl::ObjCMethod: + case clang::Decl::ObjCProperty: + case clang::Decl::BuiltinTemplate: + case clang::Decl::ClassTemplate: + case clang::Decl::FunctionTemplate: + case clang::Decl::TypeAliasTemplate: + case clang::Decl::VarTemplate: + case clang::Decl::TemplateTemplateParm: + case clang::Decl::Enum: + case clang::Decl::Record: + case clang::Decl::CXXRecord: + case clang::Decl::ClassTemplateSpecialization: + case clang::Decl::ClassTemplatePartialSpecialization: + case clang::Decl::TemplateTypeParm: + case clang::Decl::ObjCTypeParam: + case clang::Decl::TypeAlias: + case clang::Decl::Typedef: + case clang::Decl::UnresolvedUsingTypename: + case clang::Decl::Using: + case clang::Decl::UsingDirective: + case clang::Decl::UsingPack: + case clang::Decl::UsingShadow: + case clang::Decl::ConstructorUsingShadow: + case clang::Decl::Binding: + case clang::Decl::Field: + case clang::Decl::ObjCAtDefsField: + case clang::Decl::ObjCIvar: + case clang::Decl::Function: + case clang::Decl::CXXDeductionGuide: + case clang::Decl::CXXMethod: + case clang::Decl::CXXConstructor: + case clang::Decl::CXXConversion: + case clang::Decl::CXXDestructor: + case clang::Decl::MSProperty: + case clang::Decl::NonTypeTemplateParm: + case clang::Decl::Var: + case clang::Decl::Decomposition: + case clang::Decl::ImplicitParam: + case clang::Decl::OMPCapturedExpr: + case clang::Decl::ParmVar: + case clang::Decl::VarTemplateSpecialization: + case clang::Decl::VarTemplatePartialSpecialization: + case clang::Decl::EnumConstant: + case clang::Decl::IndirectField: + case clang::Decl::OMPDeclareReduction: + case clang::Decl::UnresolvedUsingValue: + case clang::Decl::OMPRequires: + case clang::Decl::OMPThreadPrivate: + case clang::Decl::ObjCPropertyImpl: + case clang::Decl::PragmaComment: + case clang::Decl::PragmaDetectMismatch: + case clang::Decl::StaticAssert: + case clang::Decl::TranslationUnit: break; } } -- cgit v1.2.3 From 46e1c34fcfe0973735c75a0c210db314030798f0 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Wed, 8 May 2019 22:04:51 -0400 Subject: self-hosted translate-c progress on function decls See #1964 --- src-self-hosted/clang.zig | 23 +++++++++++---- src-self-hosted/stage1.zig | 3 +- src-self-hosted/translate_c.zig | 62 +++++++++++++++++++++++++++++++++++------ src/translate_c.cpp | 28 ++++++++++--------- src/zig_clang.cpp | 10 +++++++ src/zig_clang.h | 3 ++ 6 files changed, 102 insertions(+), 27 deletions(-) (limited to 'src/zig_clang.cpp') diff --git a/src-self-hosted/clang.zig b/src-self-hosted/clang.zig index 62310e8bea..546c2fe527 100644 --- a/src-self-hosted/clang.zig +++ b/src-self-hosted/clang.zig @@ -806,13 +806,13 @@ pub const enum_ZigClangAPValueKind = extern enum { ZigClangAPValueAddrLabelDiff, }; pub extern fn ZigClangSourceManager_getSpellingLoc(arg0: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) struct_ZigClangSourceLocation; -pub extern fn ZigClangSourceManager_getFilename(arg0: ?*const struct_ZigClangSourceManager, SpellingLoc: struct_ZigClangSourceLocation) [*c]const u8; +pub extern fn ZigClangSourceManager_getFilename(self: *const struct_ZigClangSourceManager, SpellingLoc: struct_ZigClangSourceLocation) ?[*]const u8; pub extern fn ZigClangSourceManager_getSpellingLineNumber(arg0: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) c_uint; pub extern fn ZigClangSourceManager_getSpellingColumnNumber(arg0: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) c_uint; pub extern fn ZigClangSourceManager_getCharacterData(arg0: ?*const struct_ZigClangSourceManager, SL: struct_ZigClangSourceLocation) [*c]const u8; pub extern fn ZigClangASTContext_getPointerType(arg0: ?*const struct_ZigClangASTContext, T: struct_ZigClangQualType) struct_ZigClangQualType; pub extern fn ZigClangASTUnit_getASTContext(arg0: ?*struct_ZigClangASTUnit) ?*struct_ZigClangASTContext; -pub extern fn ZigClangASTUnit_getSourceManager(arg0: ?*struct_ZigClangASTUnit) ?*struct_ZigClangSourceManager; +pub extern fn ZigClangASTUnit_getSourceManager(self: *struct_ZigClangASTUnit) *struct_ZigClangSourceManager; pub extern fn ZigClangASTUnit_visitLocalTopLevelDecls(self: *struct_ZigClangASTUnit, context: ?*c_void, Fn: ?extern fn (?*c_void, *const struct_ZigClangDecl) bool) bool; pub extern fn ZigClangRecordType_getDecl(record_ty: ?*const struct_ZigClangRecordType) ?*const struct_ZigClangRecordDecl; pub extern fn ZigClangEnumType_getDecl(record_ty: ?*const struct_ZigClangEnumType) ?*const struct_ZigClangEnumDecl; @@ -824,6 +824,7 @@ pub extern fn ZigClangEnumDecl_getDefinition(arg0: ?*const struct_ZigClangEnumDe pub extern fn ZigClangRecordDecl_getLocation(arg0: ?*const struct_ZigClangRecordDecl) struct_ZigClangSourceLocation; pub extern fn ZigClangEnumDecl_getLocation(arg0: ?*const struct_ZigClangEnumDecl) struct_ZigClangSourceLocation; pub extern fn ZigClangTypedefNameDecl_getLocation(arg0: ?*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; @@ -833,7 +834,7 @@ pub extern fn ZigClangSourceLocation_eq(a: struct_ZigClangSourceLocation, b: str pub extern fn ZigClangTypedefType_getDecl(arg0: ?*const struct_ZigClangTypedefType) ?*const struct_ZigClangTypedefNameDecl; pub extern fn ZigClangTypedefNameDecl_getUnderlyingType(arg0: ?*const struct_ZigClangTypedefNameDecl) struct_ZigClangQualType; pub extern fn ZigClangQualType_getCanonicalType(arg0: struct_ZigClangQualType) struct_ZigClangQualType; -pub extern fn ZigClangQualType_getTypePtr(arg0: struct_ZigClangQualType) ?*const struct_ZigClangType; +pub extern fn ZigClangQualType_getTypePtr(self: struct_ZigClangQualType) *const struct_ZigClangType; pub extern fn ZigClangQualType_addConst(arg0: [*c]struct_ZigClangQualType) void; pub extern fn ZigClangQualType_eq(arg0: struct_ZigClangQualType, arg1: struct_ZigClangQualType) bool; pub extern fn ZigClangQualType_isConstQualified(arg0: struct_ZigClangQualType) bool; @@ -841,7 +842,7 @@ pub extern fn ZigClangQualType_isVolatileQualified(arg0: struct_ZigClangQualType pub extern fn ZigClangQualType_isRestrictQualified(arg0: struct_ZigClangQualType) bool; pub extern fn ZigClangType_getTypeClass(self: ?*const struct_ZigClangType) enum_ZigClangTypeClass; pub extern fn ZigClangType_isVoidType(self: ?*const struct_ZigClangType) bool; -pub extern fn ZigClangType_getTypeClassName(self: ?*const struct_ZigClangType) [*c]const u8; +pub extern fn ZigClangType_getTypeClassName(self: *const struct_ZigClangType) [*]const u8; pub extern fn ZigClangStmt_getBeginLoc(self: ?*const struct_ZigClangStmt) struct_ZigClangSourceLocation; pub extern fn ZigClangStmt_getStmtClass(self: ?*const struct_ZigClangStmt) enum_ZigClangStmtClass; pub extern fn ZigClangStmt_classof_Expr(self: ?*const struct_ZigClangStmt) bool; @@ -863,6 +864,10 @@ pub extern fn ZigClangAPSInt_getRawData(self: ?*const struct_ZigClangAPSInt) [*c pub extern fn ZigClangAPSInt_getNumWords(self: ?*const struct_ZigClangAPSInt) c_uint; pub extern fn ZigClangAPValueLValueBase_dyn_cast_Expr(self: struct_ZigClangAPValueLValueBase) ?*const struct_ZigClangExpr; pub extern fn ZigClangASTUnit_delete(arg0: ?*struct_ZigClangASTUnit) void; + +pub extern fn ZigClangFunctionDecl_getType(self: *const struct_ZigClangFunctionDecl) struct_ZigClangQualType; +pub extern fn ZigClangFunctionDecl_getLocation(self: *const struct_ZigClangFunctionDecl) struct_ZigClangSourceLocation; + pub const ZigClangSourceLocation = struct_ZigClangSourceLocation; pub const ZigClangQualType = struct_ZigClangQualType; pub const ZigClangAPValueLValueBase = struct_ZigClangAPValueLValueBase; @@ -944,6 +949,10 @@ pub const ZigClangStmtClass = enum_ZigClangStmtClass; pub const ZigClangCK = enum_ZigClangCK; pub const ZigClangAPValueKind = enum_ZigClangAPValueKind; +pub const struct_ZigClangSourceLocation = extern struct { + ID: c_uint, +}; + pub const Stage2ErrorMsg = extern struct { filename_ptr: ?[*]const u8, filename_len: usize, @@ -968,8 +977,8 @@ pub extern fn ZigClangLoadFromCommandLine( resources_path: [*c]const u8, ) ?*ZigClangASTUnit; - pub extern fn ZigClangDecl_getKind(decl: *const ZigClangDecl) ZigClangDeclKind; +pub extern fn ZigClangDecl_getDeclKindName(decl: *const struct_ZigClangDecl) [*]const u8; pub const ZigClangDeclKind = extern enum { AccessSpec, @@ -1047,3 +1056,7 @@ pub const ZigClangDeclKind = extern enum { StaticAssert, TranslationUnit, }; + +pub const struct_ZigClangQualType = extern struct { + ptr: ?*c_void, +}; diff --git a/src-self-hosted/stage1.zig b/src-self-hosted/stage1.zig index 7a44e8f3a0..da2dcb414c 100644 --- a/src-self-hosted/stage1.zig +++ b/src-self-hosted/stage1.zig @@ -90,7 +90,8 @@ export fn stage2_translate_c( .import => translate_c.Mode.import, .translate => translate_c.Mode.translate, }, &errors, resources_path) catch |err| switch (err) { - error.SemanticAnalyzeFail => { + // TODO after https://github.com/ziglang/zig/issues/769 we can remove error.UnsupportedType + error.SemanticAnalyzeFail, error.UnsupportedType => { out_errors_ptr.* = errors.ptr; out_errors_len.* = errors.len; return Error.CCompileErrors; diff --git a/src-self-hosted/translate_c.zig b/src-self-hosted/translate_c.zig index ddf7c6f21d..7b349764fb 100644 --- a/src-self-hosted/translate_c.zig +++ b/src-self-hosted/translate_c.zig @@ -13,12 +13,16 @@ pub const Mode = enum { pub const ClangErrMsg = Stage2ErrorMsg; -pub const Error = error{OutOfMemory}; +pub const Error = error{ + OutOfMemory, + UnsupportedType, +}; const Context = struct { tree: *ast.Tree, source_buffer: *std.Buffer, err: Error, + source_manager: *ZigClangSourceManager, fn a(c: *Context) *std.mem.Allocator { return &c.tree.arena_allocator.allocator; @@ -28,6 +32,17 @@ const Context = struct { fn str(c: *Context, s: [*]const u8) ![]u8 { return std.mem.dupe(c.a(), u8, std.mem.toSliceConst(u8, s)); } + + /// 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); + const filename = if (filename_c) |s| try c.str(s) else ([]const u8)("(no file)"); + + const line = ZigClangSourceManager_getSpellingLineNumber(c.source_manager, spelling_loc); + const column = ZigClangSourceManager_getSpellingColumnNumber(c.source_manager, spelling_loc); + return std.fmt.allocPrint(c.a(), "{}:{}:{}", filename, line, column); + } }; pub fn translate( @@ -78,6 +93,7 @@ pub fn translate( var context = Context{ .tree = tree, .source_buffer = &source_buffer, + .source_manager = ZigClangASTUnit_getSourceManager(ast_unit), .err = undefined, }; @@ -105,27 +121,57 @@ fn declVisitor(c: *Context, decl: *const ZigClangDecl) Error!void { return visitFnDecl(c, @ptrCast(*const ZigClangFunctionDecl, decl)); }, .Typedef => { - try appendToken(c, .LineComment, "// TODO translate typedef"); + try emitWarning(c, ZigClangDecl_getLocation(decl), "TODO implement translate-c for typedefs"); }, .Enum => { - try appendToken(c, .LineComment, "// TODO translate enum"); + try emitWarning(c, ZigClangDecl_getLocation(decl), "TODO implement translate-c for enums"); }, .Record => { - try appendToken(c, .LineComment, "// TODO translate struct"); + try emitWarning(c, ZigClangDecl_getLocation(decl), "TODO implement translate-c for structs"); }, .Var => { - try appendToken(c, .LineComment, "// TODO translate variable"); + try emitWarning(c, ZigClangDecl_getLocation(decl), "TODO implement translate-c for variables"); }, else => { - // TODO emit_warning(c, bitcast(decl->getLocation()), "ignoring %s decl", decl->getDeclKindName()); - try appendToken(c, .LineComment, "// TODO translate unknown decl"); + const decl_name = try c.str(ZigClangDecl_getDeclKindName(decl)); + try emitWarning(c, ZigClangDecl_getLocation(decl), "ignoring {} declaration", decl_name); }, } } fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { const fn_name = c.str(ZigClangDecl_getName_bytes_begin(@ptrCast(*const ZigClangDecl, fn_decl))); - try appendToken(c, .LineComment, "// TODO translate function '{}'", fn_name); + + // TODO The C++ code has this: + //if (get_global(c, fn_name)) { + // // we already saw this function + // return; + //} + + const fn_decl_loc = ZigClangFunctionDecl_getLocation(fn_decl); + const proto_node = transQualType(c, ZigClangFunctionDecl_getType(fn_decl), fn_decl_loc) catch |e| switch (e) { + error.UnsupportedType => { + try emitWarning(c, fn_decl_loc, "unable to resolve prototype of function '{}'", fn_name); + return; + }, + else => return e, + }; + + try emitWarning(c, fn_decl_loc, "TODO implement translate-c for function decls"); +} + +fn transQualType(c: *Context, qt: ZigClangQualType, source_loc: ZigClangSourceLocation) !*ast.Node { + return transType(c, ZigClangQualType_getTypePtr(qt), source_loc); +} + +fn transType(c: *Context, ty: *const ZigClangType, source_loc: ZigClangSourceLocation) !*ast.Node { + const type_name = c.str(ZigClangType_getTypeClassName(ty)); + try emitWarning(c, source_loc, "unsupported type: '{}'", type_name); + return error.UnsupportedType; +} + +fn emitWarning(c: *Context, loc: ZigClangSourceLocation, comptime format: []const u8, args: ...) !void { + try appendToken(c, .LineComment, "// {}: warning: " ++ format, c.locStr(loc), args); } fn appendToken(c: *Context, token_id: Token.Id, comptime format: []const u8, args: ...) !void { diff --git a/src/translate_c.cpp b/src/translate_c.cpp index eefdf7e260..706d296fc0 100644 --- a/src/translate_c.cpp +++ b/src/translate_c.cpp @@ -4009,7 +4009,7 @@ static TransScope *trans_stmt(Context *c, TransScope *scope, const ZigClangStmt return child_scope; } -static void visit_fn_decl(Context *c, const clang::FunctionDecl *fn_decl) { +static void visit_fn_decl(Context *c, const ZigClangFunctionDecl *fn_decl) { Buf *fn_name = buf_create_from_str(ZigClangDecl_getName_bytes_begin((const ZigClangDecl *)fn_decl)); if (get_global(c, fn_name)) { @@ -4017,26 +4017,28 @@ static void visit_fn_decl(Context *c, const clang::FunctionDecl *fn_decl) { return; } - AstNode *proto_node = trans_qual_type(c, bitcast(fn_decl->getType()), bitcast(fn_decl->getLocation())); + AstNode *proto_node = trans_qual_type(c, ZigClangFunctionDecl_getType(fn_decl), + ZigClangFunctionDecl_getLocation(fn_decl)); if (proto_node == nullptr) { - emit_warning(c, bitcast(fn_decl->getLocation()), "unable to resolve prototype of function '%s'", buf_ptr(fn_name)); + emit_warning(c, ZigClangFunctionDecl_getLocation(fn_decl), + "unable to resolve prototype of function '%s'", buf_ptr(fn_name)); return; } proto_node->data.fn_proto.name = fn_name; - proto_node->data.fn_proto.is_extern = !fn_decl->hasBody(); + proto_node->data.fn_proto.is_extern = !((const clang::FunctionDecl*)fn_decl)->hasBody(); - clang::StorageClass sc = fn_decl->getStorageClass(); + clang::StorageClass sc = ((const clang::FunctionDecl*)fn_decl)->getStorageClass(); if (sc == clang::SC_None) { proto_node->data.fn_proto.visib_mod = c->visib_mod; - proto_node->data.fn_proto.is_export = fn_decl->hasBody() ? c->want_export : false; + proto_node->data.fn_proto.is_export = ((const clang::FunctionDecl*)fn_decl)->hasBody() ? c->want_export : false; } else if (sc == clang::SC_Extern || sc == clang::SC_Static) { proto_node->data.fn_proto.visib_mod = c->visib_mod; } else if (sc == clang::SC_PrivateExtern) { - emit_warning(c, bitcast(fn_decl->getLocation()), "unsupported storage class: private extern"); + emit_warning(c, ZigClangFunctionDecl_getLocation(fn_decl), "unsupported storage class: private extern"); return; } else { - emit_warning(c, bitcast(fn_decl->getLocation()), "unsupported storage class: unknown"); + emit_warning(c, ZigClangFunctionDecl_getLocation(fn_decl), "unsupported storage class: unknown"); return; } @@ -4044,7 +4046,7 @@ static void visit_fn_decl(Context *c, const clang::FunctionDecl *fn_decl) { for (size_t i = 0; i < proto_node->data.fn_proto.params.length; i += 1) { AstNode *param_node = proto_node->data.fn_proto.params.at(i); - const clang::ParmVarDecl *param = fn_decl->getParamDecl(i); + const clang::ParmVarDecl *param = ((const clang::FunctionDecl*)fn_decl)->getParamDecl(i); const char *name = ZigClangDecl_getName_bytes_begin((const ZigClangDecl *)param); Buf *proto_param_name; @@ -4063,7 +4065,7 @@ static void visit_fn_decl(Context *c, const clang::FunctionDecl *fn_decl) { param_node->data.param_decl.name = scope_var->zig_name; } - if (!fn_decl->hasBody()) { + if (!((const clang::FunctionDecl*)fn_decl)->hasBody()) { // just a prototype add_top_level_decl(c, proto_node->data.fn_proto.name, proto_node); return; @@ -4071,11 +4073,11 @@ static void visit_fn_decl(Context *c, const clang::FunctionDecl *fn_decl) { // actual function definition with body c->ptr_params.clear(); - const ZigClangStmt *body = bitcast(fn_decl->getBody()); + const ZigClangStmt *body = bitcast(((const clang::FunctionDecl*)fn_decl)->getBody()); AstNode *actual_body_node; TransScope *result_scope = trans_stmt(c, scope, body, &actual_body_node); if (result_scope == nullptr) { - emit_warning(c, bitcast(fn_decl->getLocation()), "unable to translate function"); + emit_warning(c, ZigClangFunctionDecl_getLocation(fn_decl), "unable to translate function"); return; } assert(actual_body_node != nullptr); @@ -4558,7 +4560,7 @@ static bool decl_visitor(void *context, const ZigClangDecl *decl) { switch (ZigClangDecl_getKind(decl)) { case ZigClangDeclFunction: - visit_fn_decl(c, reinterpret_cast(decl)); + visit_fn_decl(c, reinterpret_cast(decl)); break; case ZigClangDeclTypedef: resolve_typedef_decl(c, reinterpret_cast(decl)); diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp index 17ee800059..a96ec3aa46 100644 --- a/src/zig_clang.cpp +++ b/src/zig_clang.cpp @@ -1142,6 +1142,16 @@ ZigClangQualType ZigClangEnumDecl_getIntegerType(const ZigClangEnumDecl *self) { return bitcast(reinterpret_cast(self)->getIntegerType()); } +struct ZigClangQualType ZigClangFunctionDecl_getType(const struct ZigClangFunctionDecl *self) { + auto casted = reinterpret_cast(self); + return bitcast(casted->getType()); +} + +struct ZigClangSourceLocation ZigClangFunctionDecl_getLocation(const struct ZigClangFunctionDecl *self) { + auto casted = reinterpret_cast(self); + return bitcast(casted->getLocation()); +} + const ZigClangTypedefNameDecl *ZigClangTypedefType_getDecl(const ZigClangTypedefType *self) { auto casted = reinterpret_cast(self); const clang::TypedefNameDecl *name_decl = casted->getDecl(); diff --git a/src/zig_clang.h b/src/zig_clang.h index 777ad8c34b..46074fc840 100644 --- a/src/zig_clang.h +++ b/src/zig_clang.h @@ -599,6 +599,9 @@ ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangEnumDecl_getLocation(const st ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangTypedefNameDecl_getLocation(const struct ZigClangTypedefNameDecl *); ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangDecl_getLocation(const struct ZigClangDecl *); +ZIG_EXTERN_C struct ZigClangQualType ZigClangFunctionDecl_getType(const struct ZigClangFunctionDecl *); +ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangFunctionDecl_getLocation(const struct ZigClangFunctionDecl *); + ZIG_EXTERN_C bool ZigClangRecordDecl_isUnion(const struct ZigClangRecordDecl *record_decl); ZIG_EXTERN_C bool ZigClangRecordDecl_isStruct(const struct ZigClangRecordDecl *record_decl); ZIG_EXTERN_C bool ZigClangRecordDecl_isAnonymousStructOrUnion(const struct ZigClangRecordDecl *record_decl); -- cgit v1.2.3 From 214625587c66f07f2dd54670258143637058f490 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 9 May 2019 15:46:48 -0400 Subject: translate-c: use C API for builtin types See #1964 --- src/translate_c.cpp | 590 +++++++++++++++++++++++++--------------------------- src/zig_clang.cpp | 244 ++++++++++++++++++++++ src/zig_clang.h | 121 +++++++++++ 3 files changed, 647 insertions(+), 308 deletions(-) (limited to 'src/zig_clang.cpp') diff --git a/src/translate_c.cpp b/src/translate_c.cpp index b7744afce3..4b6609027c 100644 --- a/src/translate_c.cpp +++ b/src/translate_c.cpp @@ -127,6 +127,7 @@ static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope * const ZigClangExpr *expr, TransLRValue lrval); static AstNode *trans_ap_value(Context *c, const ZigClangAPValue *ap_value, ZigClangQualType qt, ZigClangSourceLocation source_loc); +static bool c_is_unsigned_integer(Context *c, ZigClangQualType qt); static const ZigClangAPSInt *bitcast(const llvm::APSInt *src) { return reinterpret_cast(src); @@ -581,33 +582,6 @@ static bool qual_type_is_ptr(ZigClangQualType qt) { return ZigClangType_getTypeClass(ty) == ZigClangType_Pointer; } -static bool qual_type_is_int(ZigClangQualType qt) { - const ZigClangType *ty = qual_type_canon(qt); - if (ZigClangType_getTypeClass(ty) != ZigClangType_Builtin) - return false; - const clang::BuiltinType *builtin_ty = reinterpret_cast(ty); - switch (builtin_ty->getKind()) { - case clang::BuiltinType::Char_U: - case clang::BuiltinType::UChar: - case clang::BuiltinType::Char_S: - case clang::BuiltinType::Char8: - case clang::BuiltinType::SChar: - case clang::BuiltinType::UShort: - case clang::BuiltinType::UInt: - case clang::BuiltinType::ULong: - case clang::BuiltinType::ULongLong: - case clang::BuiltinType::Short: - case clang::BuiltinType::Int: - case clang::BuiltinType::Long: - case clang::BuiltinType::LongLong: - case clang::BuiltinType::UInt128: - case clang::BuiltinType::Int128: - return true; - default: - return false; - } -} - static const clang::FunctionProtoType *qual_type_get_fn_proto(ZigClangQualType qt, bool *is_ptr) { const ZigClangType *ty = qual_type_canon(qt); *is_ptr = false; @@ -639,15 +613,15 @@ static uint32_t qual_type_int_bit_width(Context *c, const ZigClangQualType qt, Z switch (ZigClangType_getTypeClass(ty)) { case ZigClangType_Builtin: { - const clang::BuiltinType *builtin_ty = reinterpret_cast(ty); - switch (builtin_ty->getKind()) { - case clang::BuiltinType::Char_U: - case clang::BuiltinType::UChar: - case clang::BuiltinType::Char_S: - case clang::BuiltinType::SChar: + const ZigClangBuiltinType *builtin_ty = reinterpret_cast(ty); + switch (ZigClangBuiltinType_getKind(builtin_ty)) { + case ZigClangBuiltinTypeChar_U: + case ZigClangBuiltinTypeUChar: + case ZigClangBuiltinTypeChar_S: + case ZigClangBuiltinTypeSChar: return 8; - case clang::BuiltinType::UInt128: - case clang::BuiltinType::Int128: + case ZigClangBuiltinTypeUInt128: + case ZigClangBuiltinTypeInt128: return 128; default: return 0; @@ -771,12 +745,12 @@ static AstNode* trans_c_cast(Context *c, ZigClangSourceLocation source_location, if (qual_type_is_ptr(dest_type) && qual_type_is_ptr(src_type)) { return trans_c_ptr_cast(c, source_location, dest_type, src_type, expr); } - if (qual_type_is_int(dest_type) && qual_type_is_ptr(src_type)) { + if (c_is_unsigned_integer(c, dest_type) && qual_type_is_ptr(src_type)) { AstNode *addr_node = trans_create_node_builtin_fn_call_str(c, "ptrToInt"); addr_node->data.fn_call_expr.params.append(expr); return trans_create_node_fn_call_1(c, trans_qual_type(c, dest_type, source_location), addr_node); } - if (qual_type_is_int(src_type) && qual_type_is_ptr(dest_type)) { + if (c_is_unsigned_integer(c, src_type) && qual_type_is_ptr(dest_type)) { AstNode *ptr_node = trans_create_node_builtin_fn_call_str(c, "intToPtr"); ptr_node->data.fn_call_expr.params.append(trans_qual_type(c, dest_type, source_location)); ptr_node->data.fn_call_expr.params.append(expr); @@ -792,15 +766,15 @@ static bool c_is_signed_integer(Context *c, ZigClangQualType qt) { const ZigClangType *c_type = qual_type_canon(qt); if (ZigClangType_getTypeClass(c_type) != ZigClangType_Builtin) return false; - const clang::BuiltinType *builtin_ty = reinterpret_cast(c_type); - switch (builtin_ty->getKind()) { - case clang::BuiltinType::SChar: - case clang::BuiltinType::Short: - case clang::BuiltinType::Int: - case clang::BuiltinType::Long: - case clang::BuiltinType::LongLong: - case clang::BuiltinType::Int128: - case clang::BuiltinType::WChar_S: + const ZigClangBuiltinType *builtin_ty = reinterpret_cast(c_type); + switch (ZigClangBuiltinType_getKind(builtin_ty)) { + case ZigClangBuiltinTypeSChar: + case ZigClangBuiltinTypeShort: + case ZigClangBuiltinTypeInt: + case ZigClangBuiltinTypeLong: + case ZigClangBuiltinTypeLongLong: + case ZigClangBuiltinTypeInt128: + case ZigClangBuiltinTypeWChar_S: return true; default: return false; @@ -811,42 +785,42 @@ static bool c_is_unsigned_integer(Context *c, ZigClangQualType qt) { const ZigClangType *c_type = qual_type_canon(qt); if (ZigClangType_getTypeClass(c_type) != ZigClangType_Builtin) return false; - const clang::BuiltinType *builtin_ty = reinterpret_cast(c_type); - switch (builtin_ty->getKind()) { - case clang::BuiltinType::Char_U: - case clang::BuiltinType::UChar: - case clang::BuiltinType::Char_S: - case clang::BuiltinType::UShort: - case clang::BuiltinType::UInt: - case clang::BuiltinType::ULong: - case clang::BuiltinType::ULongLong: - case clang::BuiltinType::UInt128: - case clang::BuiltinType::WChar_U: + const ZigClangBuiltinType *builtin_ty = reinterpret_cast(c_type); + switch (ZigClangBuiltinType_getKind(builtin_ty)) { + case ZigClangBuiltinTypeChar_U: + case ZigClangBuiltinTypeUChar: + case ZigClangBuiltinTypeChar_S: + case ZigClangBuiltinTypeUShort: + case ZigClangBuiltinTypeUInt: + case ZigClangBuiltinTypeULong: + case ZigClangBuiltinTypeULongLong: + case ZigClangBuiltinTypeUInt128: + case ZigClangBuiltinTypeWChar_U: return true; default: return false; } } -static bool c_is_builtin_type(Context *c, ZigClangQualType qt, clang::BuiltinType::Kind kind) { +static bool c_is_builtin_type(Context *c, ZigClangQualType qt, ZigClangBuiltinTypeKind kind) { const ZigClangType *c_type = qual_type_canon(qt); if (ZigClangType_getTypeClass(c_type) != ZigClangType_Builtin) return false; - const clang::BuiltinType *builtin_ty = reinterpret_cast(c_type); - return builtin_ty->getKind() == kind; + const ZigClangBuiltinType *builtin_ty = reinterpret_cast(c_type); + return ZigClangBuiltinType_getKind(builtin_ty) == kind; } static bool c_is_float(Context *c, ZigClangQualType qt) { const ZigClangType *c_type = ZigClangQualType_getTypePtr(qt); if (ZigClangType_getTypeClass(c_type) != ZigClangType_Builtin) return false; - const clang::BuiltinType *builtin_ty = reinterpret_cast(c_type); - switch (builtin_ty->getKind()) { - case clang::BuiltinType::Half: - case clang::BuiltinType::Float: - case clang::BuiltinType::Double: - case clang::BuiltinType::Float128: - case clang::BuiltinType::LongDouble: + const ZigClangBuiltinType *builtin_ty = reinterpret_cast(c_type); + switch (ZigClangBuiltinType_getKind(builtin_ty)) { + case ZigClangBuiltinTypeHalf: + case ZigClangBuiltinTypeFloat: + case ZigClangBuiltinTypeDouble: + case ZigClangBuiltinTypeFloat128: + case ZigClangBuiltinTypeLongDouble: return true; default: return false; @@ -866,8 +840,8 @@ static bool qual_type_has_wrapping_overflow(Context *c, ZigClangQualType qt) { static bool type_is_opaque(Context *c, const ZigClangType *ty, ZigClangSourceLocation source_loc) { switch (ZigClangType_getTypeClass(ty)) { case ZigClangType_Builtin: { - const clang::BuiltinType *builtin_ty = reinterpret_cast(ty); - return builtin_ty->getKind() == clang::BuiltinType::Void; + const ZigClangBuiltinType *builtin_ty = reinterpret_cast(ty); + return ZigClangBuiltinType_getKind(builtin_ty) == ZigClangBuiltinTypeVoid; } case ZigClangType_Record: { const clang::RecordType *record_ty = reinterpret_cast(ty); @@ -893,144 +867,144 @@ static AstNode *trans_type(Context *c, const ZigClangType *ty, ZigClangSourceLoc switch (ZigClangType_getTypeClass(ty)) { case ZigClangType_Builtin: { - const clang::BuiltinType *builtin_ty = reinterpret_cast(ty); - switch (builtin_ty->getKind()) { - case clang::BuiltinType::Void: + const ZigClangBuiltinType *builtin_ty = reinterpret_cast(ty); + switch (ZigClangBuiltinType_getKind(builtin_ty)) { + case ZigClangBuiltinTypeVoid: return trans_create_node_symbol_str(c, "c_void"); - case clang::BuiltinType::Bool: + case ZigClangBuiltinTypeBool: return trans_create_node_symbol_str(c, "bool"); - case clang::BuiltinType::Char_U: - case clang::BuiltinType::UChar: - case clang::BuiltinType::Char_S: - case clang::BuiltinType::Char8: + case ZigClangBuiltinTypeChar_U: + case ZigClangBuiltinTypeUChar: + case ZigClangBuiltinTypeChar_S: + case ZigClangBuiltinTypeChar8: return trans_create_node_symbol_str(c, "u8"); - case clang::BuiltinType::SChar: + case ZigClangBuiltinTypeSChar: return trans_create_node_symbol_str(c, "i8"); - case clang::BuiltinType::UShort: + case ZigClangBuiltinTypeUShort: return trans_create_node_symbol_str(c, "c_ushort"); - case clang::BuiltinType::UInt: + case ZigClangBuiltinTypeUInt: return trans_create_node_symbol_str(c, "c_uint"); - case clang::BuiltinType::ULong: + case ZigClangBuiltinTypeULong: return trans_create_node_symbol_str(c, "c_ulong"); - case clang::BuiltinType::ULongLong: + case ZigClangBuiltinTypeULongLong: return trans_create_node_symbol_str(c, "c_ulonglong"); - case clang::BuiltinType::Short: + case ZigClangBuiltinTypeShort: return trans_create_node_symbol_str(c, "c_short"); - case clang::BuiltinType::Int: + case ZigClangBuiltinTypeInt: return trans_create_node_symbol_str(c, "c_int"); - case clang::BuiltinType::Long: + case ZigClangBuiltinTypeLong: return trans_create_node_symbol_str(c, "c_long"); - case clang::BuiltinType::LongLong: + case ZigClangBuiltinTypeLongLong: return trans_create_node_symbol_str(c, "c_longlong"); - case clang::BuiltinType::UInt128: + case ZigClangBuiltinTypeUInt128: return trans_create_node_symbol_str(c, "u128"); - case clang::BuiltinType::Int128: + case ZigClangBuiltinTypeInt128: return trans_create_node_symbol_str(c, "i128"); - case clang::BuiltinType::Float: + case ZigClangBuiltinTypeFloat: return trans_create_node_symbol_str(c, "f32"); - case clang::BuiltinType::Double: + case ZigClangBuiltinTypeDouble: return trans_create_node_symbol_str(c, "f64"); - case clang::BuiltinType::Float128: + case ZigClangBuiltinTypeFloat128: return trans_create_node_symbol_str(c, "f128"); - case clang::BuiltinType::Float16: + case ZigClangBuiltinTypeFloat16: return trans_create_node_symbol_str(c, "f16"); - case clang::BuiltinType::LongDouble: + case ZigClangBuiltinTypeLongDouble: return trans_create_node_symbol_str(c, "c_longdouble"); - case clang::BuiltinType::WChar_U: - case clang::BuiltinType::Char16: - case clang::BuiltinType::Char32: - case clang::BuiltinType::WChar_S: - case clang::BuiltinType::Half: - case clang::BuiltinType::NullPtr: - case clang::BuiltinType::ObjCId: - case clang::BuiltinType::ObjCClass: - case clang::BuiltinType::ObjCSel: - case clang::BuiltinType::OMPArraySection: - case clang::BuiltinType::Dependent: - case clang::BuiltinType::Overload: - case clang::BuiltinType::BoundMember: - case clang::BuiltinType::PseudoObject: - case clang::BuiltinType::UnknownAny: - case clang::BuiltinType::BuiltinFn: - case clang::BuiltinType::ARCUnbridgedCast: - case clang::BuiltinType::ShortAccum: - case clang::BuiltinType::Accum: - case clang::BuiltinType::LongAccum: - case clang::BuiltinType::UShortAccum: - case clang::BuiltinType::UAccum: - case clang::BuiltinType::ULongAccum: - - case clang::BuiltinType::OCLImage1dRO: - case clang::BuiltinType::OCLImage1dArrayRO: - case clang::BuiltinType::OCLImage1dBufferRO: - case clang::BuiltinType::OCLImage2dRO: - case clang::BuiltinType::OCLImage2dArrayRO: - case clang::BuiltinType::OCLImage2dDepthRO: - case clang::BuiltinType::OCLImage2dArrayDepthRO: - case clang::BuiltinType::OCLImage2dMSAARO: - case clang::BuiltinType::OCLImage2dArrayMSAARO: - case clang::BuiltinType::OCLImage2dMSAADepthRO: - case clang::BuiltinType::OCLImage2dArrayMSAADepthRO: - case clang::BuiltinType::OCLImage3dRO: - case clang::BuiltinType::OCLImage1dWO: - case clang::BuiltinType::OCLImage1dArrayWO: - case clang::BuiltinType::OCLImage1dBufferWO: - case clang::BuiltinType::OCLImage2dWO: - case clang::BuiltinType::OCLImage2dArrayWO: - case clang::BuiltinType::OCLImage2dDepthWO: - case clang::BuiltinType::OCLImage2dArrayDepthWO: - case clang::BuiltinType::OCLImage2dMSAAWO: - case clang::BuiltinType::OCLImage2dArrayMSAAWO: - case clang::BuiltinType::OCLImage2dMSAADepthWO: - case clang::BuiltinType::OCLImage2dArrayMSAADepthWO: - case clang::BuiltinType::OCLImage3dWO: - case clang::BuiltinType::OCLImage1dRW: - case clang::BuiltinType::OCLImage1dArrayRW: - case clang::BuiltinType::OCLImage1dBufferRW: - case clang::BuiltinType::OCLImage2dRW: - case clang::BuiltinType::OCLImage2dArrayRW: - case clang::BuiltinType::OCLImage2dDepthRW: - case clang::BuiltinType::OCLImage2dArrayDepthRW: - case clang::BuiltinType::OCLImage2dMSAARW: - case clang::BuiltinType::OCLImage2dArrayMSAARW: - case clang::BuiltinType::OCLImage2dMSAADepthRW: - case clang::BuiltinType::OCLImage2dArrayMSAADepthRW: - case clang::BuiltinType::OCLImage3dRW: - case clang::BuiltinType::OCLSampler: - case clang::BuiltinType::OCLEvent: - case clang::BuiltinType::OCLClkEvent: - case clang::BuiltinType::OCLQueue: - case clang::BuiltinType::OCLReserveID: - case clang::BuiltinType::ShortFract: - case clang::BuiltinType::Fract: - case clang::BuiltinType::LongFract: - case clang::BuiltinType::UShortFract: - case clang::BuiltinType::UFract: - case clang::BuiltinType::ULongFract: - case clang::BuiltinType::SatShortAccum: - case clang::BuiltinType::SatAccum: - case clang::BuiltinType::SatLongAccum: - case clang::BuiltinType::SatUShortAccum: - case clang::BuiltinType::SatUAccum: - case clang::BuiltinType::SatULongAccum: - case clang::BuiltinType::SatShortFract: - case clang::BuiltinType::SatFract: - case clang::BuiltinType::SatLongFract: - case clang::BuiltinType::SatUShortFract: - case clang::BuiltinType::SatUFract: - case clang::BuiltinType::SatULongFract: - case clang::BuiltinType::OCLIntelSubgroupAVCMcePayload: - case clang::BuiltinType::OCLIntelSubgroupAVCImePayload: - case clang::BuiltinType::OCLIntelSubgroupAVCRefPayload: - case clang::BuiltinType::OCLIntelSubgroupAVCSicPayload: - case clang::BuiltinType::OCLIntelSubgroupAVCMceResult: - case clang::BuiltinType::OCLIntelSubgroupAVCImeResult: - case clang::BuiltinType::OCLIntelSubgroupAVCRefResult: - case clang::BuiltinType::OCLIntelSubgroupAVCSicResult: - case clang::BuiltinType::OCLIntelSubgroupAVCImeResultSingleRefStreamout: - case clang::BuiltinType::OCLIntelSubgroupAVCImeResultDualRefStreamout: - case clang::BuiltinType::OCLIntelSubgroupAVCImeSingleRefStreamin: - case clang::BuiltinType::OCLIntelSubgroupAVCImeDualRefStreamin: + case ZigClangBuiltinTypeWChar_U: + case ZigClangBuiltinTypeChar16: + case ZigClangBuiltinTypeChar32: + case ZigClangBuiltinTypeWChar_S: + case ZigClangBuiltinTypeHalf: + case ZigClangBuiltinTypeNullPtr: + case ZigClangBuiltinTypeObjCId: + case ZigClangBuiltinTypeObjCClass: + case ZigClangBuiltinTypeObjCSel: + case ZigClangBuiltinTypeOMPArraySection: + case ZigClangBuiltinTypeDependent: + case ZigClangBuiltinTypeOverload: + case ZigClangBuiltinTypeBoundMember: + case ZigClangBuiltinTypePseudoObject: + case ZigClangBuiltinTypeUnknownAny: + case ZigClangBuiltinTypeBuiltinFn: + case ZigClangBuiltinTypeARCUnbridgedCast: + case ZigClangBuiltinTypeShortAccum: + case ZigClangBuiltinTypeAccum: + case ZigClangBuiltinTypeLongAccum: + case ZigClangBuiltinTypeUShortAccum: + case ZigClangBuiltinTypeUAccum: + case ZigClangBuiltinTypeULongAccum: + + case ZigClangBuiltinTypeOCLImage1dRO: + case ZigClangBuiltinTypeOCLImage1dArrayRO: + case ZigClangBuiltinTypeOCLImage1dBufferRO: + case ZigClangBuiltinTypeOCLImage2dRO: + case ZigClangBuiltinTypeOCLImage2dArrayRO: + case ZigClangBuiltinTypeOCLImage2dDepthRO: + case ZigClangBuiltinTypeOCLImage2dArrayDepthRO: + case ZigClangBuiltinTypeOCLImage2dMSAARO: + case ZigClangBuiltinTypeOCLImage2dArrayMSAARO: + case ZigClangBuiltinTypeOCLImage2dMSAADepthRO: + case ZigClangBuiltinTypeOCLImage2dArrayMSAADepthRO: + case ZigClangBuiltinTypeOCLImage3dRO: + case ZigClangBuiltinTypeOCLImage1dWO: + case ZigClangBuiltinTypeOCLImage1dArrayWO: + case ZigClangBuiltinTypeOCLImage1dBufferWO: + case ZigClangBuiltinTypeOCLImage2dWO: + case ZigClangBuiltinTypeOCLImage2dArrayWO: + case ZigClangBuiltinTypeOCLImage2dDepthWO: + case ZigClangBuiltinTypeOCLImage2dArrayDepthWO: + case ZigClangBuiltinTypeOCLImage2dMSAAWO: + case ZigClangBuiltinTypeOCLImage2dArrayMSAAWO: + case ZigClangBuiltinTypeOCLImage2dMSAADepthWO: + case ZigClangBuiltinTypeOCLImage2dArrayMSAADepthWO: + case ZigClangBuiltinTypeOCLImage3dWO: + case ZigClangBuiltinTypeOCLImage1dRW: + case ZigClangBuiltinTypeOCLImage1dArrayRW: + case ZigClangBuiltinTypeOCLImage1dBufferRW: + case ZigClangBuiltinTypeOCLImage2dRW: + case ZigClangBuiltinTypeOCLImage2dArrayRW: + case ZigClangBuiltinTypeOCLImage2dDepthRW: + case ZigClangBuiltinTypeOCLImage2dArrayDepthRW: + case ZigClangBuiltinTypeOCLImage2dMSAARW: + case ZigClangBuiltinTypeOCLImage2dArrayMSAARW: + case ZigClangBuiltinTypeOCLImage2dMSAADepthRW: + case ZigClangBuiltinTypeOCLImage2dArrayMSAADepthRW: + case ZigClangBuiltinTypeOCLImage3dRW: + case ZigClangBuiltinTypeOCLSampler: + case ZigClangBuiltinTypeOCLEvent: + case ZigClangBuiltinTypeOCLClkEvent: + case ZigClangBuiltinTypeOCLQueue: + case ZigClangBuiltinTypeOCLReserveID: + case ZigClangBuiltinTypeShortFract: + case ZigClangBuiltinTypeFract: + case ZigClangBuiltinTypeLongFract: + case ZigClangBuiltinTypeUShortFract: + case ZigClangBuiltinTypeUFract: + case ZigClangBuiltinTypeULongFract: + case ZigClangBuiltinTypeSatShortAccum: + case ZigClangBuiltinTypeSatAccum: + case ZigClangBuiltinTypeSatLongAccum: + case ZigClangBuiltinTypeSatUShortAccum: + case ZigClangBuiltinTypeSatUAccum: + case ZigClangBuiltinTypeSatULongAccum: + case ZigClangBuiltinTypeSatShortFract: + case ZigClangBuiltinTypeSatFract: + case ZigClangBuiltinTypeSatLongFract: + case ZigClangBuiltinTypeSatUShortFract: + case ZigClangBuiltinTypeSatUFract: + case ZigClangBuiltinTypeSatULongFract: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCMcePayload: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCImePayload: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCRefPayload: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCSicPayload: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCMceResult: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResult: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCRefResult: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCSicResult: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResultSingleRefStreamout: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResultDualRefStreamout: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCImeSingleRefStreamin: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCImeDualRefStreamin: emit_warning(c, source_loc, "unsupported builtin type"); return nullptr; } @@ -2729,128 +2703,128 @@ static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope * switch (classs) { case ZigClangType_Builtin: { - const clang::BuiltinType *builtin_ty = reinterpret_cast(ty); - switch (builtin_ty->getKind()) { - case clang::BuiltinType::Bool: - case clang::BuiltinType::Char_U: - case clang::BuiltinType::UChar: - case clang::BuiltinType::Char_S: - case clang::BuiltinType::SChar: - case clang::BuiltinType::UShort: - case clang::BuiltinType::UInt: - case clang::BuiltinType::ULong: - case clang::BuiltinType::ULongLong: - case clang::BuiltinType::Short: - case clang::BuiltinType::Int: - case clang::BuiltinType::Long: - case clang::BuiltinType::LongLong: - case clang::BuiltinType::UInt128: - case clang::BuiltinType::Int128: - case clang::BuiltinType::Float: - case clang::BuiltinType::Double: - case clang::BuiltinType::Float128: - case clang::BuiltinType::LongDouble: - case clang::BuiltinType::WChar_U: - case clang::BuiltinType::Char8: - case clang::BuiltinType::Char16: - case clang::BuiltinType::Char32: - case clang::BuiltinType::WChar_S: - case clang::BuiltinType::Float16: + const ZigClangBuiltinType *builtin_ty = reinterpret_cast(ty); + switch (ZigClangBuiltinType_getKind(builtin_ty)) { + case ZigClangBuiltinTypeBool: + case ZigClangBuiltinTypeChar_U: + case ZigClangBuiltinTypeUChar: + case ZigClangBuiltinTypeChar_S: + case ZigClangBuiltinTypeSChar: + case ZigClangBuiltinTypeUShort: + case ZigClangBuiltinTypeUInt: + case ZigClangBuiltinTypeULong: + case ZigClangBuiltinTypeULongLong: + case ZigClangBuiltinTypeShort: + case ZigClangBuiltinTypeInt: + case ZigClangBuiltinTypeLong: + case ZigClangBuiltinTypeLongLong: + case ZigClangBuiltinTypeUInt128: + case ZigClangBuiltinTypeInt128: + case ZigClangBuiltinTypeFloat: + case ZigClangBuiltinTypeDouble: + case ZigClangBuiltinTypeFloat128: + case ZigClangBuiltinTypeLongDouble: + case ZigClangBuiltinTypeWChar_U: + case ZigClangBuiltinTypeChar8: + case ZigClangBuiltinTypeChar16: + case ZigClangBuiltinTypeChar32: + case ZigClangBuiltinTypeWChar_S: + case ZigClangBuiltinTypeFloat16: return trans_create_node_bin_op(c, res, BinOpTypeCmpNotEq, trans_create_node_unsigned_negative(c, 0, false)); - case clang::BuiltinType::NullPtr: + case ZigClangBuiltinTypeNullPtr: return trans_create_node_bin_op(c, res, BinOpTypeCmpNotEq, trans_create_node(c, NodeTypeNullLiteral)); - case clang::BuiltinType::Void: - case clang::BuiltinType::Half: - case clang::BuiltinType::ObjCId: - case clang::BuiltinType::ObjCClass: - case clang::BuiltinType::ObjCSel: - case clang::BuiltinType::OMPArraySection: - case clang::BuiltinType::Dependent: - case clang::BuiltinType::Overload: - case clang::BuiltinType::BoundMember: - case clang::BuiltinType::PseudoObject: - case clang::BuiltinType::UnknownAny: - case clang::BuiltinType::BuiltinFn: - case clang::BuiltinType::ARCUnbridgedCast: - case clang::BuiltinType::OCLImage1dRO: - case clang::BuiltinType::OCLImage1dArrayRO: - case clang::BuiltinType::OCLImage1dBufferRO: - case clang::BuiltinType::OCLImage2dRO: - case clang::BuiltinType::OCLImage2dArrayRO: - case clang::BuiltinType::OCLImage2dDepthRO: - case clang::BuiltinType::OCLImage2dArrayDepthRO: - case clang::BuiltinType::OCLImage2dMSAARO: - case clang::BuiltinType::OCLImage2dArrayMSAARO: - case clang::BuiltinType::OCLImage2dMSAADepthRO: - case clang::BuiltinType::OCLImage2dArrayMSAADepthRO: - case clang::BuiltinType::OCLImage3dRO: - case clang::BuiltinType::OCLImage1dWO: - case clang::BuiltinType::OCLImage1dArrayWO: - case clang::BuiltinType::OCLImage1dBufferWO: - case clang::BuiltinType::OCLImage2dWO: - case clang::BuiltinType::OCLImage2dArrayWO: - case clang::BuiltinType::OCLImage2dDepthWO: - case clang::BuiltinType::OCLImage2dArrayDepthWO: - case clang::BuiltinType::OCLImage2dMSAAWO: - case clang::BuiltinType::OCLImage2dArrayMSAAWO: - case clang::BuiltinType::OCLImage2dMSAADepthWO: - case clang::BuiltinType::OCLImage2dArrayMSAADepthWO: - case clang::BuiltinType::OCLImage3dWO: - case clang::BuiltinType::OCLImage1dRW: - case clang::BuiltinType::OCLImage1dArrayRW: - case clang::BuiltinType::OCLImage1dBufferRW: - case clang::BuiltinType::OCLImage2dRW: - case clang::BuiltinType::OCLImage2dArrayRW: - case clang::BuiltinType::OCLImage2dDepthRW: - case clang::BuiltinType::OCLImage2dArrayDepthRW: - case clang::BuiltinType::OCLImage2dMSAARW: - case clang::BuiltinType::OCLImage2dArrayMSAARW: - case clang::BuiltinType::OCLImage2dMSAADepthRW: - case clang::BuiltinType::OCLImage2dArrayMSAADepthRW: - case clang::BuiltinType::OCLImage3dRW: - case clang::BuiltinType::OCLSampler: - case clang::BuiltinType::OCLEvent: - case clang::BuiltinType::OCLClkEvent: - case clang::BuiltinType::OCLQueue: - case clang::BuiltinType::OCLReserveID: - case clang::BuiltinType::ShortAccum: - case clang::BuiltinType::Accum: - case clang::BuiltinType::LongAccum: - case clang::BuiltinType::UShortAccum: - case clang::BuiltinType::UAccum: - case clang::BuiltinType::ULongAccum: - case clang::BuiltinType::ShortFract: - case clang::BuiltinType::Fract: - case clang::BuiltinType::LongFract: - case clang::BuiltinType::UShortFract: - case clang::BuiltinType::UFract: - case clang::BuiltinType::ULongFract: - case clang::BuiltinType::SatShortAccum: - case clang::BuiltinType::SatAccum: - case clang::BuiltinType::SatLongAccum: - case clang::BuiltinType::SatUShortAccum: - case clang::BuiltinType::SatUAccum: - case clang::BuiltinType::SatULongAccum: - case clang::BuiltinType::SatShortFract: - case clang::BuiltinType::SatFract: - case clang::BuiltinType::SatLongFract: - case clang::BuiltinType::SatUShortFract: - case clang::BuiltinType::SatUFract: - case clang::BuiltinType::SatULongFract: - case clang::BuiltinType::OCLIntelSubgroupAVCMcePayload: - case clang::BuiltinType::OCLIntelSubgroupAVCImePayload: - case clang::BuiltinType::OCLIntelSubgroupAVCRefPayload: - case clang::BuiltinType::OCLIntelSubgroupAVCSicPayload: - case clang::BuiltinType::OCLIntelSubgroupAVCMceResult: - case clang::BuiltinType::OCLIntelSubgroupAVCImeResult: - case clang::BuiltinType::OCLIntelSubgroupAVCRefResult: - case clang::BuiltinType::OCLIntelSubgroupAVCSicResult: - case clang::BuiltinType::OCLIntelSubgroupAVCImeResultSingleRefStreamout: - case clang::BuiltinType::OCLIntelSubgroupAVCImeResultDualRefStreamout: - case clang::BuiltinType::OCLIntelSubgroupAVCImeSingleRefStreamin: - case clang::BuiltinType::OCLIntelSubgroupAVCImeDualRefStreamin: + case ZigClangBuiltinTypeVoid: + case ZigClangBuiltinTypeHalf: + case ZigClangBuiltinTypeObjCId: + case ZigClangBuiltinTypeObjCClass: + case ZigClangBuiltinTypeObjCSel: + case ZigClangBuiltinTypeOMPArraySection: + case ZigClangBuiltinTypeDependent: + case ZigClangBuiltinTypeOverload: + case ZigClangBuiltinTypeBoundMember: + case ZigClangBuiltinTypePseudoObject: + case ZigClangBuiltinTypeUnknownAny: + case ZigClangBuiltinTypeBuiltinFn: + case ZigClangBuiltinTypeARCUnbridgedCast: + case ZigClangBuiltinTypeOCLImage1dRO: + case ZigClangBuiltinTypeOCLImage1dArrayRO: + case ZigClangBuiltinTypeOCLImage1dBufferRO: + case ZigClangBuiltinTypeOCLImage2dRO: + case ZigClangBuiltinTypeOCLImage2dArrayRO: + case ZigClangBuiltinTypeOCLImage2dDepthRO: + case ZigClangBuiltinTypeOCLImage2dArrayDepthRO: + case ZigClangBuiltinTypeOCLImage2dMSAARO: + case ZigClangBuiltinTypeOCLImage2dArrayMSAARO: + case ZigClangBuiltinTypeOCLImage2dMSAADepthRO: + case ZigClangBuiltinTypeOCLImage2dArrayMSAADepthRO: + case ZigClangBuiltinTypeOCLImage3dRO: + case ZigClangBuiltinTypeOCLImage1dWO: + case ZigClangBuiltinTypeOCLImage1dArrayWO: + case ZigClangBuiltinTypeOCLImage1dBufferWO: + case ZigClangBuiltinTypeOCLImage2dWO: + case ZigClangBuiltinTypeOCLImage2dArrayWO: + case ZigClangBuiltinTypeOCLImage2dDepthWO: + case ZigClangBuiltinTypeOCLImage2dArrayDepthWO: + case ZigClangBuiltinTypeOCLImage2dMSAAWO: + case ZigClangBuiltinTypeOCLImage2dArrayMSAAWO: + case ZigClangBuiltinTypeOCLImage2dMSAADepthWO: + case ZigClangBuiltinTypeOCLImage2dArrayMSAADepthWO: + case ZigClangBuiltinTypeOCLImage3dWO: + case ZigClangBuiltinTypeOCLImage1dRW: + case ZigClangBuiltinTypeOCLImage1dArrayRW: + case ZigClangBuiltinTypeOCLImage1dBufferRW: + case ZigClangBuiltinTypeOCLImage2dRW: + case ZigClangBuiltinTypeOCLImage2dArrayRW: + case ZigClangBuiltinTypeOCLImage2dDepthRW: + case ZigClangBuiltinTypeOCLImage2dArrayDepthRW: + case ZigClangBuiltinTypeOCLImage2dMSAARW: + case ZigClangBuiltinTypeOCLImage2dArrayMSAARW: + case ZigClangBuiltinTypeOCLImage2dMSAADepthRW: + case ZigClangBuiltinTypeOCLImage2dArrayMSAADepthRW: + case ZigClangBuiltinTypeOCLImage3dRW: + case ZigClangBuiltinTypeOCLSampler: + case ZigClangBuiltinTypeOCLEvent: + case ZigClangBuiltinTypeOCLClkEvent: + case ZigClangBuiltinTypeOCLQueue: + case ZigClangBuiltinTypeOCLReserveID: + case ZigClangBuiltinTypeShortAccum: + case ZigClangBuiltinTypeAccum: + case ZigClangBuiltinTypeLongAccum: + case ZigClangBuiltinTypeUShortAccum: + case ZigClangBuiltinTypeUAccum: + case ZigClangBuiltinTypeULongAccum: + case ZigClangBuiltinTypeShortFract: + case ZigClangBuiltinTypeFract: + case ZigClangBuiltinTypeLongFract: + case ZigClangBuiltinTypeUShortFract: + case ZigClangBuiltinTypeUFract: + case ZigClangBuiltinTypeULongFract: + case ZigClangBuiltinTypeSatShortAccum: + case ZigClangBuiltinTypeSatAccum: + case ZigClangBuiltinTypeSatLongAccum: + case ZigClangBuiltinTypeSatUShortAccum: + case ZigClangBuiltinTypeSatUAccum: + case ZigClangBuiltinTypeSatULongAccum: + case ZigClangBuiltinTypeSatShortFract: + case ZigClangBuiltinTypeSatFract: + case ZigClangBuiltinTypeSatLongFract: + case ZigClangBuiltinTypeSatUShortFract: + case ZigClangBuiltinTypeSatUFract: + case ZigClangBuiltinTypeSatULongFract: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCMcePayload: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCImePayload: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCRefPayload: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCSicPayload: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCMceResult: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResult: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCRefResult: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCSicResult: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResultSingleRefStreamout: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResultDualRefStreamout: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCImeSingleRefStreamin: + case ZigClangBuiltinTypeOCLIntelSubgroupAVCImeDualRefStreamin: return res; } break; @@ -4268,8 +4242,8 @@ static AstNode *resolve_enum_decl(Context *c, const ZigClangEnumDecl *enum_decl) // TODO only emit this tag type if the enum tag type is not the default. // I don't know what the default is, need to figure out how clang is deciding. // it appears to at least be different across gcc/msvc - if (!c_is_builtin_type(c, ZigClangEnumDecl_getIntegerType(enum_decl), clang::BuiltinType::UInt) && - !c_is_builtin_type(c, ZigClangEnumDecl_getIntegerType(enum_decl), clang::BuiltinType::Int)) + if (!c_is_builtin_type(c, ZigClangEnumDecl_getIntegerType(enum_decl), ZigClangBuiltinTypeUInt) && + !c_is_builtin_type(c, ZigClangEnumDecl_getIntegerType(enum_decl), ZigClangBuiltinTypeInt)) { enum_node->data.container_decl.init_arg_expr = tag_int_type; } diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp index a96ec3aa46..0231d03418 100644 --- a/src/zig_clang.cpp +++ b/src/zig_clang.cpp @@ -954,6 +954,245 @@ static_assert((clang::Decl::Kind)ZigClangDeclPragmaDetectMismatch == clang::Decl static_assert((clang::Decl::Kind)ZigClangDeclStaticAssert == clang::Decl::StaticAssert, ""); static_assert((clang::Decl::Kind)ZigClangDeclTranslationUnit == clang::Decl::TranslationUnit, ""); +void ZigClang_detect_enum_BuiltinTypeKind(clang::BuiltinType::Kind x) { + switch (x) { + case clang::BuiltinType::OCLImage1dRO: + case clang::BuiltinType::OCLImage1dArrayRO: + case clang::BuiltinType::OCLImage1dBufferRO: + case clang::BuiltinType::OCLImage2dRO: + case clang::BuiltinType::OCLImage2dArrayRO: + case clang::BuiltinType::OCLImage2dDepthRO: + case clang::BuiltinType::OCLImage2dArrayDepthRO: + case clang::BuiltinType::OCLImage2dMSAARO: + case clang::BuiltinType::OCLImage2dArrayMSAARO: + case clang::BuiltinType::OCLImage2dMSAADepthRO: + case clang::BuiltinType::OCLImage2dArrayMSAADepthRO: + case clang::BuiltinType::OCLImage3dRO: + case clang::BuiltinType::OCLImage1dWO: + case clang::BuiltinType::OCLImage1dArrayWO: + case clang::BuiltinType::OCLImage1dBufferWO: + case clang::BuiltinType::OCLImage2dWO: + case clang::BuiltinType::OCLImage2dArrayWO: + case clang::BuiltinType::OCLImage2dDepthWO: + case clang::BuiltinType::OCLImage2dArrayDepthWO: + case clang::BuiltinType::OCLImage2dMSAAWO: + case clang::BuiltinType::OCLImage2dArrayMSAAWO: + case clang::BuiltinType::OCLImage2dMSAADepthWO: + case clang::BuiltinType::OCLImage2dArrayMSAADepthWO: + case clang::BuiltinType::OCLImage3dWO: + case clang::BuiltinType::OCLImage1dRW: + case clang::BuiltinType::OCLImage1dArrayRW: + case clang::BuiltinType::OCLImage1dBufferRW: + case clang::BuiltinType::OCLImage2dRW: + case clang::BuiltinType::OCLImage2dArrayRW: + case clang::BuiltinType::OCLImage2dDepthRW: + case clang::BuiltinType::OCLImage2dArrayDepthRW: + case clang::BuiltinType::OCLImage2dMSAARW: + case clang::BuiltinType::OCLImage2dArrayMSAARW: + case clang::BuiltinType::OCLImage2dMSAADepthRW: + case clang::BuiltinType::OCLImage2dArrayMSAADepthRW: + case clang::BuiltinType::OCLImage3dRW: + case clang::BuiltinType::OCLIntelSubgroupAVCMcePayload: + case clang::BuiltinType::OCLIntelSubgroupAVCImePayload: + case clang::BuiltinType::OCLIntelSubgroupAVCRefPayload: + case clang::BuiltinType::OCLIntelSubgroupAVCSicPayload: + case clang::BuiltinType::OCLIntelSubgroupAVCMceResult: + case clang::BuiltinType::OCLIntelSubgroupAVCImeResult: + case clang::BuiltinType::OCLIntelSubgroupAVCRefResult: + case clang::BuiltinType::OCLIntelSubgroupAVCSicResult: + case clang::BuiltinType::OCLIntelSubgroupAVCImeResultSingleRefStreamout: + case clang::BuiltinType::OCLIntelSubgroupAVCImeResultDualRefStreamout: + case clang::BuiltinType::OCLIntelSubgroupAVCImeSingleRefStreamin: + case clang::BuiltinType::OCLIntelSubgroupAVCImeDualRefStreamin: + case clang::BuiltinType::Void: + case clang::BuiltinType::Bool: + case clang::BuiltinType::Char_U: + case clang::BuiltinType::UChar: + case clang::BuiltinType::WChar_U: + case clang::BuiltinType::Char8: + case clang::BuiltinType::Char16: + case clang::BuiltinType::Char32: + case clang::BuiltinType::UShort: + case clang::BuiltinType::UInt: + case clang::BuiltinType::ULong: + case clang::BuiltinType::ULongLong: + case clang::BuiltinType::UInt128: + case clang::BuiltinType::Char_S: + case clang::BuiltinType::SChar: + case clang::BuiltinType::WChar_S: + case clang::BuiltinType::Short: + case clang::BuiltinType::Int: + case clang::BuiltinType::Long: + case clang::BuiltinType::LongLong: + case clang::BuiltinType::Int128: + case clang::BuiltinType::ShortAccum: + case clang::BuiltinType::Accum: + case clang::BuiltinType::LongAccum: + case clang::BuiltinType::UShortAccum: + case clang::BuiltinType::UAccum: + case clang::BuiltinType::ULongAccum: + case clang::BuiltinType::ShortFract: + case clang::BuiltinType::Fract: + case clang::BuiltinType::LongFract: + case clang::BuiltinType::UShortFract: + case clang::BuiltinType::UFract: + case clang::BuiltinType::ULongFract: + case clang::BuiltinType::SatShortAccum: + case clang::BuiltinType::SatAccum: + case clang::BuiltinType::SatLongAccum: + case clang::BuiltinType::SatUShortAccum: + case clang::BuiltinType::SatUAccum: + case clang::BuiltinType::SatULongAccum: + case clang::BuiltinType::SatShortFract: + case clang::BuiltinType::SatFract: + case clang::BuiltinType::SatLongFract: + case clang::BuiltinType::SatUShortFract: + case clang::BuiltinType::SatUFract: + case clang::BuiltinType::SatULongFract: + case clang::BuiltinType::Half: + case clang::BuiltinType::Float: + case clang::BuiltinType::Double: + case clang::BuiltinType::LongDouble: + case clang::BuiltinType::Float16: + case clang::BuiltinType::Float128: + case clang::BuiltinType::NullPtr: + case clang::BuiltinType::ObjCId: + case clang::BuiltinType::ObjCClass: + case clang::BuiltinType::ObjCSel: + case clang::BuiltinType::OCLSampler: + case clang::BuiltinType::OCLEvent: + case clang::BuiltinType::OCLClkEvent: + case clang::BuiltinType::OCLQueue: + case clang::BuiltinType::OCLReserveID: + case clang::BuiltinType::Dependent: + case clang::BuiltinType::Overload: + case clang::BuiltinType::BoundMember: + case clang::BuiltinType::PseudoObject: + case clang::BuiltinType::UnknownAny: + case clang::BuiltinType::BuiltinFn: + case clang::BuiltinType::ARCUnbridgedCast: + case clang::BuiltinType::OMPArraySection: + break; + } +} + +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage1dRO == clang::BuiltinType::OCLImage1dRO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage1dArrayRO == clang::BuiltinType::OCLImage1dArrayRO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage1dBufferRO == clang::BuiltinType::OCLImage1dBufferRO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dRO == clang::BuiltinType::OCLImage2dRO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayRO == clang::BuiltinType::OCLImage2dArrayRO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dDepthRO == clang::BuiltinType::OCLImage2dDepthRO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayDepthRO == clang::BuiltinType::OCLImage2dArrayDepthRO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dMSAARO == clang::BuiltinType::OCLImage2dMSAARO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayMSAARO == clang::BuiltinType::OCLImage2dArrayMSAARO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dMSAADepthRO == clang::BuiltinType::OCLImage2dMSAADepthRO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayMSAADepthRO == clang::BuiltinType::OCLImage2dArrayMSAADepthRO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage3dRO == clang::BuiltinType::OCLImage3dRO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage1dWO == clang::BuiltinType::OCLImage1dWO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage1dArrayWO == clang::BuiltinType::OCLImage1dArrayWO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage1dBufferWO == clang::BuiltinType::OCLImage1dBufferWO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dWO == clang::BuiltinType::OCLImage2dWO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayWO == clang::BuiltinType::OCLImage2dArrayWO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dDepthWO == clang::BuiltinType::OCLImage2dDepthWO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayDepthWO == clang::BuiltinType::OCLImage2dArrayDepthWO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dMSAAWO == clang::BuiltinType::OCLImage2dMSAAWO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayMSAAWO == clang::BuiltinType::OCLImage2dArrayMSAAWO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dMSAADepthWO == clang::BuiltinType::OCLImage2dMSAADepthWO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayMSAADepthWO == clang::BuiltinType::OCLImage2dArrayMSAADepthWO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage3dWO == clang::BuiltinType::OCLImage3dWO, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage1dRW == clang::BuiltinType::OCLImage1dRW, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage1dArrayRW == clang::BuiltinType::OCLImage1dArrayRW, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage1dBufferRW == clang::BuiltinType::OCLImage1dBufferRW, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dRW == clang::BuiltinType::OCLImage2dRW, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayRW == clang::BuiltinType::OCLImage2dArrayRW, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dDepthRW == clang::BuiltinType::OCLImage2dDepthRW, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayDepthRW == clang::BuiltinType::OCLImage2dArrayDepthRW, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dMSAARW == clang::BuiltinType::OCLImage2dMSAARW, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayMSAARW == clang::BuiltinType::OCLImage2dArrayMSAARW, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dMSAADepthRW == clang::BuiltinType::OCLImage2dMSAADepthRW, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage2dArrayMSAADepthRW == clang::BuiltinType::OCLImage2dArrayMSAADepthRW, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLImage3dRW == clang::BuiltinType::OCLImage3dRW, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCMcePayload == clang::BuiltinType::OCLIntelSubgroupAVCMcePayload, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCImePayload == clang::BuiltinType::OCLIntelSubgroupAVCImePayload, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCRefPayload == clang::BuiltinType::OCLIntelSubgroupAVCRefPayload, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCSicPayload == clang::BuiltinType::OCLIntelSubgroupAVCSicPayload, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCMceResult == clang::BuiltinType::OCLIntelSubgroupAVCMceResult, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResult == clang::BuiltinType::OCLIntelSubgroupAVCImeResult, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCRefResult == clang::BuiltinType::OCLIntelSubgroupAVCRefResult, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCSicResult == clang::BuiltinType::OCLIntelSubgroupAVCSicResult, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResultSingleRefStreamout == clang::BuiltinType::OCLIntelSubgroupAVCImeResultSingleRefStreamout, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResultDualRefStreamout == clang::BuiltinType::OCLIntelSubgroupAVCImeResultDualRefStreamout, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCImeSingleRefStreamin == clang::BuiltinType::OCLIntelSubgroupAVCImeSingleRefStreamin, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLIntelSubgroupAVCImeDualRefStreamin == clang::BuiltinType::OCLIntelSubgroupAVCImeDualRefStreamin, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeVoid == clang::BuiltinType::Void, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeBool == clang::BuiltinType::Bool, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeChar_U == clang::BuiltinType::Char_U, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeUChar == clang::BuiltinType::UChar, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeWChar_U == clang::BuiltinType::WChar_U, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeChar8 == clang::BuiltinType::Char8, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeChar16 == clang::BuiltinType::Char16, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeChar32 == clang::BuiltinType::Char32, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeUShort == clang::BuiltinType::UShort, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeUInt == clang::BuiltinType::UInt, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeULong == clang::BuiltinType::ULong, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeULongLong == clang::BuiltinType::ULongLong, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeUInt128 == clang::BuiltinType::UInt128, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeChar_S == clang::BuiltinType::Char_S, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSChar == clang::BuiltinType::SChar, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeWChar_S == clang::BuiltinType::WChar_S, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeShort == clang::BuiltinType::Short, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeInt == clang::BuiltinType::Int, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeLong == clang::BuiltinType::Long, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeLongLong == clang::BuiltinType::LongLong, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeInt128 == clang::BuiltinType::Int128, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeShortAccum == clang::BuiltinType::ShortAccum, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeAccum == clang::BuiltinType::Accum, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeLongAccum == clang::BuiltinType::LongAccum, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeUShortAccum == clang::BuiltinType::UShortAccum, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeUAccum == clang::BuiltinType::UAccum, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeULongAccum == clang::BuiltinType::ULongAccum, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeShortFract == clang::BuiltinType::ShortFract, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeFract == clang::BuiltinType::Fract, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeLongFract == clang::BuiltinType::LongFract, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeUShortFract == clang::BuiltinType::UShortFract, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeUFract == clang::BuiltinType::UFract, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeULongFract == clang::BuiltinType::ULongFract, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatShortAccum == clang::BuiltinType::SatShortAccum, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatAccum == clang::BuiltinType::SatAccum, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatLongAccum == clang::BuiltinType::SatLongAccum, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatUShortAccum == clang::BuiltinType::SatUShortAccum, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatUAccum == clang::BuiltinType::SatUAccum, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatULongAccum == clang::BuiltinType::SatULongAccum, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatShortFract == clang::BuiltinType::SatShortFract, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatFract == clang::BuiltinType::SatFract, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatLongFract == clang::BuiltinType::SatLongFract, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatUShortFract == clang::BuiltinType::SatUShortFract, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatUFract == clang::BuiltinType::SatUFract, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeSatULongFract == clang::BuiltinType::SatULongFract, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeHalf == clang::BuiltinType::Half, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeFloat == clang::BuiltinType::Float, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeDouble == clang::BuiltinType::Double, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeLongDouble == clang::BuiltinType::LongDouble, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeFloat16 == clang::BuiltinType::Float16, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeFloat128 == clang::BuiltinType::Float128, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeNullPtr == clang::BuiltinType::NullPtr, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeObjCId == clang::BuiltinType::ObjCId, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeObjCClass == clang::BuiltinType::ObjCClass, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeObjCSel == clang::BuiltinType::ObjCSel, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLSampler == clang::BuiltinType::OCLSampler, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLEvent == clang::BuiltinType::OCLEvent, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLClkEvent == clang::BuiltinType::OCLClkEvent, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLQueue == clang::BuiltinType::OCLQueue, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOCLReserveID == clang::BuiltinType::OCLReserveID, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeDependent == clang::BuiltinType::Dependent, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOverload == clang::BuiltinType::Overload, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeBoundMember == clang::BuiltinType::BoundMember, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypePseudoObject == clang::BuiltinType::PseudoObject, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeUnknownAny == clang::BuiltinType::UnknownAny, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeBuiltinFn == clang::BuiltinType::BuiltinFn, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeARCUnbridgedCast == clang::BuiltinType::ARCUnbridgedCast, ""); +static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOMPArraySection == clang::BuiltinType::OMPArraySection, ""); + static_assert(sizeof(ZigClangSourceLocation) == sizeof(clang::SourceLocation), ""); static ZigClangSourceLocation bitcast(clang::SourceLocation src) { @@ -1449,3 +1688,8 @@ void ZigClangErrorMsg_delete(Stage2ErrorMsg *ptr, size_t len) { void ZigClangASTUnit_delete(struct ZigClangASTUnit *self) { delete reinterpret_cast(self); } + +enum ZigClangBuiltinTypeKind ZigClangBuiltinType_getKind(const struct ZigClangBuiltinType *self) { + auto casted = reinterpret_cast(self); + return (ZigClangBuiltinTypeKind)casted->getKind(); +} diff --git a/src/zig_clang.h b/src/zig_clang.h index 46074fc840..e4289e736c 100644 --- a/src/zig_clang.h +++ b/src/zig_clang.h @@ -559,6 +559,125 @@ enum ZigClangDeclKind { ZigClangDeclTranslationUnit, }; +enum ZigClangBuiltinTypeKind { + ZigClangBuiltinTypeOCLImage1dRO, + ZigClangBuiltinTypeOCLImage1dArrayRO, + ZigClangBuiltinTypeOCLImage1dBufferRO, + ZigClangBuiltinTypeOCLImage2dRO, + ZigClangBuiltinTypeOCLImage2dArrayRO, + ZigClangBuiltinTypeOCLImage2dDepthRO, + ZigClangBuiltinTypeOCLImage2dArrayDepthRO, + ZigClangBuiltinTypeOCLImage2dMSAARO, + ZigClangBuiltinTypeOCLImage2dArrayMSAARO, + ZigClangBuiltinTypeOCLImage2dMSAADepthRO, + ZigClangBuiltinTypeOCLImage2dArrayMSAADepthRO, + ZigClangBuiltinTypeOCLImage3dRO, + ZigClangBuiltinTypeOCLImage1dWO, + ZigClangBuiltinTypeOCLImage1dArrayWO, + ZigClangBuiltinTypeOCLImage1dBufferWO, + ZigClangBuiltinTypeOCLImage2dWO, + ZigClangBuiltinTypeOCLImage2dArrayWO, + ZigClangBuiltinTypeOCLImage2dDepthWO, + ZigClangBuiltinTypeOCLImage2dArrayDepthWO, + ZigClangBuiltinTypeOCLImage2dMSAAWO, + ZigClangBuiltinTypeOCLImage2dArrayMSAAWO, + ZigClangBuiltinTypeOCLImage2dMSAADepthWO, + ZigClangBuiltinTypeOCLImage2dArrayMSAADepthWO, + ZigClangBuiltinTypeOCLImage3dWO, + ZigClangBuiltinTypeOCLImage1dRW, + ZigClangBuiltinTypeOCLImage1dArrayRW, + ZigClangBuiltinTypeOCLImage1dBufferRW, + ZigClangBuiltinTypeOCLImage2dRW, + ZigClangBuiltinTypeOCLImage2dArrayRW, + ZigClangBuiltinTypeOCLImage2dDepthRW, + ZigClangBuiltinTypeOCLImage2dArrayDepthRW, + ZigClangBuiltinTypeOCLImage2dMSAARW, + ZigClangBuiltinTypeOCLImage2dArrayMSAARW, + ZigClangBuiltinTypeOCLImage2dMSAADepthRW, + ZigClangBuiltinTypeOCLImage2dArrayMSAADepthRW, + ZigClangBuiltinTypeOCLImage3dRW, + ZigClangBuiltinTypeOCLIntelSubgroupAVCMcePayload, + ZigClangBuiltinTypeOCLIntelSubgroupAVCImePayload, + ZigClangBuiltinTypeOCLIntelSubgroupAVCRefPayload, + ZigClangBuiltinTypeOCLIntelSubgroupAVCSicPayload, + ZigClangBuiltinTypeOCLIntelSubgroupAVCMceResult, + ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResult, + ZigClangBuiltinTypeOCLIntelSubgroupAVCRefResult, + ZigClangBuiltinTypeOCLIntelSubgroupAVCSicResult, + ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResultSingleRefStreamout, + ZigClangBuiltinTypeOCLIntelSubgroupAVCImeResultDualRefStreamout, + ZigClangBuiltinTypeOCLIntelSubgroupAVCImeSingleRefStreamin, + ZigClangBuiltinTypeOCLIntelSubgroupAVCImeDualRefStreamin, + ZigClangBuiltinTypeVoid, + ZigClangBuiltinTypeBool, + ZigClangBuiltinTypeChar_U, + ZigClangBuiltinTypeUChar, + ZigClangBuiltinTypeWChar_U, + ZigClangBuiltinTypeChar8, + ZigClangBuiltinTypeChar16, + ZigClangBuiltinTypeChar32, + ZigClangBuiltinTypeUShort, + ZigClangBuiltinTypeUInt, + ZigClangBuiltinTypeULong, + ZigClangBuiltinTypeULongLong, + ZigClangBuiltinTypeUInt128, + ZigClangBuiltinTypeChar_S, + ZigClangBuiltinTypeSChar, + ZigClangBuiltinTypeWChar_S, + ZigClangBuiltinTypeShort, + ZigClangBuiltinTypeInt, + ZigClangBuiltinTypeLong, + ZigClangBuiltinTypeLongLong, + ZigClangBuiltinTypeInt128, + ZigClangBuiltinTypeShortAccum, + ZigClangBuiltinTypeAccum, + ZigClangBuiltinTypeLongAccum, + ZigClangBuiltinTypeUShortAccum, + ZigClangBuiltinTypeUAccum, + ZigClangBuiltinTypeULongAccum, + ZigClangBuiltinTypeShortFract, + ZigClangBuiltinTypeFract, + ZigClangBuiltinTypeLongFract, + ZigClangBuiltinTypeUShortFract, + ZigClangBuiltinTypeUFract, + ZigClangBuiltinTypeULongFract, + ZigClangBuiltinTypeSatShortAccum, + ZigClangBuiltinTypeSatAccum, + ZigClangBuiltinTypeSatLongAccum, + ZigClangBuiltinTypeSatUShortAccum, + ZigClangBuiltinTypeSatUAccum, + ZigClangBuiltinTypeSatULongAccum, + ZigClangBuiltinTypeSatShortFract, + ZigClangBuiltinTypeSatFract, + ZigClangBuiltinTypeSatLongFract, + ZigClangBuiltinTypeSatUShortFract, + ZigClangBuiltinTypeSatUFract, + ZigClangBuiltinTypeSatULongFract, + ZigClangBuiltinTypeHalf, + ZigClangBuiltinTypeFloat, + ZigClangBuiltinTypeDouble, + ZigClangBuiltinTypeLongDouble, + ZigClangBuiltinTypeFloat16, + ZigClangBuiltinTypeFloat128, + ZigClangBuiltinTypeNullPtr, + ZigClangBuiltinTypeObjCId, + ZigClangBuiltinTypeObjCClass, + ZigClangBuiltinTypeObjCSel, + ZigClangBuiltinTypeOCLSampler, + ZigClangBuiltinTypeOCLEvent, + ZigClangBuiltinTypeOCLClkEvent, + ZigClangBuiltinTypeOCLQueue, + ZigClangBuiltinTypeOCLReserveID, + ZigClangBuiltinTypeDependent, + ZigClangBuiltinTypeOverload, + ZigClangBuiltinTypeBoundMember, + ZigClangBuiltinTypePseudoObject, + ZigClangBuiltinTypeUnknownAny, + ZigClangBuiltinTypeBuiltinFn, + ZigClangBuiltinTypeARCUnbridgedCast, + ZigClangBuiltinTypeOMPArraySection, +}; + ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangSourceManager_getSpellingLoc(const struct ZigClangSourceManager *, struct ZigClangSourceLocation Loc); ZIG_EXTERN_C const char *ZigClangSourceManager_getFilename(const struct ZigClangSourceManager *, @@ -655,4 +774,6 @@ ZIG_EXTERN_C unsigned ZigClangAPSInt_getNumWords(const struct ZigClangAPSInt *se ZIG_EXTERN_C const struct ZigClangExpr *ZigClangAPValueLValueBase_dyn_cast_Expr(struct ZigClangAPValueLValueBase self); +ZIG_EXTERN_C enum ZigClangBuiltinTypeKind ZigClangBuiltinType_getKind(const struct ZigClangBuiltinType *self); + #endif -- cgit v1.2.3 From eea2de108d686e36996ff698feec4c0c6574cb15 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 9 May 2019 16:52:30 -0400 Subject: translate-c: progress on self-hosted function prototypes See #1964 --- src-self-hosted/clang.zig | 1265 ++++++++++++++++----------------------- src-self-hosted/translate_c.zig | 101 +++- src/translate_c.cpp | 46 +- src/zig_clang.cpp | 58 ++ src/zig_clang.h | 26 + 5 files changed, 730 insertions(+), 766 deletions(-) (limited to 'src/zig_clang.cpp') diff --git a/src-self-hosted/clang.zig b/src-self-hosted/clang.zig index 546c2fe527..8333363d8d 100644 --- a/src-self-hosted/clang.zig +++ b/src-self-hosted/clang.zig @@ -69,742 +69,388 @@ pub const struct_ZigClangUnaryOperator = @OpaqueType(); pub const struct_ZigClangValueDecl = @OpaqueType(); pub const struct_ZigClangVarDecl = @OpaqueType(); pub const struct_ZigClangWhileStmt = @OpaqueType(); -pub const ZigClangBO_PtrMemD = enum_ZigClangBO._PtrMemD; -pub const ZigClangBO_PtrMemI = enum_ZigClangBO._PtrMemI; -pub const ZigClangBO_Mul = enum_ZigClangBO._Mul; -pub const ZigClangBO_Div = enum_ZigClangBO._Div; -pub const ZigClangBO_Rem = enum_ZigClangBO._Rem; -pub const ZigClangBO_Add = enum_ZigClangBO._Add; -pub const ZigClangBO_Sub = enum_ZigClangBO._Sub; -pub const ZigClangBO_Shl = enum_ZigClangBO._Shl; -pub const ZigClangBO_Shr = enum_ZigClangBO._Shr; -pub const ZigClangBO_Cmp = enum_ZigClangBO._Cmp; -pub const ZigClangBO_LT = enum_ZigClangBO._LT; -pub const ZigClangBO_GT = enum_ZigClangBO._GT; -pub const ZigClangBO_LE = enum_ZigClangBO._LE; -pub const ZigClangBO_GE = enum_ZigClangBO._GE; -pub const ZigClangBO_EQ = enum_ZigClangBO._EQ; -pub const ZigClangBO_NE = enum_ZigClangBO._NE; -pub const ZigClangBO_And = enum_ZigClangBO._And; -pub const ZigClangBO_Xor = enum_ZigClangBO._Xor; -pub const ZigClangBO_Or = enum_ZigClangBO._Or; -pub const ZigClangBO_LAnd = enum_ZigClangBO._LAnd; -pub const ZigClangBO_LOr = enum_ZigClangBO._LOr; -pub const ZigClangBO_Assign = enum_ZigClangBO._Assign; -pub const ZigClangBO_MulAssign = enum_ZigClangBO._MulAssign; -pub const ZigClangBO_DivAssign = enum_ZigClangBO._DivAssign; -pub const ZigClangBO_RemAssign = enum_ZigClangBO._RemAssign; -pub const ZigClangBO_AddAssign = enum_ZigClangBO._AddAssign; -pub const ZigClangBO_SubAssign = enum_ZigClangBO._SubAssign; -pub const ZigClangBO_ShlAssign = enum_ZigClangBO._ShlAssign; -pub const ZigClangBO_ShrAssign = enum_ZigClangBO._ShrAssign; -pub const ZigClangBO_AndAssign = enum_ZigClangBO._AndAssign; -pub const ZigClangBO_XorAssign = enum_ZigClangBO._XorAssign; -pub const ZigClangBO_OrAssign = enum_ZigClangBO._OrAssign; -pub const ZigClangBO_Comma = enum_ZigClangBO._Comma; -pub const enum_ZigClangBO = extern enum { - _PtrMemD, - _PtrMemI, - _Mul, - _Div, - _Rem, - _Add, - _Sub, - _Shl, - _Shr, - _Cmp, - _LT, - _GT, - _LE, - _GE, - _EQ, - _NE, - _And, - _Xor, - _Or, - _LAnd, - _LOr, - _Assign, - _MulAssign, - _DivAssign, - _RemAssign, - _AddAssign, - _SubAssign, - _ShlAssign, - _ShrAssign, - _AndAssign, - _XorAssign, - _OrAssign, - _Comma, +pub const ZigClangFunctionType = @OpaqueType(); + +pub const ZigClangBO = extern enum { + PtrMemD, + PtrMemI, + Mul, + Div, + Rem, + Add, + Sub, + Shl, + Shr, + Cmp, + LT, + GT, + LE, + GE, + EQ, + NE, + And, + Xor, + Or, + LAnd, + LOr, + Assign, + MulAssign, + DivAssign, + RemAssign, + AddAssign, + SubAssign, + ShlAssign, + ShrAssign, + AndAssign, + XorAssign, + OrAssign, + Comma, }; -pub const ZigClangUO_PostInc = enum_ZigClangUO._PostInc; -pub const ZigClangUO_PostDec = enum_ZigClangUO._PostDec; -pub const ZigClangUO_PreInc = enum_ZigClangUO._PreInc; -pub const ZigClangUO_PreDec = enum_ZigClangUO._PreDec; -pub const ZigClangUO_AddrOf = enum_ZigClangUO._AddrOf; -pub const ZigClangUO_Deref = enum_ZigClangUO._Deref; -pub const ZigClangUO_Plus = enum_ZigClangUO._Plus; -pub const ZigClangUO_Minus = enum_ZigClangUO._Minus; -pub const ZigClangUO_Not = enum_ZigClangUO._Not; -pub const ZigClangUO_LNot = enum_ZigClangUO._LNot; -pub const ZigClangUO_Real = enum_ZigClangUO._Real; -pub const ZigClangUO_Imag = enum_ZigClangUO._Imag; -pub const ZigClangUO_Extension = enum_ZigClangUO._Extension; -pub const ZigClangUO_Coawait = enum_ZigClangUO._Coawait; -pub const enum_ZigClangUO = extern enum { - _PostInc, - _PostDec, - _PreInc, - _PreDec, - _AddrOf, - _Deref, - _Plus, - _Minus, - _Not, - _LNot, - _Real, - _Imag, - _Extension, - _Coawait, + +pub const ZigClangUO = extern enum { + PostInc, + PostDec, + PreInc, + PreDec, + AddrOf, + Deref, + Plus, + Minus, + Not, + LNot, + Real, + Imag, + Extension, + Coawait, }; -pub const ZigClangType_Builtin = enum_ZigClangTypeClass.ZigClangType_Builtin; -pub const ZigClangType_Complex = enum_ZigClangTypeClass.ZigClangType_Complex; -pub const ZigClangType_Pointer = enum_ZigClangTypeClass.ZigClangType_Pointer; -pub const ZigClangType_BlockPointer = enum_ZigClangTypeClass.ZigClangType_BlockPointer; -pub const ZigClangType_LValueReference = enum_ZigClangTypeClass.ZigClangType_LValueReference; -pub const ZigClangType_RValueReference = enum_ZigClangTypeClass.ZigClangType_RValueReference; -pub const ZigClangType_MemberPointer = enum_ZigClangTypeClass.ZigClangType_MemberPointer; -pub const ZigClangType_ConstantArray = enum_ZigClangTypeClass.ZigClangType_ConstantArray; -pub const ZigClangType_IncompleteArray = enum_ZigClangTypeClass.ZigClangType_IncompleteArray; -pub const ZigClangType_VariableArray = enum_ZigClangTypeClass.ZigClangType_VariableArray; -pub const ZigClangType_DependentSizedArray = enum_ZigClangTypeClass.ZigClangType_DependentSizedArray; -pub const ZigClangType_DependentSizedExtVector = enum_ZigClangTypeClass.ZigClangType_DependentSizedExtVector; -pub const ZigClangType_DependentAddressSpace = enum_ZigClangTypeClass.ZigClangType_DependentAddressSpace; -pub const ZigClangType_Vector = enum_ZigClangTypeClass.ZigClangType_Vector; -pub const ZigClangType_DependentVector = enum_ZigClangTypeClass.ZigClangType_DependentVector; -pub const ZigClangType_ExtVector = enum_ZigClangTypeClass.ZigClangType_ExtVector; -pub const ZigClangType_FunctionProto = enum_ZigClangTypeClass.ZigClangType_FunctionProto; -pub const ZigClangType_FunctionNoProto = enum_ZigClangTypeClass.ZigClangType_FunctionNoProto; -pub const ZigClangType_UnresolvedUsing = enum_ZigClangTypeClass.ZigClangType_UnresolvedUsing; -pub const ZigClangType_Paren = enum_ZigClangTypeClass.ZigClangType_Paren; -pub const ZigClangType_Typedef = enum_ZigClangTypeClass.ZigClangType_Typedef; -pub const ZigClangType_Adjusted = enum_ZigClangTypeClass.ZigClangType_Adjusted; -pub const ZigClangType_Decayed = enum_ZigClangTypeClass.ZigClangType_Decayed; -pub const ZigClangType_TypeOfExpr = enum_ZigClangTypeClass.ZigClangType_TypeOfExpr; -pub const ZigClangType_TypeOf = enum_ZigClangTypeClass.ZigClangType_TypeOf; -pub const ZigClangType_Decltype = enum_ZigClangTypeClass.ZigClangType_Decltype; -pub const ZigClangType_UnaryTransform = enum_ZigClangTypeClass.ZigClangType_UnaryTransform; -pub const ZigClangType_Record = enum_ZigClangTypeClass.ZigClangType_Record; -pub const ZigClangType_Enum = enum_ZigClangTypeClass.ZigClangType_Enum; -pub const ZigClangType_Elaborated = enum_ZigClangTypeClass.ZigClangType_Elaborated; -pub const ZigClangType_Attributed = enum_ZigClangTypeClass.ZigClangType_Attributed; -pub const ZigClangType_TemplateTypeParm = enum_ZigClangTypeClass.ZigClangType_TemplateTypeParm; -pub const ZigClangType_SubstTemplateTypeParm = enum_ZigClangTypeClass.ZigClangType_SubstTemplateTypeParm; -pub const ZigClangType_SubstTemplateTypeParmPack = enum_ZigClangTypeClass.ZigClangType_SubstTemplateTypeParmPack; -pub const ZigClangType_TemplateSpecialization = enum_ZigClangTypeClass.ZigClangType_TemplateSpecialization; -pub const ZigClangType_Auto = enum_ZigClangTypeClass.ZigClangType_Auto; -pub const ZigClangType_DeducedTemplateSpecialization = enum_ZigClangTypeClass.ZigClangType_DeducedTemplateSpecialization; -pub const ZigClangType_InjectedClassName = enum_ZigClangTypeClass.ZigClangType_InjectedClassName; -pub const ZigClangType_DependentName = enum_ZigClangTypeClass.ZigClangType_DependentName; -pub const ZigClangType_DependentTemplateSpecialization = enum_ZigClangTypeClass.ZigClangType_DependentTemplateSpecialization; -pub const ZigClangType_PackExpansion = enum_ZigClangTypeClass.ZigClangType_PackExpansion; -pub const ZigClangType_ObjCTypeParam = enum_ZigClangTypeClass.ZigClangType_ObjCTypeParam; -pub const ZigClangType_ObjCObject = enum_ZigClangTypeClass.ZigClangType_ObjCObject; -pub const ZigClangType_ObjCInterface = enum_ZigClangTypeClass.ZigClangType_ObjCInterface; -pub const ZigClangType_ObjCObjectPointer = enum_ZigClangTypeClass.ZigClangType_ObjCObjectPointer; -pub const ZigClangType_Pipe = enum_ZigClangTypeClass.ZigClangType_Pipe; -pub const ZigClangType_Atomic = enum_ZigClangTypeClass.ZigClangType_Atomic; -pub const enum_ZigClangTypeClass = extern enum { - ZigClangType_Builtin, - ZigClangType_Complex, - ZigClangType_Pointer, - ZigClangType_BlockPointer, - ZigClangType_LValueReference, - ZigClangType_RValueReference, - ZigClangType_MemberPointer, - ZigClangType_ConstantArray, - ZigClangType_IncompleteArray, - ZigClangType_VariableArray, - ZigClangType_DependentSizedArray, - ZigClangType_DependentSizedExtVector, - ZigClangType_DependentAddressSpace, - ZigClangType_Vector, - ZigClangType_DependentVector, - ZigClangType_ExtVector, - ZigClangType_FunctionProto, - ZigClangType_FunctionNoProto, - ZigClangType_UnresolvedUsing, - ZigClangType_Paren, - ZigClangType_Typedef, - ZigClangType_Adjusted, - ZigClangType_Decayed, - ZigClangType_TypeOfExpr, - ZigClangType_TypeOf, - ZigClangType_Decltype, - ZigClangType_UnaryTransform, - ZigClangType_Record, - ZigClangType_Enum, - ZigClangType_Elaborated, - ZigClangType_Attributed, - ZigClangType_TemplateTypeParm, - ZigClangType_SubstTemplateTypeParm, - ZigClangType_SubstTemplateTypeParmPack, - ZigClangType_TemplateSpecialization, - ZigClangType_Auto, - ZigClangType_DeducedTemplateSpecialization, - ZigClangType_InjectedClassName, - ZigClangType_DependentName, - ZigClangType_DependentTemplateSpecialization, - ZigClangType_PackExpansion, - ZigClangType_ObjCTypeParam, - ZigClangType_ObjCObject, - ZigClangType_ObjCInterface, - ZigClangType_ObjCObjectPointer, - ZigClangType_Pipe, - ZigClangType_Atomic, + +pub const ZigClangTypeClass = extern enum { + Builtin, + Complex, + Pointer, + BlockPointer, + LValueReference, + RValueReference, + MemberPointer, + ConstantArray, + IncompleteArray, + VariableArray, + DependentSizedArray, + DependentSizedExtVector, + DependentAddressSpace, + Vector, + DependentVector, + ExtVector, + FunctionProto, + FunctionNoProto, + UnresolvedUsing, + Paren, + Typedef, + Adjusted, + Decayed, + TypeOfExpr, + TypeOf, + Decltype, + UnaryTransform, + Record, + Enum, + Elaborated, + Attributed, + TemplateTypeParm, + SubstTemplateTypeParm, + SubstTemplateTypeParmPack, + TemplateSpecialization, + Auto, + DeducedTemplateSpecialization, + InjectedClassName, + DependentName, + DependentTemplateSpecialization, + PackExpansion, + ObjCTypeParam, + ObjCObject, + ObjCInterface, + ObjCObjectPointer, + Pipe, + Atomic, }; -pub const ZigClangStmt_NoStmtClass = enum_ZigClangStmtClass.ZigClangStmt_NoStmtClass; -pub const ZigClangStmt_GCCAsmStmtClass = enum_ZigClangStmtClass.ZigClangStmt_GCCAsmStmtClass; -pub const ZigClangStmt_MSAsmStmtClass = enum_ZigClangStmtClass.ZigClangStmt_MSAsmStmtClass; -pub const ZigClangStmt_AttributedStmtClass = enum_ZigClangStmtClass.ZigClangStmt_AttributedStmtClass; -pub const ZigClangStmt_BreakStmtClass = enum_ZigClangStmtClass.ZigClangStmt_BreakStmtClass; -pub const ZigClangStmt_CXXCatchStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CXXCatchStmtClass; -pub const ZigClangStmt_CXXForRangeStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CXXForRangeStmtClass; -pub const ZigClangStmt_CXXTryStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CXXTryStmtClass; -pub const ZigClangStmt_CapturedStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CapturedStmtClass; -pub const ZigClangStmt_CompoundStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CompoundStmtClass; -pub const ZigClangStmt_ContinueStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ContinueStmtClass; -pub const ZigClangStmt_CoreturnStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CoreturnStmtClass; -pub const ZigClangStmt_CoroutineBodyStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CoroutineBodyStmtClass; -pub const ZigClangStmt_DeclStmtClass = enum_ZigClangStmtClass.ZigClangStmt_DeclStmtClass; -pub const ZigClangStmt_DoStmtClass = enum_ZigClangStmtClass.ZigClangStmt_DoStmtClass; -pub const ZigClangStmt_BinaryConditionalOperatorClass = enum_ZigClangStmtClass.ZigClangStmt_BinaryConditionalOperatorClass; -pub const ZigClangStmt_ConditionalOperatorClass = enum_ZigClangStmtClass.ZigClangStmt_ConditionalOperatorClass; -pub const ZigClangStmt_AddrLabelExprClass = enum_ZigClangStmtClass.ZigClangStmt_AddrLabelExprClass; -pub const ZigClangStmt_ArrayInitIndexExprClass = enum_ZigClangStmtClass.ZigClangStmt_ArrayInitIndexExprClass; -pub const ZigClangStmt_ArrayInitLoopExprClass = enum_ZigClangStmtClass.ZigClangStmt_ArrayInitLoopExprClass; -pub const ZigClangStmt_ArraySubscriptExprClass = enum_ZigClangStmtClass.ZigClangStmt_ArraySubscriptExprClass; -pub const ZigClangStmt_ArrayTypeTraitExprClass = enum_ZigClangStmtClass.ZigClangStmt_ArrayTypeTraitExprClass; -pub const ZigClangStmt_AsTypeExprClass = enum_ZigClangStmtClass.ZigClangStmt_AsTypeExprClass; -pub const ZigClangStmt_AtomicExprClass = enum_ZigClangStmtClass.ZigClangStmt_AtomicExprClass; -pub const ZigClangStmt_BinaryOperatorClass = enum_ZigClangStmtClass.ZigClangStmt_BinaryOperatorClass; -pub const ZigClangStmt_CompoundAssignOperatorClass = enum_ZigClangStmtClass.ZigClangStmt_CompoundAssignOperatorClass; -pub const ZigClangStmt_BlockExprClass = enum_ZigClangStmtClass.ZigClangStmt_BlockExprClass; -pub const ZigClangStmt_CXXBindTemporaryExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXBindTemporaryExprClass; -pub const ZigClangStmt_CXXBoolLiteralExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXBoolLiteralExprClass; -pub const ZigClangStmt_CXXConstructExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXConstructExprClass; -pub const ZigClangStmt_CXXTemporaryObjectExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXTemporaryObjectExprClass; -pub const ZigClangStmt_CXXDefaultArgExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXDefaultArgExprClass; -pub const ZigClangStmt_CXXDefaultInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXDefaultInitExprClass; -pub const ZigClangStmt_CXXDeleteExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXDeleteExprClass; -pub const ZigClangStmt_CXXDependentScopeMemberExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXDependentScopeMemberExprClass; -pub const ZigClangStmt_CXXFoldExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXFoldExprClass; -pub const ZigClangStmt_CXXInheritedCtorInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXInheritedCtorInitExprClass; -pub const ZigClangStmt_CXXNewExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXNewExprClass; -pub const ZigClangStmt_CXXNoexceptExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXNoexceptExprClass; -pub const ZigClangStmt_CXXNullPtrLiteralExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXNullPtrLiteralExprClass; -pub const ZigClangStmt_CXXPseudoDestructorExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXPseudoDestructorExprClass; -pub const ZigClangStmt_CXXScalarValueInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXScalarValueInitExprClass; -pub const ZigClangStmt_CXXStdInitializerListExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXStdInitializerListExprClass; -pub const ZigClangStmt_CXXThisExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXThisExprClass; -pub const ZigClangStmt_CXXThrowExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXThrowExprClass; -pub const ZigClangStmt_CXXTypeidExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXTypeidExprClass; -pub const ZigClangStmt_CXXUnresolvedConstructExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXUnresolvedConstructExprClass; -pub const ZigClangStmt_CXXUuidofExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXUuidofExprClass; -pub const ZigClangStmt_CallExprClass = enum_ZigClangStmtClass.ZigClangStmt_CallExprClass; -pub const ZigClangStmt_CUDAKernelCallExprClass = enum_ZigClangStmtClass.ZigClangStmt_CUDAKernelCallExprClass; -pub const ZigClangStmt_CXXMemberCallExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXMemberCallExprClass; -pub const ZigClangStmt_CXXOperatorCallExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXOperatorCallExprClass; -pub const ZigClangStmt_UserDefinedLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_UserDefinedLiteralClass; -pub const ZigClangStmt_CStyleCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CStyleCastExprClass; -pub const ZigClangStmt_CXXFunctionalCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXFunctionalCastExprClass; -pub const ZigClangStmt_CXXConstCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXConstCastExprClass; -pub const ZigClangStmt_CXXDynamicCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXDynamicCastExprClass; -pub const ZigClangStmt_CXXReinterpretCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXReinterpretCastExprClass; -pub const ZigClangStmt_CXXStaticCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_CXXStaticCastExprClass; -pub const ZigClangStmt_ObjCBridgedCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCBridgedCastExprClass; -pub const ZigClangStmt_ImplicitCastExprClass = enum_ZigClangStmtClass.ZigClangStmt_ImplicitCastExprClass; -pub const ZigClangStmt_CharacterLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_CharacterLiteralClass; -pub const ZigClangStmt_ChooseExprClass = enum_ZigClangStmtClass.ZigClangStmt_ChooseExprClass; -pub const ZigClangStmt_CompoundLiteralExprClass = enum_ZigClangStmtClass.ZigClangStmt_CompoundLiteralExprClass; -pub const ZigClangStmt_ConvertVectorExprClass = enum_ZigClangStmtClass.ZigClangStmt_ConvertVectorExprClass; -pub const ZigClangStmt_CoawaitExprClass = enum_ZigClangStmtClass.ZigClangStmt_CoawaitExprClass; -pub const ZigClangStmt_CoyieldExprClass = enum_ZigClangStmtClass.ZigClangStmt_CoyieldExprClass; -pub const ZigClangStmt_DeclRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_DeclRefExprClass; -pub const ZigClangStmt_DependentCoawaitExprClass = enum_ZigClangStmtClass.ZigClangStmt_DependentCoawaitExprClass; -pub const ZigClangStmt_DependentScopeDeclRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_DependentScopeDeclRefExprClass; -pub const ZigClangStmt_DesignatedInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_DesignatedInitExprClass; -pub const ZigClangStmt_DesignatedInitUpdateExprClass = enum_ZigClangStmtClass.ZigClangStmt_DesignatedInitUpdateExprClass; -pub const ZigClangStmt_ExpressionTraitExprClass = enum_ZigClangStmtClass.ZigClangStmt_ExpressionTraitExprClass; -pub const ZigClangStmt_ExtVectorElementExprClass = enum_ZigClangStmtClass.ZigClangStmt_ExtVectorElementExprClass; -pub const ZigClangStmt_FixedPointLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_FixedPointLiteralClass; -pub const ZigClangStmt_FloatingLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_FloatingLiteralClass; -pub const ZigClangStmt_ConstantExprClass = enum_ZigClangStmtClass.ZigClangStmt_ConstantExprClass; -pub const ZigClangStmt_ExprWithCleanupsClass = enum_ZigClangStmtClass.ZigClangStmt_ExprWithCleanupsClass; -pub const ZigClangStmt_FunctionParmPackExprClass = enum_ZigClangStmtClass.ZigClangStmt_FunctionParmPackExprClass; -pub const ZigClangStmt_GNUNullExprClass = enum_ZigClangStmtClass.ZigClangStmt_GNUNullExprClass; -pub const ZigClangStmt_GenericSelectionExprClass = enum_ZigClangStmtClass.ZigClangStmt_GenericSelectionExprClass; -pub const ZigClangStmt_ImaginaryLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_ImaginaryLiteralClass; -pub const ZigClangStmt_ImplicitValueInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_ImplicitValueInitExprClass; -pub const ZigClangStmt_InitListExprClass = enum_ZigClangStmtClass.ZigClangStmt_InitListExprClass; -pub const ZigClangStmt_IntegerLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_IntegerLiteralClass; -pub const ZigClangStmt_LambdaExprClass = enum_ZigClangStmtClass.ZigClangStmt_LambdaExprClass; -pub const ZigClangStmt_MSPropertyRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_MSPropertyRefExprClass; -pub const ZigClangStmt_MSPropertySubscriptExprClass = enum_ZigClangStmtClass.ZigClangStmt_MSPropertySubscriptExprClass; -pub const ZigClangStmt_MaterializeTemporaryExprClass = enum_ZigClangStmtClass.ZigClangStmt_MaterializeTemporaryExprClass; -pub const ZigClangStmt_MemberExprClass = enum_ZigClangStmtClass.ZigClangStmt_MemberExprClass; -pub const ZigClangStmt_NoInitExprClass = enum_ZigClangStmtClass.ZigClangStmt_NoInitExprClass; -pub const ZigClangStmt_OMPArraySectionExprClass = enum_ZigClangStmtClass.ZigClangStmt_OMPArraySectionExprClass; -pub const ZigClangStmt_ObjCArrayLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCArrayLiteralClass; -pub const ZigClangStmt_ObjCAvailabilityCheckExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAvailabilityCheckExprClass; -pub const ZigClangStmt_ObjCBoolLiteralExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCBoolLiteralExprClass; -pub const ZigClangStmt_ObjCBoxedExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCBoxedExprClass; -pub const ZigClangStmt_ObjCDictionaryLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCDictionaryLiteralClass; -pub const ZigClangStmt_ObjCEncodeExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCEncodeExprClass; -pub const ZigClangStmt_ObjCIndirectCopyRestoreExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCIndirectCopyRestoreExprClass; -pub const ZigClangStmt_ObjCIsaExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCIsaExprClass; -pub const ZigClangStmt_ObjCIvarRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCIvarRefExprClass; -pub const ZigClangStmt_ObjCMessageExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCMessageExprClass; -pub const ZigClangStmt_ObjCPropertyRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCPropertyRefExprClass; -pub const ZigClangStmt_ObjCProtocolExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCProtocolExprClass; -pub const ZigClangStmt_ObjCSelectorExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCSelectorExprClass; -pub const ZigClangStmt_ObjCStringLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCStringLiteralClass; -pub const ZigClangStmt_ObjCSubscriptRefExprClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCSubscriptRefExprClass; -pub const ZigClangStmt_OffsetOfExprClass = enum_ZigClangStmtClass.ZigClangStmt_OffsetOfExprClass; -pub const ZigClangStmt_OpaqueValueExprClass = enum_ZigClangStmtClass.ZigClangStmt_OpaqueValueExprClass; -pub const ZigClangStmt_UnresolvedLookupExprClass = enum_ZigClangStmtClass.ZigClangStmt_UnresolvedLookupExprClass; -pub const ZigClangStmt_UnresolvedMemberExprClass = enum_ZigClangStmtClass.ZigClangStmt_UnresolvedMemberExprClass; -pub const ZigClangStmt_PackExpansionExprClass = enum_ZigClangStmtClass.ZigClangStmt_PackExpansionExprClass; -pub const ZigClangStmt_ParenExprClass = enum_ZigClangStmtClass.ZigClangStmt_ParenExprClass; -pub const ZigClangStmt_ParenListExprClass = enum_ZigClangStmtClass.ZigClangStmt_ParenListExprClass; -pub const ZigClangStmt_PredefinedExprClass = enum_ZigClangStmtClass.ZigClangStmt_PredefinedExprClass; -pub const ZigClangStmt_PseudoObjectExprClass = enum_ZigClangStmtClass.ZigClangStmt_PseudoObjectExprClass; -pub const ZigClangStmt_ShuffleVectorExprClass = enum_ZigClangStmtClass.ZigClangStmt_ShuffleVectorExprClass; -pub const ZigClangStmt_SizeOfPackExprClass = enum_ZigClangStmtClass.ZigClangStmt_SizeOfPackExprClass; -pub const ZigClangStmt_StmtExprClass = enum_ZigClangStmtClass.ZigClangStmt_StmtExprClass; -pub const ZigClangStmt_StringLiteralClass = enum_ZigClangStmtClass.ZigClangStmt_StringLiteralClass; -pub const ZigClangStmt_SubstNonTypeTemplateParmExprClass = enum_ZigClangStmtClass.ZigClangStmt_SubstNonTypeTemplateParmExprClass; -pub const ZigClangStmt_SubstNonTypeTemplateParmPackExprClass = enum_ZigClangStmtClass.ZigClangStmt_SubstNonTypeTemplateParmPackExprClass; -pub const ZigClangStmt_TypeTraitExprClass = enum_ZigClangStmtClass.ZigClangStmt_TypeTraitExprClass; -pub const ZigClangStmt_TypoExprClass = enum_ZigClangStmtClass.ZigClangStmt_TypoExprClass; -pub const ZigClangStmt_UnaryExprOrTypeTraitExprClass = enum_ZigClangStmtClass.ZigClangStmt_UnaryExprOrTypeTraitExprClass; -pub const ZigClangStmt_UnaryOperatorClass = enum_ZigClangStmtClass.ZigClangStmt_UnaryOperatorClass; -pub const ZigClangStmt_VAArgExprClass = enum_ZigClangStmtClass.ZigClangStmt_VAArgExprClass; -pub const ZigClangStmt_ForStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ForStmtClass; -pub const ZigClangStmt_GotoStmtClass = enum_ZigClangStmtClass.ZigClangStmt_GotoStmtClass; -pub const ZigClangStmt_IfStmtClass = enum_ZigClangStmtClass.ZigClangStmt_IfStmtClass; -pub const ZigClangStmt_IndirectGotoStmtClass = enum_ZigClangStmtClass.ZigClangStmt_IndirectGotoStmtClass; -pub const ZigClangStmt_LabelStmtClass = enum_ZigClangStmtClass.ZigClangStmt_LabelStmtClass; -pub const ZigClangStmt_MSDependentExistsStmtClass = enum_ZigClangStmtClass.ZigClangStmt_MSDependentExistsStmtClass; -pub const ZigClangStmt_NullStmtClass = enum_ZigClangStmtClass.ZigClangStmt_NullStmtClass; -pub const ZigClangStmt_OMPAtomicDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPAtomicDirectiveClass; -pub const ZigClangStmt_OMPBarrierDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPBarrierDirectiveClass; -pub const ZigClangStmt_OMPCancelDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPCancelDirectiveClass; -pub const ZigClangStmt_OMPCancellationPointDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPCancellationPointDirectiveClass; -pub const ZigClangStmt_OMPCriticalDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPCriticalDirectiveClass; -pub const ZigClangStmt_OMPFlushDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPFlushDirectiveClass; -pub const ZigClangStmt_OMPDistributeDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPDistributeDirectiveClass; -pub const ZigClangStmt_OMPDistributeParallelForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPDistributeParallelForDirectiveClass; -pub const ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass; -pub const ZigClangStmt_OMPDistributeSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPDistributeSimdDirectiveClass; -pub const ZigClangStmt_OMPForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPForDirectiveClass; -pub const ZigClangStmt_OMPForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPForSimdDirectiveClass; -pub const ZigClangStmt_OMPParallelForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPParallelForDirectiveClass; -pub const ZigClangStmt_OMPParallelForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPParallelForSimdDirectiveClass; -pub const ZigClangStmt_OMPSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPSimdDirectiveClass; -pub const ZigClangStmt_OMPTargetParallelForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetParallelForSimdDirectiveClass; -pub const ZigClangStmt_OMPTargetSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetSimdDirectiveClass; -pub const ZigClangStmt_OMPTargetTeamsDistributeDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetTeamsDistributeDirectiveClass; -pub const ZigClangStmt_OMPTargetTeamsDistributeParallelForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetTeamsDistributeParallelForDirectiveClass; -pub const ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass; -pub const ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass; -pub const ZigClangStmt_OMPTaskLoopDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskLoopDirectiveClass; -pub const ZigClangStmt_OMPTaskLoopSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskLoopSimdDirectiveClass; -pub const ZigClangStmt_OMPTeamsDistributeDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTeamsDistributeDirectiveClass; -pub const ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass; -pub const ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass; -pub const ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass; -pub const ZigClangStmt_OMPMasterDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPMasterDirectiveClass; -pub const ZigClangStmt_OMPOrderedDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPOrderedDirectiveClass; -pub const ZigClangStmt_OMPParallelDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPParallelDirectiveClass; -pub const ZigClangStmt_OMPParallelSectionsDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPParallelSectionsDirectiveClass; -pub const ZigClangStmt_OMPSectionDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPSectionDirectiveClass; -pub const ZigClangStmt_OMPSectionsDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPSectionsDirectiveClass; -pub const ZigClangStmt_OMPSingleDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPSingleDirectiveClass; -pub const ZigClangStmt_OMPTargetDataDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetDataDirectiveClass; -pub const ZigClangStmt_OMPTargetDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetDirectiveClass; -pub const ZigClangStmt_OMPTargetEnterDataDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetEnterDataDirectiveClass; -pub const ZigClangStmt_OMPTargetExitDataDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetExitDataDirectiveClass; -pub const ZigClangStmt_OMPTargetParallelDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetParallelDirectiveClass; -pub const ZigClangStmt_OMPTargetParallelForDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetParallelForDirectiveClass; -pub const ZigClangStmt_OMPTargetTeamsDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetTeamsDirectiveClass; -pub const ZigClangStmt_OMPTargetUpdateDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTargetUpdateDirectiveClass; -pub const ZigClangStmt_OMPTaskDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskDirectiveClass; -pub const ZigClangStmt_OMPTaskgroupDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskgroupDirectiveClass; -pub const ZigClangStmt_OMPTaskwaitDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskwaitDirectiveClass; -pub const ZigClangStmt_OMPTaskyieldDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTaskyieldDirectiveClass; -pub const ZigClangStmt_OMPTeamsDirectiveClass = enum_ZigClangStmtClass.ZigClangStmt_OMPTeamsDirectiveClass; -pub const ZigClangStmt_ObjCAtCatchStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAtCatchStmtClass; -pub const ZigClangStmt_ObjCAtFinallyStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAtFinallyStmtClass; -pub const ZigClangStmt_ObjCAtSynchronizedStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAtSynchronizedStmtClass; -pub const ZigClangStmt_ObjCAtThrowStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAtThrowStmtClass; -pub const ZigClangStmt_ObjCAtTryStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAtTryStmtClass; -pub const ZigClangStmt_ObjCAutoreleasePoolStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCAutoreleasePoolStmtClass; -pub const ZigClangStmt_ObjCForCollectionStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ObjCForCollectionStmtClass; -pub const ZigClangStmt_ReturnStmtClass = enum_ZigClangStmtClass.ZigClangStmt_ReturnStmtClass; -pub const ZigClangStmt_SEHExceptStmtClass = enum_ZigClangStmtClass.ZigClangStmt_SEHExceptStmtClass; -pub const ZigClangStmt_SEHFinallyStmtClass = enum_ZigClangStmtClass.ZigClangStmt_SEHFinallyStmtClass; -pub const ZigClangStmt_SEHLeaveStmtClass = enum_ZigClangStmtClass.ZigClangStmt_SEHLeaveStmtClass; -pub const ZigClangStmt_SEHTryStmtClass = enum_ZigClangStmtClass.ZigClangStmt_SEHTryStmtClass; -pub const ZigClangStmt_CaseStmtClass = enum_ZigClangStmtClass.ZigClangStmt_CaseStmtClass; -pub const ZigClangStmt_DefaultStmtClass = enum_ZigClangStmtClass.ZigClangStmt_DefaultStmtClass; -pub const ZigClangStmt_SwitchStmtClass = enum_ZigClangStmtClass.ZigClangStmt_SwitchStmtClass; -pub const ZigClangStmt_WhileStmtClass = enum_ZigClangStmtClass.ZigClangStmt_WhileStmtClass; -pub const enum_ZigClangStmtClass = extern enum { - ZigClangStmt_NoStmtClass = 0, - ZigClangStmt_GCCAsmStmtClass = 1, - ZigClangStmt_MSAsmStmtClass = 2, - ZigClangStmt_AttributedStmtClass = 3, - ZigClangStmt_BreakStmtClass = 4, - ZigClangStmt_CXXCatchStmtClass = 5, - ZigClangStmt_CXXForRangeStmtClass = 6, - ZigClangStmt_CXXTryStmtClass = 7, - ZigClangStmt_CapturedStmtClass = 8, - ZigClangStmt_CompoundStmtClass = 9, - ZigClangStmt_ContinueStmtClass = 10, - ZigClangStmt_CoreturnStmtClass = 11, - ZigClangStmt_CoroutineBodyStmtClass = 12, - ZigClangStmt_DeclStmtClass = 13, - ZigClangStmt_DoStmtClass = 14, - ZigClangStmt_BinaryConditionalOperatorClass = 15, - ZigClangStmt_ConditionalOperatorClass = 16, - ZigClangStmt_AddrLabelExprClass = 17, - ZigClangStmt_ArrayInitIndexExprClass = 18, - ZigClangStmt_ArrayInitLoopExprClass = 19, - ZigClangStmt_ArraySubscriptExprClass = 20, - ZigClangStmt_ArrayTypeTraitExprClass = 21, - ZigClangStmt_AsTypeExprClass = 22, - ZigClangStmt_AtomicExprClass = 23, - ZigClangStmt_BinaryOperatorClass = 24, - ZigClangStmt_CompoundAssignOperatorClass = 25, - ZigClangStmt_BlockExprClass = 26, - ZigClangStmt_CXXBindTemporaryExprClass = 27, - ZigClangStmt_CXXBoolLiteralExprClass = 28, - ZigClangStmt_CXXConstructExprClass = 29, - ZigClangStmt_CXXTemporaryObjectExprClass = 30, - ZigClangStmt_CXXDefaultArgExprClass = 31, - ZigClangStmt_CXXDefaultInitExprClass = 32, - ZigClangStmt_CXXDeleteExprClass = 33, - ZigClangStmt_CXXDependentScopeMemberExprClass = 34, - ZigClangStmt_CXXFoldExprClass = 35, - ZigClangStmt_CXXInheritedCtorInitExprClass = 36, - ZigClangStmt_CXXNewExprClass = 37, - ZigClangStmt_CXXNoexceptExprClass = 38, - ZigClangStmt_CXXNullPtrLiteralExprClass = 39, - ZigClangStmt_CXXPseudoDestructorExprClass = 40, - ZigClangStmt_CXXScalarValueInitExprClass = 41, - ZigClangStmt_CXXStdInitializerListExprClass = 42, - ZigClangStmt_CXXThisExprClass = 43, - ZigClangStmt_CXXThrowExprClass = 44, - ZigClangStmt_CXXTypeidExprClass = 45, - ZigClangStmt_CXXUnresolvedConstructExprClass = 46, - ZigClangStmt_CXXUuidofExprClass = 47, - ZigClangStmt_CallExprClass = 48, - ZigClangStmt_CUDAKernelCallExprClass = 49, - ZigClangStmt_CXXMemberCallExprClass = 50, - ZigClangStmt_CXXOperatorCallExprClass = 51, - ZigClangStmt_UserDefinedLiteralClass = 52, - ZigClangStmt_CStyleCastExprClass = 53, - ZigClangStmt_CXXFunctionalCastExprClass = 54, - ZigClangStmt_CXXConstCastExprClass = 55, - ZigClangStmt_CXXDynamicCastExprClass = 56, - ZigClangStmt_CXXReinterpretCastExprClass = 57, - ZigClangStmt_CXXStaticCastExprClass = 58, - ZigClangStmt_ObjCBridgedCastExprClass = 59, - ZigClangStmt_ImplicitCastExprClass = 60, - ZigClangStmt_CharacterLiteralClass = 61, - ZigClangStmt_ChooseExprClass = 62, - ZigClangStmt_CompoundLiteralExprClass = 63, - ZigClangStmt_ConvertVectorExprClass = 64, - ZigClangStmt_CoawaitExprClass = 65, - ZigClangStmt_CoyieldExprClass = 66, - ZigClangStmt_DeclRefExprClass = 67, - ZigClangStmt_DependentCoawaitExprClass = 68, - ZigClangStmt_DependentScopeDeclRefExprClass = 69, - ZigClangStmt_DesignatedInitExprClass = 70, - ZigClangStmt_DesignatedInitUpdateExprClass = 71, - ZigClangStmt_ExpressionTraitExprClass = 72, - ZigClangStmt_ExtVectorElementExprClass = 73, - ZigClangStmt_FixedPointLiteralClass = 74, - ZigClangStmt_FloatingLiteralClass = 75, - ZigClangStmt_ConstantExprClass = 76, - ZigClangStmt_ExprWithCleanupsClass = 77, - ZigClangStmt_FunctionParmPackExprClass = 78, - ZigClangStmt_GNUNullExprClass = 79, - ZigClangStmt_GenericSelectionExprClass = 80, - ZigClangStmt_ImaginaryLiteralClass = 81, - ZigClangStmt_ImplicitValueInitExprClass = 82, - ZigClangStmt_InitListExprClass = 83, - ZigClangStmt_IntegerLiteralClass = 84, - ZigClangStmt_LambdaExprClass = 85, - ZigClangStmt_MSPropertyRefExprClass = 86, - ZigClangStmt_MSPropertySubscriptExprClass = 87, - ZigClangStmt_MaterializeTemporaryExprClass = 88, - ZigClangStmt_MemberExprClass = 89, - ZigClangStmt_NoInitExprClass = 90, - ZigClangStmt_OMPArraySectionExprClass = 91, - ZigClangStmt_ObjCArrayLiteralClass = 92, - ZigClangStmt_ObjCAvailabilityCheckExprClass = 93, - ZigClangStmt_ObjCBoolLiteralExprClass = 94, - ZigClangStmt_ObjCBoxedExprClass = 95, - ZigClangStmt_ObjCDictionaryLiteralClass = 96, - ZigClangStmt_ObjCEncodeExprClass = 97, - ZigClangStmt_ObjCIndirectCopyRestoreExprClass = 98, - ZigClangStmt_ObjCIsaExprClass = 99, - ZigClangStmt_ObjCIvarRefExprClass = 100, - ZigClangStmt_ObjCMessageExprClass = 101, - ZigClangStmt_ObjCPropertyRefExprClass = 102, - ZigClangStmt_ObjCProtocolExprClass = 103, - ZigClangStmt_ObjCSelectorExprClass = 104, - ZigClangStmt_ObjCStringLiteralClass = 105, - ZigClangStmt_ObjCSubscriptRefExprClass = 106, - ZigClangStmt_OffsetOfExprClass = 107, - ZigClangStmt_OpaqueValueExprClass = 108, - ZigClangStmt_UnresolvedLookupExprClass = 109, - ZigClangStmt_UnresolvedMemberExprClass = 110, - ZigClangStmt_PackExpansionExprClass = 111, - ZigClangStmt_ParenExprClass = 112, - ZigClangStmt_ParenListExprClass = 113, - ZigClangStmt_PredefinedExprClass = 114, - ZigClangStmt_PseudoObjectExprClass = 115, - ZigClangStmt_ShuffleVectorExprClass = 116, - ZigClangStmt_SizeOfPackExprClass = 117, - ZigClangStmt_StmtExprClass = 118, - ZigClangStmt_StringLiteralClass = 119, - ZigClangStmt_SubstNonTypeTemplateParmExprClass = 120, - ZigClangStmt_SubstNonTypeTemplateParmPackExprClass = 121, - ZigClangStmt_TypeTraitExprClass = 122, - ZigClangStmt_TypoExprClass = 123, - ZigClangStmt_UnaryExprOrTypeTraitExprClass = 124, - ZigClangStmt_UnaryOperatorClass = 125, - ZigClangStmt_VAArgExprClass = 126, - ZigClangStmt_ForStmtClass = 127, - ZigClangStmt_GotoStmtClass = 128, - ZigClangStmt_IfStmtClass = 129, - ZigClangStmt_IndirectGotoStmtClass = 130, - ZigClangStmt_LabelStmtClass = 131, - ZigClangStmt_MSDependentExistsStmtClass = 132, - ZigClangStmt_NullStmtClass = 133, - ZigClangStmt_OMPAtomicDirectiveClass = 134, - ZigClangStmt_OMPBarrierDirectiveClass = 135, - ZigClangStmt_OMPCancelDirectiveClass = 136, - ZigClangStmt_OMPCancellationPointDirectiveClass = 137, - ZigClangStmt_OMPCriticalDirectiveClass = 138, - ZigClangStmt_OMPFlushDirectiveClass = 139, - ZigClangStmt_OMPDistributeDirectiveClass = 140, - ZigClangStmt_OMPDistributeParallelForDirectiveClass = 141, - ZigClangStmt_OMPDistributeParallelForSimdDirectiveClass = 142, - ZigClangStmt_OMPDistributeSimdDirectiveClass = 143, - ZigClangStmt_OMPForDirectiveClass = 144, - ZigClangStmt_OMPForSimdDirectiveClass = 145, - ZigClangStmt_OMPParallelForDirectiveClass = 146, - ZigClangStmt_OMPParallelForSimdDirectiveClass = 147, - ZigClangStmt_OMPSimdDirectiveClass = 148, - ZigClangStmt_OMPTargetParallelForSimdDirectiveClass = 149, - ZigClangStmt_OMPTargetSimdDirectiveClass = 150, - ZigClangStmt_OMPTargetTeamsDistributeDirectiveClass = 151, - ZigClangStmt_OMPTargetTeamsDistributeParallelForDirectiveClass = 152, - ZigClangStmt_OMPTargetTeamsDistributeParallelForSimdDirectiveClass = 153, - ZigClangStmt_OMPTargetTeamsDistributeSimdDirectiveClass = 154, - ZigClangStmt_OMPTaskLoopDirectiveClass = 155, - ZigClangStmt_OMPTaskLoopSimdDirectiveClass = 156, - ZigClangStmt_OMPTeamsDistributeDirectiveClass = 157, - ZigClangStmt_OMPTeamsDistributeParallelForDirectiveClass = 158, - ZigClangStmt_OMPTeamsDistributeParallelForSimdDirectiveClass = 159, - ZigClangStmt_OMPTeamsDistributeSimdDirectiveClass = 160, - ZigClangStmt_OMPMasterDirectiveClass = 161, - ZigClangStmt_OMPOrderedDirectiveClass = 162, - ZigClangStmt_OMPParallelDirectiveClass = 163, - ZigClangStmt_OMPParallelSectionsDirectiveClass = 164, - ZigClangStmt_OMPSectionDirectiveClass = 165, - ZigClangStmt_OMPSectionsDirectiveClass = 166, - ZigClangStmt_OMPSingleDirectiveClass = 167, - ZigClangStmt_OMPTargetDataDirectiveClass = 168, - ZigClangStmt_OMPTargetDirectiveClass = 169, - ZigClangStmt_OMPTargetEnterDataDirectiveClass = 170, - ZigClangStmt_OMPTargetExitDataDirectiveClass = 171, - ZigClangStmt_OMPTargetParallelDirectiveClass = 172, - ZigClangStmt_OMPTargetParallelForDirectiveClass = 173, - ZigClangStmt_OMPTargetTeamsDirectiveClass = 174, - ZigClangStmt_OMPTargetUpdateDirectiveClass = 175, - ZigClangStmt_OMPTaskDirectiveClass = 176, - ZigClangStmt_OMPTaskgroupDirectiveClass = 177, - ZigClangStmt_OMPTaskwaitDirectiveClass = 178, - ZigClangStmt_OMPTaskyieldDirectiveClass = 179, - ZigClangStmt_OMPTeamsDirectiveClass = 180, - ZigClangStmt_ObjCAtCatchStmtClass = 181, - ZigClangStmt_ObjCAtFinallyStmtClass = 182, - ZigClangStmt_ObjCAtSynchronizedStmtClass = 183, - ZigClangStmt_ObjCAtThrowStmtClass = 184, - ZigClangStmt_ObjCAtTryStmtClass = 185, - ZigClangStmt_ObjCAutoreleasePoolStmtClass = 186, - ZigClangStmt_ObjCForCollectionStmtClass = 187, - ZigClangStmt_ReturnStmtClass = 188, - ZigClangStmt_SEHExceptStmtClass = 189, - ZigClangStmt_SEHFinallyStmtClass = 190, - ZigClangStmt_SEHLeaveStmtClass = 191, - ZigClangStmt_SEHTryStmtClass = 192, - ZigClangStmt_CaseStmtClass = 193, - ZigClangStmt_DefaultStmtClass = 194, - ZigClangStmt_SwitchStmtClass = 195, - ZigClangStmt_WhileStmtClass = 196, + +pub const ZigClangStmtClass = extern enum { + NoStmtClass = 0, + GCCAsmStmtClass = 1, + MSAsmStmtClass = 2, + AttributedStmtClass = 3, + BreakStmtClass = 4, + CXXCatchStmtClass = 5, + CXXForRangeStmtClass = 6, + CXXTryStmtClass = 7, + CapturedStmtClass = 8, + CompoundStmtClass = 9, + ContinueStmtClass = 10, + CoreturnStmtClass = 11, + CoroutineBodyStmtClass = 12, + DeclStmtClass = 13, + DoStmtClass = 14, + BinaryConditionalOperatorClass = 15, + ConditionalOperatorClass = 16, + AddrLabelExprClass = 17, + ArrayInitIndexExprClass = 18, + ArrayInitLoopExprClass = 19, + ArraySubscriptExprClass = 20, + ArrayTypeTraitExprClass = 21, + AsTypeExprClass = 22, + AtomicExprClass = 23, + BinaryOperatorClass = 24, + CompoundAssignOperatorClass = 25, + BlockExprClass = 26, + CXXBindTemporaryExprClass = 27, + CXXBoolLiteralExprClass = 28, + CXXConstructExprClass = 29, + CXXTemporaryObjectExprClass = 30, + CXXDefaultArgExprClass = 31, + CXXDefaultInitExprClass = 32, + CXXDeleteExprClass = 33, + CXXDependentScopeMemberExprClass = 34, + CXXFoldExprClass = 35, + CXXInheritedCtorInitExprClass = 36, + CXXNewExprClass = 37, + CXXNoexceptExprClass = 38, + CXXNullPtrLiteralExprClass = 39, + CXXPseudoDestructorExprClass = 40, + CXXScalarValueInitExprClass = 41, + CXXStdInitializerListExprClass = 42, + CXXThisExprClass = 43, + CXXThrowExprClass = 44, + CXXTypeidExprClass = 45, + CXXUnresolvedConstructExprClass = 46, + CXXUuidofExprClass = 47, + CallExprClass = 48, + CUDAKernelCallExprClass = 49, + CXXMemberCallExprClass = 50, + CXXOperatorCallExprClass = 51, + UserDefinedLiteralClass = 52, + CStyleCastExprClass = 53, + CXXFunctionalCastExprClass = 54, + CXXConstCastExprClass = 55, + CXXDynamicCastExprClass = 56, + CXXReinterpretCastExprClass = 57, + CXXStaticCastExprClass = 58, + ObjCBridgedCastExprClass = 59, + ImplicitCastExprClass = 60, + CharacterLiteralClass = 61, + ChooseExprClass = 62, + CompoundLiteralExprClass = 63, + ConvertVectorExprClass = 64, + CoawaitExprClass = 65, + CoyieldExprClass = 66, + DeclRefExprClass = 67, + DependentCoawaitExprClass = 68, + DependentScopeDeclRefExprClass = 69, + DesignatedInitExprClass = 70, + DesignatedInitUpdateExprClass = 71, + ExpressionTraitExprClass = 72, + ExtVectorElementExprClass = 73, + FixedPointLiteralClass = 74, + FloatingLiteralClass = 75, + ConstantExprClass = 76, + ExprWithCleanupsClass = 77, + FunctionParmPackExprClass = 78, + GNUNullExprClass = 79, + GenericSelectionExprClass = 80, + ImaginaryLiteralClass = 81, + ImplicitValueInitExprClass = 82, + InitListExprClass = 83, + IntegerLiteralClass = 84, + LambdaExprClass = 85, + MSPropertyRefExprClass = 86, + MSPropertySubscriptExprClass = 87, + MaterializeTemporaryExprClass = 88, + MemberExprClass = 89, + NoInitExprClass = 90, + OMPArraySectionExprClass = 91, + ObjCArrayLiteralClass = 92, + ObjCAvailabilityCheckExprClass = 93, + ObjCBoolLiteralExprClass = 94, + ObjCBoxedExprClass = 95, + ObjCDictionaryLiteralClass = 96, + ObjCEncodeExprClass = 97, + ObjCIndirectCopyRestoreExprClass = 98, + ObjCIsaExprClass = 99, + ObjCIvarRefExprClass = 100, + ObjCMessageExprClass = 101, + ObjCPropertyRefExprClass = 102, + ObjCProtocolExprClass = 103, + ObjCSelectorExprClass = 104, + ObjCStringLiteralClass = 105, + ObjCSubscriptRefExprClass = 106, + OffsetOfExprClass = 107, + OpaqueValueExprClass = 108, + UnresolvedLookupExprClass = 109, + UnresolvedMemberExprClass = 110, + PackExpansionExprClass = 111, + ParenExprClass = 112, + ParenListExprClass = 113, + PredefinedExprClass = 114, + PseudoObjectExprClass = 115, + ShuffleVectorExprClass = 116, + SizeOfPackExprClass = 117, + StmtExprClass = 118, + StringLiteralClass = 119, + SubstNonTypeTemplateParmExprClass = 120, + SubstNonTypeTemplateParmPackExprClass = 121, + TypeTraitExprClass = 122, + TypoExprClass = 123, + UnaryExprOrTypeTraitExprClass = 124, + UnaryOperatorClass = 125, + VAArgExprClass = 126, + ForStmtClass = 127, + GotoStmtClass = 128, + IfStmtClass = 129, + IndirectGotoStmtClass = 130, + LabelStmtClass = 131, + MSDependentExistsStmtClass = 132, + NullStmtClass = 133, + OMPAtomicDirectiveClass = 134, + OMPBarrierDirectiveClass = 135, + OMPCancelDirectiveClass = 136, + OMPCancellationPointDirectiveClass = 137, + OMPCriticalDirectiveClass = 138, + OMPFlushDirectiveClass = 139, + OMPDistributeDirectiveClass = 140, + OMPDistributeParallelForDirectiveClass = 141, + OMPDistributeParallelForSimdDirectiveClass = 142, + OMPDistributeSimdDirectiveClass = 143, + OMPForDirectiveClass = 144, + OMPForSimdDirectiveClass = 145, + OMPParallelForDirectiveClass = 146, + OMPParallelForSimdDirectiveClass = 147, + OMPSimdDirectiveClass = 148, + OMPTargetParallelForSimdDirectiveClass = 149, + OMPTargetSimdDirectiveClass = 150, + OMPTargetTeamsDistributeDirectiveClass = 151, + OMPTargetTeamsDistributeParallelForDirectiveClass = 152, + OMPTargetTeamsDistributeParallelForSimdDirectiveClass = 153, + OMPTargetTeamsDistributeSimdDirectiveClass = 154, + OMPTaskLoopDirectiveClass = 155, + OMPTaskLoopSimdDirectiveClass = 156, + OMPTeamsDistributeDirectiveClass = 157, + OMPTeamsDistributeParallelForDirectiveClass = 158, + OMPTeamsDistributeParallelForSimdDirectiveClass = 159, + OMPTeamsDistributeSimdDirectiveClass = 160, + OMPMasterDirectiveClass = 161, + OMPOrderedDirectiveClass = 162, + OMPParallelDirectiveClass = 163, + OMPParallelSectionsDirectiveClass = 164, + OMPSectionDirectiveClass = 165, + OMPSectionsDirectiveClass = 166, + OMPSingleDirectiveClass = 167, + OMPTargetDataDirectiveClass = 168, + OMPTargetDirectiveClass = 169, + OMPTargetEnterDataDirectiveClass = 170, + OMPTargetExitDataDirectiveClass = 171, + OMPTargetParallelDirectiveClass = 172, + OMPTargetParallelForDirectiveClass = 173, + OMPTargetTeamsDirectiveClass = 174, + OMPTargetUpdateDirectiveClass = 175, + OMPTaskDirectiveClass = 176, + OMPTaskgroupDirectiveClass = 177, + OMPTaskwaitDirectiveClass = 178, + OMPTaskyieldDirectiveClass = 179, + OMPTeamsDirectiveClass = 180, + ObjCAtCatchStmtClass = 181, + ObjCAtFinallyStmtClass = 182, + ObjCAtSynchronizedStmtClass = 183, + ObjCAtThrowStmtClass = 184, + ObjCAtTryStmtClass = 185, + ObjCAutoreleasePoolStmtClass = 186, + ObjCForCollectionStmtClass = 187, + ReturnStmtClass = 188, + SEHExceptStmtClass = 189, + SEHFinallyStmtClass = 190, + SEHLeaveStmtClass = 191, + SEHTryStmtClass = 192, + CaseStmtClass = 193, + DefaultStmtClass = 194, + SwitchStmtClass = 195, + WhileStmtClass = 196, }; -pub const ZigClangCK_Dependent = enum_ZigClangCK._Dependent; -pub const ZigClangCK_BitCast = enum_ZigClangCK._BitCast; -pub const ZigClangCK_LValueBitCast = enum_ZigClangCK._LValueBitCast; -pub const ZigClangCK_LValueToRValue = enum_ZigClangCK._LValueToRValue; -pub const ZigClangCK_NoOp = enum_ZigClangCK._NoOp; -pub const ZigClangCK_BaseToDerived = enum_ZigClangCK._BaseToDerived; -pub const ZigClangCK_DerivedToBase = enum_ZigClangCK._DerivedToBase; -pub const ZigClangCK_UncheckedDerivedToBase = enum_ZigClangCK._UncheckedDerivedToBase; -pub const ZigClangCK_Dynamic = enum_ZigClangCK._Dynamic; -pub const ZigClangCK_ToUnion = enum_ZigClangCK._ToUnion; -pub const ZigClangCK_ArrayToPointerDecay = enum_ZigClangCK._ArrayToPointerDecay; -pub const ZigClangCK_FunctionToPointerDecay = enum_ZigClangCK._FunctionToPointerDecay; -pub const ZigClangCK_NullToPointer = enum_ZigClangCK._NullToPointer; -pub const ZigClangCK_NullToMemberPointer = enum_ZigClangCK._NullToMemberPointer; -pub const ZigClangCK_BaseToDerivedMemberPointer = enum_ZigClangCK._BaseToDerivedMemberPointer; -pub const ZigClangCK_DerivedToBaseMemberPointer = enum_ZigClangCK._DerivedToBaseMemberPointer; -pub const ZigClangCK_MemberPointerToBoolean = enum_ZigClangCK._MemberPointerToBoolean; -pub const ZigClangCK_ReinterpretMemberPointer = enum_ZigClangCK._ReinterpretMemberPointer; -pub const ZigClangCK_UserDefinedConversion = enum_ZigClangCK._UserDefinedConversion; -pub const ZigClangCK_ConstructorConversion = enum_ZigClangCK._ConstructorConversion; -pub const ZigClangCK_IntegralToPointer = enum_ZigClangCK._IntegralToPointer; -pub const ZigClangCK_PointerToIntegral = enum_ZigClangCK._PointerToIntegral; -pub const ZigClangCK_PointerToBoolean = enum_ZigClangCK._PointerToBoolean; -pub const ZigClangCK_ToVoid = enum_ZigClangCK._ToVoid; -pub const ZigClangCK_VectorSplat = enum_ZigClangCK._VectorSplat; -pub const ZigClangCK_IntegralCast = enum_ZigClangCK._IntegralCast; -pub const ZigClangCK_IntegralToBoolean = enum_ZigClangCK._IntegralToBoolean; -pub const ZigClangCK_IntegralToFloating = enum_ZigClangCK._IntegralToFloating; -pub const ZigClangCK_FixedPointCast = enum_ZigClangCK._FixedPointCast; -pub const ZigClangCK_FixedPointToBoolean = enum_ZigClangCK._FixedPointToBoolean; -pub const ZigClangCK_FloatingToIntegral = enum_ZigClangCK._FloatingToIntegral; -pub const ZigClangCK_FloatingToBoolean = enum_ZigClangCK._FloatingToBoolean; -pub const ZigClangCK_BooleanToSignedIntegral = enum_ZigClangCK._BooleanToSignedIntegral; -pub const ZigClangCK_FloatingCast = enum_ZigClangCK._FloatingCast; -pub const ZigClangCK_CPointerToObjCPointerCast = enum_ZigClangCK._CPointerToObjCPointerCast; -pub const ZigClangCK_BlockPointerToObjCPointerCast = enum_ZigClangCK._BlockPointerToObjCPointerCast; -pub const ZigClangCK_AnyPointerToBlockPointerCast = enum_ZigClangCK._AnyPointerToBlockPointerCast; -pub const ZigClangCK_ObjCObjectLValueCast = enum_ZigClangCK._ObjCObjectLValueCast; -pub const ZigClangCK_FloatingRealToComplex = enum_ZigClangCK._FloatingRealToComplex; -pub const ZigClangCK_FloatingComplexToReal = enum_ZigClangCK._FloatingComplexToReal; -pub const ZigClangCK_FloatingComplexToBoolean = enum_ZigClangCK._FloatingComplexToBoolean; -pub const ZigClangCK_FloatingComplexCast = enum_ZigClangCK._FloatingComplexCast; -pub const ZigClangCK_FloatingComplexToIntegralComplex = enum_ZigClangCK._FloatingComplexToIntegralComplex; -pub const ZigClangCK_IntegralRealToComplex = enum_ZigClangCK._IntegralRealToComplex; -pub const ZigClangCK_IntegralComplexToReal = enum_ZigClangCK._IntegralComplexToReal; -pub const ZigClangCK_IntegralComplexToBoolean = enum_ZigClangCK._IntegralComplexToBoolean; -pub const ZigClangCK_IntegralComplexCast = enum_ZigClangCK._IntegralComplexCast; -pub const ZigClangCK_IntegralComplexToFloatingComplex = enum_ZigClangCK._IntegralComplexToFloatingComplex; -pub const ZigClangCK_ARCProduceObject = enum_ZigClangCK._ARCProduceObject; -pub const ZigClangCK_ARCConsumeObject = enum_ZigClangCK._ARCConsumeObject; -pub const ZigClangCK_ARCReclaimReturnedObject = enum_ZigClangCK._ARCReclaimReturnedObject; -pub const ZigClangCK_ARCExtendBlockObject = enum_ZigClangCK._ARCExtendBlockObject; -pub const ZigClangCK_AtomicToNonAtomic = enum_ZigClangCK._AtomicToNonAtomic; -pub const ZigClangCK_NonAtomicToAtomic = enum_ZigClangCK._NonAtomicToAtomic; -pub const ZigClangCK_CopyAndAutoreleaseBlockObject = enum_ZigClangCK._CopyAndAutoreleaseBlockObject; -pub const ZigClangCK_BuiltinFnToFnPtr = enum_ZigClangCK._BuiltinFnToFnPtr; -pub const ZigClangCK_ZeroToOCLOpaqueType = enum_ZigClangCK._ZeroToOCLOpaqueType; -pub const ZigClangCK_AddressSpaceConversion = enum_ZigClangCK._AddressSpaceConversion; -pub const ZigClangCK_IntToOCLSampler = enum_ZigClangCK._IntToOCLSampler; -pub const enum_ZigClangCK = extern enum { - _Dependent, - _BitCast, - _LValueBitCast, - _LValueToRValue, - _NoOp, - _BaseToDerived, - _DerivedToBase, - _UncheckedDerivedToBase, - _Dynamic, - _ToUnion, - _ArrayToPointerDecay, - _FunctionToPointerDecay, - _NullToPointer, - _NullToMemberPointer, - _BaseToDerivedMemberPointer, - _DerivedToBaseMemberPointer, - _MemberPointerToBoolean, - _ReinterpretMemberPointer, - _UserDefinedConversion, - _ConstructorConversion, - _IntegralToPointer, - _PointerToIntegral, - _PointerToBoolean, - _ToVoid, - _VectorSplat, - _IntegralCast, - _IntegralToBoolean, - _IntegralToFloating, - _FixedPointCast, - _FixedPointToBoolean, - _FloatingToIntegral, - _FloatingToBoolean, - _BooleanToSignedIntegral, - _FloatingCast, - _CPointerToObjCPointerCast, - _BlockPointerToObjCPointerCast, - _AnyPointerToBlockPointerCast, - _ObjCObjectLValueCast, - _FloatingRealToComplex, - _FloatingComplexToReal, - _FloatingComplexToBoolean, - _FloatingComplexCast, - _FloatingComplexToIntegralComplex, - _IntegralRealToComplex, - _IntegralComplexToReal, - _IntegralComplexToBoolean, - _IntegralComplexCast, - _IntegralComplexToFloatingComplex, - _ARCProduceObject, - _ARCConsumeObject, - _ARCReclaimReturnedObject, - _ARCExtendBlockObject, - _AtomicToNonAtomic, - _NonAtomicToAtomic, - _CopyAndAutoreleaseBlockObject, - _BuiltinFnToFnPtr, - _ZeroToOCLOpaqueType, - _AddressSpaceConversion, - _IntToOCLSampler, + +pub const ZigClangCK = extern enum { + Dependent, + BitCast, + LValueBitCast, + LValueToRValue, + NoOp, + BaseToDerived, + DerivedToBase, + UncheckedDerivedToBase, + Dynamic, + ToUnion, + ArrayToPointerDecay, + FunctionToPointerDecay, + NullToPointer, + NullToMemberPointer, + BaseToDerivedMemberPointer, + DerivedToBaseMemberPointer, + MemberPointerToBoolean, + ReinterpretMemberPointer, + UserDefinedConversion, + ConstructorConversion, + IntegralToPointer, + PointerToIntegral, + PointerToBoolean, + ToVoid, + VectorSplat, + IntegralCast, + IntegralToBoolean, + IntegralToFloating, + FixedPointCast, + FixedPointToBoolean, + FloatingToIntegral, + FloatingToBoolean, + BooleanToSignedIntegral, + FloatingCast, + CPointerToObjCPointerCast, + BlockPointerToObjCPointerCast, + AnyPointerToBlockPointerCast, + ObjCObjectLValueCast, + FloatingRealToComplex, + FloatingComplexToReal, + FloatingComplexToBoolean, + FloatingComplexCast, + FloatingComplexToIntegralComplex, + IntegralRealToComplex, + IntegralComplexToReal, + IntegralComplexToBoolean, + IntegralComplexCast, + IntegralComplexToFloatingComplex, + ARCProduceObject, + ARCConsumeObject, + ARCReclaimReturnedObject, + ARCExtendBlockObject, + AtomicToNonAtomic, + NonAtomicToAtomic, + CopyAndAutoreleaseBlockObject, + BuiltinFnToFnPtr, + ZeroToOCLOpaqueType, + AddressSpaceConversion, + IntToOCLSampler, }; -pub const ZigClangAPValueUninitialized = enum_ZigClangAPValueKind.ZigClangAPValueUninitialized; -pub const ZigClangAPValueInt = enum_ZigClangAPValueKind.ZigClangAPValueInt; -pub const ZigClangAPValueFloat = enum_ZigClangAPValueKind.ZigClangAPValueFloat; -pub const ZigClangAPValueComplexInt = enum_ZigClangAPValueKind.ZigClangAPValueComplexInt; -pub const ZigClangAPValueComplexFloat = enum_ZigClangAPValueKind.ZigClangAPValueComplexFloat; -pub const ZigClangAPValueLValue = enum_ZigClangAPValueKind.ZigClangAPValueLValue; -pub const ZigClangAPValueVector = enum_ZigClangAPValueKind.ZigClangAPValueVector; -pub const ZigClangAPValueArray = enum_ZigClangAPValueKind.ZigClangAPValueArray; -pub const ZigClangAPValueStruct = enum_ZigClangAPValueKind.ZigClangAPValueStruct; -pub const ZigClangAPValueUnion = enum_ZigClangAPValueKind.ZigClangAPValueUnion; -pub const ZigClangAPValueMemberPointer = enum_ZigClangAPValueKind.ZigClangAPValueMemberPointer; -pub const ZigClangAPValueAddrLabelDiff = enum_ZigClangAPValueKind.ZigClangAPValueAddrLabelDiff; -pub const enum_ZigClangAPValueKind = extern enum { - ZigClangAPValueUninitialized, - ZigClangAPValueInt, - ZigClangAPValueFloat, - ZigClangAPValueComplexInt, - ZigClangAPValueComplexFloat, - ZigClangAPValueLValue, - ZigClangAPValueVector, - ZigClangAPValueArray, - ZigClangAPValueStruct, - ZigClangAPValueUnion, - ZigClangAPValueMemberPointer, - ZigClangAPValueAddrLabelDiff, + +pub const ZigClangAPValueKind = extern enum { + Uninitialized, + Int, + Float, + ComplexInt, + ComplexFloat, + LValue, + Vector, + Array, + Struct, + Union, + MemberPointer, + AddrLabelDiff, }; + pub extern fn ZigClangSourceManager_getSpellingLoc(arg0: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) struct_ZigClangSourceLocation; pub extern fn ZigClangSourceManager_getFilename(self: *const struct_ZigClangSourceManager, SpellingLoc: struct_ZigClangSourceLocation) ?[*]const u8; pub extern fn ZigClangSourceManager_getSpellingLineNumber(arg0: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) c_uint; @@ -840,16 +486,16 @@ pub extern fn ZigClangQualType_eq(arg0: struct_ZigClangQualType, arg1: struct_Zi pub extern fn ZigClangQualType_isConstQualified(arg0: struct_ZigClangQualType) bool; pub extern fn ZigClangQualType_isVolatileQualified(arg0: struct_ZigClangQualType) bool; pub extern fn ZigClangQualType_isRestrictQualified(arg0: struct_ZigClangQualType) bool; -pub extern fn ZigClangType_getTypeClass(self: ?*const struct_ZigClangType) enum_ZigClangTypeClass; +pub extern fn ZigClangType_getTypeClass(self: ?*const struct_ZigClangType) ZigClangTypeClass; pub extern fn ZigClangType_isVoidType(self: ?*const struct_ZigClangType) bool; pub extern fn ZigClangType_getTypeClassName(self: *const struct_ZigClangType) [*]const u8; pub extern fn ZigClangStmt_getBeginLoc(self: ?*const struct_ZigClangStmt) struct_ZigClangSourceLocation; -pub extern fn ZigClangStmt_getStmtClass(self: ?*const struct_ZigClangStmt) enum_ZigClangStmtClass; +pub extern fn ZigClangStmt_getStmtClass(self: ?*const struct_ZigClangStmt) ZigClangStmtClass; pub extern fn ZigClangStmt_classof_Expr(self: ?*const struct_ZigClangStmt) bool; -pub extern fn ZigClangExpr_getStmtClass(self: ?*const struct_ZigClangExpr) enum_ZigClangStmtClass; +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 ZigClangAPValue_getKind(self: ?*const struct_ZigClangAPValue) enum_ZigClangAPValueKind; +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_getArrayInitializedElt(self: ?*const struct_ZigClangAPValue, i: c_uint) ?*const struct_ZigClangAPValue; @@ -867,6 +513,11 @@ pub extern fn ZigClangASTUnit_delete(arg0: ?*struct_ZigClangASTUnit) void; pub extern fn ZigClangFunctionDecl_getType(self: *const struct_ZigClangFunctionDecl) struct_ZigClangQualType; pub extern fn ZigClangFunctionDecl_getLocation(self: *const struct_ZigClangFunctionDecl) struct_ZigClangSourceLocation; +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 const ZigClangSourceLocation = struct_ZigClangSourceLocation; pub const ZigClangQualType = struct_ZigClangQualType; @@ -942,12 +593,6 @@ pub const ZigClangUnaryOperator = struct_ZigClangUnaryOperator; pub const ZigClangValueDecl = struct_ZigClangValueDecl; pub const ZigClangVarDecl = struct_ZigClangVarDecl; pub const ZigClangWhileStmt = struct_ZigClangWhileStmt; -pub const ZigClangBO = enum_ZigClangBO; -pub const ZigClangUO = enum_ZigClangUO; -pub const ZigClangTypeClass = enum_ZigClangTypeClass; -pub const ZigClangStmtClass = enum_ZigClangStmtClass; -pub const ZigClangCK = enum_ZigClangCK; -pub const ZigClangAPValueKind = enum_ZigClangAPValueKind; pub const struct_ZigClangSourceLocation = extern struct { ID: c_uint, @@ -1060,3 +705,143 @@ pub const ZigClangDeclKind = extern enum { pub const struct_ZigClangQualType = extern struct { ptr: ?*c_void, }; + +pub const ZigClangBuiltinTypeKind = extern enum { + OCLImage1dRO, + OCLImage1dArrayRO, + OCLImage1dBufferRO, + OCLImage2dRO, + OCLImage2dArrayRO, + OCLImage2dDepthRO, + OCLImage2dArrayDepthRO, + OCLImage2dMSAARO, + OCLImage2dArrayMSAARO, + OCLImage2dMSAADepthRO, + OCLImage2dArrayMSAADepthRO, + OCLImage3dRO, + OCLImage1dWO, + OCLImage1dArrayWO, + OCLImage1dBufferWO, + OCLImage2dWO, + OCLImage2dArrayWO, + OCLImage2dDepthWO, + OCLImage2dArrayDepthWO, + OCLImage2dMSAAWO, + OCLImage2dArrayMSAAWO, + OCLImage2dMSAADepthWO, + OCLImage2dArrayMSAADepthWO, + OCLImage3dWO, + OCLImage1dRW, + OCLImage1dArrayRW, + OCLImage1dBufferRW, + OCLImage2dRW, + OCLImage2dArrayRW, + OCLImage2dDepthRW, + OCLImage2dArrayDepthRW, + OCLImage2dMSAARW, + OCLImage2dArrayMSAARW, + OCLImage2dMSAADepthRW, + OCLImage2dArrayMSAADepthRW, + OCLImage3dRW, + OCLIntelSubgroupAVCMcePayload, + OCLIntelSubgroupAVCImePayload, + OCLIntelSubgroupAVCRefPayload, + OCLIntelSubgroupAVCSicPayload, + OCLIntelSubgroupAVCMceResult, + OCLIntelSubgroupAVCImeResult, + OCLIntelSubgroupAVCRefResult, + OCLIntelSubgroupAVCSicResult, + OCLIntelSubgroupAVCImeResultSingleRefStreamout, + OCLIntelSubgroupAVCImeResultDualRefStreamout, + OCLIntelSubgroupAVCImeSingleRefStreamin, + OCLIntelSubgroupAVCImeDualRefStreamin, + Void, + Bool, + Char_U, + UChar, + WChar_U, + Char8, + Char16, + Char32, + UShort, + UInt, + ULong, + ULongLong, + UInt128, + Char_S, + SChar, + WChar_S, + Short, + Int, + Long, + LongLong, + Int128, + ShortAccum, + Accum, + LongAccum, + UShortAccum, + UAccum, + ULongAccum, + ShortFract, + Fract, + LongFract, + UShortFract, + UFract, + ULongFract, + SatShortAccum, + SatAccum, + SatLongAccum, + SatUShortAccum, + SatUAccum, + SatULongAccum, + SatShortFract, + SatFract, + SatLongFract, + SatUShortFract, + SatUFract, + SatULongFract, + Half, + Float, + Double, + LongDouble, + Float16, + Float128, + NullPtr, + ObjCId, + ObjCClass, + ObjCSel, + OCLSampler, + OCLEvent, + OCLClkEvent, + OCLQueue, + OCLReserveID, + Dependent, + Overload, + BoundMember, + PseudoObject, + UnknownAny, + BuiltinFn, + ARCUnbridgedCast, + OMPArraySection, +}; + +pub const ZigClangCallingConv = extern enum { + C, + X86StdCall, + X86FastCall, + X86ThisCall, + X86VectorCall, + X86Pascal, + Win64, + X86_64SysV, + X86RegCall, + AAPCS, + AAPCS_VFP, + IntelOclBicc, + SpirFunction, + OpenCLKernel, + Swift, + PreserveMost, + PreserveAll, + AArch64VectorCall, +}; diff --git a/src-self-hosted/translate_c.zig b/src-self-hosted/translate_c.zig index 7b349764fb..d565d1b88c 100644 --- a/src-self-hosted/translate_c.zig +++ b/src-self-hosted/translate_c.zig @@ -11,6 +11,15 @@ pub const Mode = enum { translate, }; +// TODO merge with Type.Fn.CallingConvention +pub const CallingConvention = enum { + auto, + c, + cold, + naked, + stdcall, +}; + pub const ClangErrMsg = Stage2ErrorMsg; pub const Error = error{ @@ -165,9 +174,95 @@ fn transQualType(c: *Context, qt: ZigClangQualType, source_loc: ZigClangSourceLo } fn transType(c: *Context, ty: *const ZigClangType, source_loc: ZigClangSourceLocation) !*ast.Node { - const type_name = c.str(ZigClangType_getTypeClassName(ty)); - try emitWarning(c, source_loc, "unsupported type: '{}'", type_name); - return error.UnsupportedType; + switch (ZigClangType_getTypeClass(ty)) { + .Builtin => { + const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty); + switch (ZigClangBuiltinType_getKind(builtin_ty)) { + else => { + try emitWarning(c, source_loc, "unsupported builtin type"); + return error.UnsupportedType; + }, + } + }, + .FunctionProto => { + const fn_ty = @ptrCast(*const ZigClangFunctionType, ty); + const cc = switch (ZigClangFunctionType_getCallConv(fn_ty)) { + .C => CallingConvention.c, + .X86StdCall => CallingConvention.stdcall, + .X86FastCall => { + try emitWarning(c, source_loc, "unsupported calling convention: x86 fastcall"); + return error.UnsupportedType; + }, + .X86ThisCall => { + try emitWarning(c, source_loc, "unsupported calling convention: x86 thiscall"); + return error.UnsupportedType; + }, + .X86VectorCall => { + try emitWarning(c, source_loc, "unsupported calling convention: x86 vectorcall"); + return error.UnsupportedType; + }, + .X86Pascal => { + try emitWarning(c, source_loc, "unsupported calling convention: x86 pascal"); + return error.UnsupportedType; + }, + .Win64 => { + try emitWarning(c, source_loc, "unsupported calling convention: win64"); + return error.UnsupportedType; + }, + .X86_64SysV => { + try emitWarning(c, source_loc, "unsupported calling convention: x86 64sysv"); + return error.UnsupportedType; + }, + .X86RegCall => { + try emitWarning(c, source_loc, "unsupported calling convention: x86 reg"); + return error.UnsupportedType; + }, + .AAPCS => { + try emitWarning(c, source_loc, "unsupported calling convention: aapcs"); + return error.UnsupportedType; + }, + .AAPCS_VFP => { + try emitWarning(c, source_loc, "unsupported calling convention: aapcs-vfp"); + return error.UnsupportedType; + }, + .IntelOclBicc => { + try emitWarning(c, source_loc, "unsupported calling convention: intel_ocl_bicc"); + return error.UnsupportedType; + }, + .SpirFunction => { + try emitWarning(c, source_loc, "unsupported calling convention: SPIR function"); + return error.UnsupportedType; + }, + .OpenCLKernel => { + try emitWarning(c, source_loc, "unsupported calling convention: OpenCLKernel"); + return error.UnsupportedType; + }, + .Swift => { + try emitWarning(c, source_loc, "unsupported calling convention: Swift"); + return error.UnsupportedType; + }, + .PreserveMost => { + try emitWarning(c, source_loc, "unsupported calling convention: PreserveMost"); + return error.UnsupportedType; + }, + .PreserveAll => { + try emitWarning(c, source_loc, "unsupported calling convention: PreserveAll"); + return error.UnsupportedType; + }, + .AArch64VectorCall => { + try emitWarning(c, source_loc, "unsupported calling convention: AArch64VectorCall"); + return error.UnsupportedType; + }, + }; + try emitWarning(c, source_loc, "TODO: implement transType for FunctionProto"); + return error.UnsupportedType; + }, + else => { + const type_name = c.str(ZigClangType_getTypeClassName(ty)); + try emitWarning(c, source_loc, "unsupported type: '{}'", type_name); + return error.UnsupportedType; + }, + } } fn emitWarning(c: *Context, loc: ZigClangSourceLocation, comptime format: []const u8, args: ...) !void { diff --git a/src/translate_c.cpp b/src/translate_c.cpp index 4b6609027c..0415972430 100644 --- a/src/translate_c.cpp +++ b/src/translate_c.cpp @@ -1061,72 +1061,72 @@ static AstNode *trans_type(Context *c, const ZigClangType *ty, ZigClangSourceLoc case ZigClangType_FunctionProto: case ZigClangType_FunctionNoProto: { - const clang::FunctionType *fn_ty = reinterpret_cast(ty); + const ZigClangFunctionType *fn_ty = reinterpret_cast(ty); AstNode *proto_node = trans_create_node(c, NodeTypeFnProto); - switch (fn_ty->getCallConv()) { - case clang::CC_C: // __attribute__((cdecl)) + switch (ZigClangFunctionType_getCallConv(fn_ty)) { + case ZigClangCallingConv_C: // __attribute__((cdecl)) proto_node->data.fn_proto.cc = CallingConventionC; proto_node->data.fn_proto.is_extern = true; break; - case clang::CC_X86StdCall: // __attribute__((stdcall)) + case ZigClangCallingConv_X86StdCall: // __attribute__((stdcall)) proto_node->data.fn_proto.cc = CallingConventionStdcall; break; - case clang::CC_X86FastCall: // __attribute__((fastcall)) + case ZigClangCallingConv_X86FastCall: // __attribute__((fastcall)) emit_warning(c, source_loc, "unsupported calling convention: x86 fastcall"); return nullptr; - case clang::CC_X86ThisCall: // __attribute__((thiscall)) + case ZigClangCallingConv_X86ThisCall: // __attribute__((thiscall)) emit_warning(c, source_loc, "unsupported calling convention: x86 thiscall"); return nullptr; - case clang::CC_X86VectorCall: // __attribute__((vectorcall)) + case ZigClangCallingConv_X86VectorCall: // __attribute__((vectorcall)) emit_warning(c, source_loc, "unsupported calling convention: x86 vectorcall"); return nullptr; - case clang::CC_X86Pascal: // __attribute__((pascal)) + case ZigClangCallingConv_X86Pascal: // __attribute__((pascal)) emit_warning(c, source_loc, "unsupported calling convention: x86 pascal"); return nullptr; - case clang::CC_Win64: // __attribute__((ms_abi)) + case ZigClangCallingConv_Win64: // __attribute__((ms_abi)) emit_warning(c, source_loc, "unsupported calling convention: win64"); return nullptr; - case clang::CC_X86_64SysV: // __attribute__((sysv_abi)) + case ZigClangCallingConv_X86_64SysV: // __attribute__((sysv_abi)) emit_warning(c, source_loc, "unsupported calling convention: x86 64sysv"); return nullptr; - case clang::CC_X86RegCall: + case ZigClangCallingConv_X86RegCall: emit_warning(c, source_loc, "unsupported calling convention: x86 reg"); return nullptr; - case clang::CC_AAPCS: // __attribute__((pcs("aapcs"))) + case ZigClangCallingConv_AAPCS: // __attribute__((pcs("aapcs"))) emit_warning(c, source_loc, "unsupported calling convention: aapcs"); return nullptr; - case clang::CC_AAPCS_VFP: // __attribute__((pcs("aapcs-vfp"))) + case ZigClangCallingConv_AAPCS_VFP: // __attribute__((pcs("aapcs-vfp"))) emit_warning(c, source_loc, "unsupported calling convention: aapcs-vfp"); return nullptr; - case clang::CC_IntelOclBicc: // __attribute__((intel_ocl_bicc)) + case ZigClangCallingConv_IntelOclBicc: // __attribute__((intel_ocl_bicc)) emit_warning(c, source_loc, "unsupported calling convention: intel_ocl_bicc"); return nullptr; - case clang::CC_SpirFunction: // default for OpenCL functions on SPIR target + case ZigClangCallingConv_SpirFunction: // default for OpenCL functions on SPIR target emit_warning(c, source_loc, "unsupported calling convention: SPIR function"); return nullptr; - case clang::CC_OpenCLKernel: + case ZigClangCallingConv_OpenCLKernel: emit_warning(c, source_loc, "unsupported calling convention: OpenCLKernel"); return nullptr; - case clang::CC_Swift: + case ZigClangCallingConv_Swift: emit_warning(c, source_loc, "unsupported calling convention: Swift"); return nullptr; - case clang::CC_PreserveMost: + case ZigClangCallingConv_PreserveMost: emit_warning(c, source_loc, "unsupported calling convention: PreserveMost"); return nullptr; - case clang::CC_PreserveAll: + case ZigClangCallingConv_PreserveAll: emit_warning(c, source_loc, "unsupported calling convention: PreserveAll"); return nullptr; - case clang::CC_AArch64VectorCall: + case ZigClangCallingConv_AArch64VectorCall: emit_warning(c, source_loc, "unsupported calling convention: AArch64VectorCall"); return nullptr; } - if (fn_ty->getNoReturnAttr()) { + if (ZigClangFunctionType_getNoReturnAttr(fn_ty)) { proto_node->data.fn_proto.return_type = trans_create_node_symbol_str(c, "noreturn"); } else { - proto_node->data.fn_proto.return_type = trans_qual_type(c, bitcast(fn_ty->getReturnType()), - source_loc); + proto_node->data.fn_proto.return_type = trans_qual_type(c, + ZigClangFunctionType_getReturnType(fn_ty), source_loc); if (proto_node->data.fn_proto.return_type == nullptr) { emit_warning(c, source_loc, "unsupported function proto return type"); return nullptr; diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp index 0231d03418..079cfd96e3 100644 --- a/src/zig_clang.cpp +++ b/src/zig_clang.cpp @@ -1193,6 +1193,49 @@ static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeBuiltinFn == clang::B static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeARCUnbridgedCast == clang::BuiltinType::ARCUnbridgedCast, ""); static_assert((clang::BuiltinType::Kind)ZigClangBuiltinTypeOMPArraySection == clang::BuiltinType::OMPArraySection, ""); +void ZigClang_detect_enum_CallingConv(clang::CallingConv x) { + switch (x) { + case clang::CC_C: + case clang::CC_X86StdCall: + case clang::CC_X86FastCall: + case clang::CC_X86ThisCall: + case clang::CC_X86VectorCall: + case clang::CC_X86Pascal: + case clang::CC_Win64: + case clang::CC_X86_64SysV: + case clang::CC_X86RegCall: + case clang::CC_AAPCS: + case clang::CC_AAPCS_VFP: + case clang::CC_IntelOclBicc: + case clang::CC_SpirFunction: + case clang::CC_OpenCLKernel: + case clang::CC_Swift: + case clang::CC_PreserveMost: + case clang::CC_PreserveAll: + case clang::CC_AArch64VectorCall: + break; + } +} + +static_assert((clang::CallingConv)ZigClangCallingConv_C == clang::CC_C, ""); +static_assert((clang::CallingConv)ZigClangCallingConv_X86StdCall == clang::CC_X86StdCall, ""); +static_assert((clang::CallingConv)ZigClangCallingConv_X86FastCall == clang::CC_X86FastCall, ""); +static_assert((clang::CallingConv)ZigClangCallingConv_X86ThisCall == clang::CC_X86ThisCall, ""); +static_assert((clang::CallingConv)ZigClangCallingConv_X86VectorCall == clang::CC_X86VectorCall, ""); +static_assert((clang::CallingConv)ZigClangCallingConv_X86Pascal == clang::CC_X86Pascal, ""); +static_assert((clang::CallingConv)ZigClangCallingConv_Win64 == clang::CC_Win64, ""); +static_assert((clang::CallingConv)ZigClangCallingConv_X86_64SysV == clang::CC_X86_64SysV, ""); +static_assert((clang::CallingConv)ZigClangCallingConv_X86RegCall == clang::CC_X86RegCall, ""); +static_assert((clang::CallingConv)ZigClangCallingConv_AAPCS == clang::CC_AAPCS, ""); +static_assert((clang::CallingConv)ZigClangCallingConv_AAPCS_VFP == clang::CC_AAPCS_VFP, ""); +static_assert((clang::CallingConv)ZigClangCallingConv_IntelOclBicc == clang::CC_IntelOclBicc, ""); +static_assert((clang::CallingConv)ZigClangCallingConv_SpirFunction == clang::CC_SpirFunction, ""); +static_assert((clang::CallingConv)ZigClangCallingConv_OpenCLKernel == clang::CC_OpenCLKernel, ""); +static_assert((clang::CallingConv)ZigClangCallingConv_Swift == clang::CC_Swift, ""); +static_assert((clang::CallingConv)ZigClangCallingConv_PreserveMost == clang::CC_PreserveMost, ""); +static_assert((clang::CallingConv)ZigClangCallingConv_PreserveAll == clang::CC_PreserveAll, ""); +static_assert((clang::CallingConv)ZigClangCallingConv_AArch64VectorCall == clang::CC_AArch64VectorCall, ""); + static_assert(sizeof(ZigClangSourceLocation) == sizeof(clang::SourceLocation), ""); static ZigClangSourceLocation bitcast(clang::SourceLocation src) { @@ -1693,3 +1736,18 @@ enum ZigClangBuiltinTypeKind ZigClangBuiltinType_getKind(const struct ZigClangBu auto casted = reinterpret_cast(self); return (ZigClangBuiltinTypeKind)casted->getKind(); } + +bool ZigClangFunctionType_getNoReturnAttr(const struct ZigClangFunctionType *self) { + auto casted = reinterpret_cast(self); + return casted->getNoReturnAttr(); +} + +enum ZigClangCallingConv ZigClangFunctionType_getCallConv(const struct ZigClangFunctionType *self) { + auto casted = reinterpret_cast(self); + return (ZigClangCallingConv)casted->getCallConv(); +} + +struct ZigClangQualType ZigClangFunctionType_getReturnType(const struct ZigClangFunctionType *self) { + auto casted = reinterpret_cast(self); + return bitcast(casted->getReturnType()); +} diff --git a/src/zig_clang.h b/src/zig_clang.h index e4289e736c..0c40e6dbce 100644 --- a/src/zig_clang.h +++ b/src/zig_clang.h @@ -101,6 +101,7 @@ struct ZigClangUnaryOperator; struct ZigClangValueDecl; struct ZigClangVarDecl; struct ZigClangWhileStmt; +struct ZigClangFunctionType; enum ZigClangBO { ZigClangBO_PtrMemD, @@ -678,6 +679,27 @@ enum ZigClangBuiltinTypeKind { ZigClangBuiltinTypeOMPArraySection, }; +enum ZigClangCallingConv { + ZigClangCallingConv_C, // __attribute__((cdecl)) + ZigClangCallingConv_X86StdCall, // __attribute__((stdcall)) + ZigClangCallingConv_X86FastCall, // __attribute__((fastcall)) + ZigClangCallingConv_X86ThisCall, // __attribute__((thiscall)) + ZigClangCallingConv_X86VectorCall, // __attribute__((vectorcall)) + ZigClangCallingConv_X86Pascal, // __attribute__((pascal)) + ZigClangCallingConv_Win64, // __attribute__((ms_abi)) + ZigClangCallingConv_X86_64SysV, // __attribute__((sysv_abi)) + ZigClangCallingConv_X86RegCall, // __attribute__((regcall)) + ZigClangCallingConv_AAPCS, // __attribute__((pcs("aapcs"))) + ZigClangCallingConv_AAPCS_VFP, // __attribute__((pcs("aapcs-vfp"))) + ZigClangCallingConv_IntelOclBicc, // __attribute__((intel_ocl_bicc)) + ZigClangCallingConv_SpirFunction, // default for OpenCL functions on SPIR target + ZigClangCallingConv_OpenCLKernel, // inferred for OpenCL kernels + ZigClangCallingConv_Swift, // __attribute__((swiftcall)) + ZigClangCallingConv_PreserveMost, // __attribute__((preserve_most)) + ZigClangCallingConv_PreserveAll, // __attribute__((preserve_all)) + ZigClangCallingConv_AArch64VectorCall, // __attribute__((aarch64_vector_pcs)) +}; + ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangSourceManager_getSpellingLoc(const struct ZigClangSourceManager *, struct ZigClangSourceLocation Loc); ZIG_EXTERN_C const char *ZigClangSourceManager_getFilename(const struct ZigClangSourceManager *, @@ -776,4 +798,8 @@ ZIG_EXTERN_C const struct ZigClangExpr *ZigClangAPValueLValueBase_dyn_cast_Expr( ZIG_EXTERN_C enum ZigClangBuiltinTypeKind ZigClangBuiltinType_getKind(const struct ZigClangBuiltinType *self); +ZIG_EXTERN_C bool ZigClangFunctionType_getNoReturnAttr(const struct ZigClangFunctionType *self); +ZIG_EXTERN_C enum ZigClangCallingConv ZigClangFunctionType_getCallConv(const struct ZigClangFunctionType *self); +ZIG_EXTERN_C struct ZigClangQualType ZigClangFunctionType_getReturnType(const struct ZigClangFunctionType *self); + #endif -- cgit v1.2.3 From 1c0223899cfe6c1c73f186330f6eff2cc9e78579 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Fri, 10 May 2019 01:23:22 -0400 Subject: translate-c: progress on self-hosted function prototypes See #1964 --- src-self-hosted/clang.zig | 4 + src-self-hosted/translate_c.zig | 262 ++++++++++++++++++++++++++++------------ src/translate_c.cpp | 8 +- src/zig_clang.cpp | 17 +++ src/zig_clang.h | 3 + 5 files changed, 211 insertions(+), 83 deletions(-) (limited to 'src/zig_clang.cpp') diff --git a/src-self-hosted/clang.zig b/src-self-hosted/clang.zig index 8333363d8d..3e2346f681 100644 --- a/src-self-hosted/clang.zig +++ b/src-self-hosted/clang.zig @@ -519,6 +519,10 @@ pub extern fn ZigClangFunctionType_getNoReturnAttr(self: *const ZigClangFunction 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 const ZigClangSourceLocation = struct_ZigClangSourceLocation; pub const ZigClangQualType = struct_ZigClangQualType; pub const ZigClangAPValueLValueBase = struct_ZigClangAPValueLValueBase; diff --git a/src-self-hosted/translate_c.zig b/src-self-hosted/translate_c.zig index d565d1b88c..84e45b9dc4 100644 --- a/src-self-hosted/translate_c.zig +++ b/src-self-hosted/translate_c.zig @@ -110,7 +110,7 @@ pub fn translate( return context.err; } - try appendToken(&context, .Eof, ""); + _ = try appendToken(&context, .Eof, ""); tree.source = source_buffer.toOwnedSlice(); return tree; } @@ -149,7 +149,7 @@ fn declVisitor(c: *Context, decl: *const ZigClangDecl) Error!void { } fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { - const fn_name = c.str(ZigClangDecl_getName_bytes_begin(@ptrCast(*const ZigClangDecl, fn_decl))); + const fn_name = try c.str(ZigClangDecl_getName_bytes_begin(@ptrCast(*const ZigClangDecl, fn_decl))); // TODO The C++ code has this: //if (get_global(c, fn_name)) { @@ -160,28 +160,49 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { const fn_decl_loc = ZigClangFunctionDecl_getLocation(fn_decl); const proto_node = transQualType(c, ZigClangFunctionDecl_getType(fn_decl), fn_decl_loc) catch |e| switch (e) { error.UnsupportedType => { - try emitWarning(c, fn_decl_loc, "unable to resolve prototype of function '{}'", fn_name); + try failDecl(c, fn_decl_loc, fn_name, "unable to resolve prototype of function"); return; }, else => return e, }; + const semi_tok = try appendToken(c, .Semicolon, ";"); - try emitWarning(c, fn_decl_loc, "TODO implement translate-c for function decls"); + try emitWarning(c, fn_decl_loc, "TODO implement more translate-c for function decls"); + + try c.tree.root_node.decls.push(proto_node); } fn transQualType(c: *Context, qt: ZigClangQualType, source_loc: ZigClangSourceLocation) !*ast.Node { return transType(c, ZigClangQualType_getTypePtr(qt), source_loc); } +const RestorePoint = struct { + context: *Context, + token_index: ast.TokenIndex, + src_buf_index: usize, + + fn activate(self: RestorePoint) void { + self.context.tree.tokens.shrink(self.token_index); + self.context.source_buffer.shrink(self.src_buf_index); + } +}; + +fn makeRestorePoint(c: *Context) RestorePoint { + return RestorePoint{ + .context = c, + .token_index = c.tree.tokens.len, + .src_buf_index = c.source_buffer.len(), + }; +} + fn transType(c: *Context, ty: *const ZigClangType, source_loc: ZigClangSourceLocation) !*ast.Node { + const rp = makeRestorePoint(c); + switch (ZigClangType_getTypeClass(ty)) { .Builtin => { const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty); switch (ZigClangBuiltinType_getKind(builtin_ty)) { - else => { - try emitWarning(c, source_loc, "unsupported builtin type"); - return error.UnsupportedType; - }, + else => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported builtin type"), } }, .FunctionProto => { @@ -189,87 +210,157 @@ fn transType(c: *Context, ty: *const ZigClangType, source_loc: ZigClangSourceLoc const cc = switch (ZigClangFunctionType_getCallConv(fn_ty)) { .C => CallingConvention.c, .X86StdCall => CallingConvention.stdcall, - .X86FastCall => { - try emitWarning(c, source_loc, "unsupported calling convention: x86 fastcall"); - return error.UnsupportedType; - }, - .X86ThisCall => { - try emitWarning(c, source_loc, "unsupported calling convention: x86 thiscall"); - return error.UnsupportedType; - }, - .X86VectorCall => { - try emitWarning(c, source_loc, "unsupported calling convention: x86 vectorcall"); - return error.UnsupportedType; - }, - .X86Pascal => { - try emitWarning(c, source_loc, "unsupported calling convention: x86 pascal"); - return error.UnsupportedType; - }, - .Win64 => { - try emitWarning(c, source_loc, "unsupported calling convention: win64"); - return error.UnsupportedType; - }, - .X86_64SysV => { - try emitWarning(c, source_loc, "unsupported calling convention: x86 64sysv"); - return error.UnsupportedType; - }, - .X86RegCall => { - try emitWarning(c, source_loc, "unsupported calling convention: x86 reg"); - return error.UnsupportedType; - }, - .AAPCS => { - try emitWarning(c, source_loc, "unsupported calling convention: aapcs"); - return error.UnsupportedType; - }, - .AAPCS_VFP => { - try emitWarning(c, source_loc, "unsupported calling convention: aapcs-vfp"); - return error.UnsupportedType; - }, - .IntelOclBicc => { - try emitWarning(c, source_loc, "unsupported calling convention: intel_ocl_bicc"); - return error.UnsupportedType; - }, - .SpirFunction => { - try emitWarning(c, source_loc, "unsupported calling convention: SPIR function"); - return error.UnsupportedType; - }, - .OpenCLKernel => { - try emitWarning(c, source_loc, "unsupported calling convention: OpenCLKernel"); - return error.UnsupportedType; - }, - .Swift => { - try emitWarning(c, source_loc, "unsupported calling convention: Swift"); - return error.UnsupportedType; - }, - .PreserveMost => { - try emitWarning(c, source_loc, "unsupported calling convention: PreserveMost"); - return error.UnsupportedType; - }, - .PreserveAll => { - try emitWarning(c, source_loc, "unsupported calling convention: PreserveAll"); - return error.UnsupportedType; - }, - .AArch64VectorCall => { - try emitWarning(c, source_loc, "unsupported calling convention: AArch64VectorCall"); - return error.UnsupportedType; - }, + .X86FastCall => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: x86 fastcall"), + .X86ThisCall => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: x86 thiscall"), + .X86VectorCall => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: x86 vectorcall"), + .X86Pascal => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: x86 pascal"), + .Win64 => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: win64"), + .X86_64SysV => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: x86 64sysv"), + .X86RegCall => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: x86 reg"), + .AAPCS => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: aapcs"), + .AAPCS_VFP => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: aapcs-vfp"), + .IntelOclBicc => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: intel_ocl_bicc"), + .SpirFunction => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: SPIR function"), + .OpenCLKernel => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: OpenCLKernel"), + .Swift => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: Swift"), + .PreserveMost => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: PreserveMost"), + .PreserveAll => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: PreserveAll"), + .AArch64VectorCall => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: AArch64VectorCall"), + }; + + const fn_proto_ty = @ptrCast(*const ZigClangFunctionProtoType, ty); + const is_var_args = ZigClangFunctionProtoType_isVariadic(fn_proto_ty); + const param_count: usize = ZigClangFunctionProtoType_getNumParams(fn_proto_ty); + var i: usize = 0; + while (i < param_count) : (i += 1) { + return revertAndWarn(rp, error.UnsupportedType, source_loc, "TODO: implement parameters for FunctionProto in transType"); + } + // TODO check for always_inline attribute + // TODO check for align attribute + + // extern fn (...) T + const cc_tok = if (cc == .stdcall) try appendToken(c, .Keyword_stdcallcc, "stdcallcc") else null; + const extern_tok = if (cc == .c) try appendToken(c, .Keyword_extern, "extern") else null; + const fn_tok = try appendToken(c, .Keyword_fn, "fn"); + const lparen_tok = try appendToken(c, .LParen, "("); + const var_args_tok = if (is_var_args) try appendToken(c, .Ellipsis3, "...") else null; + const rparen_tok = try appendToken(c, .RParen, ")"); + + const return_type_node = blk: { + if (ZigClangFunctionType_getNoReturnAttr(fn_ty)) { + break :blk try appendIdentifier(c, "noreturn"); + } else { + return revertAndWarn(rp, error.UnsupportedType, source_loc, "TODO: non-noreturn FunctionProto return type"); + //proto_node->data.fn_proto.return_type = trans_qual_type(c, + // ZigClangFunctionType_getReturnType(fn_ty), source_loc); + //if (proto_node->data.fn_proto.return_type == nullptr) { + // emit_warning(c, source_loc, "unsupported function proto return type"); + // return nullptr; + //} + //// convert c_void to actual void (only for return type) + //// we do want to look at the AstNode instead of ZigClangQualType, because + //// if they do something like: + //// typedef Foo void; + //// void foo(void) -> Foo; + //// we want to keep the return type AST node. + //if (is_c_void_type(proto_node->data.fn_proto.return_type)) { + // proto_node->data.fn_proto.return_type = trans_create_node_symbol_str(c, "void"); + //} + } + }; + + const fn_proto = try c.a().create(ast.Node.FnProto); + fn_proto.* = ast.Node.FnProto{ + .base = ast.Node{ .id = ast.Node.Id.FnProto }, + .doc_comments = null, + .visib_token = null, + .fn_token = fn_tok, + .name_token = null, + .params = ast.Node.FnProto.ParamList.init(c.a()), + .return_type = ast.Node.FnProto.ReturnType{ .Explicit = return_type_node }, + .var_args_token = var_args_tok, + .extern_export_inline_token = extern_tok, + .cc_token = cc_tok, + .async_attr = null, + .body_node = null, + .lib_name = null, + .align_expr = null, + .section_expr = null, }; - try emitWarning(c, source_loc, "TODO: implement transType for FunctionProto"); - return error.UnsupportedType; + return &fn_proto.base; }, + else => { const type_name = c.str(ZigClangType_getTypeClassName(ty)); - try emitWarning(c, source_loc, "unsupported type: '{}'", type_name); - return error.UnsupportedType; + return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported type: '{}'", type_name); }, } } +fn revertAndWarn( + restore_point: RestorePoint, + err: var, + source_loc: ZigClangSourceLocation, + comptime format: []const u8, + args: ..., +) (@typeOf(err) || error{OutOfMemory}) { + restore_point.activate(); + try emitWarning(restore_point.context, source_loc, format, args); + return err; +} + fn emitWarning(c: *Context, loc: ZigClangSourceLocation, comptime format: []const u8, args: ...) !void { - try appendToken(c, .LineComment, "// {}: warning: " ++ format, c.locStr(loc), args); + _ = try appendToken(c, .LineComment, "// {}: warning: " ++ format, c.locStr(loc), args); +} + +fn failDecl(c: *Context, loc: ZigClangSourceLocation, name: []const u8, comptime format: []const u8, args: ...) !void { + // const name = @compileError(msg); + const const_tok = try appendToken(c, .Keyword_const, "const"); + const name_tok = try appendToken(c, .Identifier, "{}", name); + const eq_tok = try appendToken(c, .Equal, "="); + const builtin_tok = try appendToken(c, .Builtin, "@compileError"); + const lparen_tok = try appendToken(c, .LParen, "("); + const msg_tok = try appendToken(c, .StringLiteral, "\"" ++ format ++ "\"", args); + const rparen_tok = try appendToken(c, .RParen, ")"); + const semi_tok = try appendToken(c, .Semicolon, ";"); + + const msg_node = try c.a().create(ast.Node.StringLiteral); + msg_node.* = ast.Node.StringLiteral{ + .base = ast.Node{ .id = ast.Node.Id.StringLiteral }, + .token = msg_tok, + }; + + const call_node = try c.a().create(ast.Node.BuiltinCall); + call_node.* = ast.Node.BuiltinCall{ + .base = ast.Node{ .id = ast.Node.Id.BuiltinCall }, + .builtin_token = builtin_tok, + .params = ast.Node.BuiltinCall.ParamList.init(c.a()), + .rparen_token = rparen_tok, + }; + try call_node.params.push(&msg_node.base); + + const var_decl_node = try c.a().create(ast.Node.VarDecl); + var_decl_node.* = ast.Node.VarDecl{ + .base = ast.Node{ .id = ast.Node.Id.VarDecl }, + .doc_comments = null, + .visib_token = null, + .thread_local_token = null, + .name_token = name_tok, + .eq_token = eq_tok, + .mut_token = const_tok, + .comptime_token = null, + .extern_export_token = null, + .lib_name = null, + .type_node = null, + .align_node = null, + .section_node = null, + .init_node = &call_node.base, + .semicolon_token = semi_tok, + }; + try c.tree.root_node.decls.push(&var_decl_node.base); } -fn appendToken(c: *Context, token_id: Token.Id, comptime format: []const u8, args: ...) !void { +fn appendToken(c: *Context, token_id: Token.Id, comptime format: []const u8, args: ...) !ast.TokenIndex { const S = struct { fn callback(context: *Context, bytes: []const u8) Error!void { return context.source_buffer.append(bytes); @@ -280,8 +371,9 @@ fn appendToken(c: *Context, token_id: Token.Id, comptime format: []const u8, arg try std.fmt.format(c, Error, S.callback, format, args); const end_index = c.source_buffer.len(); + const token_index = c.tree.tokens.len; const new_token = try c.tree.tokens.addOne(); - errdefer c.tree.tokens.shrink(c.tree.tokens.len - 1); + errdefer c.tree.tokens.shrink(token_index); new_token.* = Token{ .id = token_id, @@ -289,6 +381,18 @@ fn appendToken(c: *Context, token_id: Token.Id, comptime format: []const u8, arg .end = end_index, }; try c.source_buffer.appendByte('\n'); + + return token_index; +} + +fn appendIdentifier(c: *Context, name: []const u8) !*ast.Node { + const token_index = try appendToken(c, .Identifier, "{}", name); + const identifier = try c.a().create(ast.Node.Identifier); + identifier.* = ast.Node.Identifier{ + .base = ast.Node{ .id = ast.Node.Id.Identifier }, + .token = token_index, + }; + return &identifier.base; } pub fn freeErrors(errors: []ClangErrMsg) void { diff --git a/src/translate_c.cpp b/src/translate_c.cpp index 0415972430..64bf995cdd 100644 --- a/src/translate_c.cpp +++ b/src/translate_c.cpp @@ -1152,13 +1152,13 @@ static AstNode *trans_type(Context *c, const ZigClangType *ty, ZigClangSourceLoc return proto_node; } - const clang::FunctionProtoType *fn_proto_ty = reinterpret_cast(ty); + const ZigClangFunctionProtoType *fn_proto_ty = reinterpret_cast(ty); - proto_node->data.fn_proto.is_var_args = fn_proto_ty->isVariadic(); - size_t param_count = fn_proto_ty->getNumParams(); + proto_node->data.fn_proto.is_var_args = ZigClangFunctionProtoType_isVariadic(fn_proto_ty); + size_t param_count = ZigClangFunctionProtoType_getNumParams(fn_proto_ty); for (size_t i = 0; i < param_count; i += 1) { - ZigClangQualType qt = bitcast(fn_proto_ty->getParamType(i)); + ZigClangQualType qt = ZigClangFunctionProtoType_getParamType(fn_proto_ty, i); AstNode *param_type_node = trans_qual_type(c, qt, source_loc); if (param_type_node == nullptr) { diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp index 079cfd96e3..b1457fd817 100644 --- a/src/zig_clang.cpp +++ b/src/zig_clang.cpp @@ -1751,3 +1751,20 @@ struct ZigClangQualType ZigClangFunctionType_getReturnType(const struct ZigClang auto casted = reinterpret_cast(self); return bitcast(casted->getReturnType()); } + +bool ZigClangFunctionProtoType_isVariadic(const struct ZigClangFunctionProtoType *self) { + auto casted = reinterpret_cast(self); + return casted->isVariadic(); +} + +unsigned ZigClangFunctionProtoType_getNumParams(const struct ZigClangFunctionProtoType *self) { + auto casted = reinterpret_cast(self); + return casted->getNumParams(); +} + +struct ZigClangQualType ZigClangFunctionProtoType_getParamType(const struct ZigClangFunctionProtoType *self, + unsigned index) +{ + auto casted = reinterpret_cast(self); + return bitcast(casted->getParamType(index)); +} diff --git a/src/zig_clang.h b/src/zig_clang.h index 0c40e6dbce..6a67ec85c1 100644 --- a/src/zig_clang.h +++ b/src/zig_clang.h @@ -802,4 +802,7 @@ ZIG_EXTERN_C bool ZigClangFunctionType_getNoReturnAttr(const struct ZigClangFunc ZIG_EXTERN_C enum ZigClangCallingConv ZigClangFunctionType_getCallConv(const struct ZigClangFunctionType *self); ZIG_EXTERN_C struct ZigClangQualType ZigClangFunctionType_getReturnType(const struct ZigClangFunctionType *self); +ZIG_EXTERN_C bool ZigClangFunctionProtoType_isVariadic(const struct ZigClangFunctionProtoType *self); +ZIG_EXTERN_C unsigned ZigClangFunctionProtoType_getNumParams(const struct ZigClangFunctionProtoType *self); +ZIG_EXTERN_C struct ZigClangQualType ZigClangFunctionProtoType_getParamType(const struct ZigClangFunctionProtoType *self, unsigned i); #endif -- cgit v1.2.3 From a6f7a9ce2b008ff66ab32c8162d64dd77ffe952f Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Fri, 10 May 2019 16:03:54 -0400 Subject: translate-c: we have our first test of self-hosted See #1964 --- src-self-hosted/clang.zig | 15 +- src-self-hosted/translate_c.zig | 316 ++++++++++++++++++++++++++-------------- src/translate_c.cpp | 18 +-- src/zig_clang.cpp | 43 ++++++ src/zig_clang.h | 17 ++- test/tests.zig | 28 +++- test/translate_c.zig | 6 + 7 files changed, 320 insertions(+), 123 deletions(-) (limited to 'src/zig_clang.cpp') diff --git a/src-self-hosted/clang.zig b/src-self-hosted/clang.zig index 3e2346f681..dd9e49b05b 100644 --- a/src-self-hosted/clang.zig +++ b/src-self-hosted/clang.zig @@ -56,7 +56,6 @@ pub const struct_ZigClangSkipFunctionBodiesScope = @OpaqueType(); pub const struct_ZigClangSourceManager = @OpaqueType(); pub const struct_ZigClangSourceRange = @OpaqueType(); pub const struct_ZigClangStmt = @OpaqueType(); -pub const struct_ZigClangStorageClass = @OpaqueType(); pub const struct_ZigClangStringLiteral = @OpaqueType(); pub const struct_ZigClangStringRef = @OpaqueType(); pub const struct_ZigClangSwitchStmt = @OpaqueType(); @@ -513,6 +512,10 @@ pub extern fn ZigClangASTUnit_delete(arg0: ?*struct_ZigClangASTUnit) void; pub extern fn ZigClangFunctionDecl_getType(self: *const struct_ZigClangFunctionDecl) struct_ZigClangQualType; pub extern fn ZigClangFunctionDecl_getLocation(self: *const struct_ZigClangFunctionDecl) struct_ZigClangSourceLocation; +pub extern fn ZigClangFunctionDecl_hasBody(self: *const struct_ZigClangFunctionDecl) bool; +pub extern fn ZigClangFunctionDecl_getStorageClass(self: *const struct_ZigClangFunctionDecl) ZigClangStorageClass; +pub extern fn ZigClangFunctionDecl_getParamDecl(self: *const struct_ZigClangFunctionDecl, i: c_uint) *const struct_ZigClangParmVarDecl; + pub extern fn ZigClangBuiltinType_getKind(self: *const struct_ZigClangBuiltinType) ZigClangBuiltinTypeKind; pub extern fn ZigClangFunctionType_getNoReturnAttr(self: *const ZigClangFunctionType) bool; @@ -584,7 +587,6 @@ pub const ZigClangSkipFunctionBodiesScope = struct_ZigClangSkipFunctionBodiesSco pub const ZigClangSourceManager = struct_ZigClangSourceManager; pub const ZigClangSourceRange = struct_ZigClangSourceRange; pub const ZigClangStmt = struct_ZigClangStmt; -pub const ZigClangStorageClass = struct_ZigClangStorageClass; pub const ZigClangStringLiteral = struct_ZigClangStringLiteral; pub const ZigClangStringRef = struct_ZigClangStringRef; pub const ZigClangSwitchStmt = struct_ZigClangSwitchStmt; @@ -849,3 +851,12 @@ pub const ZigClangCallingConv = extern enum { PreserveAll, AArch64VectorCall, }; + +pub const ZigClangStorageClass = extern enum { + None, + Extern, + Static, + PrivateExtern, + Auto, + Register, +}; diff --git a/src-self-hosted/translate_c.zig b/src-self-hosted/translate_c.zig index 84e45b9dc4..9642212de1 100644 --- a/src-self-hosted/translate_c.zig +++ b/src-self-hosted/translate_c.zig @@ -2,6 +2,7 @@ // and stage2. Currently the only way it is used is with `zig translate-c-2`. const std = @import("std"); +const builtin = @import("builtin"); const ast = std.zig.ast; const Token = std.zig.Token; use @import("clang.zig"); @@ -12,13 +13,7 @@ pub const Mode = enum { }; // TODO merge with Type.Fn.CallingConvention -pub const CallingConvention = enum { - auto, - c, - cold, - naked, - stdcall, -}; +const CallingConvention = builtin.TypeInfo.CallingConvention; pub const ClangErrMsg = Stage2ErrorMsg; @@ -27,11 +22,64 @@ pub const Error = error{ UnsupportedType, }; +const DeclTable = std.HashMap(usize, void, addrHash, addrEql); + +fn addrHash(x: usize) u32 { + switch (@typeInfo(usize).Int.bits) { + 32 => return x, + // pointers are usually aligned so we ignore the bits that are probably all 0 anyway + // usually the larger bits of addr space are unused so we just chop em off + 64 => return @truncate(u32, x >> 4), + else => @compileError("unreachable"), + } +} + +fn addrEql(a: usize, b: usize) bool { + return a == b; +} + +const Scope = struct { + id: Id, + parent: ?*Scope, + + const Id = enum { + Switch, + Var, + Block, + Root, + While, + }; + const Switch = struct { + base: Scope, + }; + + const Var = struct { + base: Scope, + c_name: []const u8, + zig_name: []const u8, + }; + + const Block = struct { + base: Scope, + }; + + const Root = struct { + base: Scope, + }; + + const While = struct { + base: Scope, + }; +}; + const Context = struct { tree: *ast.Tree, source_buffer: *std.Buffer, err: Error, source_manager: *ZigClangSourceManager, + decl_table: DeclTable, + global_scope: *Scope.Root, + mode: Mode, fn a(c: *Context) *std.mem.Allocator { return &c.tree.arena_allocator.allocator; @@ -76,7 +124,7 @@ pub fn translate( var tree_arena = std.heap.ArenaAllocator.init(backing_allocator); errdefer tree_arena.deinit(); - const arena = &tree_arena.allocator; + var arena = &tree_arena.allocator; const root_node = try arena.create(ast.Node.Root); root_node.* = ast.Node.Root{ @@ -96,14 +144,24 @@ pub fn translate( .errors = ast.Tree.ErrorList.init(arena), }; tree.arena_allocator = tree_arena; + arena = &tree.arena_allocator.allocator; - var source_buffer = try std.Buffer.initSize(&tree.arena_allocator.allocator, 0); + var source_buffer = try std.Buffer.initSize(arena, 0); var context = Context{ .tree = tree, .source_buffer = &source_buffer, .source_manager = ZigClangASTUnit_getSourceManager(ast_unit), .err = undefined, + .decl_table = DeclTable.init(arena), + .global_scope = try arena.create(Scope.Root), + .mode = mode, + }; + context.global_scope.* = Scope.Root{ + .base = Scope{ + .id = Scope.Id.Root, + .parent = null, + }, }; if (!ZigClangASTUnit_visitLocalTopLevelDecls(ast_unit, &context, declVisitorC)) { @@ -149,27 +207,39 @@ fn declVisitor(c: *Context, decl: *const ZigClangDecl) Error!void { } fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { - const fn_name = try c.str(ZigClangDecl_getName_bytes_begin(@ptrCast(*const ZigClangDecl, fn_decl))); - - // TODO The C++ code has this: - //if (get_global(c, fn_name)) { - // // we already saw this function - // return; - //} + if (try c.decl_table.put(@ptrToInt(fn_decl), {})) |_| return; // Avoid processing this decl twice + const fn_name = try c.str(ZigClangDecl_getName_bytes_begin(@ptrCast(*const ZigClangDecl, fn_decl))); const fn_decl_loc = ZigClangFunctionDecl_getLocation(fn_decl); - const proto_node = transQualType(c, ZigClangFunctionDecl_getType(fn_decl), fn_decl_loc) catch |e| switch (e) { - error.UnsupportedType => { - try failDecl(c, fn_decl_loc, fn_name, "unable to resolve prototype of function"); - return; + const fn_qt = ZigClangFunctionDecl_getType(fn_decl); + const fn_type = ZigClangQualType_getTypePtr(fn_qt); + const proto_node = switch (ZigClangType_getTypeClass(fn_type)) { + .FunctionProto => transFnProto( + c, + @ptrCast(*const ZigClangFunctionProtoType, fn_type), + fn_decl_loc, + fn_decl, + fn_name, + ) catch |err| switch (err) { + error.UnsupportedType => { + return failDecl(c, fn_decl_loc, fn_name, "unable to resolve prototype of function"); + }, + else => return err, }, - else => return e, + .FunctionNoProto => return failDecl(c, fn_decl_loc, fn_name, "TODO support functions with no prototype"), + else => unreachable, }; - const semi_tok = try appendToken(c, .Semicolon, ";"); - try emitWarning(c, fn_decl_loc, "TODO implement more translate-c for function decls"); + if (!ZigClangFunctionDecl_hasBody(fn_decl)) { + const semi_tok = try appendToken(c, .Semicolon, ";"); + return addTopLevelDecl(c, fn_name, &proto_node.base); + } + + try emitWarning(c, fn_decl_loc, "TODO implement function body translation"); +} - try c.tree.root_node.decls.push(proto_node); +fn addTopLevelDecl(c: *Context, name: []const u8, decl_node: *ast.Node) !void { + try c.tree.root_node.decls.push(decl_node); } fn transQualType(c: *Context, qt: ZigClangQualType, source_loc: ZigClangSourceLocation) !*ast.Node { @@ -205,91 +275,7 @@ fn transType(c: *Context, ty: *const ZigClangType, source_loc: ZigClangSourceLoc else => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported builtin type"), } }, - .FunctionProto => { - const fn_ty = @ptrCast(*const ZigClangFunctionType, ty); - const cc = switch (ZigClangFunctionType_getCallConv(fn_ty)) { - .C => CallingConvention.c, - .X86StdCall => CallingConvention.stdcall, - .X86FastCall => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: x86 fastcall"), - .X86ThisCall => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: x86 thiscall"), - .X86VectorCall => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: x86 vectorcall"), - .X86Pascal => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: x86 pascal"), - .Win64 => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: win64"), - .X86_64SysV => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: x86 64sysv"), - .X86RegCall => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: x86 reg"), - .AAPCS => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: aapcs"), - .AAPCS_VFP => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: aapcs-vfp"), - .IntelOclBicc => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: intel_ocl_bicc"), - .SpirFunction => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: SPIR function"), - .OpenCLKernel => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: OpenCLKernel"), - .Swift => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: Swift"), - .PreserveMost => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: PreserveMost"), - .PreserveAll => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: PreserveAll"), - .AArch64VectorCall => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: AArch64VectorCall"), - }; - - const fn_proto_ty = @ptrCast(*const ZigClangFunctionProtoType, ty); - const is_var_args = ZigClangFunctionProtoType_isVariadic(fn_proto_ty); - const param_count: usize = ZigClangFunctionProtoType_getNumParams(fn_proto_ty); - var i: usize = 0; - while (i < param_count) : (i += 1) { - return revertAndWarn(rp, error.UnsupportedType, source_loc, "TODO: implement parameters for FunctionProto in transType"); - } - // TODO check for always_inline attribute - // TODO check for align attribute - - // extern fn (...) T - const cc_tok = if (cc == .stdcall) try appendToken(c, .Keyword_stdcallcc, "stdcallcc") else null; - const extern_tok = if (cc == .c) try appendToken(c, .Keyword_extern, "extern") else null; - const fn_tok = try appendToken(c, .Keyword_fn, "fn"); - const lparen_tok = try appendToken(c, .LParen, "("); - const var_args_tok = if (is_var_args) try appendToken(c, .Ellipsis3, "...") else null; - const rparen_tok = try appendToken(c, .RParen, ")"); - - const return_type_node = blk: { - if (ZigClangFunctionType_getNoReturnAttr(fn_ty)) { - break :blk try appendIdentifier(c, "noreturn"); - } else { - return revertAndWarn(rp, error.UnsupportedType, source_loc, "TODO: non-noreturn FunctionProto return type"); - //proto_node->data.fn_proto.return_type = trans_qual_type(c, - // ZigClangFunctionType_getReturnType(fn_ty), source_loc); - //if (proto_node->data.fn_proto.return_type == nullptr) { - // emit_warning(c, source_loc, "unsupported function proto return type"); - // return nullptr; - //} - //// convert c_void to actual void (only for return type) - //// we do want to look at the AstNode instead of ZigClangQualType, because - //// if they do something like: - //// typedef Foo void; - //// void foo(void) -> Foo; - //// we want to keep the return type AST node. - //if (is_c_void_type(proto_node->data.fn_proto.return_type)) { - // proto_node->data.fn_proto.return_type = trans_create_node_symbol_str(c, "void"); - //} - } - }; - - const fn_proto = try c.a().create(ast.Node.FnProto); - fn_proto.* = ast.Node.FnProto{ - .base = ast.Node{ .id = ast.Node.Id.FnProto }, - .doc_comments = null, - .visib_token = null, - .fn_token = fn_tok, - .name_token = null, - .params = ast.Node.FnProto.ParamList.init(c.a()), - .return_type = ast.Node.FnProto.ReturnType{ .Explicit = return_type_node }, - .var_args_token = var_args_tok, - .extern_export_inline_token = extern_tok, - .cc_token = cc_tok, - .async_attr = null, - .body_node = null, - .lib_name = null, - .align_expr = null, - .section_expr = null, - }; - return &fn_proto.base; - }, - + .FunctionProto => return transFnProto(c, @ptrCast(*const ZigClangFunctionType, ty), source_loc, null, false), else => { const type_name = c.str(ZigClangType_getTypeClassName(ty)); return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported type: '{}'", type_name); @@ -297,6 +283,118 @@ fn transType(c: *Context, ty: *const ZigClangType, source_loc: ZigClangSourceLoc } } +fn transFnProto( + c: *Context, + fn_proto_ty: *const ZigClangFunctionProtoType, + source_loc: ZigClangSourceLocation, + opt_fn_decl: ?*const ZigClangFunctionDecl, + fn_name: ?[]const u8, +) !*ast.Node.FnProto { + const fn_ty = @ptrCast(*const ZigClangFunctionType, fn_proto_ty); + const rp = makeRestorePoint(c); + const cc = switch (ZigClangFunctionType_getCallConv(fn_ty)) { + .C => CallingConvention.C, + .X86StdCall => CallingConvention.Stdcall, + .X86FastCall => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: x86 fastcall"), + .X86ThisCall => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: x86 thiscall"), + .X86VectorCall => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: x86 vectorcall"), + .X86Pascal => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: x86 pascal"), + .Win64 => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: win64"), + .X86_64SysV => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: x86 64sysv"), + .X86RegCall => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: x86 reg"), + .AAPCS => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: aapcs"), + .AAPCS_VFP => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: aapcs-vfp"), + .IntelOclBicc => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: intel_ocl_bicc"), + .SpirFunction => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: SPIR function"), + .OpenCLKernel => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: OpenCLKernel"), + .Swift => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: Swift"), + .PreserveMost => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: PreserveMost"), + .PreserveAll => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: PreserveAll"), + .AArch64VectorCall => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported calling convention: AArch64VectorCall"), + }; + + const is_var_args = ZigClangFunctionProtoType_isVariadic(fn_proto_ty); + const param_count: usize = ZigClangFunctionProtoType_getNumParams(fn_proto_ty); + var i: usize = 0; + while (i < param_count) : (i += 1) { + return revertAndWarn(rp, error.UnsupportedType, source_loc, "TODO: implement parameters for FunctionProto in transType"); + } + // TODO check for always_inline attribute + // TODO check for align attribute + + // extern fn name(...) T + const cc_tok = if (cc == .Stdcall) try appendToken(c, .Keyword_stdcallcc, "stdcallcc") else null; + const is_export = exp: { + const fn_decl = opt_fn_decl orelse break :exp false; + const has_body = ZigClangFunctionDecl_hasBody(fn_decl); + const storage_class = ZigClangFunctionDecl_getStorageClass(fn_decl); + break :exp switch (storage_class) { + .None => switch (c.mode) { + .import => false, + .translate => has_body, + }, + .Extern, .Static => false, + .PrivateExtern => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported storage class: private extern"), + .Auto => unreachable, // Not legal on functions + .Register => unreachable, // Not legal on functions + }; + }; + const extern_export_inline_tok = if (is_export) + try appendToken(c, .Keyword_export, "export") + else if (cc == .C) + try appendToken(c, .Keyword_extern, "extern") + else + null; + const fn_tok = try appendToken(c, .Keyword_fn, "fn"); + const name_tok = if (fn_name) |n| try appendToken(c, .Identifier, "{}", n) else null; + const lparen_tok = try appendToken(c, .LParen, "("); + const var_args_tok = if (is_var_args) try appendToken(c, .Ellipsis3, "...") else null; + const rparen_tok = try appendToken(c, .RParen, ")"); + + const return_type_node = blk: { + if (ZigClangFunctionType_getNoReturnAttr(fn_ty)) { + break :blk try appendIdentifier(c, "noreturn"); + } else { + return revertAndWarn(rp, error.UnsupportedType, source_loc, "TODO: non-noreturn FunctionProto return type"); + //proto_node->data.fn_proto.return_type = trans_qual_type(c, + // ZigClangFunctionType_getReturnType(fn_ty), source_loc); + //if (proto_node->data.fn_proto.return_type == nullptr) { + // emit_warning(c, source_loc, "unsupported function proto return type"); + // return nullptr; + //} + //// convert c_void to actual void (only for return type) + //// we do want to look at the AstNode instead of ZigClangQualType, because + //// if they do something like: + //// typedef Foo void; + //// void foo(void) -> Foo; + //// we want to keep the return type AST node. + //if (is_c_void_type(proto_node->data.fn_proto.return_type)) { + // proto_node->data.fn_proto.return_type = trans_create_node_symbol_str(c, "void"); + //} + } + }; + + const fn_proto = try c.a().create(ast.Node.FnProto); + fn_proto.* = ast.Node.FnProto{ + .base = ast.Node{ .id = ast.Node.Id.FnProto }, + .doc_comments = null, + .visib_token = null, + .fn_token = fn_tok, + .name_token = name_tok, + .params = ast.Node.FnProto.ParamList.init(c.a()), + .return_type = ast.Node.FnProto.ReturnType{ .Explicit = return_type_node }, + .var_args_token = var_args_tok, + .extern_export_inline_token = extern_export_inline_tok, + .cc_token = cc_tok, + .async_attr = null, + .body_node = null, + .lib_name = null, + .align_expr = null, + .section_expr = null, + }; + return fn_proto; +} + fn revertAndWarn( restore_point: RestorePoint, err: var, diff --git a/src/translate_c.cpp b/src/translate_c.cpp index 64bf995cdd..71c0376130 100644 --- a/src/translate_c.cpp +++ b/src/translate_c.cpp @@ -4038,15 +4038,15 @@ static void visit_fn_decl(Context *c, const ZigClangFunctionDecl *fn_decl) { } proto_node->data.fn_proto.name = fn_name; - proto_node->data.fn_proto.is_extern = !((const clang::FunctionDecl*)fn_decl)->hasBody(); + proto_node->data.fn_proto.is_extern = !ZigClangFunctionDecl_hasBody(fn_decl); - clang::StorageClass sc = ((const clang::FunctionDecl*)fn_decl)->getStorageClass(); - if (sc == clang::SC_None) { + ZigClangStorageClass sc = ZigClangFunctionDecl_getStorageClass(fn_decl); + if (sc == ZigClangStorageClass_None) { proto_node->data.fn_proto.visib_mod = c->visib_mod; - proto_node->data.fn_proto.is_export = ((const clang::FunctionDecl*)fn_decl)->hasBody() ? c->want_export : false; - } else if (sc == clang::SC_Extern || sc == clang::SC_Static) { + proto_node->data.fn_proto.is_export = ZigClangFunctionDecl_hasBody(fn_decl) ? c->want_export : false; + } else if (sc == ZigClangStorageClass_Extern || sc == ZigClangStorageClass_Static) { proto_node->data.fn_proto.visib_mod = c->visib_mod; - } else if (sc == clang::SC_PrivateExtern) { + } else if (sc == ZigClangStorageClass_PrivateExtern) { emit_warning(c, ZigClangFunctionDecl_getLocation(fn_decl), "unsupported storage class: private extern"); return; } else { @@ -4058,7 +4058,7 @@ static void visit_fn_decl(Context *c, const ZigClangFunctionDecl *fn_decl) { for (size_t i = 0; i < proto_node->data.fn_proto.params.length; i += 1) { AstNode *param_node = proto_node->data.fn_proto.params.at(i); - const clang::ParmVarDecl *param = ((const clang::FunctionDecl*)fn_decl)->getParamDecl(i); + const ZigClangParmVarDecl *param = ZigClangFunctionDecl_getParamDecl(fn_decl, i); const char *name = ZigClangDecl_getName_bytes_begin((const ZigClangDecl *)param); Buf *proto_param_name; @@ -4077,7 +4077,7 @@ static void visit_fn_decl(Context *c, const ZigClangFunctionDecl *fn_decl) { param_node->data.param_decl.name = scope_var->zig_name; } - if (!((const clang::FunctionDecl*)fn_decl)->hasBody()) { + if (!ZigClangFunctionDecl_hasBody(fn_decl)) { // just a prototype add_top_level_decl(c, proto_node->data.fn_proto.name, proto_node); return; @@ -4085,7 +4085,7 @@ static void visit_fn_decl(Context *c, const ZigClangFunctionDecl *fn_decl) { // actual function definition with body c->ptr_params.clear(); - const ZigClangStmt *body = bitcast(((const clang::FunctionDecl*)fn_decl)->getBody()); + const ZigClangStmt *body = ZigClangFunctionDecl_getBody(fn_decl); AstNode *actual_body_node; TransScope *result_scope = trans_stmt(c, scope, body, &actual_body_node); if (result_scope == nullptr) { diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp index b1457fd817..25e309a63e 100644 --- a/src/zig_clang.cpp +++ b/src/zig_clang.cpp @@ -1236,6 +1236,25 @@ static_assert((clang::CallingConv)ZigClangCallingConv_PreserveMost == clang::CC_ static_assert((clang::CallingConv)ZigClangCallingConv_PreserveAll == clang::CC_PreserveAll, ""); static_assert((clang::CallingConv)ZigClangCallingConv_AArch64VectorCall == clang::CC_AArch64VectorCall, ""); +void ZigClang_detect_enum_StorageClass(clang::StorageClass x) { + switch (x) { + case clang::SC_None: + case clang::SC_Extern: + case clang::SC_Static: + case clang::SC_PrivateExtern: + case clang::SC_Auto: + case clang::SC_Register: + break; + } +} + +static_assert((clang::StorageClass)ZigClangStorageClass_None == clang::SC_None, ""); +static_assert((clang::StorageClass)ZigClangStorageClass_Extern == clang::SC_Extern, ""); +static_assert((clang::StorageClass)ZigClangStorageClass_Static == clang::SC_Static, ""); +static_assert((clang::StorageClass)ZigClangStorageClass_PrivateExtern == clang::SC_PrivateExtern, ""); +static_assert((clang::StorageClass)ZigClangStorageClass_Auto == clang::SC_Auto, ""); +static_assert((clang::StorageClass)ZigClangStorageClass_Register == clang::SC_Register, ""); + static_assert(sizeof(ZigClangSourceLocation) == sizeof(clang::SourceLocation), ""); static ZigClangSourceLocation bitcast(clang::SourceLocation src) { @@ -1434,6 +1453,30 @@ struct ZigClangSourceLocation ZigClangFunctionDecl_getLocation(const struct ZigC return bitcast(casted->getLocation()); } +bool ZigClangFunctionDecl_hasBody(const struct ZigClangFunctionDecl *self) { + auto casted = reinterpret_cast(self); + return casted->hasBody(); +} + +enum ZigClangStorageClass ZigClangFunctionDecl_getStorageClass(const struct ZigClangFunctionDecl *self) { + auto casted = reinterpret_cast(self); + return (ZigClangStorageClass)casted->getStorageClass(); +} + +const struct ZigClangParmVarDecl *ZigClangFunctionDecl_getParamDecl(const struct ZigClangFunctionDecl *self, + unsigned i) +{ + auto casted = reinterpret_cast(self); + const clang::ParmVarDecl *parm_var_decl = casted->getParamDecl(i); + return reinterpret_cast(parm_var_decl); +} + +const struct ZigClangStmt *ZigClangFunctionDecl_getBody(const struct ZigClangFunctionDecl *self) { + auto casted = reinterpret_cast(self); + const clang::Stmt *stmt = casted->getBody(); + return reinterpret_cast(stmt); +} + const ZigClangTypedefNameDecl *ZigClangTypedefType_getDecl(const ZigClangTypedefType *self) { auto casted = reinterpret_cast(self); const clang::TypedefNameDecl *name_decl = casted->getDecl(); diff --git a/src/zig_clang.h b/src/zig_clang.h index 6a67ec85c1..8e0d2f9f98 100644 --- a/src/zig_clang.h +++ b/src/zig_clang.h @@ -88,7 +88,6 @@ struct ZigClangSkipFunctionBodiesScope; struct ZigClangSourceManager; struct ZigClangSourceRange; struct ZigClangStmt; -struct ZigClangStorageClass; struct ZigClangStringLiteral; struct ZigClangStringRef; struct ZigClangSwitchStmt; @@ -700,6 +699,18 @@ enum ZigClangCallingConv { ZigClangCallingConv_AArch64VectorCall, // __attribute__((aarch64_vector_pcs)) }; +enum ZigClangStorageClass { + // These are legal on both functions and variables. + ZigClangStorageClass_None, + ZigClangStorageClass_Extern, + ZigClangStorageClass_Static, + ZigClangStorageClass_PrivateExtern, + + // These are only legal on variables. + ZigClangStorageClass_Auto, + ZigClangStorageClass_Register, +}; + ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangSourceManager_getSpellingLoc(const struct ZigClangSourceManager *, struct ZigClangSourceLocation Loc); ZIG_EXTERN_C const char *ZigClangSourceManager_getFilename(const struct ZigClangSourceManager *, @@ -742,6 +753,10 @@ ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangDecl_getLocation(const struct ZIG_EXTERN_C struct ZigClangQualType ZigClangFunctionDecl_getType(const struct ZigClangFunctionDecl *); ZIG_EXTERN_C struct ZigClangSourceLocation ZigClangFunctionDecl_getLocation(const struct ZigClangFunctionDecl *); +ZIG_EXTERN_C bool ZigClangFunctionDecl_hasBody(const struct ZigClangFunctionDecl *); +ZIG_EXTERN_C enum ZigClangStorageClass ZigClangFunctionDecl_getStorageClass(const struct ZigClangFunctionDecl *); +ZIG_EXTERN_C const struct ZigClangParmVarDecl *ZigClangFunctionDecl_getParamDecl(const struct ZigClangFunctionDecl *, unsigned i); +ZIG_EXTERN_C const struct ZigClangStmt *ZigClangFunctionDecl_getBody(const struct ZigClangFunctionDecl *); ZIG_EXTERN_C bool ZigClangRecordDecl_isUnion(const struct ZigClangRecordDecl *record_decl); ZIG_EXTERN_C bool ZigClangRecordDecl_isStruct(const struct ZigClangRecordDecl *record_decl); diff --git a/test/tests.zig b/test/tests.zig index 61fd0426f1..fec6a294ff 100644 --- a/test/tests.zig +++ b/test/tests.zig @@ -903,6 +903,7 @@ pub const TranslateCContext = struct { sources: ArrayList(SourceFile), expected_lines: ArrayList([]const u8), allow_warnings: bool, + stage2: bool, const SourceFile = struct { filename: []const u8, @@ -955,7 +956,8 @@ pub const TranslateCContext = struct { var zig_args = ArrayList([]const u8).init(b.allocator); zig_args.append(b.zig_exe) catch unreachable; - zig_args.append("translate-c") catch unreachable; + const translate_c_cmd = if (self.case.stage2) "translate-c-2" else "translate-c"; + zig_args.append(translate_c_cmd) catch unreachable; zig_args.append(b.pathFromRoot(root_src)) catch unreachable; warn("Test {}/{} {}...", self.test_index + 1, self.context.test_index, self.name); @@ -1052,6 +1054,7 @@ pub const TranslateCContext = struct { .sources = ArrayList(TestCase.SourceFile).init(self.b.allocator), .expected_lines = ArrayList([]const u8).init(self.b.allocator), .allow_warnings = allow_warnings, + .stage2 = false, }; tc.addSourceFile(filename, source); @@ -1072,6 +1075,26 @@ pub const TranslateCContext = struct { self.addCase(tc); } + pub fn add_both(self: *TranslateCContext, name: []const u8, source: []const u8, expected_lines: ...) void { + for ([]bool{ false, true }) |stage2| { + const tc = self.create(false, "source.c", name, source, expected_lines); + tc.stage2 = stage2; + self.addCase(tc); + } + } + + pub fn add_2(self: *TranslateCContext, name: []const u8, source: []const u8, expected_lines: ...) void { + const tc = self.create(false, "source.c", name, source, expected_lines); + tc.stage2 = true; + self.addCase(tc); + } + + pub fn addC_2(self: *TranslateCContext, name: []const u8, source: []const u8, expected_lines: ...) void { + const tc = self.create(false, "source.c", name, source, expected_lines); + tc.stage2 = true; + self.addCase(tc); + } + pub fn addAllowWarnings(self: *TranslateCContext, name: []const u8, source: []const u8, expected_lines: ...) void { const tc = self.create(true, "source.h", name, source, expected_lines); self.addCase(tc); @@ -1080,7 +1103,8 @@ pub const TranslateCContext = struct { pub fn addCase(self: *TranslateCContext, case: *const TestCase) void { const b = self.b; - const annotated_case_name = fmt.allocPrint(self.b.allocator, "translate-c {}", case.name) catch unreachable; + const translate_c_cmd = if (case.stage2) "translate-c-2" else "translate-c"; + const annotated_case_name = fmt.allocPrint(self.b.allocator, "{} {}", translate_c_cmd, case.name) catch unreachable; if (self.test_filter) |filter| { if (mem.indexOf(u8, annotated_case_name, filter) == null) return; } diff --git a/test/translate_c.zig b/test/translate_c.zig index 8ad1583396..762b28e3aa 100644 --- a/test/translate_c.zig +++ b/test/translate_c.zig @@ -2,6 +2,12 @@ const tests = @import("tests.zig"); const builtin = @import("builtin"); pub fn addCases(cases: *tests.TranslateCContext) void { + cases.add_both("simple noreturn fn", + \\void __attribute__((noreturn)) foo(void); + , + \\extern fn foo() noreturn; + ); + cases.add("macro with left shift", \\#define REDISMODULE_READ (1<<0) , -- cgit v1.2.3 From 5f4c3e6557b6ffd654fad5ef3928e5f21db56a50 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Fri, 10 May 2019 23:35:46 -0400 Subject: stage2 translate-c: simple function definitions See #1964 --- src-self-hosted/clang.zig | 26 +++--- src-self-hosted/translate_c.zig | 186 +++++++++++++++++++++++++++++++++------- src/translate_c.cpp | 16 ++-- src/zig_clang.cpp | 18 ++++ src/zig_clang.h | 7 ++ test/translate_c.zig | 6 ++ 6 files changed, 210 insertions(+), 49 deletions(-) (limited to 'src/zig_clang.cpp') diff --git a/src-self-hosted/clang.zig b/src-self-hosted/clang.zig index dd9e49b05b..92fe7b7cd3 100644 --- a/src-self-hosted/clang.zig +++ b/src-self-hosted/clang.zig @@ -12,7 +12,7 @@ pub const struct_ZigClangCStyleCastExpr = @OpaqueType(); pub const struct_ZigClangCallExpr = @OpaqueType(); pub const struct_ZigClangCaseStmt = @OpaqueType(); pub const struct_ZigClangCompoundAssignOperator = @OpaqueType(); -pub const struct_ZigClangCompoundStmt = @OpaqueType(); +pub const ZigClangCompoundStmt = @OpaqueType(); pub const struct_ZigClangConditionalOperator = @OpaqueType(); pub const struct_ZigClangConstantArrayType = @OpaqueType(); pub const struct_ZigClangContinueStmt = @OpaqueType(); @@ -33,7 +33,7 @@ pub const struct_ZigClangFieldDecl = @OpaqueType(); pub const struct_ZigClangFileID = @OpaqueType(); pub const struct_ZigClangForStmt = @OpaqueType(); pub const struct_ZigClangFullSourceLoc = @OpaqueType(); -pub const struct_ZigClangFunctionDecl = @OpaqueType(); +pub const ZigClangFunctionDecl = @OpaqueType(); pub const struct_ZigClangFunctionProtoType = @OpaqueType(); pub const struct_ZigClangIfStmt = @OpaqueType(); pub const struct_ZigClangImplicitCastExpr = @OpaqueType(); @@ -488,12 +488,12 @@ pub extern fn ZigClangQualType_isRestrictQualified(arg0: struct_ZigClangQualType pub extern fn ZigClangType_getTypeClass(self: ?*const struct_ZigClangType) ZigClangTypeClass; pub extern fn ZigClangType_isVoidType(self: ?*const struct_ZigClangType) bool; pub extern fn ZigClangType_getTypeClassName(self: *const struct_ZigClangType) [*]const u8; -pub extern fn ZigClangStmt_getBeginLoc(self: ?*const struct_ZigClangStmt) struct_ZigClangSourceLocation; +pub extern fn ZigClangStmt_getBeginLoc(self: *const struct_ZigClangStmt) struct_ZigClangSourceLocation; pub extern fn ZigClangStmt_getStmtClass(self: ?*const struct_ZigClangStmt) ZigClangStmtClass; pub extern fn ZigClangStmt_classof_Expr(self: ?*const struct_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 ZigClangExpr_getBeginLoc(self: *const struct_ZigClangExpr) struct_ZigClangSourceLocation; 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; @@ -510,11 +510,12 @@ pub extern fn ZigClangAPSInt_getNumWords(self: ?*const struct_ZigClangAPSInt) c_ pub extern fn ZigClangAPValueLValueBase_dyn_cast_Expr(self: struct_ZigClangAPValueLValueBase) ?*const struct_ZigClangExpr; pub extern fn ZigClangASTUnit_delete(arg0: ?*struct_ZigClangASTUnit) void; -pub extern fn ZigClangFunctionDecl_getType(self: *const struct_ZigClangFunctionDecl) struct_ZigClangQualType; -pub extern fn ZigClangFunctionDecl_getLocation(self: *const struct_ZigClangFunctionDecl) struct_ZigClangSourceLocation; -pub extern fn ZigClangFunctionDecl_hasBody(self: *const struct_ZigClangFunctionDecl) bool; -pub extern fn ZigClangFunctionDecl_getStorageClass(self: *const struct_ZigClangFunctionDecl) ZigClangStorageClass; -pub extern fn ZigClangFunctionDecl_getParamDecl(self: *const struct_ZigClangFunctionDecl, i: c_uint) *const struct_ZigClangParmVarDecl; +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 struct_ZigClangStmt; pub extern fn ZigClangBuiltinType_getKind(self: *const struct_ZigClangBuiltinType) ZigClangBuiltinTypeKind; @@ -543,7 +544,6 @@ 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 ZigClangConditionalOperator = struct_ZigClangConditionalOperator; pub const ZigClangConstantArrayType = struct_ZigClangConstantArrayType; pub const ZigClangContinueStmt = struct_ZigClangContinueStmt; @@ -564,7 +564,6 @@ 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; @@ -860,3 +859,8 @@ pub const ZigClangStorageClass = extern enum { Auto, Register, }; + +pub const ZigClangCompoundStmt_const_body_iterator = [*c]const *struct_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; diff --git a/src-self-hosted/translate_c.zig b/src-self-hosted/translate_c.zig index b3738dc961..e7d6bfd09c 100644 --- a/src-self-hosted/translate_c.zig +++ b/src-self-hosted/translate_c.zig @@ -3,6 +3,7 @@ const std = @import("std"); const builtin = @import("builtin"); +const assert = std.debug.assert; const ast = std.zig.ast; const Token = std.zig.Token; use @import("clang.zig"); @@ -21,6 +22,10 @@ pub const Error = error{ OutOfMemory, UnsupportedType, }; +pub const TransError = error{ + OutOfMemory, + UnsupportedTranslation, +}; const DeclTable = std.HashMap(usize, void, addrHash, addrEql); @@ -61,6 +66,27 @@ const Scope = struct { const Block = struct { base: Scope, + block_node: *ast.Node.Block, + + /// Don't forget to set rbrace token later + fn create(c: *Context, parent: *Scope, lbrace_tok: ast.TokenIndex) !*Block { + const block = try c.a().create(Block); + block.* = Block{ + .base = Scope{ + .id = Id.Block, + .parent = parent, + }, + .block_node = try c.a().create(ast.Node.Block), + }; + block.block_node.* = ast.Node.Block{ + .base = ast.Node{ .id = ast.Node.Id.Block }, + .label = null, + .lbrace = lbrace_tok, + .statements = ast.Node.Block.StatementList.init(c.a()), + .rbrace = undefined, + }; + return block; + } }; const Root = struct { @@ -72,6 +98,12 @@ const Scope = struct { }; }; +const TransResult = struct { + node: *ast.Node, + node_scope: *Scope, + child_scope: *Scope, +}; + const Context = struct { tree: *ast.Tree, source_buffer: *std.Buffer, @@ -170,6 +202,14 @@ pub fn translate( _ = try appendToken(&context, .Eof, ""); tree.source = source_buffer.toOwnedSlice(); + if (false) { + std.debug.warn("debug source:\n{}\n==EOF==\ntokens:\n", tree.source); + var i: usize = 0; + while (i < tree.tokens.len) : (i += 1) { + const token = tree.tokens.at(i); + std.debug.warn("{}\n", token); + } + } return tree; } @@ -213,29 +253,107 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void { const fn_decl_loc = ZigClangFunctionDecl_getLocation(fn_decl); const fn_qt = ZigClangFunctionDecl_getType(fn_decl); const fn_type = ZigClangQualType_getTypePtr(fn_qt); + var scope = &c.global_scope.base; + const decl_ctx = FnDeclContext{ + .fn_name = fn_name, + .has_body = ZigClangFunctionDecl_hasBody(fn_decl), + .storage_class = ZigClangFunctionDecl_getStorageClass(fn_decl), + .scope = &scope, + }; const proto_node = switch (ZigClangType_getTypeClass(fn_type)) { - .FunctionProto => transFnProto( - rp, - @ptrCast(*const ZigClangFunctionProtoType, fn_type), - fn_decl_loc, - fn_decl, - fn_name, - ) catch |err| switch (err) { - error.UnsupportedType => { - return failDecl(c, fn_decl_loc, fn_name, "unable to resolve prototype of function"); - }, - else => return err, + .FunctionProto => blk: { + const fn_proto_type = @ptrCast(*const ZigClangFunctionProtoType, fn_type); + break :blk transFnProto(rp, fn_proto_type, fn_decl_loc, decl_ctx) catch |err| switch (err) { + error.UnsupportedType => { + return failDecl(c, fn_decl_loc, fn_name, "unable to resolve prototype of function"); + }, + error.OutOfMemory => return error.OutOfMemory, + }; }, .FunctionNoProto => return failDecl(c, fn_decl_loc, fn_name, "TODO support functions with no prototype"), else => unreachable, }; - if (!ZigClangFunctionDecl_hasBody(fn_decl)) { + if (!decl_ctx.has_body) { const semi_tok = try appendToken(c, .Semicolon, ";"); return addTopLevelDecl(c, fn_name, &proto_node.base); } - try emitWarning(c, fn_decl_loc, "TODO implement function body translation"); + // actual function definition with body + const body_stmt = ZigClangFunctionDecl_getBody(fn_decl); + const result = transStmt(rp, scope, body_stmt, .unused, .r_value) catch |err| switch (err) { + error.OutOfMemory => return error.OutOfMemory, + error.UnsupportedTranslation => return failDecl(c, fn_decl_loc, fn_name, "unable to translate function"), + }; + assert(result.node.id == ast.Node.Id.Block); + proto_node.body_node = result.node; + + return addTopLevelDecl(c, fn_name, &proto_node.base); +} + +const ResultUsed = enum { + used, + unused, +}; + +const LRValue = enum { + l_value, + r_value, +}; + +fn transStmt( + rp: RestorePoint, + scope: *Scope, + stmt: *const ZigClangStmt, + result_used: ResultUsed, + lrvalue: LRValue, +) !TransResult { + const sc = ZigClangStmt_getStmtClass(stmt); + switch (sc) { + .CompoundStmtClass => return transCompoundStmt(rp, scope, @ptrCast(*const ZigClangCompoundStmt, stmt)), + else => { + return revertAndWarn( + rp, + error.UnsupportedTranslation, + ZigClangStmt_getBeginLoc(stmt), + "TODO implement translation of stmt class {}", + @tagName(sc), + ); + }, + } +} + +fn transCompoundStmtInline( + rp: RestorePoint, + parent_scope: *Scope, + stmt: *const ZigClangCompoundStmt, + block_node: *ast.Node.Block, +) TransError!TransResult { + var it = ZigClangCompoundStmt_body_begin(stmt); + const end_it = ZigClangCompoundStmt_body_end(stmt); + var scope = parent_scope; + while (it != end_it) : (it += 1) { + const result = try transStmt(rp, scope, it.*, .unused, .r_value); + scope = result.child_scope; + try block_node.statements.push(result.node); + } + return TransResult{ + .node = &block_node.base, + .child_scope = scope, + .node_scope = scope, + }; +} + +fn transCompoundStmt(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCompoundStmt) !TransResult { + const lbrace_tok = try appendToken(rp.c, .LBrace, "{"); + const block_scope = try Scope.Block.create(rp.c, scope, lbrace_tok); + const inline_result = try transCompoundStmtInline(rp, &block_scope.base, stmt, block_scope.block_node); + block_scope.block_node.rbrace = try appendToken(rp.c, .RBrace, "}"); + return TransResult{ + .node = &block_scope.block_node.base, + .node_scope = inline_result.node_scope, + .child_scope = inline_result.child_scope, + }; } fn addTopLevelDecl(c: *Context, name: []const u8, decl_node: *ast.Node) !void { @@ -299,7 +417,7 @@ fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSour }, .FunctionProto => { const fn_proto_ty = @ptrCast(*const ZigClangFunctionProtoType, ty); - const fn_proto = try transFnProto(rp, fn_proto_ty, source_loc, null, null); + const fn_proto = try transFnProto(rp, fn_proto_ty, source_loc, null); return &fn_proto.base; }, else => { @@ -309,12 +427,18 @@ fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSour } } +const FnDeclContext = struct { + fn_name: []const u8, + has_body: bool, + storage_class: ZigClangStorageClass, + scope: **Scope, +}; + fn transFnProto( rp: RestorePoint, fn_proto_ty: *const ZigClangFunctionProtoType, source_loc: ZigClangSourceLocation, - opt_fn_decl: ?*const ZigClangFunctionDecl, - fn_name: ?[]const u8, + fn_decl_context: ?FnDeclContext, ) !*ast.Node.FnProto { const fn_ty = @ptrCast(*const ZigClangFunctionType, fn_proto_ty); const cc = switch (ZigClangFunctionType_getCallConv(fn_ty)) { @@ -351,13 +475,11 @@ fn transFnProto( const pub_tok = try appendToken(rp.c, .Keyword_pub, "pub"); const cc_tok = if (cc == .Stdcall) try appendToken(rp.c, .Keyword_stdcallcc, "stdcallcc") else null; const is_export = exp: { - const fn_decl = opt_fn_decl orelse break :exp false; - const has_body = ZigClangFunctionDecl_hasBody(fn_decl); - const storage_class = ZigClangFunctionDecl_getStorageClass(fn_decl); - break :exp switch (storage_class) { + const decl_ctx = fn_decl_context orelse break :exp false; + break :exp switch (decl_ctx.storage_class) { .None => switch (rp.c.mode) { .import => false, - .translate => has_body, + .translate => decl_ctx.has_body, }, .Extern, .Static => false, .PrivateExtern => return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported storage class: private extern"), @@ -372,7 +494,7 @@ fn transFnProto( else null; const fn_tok = try appendToken(rp.c, .Keyword_fn, "fn"); - const name_tok = if (fn_name) |n| try appendToken(rp.c, .Identifier, "{}", n) else null; + const name_tok = if (fn_decl_context) |ctx| try appendToken(rp.c, .Identifier, ctx.fn_name) else null; const lparen_tok = try appendToken(rp.c, .LParen, "("); const var_args_tok = if (is_var_args) try appendToken(rp.c, .Ellipsis3, "...") else null; const rparen_tok = try appendToken(rp.c, .RParen, ")"); @@ -390,7 +512,7 @@ fn transFnProto( try emitWarning(rp.c, source_loc, "unsupported function proto return type"); return err; }, - else => return err, + error.OutOfMemory => return error.OutOfMemory, }; } } @@ -430,17 +552,17 @@ fn revertAndWarn( } fn emitWarning(c: *Context, loc: ZigClangSourceLocation, comptime format: []const u8, args: ...) !void { - _ = try appendToken(c, .LineComment, "// {}: warning: " ++ format, c.locStr(loc), args); + _ = try appendTokenFmt(c, .LineComment, "// {}: warning: " ++ format, c.locStr(loc), args); } fn failDecl(c: *Context, loc: ZigClangSourceLocation, name: []const u8, comptime format: []const u8, args: ...) !void { // const name = @compileError(msg); const const_tok = try appendToken(c, .Keyword_const, "const"); - const name_tok = try appendToken(c, .Identifier, "{}", name); + const name_tok = try appendToken(c, .Identifier, name); const eq_tok = try appendToken(c, .Equal, "="); const builtin_tok = try appendToken(c, .Builtin, "@compileError"); const lparen_tok = try appendToken(c, .LParen, "("); - const msg_tok = try appendToken(c, .StringLiteral, "\"" ++ format ++ "\"", args); + const msg_tok = try appendTokenFmt(c, .StringLiteral, "\"" ++ format ++ "\"", args); const rparen_tok = try appendToken(c, .RParen, ")"); const semi_tok = try appendToken(c, .Semicolon, ";"); @@ -480,16 +602,20 @@ fn failDecl(c: *Context, loc: ZigClangSourceLocation, name: []const u8, comptime try c.tree.root_node.decls.push(&var_decl_node.base); } -fn appendToken(c: *Context, token_id: Token.Id, comptime format: []const u8, args: ...) !ast.TokenIndex { +fn appendToken(c: *Context, token_id: Token.Id, bytes: []const u8) !ast.TokenIndex { + return appendTokenFmt(c, token_id, "{}", bytes); +} + +fn appendTokenFmt(c: *Context, token_id: Token.Id, comptime format: []const u8, args: ...) !ast.TokenIndex { const S = struct { - fn callback(context: *Context, bytes: []const u8) Error!void { + fn callback(context: *Context, bytes: []const u8) error{OutOfMemory}!void { return context.source_buffer.append(bytes); } }; const start_index = c.source_buffer.len(); errdefer c.source_buffer.shrink(start_index); - try std.fmt.format(c, Error, S.callback, format, args); + try std.fmt.format(c, error{OutOfMemory}, S.callback, format, args); const end_index = c.source_buffer.len(); const token_index = c.tree.tokens.len; const new_token = try c.tree.tokens.addOne(); @@ -506,7 +632,7 @@ fn appendToken(c: *Context, token_id: Token.Id, comptime format: []const u8, arg } fn appendIdentifier(c: *Context, name: []const u8) !*ast.Node { - const token_index = try appendToken(c, .Identifier, "{}", name); + const token_index = try appendToken(c, .Identifier, name); const identifier = try c.a().create(ast.Node.Identifier); identifier.* = ast.Node.Identifier{ .base = ast.Node{ .id = ast.Node.Id.Identifier }, diff --git a/src/translate_c.cpp b/src/translate_c.cpp index 71c0376130..c3c715cb47 100644 --- a/src/translate_c.cpp +++ b/src/translate_c.cpp @@ -1277,15 +1277,15 @@ static AstNode *trans_qual_type(Context *c, ZigClangQualType qt, ZigClangSourceL return trans_type(c, ZigClangQualType_getTypePtr(qt), source_loc); } -static int trans_compound_stmt_inline(Context *c, TransScope *scope, const clang::CompoundStmt *stmt, +static int trans_compound_stmt_inline(Context *c, TransScope *scope, const ZigClangCompoundStmt *stmt, AstNode *block_node, TransScope **out_node_scope) { assert(block_node->type == NodeTypeBlock); - for (clang::CompoundStmt::const_body_iterator it = stmt->body_begin(), end_it = stmt->body_end(); - it != end_it; ++it) + for (ZigClangCompoundStmt_const_body_iterator it = ZigClangCompoundStmt_body_begin(stmt), + end_it = ZigClangCompoundStmt_body_end(stmt); it != end_it; ++it) { AstNode *child_node; - scope = trans_stmt(c, scope, bitcast(*it), &child_node); + scope = trans_stmt(c, scope, *it, &child_node); if (scope == nullptr) return ErrorUnexpected; if (child_node != nullptr) @@ -1297,7 +1297,7 @@ static int trans_compound_stmt_inline(Context *c, TransScope *scope, const clang return ErrorNone; } -static AstNode *trans_compound_stmt(Context *c, TransScope *scope, const clang::CompoundStmt *stmt, +static AstNode *trans_compound_stmt(Context *c, TransScope *scope, const ZigClangCompoundStmt *stmt, TransScope **out_node_scope) { TransScopeBlock *child_scope_block = trans_scope_block_create(c, scope); @@ -1309,7 +1309,7 @@ static AstNode *trans_compound_stmt(Context *c, TransScope *scope, const clang:: static AstNode *trans_stmt_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::StmtExpr *stmt, TransScope **out_node_scope) { - AstNode *block = trans_compound_stmt(c, scope, stmt->getSubStmt(), out_node_scope); + AstNode *block = trans_compound_stmt(c, scope, (const ZigClangCompoundStmt *)stmt->getSubStmt(), out_node_scope); if (block == nullptr) return block; assert(block->type == NodeTypeBlock); @@ -3220,7 +3220,7 @@ static AstNode *trans_switch_stmt(Context *c, TransScope *parent_scope, const cl AstNode *body_node; const ZigClangStmt *body_stmt = bitcast(stmt->getBody()); if (ZigClangStmt_getStmtClass(body_stmt) == ZigClangStmt_CompoundStmtClass) { - if (trans_compound_stmt_inline(c, &switch_scope->base, (const clang::CompoundStmt *)body_stmt, + if (trans_compound_stmt_inline(c, &switch_scope->base, (const ZigClangCompoundStmt *)body_stmt, block_scope->node, nullptr)) { return nullptr; @@ -3399,7 +3399,7 @@ static int trans_stmt_extra(Context *c, TransScope *scope, const ZigClangStmt *s trans_return_stmt(c, scope, (const clang::ReturnStmt *)stmt)); case ZigClangStmt_CompoundStmtClass: return wrap_stmt(out_node, out_child_scope, scope, - trans_compound_stmt(c, scope, (const clang::CompoundStmt *)stmt, out_node_scope)); + trans_compound_stmt(c, scope, (const ZigClangCompoundStmt *)stmt, out_node_scope)); case ZigClangStmt_IntegerLiteralClass: return wrap_stmt(out_node, out_child_scope, scope, trans_integer_literal(c, result_used, (const clang::IntegerLiteral *)stmt)); diff --git a/src/zig_clang.cpp b/src/zig_clang.cpp index 25e309a63e..b558fa318c 100644 --- a/src/zig_clang.cpp +++ b/src/zig_clang.cpp @@ -1292,6 +1292,14 @@ static clang::APValue::LValueBase bitcast(ZigClangAPValueLValueBase src) { return dest; } +static_assert(sizeof(ZigClangCompoundStmt_const_body_iterator) == sizeof(clang::CompoundStmt::const_body_iterator), ""); +static ZigClangCompoundStmt_const_body_iterator bitcast(clang::CompoundStmt::const_body_iterator src) { + ZigClangCompoundStmt_const_body_iterator dest; + memcpy(&dest, static_cast(&src), sizeof(ZigClangCompoundStmt_const_body_iterator)); + return dest; +} + + ZigClangSourceLocation ZigClangSourceManager_getSpellingLoc(const ZigClangSourceManager *self, ZigClangSourceLocation Loc) { @@ -1811,3 +1819,13 @@ struct ZigClangQualType ZigClangFunctionProtoType_getParamType(const struct ZigC auto casted = reinterpret_cast(self); return bitcast(casted->getParamType(index)); } + +ZigClangCompoundStmt_const_body_iterator ZigClangCompoundStmt_body_begin(const struct ZigClangCompoundStmt *self) { + auto casted = reinterpret_cast(self); + return bitcast(casted->body_begin()); +} + +ZigClangCompoundStmt_const_body_iterator ZigClangCompoundStmt_body_end(const struct ZigClangCompoundStmt *self) { + auto casted = reinterpret_cast(self); + return bitcast(casted->body_end()); +} diff --git a/src/zig_clang.h b/src/zig_clang.h index 8e0d2f9f98..fd74536b28 100644 --- a/src/zig_clang.h +++ b/src/zig_clang.h @@ -102,6 +102,8 @@ struct ZigClangVarDecl; struct ZigClangWhileStmt; struct ZigClangFunctionType; +typedef struct ZigClangStmt *const * ZigClangCompoundStmt_const_body_iterator; + enum ZigClangBO { ZigClangBO_PtrMemD, ZigClangBO_PtrMemI, @@ -820,4 +822,9 @@ ZIG_EXTERN_C struct ZigClangQualType ZigClangFunctionType_getReturnType(const st ZIG_EXTERN_C bool ZigClangFunctionProtoType_isVariadic(const struct ZigClangFunctionProtoType *self); ZIG_EXTERN_C unsigned ZigClangFunctionProtoType_getNumParams(const struct ZigClangFunctionProtoType *self); ZIG_EXTERN_C struct ZigClangQualType ZigClangFunctionProtoType_getParamType(const struct ZigClangFunctionProtoType *self, unsigned i); + + +ZIG_EXTERN_C ZigClangCompoundStmt_const_body_iterator ZigClangCompoundStmt_body_begin(const struct ZigClangCompoundStmt *self); +ZIG_EXTERN_C ZigClangCompoundStmt_const_body_iterator ZigClangCompoundStmt_body_end(const struct ZigClangCompoundStmt *self); + #endif diff --git a/test/translate_c.zig b/test/translate_c.zig index c2dfbb2860..6a2d2ef1d9 100644 --- a/test/translate_c.zig +++ b/test/translate_c.zig @@ -11,6 +11,12 @@ pub fn addCases(cases: *tests.TranslateCContext) void { \\pub extern fn bar() c_int; ); + cases.add_both("simple function definition", + \\void foo(void) {}; + , + \\pub export fn foo() void {} + ); + /////////////// Cases that pass for only stage2 //////////////// // (none) -- cgit v1.2.3