Basic changes for dbd

include/blocks/block_replacer.h

@@ -13,8 +13,8 @@ class block_replacer : public block_visitor {
 	std::shared_ptr<block> to_replace;
 	std::shared_ptr<block> replace_with;
 
-	template <typename T = expr>
-	typename T::Ptr rewrite(typename T::Ptr ptr) {
+	template <typename T>
+	typename T::Ptr rewrite(typename std::shared_ptr<T> ptr) {
 		auto tmp = node;
 		node = nullptr;
 		ptr->accept(this);
@@ -91,6 +91,8 @@ class block_replacer : public block_visitor {
 
 	virtual void visit(std::shared_ptr<func_decl>) override;
 	virtual void visit(std::shared_ptr<return_stmt>) override;
+
+	virtual void visit(std::shared_ptr<cast_expr>) override;
 };
 } // namespace block
 

include/blocks/block_visitor.h

@@ -68,6 +68,8 @@ class named_type;
 class func_decl;
 class return_stmt;
 
+class cast_expr;
+
 class block_visitor {
 public:
 	virtual void visit(std::shared_ptr<block>);
@@ -134,6 +136,10 @@ class block_visitor {
 
 	virtual void visit(std::shared_ptr<func_decl>);
 	virtual void visit(std::shared_ptr<return_stmt>);
+
+
+
+	virtual void visit(std::shared_ptr<cast_expr>);
 };
 } // namespace block
 

include/blocks/c_code_generator.h

@@ -32,61 +32,63 @@ class c_code_generator : public block_visitor {
 	void save_static_info(block::Ptr a);
 	void nextl(void);
 
-	virtual void visit(not_expr::Ptr);
-	virtual void visit(unary_minus_expr::Ptr);
-	virtual void visit(bitwise_not_expr::Ptr);
-	virtual void visit(and_expr::Ptr);
-	virtual void visit(bitwise_and_expr::Ptr);
-	virtual void visit(or_expr::Ptr);
-	virtual void visit(bitwise_or_expr::Ptr);
-	virtual void visit(bitwise_xor_expr::Ptr);
-	virtual void visit(plus_expr::Ptr);
-	virtual void visit(minus_expr::Ptr);
-	virtual void visit(mul_expr::Ptr);
-	virtual void visit(div_expr::Ptr);
-	virtual void visit(lt_expr::Ptr);
-	virtual void visit(gt_expr::Ptr);
-	virtual void visit(lte_expr::Ptr);
-	virtual void visit(gte_expr::Ptr);
-	virtual void visit(lshift_expr::Ptr);
-	virtual void visit(rshift_expr::Ptr);
-	virtual void visit(equals_expr::Ptr);
-	virtual void visit(ne_expr::Ptr);
-	virtual void visit(mod_expr::Ptr);
-	virtual void visit(var_expr::Ptr);
-	virtual void visit(int_const::Ptr);
-	virtual void visit(double_const::Ptr);
-	virtual void visit(float_const::Ptr);
-	virtual void visit(string_const::Ptr);
-	virtual void visit(assign_expr::Ptr);
-	virtual void visit(expr_stmt::Ptr);
-	virtual void visit(stmt_block::Ptr);
-	virtual void visit(decl_stmt::Ptr);
-	virtual void visit(if_stmt::Ptr);
-	virtual void visit(while_stmt::Ptr);
-	virtual void visit(for_stmt::Ptr);
-	virtual void visit(break_stmt::Ptr);
-	virtual void visit(continue_stmt::Ptr);
-	virtual void visit(sq_bkt_expr::Ptr);
-	virtual void visit(function_call_expr::Ptr);
-	virtual void visit(initializer_list_expr::Ptr);
+	virtual void visit(not_expr::Ptr) override;
+	virtual void visit(unary_minus_expr::Ptr) override;
+	virtual void visit(bitwise_not_expr::Ptr) override;
+	virtual void visit(and_expr::Ptr) override;
+	virtual void visit(bitwise_and_expr::Ptr) override;
+	virtual void visit(or_expr::Ptr) override;
+	virtual void visit(bitwise_or_expr::Ptr) override;
+	virtual void visit(bitwise_xor_expr::Ptr) override;
+	virtual void visit(plus_expr::Ptr) override;
+	virtual void visit(minus_expr::Ptr) override;
+	virtual void visit(mul_expr::Ptr) override;
+	virtual void visit(div_expr::Ptr) override;
+	virtual void visit(lt_expr::Ptr) override;
+	virtual void visit(gt_expr::Ptr) override;
+	virtual void visit(lte_expr::Ptr) override;
+	virtual void visit(gte_expr::Ptr) override;
+	virtual void visit(lshift_expr::Ptr) override;
+	virtual void visit(rshift_expr::Ptr) override;
+	virtual void visit(equals_expr::Ptr) override;
+	virtual void visit(ne_expr::Ptr) override;
+	virtual void visit(mod_expr::Ptr) override;
+	virtual void visit(var_expr::Ptr) override;
+	virtual void visit(int_const::Ptr) override;
+	virtual void visit(double_const::Ptr) override;
+	virtual void visit(float_const::Ptr) override;
+	virtual void visit(string_const::Ptr) override;
+	virtual void visit(assign_expr::Ptr) override;
+	virtual void visit(expr_stmt::Ptr) override;
+	virtual void visit(stmt_block::Ptr) override;
+	virtual void visit(decl_stmt::Ptr) override;
+	virtual void visit(if_stmt::Ptr) override;
+	virtual void visit(while_stmt::Ptr) override;
+	virtual void visit(for_stmt::Ptr) override;
+	virtual void visit(break_stmt::Ptr) override;
+	virtual void visit(continue_stmt::Ptr) override;
+	virtual void visit(sq_bkt_expr::Ptr) override;
+	virtual void visit(function_call_expr::Ptr) override;
+	virtual void visit(initializer_list_expr::Ptr) override;
 
-	virtual void visit(var::Ptr);
-	virtual void visit(scalar_type::Ptr);
-	virtual void visit(pointer_type::Ptr);
-	virtual void visit(reference_type::Ptr);
-	virtual void visit(array_type::Ptr);
-	virtual void visit(builder_var_type::Ptr);
-	virtual void visit(named_type::Ptr);
+	virtual void visit(var::Ptr) override;
+	virtual void visit(scalar_type::Ptr) override;
+	virtual void visit(pointer_type::Ptr) override;
+	virtual void visit(reference_type::Ptr) override;
+	virtual void visit(array_type::Ptr) override;
+	virtual void visit(builder_var_type::Ptr) override;
+	virtual void visit(named_type::Ptr) override;
 
 	void handle_func_arg(var::Ptr a);
-	virtual void visit(func_decl::Ptr);
-	virtual void visit(return_stmt::Ptr);
-	virtual void visit(member_access_expr::Ptr);
-	virtual void visit(addr_of_expr::Ptr);
+	virtual void visit(func_decl::Ptr) override;
+	virtual void visit(return_stmt::Ptr) override;
+	virtual void visit(member_access_expr::Ptr) override;
+	virtual void visit(addr_of_expr::Ptr) override;
 
-	virtual void visit(goto_stmt::Ptr);
-	virtual void visit(label_stmt::Ptr);
+	virtual void visit(goto_stmt::Ptr) override;
+	virtual void visit(label_stmt::Ptr) override;
+
+	virtual void visit(cast_expr::Ptr) override;
 
 	static void generate_code(block::Ptr ast, std::ostream &oss, int indent = 0, bool decl_only = false) {
 		c_code_generator generator(oss);

include/blocks/expr.h

@@ -750,6 +750,39 @@ class addr_of_expr: public unary_expr {
 		return np;
 	}
 };
+
+
+
+
+/* Expressions that will never be generated but could be promoted 
+or are useful for representing some key elements */
+class cast_expr: public unary_expr {
+public:
+	type::Ptr type1;
+
+	typedef std::shared_ptr<cast_expr> Ptr;
+	virtual void dump(std::ostream &oss, int) override;
+	virtual void accept(block_visitor* a) override {
+		a->visit(self<cast_expr>());
+	}	
+	virtual bool is_same(block::Ptr other) override {
+		if (!isa<cast_expr>(other))
+			return false;
+		cast_expr::Ptr other_expr = to<cast_expr>(other);
+		if (!other_expr->expr1->is_same(expr1))
+			return false;
+		if (!other_expr->type1->is_same(type1))
+			return false;
+		return true;
+	}
+	virtual block::Ptr clone_impl(void) override {
+		auto np = clone_obj(this);
+		np->expr1 = clone(expr1);
+		np->type1 = clone(type1);
+		return np;
+	}
+};
+
 } // namespace block
 
 #endif

src/blocks/block_replacer.cpp

@@ -258,5 +258,10 @@ void block_replacer::visit(addr_of_expr::Ptr a) {
 	a->expr1 = rewrite(a->expr1);
 	node = a;
 }
+void block_replacer::visit(cast_expr::Ptr a) {
+	a->expr1 = rewrite(a->expr1);
+	a->type1 = rewrite(a->type1);
+	node = a;
+}
 
 } // namespace block

src/blocks/block_visitor.cpp

@@ -205,5 +205,9 @@ void block_visitor::visit(member_access_expr::Ptr a) {
 void block_visitor::visit(addr_of_expr::Ptr a) {
 	a->expr1->accept(this);
 }
+void block_visitor::visit(cast_expr::Ptr a) {
+	a->expr1->accept(this);
+	a->type1->accept(this);
+}
 
 } // namespace block

src/blocks/c_code_generator.cpp

@@ -378,6 +378,7 @@ void c_code_generator::visit(if_stmt::Ptr a) {
 	a->cond->accept(this);
 	oss << ")";
 	if (isa<stmt_block>(a->then_stmt)) {
+		auto sb = to<stmt_block>(a->then_stmt);
 		oss << " ";
 		a->then_stmt->accept(this);
 		oss << " ";
@@ -395,6 +396,9 @@ void c_code_generator::visit(if_stmt::Ptr a) {
 	if (isa<stmt_block>(a->else_stmt)) {
 		if (to<stmt_block>(a->else_stmt)->stmts.size() == 0)
 			return;
+
+		auto sb = to<stmt_block>(a->else_stmt);
+
 		oss << "else";
 		oss << " ";
 		a->else_stmt->accept(this);
@@ -529,13 +533,18 @@ void c_code_generator::visit(func_decl::Ptr a) {
 			handle_func_arg(arg);
 		} else {
 			arg->var_type->accept(this);
-			oss << " " << arg->var_name;
+			if (arg->var_name != "")
+				oss << " " << arg->var_name;
 		}
 	}
+	if (a->getBoolMetadata("is_variadic")) {
+		oss << ", ...";
+		printDelim = true;
+	}
 	if (!printDelim)
 		oss << "void";
 	oss << ")";
-	if (decl_only) {
+	if (decl_only || a->getBoolMetadata("is_decl_only")) {
 		oss << ";";
 		return;
 	}
@@ -569,8 +578,11 @@ void c_code_generator::visit(label_stmt::Ptr a) {
 	oss << a->label1->label_name << ":";
 }
 void c_code_generator::visit(return_stmt::Ptr a) {
-	oss << "return ";
-	a->return_val->accept(this);
+	oss << "return";
+	if (a->return_val) {
+		oss << " ";
+		a->return_val->accept(this);
+	}
 	oss << ";";
 }
 void c_code_generator::visit(member_access_expr::Ptr a) {
@@ -607,4 +619,18 @@ void c_code_generator::visit(addr_of_expr::Ptr a) {
 	a->expr1->accept(this);
 	oss << "))";
 }
+
+void c_code_generator::visit(cast_expr::Ptr a) {
+	oss << "(";
+	a->type1->accept(this);
+	oss << ")";
+	if (expr_needs_bracket(a->expr1)) {
+		oss << "(";
+		a->expr1->accept(this);
+		oss << ")";
+	} else {
+		a->expr1->accept(this);
+	}
+}
+
 } // namespace block

src/blocks/expr.cpp

@@ -207,4 +207,11 @@ void addr_of_expr::dump(std::ostream &oss, int indent) {
 	expr1->dump(oss, indent + 1);
 }
 
+void cast_expr::dump(std::ostream &oss, int indent) {
+	printer::indent(oss, indent);
+	oss << "CAST_EXPR" << std::endl;
+	expr1->dump(oss, indent + 1);
+	type1->dump(oss, indent + 1);
+}
+
 } // namespace block