authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-04-15 00:32:27-04:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-04-15 00:32:27-04:00
log5cb18e9c6f5ee49541579ba3e45d9de4fcec8bcb
tree1ab15408d340a7656ab3a6fbbfc4c2f1322c5d7c
parentcc8cf94cb275198f06e6f7456b366f98d0710373
signature Commit is signed but in an unrecognized format.

translate-c: move some code to the C API

See #1964

3 files changed, 387 insertions(+), 234 deletions(-)

src/translate_c.cpp+182-176
......@@ -121,15 +121,20 @@ static int trans_stmt_extra(Context *c, TransScope *scope, const ZigClangStmt *s
121121 AstNode **out_node, TransScope **out_child_scope,
122122 TransScope **out_node_scope);
123123static TransScope *trans_stmt(Context *c, TransScope *scope, const ZigClangStmt *stmt, AstNode **out_node);
124static AstNode *trans_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::Expr *expr, TransLRValue lrval);
124static AstNode *trans_expr(Context *c, ResultUsed result_used, TransScope *scope, const ZigClangExpr *expr, TransLRValue lrval);
125125static AstNode *trans_qual_type(Context *c, ZigClangQualType qt, ZigClangSourceLocation source_loc);
126static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::Expr *expr, TransLRValue lrval);
126static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *scope,
127 const ZigClangExpr *expr, TransLRValue lrval);
127128static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, ZigClangQualType qt, ZigClangSourceLocation source_loc);
128129
129130static const ZigClangStmt *bitcast(const clang::Stmt *src) {
130131 return reinterpret_cast<const ZigClangStmt *>(src);
131132}
132133
134static const ZigClangExpr *bitcast(const clang::Expr *src) {
135 return reinterpret_cast<const ZigClangExpr *>(src);
136}
137
133138static ZigClangSourceLocation bitcast(clang::SourceLocation src) {
134139 ZigClangSourceLocation dest;
135140 memcpy(&dest, static_cast<void *>(&src), sizeof(ZigClangSourceLocation));
......@@ -511,14 +516,14 @@ static const ZigClangType *qual_type_canon(ZigClangQualType qt) {
511516 return ZigClangQualType_getTypePtr(canon);
512517}
513518
514static ZigClangQualType get_expr_qual_type(Context *c, const clang::Expr *expr) {
519static ZigClangQualType get_expr_qual_type(Context *c, const ZigClangExpr *expr) {
515520 // String literals in C are `char *` but they should really be `const char *`.
516 if ((ZigClangStmtClass)expr->getStmtClass() == ZigClangStmt_ImplicitCastExprClass) {
517 const clang::ImplicitCastExpr *cast_expr = static_cast<const clang::ImplicitCastExpr *>(expr);
518 if (cast_expr->getCastKind() == clang::CK_ArrayToPointerDecay) {
519 const clang::Expr *sub_expr = cast_expr->getSubExpr();
520 if ((ZigClangStmtClass)sub_expr->getStmtClass() == ZigClangStmt_StringLiteralClass) {
521 ZigClangQualType array_qt = bitcast(sub_expr->getType());
521 if (ZigClangExpr_getStmtClass(expr) == ZigClangStmt_ImplicitCastExprClass) {
522 const clang::ImplicitCastExpr *cast_expr = reinterpret_cast<const clang::ImplicitCastExpr *>(expr);
523 if ((ZigClangCK)cast_expr->getCastKind() == ZigClangCK_ArrayToPointerDecay) {
524 const ZigClangExpr *sub_expr = bitcast(cast_expr->getSubExpr());
525 if (ZigClangExpr_getStmtClass(sub_expr) == ZigClangStmt_StringLiteralClass) {
526 ZigClangQualType array_qt = ZigClangExpr_getType(sub_expr);
522527 const clang::ArrayType *array_type = reinterpret_cast<const clang::ArrayType *>(
523528 ZigClangQualType_getTypePtr(array_qt));
524529 ZigClangQualType pointee_qt = bitcast(array_type->getElementType());
......@@ -527,26 +532,26 @@ static ZigClangQualType get_expr_qual_type(Context *c, const clang::Expr *expr)
527532 }
528533 }
529534 }
530 return bitcast(expr->getType());
535 return ZigClangExpr_getType(expr);
531536}
532537
533static ZigClangQualType get_expr_qual_type_before_implicit_cast(Context *c, const clang::Expr *expr) {
534 if ((ZigClangStmtClass)expr->getStmtClass() == ZigClangStmt_ImplicitCastExprClass) {
535 const clang::ImplicitCastExpr *cast_expr = static_cast<const clang::ImplicitCastExpr *>(expr);
536 return get_expr_qual_type(c, cast_expr->getSubExpr());
538static ZigClangQualType get_expr_qual_type_before_implicit_cast(Context *c, const ZigClangExpr *expr) {
539 if (ZigClangExpr_getStmtClass(expr) == ZigClangStmt_ImplicitCastExprClass) {
540 const clang::ImplicitCastExpr *cast_expr = reinterpret_cast<const clang::ImplicitCastExpr *>(expr);
541 return get_expr_qual_type(c, bitcast(cast_expr->getSubExpr()));
537542 }
538 return bitcast(expr->getType());
543 return ZigClangExpr_getType(expr);
539544}
540545
541static AstNode *get_expr_type(Context *c, const clang::Expr *expr) {
542 return trans_qual_type(c, get_expr_qual_type(c, expr), bitcast(expr->getBeginLoc()));
546static AstNode *get_expr_type(Context *c, const ZigClangExpr *expr) {
547 return trans_qual_type(c, get_expr_qual_type(c, expr), ZigClangExpr_getBeginLoc(expr));
543548}
544549
545550static bool is_c_void_type(AstNode *node) {
546551 return (node->type == NodeTypeSymbol && buf_eql_str(node->data.symbol_expr.symbol, "c_void"));
547552}
548553
549static bool expr_types_equal(Context *c, const clang::Expr *expr1, const clang::Expr *expr2) {
554static bool expr_types_equal(Context *c, const ZigClangExpr *expr1, const ZigClangExpr *expr2) {
550555 ZigClangQualType t1 = get_expr_qual_type(c, expr1);
551556 ZigClangQualType t2 = get_expr_qual_type(c, expr2);
552557
......@@ -1272,7 +1277,7 @@ static AstNode *trans_stmt_expr(Context *c, ResultUsed result_used, TransScope *
12721277}
12731278
12741279static AstNode *trans_return_stmt(Context *c, TransScope *scope, const clang::ReturnStmt *stmt) {
1275 const clang::Expr *value_expr = stmt->getRetValue();
1280 const ZigClangExpr *value_expr = bitcast(stmt->getRetValue());
12761281 if (value_expr == nullptr) {
12771282 return trans_create_node(c, NodeTypeReturnExpr);
12781283 } else {
......@@ -1311,9 +1316,9 @@ static AstNode *trans_conditional_operator(Context *c, ResultUsed result_used, T
13111316{
13121317 AstNode *node = trans_create_node(c, NodeTypeIfBoolExpr);
13131318
1314 clang::Expr *cond_expr = stmt->getCond();
1315 clang::Expr *true_expr = stmt->getTrueExpr();
1316 clang::Expr *false_expr = stmt->getFalseExpr();
1319 const ZigClangExpr *cond_expr = bitcast(stmt->getCond());
1320 const ZigClangExpr *true_expr = bitcast(stmt->getTrueExpr());
1321 const ZigClangExpr *false_expr = bitcast(stmt->getFalseExpr());
13171322
13181323 node->data.if_bool_expr.condition = trans_expr(c, ResultUsedYes, scope, cond_expr, TransRValue);
13191324 if (node->data.if_bool_expr.condition == nullptr)
......@@ -1330,7 +1335,9 @@ static AstNode *trans_conditional_operator(Context *c, ResultUsed result_used, T
13301335 return maybe_suppress_result(c, result_used, node);
13311336}
13321337
1333static AstNode *trans_create_bin_op(Context *c, TransScope *scope, clang::Expr *lhs, BinOpType bin_op, clang::Expr *rhs) {
1338static AstNode *trans_create_bin_op(Context *c, TransScope *scope, const ZigClangExpr *lhs,
1339 BinOpType bin_op, const ZigClangExpr *rhs)
1340{
13341341 AstNode *node = trans_create_node(c, NodeTypeBinOpExpr);
13351342 node->data.bin_op_expr.bin_op = bin_op;
13361343
......@@ -1345,7 +1352,9 @@ static AstNode *trans_create_bin_op(Context *c, TransScope *scope, clang::Expr *
13451352 return node;
13461353}
13471354
1348static AstNode *trans_create_bool_bin_op(Context *c, TransScope *scope, clang::Expr *lhs, BinOpType bin_op, clang::Expr *rhs) {
1355static AstNode *trans_create_bool_bin_op(Context *c, TransScope *scope, const ZigClangExpr *lhs,
1356 BinOpType bin_op, const ZigClangExpr *rhs)
1357{
13491358 assert(bin_op == BinOpTypeBoolAnd || bin_op == BinOpTypeBoolOr);
13501359 AstNode *node = trans_create_node(c, NodeTypeBinOpExpr);
13511360 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
13611370 return node;
13621371}
13631372
1364static AstNode *trans_create_assign(Context *c, ResultUsed result_used, TransScope *scope, clang::Expr *lhs, clang::Expr *rhs) {
1373static AstNode *trans_create_assign(Context *c, ResultUsed result_used, TransScope *scope,
1374 const ZigClangExpr *lhs, const ZigClangExpr *rhs)
1375{
13651376 if (result_used == ResultUsedNo) {
13661377 // common case
13671378 AstNode *node = trans_create_node(c, NodeTypeBinOpExpr);
......@@ -1413,9 +1424,9 @@ static AstNode *trans_create_assign(Context *c, ResultUsed result_used, TransSco
14131424}
14141425
14151426static AstNode *trans_create_shift_op(Context *c, TransScope *scope, ZigClangQualType result_type,
1416 clang::Expr *lhs_expr, BinOpType bin_op, clang::Expr *rhs_expr)
1427 const ZigClangExpr *lhs_expr, BinOpType bin_op, const ZigClangExpr *rhs_expr)
14171428{
1418 ZigClangSourceLocation rhs_location = bitcast(rhs_expr->getBeginLoc());
1429 ZigClangSourceLocation rhs_location = ZigClangExpr_getBeginLoc(rhs_expr);
14191430 AstNode *rhs_type = qual_type_to_log2_int_ref(c, result_type, rhs_location);
14201431 // lhs >> u5(rh)
14211432
......@@ -1441,23 +1452,23 @@ static AstNode *trans_binary_operator(Context *c, ResultUsed result_used, TransS
14411452 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle more C binary operators: BO_Cmp");
14421453 return nullptr;
14431454 case clang::BO_Mul: {
1444 AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(),
1455 AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()),
14451456 qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())) ? BinOpTypeMultWrap : BinOpTypeMult,
1446 stmt->getRHS());
1457 bitcast(stmt->getRHS()));
14471458 return maybe_suppress_result(c, result_used, node);
14481459 }
14491460 case clang::BO_Div:
14501461 if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType()))) {
14511462 // unsigned/float division uses the operator
1452 AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeDiv, stmt->getRHS());
1463 AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeDiv, bitcast(stmt->getRHS()));
14531464 return maybe_suppress_result(c, result_used, node);
14541465 } else {
14551466 // signed integer division uses @divTrunc
14561467 AstNode *fn_call = trans_create_node_builtin_fn_call_str(c, "divTrunc");
1457 AstNode *lhs = trans_expr(c, ResultUsedYes, scope, stmt->getLHS(), TransLValue);
1468 AstNode *lhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getLHS()), TransLValue);
14581469 if (lhs == nullptr) return nullptr;
14591470 fn_call->data.fn_call_expr.params.append(lhs);
1460 AstNode *rhs = trans_expr(c, ResultUsedYes, scope, stmt->getRHS(), TransLValue);
1471 AstNode *rhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getRHS()), TransLValue);
14611472 if (rhs == nullptr) return nullptr;
14621473 fn_call->data.fn_call_expr.params.append(rhs);
14631474 return maybe_suppress_result(c, result_used, fn_call);
......@@ -1465,97 +1476,97 @@ static AstNode *trans_binary_operator(Context *c, ResultUsed result_used, TransS
14651476 case clang::BO_Rem:
14661477 if (qual_type_has_wrapping_overflow(c, bitcast(stmt->getType()))) {
14671478 // unsigned/float division uses the operator
1468 AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeMod, stmt->getRHS());
1479 AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeMod, bitcast(stmt->getRHS()));
14691480 return maybe_suppress_result(c, result_used, node);
14701481 } else {
14711482 // signed integer division uses @rem
14721483 AstNode *fn_call = trans_create_node_builtin_fn_call_str(c, "rem");
1473 AstNode *lhs = trans_expr(c, ResultUsedYes, scope, stmt->getLHS(), TransLValue);
1484 AstNode *lhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getLHS()), TransLValue);
14741485 if (lhs == nullptr) return nullptr;
14751486 fn_call->data.fn_call_expr.params.append(lhs);
1476 AstNode *rhs = trans_expr(c, ResultUsedYes, scope, stmt->getRHS(), TransLValue);
1487 AstNode *rhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getRHS()), TransLValue);
14771488 if (rhs == nullptr) return nullptr;
14781489 fn_call->data.fn_call_expr.params.append(rhs);
14791490 return maybe_suppress_result(c, result_used, fn_call);
14801491 }
14811492 case clang::BO_Add: {
1482 AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(),
1493 AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()),
14831494 qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())) ? BinOpTypeAddWrap : BinOpTypeAdd,
1484 stmt->getRHS());
1495 bitcast(stmt->getRHS()));
14851496 return maybe_suppress_result(c, result_used, node);
14861497 }
14871498 case clang::BO_Sub: {
1488 AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(),
1499 AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()),
14891500 qual_type_has_wrapping_overflow(c, bitcast(stmt->getType())) ? BinOpTypeSubWrap : BinOpTypeSub,
1490 stmt->getRHS());
1501 bitcast(stmt->getRHS()));
14911502 return maybe_suppress_result(c, result_used, node);
14921503 }
14931504 case clang::BO_Shl: {
1494 AstNode *node = trans_create_shift_op(c, scope, bitcast(stmt->getType()), stmt->getLHS(), BinOpTypeBitShiftLeft, stmt->getRHS());
1505 AstNode *node = trans_create_shift_op(c, scope, bitcast(stmt->getType()), bitcast(stmt->getLHS()), BinOpTypeBitShiftLeft, bitcast(stmt->getRHS()));
14951506 return maybe_suppress_result(c, result_used, node);
14961507 }
14971508 case clang::BO_Shr: {
1498 AstNode *node = trans_create_shift_op(c, scope, bitcast(stmt->getType()), stmt->getLHS(), BinOpTypeBitShiftRight, stmt->getRHS());
1509 AstNode *node = trans_create_shift_op(c, scope, bitcast(stmt->getType()), bitcast(stmt->getLHS()), BinOpTypeBitShiftRight, bitcast(stmt->getRHS()));
14991510 return maybe_suppress_result(c, result_used, node);
15001511 }
15011512 case clang::BO_LT: {
1502 AstNode *node =trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeCmpLessThan, stmt->getRHS());
1513 AstNode *node =trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeCmpLessThan, bitcast(stmt->getRHS()));
15031514 return maybe_suppress_result(c, result_used, node);
15041515 }
15051516 case clang::BO_GT: {
1506 AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeCmpGreaterThan, stmt->getRHS());
1517 AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeCmpGreaterThan, bitcast(stmt->getRHS()));
15071518 return maybe_suppress_result(c, result_used, node);
15081519 }
15091520 case clang::BO_LE: {
1510 AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeCmpLessOrEq, stmt->getRHS());
1521 AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeCmpLessOrEq, bitcast(stmt->getRHS()));
15111522 return maybe_suppress_result(c, result_used, node);
15121523 }
15131524 case clang::BO_GE: {
1514 AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeCmpGreaterOrEq, stmt->getRHS());
1525 AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeCmpGreaterOrEq, bitcast(stmt->getRHS()));
15151526 return maybe_suppress_result(c, result_used, node);
15161527 }
15171528 case clang::BO_EQ: {
1518 AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeCmpEq, stmt->getRHS());
1529 AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeCmpEq, bitcast(stmt->getRHS()));
15191530 return maybe_suppress_result(c, result_used, node);
15201531 }
15211532 case clang::BO_NE: {
1522 AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeCmpNotEq, stmt->getRHS());
1533 AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeCmpNotEq, bitcast(stmt->getRHS()));
15231534 return maybe_suppress_result(c, result_used, node);
15241535 }
15251536 case clang::BO_And: {
1526 AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeBinAnd, stmt->getRHS());
1537 AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeBinAnd, bitcast(stmt->getRHS()));
15271538 return maybe_suppress_result(c, result_used, node);
15281539 }
15291540 case clang::BO_Xor: {
1530 AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeBinXor, stmt->getRHS());
1541 AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeBinXor, bitcast(stmt->getRHS()));
15311542 return maybe_suppress_result(c, result_used, node);
15321543 }
15331544 case clang::BO_Or: {
1534 AstNode *node = trans_create_bin_op(c, scope, stmt->getLHS(), BinOpTypeBinOr, stmt->getRHS());
1545 AstNode *node = trans_create_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeBinOr, bitcast(stmt->getRHS()));
15351546 return maybe_suppress_result(c, result_used, node);
15361547 }
15371548 case clang::BO_LAnd: {
1538 AstNode *node = trans_create_bool_bin_op(c, scope, stmt->getLHS(), BinOpTypeBoolAnd, stmt->getRHS());
1549 AstNode *node = trans_create_bool_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeBoolAnd, bitcast(stmt->getRHS()));
15391550 return maybe_suppress_result(c, result_used, node);
15401551 }
15411552 case clang::BO_LOr: {
1542 AstNode *node = trans_create_bool_bin_op(c, scope, stmt->getLHS(), BinOpTypeBoolOr, stmt->getRHS());
1553 AstNode *node = trans_create_bool_bin_op(c, scope, bitcast(stmt->getLHS()), BinOpTypeBoolOr, bitcast(stmt->getRHS()));
15431554 return maybe_suppress_result(c, result_used, node);
15441555 }
15451556 case clang::BO_Assign:
1546 return trans_create_assign(c, result_used, scope, stmt->getLHS(), stmt->getRHS());
1557 return trans_create_assign(c, result_used, scope, bitcast(stmt->getLHS()), bitcast(stmt->getRHS()));
15471558 case clang::BO_Comma:
15481559 {
15491560 TransScopeBlock *scope_block = trans_scope_block_create(c, scope);
15501561 Buf *label_name = buf_create_from_str("x");
15511562 scope_block->node->data.block.name = label_name;
15521563
1553 AstNode *lhs = trans_expr(c, ResultUsedNo, &scope_block->base, stmt->getLHS(), TransRValue);
1564 AstNode *lhs = trans_expr(c, ResultUsedNo, &scope_block->base, bitcast(stmt->getLHS()), TransRValue);
15541565 if (lhs == nullptr)
15551566 return nullptr;
15561567 scope_block->node->data.block.statements.append(lhs);
15571568
1558 AstNode *rhs = trans_expr(c, ResultUsedYes, &scope_block->base, stmt->getRHS(), TransRValue);
1569 AstNode *rhs = trans_expr(c, ResultUsedYes, &scope_block->base, bitcast(stmt->getRHS()), TransRValue);
15591570 if (rhs == nullptr)
15601571 return nullptr;
15611572
......@@ -1589,10 +1600,10 @@ static AstNode *trans_create_compound_assign_shift(Context *c, ResultUsed result
15891600 if (!use_intermediate_casts && result_used == ResultUsedNo) {
15901601 // simple common case, where the C and Zig are identical:
15911602 // lhs >>= rhs
1592 AstNode *lhs = trans_expr(c, ResultUsedYes, scope, stmt->getLHS(), TransLValue);
1603 AstNode *lhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getLHS()), TransLValue);
15931604 if (lhs == nullptr) return nullptr;
15941605
1595 AstNode *rhs = trans_expr(c, ResultUsedYes, scope, stmt->getRHS(), TransRValue);
1606 AstNode *rhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getRHS()), TransRValue);
15961607 if (rhs == nullptr) return nullptr;
15971608 AstNode *coerced_rhs = trans_create_node_fn_call_1(c, rhs_type, rhs);
15981609
......@@ -1612,7 +1623,7 @@ static AstNode *trans_create_compound_assign_shift(Context *c, ResultUsed result
16121623 child_scope->node->data.block.name = label_name;
16131624
16141625 // const _ref = &lhs;
1615 AstNode *lhs = trans_expr(c, ResultUsedYes, &child_scope->base, stmt->getLHS(), TransLValue);
1626 AstNode *lhs = trans_expr(c, ResultUsedYes, &child_scope->base, bitcast(stmt->getLHS()), TransLValue);
16161627 if (lhs == nullptr) return nullptr;
16171628 AstNode *addr_of_lhs = trans_create_node_addr_of(c, lhs);
16181629 // TODO: avoid name collisions with generated variable names
......@@ -1622,7 +1633,7 @@ static AstNode *trans_create_compound_assign_shift(Context *c, ResultUsed result
16221633
16231634 // *_ref = result_type(operation_type(*_ref) >> u5(rhs));
16241635
1625 AstNode *rhs = trans_expr(c, ResultUsedYes, &child_scope->base, stmt->getRHS(), TransRValue);
1636 AstNode *rhs = trans_expr(c, ResultUsedYes, &child_scope->base, bitcast(stmt->getRHS()), TransRValue);
16261637 if (rhs == nullptr) return nullptr;
16271638 AstNode *coerced_rhs = trans_create_node_fn_call_1(c, rhs_type, rhs);
16281639
......@@ -1667,9 +1678,9 @@ static AstNode *trans_create_compound_assign(Context *c, ResultUsed result_used,
16671678 if (result_used == ResultUsedNo) {
16681679 // simple common case, where the C and Zig are identical:
16691680 // lhs += rhs
1670 AstNode *lhs = trans_expr(c, ResultUsedYes, scope, stmt->getLHS(), TransLValue);
1681 AstNode *lhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getLHS()), TransLValue);
16711682 if (lhs == nullptr) return nullptr;
1672 AstNode *rhs = trans_expr(c, ResultUsedYes, scope, stmt->getRHS(), TransRValue);
1683 AstNode *rhs = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getRHS()), TransRValue);
16731684 if (rhs == nullptr) return nullptr;
16741685 return trans_create_node_bin_op(c, lhs, assign_op, rhs);
16751686 } else {
......@@ -1686,7 +1697,7 @@ static AstNode *trans_create_compound_assign(Context *c, ResultUsed result_used,
16861697 child_scope->node->data.block.name = label_name;
16871698
16881699 // const _ref = &lhs;
1689 AstNode *lhs = trans_expr(c, ResultUsedYes, &child_scope->base, stmt->getLHS(), TransLValue);
1700 AstNode *lhs = trans_expr(c, ResultUsedYes, &child_scope->base, bitcast(stmt->getLHS()), TransLValue);
16901701 if (lhs == nullptr) return nullptr;
16911702 AstNode *addr_of_lhs = trans_create_node_addr_of(c, lhs);
16921703 // TODO: avoid name collisions with generated variable names
......@@ -1696,7 +1707,7 @@ static AstNode *trans_create_compound_assign(Context *c, ResultUsed result_used,
16961707
16971708 // *_ref = *_ref + rhs;
16981709
1699 AstNode *rhs = trans_expr(c, ResultUsedYes, &child_scope->base, stmt->getRHS(), TransRValue);
1710 AstNode *rhs = trans_expr(c, ResultUsedYes, &child_scope->base, bitcast(stmt->getRHS()), TransRValue);
17001711 if (rhs == nullptr) return nullptr;
17011712
17021713 AstNode *assign_statement = trans_create_node_bin_op(c,
......@@ -1788,201 +1799,201 @@ static AstNode *trans_compound_assign_operator(Context *c, ResultUsed result_use
17881799}
17891800
17901801static AstNode *trans_implicit_cast_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::ImplicitCastExpr *stmt) {
1791 switch (stmt->getCastKind()) {
1792 case clang::CK_LValueToRValue:
1793 return trans_expr(c, ResultUsedYes, scope, stmt->getSubExpr(), TransRValue);
1794 case clang::CK_IntegralCast:
1802 switch ((ZigClangCK)stmt->getCastKind()) {
1803 case ZigClangCK_LValueToRValue:
1804 return trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getSubExpr()), TransRValue);
1805 case ZigClangCK_IntegralCast:
17951806 {
1796 AstNode *target_node = trans_expr(c, ResultUsedYes, scope, stmt->getSubExpr(), TransRValue);
1807 AstNode *target_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getSubExpr()), TransRValue);
17971808 if (target_node == nullptr)
17981809 return nullptr;
17991810 AstNode *node = trans_c_cast(c, bitcast(stmt->getExprLoc()), bitcast(stmt->getType()),
18001811 bitcast(stmt->getSubExpr()->getType()), target_node);
18011812 return maybe_suppress_result(c, result_used, node);
18021813 }
1803 case clang::CK_FunctionToPointerDecay:
1804 case clang::CK_ArrayToPointerDecay:
1814 case ZigClangCK_FunctionToPointerDecay:
1815 case ZigClangCK_ArrayToPointerDecay:
18051816 {
1806 AstNode *target_node = trans_expr(c, ResultUsedYes, scope, stmt->getSubExpr(), TransRValue);
1817 AstNode *target_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getSubExpr()), TransRValue);
18071818 if (target_node == nullptr)
18081819 return nullptr;
18091820 return maybe_suppress_result(c, result_used, target_node);
18101821 }
1811 case clang::CK_BitCast:
1822 case ZigClangCK_BitCast:
18121823 {
1813 AstNode *target_node = trans_expr(c, ResultUsedYes, scope, stmt->getSubExpr(), TransRValue);
1824 AstNode *target_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getSubExpr()), TransRValue);
18141825 if (target_node == nullptr)
18151826 return nullptr;
18161827
1817 if (expr_types_equal(c, stmt, stmt->getSubExpr())) {
1828 if (expr_types_equal(c, (const ZigClangExpr *)stmt, bitcast(stmt->getSubExpr()))) {
18181829 return target_node;
18191830 }
18201831
1821 AstNode *dest_type_node = get_expr_type(c, stmt);
1832 AstNode *dest_type_node = get_expr_type(c, (const ZigClangExpr *)stmt);
18221833
18231834 AstNode *node = trans_create_node_builtin_fn_call_str(c, "ptrCast");
18241835 node->data.fn_call_expr.params.append(dest_type_node);
18251836 node->data.fn_call_expr.params.append(target_node);
18261837 return maybe_suppress_result(c, result_used, node);
18271838 }
1828 case clang::CK_NullToPointer:
1839 case ZigClangCK_NullToPointer:
18291840 return trans_create_node_unsigned(c, 0);
1830 case clang::CK_NoOp:
1831 return trans_expr(c, ResultUsedYes, scope, stmt->getSubExpr(), TransRValue);
1832 case clang::CK_Dependent:
1841 case ZigClangCK_NoOp:
1842 return trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getSubExpr()), TransRValue);
1843 case ZigClangCK_Dependent:
18331844 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_Dependent");
18341845 return nullptr;
1835 case clang::CK_LValueBitCast:
1846 case ZigClangCK_LValueBitCast:
18361847 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_LValueBitCast");
18371848 return nullptr;
1838 case clang::CK_BaseToDerived:
1849 case ZigClangCK_BaseToDerived:
18391850 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_BaseToDerived");
18401851 return nullptr;
1841 case clang::CK_DerivedToBase:
1852 case ZigClangCK_DerivedToBase:
18421853 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_DerivedToBase");
18431854 return nullptr;
1844 case clang::CK_UncheckedDerivedToBase:
1855 case ZigClangCK_UncheckedDerivedToBase:
18451856 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_UncheckedDerivedToBase");
18461857 return nullptr;
1847 case clang::CK_Dynamic:
1858 case ZigClangCK_Dynamic:
18481859 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_Dynamic");
18491860 return nullptr;
1850 case clang::CK_ToUnion:
1861 case ZigClangCK_ToUnion:
18511862 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_ToUnion");
18521863 return nullptr;
1853 case clang::CK_NullToMemberPointer:
1864 case ZigClangCK_NullToMemberPointer:
18541865 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_NullToMemberPointer");
18551866 return nullptr;
1856 case clang::CK_BaseToDerivedMemberPointer:
1867 case ZigClangCK_BaseToDerivedMemberPointer:
18571868 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_BaseToDerivedMemberPointer");
18581869 return nullptr;
1859 case clang::CK_DerivedToBaseMemberPointer:
1870 case ZigClangCK_DerivedToBaseMemberPointer:
18601871 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_DerivedToBaseMemberPointer");
18611872 return nullptr;
1862 case clang::CK_MemberPointerToBoolean:
1873 case ZigClangCK_MemberPointerToBoolean:
18631874 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_MemberPointerToBoolean");
18641875 return nullptr;
1865 case clang::CK_ReinterpretMemberPointer:
1876 case ZigClangCK_ReinterpretMemberPointer:
18661877 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_ReinterpretMemberPointer");
18671878 return nullptr;
1868 case clang::CK_UserDefinedConversion:
1879 case ZigClangCK_UserDefinedConversion:
18691880 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation cast CK_UserDefinedConversion");
18701881 return nullptr;
1871 case clang::CK_ConstructorConversion:
1882 case ZigClangCK_ConstructorConversion:
18721883 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ConstructorConversion");
18731884 return nullptr;
1874 case clang::CK_IntegralToPointer:
1885 case ZigClangCK_IntegralToPointer:
18751886 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralToPointer");
18761887 return nullptr;
1877 case clang::CK_PointerToIntegral:
1888 case ZigClangCK_PointerToIntegral:
18781889 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_PointerToIntegral");
18791890 return nullptr;
1880 case clang::CK_PointerToBoolean:
1891 case ZigClangCK_PointerToBoolean:
18811892 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_PointerToBoolean");
18821893 return nullptr;
1883 case clang::CK_ToVoid:
1894 case ZigClangCK_ToVoid:
18841895 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ToVoid");
18851896 return nullptr;
1886 case clang::CK_VectorSplat:
1897 case ZigClangCK_VectorSplat:
18871898 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_VectorSplat");
18881899 return nullptr;
1889 case clang::CK_IntegralToBoolean:
1900 case ZigClangCK_IntegralToBoolean:
18901901 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralToBoolean");
18911902 return nullptr;
1892 case clang::CK_IntegralToFloating:
1903 case ZigClangCK_IntegralToFloating:
18931904 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralToFloating");
18941905 return nullptr;
1895 case clang::CK_FixedPointCast:
1906 case ZigClangCK_FixedPointCast:
18961907 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FixedPointCast");
18971908 return nullptr;
1898 case clang::CK_FixedPointToBoolean:
1909 case ZigClangCK_FixedPointToBoolean:
18991910 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FixedPointToBoolean");
19001911 return nullptr;
1901 case clang::CK_FloatingToIntegral:
1912 case ZigClangCK_FloatingToIntegral:
19021913 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingToIntegral");
19031914 return nullptr;
1904 case clang::CK_FloatingToBoolean:
1915 case ZigClangCK_FloatingToBoolean:
19051916 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingToBoolean");
19061917 return nullptr;
1907 case clang::CK_BooleanToSignedIntegral:
1918 case ZigClangCK_BooleanToSignedIntegral:
19081919 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_BooleanToSignedIntegral");
19091920 return nullptr;
1910 case clang::CK_FloatingCast:
1921 case ZigClangCK_FloatingCast:
19111922 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingCast");
19121923 return nullptr;
1913 case clang::CK_CPointerToObjCPointerCast:
1924 case ZigClangCK_CPointerToObjCPointerCast:
19141925 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_CPointerToObjCPointerCast");
19151926 return nullptr;
1916 case clang::CK_BlockPointerToObjCPointerCast:
1927 case ZigClangCK_BlockPointerToObjCPointerCast:
19171928 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_BlockPointerToObjCPointerCast");
19181929 return nullptr;
1919 case clang::CK_AnyPointerToBlockPointerCast:
1930 case ZigClangCK_AnyPointerToBlockPointerCast:
19201931 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_AnyPointerToBlockPointerCast");
19211932 return nullptr;
1922 case clang::CK_ObjCObjectLValueCast:
1933 case ZigClangCK_ObjCObjectLValueCast:
19231934 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ObjCObjectLValueCast");
19241935 return nullptr;
1925 case clang::CK_FloatingRealToComplex:
1936 case ZigClangCK_FloatingRealToComplex:
19261937 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingRealToComplex");
19271938 return nullptr;
1928 case clang::CK_FloatingComplexToReal:
1939 case ZigClangCK_FloatingComplexToReal:
19291940 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingComplexToReal");
19301941 return nullptr;
1931 case clang::CK_FloatingComplexToBoolean:
1942 case ZigClangCK_FloatingComplexToBoolean:
19321943 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingComplexToBoolean");
19331944 return nullptr;
1934 case clang::CK_FloatingComplexCast:
1945 case ZigClangCK_FloatingComplexCast:
19351946 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingComplexCast");
19361947 return nullptr;
1937 case clang::CK_FloatingComplexToIntegralComplex:
1948 case ZigClangCK_FloatingComplexToIntegralComplex:
19381949 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_FloatingComplexToIntegralComplex");
19391950 return nullptr;
1940 case clang::CK_IntegralRealToComplex:
1951 case ZigClangCK_IntegralRealToComplex:
19411952 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralRealToComplex");
19421953 return nullptr;
1943 case clang::CK_IntegralComplexToReal:
1954 case ZigClangCK_IntegralComplexToReal:
19441955 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralComplexToReal");
19451956 return nullptr;
1946 case clang::CK_IntegralComplexToBoolean:
1957 case ZigClangCK_IntegralComplexToBoolean:
19471958 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralComplexToBoolean");
19481959 return nullptr;
1949 case clang::CK_IntegralComplexCast:
1960 case ZigClangCK_IntegralComplexCast:
19501961 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralComplexCast");
19511962 return nullptr;
1952 case clang::CK_IntegralComplexToFloatingComplex:
1963 case ZigClangCK_IntegralComplexToFloatingComplex:
19531964 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntegralComplexToFloatingComplex");
19541965 return nullptr;
1955 case clang::CK_ARCProduceObject:
1966 case ZigClangCK_ARCProduceObject:
19561967 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ARCProduceObject");
19571968 return nullptr;
1958 case clang::CK_ARCConsumeObject:
1969 case ZigClangCK_ARCConsumeObject:
19591970 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ARCConsumeObject");
19601971 return nullptr;
1961 case clang::CK_ARCReclaimReturnedObject:
1972 case ZigClangCK_ARCReclaimReturnedObject:
19621973 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ARCReclaimReturnedObject");
19631974 return nullptr;
1964 case clang::CK_ARCExtendBlockObject:
1975 case ZigClangCK_ARCExtendBlockObject:
19651976 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ARCExtendBlockObject");
19661977 return nullptr;
1967 case clang::CK_AtomicToNonAtomic:
1978 case ZigClangCK_AtomicToNonAtomic:
19681979 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_AtomicToNonAtomic");
19691980 return nullptr;
1970 case clang::CK_NonAtomicToAtomic:
1981 case ZigClangCK_NonAtomicToAtomic:
19711982 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_NonAtomicToAtomic");
19721983 return nullptr;
1973 case clang::CK_CopyAndAutoreleaseBlockObject:
1984 case ZigClangCK_CopyAndAutoreleaseBlockObject:
19741985 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_CopyAndAutoreleaseBlockObject");
19751986 return nullptr;
1976 case clang::CK_BuiltinFnToFnPtr:
1987 case ZigClangCK_BuiltinFnToFnPtr:
19771988 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_BuiltinFnToFnPtr");
19781989 return nullptr;
1979 case clang::CK_ZeroToOCLOpaqueType:
1990 case ZigClangCK_ZeroToOCLOpaqueType:
19801991 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_ZeroToOCLOpaqueType");
19811992 return nullptr;
1982 case clang::CK_AddressSpaceConversion:
1993 case ZigClangCK_AddressSpaceConversion:
19831994 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_AddressSpaceConversion");
19841995 return nullptr;
1985 case clang::CK_IntToOCLSampler:
1996 case ZigClangCK_IntToOCLSampler:
19861997 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C CK_IntToOCLSampler");
19871998 return nullptr;
19881999 }
......@@ -2002,7 +2013,7 @@ static AstNode *trans_decl_ref_expr(Context *c, TransScope *scope, const clang::
20022013static AstNode *trans_create_post_crement(Context *c, ResultUsed result_used, TransScope *scope,
20032014 const clang::UnaryOperator *stmt, BinOpType assign_op)
20042015{
2005 clang::Expr *op_expr = stmt->getSubExpr();
2016 const ZigClangExpr *op_expr = bitcast(stmt->getSubExpr());
20062017
20072018 if (result_used == ResultUsedNo) {
20082019 // common case
......@@ -2058,7 +2069,7 @@ static AstNode *trans_create_post_crement(Context *c, ResultUsed result_used, Tr
20582069static AstNode *trans_create_pre_crement(Context *c, ResultUsed result_used, TransScope *scope,
20592070 const clang::UnaryOperator *stmt, BinOpType assign_op)
20602071{
2061 clang::Expr *op_expr = stmt->getSubExpr();
2072 const ZigClangExpr *op_expr = bitcast(stmt->getSubExpr());
20622073
20632074 if (result_used == ResultUsedNo) {
20642075 // common case
......@@ -2129,14 +2140,14 @@ static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransSc
21292140 return trans_create_pre_crement(c, result_used, scope, stmt, BinOpTypeAssignMinus);
21302141 case clang::UO_AddrOf:
21312142 {
2132 AstNode *value_node = trans_expr(c, result_used, scope, stmt->getSubExpr(), TransLValue);
2143 AstNode *value_node = trans_expr(c, result_used, scope, bitcast(stmt->getSubExpr()), TransLValue);
21332144 if (value_node == nullptr)
21342145 return value_node;
21352146 return trans_create_node_addr_of(c, value_node);
21362147 }
21372148 case clang::UO_Deref:
21382149 {
2139 AstNode *value_node = trans_expr(c, result_used, scope, stmt->getSubExpr(), TransRValue);
2150 AstNode *value_node = trans_expr(c, result_used, scope, bitcast(stmt->getSubExpr()), TransRValue);
21402151 if (value_node == nullptr)
21412152 return nullptr;
21422153 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
21502161 return nullptr;
21512162 case clang::UO_Minus:
21522163 {
2153 clang::Expr *op_expr = stmt->getSubExpr();
2154 if (!qual_type_has_wrapping_overflow(c, bitcast(op_expr->getType()))) {
2164 const ZigClangExpr *op_expr = bitcast(stmt->getSubExpr());
2165 if (!qual_type_has_wrapping_overflow(c, ZigClangExpr_getType(op_expr))) {
21552166 AstNode *node = trans_create_node(c, NodeTypePrefixOpExpr);
21562167 node->data.prefix_op_expr.prefix_op = PrefixOpNegation;
21572168
......@@ -2160,7 +2171,7 @@ static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransSc
21602171 return nullptr;
21612172
21622173 return node;
2163 } else if (c_is_unsigned_integer(c, bitcast(op_expr->getType()))) {
2174 } else if (c_is_unsigned_integer(c, ZigClangExpr_getType(op_expr))) {
21642175 // we gotta emit 0 -% x
21652176 AstNode *node = trans_create_node(c, NodeTypeBinOpExpr);
21662177 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
21782189 }
21792190 case clang::UO_Not:
21802191 {
2181 clang::Expr *op_expr = stmt->getSubExpr();
2192 const ZigClangExpr *op_expr = bitcast(stmt->getSubExpr());
21822193 AstNode *sub_node = trans_expr(c, ResultUsedYes, scope, op_expr, TransRValue);
21832194 if (sub_node == nullptr)
21842195 return nullptr;
......@@ -2187,7 +2198,7 @@ static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransSc
21872198 }
21882199 case clang::UO_LNot:
21892200 {
2190 clang::Expr *op_expr = stmt->getSubExpr();
2201 const ZigClangExpr *op_expr = bitcast(stmt->getSubExpr());
21912202 AstNode *sub_node = trans_bool_expr(c, ResultUsedYes, scope, op_expr, TransRValue);
21922203 if (sub_node == nullptr)
21932204 return nullptr;
......@@ -2201,7 +2212,7 @@ static AstNode *trans_unary_operator(Context *c, ResultUsed result_used, TransSc
22012212 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation UO_Imag");
22022213 return nullptr;
22032214 case clang::UO_Extension:
2204 return trans_expr(c, result_used, scope, stmt->getSubExpr(), TransLValue);
2215 return trans_expr(c, result_used, scope, bitcast(stmt->getSubExpr()), TransLValue);
22052216 case clang::UO_Coawait:
22062217 emit_warning(c, bitcast(stmt->getBeginLoc()), "TODO handle C translation UO_Coawait");
22072218 return nullptr;
......@@ -2226,7 +2237,7 @@ static int trans_local_declaration(Context *c, TransScope *scope, const clang::D
22262237 ZigClangQualType qual_type = bitcast(var_decl->getTypeSourceInfo()->getType());
22272238 AstNode *init_node = nullptr;
22282239 if (var_decl->hasInit()) {
2229 init_node = trans_expr(c, ResultUsedYes, scope, var_decl->getInit(), TransRValue);
2240 init_node = trans_expr(c, ResultUsedYes, scope, bitcast(var_decl->getInit()), TransRValue);
22302241 if (init_node == nullptr)
22312242 return ErrorUnexpected;
22322243
......@@ -2492,7 +2503,7 @@ static AstNode *to_enum_zero_cmp(Context *c, AstNode *expr, AstNode *enum_type)
24922503 return trans_create_node_bin_op(c, expr, BinOpTypeCmpNotEq, bitcast);
24932504}
24942505
2495static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::Expr *expr, TransLRValue lrval) {
2506static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *scope, const ZigClangExpr *expr, TransLRValue lrval) {
24962507 AstNode *res = trans_expr(c, result_used, scope, expr, lrval);
24972508 if (res == nullptr)
24982509 return nullptr;
......@@ -2689,7 +2700,7 @@ static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *
26892700 switch (elaborated_ty->getKeyword()) {
26902701 case clang::ETK_Enum: {
26912702 AstNode *enum_type = trans_qual_type(c, bitcast(elaborated_ty->getNamedType()),
2692 bitcast(expr->getBeginLoc()));
2703 ZigClangExpr_getBeginLoc(expr));
26932704 return to_enum_zero_cmp(c, res, enum_type);
26942705 }
26952706 case clang::ETK_Struct:
......@@ -2752,7 +2763,8 @@ static AstNode *trans_bool_expr(Context *c, ResultUsed result_used, TransScope *
27522763static AstNode *trans_while_loop(Context *c, TransScope *scope, const clang::WhileStmt *stmt) {
27532764 TransScopeWhile *while_scope = trans_scope_while_create(c, scope);
27542765
2755 while_scope->node->data.while_expr.condition = trans_bool_expr(c, ResultUsedYes, scope, stmt->getCond(), TransRValue);
2766 while_scope->node->data.while_expr.condition = trans_bool_expr(c, ResultUsedYes, scope,
2767 bitcast(stmt->getCond()), TransRValue);
27562768 if (while_scope->node->data.while_expr.condition == nullptr)
27572769 return nullptr;
27582770
......@@ -2779,7 +2791,8 @@ static AstNode *trans_if_statement(Context *c, TransScope *scope, const clang::I
27792791 return nullptr;
27802792 }
27812793
2782 if_node->data.if_bool_expr.condition = trans_bool_expr(c, ResultUsedYes, scope, stmt->getCond(), TransRValue);
2794 if_node->data.if_bool_expr.condition = trans_bool_expr(c, ResultUsedYes, scope, bitcast(stmt->getCond()),
2795 TransRValue);
27832796 if (if_node->data.if_bool_expr.condition == nullptr)
27842797 return nullptr;
27852798
......@@ -2789,7 +2802,7 @@ static AstNode *trans_if_statement(Context *c, TransScope *scope, const clang::I
27892802static AstNode *trans_call_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::CallExpr *stmt) {
27902803 AstNode *node = trans_create_node(c, NodeTypeFnCallExpr);
27912804
2792 AstNode *callee_raw_node = trans_expr(c, ResultUsedYes, scope, stmt->getCallee(), TransRValue);
2805 AstNode *callee_raw_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getCallee()), TransRValue);
27932806 if (callee_raw_node == nullptr)
27942807 return nullptr;
27952808
......@@ -2799,7 +2812,7 @@ static AstNode *trans_call_expr(Context *c, ResultUsed result_used, TransScope *
27992812 if (is_ptr && fn_ty) {
28002813 if ((ZigClangStmtClass)stmt->getCallee()->getStmtClass() == ZigClangStmt_ImplicitCastExprClass) {
28012814 const clang::ImplicitCastExpr *implicit_cast = static_cast<const clang::ImplicitCastExpr *>(stmt->getCallee());
2802 if (implicit_cast->getCastKind() == clang::CK_FunctionToPointerDecay) {
2815 if ((ZigClangCK)implicit_cast->getCastKind() == ZigClangCK_FunctionToPointerDecay) {
28032816 if ((ZigClangStmtClass)implicit_cast->getSubExpr()->getStmtClass() == ZigClangStmt_DeclRefExprClass) {
28042817 const clang::DeclRefExpr *decl_ref = static_cast<const clang::DeclRefExpr *>(implicit_cast->getSubExpr());
28052818 const clang::Decl *decl = decl_ref->getFoundDecl();
......@@ -2819,7 +2832,7 @@ static AstNode *trans_call_expr(Context *c, ResultUsed result_used, TransScope *
28192832 node->data.fn_call_expr.fn_ref_expr = callee_node;
28202833
28212834 unsigned num_args = stmt->getNumArgs();
2822 const clang::Expr * const* args = stmt->getArgs();
2835 const ZigClangExpr * const* args = reinterpret_cast<const ZigClangExpr * const*>(stmt->getArgs());
28232836 for (unsigned i = 0; i < num_args; i += 1) {
28242837 AstNode *arg_node = trans_expr(c, ResultUsedYes, scope, args[i], TransRValue);
28252838 if (arg_node == nullptr)
......@@ -2840,7 +2853,7 @@ static AstNode *trans_call_expr(Context *c, ResultUsed result_used, TransScope *
28402853static AstNode *trans_member_expr(Context *c, ResultUsed result_used, TransScope *scope,
28412854 const clang::MemberExpr *stmt)
28422855{
2843 AstNode *container_node = trans_expr(c, ResultUsedYes, scope, stmt->getBase(), TransRValue);
2856 AstNode *container_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getBase()), TransRValue);
28442857 if (container_node == nullptr)
28452858 return nullptr;
28462859
......@@ -2855,11 +2868,11 @@ static AstNode *trans_member_expr(Context *c, ResultUsed result_used, TransScope
28552868}
28562869
28572870static AstNode *trans_array_subscript_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::ArraySubscriptExpr *stmt) {
2858 AstNode *container_node = trans_expr(c, ResultUsedYes, scope, stmt->getBase(), TransRValue);
2871 AstNode *container_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getBase()), TransRValue);
28592872 if (container_node == nullptr)
28602873 return nullptr;
28612874
2862 AstNode *idx_node = trans_expr(c, ResultUsedYes, scope, stmt->getIdx(), TransRValue);
2875 AstNode *idx_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getIdx()), TransRValue);
28632876 if (idx_node == nullptr)
28642877 return nullptr;
28652878
......@@ -2873,7 +2886,7 @@ static AstNode *trans_array_subscript_expr(Context *c, ResultUsed result_used, T
28732886static AstNode *trans_c_style_cast_expr(Context *c, ResultUsed result_used, TransScope *scope,
28742887 const clang::CStyleCastExpr *stmt, TransLRValue lrvalue)
28752888{
2876 AstNode *sub_expr_node = trans_expr(c, ResultUsedYes, scope, stmt->getSubExpr(), lrvalue);
2889 AstNode *sub_expr_node = trans_expr(c, ResultUsedYes, scope, bitcast(stmt->getSubExpr()), lrvalue);
28772890 if (sub_expr_node == nullptr)
28782891 return nullptr;
28792892
......@@ -2943,7 +2956,7 @@ static AstNode *trans_do_loop(Context *c, TransScope *parent_scope, const clang:
29432956 }
29442957
29452958 // if (!cond) break;
2946 AstNode *condition_node = trans_expr(c, ResultUsedYes, child_scope, stmt->getCond(), TransRValue);
2959 AstNode *condition_node = trans_expr(c, ResultUsedYes, child_scope, bitcast(stmt->getCond()), TransRValue);
29472960 if (condition_node == nullptr) return nullptr;
29482961 AstNode *terminator_node = trans_create_node(c, NodeTypeIfBoolExpr);
29492962 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
29822995 child_scope->node->data.block.statements.append(while_scope->node);
29832996 }
29842997
2985 const ZigClangStmt *cond_stmt = bitcast(stmt->getCond());
2986 if (cond_stmt == nullptr) {
2998 const ZigClangExpr *cond_expr = bitcast(stmt->getCond());
2999 if (cond_expr == nullptr) {
29873000 while_scope->node->data.while_expr.condition = trans_create_node_bool(c, true);
29883001 } else {
2989 if (ZigClangStmt_classof_Expr(cond_stmt)) {
2990 const clang::Expr *cond_expr = reinterpret_cast<const clang::Expr*>(cond_stmt);
2991 while_scope->node->data.while_expr.condition = trans_bool_expr(c, ResultUsedYes, cond_scope, cond_expr, TransRValue);
3002 while_scope->node->data.while_expr.condition = trans_bool_expr(c, ResultUsedYes, cond_scope,
3003 cond_expr, TransRValue);
29923004
2993 if (while_scope->node->data.while_expr.condition == nullptr)
2994 return nullptr;
2995 } else {
2996 TransScope *end_cond_scope = trans_stmt(c, cond_scope, cond_stmt,
2997 &while_scope->node->data.while_expr.condition);
2998 if (end_cond_scope == nullptr)
2999 return nullptr;
3000 }
3005 if (while_scope->node->data.while_expr.condition == nullptr)
3006 return nullptr;
30013007 }
30023008
3003 const ZigClangStmt *inc_stmt = bitcast(stmt->getInc());
3004 if (inc_stmt != nullptr) {
3005 AstNode *inc_node;
3006 TransScope *inc_scope = trans_stmt(c, cond_scope, inc_stmt, &inc_node);
3007 if (inc_scope == nullptr)
3009 const ZigClangExpr *inc_expr = bitcast(stmt->getInc());
3010 if (inc_expr != nullptr) {
3011 AstNode *inc_node = trans_expr(c, ResultUsedNo, cond_scope, inc_expr, TransRValue);
3012 if (inc_node == nullptr)
30083013 return nullptr;
30093014 while_scope->node->data.while_expr.continue_expr = inc_node;
30103015 }
......@@ -3047,7 +3052,7 @@ static AstNode *trans_switch_stmt(Context *c, TransScope *parent_scope, const cl
30473052 switch_scope->end_label_name = end_label_name;
30483053 block_scope->node->data.block.name = end_label_name;
30493054
3050 const clang::Expr *cond_expr = stmt->getCond();
3055 const ZigClangExpr *cond_expr = bitcast(stmt->getCond());
30513056 assert(cond_expr != nullptr);
30523057
30533058 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::
31083113 {
31093114 // Add the prong
31103115 AstNode *prong_node = trans_create_node(c, NodeTypeSwitchProng);
3111 AstNode *item_node = trans_expr(c, ResultUsedYes, &switch_scope->base, stmt->getLHS(), TransRValue);
3116 AstNode *item_node = trans_expr(c, ResultUsedYes, &switch_scope->base, bitcast(stmt->getLHS()), TransRValue);
31123117 if (item_node == nullptr)
31133118 return ErrorUnexpected;
31143119 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
33133318 trans_continue_stmt(c, scope, (const clang::ContinueStmt *)stmt));
33143319 case ZigClangStmt_ParenExprClass:
33153320 return wrap_stmt(out_node, out_child_scope, scope,
3316 trans_expr(c, result_used, scope, ((const clang::ParenExpr*)stmt)->getSubExpr(), lrvalue));
3321 trans_expr(c, result_used, scope,
3322 bitcast(((const clang::ParenExpr*)stmt)->getSubExpr()), lrvalue));
33173323 case ZigClangStmt_SwitchStmtClass:
33183324 return wrap_stmt(out_node, out_child_scope, scope,
33193325 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
38363842}
38373843
38383844// Returns null if there was an error
3839static AstNode *trans_expr(Context *c, ResultUsed result_used, TransScope *scope, const clang::Expr *expr,
3845static AstNode *trans_expr(Context *c, ResultUsed result_used, TransScope *scope, const ZigClangExpr *expr,
38403846 TransLRValue lrval)
38413847{
38423848 AstNode *result_node;
......@@ -4304,7 +4310,7 @@ static AstNode *trans_ap_value(Context *c, clang::APValue *ap_value, ZigClangQua
43044310 case clang::APValue::LValue: {
43054311 const clang::APValue::LValueBase lval_base = ap_value->getLValueBase();
43064312 if (const clang::Expr *expr = lval_base.dyn_cast<const clang::Expr *>()) {
4307 return trans_expr(c, ResultUsedYes, &c->global_scope->base, expr, TransRValue);
4313 return trans_expr(c, ResultUsedYes, &c->global_scope->base, bitcast(expr), TransRValue);
43084314 }
43094315 //const clang::ValueDecl *value_decl = lval_base.get<const clang::ValueDecl *>();
43104316 emit_warning(c, source_loc, "TODO handle initializer LValue clang::ValueDecl");
src/zig_clang.cpp+141
......@@ -137,6 +137,132 @@ 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
140// Detect additions to the enum
141void zig2clang_CK(clang::CastKind x) {
142 switch (x) {
143 case clang::CK_ARCConsumeObject:
144 case clang::CK_ARCExtendBlockObject:
145 case clang::CK_ARCProduceObject:
146 case clang::CK_ARCReclaimReturnedObject:
147 case clang::CK_AddressSpaceConversion:
148 case clang::CK_AnyPointerToBlockPointerCast:
149 case clang::CK_ArrayToPointerDecay:
150 case clang::CK_AtomicToNonAtomic:
151 case clang::CK_BaseToDerived:
152 case clang::CK_BaseToDerivedMemberPointer:
153 case clang::CK_BitCast:
154 case clang::CK_BlockPointerToObjCPointerCast:
155 case clang::CK_BooleanToSignedIntegral:
156 case clang::CK_BuiltinFnToFnPtr:
157 case clang::CK_CPointerToObjCPointerCast:
158 case clang::CK_ConstructorConversion:
159 case clang::CK_CopyAndAutoreleaseBlockObject:
160 case clang::CK_Dependent:
161 case clang::CK_DerivedToBase:
162 case clang::CK_DerivedToBaseMemberPointer:
163 case clang::CK_Dynamic:
164 case clang::CK_FloatingCast:
165 case clang::CK_FloatingComplexCast:
166 case clang::CK_FloatingComplexToBoolean:
167 case clang::CK_FloatingComplexToIntegralComplex:
168 case clang::CK_FloatingComplexToReal:
169 case clang::CK_FloatingRealToComplex:
170 case clang::CK_FloatingToBoolean:
171 case clang::CK_FloatingToIntegral:
172 case clang::CK_FunctionToPointerDecay:
173 case clang::CK_IntToOCLSampler:
174 case clang::CK_IntegralCast:
175 case clang::CK_IntegralComplexCast:
176 case clang::CK_IntegralComplexToBoolean:
177 case clang::CK_IntegralComplexToFloatingComplex:
178 case clang::CK_IntegralComplexToReal:
179 case clang::CK_IntegralRealToComplex:
180 case clang::CK_IntegralToBoolean:
181 case clang::CK_IntegralToFloating:
182 case clang::CK_IntegralToPointer:
183 case clang::CK_LValueBitCast:
184 case clang::CK_LValueToRValue:
185 case clang::CK_MemberPointerToBoolean:
186 case clang::CK_NoOp:
187 case clang::CK_NonAtomicToAtomic:
188 case clang::CK_NullToMemberPointer:
189 case clang::CK_NullToPointer:
190 case clang::CK_ObjCObjectLValueCast:
191 case clang::CK_PointerToBoolean:
192 case clang::CK_PointerToIntegral:
193 case clang::CK_ReinterpretMemberPointer:
194 case clang::CK_ToUnion:
195 case clang::CK_ToVoid:
196 case clang::CK_UncheckedDerivedToBase:
197 case clang::CK_UserDefinedConversion:
198 case clang::CK_VectorSplat:
199 case clang::CK_ZeroToOCLOpaqueType:
200 case clang::CK_FixedPointCast:
201 case clang::CK_FixedPointToBoolean:
202 break;
203 }
204};
205
206static_assert((clang::CastKind)ZigClangCK_Dependent == clang::CK_Dependent, "");
207static_assert((clang::CastKind)ZigClangCK_BitCast == clang::CK_BitCast, "");
208static_assert((clang::CastKind)ZigClangCK_LValueBitCast == clang::CK_LValueBitCast, "");
209static_assert((clang::CastKind)ZigClangCK_LValueToRValue == clang::CK_LValueToRValue, "");
210static_assert((clang::CastKind)ZigClangCK_NoOp == clang::CK_NoOp, "");
211static_assert((clang::CastKind)ZigClangCK_BaseToDerived == clang::CK_BaseToDerived, "");
212static_assert((clang::CastKind)ZigClangCK_DerivedToBase == clang::CK_DerivedToBase, "");
213static_assert((clang::CastKind)ZigClangCK_UncheckedDerivedToBase == clang::CK_UncheckedDerivedToBase, "");
214static_assert((clang::CastKind)ZigClangCK_Dynamic == clang::CK_Dynamic, "");
215static_assert((clang::CastKind)ZigClangCK_ToUnion == clang::CK_ToUnion, "");
216static_assert((clang::CastKind)ZigClangCK_ArrayToPointerDecay == clang::CK_ArrayToPointerDecay, "");
217static_assert((clang::CastKind)ZigClangCK_FunctionToPointerDecay == clang::CK_FunctionToPointerDecay, "");
218static_assert((clang::CastKind)ZigClangCK_NullToPointer == clang::CK_NullToPointer, "");
219static_assert((clang::CastKind)ZigClangCK_NullToMemberPointer == clang::CK_NullToMemberPointer, "");
220static_assert((clang::CastKind)ZigClangCK_BaseToDerivedMemberPointer == clang::CK_BaseToDerivedMemberPointer, "");
221static_assert((clang::CastKind)ZigClangCK_DerivedToBaseMemberPointer == clang::CK_DerivedToBaseMemberPointer, "");
222static_assert((clang::CastKind)ZigClangCK_MemberPointerToBoolean == clang::CK_MemberPointerToBoolean, "");
223static_assert((clang::CastKind)ZigClangCK_ReinterpretMemberPointer == clang::CK_ReinterpretMemberPointer, "");
224static_assert((clang::CastKind)ZigClangCK_UserDefinedConversion == clang::CK_UserDefinedConversion, "");
225static_assert((clang::CastKind)ZigClangCK_ConstructorConversion == clang::CK_ConstructorConversion, "");
226static_assert((clang::CastKind)ZigClangCK_IntegralToPointer == clang::CK_IntegralToPointer, "");
227static_assert((clang::CastKind)ZigClangCK_PointerToIntegral == clang::CK_PointerToIntegral, "");
228static_assert((clang::CastKind)ZigClangCK_PointerToBoolean == clang::CK_PointerToBoolean, "");
229static_assert((clang::CastKind)ZigClangCK_ToVoid == clang::CK_ToVoid, "");
230static_assert((clang::CastKind)ZigClangCK_VectorSplat == clang::CK_VectorSplat, "");
231static_assert((clang::CastKind)ZigClangCK_IntegralCast == clang::CK_IntegralCast, "");
232static_assert((clang::CastKind)ZigClangCK_IntegralToBoolean == clang::CK_IntegralToBoolean, "");
233static_assert((clang::CastKind)ZigClangCK_IntegralToFloating == clang::CK_IntegralToFloating, "");
234static_assert((clang::CastKind)ZigClangCK_FixedPointCast == clang::CK_FixedPointCast, "");
235static_assert((clang::CastKind)ZigClangCK_FixedPointToBoolean == clang::CK_FixedPointToBoolean, "");
236static_assert((clang::CastKind)ZigClangCK_FloatingToIntegral == clang::CK_FloatingToIntegral, "");
237static_assert((clang::CastKind)ZigClangCK_FloatingToBoolean == clang::CK_FloatingToBoolean, "");
238static_assert((clang::CastKind)ZigClangCK_BooleanToSignedIntegral == clang::CK_BooleanToSignedIntegral, "");
239static_assert((clang::CastKind)ZigClangCK_FloatingCast == clang::CK_FloatingCast, "");
240static_assert((clang::CastKind)ZigClangCK_CPointerToObjCPointerCast == clang::CK_CPointerToObjCPointerCast, "");
241static_assert((clang::CastKind)ZigClangCK_BlockPointerToObjCPointerCast == clang::CK_BlockPointerToObjCPointerCast, "");
242static_assert((clang::CastKind)ZigClangCK_AnyPointerToBlockPointerCast == clang::CK_AnyPointerToBlockPointerCast, "");
243static_assert((clang::CastKind)ZigClangCK_ObjCObjectLValueCast == clang::CK_ObjCObjectLValueCast, "");
244static_assert((clang::CastKind)ZigClangCK_FloatingRealToComplex == clang::CK_FloatingRealToComplex, "");
245static_assert((clang::CastKind)ZigClangCK_FloatingComplexToReal == clang::CK_FloatingComplexToReal, "");
246static_assert((clang::CastKind)ZigClangCK_FloatingComplexToBoolean == clang::CK_FloatingComplexToBoolean, "");
247static_assert((clang::CastKind)ZigClangCK_FloatingComplexCast == clang::CK_FloatingComplexCast, "");
248static_assert((clang::CastKind)ZigClangCK_FloatingComplexToIntegralComplex == clang::CK_FloatingComplexToIntegralComplex, "");
249static_assert((clang::CastKind)ZigClangCK_IntegralRealToComplex == clang::CK_IntegralRealToComplex, "");
250static_assert((clang::CastKind)ZigClangCK_IntegralComplexToReal == clang::CK_IntegralComplexToReal, "");
251static_assert((clang::CastKind)ZigClangCK_IntegralComplexToBoolean == clang::CK_IntegralComplexToBoolean, "");
252static_assert((clang::CastKind)ZigClangCK_IntegralComplexCast == clang::CK_IntegralComplexCast, "");
253static_assert((clang::CastKind)ZigClangCK_IntegralComplexToFloatingComplex == clang::CK_IntegralComplexToFloatingComplex, "");
254static_assert((clang::CastKind)ZigClangCK_ARCProduceObject == clang::CK_ARCProduceObject, "");
255static_assert((clang::CastKind)ZigClangCK_ARCConsumeObject == clang::CK_ARCConsumeObject, "");
256static_assert((clang::CastKind)ZigClangCK_ARCReclaimReturnedObject == clang::CK_ARCReclaimReturnedObject, "");
257static_assert((clang::CastKind)ZigClangCK_ARCExtendBlockObject == clang::CK_ARCExtendBlockObject, "");
258static_assert((clang::CastKind)ZigClangCK_AtomicToNonAtomic == clang::CK_AtomicToNonAtomic, "");
259static_assert((clang::CastKind)ZigClangCK_NonAtomicToAtomic == clang::CK_NonAtomicToAtomic, "");
260static_assert((clang::CastKind)ZigClangCK_CopyAndAutoreleaseBlockObject == clang::CK_CopyAndAutoreleaseBlockObject, "");
261static_assert((clang::CastKind)ZigClangCK_BuiltinFnToFnPtr == clang::CK_BuiltinFnToFnPtr, "");
262static_assert((clang::CastKind)ZigClangCK_ZeroToOCLOpaqueType == clang::CK_ZeroToOCLOpaqueType, "");
263static_assert((clang::CastKind)ZigClangCK_AddressSpaceConversion == clang::CK_AddressSpaceConversion, "");
264static_assert((clang::CastKind)ZigClangCK_IntToOCLSampler == clang::CK_IntToOCLSampler, "");
265
140266// Detect additions to the enum
141267void zig2clang_TypeClass(clang::Type::TypeClass ty) {
142268 switch (ty) {
......@@ -885,3 +1011,18 @@ ZigClangStmtClass ZigClangStmt_getStmtClass(const ZigClangStmt *self) {
8851011 auto casted = reinterpret_cast<const clang::Stmt *>(self);
8861012 return (ZigClangStmtClass)casted->getStmtClass();
8871013}
1014
1015ZigClangStmtClass ZigClangExpr_getStmtClass(const ZigClangExpr *self) {
1016 auto casted = reinterpret_cast<const clang::Expr *>(self);
1017 return (ZigClangStmtClass)casted->getStmtClass();
1018}
1019
1020ZigClangQualType ZigClangExpr_getType(const ZigClangExpr *self) {
1021 auto casted = reinterpret_cast<const clang::Expr *>(self);
1022 return bitcast(casted->getType());
1023}
1024
1025ZigClangSourceLocation ZigClangExpr_getBeginLoc(const ZigClangExpr *self) {
1026 auto casted = reinterpret_cast<const clang::Expr *>(self);
1027 return bitcast(casted->getBeginLoc());
1028}
src/zig_clang.h+64-58
......@@ -418,64 +418,67 @@ enum ZigClangStmtClass {
418418//struct ZigClangCC_X86VectorCall;
419419//struct ZigClangCC_X86_64SysV;
420420
421//struct ZigClangCK_ARCConsumeObject;
422//struct ZigClangCK_ARCExtendBlockObject;
423//struct ZigClangCK_ARCProduceObject;
424//struct ZigClangCK_ARCReclaimReturnedObject;
425//struct ZigClangCK_AddressSpaceConversion;
426//struct ZigClangCK_AnyPointerToBlockPointerCast;
427//struct ZigClangCK_ArrayToPointerDecay;
428//struct ZigClangCK_AtomicToNonAtomic;
429//struct ZigClangCK_BaseToDerived;
430//struct ZigClangCK_BaseToDerivedMemberPointer;
431//struct ZigClangCK_BitCast;
432//struct ZigClangCK_BlockPointerToObjCPointerCast;
433//struct ZigClangCK_BooleanToSignedIntegral;
434//struct ZigClangCK_BuiltinFnToFnPtr;
435//struct ZigClangCK_CPointerToObjCPointerCast;
436//struct ZigClangCK_ConstructorConversion;
437//struct ZigClangCK_CopyAndAutoreleaseBlockObject;
438//struct ZigClangCK_Dependent;
439//struct ZigClangCK_DerivedToBase;
440//struct ZigClangCK_DerivedToBaseMemberPointer;
441//struct ZigClangCK_Dynamic;
442//struct ZigClangCK_FloatingCast;
443//struct ZigClangCK_FloatingComplexCast;
444//struct ZigClangCK_FloatingComplexToBoolean;
445//struct ZigClangCK_FloatingComplexToIntegralComplex;
446//struct ZigClangCK_FloatingComplexToReal;
447//struct ZigClangCK_FloatingRealToComplex;
448//struct ZigClangCK_FloatingToBoolean;
449//struct ZigClangCK_FloatingToIntegral;
450//struct ZigClangCK_FunctionToPointerDecay;
451//struct ZigClangCK_IntToOCLSampler;
452//struct ZigClangCK_IntegralCast;
453//struct ZigClangCK_IntegralComplexCast;
454//struct ZigClangCK_IntegralComplexToBoolean;
455//struct ZigClangCK_IntegralComplexToFloatingComplex;
456//struct ZigClangCK_IntegralComplexToReal;
457//struct ZigClangCK_IntegralRealToComplex;
458//struct ZigClangCK_IntegralToBoolean;
459//struct ZigClangCK_IntegralToFloating;
460//struct ZigClangCK_IntegralToPointer;
461//struct ZigClangCK_LValueBitCast;
462//struct ZigClangCK_LValueToRValue;
463//struct ZigClangCK_MemberPointerToBoolean;
464//struct ZigClangCK_NoOp;
465//struct ZigClangCK_NonAtomicToAtomic;
466//struct ZigClangCK_NullToMemberPointer;
467//struct ZigClangCK_NullToPointer;
468//struct ZigClangCK_ObjCObjectLValueCast;
469//struct ZigClangCK_PointerToBoolean;
470//struct ZigClangCK_PointerToIntegral;
471//struct ZigClangCK_ReinterpretMemberPointer;
472//struct ZigClangCK_ToUnion;
473//struct ZigClangCK_ToVoid;
474//struct ZigClangCK_UncheckedDerivedToBase;
475//struct ZigClangCK_UserDefinedConversion;
476//struct ZigClangCK_VectorSplat;
477//struct ZigClangCK_ZeroToOCLEvent;
478//struct ZigClangCK_ZeroToOCLQueue;
421enum ZigClangCK {
422 ZigClangCK_Dependent,
423 ZigClangCK_BitCast,
424 ZigClangCK_LValueBitCast,
425 ZigClangCK_LValueToRValue,
426 ZigClangCK_NoOp,
427 ZigClangCK_BaseToDerived,
428 ZigClangCK_DerivedToBase,
429 ZigClangCK_UncheckedDerivedToBase,
430 ZigClangCK_Dynamic,
431 ZigClangCK_ToUnion,
432 ZigClangCK_ArrayToPointerDecay,
433 ZigClangCK_FunctionToPointerDecay,
434 ZigClangCK_NullToPointer,
435 ZigClangCK_NullToMemberPointer,
436 ZigClangCK_BaseToDerivedMemberPointer,
437 ZigClangCK_DerivedToBaseMemberPointer,
438 ZigClangCK_MemberPointerToBoolean,
439 ZigClangCK_ReinterpretMemberPointer,
440 ZigClangCK_UserDefinedConversion,
441 ZigClangCK_ConstructorConversion,
442 ZigClangCK_IntegralToPointer,
443 ZigClangCK_PointerToIntegral,
444 ZigClangCK_PointerToBoolean,
445 ZigClangCK_ToVoid,
446 ZigClangCK_VectorSplat,
447 ZigClangCK_IntegralCast,
448 ZigClangCK_IntegralToBoolean,
449 ZigClangCK_IntegralToFloating,
450 ZigClangCK_FixedPointCast,
451 ZigClangCK_FixedPointToBoolean,
452 ZigClangCK_FloatingToIntegral,
453 ZigClangCK_FloatingToBoolean,
454 ZigClangCK_BooleanToSignedIntegral,
455 ZigClangCK_FloatingCast,
456 ZigClangCK_CPointerToObjCPointerCast,
457 ZigClangCK_BlockPointerToObjCPointerCast,
458 ZigClangCK_AnyPointerToBlockPointerCast,
459 ZigClangCK_ObjCObjectLValueCast,
460 ZigClangCK_FloatingRealToComplex,
461 ZigClangCK_FloatingComplexToReal,
462 ZigClangCK_FloatingComplexToBoolean,
463 ZigClangCK_FloatingComplexCast,
464 ZigClangCK_FloatingComplexToIntegralComplex,
465 ZigClangCK_IntegralRealToComplex,
466 ZigClangCK_IntegralComplexToReal,
467 ZigClangCK_IntegralComplexToBoolean,
468 ZigClangCK_IntegralComplexCast,
469 ZigClangCK_IntegralComplexToFloatingComplex,
470 ZigClangCK_ARCProduceObject,
471 ZigClangCK_ARCConsumeObject,
472 ZigClangCK_ARCReclaimReturnedObject,
473 ZigClangCK_ARCExtendBlockObject,
474 ZigClangCK_AtomicToNonAtomic,
475 ZigClangCK_NonAtomicToAtomic,
476 ZigClangCK_CopyAndAutoreleaseBlockObject,
477 ZigClangCK_BuiltinFnToFnPtr,
478 ZigClangCK_ZeroToOCLOpaqueType,
479 ZigClangCK_AddressSpaceConversion,
480 ZigClangCK_IntToOCLSampler,
481};
479482
480483//struct ZigClangETK_Class;
481484//struct ZigClangETK_Enum;
......@@ -552,4 +555,7 @@ ZIG_EXTERN_C ZigClangSourceLocation ZigClangStmt_getBeginLoc(const ZigClangStmt
552555ZIG_EXTERN_C ZigClangStmtClass ZigClangStmt_getStmtClass(const ZigClangStmt *self);
553556ZIG_EXTERN_C bool ZigClangStmt_classof_Expr(const ZigClangStmt *self);
554557
558ZIG_EXTERN_C ZigClangStmtClass ZigClangExpr_getStmtClass(const ZigClangExpr *self);
559ZIG_EXTERN_C ZigClangQualType ZigClangExpr_getType(const ZigClangExpr *self);
560ZIG_EXTERN_C ZigClangSourceLocation ZigClangExpr_getBeginLoc(const ZigClangExpr *self);
555561#endif