authorgravatar for thejoshwolfe@gmail.comJosh Wolfe <thejoshwolfe@gmail.com> 2017-09-20 22:36:33-07:00
committergravatar for thejoshwolfe@gmail.comJosh Wolfe <thejoshwolfe@gmail.com> 2017-09-20 22:36:43-07:00
log67a5a3f3d74c4ca6f241fc67590dbc94210c2948
tree5379d98641e12b430b25f503879fee8494cfbc5c
parent0d1f64b08cf1dc20c733391c6639af0ba88755e9

add sub mul div rem

2 files changed, 73 insertions(+), 10 deletions(-)

src/parsec.cpp+37-10
......@@ -951,20 +951,47 @@ static AstNode *trans_binary_operator(Context *c, bool result_used, AstNode *blo
951951 emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_PtrMemI");
952952 return nullptr;
953953 case BO_Mul:
954 emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_Mul");
955 return nullptr;
954 return trans_create_bin_op(c, block, stmt->getLHS(),
955 qual_type_has_wrapping_overflow(c, stmt->getType()) ? BinOpTypeMultWrap : BinOpTypeMult,
956 stmt->getRHS());
956957 case BO_Div:
957 emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_Div");
958 return nullptr;
958 if (qual_type_has_wrapping_overflow(c, stmt->getType())) {
959 // unsigned/float division uses the operator
960 return trans_create_bin_op(c, block, stmt->getLHS(), BinOpTypeDiv, stmt->getRHS());
961 } else {
962 // signed integer division uses @divTrunc
963 AstNode *fn_call = trans_create_node_builtin_fn_call_str(c, "divTrunc");
964 AstNode *lhs = trans_expr(c, true, block, stmt->getLHS(), TransLValue);
965 if (lhs == nullptr) return nullptr;
966 fn_call->data.fn_call_expr.params.append(lhs);
967 AstNode *rhs = trans_expr(c, true, block, stmt->getRHS(), TransLValue);
968 if (rhs == nullptr) return nullptr;
969 fn_call->data.fn_call_expr.params.append(rhs);
970 return fn_call;
971 }
959972 case BO_Rem:
960 emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_Rem");
961 return nullptr;
973 if (qual_type_has_wrapping_overflow(c, stmt->getType())) {
974 // unsigned/float division uses the operator
975 return trans_create_bin_op(c, block, stmt->getLHS(), BinOpTypeMod, stmt->getRHS());
976 } else {
977 // signed integer division uses @divTrunc
978 AstNode *fn_call = trans_create_node_builtin_fn_call_str(c, "rem");
979 AstNode *lhs = trans_expr(c, true, block, stmt->getLHS(), TransLValue);
980 if (lhs == nullptr) return nullptr;
981 fn_call->data.fn_call_expr.params.append(lhs);
982 AstNode *rhs = trans_expr(c, true, block, stmt->getRHS(), TransLValue);
983 if (rhs == nullptr) return nullptr;
984 fn_call->data.fn_call_expr.params.append(rhs);
985 return fn_call;
986 }
962987 case BO_Add:
963 emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_Add");
964 return nullptr;
988 return trans_create_bin_op(c, block, stmt->getLHS(),
989 qual_type_has_wrapping_overflow(c, stmt->getType()) ? BinOpTypeAddWrap : BinOpTypeAdd,
990 stmt->getRHS());
965991 case BO_Sub:
966 emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_Sub");
967 return nullptr;
992 return trans_create_bin_op(c, block, stmt->getLHS(),
993 qual_type_has_wrapping_overflow(c, stmt->getType()) ? BinOpTypeSubWrap : BinOpTypeSub,
994 stmt->getRHS());
968995 case BO_Shl:
969996 emit_warning(c, stmt->getLocStart(), "TODO handle more C binary operators: BO_Shl");
970997 return nullptr;
test/parsec.zig+36
......@@ -389,6 +389,42 @@ pub fn addCases(cases: &tests.ParseCContext) {
389389 \\}
390390 );
391391
392 cases.add("add, sub, mul, div, rem",
393 \\int s(int a, int b) {
394 \\ int c;
395 \\ c = a + b;
396 \\ c = a - b;
397 \\ c = a * b;
398 \\ c = a / b;
399 \\ c = a % b;
400 \\}
401 \\unsigned u(unsigned a, unsigned b) {
402 \\ unsigned c;
403 \\ c = a + b;
404 \\ c = a - b;
405 \\ c = a * b;
406 \\ c = a / b;
407 \\ c = a % b;
408 \\}
409 ,
410 \\export fn s(a: c_int, b: c_int) -> c_int {
411 \\ var c: c_int;
412 \\ c = (a + b);
413 \\ c = (a - b);
414 \\ c = (a * b);
415 \\ c = @divTrunc(a, b);
416 \\ c = @rem(a, b);
417 \\}
418 \\export fn u(a: c_uint, b: c_uint) -> c_uint {
419 \\ var c: c_uint;
420 \\ c = (a +% b);
421 \\ c = (a -% b);
422 \\ c = (a *% b);
423 \\ c = (a / b);
424 \\ c = (a % b);
425 \\}
426 );
427
392428 cases.add("bitwise binary operators",
393429 \\int max(int a, int b) {
394430 \\ return (a & b) ^ (a | b);