authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-04-12 03:12:22-04:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-04-12 03:12:22-04:00
logf860493f23f0c438e76268b412f85e7b9843ea89
treee6f101993f1c96f2dd0a572e383ea11dea234a7d
parent6f34d08aedb4c89257de04da1e4f8d162188d247
signaturelock-open Commit is signed but in an unrecognized format.

translate-c: move some code to the C API

See #1964

3 files changed, 544 insertions(+), 317 deletions(-)

src/translate_c.cpp+269-268
......@@ -122,9 +122,9 @@ static int trans_stmt_extra(Context *c, TransScope *scope, const clang::Stmt *st
122122 TransScope **out_node_scope);
123123static TransScope *trans_stmt(Context *c, TransScope *scope, const clang::Stmt *stmt, AstNode **out_node);
124124static AstNode *trans_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::Expr *expr, TransLRValue lrval);
125static AstNode *trans_qual_type(Context *c, clang::QualType qt, ZigClangSourceLocation source_loc);
125static AstNode *trans_qual_type(Context *c, ZigClangQualType qt, ZigClangSourceLocation source_loc);
126126static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::Expr *expr, TransLRValue lrval);
127static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, clang::QualType qt, ZigClangSourceLocation source_loc);
127static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, ZigClangQualType qt, ZigClangSourceLocation source_loc);
128128
129129static ZigClangSourceLocation bitcast(clang::SourceLocation src) {
130130 ZigClangSourceLocation dest;
......@@ -136,11 +136,11 @@ static ZigClangQualType bitcast(clang::QualType src) {
136136 memcpy(&dest, static_cast<void *>(&src), sizeof(ZigClangQualType));
137137 return dest;
138138}
139static clang::QualType bitcast(ZigClangQualType src) {
140 clang::QualType dest;
141 memcpy(&dest, static_cast<void *>(&src), sizeof(ZigClangQualType));
142 return dest;
143}
139//static clang::QualType bitcast(ZigClangQualType src) {
140// clang::QualType dest;
141// memcpy(&dest, static_cast<void *>(&src), sizeof(ZigClangQualType));
142// return dest;
143//}
144144
145145ATTRIBUTE_PRINTF(3, 4)
146146static 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)
502502
503503}
504504
505static const clang::Type *qual_type_canon(clang::QualType qt) {
506 return qt.getCanonicalType().getTypePtr();
505static const ZigClangType *qual_type_canon(ZigClangQualType qt) {
506 ZigClangQualType canon = ZigClangQualType_getCanonicalType(qt);
507 return ZigClangQualType_getTypePtr(canon);
507508}
508509
509static clang::QualType get_expr_qual_type(Context *c, const clang::Expr *expr) {
510static ZigClangQualType get_expr_qual_type(Context *c, const clang::Expr *expr) {
510511 // String literals in C are `char *` but they should really be `const char *`.
511512 if (expr->getStmtClass() == clang::Stmt::ImplicitCastExprClass) {
512513 const clang::ImplicitCastExpr *cast_expr = static_cast<const clang::ImplicitCastExpr *>(expr);
513514 if (cast_expr->getCastKind() == clang::CK_ArrayToPointerDecay) {
514515 const clang::Expr *sub_expr = cast_expr->getSubExpr();
515516 if (sub_expr->getStmtClass() == clang::Stmt::StringLiteralClass) {
516 clang::QualType array_qt = sub_expr->getType();
517 const clang::ArrayType *array_type = static_cast<const clang::ArrayType *>(array_qt.getTypePtr());
518 clang::QualType pointee_qt = array_type->getElementType();
519 pointee_qt.addConst();
520 return bitcast(ZigClangASTContext_getPointerType(c->ctx, bitcast(pointee_qt)));
517 ZigClangQualType array_qt = bitcast(sub_expr->getType());
518 const clang::ArrayType *array_type = reinterpret_cast<const clang::ArrayType *>(
519 ZigClangQualType_getTypePtr(array_qt));
520 ZigClangQualType pointee_qt = bitcast(array_type->getElementType());
521 ZigClangQualType_addConst(&pointee_qt);
522 return ZigClangASTContext_getPointerType(c->ctx, pointee_qt);
521523 }
522524 }
523525 }
524 return expr->getType();
526 return bitcast(expr->getType());
525527}
526528
527static clang::QualType get_expr_qual_type_before_implicit_cast(Context *c, const clang::Expr *expr) {
529static ZigClangQualType get_expr_qual_type_before_implicit_cast(Context *c, const clang::Expr *expr) {
528530 if (expr->getStmtClass() == clang::Stmt::ImplicitCastExprClass) {
529531 const clang::ImplicitCastExpr *cast_expr = static_cast<const clang::ImplicitCastExpr *>(expr);
530532 return get_expr_qual_type(c, cast_expr->getSubExpr());
531533 }
532 return expr->getType();
534 return bitcast(expr->getType());
533535}
534536
535537static AstNode *get_expr_type(Context *c, const clang::Expr *expr) {
536538 return trans_qual_type(c, get_expr_qual_type(c, expr), bitcast(expr->getBeginLoc()));
537539}
538540
539static bool qual_types_equal(clang::QualType t1, clang::QualType t2) {
540 if (t1.isConstQualified() != t2.isConstQualified()) {
541 return false;
542 }
543 if (t1.isVolatileQualified() != t2.isVolatileQualified()) {
544 return false;
545 }
546 if (t1.isRestrictQualified() != t2.isRestrictQualified()) {
547 return false;
548 }
549 return t1.getTypePtr() == t2.getTypePtr();
550}
551
552541static bool is_c_void_type(AstNode *node) {
553542 return (node->type == NodeTypeSymbol && buf_eql_str(node->data.symbol_expr.symbol, "c_void"));
554543}
555544
556545static bool expr_types_equal(Context *c, const clang::Expr *expr1, const clang::Expr *expr2) {
557 clang::QualType t1 = get_expr_qual_type(c, expr1);
558 clang::QualType t2 = get_expr_qual_type(c, expr2);
546 ZigClangQualType t1 = get_expr_qual_type(c, expr1);
547 ZigClangQualType t2 = get_expr_qual_type(c, expr2);
559548
560 return qual_types_equal(t1, t2);
549 return ZigClangQualType_eq(t1, t2);
561550}
562551
563static bool qual_type_is_ptr(clang::QualType qt) {
564 const clang::Type *ty = qual_type_canon(qt);
565 return ty->getTypeClass() == clang::Type::Pointer;
552static bool qual_type_is_ptr(ZigClangQualType qt) {
553 const ZigClangType *ty = qual_type_canon(qt);
554 return ZigClangType_getTypeClass(ty) == ZigClangType_Pointer;
566555}
567556
568static const clang::FunctionProtoType *qual_type_get_fn_proto(clang::QualType qt, bool *is_ptr) {
569 const clang::Type *ty = qual_type_canon(qt);
557static const clang::FunctionProtoType *qual_type_get_fn_proto(ZigClangQualType qt, bool *is_ptr) {
558 const ZigClangType *ty = qual_type_canon(qt);
570559 *is_ptr = false;
571560
572 if (ty->getTypeClass() == clang::Type::Pointer) {
561 if (ZigClangType_getTypeClass(ty) == ZigClangType_Pointer) {
573562 *is_ptr = true;
574 const clang::PointerType *pointer_ty = static_cast<const clang::PointerType*>(ty);
575 clang::QualType child_qt = pointer_ty->getPointeeType();
576 ty = child_qt.getTypePtr();
563 const clang::PointerType *pointer_ty = reinterpret_cast<const clang::PointerType*>(ty);
564 ZigClangQualType child_qt = bitcast(pointer_ty->getPointeeType());
565 ty = ZigClangQualType_getTypePtr(child_qt);
577566 }
578567
579 if (ty->getTypeClass() == clang::Type::FunctionProto) {
580 return static_cast<const clang::FunctionProtoType*>(ty);
568 if (ZigClangType_getTypeClass(ty) == ZigClangType_FunctionProto) {
569 return reinterpret_cast<const clang::FunctionProtoType*>(ty);
581570 }
582571
583572 return nullptr;
584573}
585574
586static bool qual_type_is_fn_ptr(clang::QualType qt) {
575static bool qual_type_is_fn_ptr(ZigClangQualType qt) {
587576 bool is_ptr;
588577 if (qual_type_get_fn_proto(qt, &is_ptr)) {
589578 return is_ptr;
......@@ -592,12 +581,12 @@ static bool qual_type_is_fn_ptr(clang::QualType qt) {
592581 return false;
593582}
594583
595static uint32_t qual_type_int_bit_width(Context *c, const clang::QualType qt, ZigClangSourceLocation source_loc) {
596 const clang::Type *ty = qt.getTypePtr();
597 switch (ty->getTypeClass()) {
598 case clang::Type::Builtin:
584static uint32_t qual_type_int_bit_width(Context *c, const ZigClangQualType qt, ZigClangSourceLocation source_loc) {
585 const ZigClangType *ty = ZigClangQualType_getTypePtr(qt);
586 switch (ZigClangType_getTypeClass(ty)) {
587 case ZigClangType_Builtin:
599588 {
600 const clang::BuiltinType *builtin_ty = static_cast<const clang::BuiltinType*>(ty);
589 const clang::BuiltinType *builtin_ty = reinterpret_cast<const clang::BuiltinType*>(ty);
601590 switch (builtin_ty->getKind()) {
602591 case clang::BuiltinType::Char_U:
603592 case clang::BuiltinType::UChar:
......@@ -612,7 +601,7 @@ static uint32_t qual_type_int_bit_width(Context *c, const clang::QualType qt, Zi
612601 }
613602 zig_unreachable();
614603 }
615 case clang::Type::Typedef:
604 case ZigClangType_Typedef:
616605 {
617606 const ZigClangTypedefType *typedef_ty = reinterpret_cast<const ZigClangTypedefType*>(ty);
618607 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
636625}
637626
638627
639static AstNode *qual_type_to_log2_int_ref(Context *c, const clang::QualType qt,
628static AstNode *qual_type_to_log2_int_ref(Context *c, const ZigClangQualType qt,
640629 ZigClangSourceLocation source_loc)
641630{
642631 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,
669658 return log2int_fn_call;
670659}
671660
672static bool qual_type_child_is_fn_proto(const clang::QualType qt) {
673 if (qt.getTypePtr()->getTypeClass() == clang::Type::Paren) {
674 const clang::ParenType *paren_type = static_cast<const clang::ParenType *>(qt.getTypePtr());
661static bool qual_type_child_is_fn_proto(ZigClangQualType qt) {
662 const ZigClangType *ty = ZigClangQualType_getTypePtr(qt);
663 if (ZigClangType_getTypeClass(ty) == ZigClangType_Paren) {
664 const clang::ParenType *paren_type = reinterpret_cast<const clang::ParenType *>(ty);
675665 if (paren_type->getInnerType()->getTypeClass() == clang::Type::FunctionProto) {
676666 return true;
677667 }
678 } else if (qt.getTypePtr()->getTypeClass() == clang::Type::Attributed) {
679 const clang::AttributedType *attr_type = static_cast<const clang::AttributedType *>(qt.getTypePtr());
680 return qual_type_child_is_fn_proto(attr_type->getEquivalentType());
668 } else if (ZigClangType_getTypeClass(ty) == ZigClangType_Attributed) {
669 const clang::AttributedType *attr_type = reinterpret_cast<const clang::AttributedType *>(ty);
670 return qual_type_child_is_fn_proto(bitcast(attr_type->getEquivalentType()));
681671 }
682672 return false;
683673}
684674
685static AstNode* trans_c_cast(Context *c, ZigClangSourceLocation source_location, clang::QualType dest_type,
686 clang::QualType src_type, AstNode *expr)
675static AstNode* trans_c_cast(Context *c, ZigClangSourceLocation source_location, ZigClangQualType dest_type,
676 ZigClangQualType src_type, AstNode *expr)
687677{
688678 // The only way void pointer casts are valid C code, is if
689679 // the value of the expression is ignored. We therefore just
690680 // return the expr, and let the system that ignores values
691681 // translate this correctly.
692 if (qual_type_canon(dest_type)->isVoidType()) {
682 if (ZigClangType_isVoidType(qual_type_canon(dest_type))) {
693683 return expr;
694684 }
695 if (qual_types_equal(dest_type, src_type)) {
685 if (ZigClangQualType_eq(dest_type, src_type)) {
696686 return expr;
697687 }
698688 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,
707697 return trans_create_node_fn_call_1(c, trans_qual_type(c, dest_type, source_location), expr);
708698}
709699
710static bool c_is_signed_integer(Context *c, clang::QualType qt) {
711 const clang::Type *c_type = qual_type_canon(qt);
712 if (c_type->getTypeClass() != clang::Type::Builtin)
700static bool c_is_signed_integer(Context *c, ZigClangQualType qt) {
701 const ZigClangType *c_type = qual_type_canon(qt);
702 if (ZigClangType_getTypeClass(c_type) != ZigClangType_Builtin)
713703 return false;
714 const clang::BuiltinType *builtin_ty = static_cast<const clang::BuiltinType*>(c_type);
704 const clang::BuiltinType *builtin_ty = reinterpret_cast<const clang::BuiltinType*>(c_type);
715705 switch (builtin_ty->getKind()) {
716706 case clang::BuiltinType::SChar:
717707 case clang::BuiltinType::Short:
......@@ -726,11 +716,11 @@ static bool c_is_signed_integer(Context *c, clang::QualType qt) {
726716 }
727717}
728718
729static bool c_is_unsigned_integer(Context *c, clang::QualType qt) {
730 const clang::Type *c_type = qual_type_canon(qt);
731 if (c_type->getTypeClass() != clang::Type::Builtin)
719static bool c_is_unsigned_integer(Context *c, ZigClangQualType qt) {
720 const ZigClangType *c_type = qual_type_canon(qt);
721 if (ZigClangType_getTypeClass(c_type) != ZigClangType_Builtin)
732722 return false;
733 const clang::BuiltinType *builtin_ty = static_cast<const clang::BuiltinType*>(c_type);
723 const clang::BuiltinType *builtin_ty = reinterpret_cast<const clang::BuiltinType*>(c_type);
734724 switch (builtin_ty->getKind()) {
735725 case clang::BuiltinType::Char_U:
736726 case clang::BuiltinType::UChar:
......@@ -747,19 +737,19 @@ static bool c_is_unsigned_integer(Context *c, clang::QualType qt) {
747737 }
748738}
749739
750static bool c_is_builtin_type(Context *c, clang::QualType qt, clang::BuiltinType::Kind kind) {
751 const clang::Type *c_type = qual_type_canon(qt);
752 if (c_type->getTypeClass() != clang::Type::Builtin)
740static bool c_is_builtin_type(Context *c, ZigClangQualType qt, clang::BuiltinType::Kind kind) {
741 const ZigClangType *c_type = qual_type_canon(qt);
742 if (ZigClangType_getTypeClass(c_type) != ZigClangType_Builtin)
753743 return false;
754 const clang::BuiltinType *builtin_ty = static_cast<const clang::BuiltinType*>(c_type);
744 const clang::BuiltinType *builtin_ty = reinterpret_cast<const clang::BuiltinType*>(c_type);
755745 return builtin_ty->getKind() == kind;
756746}
757747
758static bool c_is_float(Context *c, clang::QualType qt) {
759 const clang::Type *c_type = qt.getTypePtr();
760 if (c_type->getTypeClass() != clang::Type::Builtin)
748static bool c_is_float(Context *c, ZigClangQualType qt) {
749 const ZigClangType *c_type = ZigClangQualType_getTypePtr(qt);
750 if (ZigClangType_getTypeClass(c_type) != ZigClangType_Builtin)
761751 return false;
762 const clang::BuiltinType *builtin_ty = static_cast<const clang::BuiltinType*>(c_type);
752 const clang::BuiltinType *builtin_ty = reinterpret_cast<const clang::BuiltinType*>(c_type);
763753 switch (builtin_ty->getKind()) {
764754 case clang::BuiltinType::Half:
765755 case clang::BuiltinType::Float:
......@@ -772,7 +762,7 @@ static bool c_is_float(Context *c, clang::QualType qt) {
772762 }
773763}
774764
775static bool qual_type_has_wrapping_overflow(Context *c, clang::QualType qt) {
765static bool qual_type_has_wrapping_overflow(Context *c, ZigClangQualType qt) {
776766 if (c_is_signed_integer(c, qt) || c_is_float(c, qt)) {
777767 // float and signed integer overflow is undefined behavior.
778768 return false;
......@@ -782,37 +772,37 @@ static bool qual_type_has_wrapping_overflow(Context *c, clang::QualType qt) {
782772 }
783773}
784774
785static bool type_is_opaque(Context *c, const clang::Type *ty, ZigClangSourceLocation source_loc) {
786 switch (ty->getTypeClass()) {
787 case clang::Type::Builtin: {
788 const clang::BuiltinType *builtin_ty = static_cast<const clang::BuiltinType*>(ty);
775static bool type_is_opaque(Context *c, const ZigClangType *ty, ZigClangSourceLocation source_loc) {
776 switch (ZigClangType_getTypeClass(ty)) {
777 case ZigClangType_Builtin: {
778 const clang::BuiltinType *builtin_ty = reinterpret_cast<const clang::BuiltinType*>(ty);
789779 return builtin_ty->getKind() == clang::BuiltinType::Void;
790780 }
791 case clang::Type::Record: {
792 const clang::RecordType *record_ty = static_cast<const clang::RecordType*>(ty);
781 case ZigClangType_Record: {
782 const clang::RecordType *record_ty = reinterpret_cast<const clang::RecordType*>(ty);
793783 return record_ty->getDecl()->getDefinition() == nullptr;
794784 }
795 case clang::Type::Elaborated: {
796 const clang::ElaboratedType *elaborated_ty = static_cast<const clang::ElaboratedType*>(ty);
797 return type_is_opaque(c, elaborated_ty->getNamedType().getTypePtr(), source_loc);
785 case ZigClangType_Elaborated: {
786 const clang::ElaboratedType *elaborated_ty = reinterpret_cast<const clang::ElaboratedType*>(ty);
787 ZigClangQualType qt = bitcast(elaborated_ty->getNamedType());
788 return type_is_opaque(c, ZigClangQualType_getTypePtr(qt), source_loc);
798789 }
799 case clang::Type::Typedef: {
790 case ZigClangType_Typedef: {
800791 const ZigClangTypedefType *typedef_ty = reinterpret_cast<const ZigClangTypedefType*>(ty);
801792 const ZigClangTypedefNameDecl *typedef_decl = ZigClangTypedefType_getDecl(typedef_ty);
802793 ZigClangQualType underlying_type = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl);
803 clang::QualType qt = bitcast(underlying_type);
804 return type_is_opaque(c, qt.getTypePtr(), source_loc);
794 return type_is_opaque(c, ZigClangQualType_getTypePtr(underlying_type), source_loc);
805795 }
806796 default:
807797 return false;
808798 }
809799}
810800
811static AstNode *trans_type(Context *c, const clang::Type *ty, ZigClangSourceLocation source_loc) {
812 switch (ty->getTypeClass()) {
813 case clang::Type::Builtin:
801static AstNode *trans_type(Context *c, const ZigClangType *ty, ZigClangSourceLocation source_loc) {
802 switch (ZigClangType_getTypeClass(ty)) {
803 case ZigClangType_Builtin:
814804 {
815 const clang::BuiltinType *builtin_ty = static_cast<const clang::BuiltinType*>(ty);
805 const clang::BuiltinType *builtin_ty = reinterpret_cast<const clang::BuiltinType*>(ty);
816806 switch (builtin_ty->getKind()) {
817807 case clang::BuiltinType::Void:
818808 return trans_create_node_symbol_str(c, "c_void");
......@@ -955,10 +945,10 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, ZigClangSourceLoca
955945 }
956946 break;
957947 }
958 case clang::Type::Pointer:
948 case ZigClangType_Pointer:
959949 {
960 const clang::PointerType *pointer_ty = static_cast<const clang::PointerType*>(ty);
961 clang::QualType child_qt = pointer_ty->getPointeeType();
950 const clang::PointerType *pointer_ty = reinterpret_cast<const clang::PointerType*>(ty);
951 ZigClangQualType child_qt = bitcast(pointer_ty->getPointeeType());
962952 AstNode *child_node = trans_qual_type(c, child_qt, source_loc);
963953 if (child_node == nullptr) {
964954 emit_warning(c, source_loc, "pointer to unsupported type");
......@@ -969,29 +959,33 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, ZigClangSourceLoca
969959 return trans_create_node_prefix_op(c, PrefixOpOptional, child_node);
970960 }
971961
972 if (type_is_opaque(c, child_qt.getTypePtr(), source_loc)) {
973 AstNode *pointer_node = trans_create_node_ptr_type(c, child_qt.isConstQualified(),
974 child_qt.isVolatileQualified(), child_node, PtrLenSingle);
962 if (type_is_opaque(c, ZigClangQualType_getTypePtr(child_qt), source_loc)) {
963 AstNode *pointer_node = trans_create_node_ptr_type(c,
964 ZigClangQualType_isConstQualified(child_qt),
965 ZigClangQualType_isVolatileQualified(child_qt),
966 child_node, PtrLenSingle);
975967 return trans_create_node_prefix_op(c, PrefixOpOptional, pointer_node);
976968 } else {
977 return trans_create_node_ptr_type(c, child_qt.isConstQualified(),
978 child_qt.isVolatileQualified(), child_node, PtrLenC);
969 return trans_create_node_ptr_type(c,
970 ZigClangQualType_isConstQualified(child_qt),
971 ZigClangQualType_isVolatileQualified(child_qt),
972 child_node, PtrLenC);
979973 }
980974 }
981 case clang::Type::Typedef:
975 case ZigClangType_Typedef:
982976 {
983977 const ZigClangTypedefType *typedef_ty = reinterpret_cast<const ZigClangTypedefType*>(ty);
984978 const ZigClangTypedefNameDecl *typedef_decl = ZigClangTypedefType_getDecl(typedef_ty);
985979 return resolve_typedef_decl(c, typedef_decl);
986980 }
987 case clang::Type::Elaborated:
981 case ZigClangType_Elaborated:
988982 {
989 const clang::ElaboratedType *elaborated_ty = static_cast<const clang::ElaboratedType*>(ty);
983 const clang::ElaboratedType *elaborated_ty = reinterpret_cast<const clang::ElaboratedType*>(ty);
990984 switch (elaborated_ty->getKeyword()) {
991985 case clang::ETK_Struct:
992986 case clang::ETK_Enum:
993987 case clang::ETK_Union:
994 return trans_qual_type(c, elaborated_ty->getNamedType(), source_loc);
988 return trans_qual_type(c, bitcast(elaborated_ty->getNamedType()), source_loc);
995989 case clang::ETK_Interface:
996990 case clang::ETK_Class:
997991 case clang::ETK_Typename:
......@@ -1000,10 +994,10 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, ZigClangSourceLoca
1000994 return nullptr;
1001995 }
1002996 }
1003 case clang::Type::FunctionProto:
1004 case clang::Type::FunctionNoProto:
997 case ZigClangType_FunctionProto:
998 case ZigClangType_FunctionNoProto:
1005999 {
1006 const clang::FunctionType *fn_ty = static_cast<const clang::FunctionType*>(ty);
1000 const clang::FunctionType *fn_ty = reinterpret_cast<const clang::FunctionType*>(ty);
10071001
10081002 AstNode *proto_node = trans_create_node(c, NodeTypeFnProto);
10091003 switch (fn_ty->getCallConv()) {
......@@ -1067,14 +1061,14 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, ZigClangSourceLoca
10671061 if (fn_ty->getNoReturnAttr()) {
10681062 proto_node->data.fn_proto.return_type = trans_create_node_symbol_str(c, "noreturn");
10691063 } else {
1070 proto_node->data.fn_proto.return_type = trans_qual_type(c, fn_ty->getReturnType(),
1064 proto_node->data.fn_proto.return_type = trans_qual_type(c, bitcast(fn_ty->getReturnType()),
10711065 source_loc);
10721066 if (proto_node->data.fn_proto.return_type == nullptr) {
10731067 emit_warning(c, source_loc, "unsupported function proto return type");
10741068 return nullptr;
10751069 }
10761070 // convert c_void to actual void (only for return type)
1077 // we do want to look at the AstNode instead of clang::QualType, because
1071 // we do want to look at the AstNode instead of ZigClangQualType, because
10781072 // if they do something like:
10791073 // typedef Foo void;
10801074 // void foo(void) -> Foo;
......@@ -1090,17 +1084,17 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, ZigClangSourceLoca
10901084 proto_node->data.fn_proto.name = buf_create_from_str(fn_name);
10911085 }
10921086
1093 if (ty->getTypeClass() == clang::Type::FunctionNoProto) {
1087 if (ZigClangType_getTypeClass(ty) == ZigClangType_FunctionNoProto) {
10941088 return proto_node;
10951089 }
10961090
1097 const clang::FunctionProtoType *fn_proto_ty = static_cast<const clang::FunctionProtoType*>(ty);
1091 const clang::FunctionProtoType *fn_proto_ty = reinterpret_cast<const clang::FunctionProtoType*>(ty);
10981092
10991093 proto_node->data.fn_proto.is_var_args = fn_proto_ty->isVariadic();
11001094 size_t param_count = fn_proto_ty->getNumParams();
11011095
11021096 for (size_t i = 0; i < param_count; i += 1) {
1103 clang::QualType qt = fn_proto_ty->getParamType(i);
1097 ZigClangQualType qt = bitcast(fn_proto_ty->getParamType(i));
11041098 AstNode *param_type_node = trans_qual_type(c, qt, source_loc);
11051099
11061100 if (param_type_node == nullptr) {
......@@ -1114,7 +1108,7 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, ZigClangSourceLoca
11141108 if (param_name != nullptr) {
11151109 param_node->data.param_decl.name = buf_create_from_str(param_name);
11161110 }
1117 param_node->data.param_decl.is_noalias = qt.isRestrictQualified();
1111 param_node->data.param_decl.is_noalias = ZigClangQualType_isRestrictQualified(qt);
11181112 param_node->data.param_decl.type = param_type_node;
11191113 proto_node->data.fn_proto.params.append(param_node);
11201114 }
......@@ -1123,20 +1117,20 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, ZigClangSourceLoca
11231117
11241118 return proto_node;
11251119 }
1126 case clang::Type::Record:
1120 case ZigClangType_Record:
11271121 {
11281122 const ZigClangRecordType *record_ty = reinterpret_cast<const ZigClangRecordType*>(ty);
11291123 return resolve_record_decl(c, ZigClangRecordType_getDecl(record_ty));
11301124 }
1131 case clang::Type::Enum:
1125 case ZigClangType_Enum:
11321126 {
11331127 const ZigClangEnumType *enum_ty = reinterpret_cast<const ZigClangEnumType*>(ty);
11341128 return resolve_enum_decl(c, ZigClangEnumType_getDecl(enum_ty));
11351129 }
1136 case clang::Type::ConstantArray:
1130 case ZigClangType_ConstantArray:
11371131 {
1138 const clang::ConstantArrayType *const_arr_ty = static_cast<const clang::ConstantArrayType *>(ty);
1139 AstNode *child_type_node = trans_qual_type(c, const_arr_ty->getElementType(), source_loc);
1132 const clang::ConstantArrayType *const_arr_ty = reinterpret_cast<const clang::ConstantArrayType *>(ty);
1133 AstNode *child_type_node = trans_qual_type(c, bitcast(const_arr_ty->getElementType()), source_loc);
11401134 if (child_type_node == nullptr) {
11411135 emit_warning(c, source_loc, "unresolved array element type");
11421136 return nullptr;
......@@ -1145,76 +1139,78 @@ static AstNode *trans_type(Context *c, const clang::Type *ty, ZigClangSourceLoca
11451139 AstNode *size_node = trans_create_node_unsigned(c, size);
11461140 return trans_create_node_array_type(c, size_node, child_type_node);
11471141 }
1148 case clang::Type::Paren:
1142 case ZigClangType_Paren:
11491143 {
1150 const clang::ParenType *paren_ty = static_cast<const clang::ParenType *>(ty);
1151 return trans_qual_type(c, paren_ty->getInnerType(), source_loc);
1144 const clang::ParenType *paren_ty = reinterpret_cast<const clang::ParenType *>(ty);
1145 return trans_qual_type(c, bitcast(paren_ty->getInnerType()), source_loc);
11521146 }
1153 case clang::Type::Decayed:
1147 case ZigClangType_Decayed:
11541148 {
1155 const clang::DecayedType *decayed_ty = static_cast<const clang::DecayedType *>(ty);
1156 return trans_qual_type(c, decayed_ty->getDecayedType(), source_loc);
1149 const clang::DecayedType *decayed_ty = reinterpret_cast<const clang::DecayedType *>(ty);
1150 return trans_qual_type(c, bitcast(decayed_ty->getDecayedType()), source_loc);
11571151 }
1158 case clang::Type::Attributed:
1152 case ZigClangType_Attributed:
11591153 {
1160 const clang::AttributedType *attributed_ty = static_cast<const clang::AttributedType *>(ty);
1161 return trans_qual_type(c, attributed_ty->getEquivalentType(), source_loc);
1154 const clang::AttributedType *attributed_ty = reinterpret_cast<const clang::AttributedType *>(ty);
1155 return trans_qual_type(c, bitcast(attributed_ty->getEquivalentType()), source_loc);
11621156 }
1163 case clang::Type::IncompleteArray:
1157 case ZigClangType_IncompleteArray:
11641158 {
1165 const clang::IncompleteArrayType *incomplete_array_ty = static_cast<const clang::IncompleteArrayType *>(ty);
1166 clang::QualType child_qt = incomplete_array_ty->getElementType();
1159 const clang::IncompleteArrayType *incomplete_array_ty = reinterpret_cast<const clang::IncompleteArrayType *>(ty);
1160 ZigClangQualType child_qt = bitcast(incomplete_array_ty->getElementType());
11671161 AstNode *child_type_node = trans_qual_type(c, child_qt, source_loc);
11681162 if (child_type_node == nullptr) {
11691163 emit_warning(c, source_loc, "unresolved array element type");
11701164 return nullptr;
11711165 }
1172 AstNode *pointer_node = trans_create_node_ptr_type(c, child_qt.isConstQualified(),
1173 child_qt.isVolatileQualified(), child_type_node, PtrLenC);
1166 AstNode *pointer_node = trans_create_node_ptr_type(c,
1167 ZigClangQualType_isConstQualified(child_qt),
1168 ZigClangQualType_isVolatileQualified(child_qt),
1169 child_type_node, PtrLenC);
11741170 return pointer_node;
11751171 }
1176 case clang::Type::BlockPointer:
1177 case clang::Type::LValueReference:
1178 case clang::Type::RValueReference:
1179 case clang::Type::MemberPointer:
1180 case clang::Type::VariableArray:
1181 case clang::Type::DependentSizedArray:
1182 case clang::Type::DependentSizedExtVector:
1183 case clang::Type::Vector:
1184 case clang::Type::ExtVector:
1185 case clang::Type::UnresolvedUsing:
1186 case clang::Type::Adjusted:
1187 case clang::Type::TypeOfExpr:
1188 case clang::Type::TypeOf:
1189 case clang::Type::Decltype:
1190 case clang::Type::UnaryTransform:
1191 case clang::Type::TemplateTypeParm:
1192 case clang::Type::SubstTemplateTypeParm:
1193 case clang::Type::SubstTemplateTypeParmPack:
1194 case clang::Type::TemplateSpecialization:
1195 case clang::Type::Auto:
1196 case clang::Type::InjectedClassName:
1197 case clang::Type::DependentName:
1198 case clang::Type::DependentTemplateSpecialization:
1199 case clang::Type::PackExpansion:
1200 case clang::Type::ObjCObject:
1201 case clang::Type::ObjCInterface:
1202 case clang::Type::Complex:
1203 case clang::Type::ObjCObjectPointer:
1204 case clang::Type::Atomic:
1205 case clang::Type::Pipe:
1206 case clang::Type::ObjCTypeParam:
1207 case clang::Type::DeducedTemplateSpecialization:
1208 case clang::Type::DependentAddressSpace:
1209 case clang::Type::DependentVector:
1210 emit_warning(c, source_loc, "unsupported type: '%s'", ty->getTypeClassName());
1172 case ZigClangType_BlockPointer:
1173 case ZigClangType_LValueReference:
1174 case ZigClangType_RValueReference:
1175 case ZigClangType_MemberPointer:
1176 case ZigClangType_VariableArray:
1177 case ZigClangType_DependentSizedArray:
1178 case ZigClangType_DependentSizedExtVector:
1179 case ZigClangType_Vector:
1180 case ZigClangType_ExtVector:
1181 case ZigClangType_UnresolvedUsing:
1182 case ZigClangType_Adjusted:
1183 case ZigClangType_TypeOfExpr:
1184 case ZigClangType_TypeOf:
1185 case ZigClangType_Decltype:
1186 case ZigClangType_UnaryTransform:
1187 case ZigClangType_TemplateTypeParm:
1188 case ZigClangType_SubstTemplateTypeParm:
1189 case ZigClangType_SubstTemplateTypeParmPack:
1190 case ZigClangType_TemplateSpecialization:
1191 case ZigClangType_Auto:
1192 case ZigClangType_InjectedClassName:
1193 case ZigClangType_DependentName:
1194 case ZigClangType_DependentTemplateSpecialization:
1195 case ZigClangType_PackExpansion:
1196 case ZigClangType_ObjCObject:
1197 case ZigClangType_ObjCInterface:
1198 case ZigClangType_Complex:
1199 case ZigClangType_ObjCObjectPointer:
1200 case ZigClangType_Atomic:
1201 case ZigClangType_Pipe:
1202 case ZigClangType_ObjCTypeParam:
1203 case ZigClangType_DeducedTemplateSpecialization:
1204 case ZigClangType_DependentAddressSpace:
1205 case ZigClangType_DependentVector:
1206 emit_warning(c, source_loc, "unsupported type: '%s'", ZigClangType_getTypeClassName(ty));
12111207 return nullptr;
12121208 }
12131209 zig_unreachable();
12141210}
12151211
1216static AstNode *trans_qual_type(Context *c, clang::QualType qt, ZigClangSourceLocation source_loc) {
1217 return trans_type(c, qt.getTypePtr(), source_loc);
1212static AstNode *trans_qual_type(Context *c, ZigClangQualType qt, ZigClangSourceLocation source_loc) {
1213 return trans_type(c, ZigClangQualType_getTypePtr(qt), source_loc);
12181214}
12191215
12201216static 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
13001296 emit_warning(c, bitcast(expr->getBeginLoc()), "invalid constant expression");
13011297 return nullptr;
13021298 }
1303 AstNode *node = trans_ap_value(c, &result.Val, expr->getType(), bitcast(expr->getBeginLoc()));
1299 AstNode *node = trans_ap_value(c, &result.Val, bitcast(expr->getType()), bitcast(expr->getBeginLoc()));
13041300 return maybe_suppress_result(c, result_used, node);
13051301}
13061302
......@@ -1410,7 +1406,7 @@ static AstNode *trans_create_assign(Context *c, ResultUsed result_used, TransSco
14101406 }
14111407}
14121408
1413static AstNode *trans_create_shift_op(Context *c, TransScope *scope, clang::QualType result_type,
1409static AstNode *trans_create_shift_op(Context *c, TransScope *scope, ZigClangQualType result_type,
14141410 clang::Expr *lhs_expr, BinOpType bin_op, clang::Expr *rhs_expr)
14151411{
14161412 ZigClangSourceLocation rhs_location = bitcast(rhs_expr->getBeginLoc());
......@@ -1440,12 +1436,12 @@ static AstNode *trans_binary_operator(Context *c, ResultUsed result_used, TransS
14401436 return nullptr;
14411437 case clang::BO_Mul: {
14421438 AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(),
1443 qual_type_has_wrapping_overflow(c, stmt->getType()) ? BinOpTypeMultWrap : BinOpTypeMult,
1439 qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())) ? BinOpTypeMultWrap : BinOpTypeMult,
14441440 stmt->getRHS());
14451441 return maybe_suppress_result(c, result_used, node);
14461442 }
14471443 case clang::BO_Div:
1448 if (qual_type_has_wrapping_overflow(c, stmt->getType())) {
1444 if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType()))) {
14491445 // unsigned/float division uses the operator
14501446 AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeDiv, stmt->getRHS());
14511447 return maybe_suppress_result(c, result_used, node);
......@@ -1461,7 +1457,7 @@ static AstNode *trans_binary_operator(Context *c, ResultUsed result_used, TransS
14611457 return maybe_suppress_result(c, result_used, fn_call);
14621458 }
14631459 case clang::BO_Rem:
1464 if (qual_type_has_wrapping_overflow(c, stmt->getType())) {
1460 if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType()))) {
14651461 // unsigned/float division uses the operator
14661462 AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeMod, stmt->getRHS());
14671463 return maybe_suppress_result(c, result_used, node);
......@@ -1478,22 +1474,22 @@ static AstNode *trans_binary_operator(Context *c, ResultUsed result_used, TransS
14781474 }
14791475 case clang::BO_Add: {
14801476 AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(),
1481 qual_type_has_wrapping_overflow(c, stmt->getType()) ? BinOpTypeAddWrap : BinOpTypeAdd,
1477 qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())) ? BinOpTypeAddWrap : BinOpTypeAdd,
14821478 stmt->getRHS());
14831479 return maybe_suppress_result(c, result_used, node);
14841480 }
14851481 case clang::BO_Sub: {
14861482 AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(),
1487 qual_type_has_wrapping_overflow(c, stmt->getType()) ? BinOpTypeSubWrap : BinOpTypeSub,
1483 qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())) ? BinOpTypeSubWrap : BinOpTypeSub,
14881484 stmt->getRHS());
14891485 return maybe_suppress_result(c, result_used, node);
14901486 }
14911487 case clang::BO_Shl: {
1492 AstNode *node = trans_create_shift_op(c, scope, stmt->getType(), stmt->getLHS(), BinOpTypeBitShiftLeft, stmt->getRHS());
1488 AstNode *node = trans_create_shift_op(c, scope, bitcast(stmt->getType()), stmt->getLHS(), BinOpTypeBitShiftLeft, stmt->getRHS());
14931489 return maybe_suppress_result(c, result_used, node);
14941490 }
14951491 case clang::BO_Shr: {
1496 AstNode *node = trans_create_shift_op(c, scope, stmt->getType(), stmt->getLHS(), BinOpTypeBitShiftRight, stmt->getRHS());
1492 AstNode *node = trans_create_shift_op(c, scope, bitcast(stmt->getType()), stmt->getLHS(), BinOpTypeBitShiftRight, stmt->getRHS());
14971493 return maybe_suppress_result(c, result_used, node);
14981494 }
14991495 case clang::BO_LT: {
......@@ -1581,7 +1577,7 @@ static AstNode *trans_create_compound_assign_shift(Context *c, ResultUsed result
15811577 const clang::CompoundAssignOperator *stmt, BinOpType assign_op, BinOpType bin_op)
15821578{
15831579 ZigClangSourceLocation rhs_location = bitcast(stmt->getRHS()->getBeginLoc());
1584 AstNode *rhs_type = qual_type_to_log2_int_ref(c, stmt->getComputationLHSType(), rhs_location);
1580 AstNode *rhs_type = qual_type_to_log2_int_ref(c, bitcast(stmt->getComputationLHSType()), rhs_location);
15851581
15861582 bool use_intermediate_casts = stmt->getComputationLHSType().getTypePtr() != stmt->getComputationResultType().getTypePtr();
15871583 if (!use_intermediate_casts && result_used == ResultUsedNo) {
......@@ -1626,14 +1622,14 @@ static AstNode *trans_create_compound_assign_shift(Context *c, ResultUsed result
16261622
16271623 // operation_type(*_ref)
16281624 AstNode *operation_type_cast = trans_c_cast(c, rhs_location,
1629 stmt->getComputationLHSType(),
1630 stmt->getLHS()->getType(),
1625 bitcast(stmt->getComputationLHSType()),
1626 bitcast(stmt->getLHS()->getType()),
16311627 trans_create_node_ptr_deref(c, trans_create_node_symbol(c, tmp_var_name)));
16321628
16331629 // result_type(... >> u5(rhs))
16341630 AstNode *result_type_cast = trans_c_cast(c, rhs_location,
1635 stmt->getComputationResultType(),
1636 stmt->getComputationLHSType(),
1631 bitcast(stmt->getComputationResultType()),
1632 bitcast(stmt->getComputationLHSType()),
16371633 trans_create_node_bin_op(c,
16381634 operation_type_cast,
16391635 bin_op,
......@@ -1724,7 +1720,7 @@ static AstNode *trans_compound_assign_operator(Context *c, ResultUsed result_use
17241720{
17251721 switch (stmt->getOpcode()) {
17261722 case clang::BO_MulAssign:
1727 if (qual_type_has_wrapping_overflow(c, stmt->getType()))
1723 if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())))
17281724 return trans_create_compound_assign(c, result_used, scope, stmt, BinOpTypeAssignTimesWrap, BinOpTypeMultWrap);
17291725 else
17301726 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
17381734 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle more C compound assign operators: BO_Cmp");
17391735 return nullptr;
17401736 case clang::BO_AddAssign:
1741 if (qual_type_has_wrapping_overflow(c, stmt->getType()))
1737 if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())))
17421738 return trans_create_compound_assign(c, result_used, scope, stmt, BinOpTypeAssignPlusWrap, BinOpTypeAddWrap);
17431739 else
17441740 return trans_create_compound_assign(c, result_used, scope, stmt, BinOpTypeAssignPlus, BinOpTypeAdd);
17451741 case clang::BO_SubAssign:
1746 if (qual_type_has_wrapping_overflow(c, stmt->getType()))
1742 if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())))
17471743 return trans_create_compound_assign(c, result_used, scope, stmt, BinOpTypeAssignMinusWrap, BinOpTypeSubWrap);
17481744 else
17491745 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
17941790 AstNode *target_node = trans_expr(c, ResultUsedYes, scope, stmt->getSubExpr(), TransRValue);
17951791 if (target_node == nullptr)
17961792 return nullptr;
1797 AstNode *node = trans_c_cast(c, bitcast(stmt->getExprLoc()), stmt->getType(),
1798 stmt->getSubExpr()->getType(), target_node);
1793 AstNode *node = trans_c_cast(c, bitcast(stmt->getExprLoc()), bitcast(stmt->getType()),
1794 bitcast(stmt->getSubExpr()->getType()), target_node);
17991795 return maybe_suppress_result(c, result_used, node);
18001796 }
18011797 case clang::CK_FunctionToPointerDecay:
......@@ -2106,22 +2102,22 @@ static AstNode *trans_create_pre_crement(Context *c, ResultUsed result_used, Tra
21062102static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransScope *scope, const clang::UnaryOperator *stmt) {
21072103 switch (stmt->getOpcode()) {
21082104 case clang::UO_PostInc:
2109 if (qual_type_has_wrapping_overflow(c, stmt->getType()))
2105 if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())))
21102106 return trans_create_post_crement(c, result_used, scope, stmt, BinOpTypeAssignPlusWrap);
21112107 else
21122108 return trans_create_post_crement(c, result_used, scope, stmt, BinOpTypeAssignPlus);
21132109 case clang::UO_PostDec:
2114 if (qual_type_has_wrapping_overflow(c, stmt->getType()))
2110 if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())))
21152111 return trans_create_post_crement(c, result_used, scope, stmt, BinOpTypeAssignMinusWrap);
21162112 else
21172113 return trans_create_post_crement(c, result_used, scope, stmt, BinOpTypeAssignMinus);
21182114 case clang::UO_PreInc:
2119 if (qual_type_has_wrapping_overflow(c, stmt->getType()))
2115 if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())))
21202116 return trans_create_pre_crement(c, result_used, scope, stmt, BinOpTypeAssignPlusWrap);
21212117 else
21222118 return trans_create_pre_crement(c, result_used, scope, stmt, BinOpTypeAssignPlus);
21232119 case clang::UO_PreDec:
2124 if (qual_type_has_wrapping_overflow(c, stmt->getType()))
2120 if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())))
21252121 return trans_create_pre_crement(c, result_used, scope, stmt, BinOpTypeAssignMinusWrap);
21262122 else
21272123 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
21372133 AstNode *value_node = trans_expr(c, result_used, scope, stmt->getSubExpr(), TransRValue);
21382134 if (value_node == nullptr)
21392135 return nullptr;
2140 bool is_fn_ptr = qual_type_is_fn_ptr(stmt->getSubExpr()->getType());
2136 bool is_fn_ptr = qual_type_is_fn_ptr(bitcast(stmt->getSubExpr()->getType()));
21412137 if (is_fn_ptr)
21422138 return value_node;
21432139 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
21492145 case clang::UO_Minus:
21502146 {
21512147 clang::Expr *op_expr = stmt->getSubExpr();
2152 if (!qual_type_has_wrapping_overflow(c, op_expr->getType())) {
2148 if (!qual_type_has_wrapping_overflow(c, bitcast(op_expr->getType()))) {
21532149 AstNode *node = trans_create_node(c, NodeTypePrefixOpExpr);
21542150 node->data.prefix_op_expr.prefix_op = PrefixOpNegation;
21552151
......@@ -2158,7 +2154,7 @@ static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransSc
21582154 return nullptr;
21592155
21602156 return node;
2161 } else if (c_is_unsigned_integer(c, op_expr->getType())) {
2157 } else if (c_is_unsigned_integer(c, bitcast(op_expr->getType()))) {
21622158 // we gotta emit 0 -% x
21632159 AstNode *node = trans_create_node(c, NodeTypeBinOpExpr);
21642160 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
22212217 switch (decl->getKind()) {
22222218 case clang::Decl::Var: {
22232219 clang::VarDecl *var_decl = (clang::VarDecl *)decl;
2224 clang::QualType qual_type = var_decl->getTypeSourceInfo()->getType();
2220 ZigClangQualType qual_type = bitcast(var_decl->getTypeSourceInfo()->getType());
22252221 AstNode *init_node = nullptr;
22262222 if (var_decl->hasInit()) {
22272223 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
22402236 TransScopeVar *var_scope = trans_scope_var_create(c, scope, c_symbol_name);
22412237 scope = &var_scope->base;
22422238
2243 AstNode *node = trans_create_node_var_decl_local(c, qual_type.isConstQualified(),
2239 AstNode *node = trans_create_node_var_decl_local(c,
2240 ZigClangQualType_isConstQualified(qual_type),
22442241 var_scope->zig_name, type_node, init_node);
22452242
22462243 scope_block->node->data.block.statements.append(node);
......@@ -2526,12 +2523,12 @@ static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *
25262523 }
25272524
25282525
2529 const clang::Type *ty = get_expr_qual_type_before_implicit_cast(c, expr).getTypePtr();
2530 auto classs = ty->getTypeClass();
2526 const ZigClangType *ty = ZigClangQualType_getTypePtr(get_expr_qual_type_before_implicit_cast(c, expr));
2527 auto classs = ZigClangType_getTypeClass(ty);
25312528 switch (classs) {
2532 case clang::Type::Builtin:
2529 case ZigClangType_Builtin:
25332530 {
2534 const clang::BuiltinType *builtin_ty = static_cast<const clang::BuiltinType*>(ty);
2531 const clang::BuiltinType *builtin_ty = reinterpret_cast<const clang::BuiltinType*>(ty);
25352532 switch (builtin_ty->getKind()) {
25362533 case clang::BuiltinType::Bool:
25372534 case clang::BuiltinType::Char_U:
......@@ -2657,11 +2654,11 @@ static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *
26572654 }
26582655 break;
26592656 }
2660 case clang::Type::Pointer:
2657 case ZigClangType_Pointer:
26612658 return trans_create_node_bin_op(c, res, BinOpTypeCmpNotEq,
26622659 trans_create_node_unsigned(c, 0));
26632660
2664 case clang::Type::Typedef:
2661 case ZigClangType_Typedef:
26652662 {
26662663 const ZigClangTypedefType *typedef_ty = reinterpret_cast<const ZigClangTypedefType*>(ty);
26672664 const ZigClangTypedefNameDecl *typedef_decl = ZigClangTypedefType_getDecl(typedef_ty);
......@@ -2673,19 +2670,20 @@ static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *
26732670 return res;
26742671 }
26752672
2676 case clang::Type::Enum:
2673 case ZigClangType_Enum:
26772674 {
26782675 const ZigClangEnumType *enum_ty = reinterpret_cast<const ZigClangEnumType *>(ty);
26792676 AstNode *enum_type = resolve_enum_decl(c, ZigClangEnumType_getDecl(enum_ty));
26802677 return to_enum_zero_cmp(c, res, enum_type);
26812678 }
26822679
2683 case clang::Type::Elaborated:
2680 case ZigClangType_Elaborated:
26842681 {
2685 const clang::ElaboratedType *elaborated_ty = static_cast<const clang::ElaboratedType*>(ty);
2682 const clang::ElaboratedType *elaborated_ty = reinterpret_cast<const clang::ElaboratedType*>(ty);
26862683 switch (elaborated_ty->getKeyword()) {
26872684 case clang::ETK_Enum: {
2688 AstNode *enum_type = trans_qual_type(c, elaborated_ty->getNamedType(), bitcast(expr->getBeginLoc()));
2685 AstNode *enum_type = trans_qual_type(c, bitcast(elaborated_ty->getNamedType()),
2686 bitcast(expr->getBeginLoc()));
26892687 return to_enum_zero_cmp(c, res, enum_type);
26902688 }
26912689 case clang::ETK_Struct:
......@@ -2698,48 +2696,48 @@ static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *
26982696 }
26992697 }
27002698
2701 case clang::Type::FunctionProto:
2702 case clang::Type::Record:
2703 case clang::Type::ConstantArray:
2704 case clang::Type::Paren:
2705 case clang::Type::Decayed:
2706 case clang::Type::Attributed:
2707 case clang::Type::IncompleteArray:
2708 case clang::Type::BlockPointer:
2709 case clang::Type::LValueReference:
2710 case clang::Type::RValueReference:
2711 case clang::Type::MemberPointer:
2712 case clang::Type::VariableArray:
2713 case clang::Type::DependentSizedArray:
2714 case clang::Type::DependentSizedExtVector:
2715 case clang::Type::Vector:
2716 case clang::Type::ExtVector:
2717 case clang::Type::FunctionNoProto:
2718 case clang::Type::UnresolvedUsing:
2719 case clang::Type::Adjusted:
2720 case clang::Type::TypeOfExpr:
2721 case clang::Type::TypeOf:
2722 case clang::Type::Decltype:
2723 case clang::Type::UnaryTransform:
2724 case clang::Type::TemplateTypeParm:
2725 case clang::Type::SubstTemplateTypeParm:
2726 case clang::Type::SubstTemplateTypeParmPack:
2727 case clang::Type::TemplateSpecialization:
2728 case clang::Type::Auto:
2729 case clang::Type::InjectedClassName:
2730 case clang::Type::DependentName:
2731 case clang::Type::DependentTemplateSpecialization:
2732 case clang::Type::PackExpansion:
2733 case clang::Type::ObjCObject:
2734 case clang::Type::ObjCInterface:
2735 case clang::Type::Complex:
2736 case clang::Type::ObjCObjectPointer:
2737 case clang::Type::Atomic:
2738 case clang::Type::Pipe:
2739 case clang::Type::ObjCTypeParam:
2740 case clang::Type::DeducedTemplateSpecialization:
2741 case clang::Type::DependentAddressSpace:
2742 case clang::Type::DependentVector:
2699 case ZigClangType_FunctionProto:
2700 case ZigClangType_Record:
2701 case ZigClangType_ConstantArray:
2702 case ZigClangType_Paren:
2703 case ZigClangType_Decayed:
2704 case ZigClangType_Attributed:
2705 case ZigClangType_IncompleteArray:
2706 case ZigClangType_BlockPointer:
2707 case ZigClangType_LValueReference:
2708 case ZigClangType_RValueReference:
2709 case ZigClangType_MemberPointer:
2710 case ZigClangType_VariableArray:
2711 case ZigClangType_DependentSizedArray:
2712 case ZigClangType_DependentSizedExtVector:
2713 case ZigClangType_Vector:
2714 case ZigClangType_ExtVector:
2715 case ZigClangType_FunctionNoProto:
2716 case ZigClangType_UnresolvedUsing:
2717 case ZigClangType_Adjusted:
2718 case ZigClangType_TypeOfExpr:
2719 case ZigClangType_TypeOf:
2720 case ZigClangType_Decltype:
2721 case ZigClangType_UnaryTransform:
2722 case ZigClangType_TemplateTypeParm:
2723 case ZigClangType_SubstTemplateTypeParm:
2724 case ZigClangType_SubstTemplateTypeParmPack:
2725 case ZigClangType_TemplateSpecialization:
2726 case ZigClangType_Auto:
2727 case ZigClangType_InjectedClassName:
2728 case ZigClangType_DependentName:
2729 case ZigClangType_DependentTemplateSpecialization:
2730 case ZigClangType_PackExpansion:
2731 case ZigClangType_ObjCObject:
2732 case ZigClangType_ObjCInterface:
2733 case ZigClangType_Complex:
2734 case ZigClangType_ObjCObjectPointer:
2735 case ZigClangType_Atomic:
2736 case ZigClangType_Pipe:
2737 case ZigClangType_ObjCTypeParam:
2738 case ZigClangType_DeducedTemplateSpecialization:
2739 case ZigClangType_DependentAddressSpace:
2740 case ZigClangType_DependentVector:
27432741 return res;
27442742 }
27452743 zig_unreachable();
......@@ -2790,7 +2788,7 @@ static AstNode *trans_call_expr(Context *c, ResultUsed result_used, TransScope *
27902788 return nullptr;
27912789
27922790 bool is_ptr = false;
2793 const clang::FunctionProtoType *fn_ty = qual_type_get_fn_proto(stmt->getCallee()->getType(), &is_ptr);
2791 const clang::FunctionProtoType *fn_ty = qual_type_get_fn_proto(bitcast(stmt->getCallee()->getType()), &is_ptr);
27942792 AstNode *callee_node = nullptr;
27952793 if (is_ptr && fn_ty) {
27962794 if (stmt->getCallee()->getStmtClass() == clang::Stmt::ImplicitCastExprClass) {
......@@ -2824,7 +2822,9 @@ static AstNode *trans_call_expr(Context *c, ResultUsed result_used, TransScope *
28242822 node->data.fn_call_expr.params.append(arg_node);
28252823 }
28262824
2827 if (result_used == ResultUsedNo && fn_ty && !qual_type_canon(fn_ty->getReturnType())->isVoidType()) {
2825 if (result_used == ResultUsedNo && fn_ty &&
2826 !ZigClangType_isVoidType(qual_type_canon(bitcast(fn_ty->getReturnType()))))
2827 {
28282828 node = trans_create_node_bin_op(c, trans_create_node_symbol_str(c, "_"), BinOpTypeAssign, node);
28292829 }
28302830
......@@ -2871,7 +2871,8 @@ static AstNode *trans_c_style_cast_expr(Context *c, ResultUsed result_used, Tran
28712871 if (sub_expr_node == nullptr)
28722872 return nullptr;
28732873
2874 AstNode *cast = trans_c_cast(c, bitcast(stmt->getBeginLoc()), stmt->getType(), stmt->getSubExpr()->getType(), sub_expr_node);
2874 AstNode *cast = trans_c_cast(c, bitcast(stmt->getBeginLoc()), bitcast(stmt->getType()),
2875 bitcast(stmt->getSubExpr()->getType()), sub_expr_node);
28752876 if (cast == nullptr)
28762877 return nullptr;
28772878
......@@ -2881,7 +2882,7 @@ static AstNode *trans_c_style_cast_expr(Context *c, ResultUsed result_used, Tran
28812882static AstNode *trans_unary_expr_or_type_trait_expr(Context *c, ResultUsed result_used,
28822883 TransScope *scope, const clang::UnaryExprOrTypeTraitExpr *stmt)
28832884{
2884 AstNode *type_node = trans_qual_type(c, stmt->getTypeOfArgument(), bitcast(stmt->getBeginLoc()));
2885 AstNode *type_node = trans_qual_type(c, bitcast(stmt->getTypeOfArgument()), bitcast(stmt->getBeginLoc()));
28852886 if (type_node == nullptr)
28862887 return nullptr;
28872888
......@@ -3858,7 +3859,7 @@ static void visit_fn_decl(Context *c, const clang::FunctionDecl *fn_decl) {
38583859 return;
38593860 }
38603861
3861 AstNode *proto_node = trans_qual_type(c, fn_decl->getType(), bitcast(fn_decl->getLocation()));
3862 AstNode *proto_node = trans_qual_type(c, bitcast(fn_decl->getType()), bitcast(fn_decl->getLocation()));
38623863 if (proto_node == nullptr) {
38633864 emit_warning(c, bitcast(fn_decl->getLocation()), "unable to resolve prototype of function '%s'", buf_ptr(fn_name));
38643865 return;
......@@ -4003,7 +4004,7 @@ static AstNode *resolve_typedef_decl(Context *c, const ZigClangTypedefNameDecl *
40034004 AstNode *symbol_node = trans_create_node_symbol(c, type_name);
40044005 c->decl_table.put(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl), symbol_node);
40054006
4006 AstNode *type_node = trans_qual_type(c, bitcast(child_qt), ZigClangTypedefNameDecl_getLocation(typedef_decl));
4007 AstNode *type_node = trans_qual_type(c, child_qt, ZigClangTypedefNameDecl_getLocation(typedef_decl));
40074008 if (type_node == nullptr) {
40084009 emit_warning(c, ZigClangTypedefNameDecl_getLocation(typedef_decl),
40094010 "typedef %s - unresolved child type", buf_ptr(type_name));
......@@ -4059,8 +4060,7 @@ static AstNode *resolve_enum_decl(Context *c, const ZigClangEnumDecl *enum_decl)
40594060 pure_enum = false;
40604061 }
40614062 }
4062 AstNode *tag_int_type = trans_qual_type(c,
4063 bitcast(ZigClangEnumDecl_getIntegerType(enum_decl)),
4063 AstNode *tag_int_type = trans_qual_type(c, ZigClangEnumDecl_getIntegerType(enum_decl),
40644064 ZigClangEnumDecl_getLocation(enum_decl));
40654065 assert(tag_int_type);
40664066
......@@ -4070,8 +4070,8 @@ static AstNode *resolve_enum_decl(Context *c, const ZigClangEnumDecl *enum_decl)
40704070 // TODO only emit this tag type if the enum tag type is not the default.
40714071 // I don't know what the default is, need to figure out how clang is deciding.
40724072 // it appears to at least be different across gcc/msvc
4073 if (!c_is_builtin_type(c, bitcast(ZigClangEnumDecl_getIntegerType(enum_decl)), clang::BuiltinType::UInt) &&
4074 !c_is_builtin_type(c, bitcast(ZigClangEnumDecl_getIntegerType(enum_decl)), clang::BuiltinType::Int))
4073 if (!c_is_builtin_type(c, ZigClangEnumDecl_getIntegerType(enum_decl), clang::BuiltinType::UInt) &&
4074 !c_is_builtin_type(c, ZigClangEnumDecl_getIntegerType(enum_decl), clang::BuiltinType::Int))
40754075 {
40764076 enum_node->data.container_decl.init_arg_expr = tag_int_type;
40774077 }
......@@ -4209,7 +4209,7 @@ static AstNode *resolve_record_decl(Context *c, const ZigClangRecordDecl *record
42094209
42104210 AstNode *field_node = trans_create_node(c, NodeTypeStructField);
42114211 field_node->data.struct_field.name = buf_create_from_str(ZigClangDecl_getName_bytes_begin((const ZigClangDecl *)field_decl));
4212 field_node->data.struct_field.type = trans_qual_type(c, field_decl->getType(),
4212 field_node->data.struct_field.type = trans_qual_type(c, bitcast(field_decl->getType()),
42134213 bitcast(field_decl->getLocation()));
42144214
42154215 if (field_node->data.struct_field.type == nullptr) {
......@@ -4233,7 +4233,7 @@ static AstNode *resolve_record_decl(Context *c, const ZigClangRecordDecl *record
42334233 }
42344234}
42354235
4236static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, clang::QualType qt, ZigClangSourceLocation source_loc) {
4236static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, ZigClangQualType qt, ZigClangSourceLocation source_loc) {
42374237 switch (ap_value->getKind()) {
42384238 case clang::APValue::Int:
42394239 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
42534253 init_node->data.container_init_expr.type = arr_type_node;
42544254 init_node->data.container_init_expr.kind = ContainerInitKindArray;
42554255
4256 clang::QualType child_qt = qt.getTypePtr()->getAsArrayTypeUnsafe()->getElementType();
4256 const clang::Type *qt_type = reinterpret_cast<const clang::Type *>(ZigClangQualType_getTypePtr(qt));
4257 ZigClangQualType child_qt = bitcast(qt_type->getAsArrayTypeUnsafe()->getElementType());
42574258
42584259 for (size_t i = 0; i < init_count; i += 1) {
42594260 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) {
43474348 return;
43484349 }
43494350
4350 clang::QualType qt = var_decl->getType();
4351 ZigClangQualType qt = bitcast(var_decl->getType());
43514352 AstNode *var_type = trans_qual_type(c, qt, bitcast(var_decl->getLocation()));
43524353 if (var_type == nullptr) {
43534354 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) {
43564357
43574358 bool is_extern = var_decl->hasExternalStorage();
43584359 bool is_static = var_decl->isFileVarDecl();
4359 bool is_const = qt.isConstQualified();
4360 bool is_const = ZigClangQualType_isConstQualified(qt);
43604361
43614362 if (is_static && !is_extern) {
43624363 AstNode *init_node;
src/zig_clang.cpp+213-49
......@@ -28,41 +28,41 @@
2828#endif
2929
3030// Detect additions to the enum
31void zig2clang_BO(ZigClangBO op) {
31void zig2clang_BO(clang::BinaryOperatorKind op) {
3232 switch (op) {
33 case ZigClangBO_PtrMemD:
34 case ZigClangBO_PtrMemI:
35 case ZigClangBO_Cmp:
36 case ZigClangBO_Mul:
37 case ZigClangBO_Div:
38 case ZigClangBO_Rem:
39 case ZigClangBO_Add:
40 case ZigClangBO_Sub:
41 case ZigClangBO_Shl:
42 case ZigClangBO_Shr:
43 case ZigClangBO_LT:
44 case ZigClangBO_GT:
45 case ZigClangBO_LE:
46 case ZigClangBO_GE:
47 case ZigClangBO_EQ:
48 case ZigClangBO_NE:
49 case ZigClangBO_And:
50 case ZigClangBO_Xor:
51 case ZigClangBO_Or:
52 case ZigClangBO_LAnd:
53 case ZigClangBO_LOr:
54 case ZigClangBO_Assign:
55 case ZigClangBO_Comma:
56 case ZigClangBO_MulAssign:
57 case ZigClangBO_DivAssign:
58 case ZigClangBO_RemAssign:
59 case ZigClangBO_AddAssign:
60 case ZigClangBO_SubAssign:
61 case ZigClangBO_ShlAssign:
62 case ZigClangBO_ShrAssign:
63 case ZigClangBO_AndAssign:
64 case ZigClangBO_XorAssign:
65 case ZigClangBO_OrAssign:
33 case clang::BO_PtrMemD:
34 case clang::BO_PtrMemI:
35 case clang::BO_Cmp:
36 case clang::BO_Mul:
37 case clang::BO_Div:
38 case clang::BO_Rem:
39 case clang::BO_Add:
40 case clang::BO_Sub:
41 case clang::BO_Shl:
42 case clang::BO_Shr:
43 case clang::BO_LT:
44 case clang::BO_GT:
45 case clang::BO_LE:
46 case clang::BO_GE:
47 case clang::BO_EQ:
48 case clang::BO_NE:
49 case clang::BO_And:
50 case clang::BO_Xor:
51 case clang::BO_Or:
52 case clang::BO_LAnd:
53 case clang::BO_LOr:
54 case clang::BO_Assign:
55 case clang::BO_Comma:
56 case clang::BO_MulAssign:
57 case clang::BO_DivAssign:
58 case clang::BO_RemAssign:
59 case clang::BO_AddAssign:
60 case clang::BO_SubAssign:
61 case clang::BO_ShlAssign:
62 case clang::BO_ShrAssign:
63 case clang::BO_AndAssign:
64 case clang::BO_XorAssign:
65 case clang::BO_OrAssign:
6666 break;
6767 }
6868}
......@@ -102,22 +102,22 @@ static_assert((clang::BinaryOperatorKind)ZigClangBO_Xor == clang::BO_Xor, "");
102102static_assert((clang::BinaryOperatorKind)ZigClangBO_XorAssign == clang::BO_XorAssign, "");
103103
104104// This function detects additions to the enum
105void zig2clang_UO(ZigClangUO op) {
105void zig2clang_UO(clang::UnaryOperatorKind op) {
106106 switch (op) {
107 case ZigClangUO_AddrOf:
108 case ZigClangUO_Coawait:
109 case ZigClangUO_Deref:
110 case ZigClangUO_Extension:
111 case ZigClangUO_Imag:
112 case ZigClangUO_LNot:
113 case ZigClangUO_Minus:
114 case ZigClangUO_Not:
115 case ZigClangUO_Plus:
116 case ZigClangUO_PostDec:
117 case ZigClangUO_PostInc:
118 case ZigClangUO_PreDec:
119 case ZigClangUO_PreInc:
120 case ZigClangUO_Real:
107 case clang::UO_AddrOf:
108 case clang::UO_Coawait:
109 case clang::UO_Deref:
110 case clang::UO_Extension:
111 case clang::UO_Imag:
112 case clang::UO_LNot:
113 case clang::UO_Minus:
114 case clang::UO_Not:
115 case clang::UO_Plus:
116 case clang::UO_PostDec:
117 case clang::UO_PostInc:
118 case clang::UO_PreDec:
119 case clang::UO_PreInc:
120 case clang::UO_Real:
121121 break;
122122 }
123123}
......@@ -137,6 +137,108 @@ static_assert((clang::UnaryOperatorKind)ZigClangUO_PreDec == clang::UO_PreDec, "
137137static_assert((clang::UnaryOperatorKind)ZigClangUO_PreInc == clang::UO_PreInc, "");
138138static_assert((clang::UnaryOperatorKind)ZigClangUO_Real == clang::UO_Real, "");
139139
140void zig2clang_TypeClass(clang::Type::TypeClass ty) {
141 switch (ty) {
142 case clang::Type::Builtin:
143 case clang::Type::Complex:
144 case clang::Type::Pointer:
145 case clang::Type::BlockPointer:
146 case clang::Type::LValueReference:
147 case clang::Type::RValueReference:
148 case clang::Type::MemberPointer:
149 case clang::Type::ConstantArray:
150 case clang::Type::IncompleteArray:
151 case clang::Type::VariableArray:
152 case clang::Type::DependentSizedArray:
153 case clang::Type::DependentSizedExtVector:
154 case clang::Type::DependentAddressSpace:
155 case clang::Type::Vector:
156 case clang::Type::DependentVector:
157 case clang::Type::ExtVector:
158 case clang::Type::FunctionProto:
159 case clang::Type::FunctionNoProto:
160 case clang::Type::UnresolvedUsing:
161 case clang::Type::Paren:
162 case clang::Type::Typedef:
163 case clang::Type::Adjusted:
164 case clang::Type::Decayed:
165 case clang::Type::TypeOfExpr:
166 case clang::Type::TypeOf:
167 case clang::Type::Decltype:
168 case clang::Type::UnaryTransform:
169 case clang::Type::Record:
170 case clang::Type::Enum:
171 case clang::Type::Elaborated:
172 case clang::Type::Attributed:
173 case clang::Type::TemplateTypeParm:
174 case clang::Type::SubstTemplateTypeParm:
175 case clang::Type::SubstTemplateTypeParmPack:
176 case clang::Type::TemplateSpecialization:
177 case clang::Type::Auto:
178 case clang::Type::DeducedTemplateSpecialization:
179 case clang::Type::InjectedClassName:
180 case clang::Type::DependentName:
181 case clang::Type::DependentTemplateSpecialization:
182 case clang::Type::PackExpansion:
183 case clang::Type::ObjCTypeParam:
184 case clang::Type::ObjCObject:
185 case clang::Type::ObjCInterface:
186 case clang::Type::ObjCObjectPointer:
187 case clang::Type::Pipe:
188 case clang::Type::Atomic:
189 break;
190 }
191}
192
193static_assert((clang::Type::TypeClass)ZigClangType_Builtin == clang::Type::Builtin, "");
194static_assert((clang::Type::TypeClass)ZigClangType_Complex == clang::Type::Complex, "");
195static_assert((clang::Type::TypeClass)ZigClangType_Pointer == clang::Type::Pointer, "");
196static_assert((clang::Type::TypeClass)ZigClangType_BlockPointer == clang::Type::BlockPointer, "");
197static_assert((clang::Type::TypeClass)ZigClangType_LValueReference == clang::Type::LValueReference, "");
198static_assert((clang::Type::TypeClass)ZigClangType_RValueReference == clang::Type::RValueReference, "");
199static_assert((clang::Type::TypeClass)ZigClangType_MemberPointer == clang::Type::MemberPointer, "");
200static_assert((clang::Type::TypeClass)ZigClangType_ConstantArray == clang::Type::ConstantArray, "");
201static_assert((clang::Type::TypeClass)ZigClangType_IncompleteArray == clang::Type::IncompleteArray, "");
202static_assert((clang::Type::TypeClass)ZigClangType_VariableArray == clang::Type::VariableArray, "");
203static_assert((clang::Type::TypeClass)ZigClangType_DependentSizedArray == clang::Type::DependentSizedArray, "");
204static_assert((clang::Type::TypeClass)ZigClangType_DependentSizedExtVector == clang::Type::DependentSizedExtVector, "");
205static_assert((clang::Type::TypeClass)ZigClangType_DependentAddressSpace == clang::Type::DependentAddressSpace, "");
206static_assert((clang::Type::TypeClass)ZigClangType_Vector == clang::Type::Vector, "");
207static_assert((clang::Type::TypeClass)ZigClangType_DependentVector == clang::Type::DependentVector, "");
208static_assert((clang::Type::TypeClass)ZigClangType_ExtVector == clang::Type::ExtVector, "");
209static_assert((clang::Type::TypeClass)ZigClangType_FunctionProto == clang::Type::FunctionProto, "");
210static_assert((clang::Type::TypeClass)ZigClangType_FunctionNoProto == clang::Type::FunctionNoProto, "");
211static_assert((clang::Type::TypeClass)ZigClangType_UnresolvedUsing == clang::Type::UnresolvedUsing, "");
212static_assert((clang::Type::TypeClass)ZigClangType_Paren == clang::Type::Paren, "");
213static_assert((clang::Type::TypeClass)ZigClangType_Typedef == clang::Type::Typedef, "");
214static_assert((clang::Type::TypeClass)ZigClangType_Adjusted == clang::Type::Adjusted, "");
215static_assert((clang::Type::TypeClass)ZigClangType_Decayed == clang::Type::Decayed, "");
216static_assert((clang::Type::TypeClass)ZigClangType_TypeOfExpr == clang::Type::TypeOfExpr, "");
217static_assert((clang::Type::TypeClass)ZigClangType_TypeOf == clang::Type::TypeOf, "");
218static_assert((clang::Type::TypeClass)ZigClangType_Decltype == clang::Type::Decltype, "");
219static_assert((clang::Type::TypeClass)ZigClangType_UnaryTransform == clang::Type::UnaryTransform, "");
220static_assert((clang::Type::TypeClass)ZigClangType_Record == clang::Type::Record, "");
221static_assert((clang::Type::TypeClass)ZigClangType_Enum == clang::Type::Enum, "");
222static_assert((clang::Type::TypeClass)ZigClangType_Elaborated == clang::Type::Elaborated, "");
223static_assert((clang::Type::TypeClass)ZigClangType_Attributed == clang::Type::Attributed, "");
224static_assert((clang::Type::TypeClass)ZigClangType_TemplateTypeParm == clang::Type::TemplateTypeParm, "");
225static_assert((clang::Type::TypeClass)ZigClangType_SubstTemplateTypeParm == clang::Type::SubstTemplateTypeParm, "");
226static_assert((clang::Type::TypeClass)ZigClangType_SubstTemplateTypeParmPack == clang::Type::SubstTemplateTypeParmPack, "");
227static_assert((clang::Type::TypeClass)ZigClangType_TemplateSpecialization == clang::Type::TemplateSpecialization, "");
228static_assert((clang::Type::TypeClass)ZigClangType_Auto == clang::Type::Auto, "");
229static_assert((clang::Type::TypeClass)ZigClangType_DeducedTemplateSpecialization == clang::Type::DeducedTemplateSpecialization, "");
230static_assert((clang::Type::TypeClass)ZigClangType_InjectedClassName == clang::Type::InjectedClassName, "");
231static_assert((clang::Type::TypeClass)ZigClangType_DependentName == clang::Type::DependentName, "");
232static_assert((clang::Type::TypeClass)ZigClangType_DependentTemplateSpecialization == clang::Type::DependentTemplateSpecialization, "");
233static_assert((clang::Type::TypeClass)ZigClangType_PackExpansion == clang::Type::PackExpansion, "");
234static_assert((clang::Type::TypeClass)ZigClangType_ObjCTypeParam == clang::Type::ObjCTypeParam, "");
235static_assert((clang::Type::TypeClass)ZigClangType_ObjCObject == clang::Type::ObjCObject, "");
236static_assert((clang::Type::TypeClass)ZigClangType_ObjCInterface == clang::Type::ObjCInterface, "");
237static_assert((clang::Type::TypeClass)ZigClangType_ObjCObjectPointer == clang::Type::ObjCObjectPointer, "");
238static_assert((clang::Type::TypeClass)ZigClangType_Pipe == clang::Type::Pipe, "");
239static_assert((clang::Type::TypeClass)ZigClangType_Atomic == clang::Type::Atomic, "");
240
241
140242static_assert(sizeof(ZigClangSourceLocation) == sizeof(clang::SourceLocation), "");
141243static ZigClangSourceLocation bitcast(clang::SourceLocation src) {
142244 ZigClangSourceLocation dest;
......@@ -304,3 +406,65 @@ ZigClangQualType ZigClangTypedefNameDecl_getUnderlyingType(const ZigClangTypedef
304406 clang::QualType ty = casted->getUnderlyingType();
305407 return bitcast(ty);
306408}
409
410ZigClangQualType ZigClangQualType_getCanonicalType(ZigClangQualType self) {
411 clang::QualType qt = bitcast(self);
412 return bitcast(qt.getCanonicalType());
413}
414
415const ZigClangType *ZigClangQualType_getTypePtr(ZigClangQualType self) {
416 clang::QualType qt = bitcast(self);
417 const clang::Type *ty = qt.getTypePtr();
418 return reinterpret_cast<const ZigClangType *>(ty);
419}
420
421void ZigClangQualType_addConst(ZigClangQualType *self) {
422 reinterpret_cast<clang::QualType *>(self)->addConst();
423}
424
425bool ZigClangQualType_eq(ZigClangQualType zig_t1, ZigClangQualType zig_t2) {
426 clang::QualType t1 = bitcast(zig_t1);
427 clang::QualType t2 = bitcast(zig_t2);
428 if (t1.isConstQualified() != t2.isConstQualified()) {
429 return false;
430 }
431 if (t1.isVolatileQualified() != t2.isVolatileQualified()) {
432 return false;
433 }
434 if (t1.isRestrictQualified() != t2.isRestrictQualified()) {
435 return false;
436 }
437 return t1.getTypePtr() == t2.getTypePtr();
438}
439
440bool ZigClangQualType_isConstQualified(ZigClangQualType self) {
441 clang::QualType qt = bitcast(self);
442 return qt.isConstQualified();
443}
444
445bool ZigClangQualType_isVolatileQualified(ZigClangQualType self) {
446 clang::QualType qt = bitcast(self);
447 return qt.isVolatileQualified();
448}
449
450bool ZigClangQualType_isRestrictQualified(ZigClangQualType self) {
451 clang::QualType qt = bitcast(self);
452 return qt.isRestrictQualified();
453}
454
455ZigClangTypeClass ZigClangType_getTypeClass(const ZigClangType *self) {
456 auto casted = reinterpret_cast<const clang::Type *>(self);
457 clang::Type::TypeClass tc = casted->getTypeClass();
458 return (ZigClangTypeClass)tc;
459}
460
461bool ZigClangType_isVoidType(const ZigClangType *self) {
462 auto casted = reinterpret_cast<const clang::Type *>(self);
463 return casted->isVoidType();
464}
465
466const char *ZigClangType_getTypeClassName(const ZigClangType *self) {
467 auto casted = reinterpret_cast<const clang::Type *>(self);
468 return casted->getTypeClassName();
469}
470
src/zig_clang.h+62
......@@ -150,6 +150,56 @@ enum ZigClangUO {
150150 ZigClangUO_Coawait,
151151};
152152
153enum ZigClangTypeClass {
154 ZigClangType_Builtin,
155 ZigClangType_Complex,
156 ZigClangType_Pointer,
157 ZigClangType_BlockPointer,
158 ZigClangType_LValueReference,
159 ZigClangType_RValueReference,
160 ZigClangType_MemberPointer,
161 ZigClangType_ConstantArray,
162 ZigClangType_IncompleteArray,
163 ZigClangType_VariableArray,
164 ZigClangType_DependentSizedArray,
165 ZigClangType_DependentSizedExtVector,
166 ZigClangType_DependentAddressSpace,
167 ZigClangType_Vector,
168 ZigClangType_DependentVector,
169 ZigClangType_ExtVector,
170 ZigClangType_FunctionProto,
171 ZigClangType_FunctionNoProto,
172 ZigClangType_UnresolvedUsing,
173 ZigClangType_Paren,
174 ZigClangType_Typedef,
175 ZigClangType_Adjusted,
176 ZigClangType_Decayed,
177 ZigClangType_TypeOfExpr,
178 ZigClangType_TypeOf,
179 ZigClangType_Decltype,
180 ZigClangType_UnaryTransform,
181 ZigClangType_Record,
182 ZigClangType_Enum,
183 ZigClangType_Elaborated,
184 ZigClangType_Attributed,
185 ZigClangType_TemplateTypeParm,
186 ZigClangType_SubstTemplateTypeParm,
187 ZigClangType_SubstTemplateTypeParmPack,
188 ZigClangType_TemplateSpecialization,
189 ZigClangType_Auto,
190 ZigClangType_DeducedTemplateSpecialization,
191 ZigClangType_InjectedClassName,
192 ZigClangType_DependentName,
193 ZigClangType_DependentTemplateSpecialization,
194 ZigClangType_PackExpansion,
195 ZigClangType_ObjCTypeParam,
196 ZigClangType_ObjCObject,
197 ZigClangType_ObjCInterface,
198 ZigClangType_ObjCObjectPointer,
199 ZigClangType_Pipe,
200 ZigClangType_Atomic,
201};
202
153203//struct ZigClangCC_AAPCS;
154204//struct ZigClangCC_AAPCS_VFP;
155205//struct ZigClangCC_C;
......@@ -285,4 +335,16 @@ ZIG_EXTERN_C bool ZigClangSourceLocation_eq(ZigClangSourceLocation a, ZigClangSo
285335
286336ZIG_EXTERN_C const ZigClangTypedefNameDecl *ZigClangTypedefType_getDecl(const ZigClangTypedefType *);
287337ZIG_EXTERN_C ZigClangQualType ZigClangTypedefNameDecl_getUnderlyingType(const ZigClangTypedefNameDecl *);
338
339ZIG_EXTERN_C ZigClangQualType ZigClangQualType_getCanonicalType(ZigClangQualType);
340ZIG_EXTERN_C const ZigClangType *ZigClangQualType_getTypePtr(ZigClangQualType);
341ZIG_EXTERN_C void ZigClangQualType_addConst(ZigClangQualType *);
342ZIG_EXTERN_C bool ZigClangQualType_eq(ZigClangQualType, ZigClangQualType);
343ZIG_EXTERN_C bool ZigClangQualType_isConstQualified(ZigClangQualType);
344ZIG_EXTERN_C bool ZigClangQualType_isVolatileQualified(ZigClangQualType);
345ZIG_EXTERN_C bool ZigClangQualType_isRestrictQualified(ZigClangQualType);
346
347ZIG_EXTERN_C ZigClangTypeClass ZigClangType_getTypeClass(const ZigClangType *self);
348ZIG_EXTERN_C bool ZigClangType_isVoidType(const ZigClangType *self);
349ZIG_EXTERN_C const char *ZigClangType_getTypeClassName(const ZigClangType *self);
288350#endif