authorgravatar for thejoshwolfe@gmail.comJosh Wolfe <thejoshwolfe@gmail.com> 2017-09-11 19:58:41-07:00
committergravatar for thejoshwolfe@gmail.comJosh Wolfe <thejoshwolfe@gmail.com> 2017-09-11 19:58:41-07:00
log7e3f45a49f83fb1b9d182bcddeb0b34e49380c8f
treed4b3a265212b03f3eb25c19266d7a32f60159f69
parent4bd23aefe7c96063b31433d26b7135b890996b02
parent6f50457b61b076bee8378c083e01425f7c81c76b

Merge branch 'master' into c-to-zig

1 files changed, 175 insertions(+), 14 deletions(-)

src/parsec.cpp+175-14
......@@ -126,6 +126,13 @@ static AstNode *trans_create_node_opaque(Context *c) {
126126 return trans_create_node_builtin_fn_call_str(c, "OpaqueType");
127127}
128128
129static AstNode *trans_create_node_fn_call_1(Context *c, AstNode *fn_ref_expr, AstNode *arg1) {
130 AstNode *node = trans_create_node(c, NodeTypeFnCallExpr);
131 node->data.fn_call_expr.fn_ref_expr = fn_ref_expr;
132 node->data.fn_call_expr.params.append(arg1);
133 return node;
134}
135
129136static AstNode *trans_create_node_field_access(Context *c, AstNode *container, Buf *field_name) {
130137 AstNode *node = trans_create_node(c, NodeTypeFieldAccessExpr);
131138 node->data.field_access_expr.struct_expr = container;
......@@ -133,6 +140,10 @@ static AstNode *trans_create_node_field_access(Context *c, AstNode *container, B
133140 return node;
134141}
135142
143static AstNode *trans_create_node_field_access_str(Context *c, AstNode *container, const char *field_name) {
144 return trans_create_node_field_access(c, container, buf_create_from_str(field_name));
145}
146
136147static AstNode *trans_create_node_prefix_op(Context *c, PrefixOp op, AstNode *child_node) {
137148 AstNode *node = trans_create_node(c, NodeTypePrefixOpExpr);
138149 node->data.prefix_op_expr.prefix_op = op;
......@@ -140,6 +151,14 @@ static AstNode *trans_create_node_prefix_op(Context *c, PrefixOp op, AstNode *ch
140151 return node;
141152}
142153
154static AstNode *trans_create_node_bin_op(Context *c, AstNode *lhs_node, BinOpType op, AstNode *rhs_node) {
155 AstNode *node = trans_create_node(c, NodeTypeBinOpExpr);
156 node->data.bin_op_expr.op1 = lhs_node;
157 node->data.bin_op_expr.bin_op = op;
158 node->data.bin_op_expr.op2 = rhs_node;
159 return node;
160}
161
143162static AstNode *trans_create_node_addr_of(Context *c, bool is_const, bool is_volatile, AstNode *child_node) {
144163 AstNode *node = trans_create_node(c, NodeTypeAddrOfExpr);
145164 node->data.addr_of_expr.is_const = is_const;
......@@ -155,6 +174,13 @@ static AstNode *trans_create_node_str_lit_c(Context *c, Buf *buf) {
155174 return node;
156175}
157176
177static AstNode *trans_create_node_str_lit_non_c(Context *c, Buf *buf) {
178 AstNode *node = trans_create_node(c, NodeTypeStringLiteral);
179 node->data.string_literal.buf = buf;
180 node->data.string_literal.c = false;
181 return node;
182}
183
158184static AstNode *trans_create_node_unsigned_negative(Context *c, uint64_t x, bool is_negative) {
159185 AstNode *node = trans_create_node(c, NodeTypeIntLiteral);
160186 node->data.int_literal.bigint = allocate<BigInt>(1);
......@@ -298,10 +324,45 @@ static AstNode *trans_create_node_apint(Context *c, const llvm::APSInt &aps_int)
298324
299325}
300326
327static AstNode *trans_qual_type(Context *c, QualType qt, const SourceLocation &source_loc);
328
301329static bool is_c_void_type(AstNode *node) {
302330 return (node->type == NodeTypeSymbol && buf_eql_str(node->data.symbol_expr.symbol, "c_void"));
303331}
304332
333static AstNode* trans_c_cast(Context *c, const SourceLocation &source_location, const QualType &qt, AstNode *expr) {
334 // TODO: maybe widen to increase size
335 // TODO: maybe bitcast to change sign
336 // TODO: maybe truncate to reduce size
337 return trans_create_node_fn_call_1(c, trans_qual_type(c, qt, source_location), expr);
338}
339
340static AstNode *qual_type_to_log2_int_ref(Context *c, const QualType &qt,
341 const SourceLocation &source_loc)
342{
343 AstNode *zig_type_node = trans_qual_type(c, qt, source_loc);
344
345// @import("std").math.Log2Int(c_long);
346//
347// FnCall
348// FieldAccess
349// FieldAccess
350// FnCall (.builtin = true)
351// Symbol "import"
352// StringLiteral "std"
353// Symbol "math"
354// Symbol "Log2Int"
355// zig_type_node
356
357 AstNode *import_fn_call = trans_create_node_builtin_fn_call_str(c, "import");
358 import_fn_call->data.fn_call_expr.params.append(trans_create_node_str_lit_non_c(c, buf_create_from_str("std")));
359 AstNode *inner_field_access = trans_create_node_field_access_str(c, import_fn_call, "math");
360 AstNode *outer_field_access = trans_create_node_field_access_str(c, inner_field_access, "Log2Int");
361 AstNode *log2int_fn_call = trans_create_node_fn_call_1(c, outer_field_access, zig_type_node);
362
363 return log2int_fn_call;
364}
365
305366static bool qual_type_child_is_fn_proto(const QualType &qt) {
306367 if (qt.getTypePtr()->getTypeClass() == Type::Paren) {
307368 const ParenType *paren_type = static_cast<const ParenType *>(qt.getTypePtr());
......@@ -373,7 +434,6 @@ static bool c_is_float(Context *c, QualType qt) {
373434}
374435
375436static AstNode *trans_stmt(Context *c, AstNode *block, Stmt *stmt);
376static AstNode *trans_qual_type(Context *c, QualType qt, const SourceLocation &source_loc);
377437static AstNode *const skip_add_to_block_node = (AstNode *) 0x2;
378438
379439static AstNode *trans_expr(Context *c, AstNode *block, Expr *expr) {
......@@ -889,25 +949,127 @@ static AstNode *trans_binary_operator(Context *c, AstNode *block, BinaryOperator
889949 zig_unreachable();
890950}
891951
952static AstNode *trans_compound_assign_operator(Context *c, AstNode *block, CompoundAssignOperator *stmt) {
953 switch (stmt->getOpcode()) {
954 case BO_MulAssign:
955 emit_warning(c, stmt->getLocStart(), "TODO handle more C compound assign operators: BO_MulAssign");
956 return nullptr;
957 case BO_DivAssign:
958 emit_warning(c, stmt->getLocStart(), "TODO handle more C compound assign operators: BO_DivAssign");
959 return nullptr;
960 case BO_RemAssign:
961 emit_warning(c, stmt->getLocStart(), "TODO handle more C compound assign operators: BO_RemAssign");
962 return nullptr;
963 case BO_AddAssign:
964 emit_warning(c, stmt->getLocStart(), "TODO handle more C compound assign operators: BO_AddAssign");
965 return nullptr;
966 case BO_SubAssign:
967 emit_warning(c, stmt->getLocStart(), "TODO handle more C compound assign operators: BO_SubAssign");
968 return nullptr;
969 case BO_ShlAssign:
970 emit_warning(c, stmt->getLocStart(), "TODO handle more C compound assign operators: BO_ShlAssign");
971 return nullptr;
972 case BO_ShrAssign: {
973 BinOpType bin_op = BinOpTypeBitShiftRight;
974 // c: lhs >>= rhs;
975 // zig: {
976 // zig: const _ref = &lhs;
977 // zig: *_ref = result_type(operation_type(*_ref) >> u5(rhs));
978 // zig: *_ref
979 // zig: };
980 // where u5 is the appropriate type
981
982 // TODO: avoid mess when we don't need the assignment value for chained assignments or anything.
983 AstNode *child_block = trans_create_node(c, NodeTypeBlock);
984
985 // const _ref = &lhs;
986 AstNode *lhs = trans_expr(c, child_block, stmt->getLHS());
987 if (lhs == nullptr) return nullptr;
988 AstNode *addr_of_lhs = trans_create_node_addr_of(c, false, false, lhs);
989 // TODO: avoid name collisions with generated variable names
990 Buf* tmp_var_name = buf_create_from_str("_ref");
991 AstNode *tmp_var_decl = trans_create_node_var_decl(c, true, tmp_var_name, nullptr, addr_of_lhs);
992 child_block->data.block.statements.append(tmp_var_decl);
993
994 // *_ref = result_type(operation_type(*_ref) >> u5(rhs));
995
996 AstNode *rhs = trans_expr(c, child_block, stmt->getRHS());
997 if (rhs == nullptr) return nullptr;
998 const SourceLocation &rhs_location = stmt->getRHS()->getLocStart();
999 AstNode *rhs_type = qual_type_to_log2_int_ref(c, stmt->getComputationLHSType(), rhs_location);
1000
1001 AstNode *assign_statement = trans_create_node_bin_op(c,
1002 trans_create_node_prefix_op(c, PrefixOpDereference,
1003 trans_create_node_symbol(c, tmp_var_name)),
1004 BinOpTypeAssign,
1005 trans_c_cast(c, rhs_location,
1006 stmt->getComputationResultType(),
1007 trans_create_node_bin_op(c,
1008 trans_c_cast(c, rhs_location,
1009 stmt->getComputationLHSType(),
1010 trans_create_node_prefix_op(c, PrefixOpDereference,
1011 trans_create_node_symbol(c, tmp_var_name))),
1012 bin_op,
1013 trans_create_node_fn_call_1(c,
1014 rhs_type,
1015 rhs))));
1016 child_block->data.block.statements.append(assign_statement);
1017
1018 // *_ref
1019 child_block->data.block.statements.append(
1020 trans_create_node_prefix_op(c, PrefixOpDereference,
1021 trans_create_node_symbol(c, tmp_var_name)));
1022 child_block->data.block.last_statement_is_result_expression = true;
1023
1024 return child_block;
1025 }
1026 case BO_AndAssign:
1027 emit_warning(c, stmt->getLocStart(), "TODO handle more C compound assign operators: BO_AndAssign");
1028 return nullptr;
1029 case BO_XorAssign:
1030 emit_warning(c, stmt->getLocStart(), "TODO handle more C compound assign operators: BO_XorAssign");
1031 return nullptr;
1032 case BO_OrAssign:
1033 emit_warning(c, stmt->getLocStart(), "TODO handle more C compound assign operators: BO_OrAssign");
1034 return nullptr;
1035 case BO_PtrMemD:
1036 case BO_PtrMemI:
1037 case BO_Assign:
1038 case BO_Mul:
1039 case BO_Div:
1040 case BO_Rem:
1041 case BO_Add:
1042 case BO_Sub:
1043 case BO_Shl:
1044 case BO_Shr:
1045 case BO_LT:
1046 case BO_GT:
1047 case BO_LE:
1048 case BO_GE:
1049 case BO_EQ:
1050 case BO_NE:
1051 case BO_And:
1052 case BO_Xor:
1053 case BO_Or:
1054 case BO_LAnd:
1055 case BO_LOr:
1056 case BO_Comma:
1057 zig_panic("compound assign expected to be handled by binary operator");
1058 }
1059
1060 zig_unreachable();
1061}
1062
8921063static AstNode *trans_implicit_cast_expr(Context *c, AstNode *block, ImplicitCastExpr *stmt) {
8931064 switch (stmt->getCastKind()) {
8941065 case CK_LValueToRValue:
8951066 return trans_expr(c, block, stmt->getSubExpr());
8961067 case CK_IntegralCast:
8971068 {
898 AstNode *node = trans_create_node_builtin_fn_call_str(c, "bitCast");
899
900 AstNode *result_type_node = trans_qual_type(c, stmt->getType(), stmt->getExprLoc());
901 if (result_type_node == nullptr)
902 return nullptr;
903
9041069 AstNode *target_node = trans_expr(c, block, stmt->getSubExpr());
9051070 if (target_node == nullptr)
9061071 return nullptr;
907
908 node->data.fn_call_expr.params.append(result_type_node);
909 node->data.fn_call_expr.params.append(target_node);
910 return node;
1072 return trans_c_cast(c, stmt->getExprLoc(), stmt->getType(), target_node);
9111073 }
9121074 case CK_Dependent:
9131075 emit_warning(c, stmt->getLocStart(), "TODO handle C translation cast CK_Dependent");
......@@ -1434,6 +1596,8 @@ static AstNode *trans_stmt(Context *c, AstNode *block, Stmt *stmt) {
14341596 return trans_conditional_operator(c, block, (ConditionalOperator *)stmt);
14351597 case Stmt::BinaryOperatorClass:
14361598 return trans_binary_operator(c, block, (BinaryOperator *)stmt);
1599 case Stmt::CompoundAssignOperatorClass:
1600 return trans_compound_assign_operator(c, block, (CompoundAssignOperator *)stmt);
14371601 case Stmt::ImplicitCastExprClass:
14381602 return trans_implicit_cast_expr(c, block, (ImplicitCastExpr *)stmt);
14391603 case Stmt::DeclRefExprClass:
......@@ -1516,9 +1680,6 @@ static AstNode *trans_stmt(Context *c, AstNode *block, Stmt *stmt) {
15161680 case Stmt::AtomicExprClass:
15171681 emit_warning(c, stmt->getLocStart(), "TODO handle C AtomicExprClass");
15181682 return nullptr;
1519 case Stmt::CompoundAssignOperatorClass:
1520 emit_warning(c, stmt->getLocStart(), "TODO handle C CompoundAssignOperatorClass");
1521 return nullptr;
15221683 case Stmt::BlockExprClass:
15231684 emit_warning(c, stmt->getLocStart(), "TODO handle C BlockExprClass");
15241685 return nullptr;