From d31604dd81e806dcb9e66200b86043beaee92a42 Mon Sep 17 00:00:00 2001
From: Ajay Brahmakshatriya <ajaybr@mit.edu>
Date: Wed, 10 Dec 2025 11:05:34 -0500
Subject: [PATCH 1/2] Added support for all nodes required for DBD

---
 include/blocks/block_replacer.h    |   8 +-
 include/blocks/block_visitor.h     |   8 ++
 include/blocks/c_code_generator.h  | 110 +++++++++++-----------
 include/blocks/expr.h              |  41 +++++++++
 include/blocks/stmt.h              | 125 ++++++++++++++++++++++++-
 include/blocks/var.h               |  34 ++++++-
 include/builder/dyn_var.h          |  17 +++-
 samples/outputs.var_names/sample38 |   2 +-
 samples/outputs.var_names/sample42 |   6 +-
 samples/outputs.var_names/sample57 |   2 +-
 samples/outputs.var_names/sample60 |   2 +-
 samples/outputs.var_names/sample68 |   6 ++
 samples/outputs/sample38           |   2 +-
 samples/outputs/sample42           |   6 +-
 samples/outputs/sample57           |   2 +-
 samples/outputs/sample60           |   2 +-
 samples/outputs/sample68           |   6 ++
 samples/sample68.cpp               |  28 ++++++
 src/blocks/block_replacer.cpp      |  71 ++++++++++-----
 src/blocks/block_visitor.cpp       |  21 +++++
 src/blocks/c_code_generator.cpp    | 142 +++++++++++++++++++++++++++--
 src/blocks/expr.cpp                |   6 ++
 src/blocks/rce.cpp                 |  20 ++--
 src/blocks/stmt.cpp                |  15 +++
 src/blocks/var.cpp                 |   7 ++
 25 files changed, 581 insertions(+), 108 deletions(-)
 create mode 100644 samples/outputs.var_names/sample68
 create mode 100644 samples/outputs/sample68
 create mode 100644 samples/sample68.cpp

diff --git a/include/blocks/block_replacer.h b/include/blocks/block_replacer.h
index 51a2799..98844b7 100644
--- a/include/blocks/block_replacer.h
+++ b/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 std::shared_ptr<T> rewrite(std::shared_ptr<T> ptr) {
 		auto tmp = node;
 		node = nullptr;
 		ptr->accept(this);
@@ -64,6 +64,8 @@ class block_replacer : public block_visitor {
 	virtual void visit(std::shared_ptr<stmt_block>) override;
 	virtual void visit(std::shared_ptr<decl_stmt>) override;
 	virtual void visit(std::shared_ptr<if_stmt>) override;
+	virtual void visit(std::shared_ptr<case_stmt>) override;
+	virtual void visit(std::shared_ptr<switch_stmt>) override;
 	virtual void visit(std::shared_ptr<label>) override;
 	virtual void visit(std::shared_ptr<label_stmt>) override;
 	virtual void visit(std::shared_ptr<goto_stmt>) override;
@@ -78,6 +80,7 @@ class block_replacer : public block_visitor {
 	virtual void visit(std::shared_ptr<foreign_expr_base>) override;
 	virtual void visit(std::shared_ptr<member_access_expr>) override;
 	virtual void visit(std::shared_ptr<addr_of_expr>) override;
+	virtual void visit(std::shared_ptr<cast_expr>) override;
 
 	virtual void visit(std::shared_ptr<var>) override;
 	virtual void visit(std::shared_ptr<type>) override;
@@ -88,6 +91,7 @@ class block_replacer : public block_visitor {
 	virtual void visit(std::shared_ptr<array_type>) override;
 	virtual void visit(std::shared_ptr<builder_var_type>) override;
 	virtual void visit(std::shared_ptr<named_type>) override;
+	virtual void visit(std::shared_ptr<anonymous_type>) override;
 
 	virtual void visit(std::shared_ptr<func_decl>) override;
 	virtual void visit(std::shared_ptr<struct_decl>) override;
diff --git a/include/blocks/block_visitor.h b/include/blocks/block_visitor.h
index 6d0d6df..2199c6d 100644
--- a/include/blocks/block_visitor.h
+++ b/include/blocks/block_visitor.h
@@ -40,6 +40,8 @@ class expr_stmt;
 class stmt_block;
 class decl_stmt;
 class if_stmt;
+class switch_stmt;
+class case_stmt;
 class label;
 class label_stmt;
 class goto_stmt;
@@ -54,6 +56,7 @@ class initializer_list_expr;
 class foreign_expr_base;
 class member_access_expr;
 class addr_of_expr;
+class cast_expr;
 
 class var;
 class type;
@@ -64,6 +67,7 @@ class function_type;
 class array_type;
 class builder_var_type;
 class named_type;
+class anonymous_type;
 
 class func_decl;
 class struct_decl;
@@ -108,6 +112,8 @@ class block_visitor {
 	virtual void visit(std::shared_ptr<stmt_block>);
 	virtual void visit(std::shared_ptr<decl_stmt>);
 	virtual void visit(std::shared_ptr<if_stmt>);
+	virtual void visit(std::shared_ptr<switch_stmt>);
+	virtual void visit(std::shared_ptr<case_stmt>);
 	virtual void visit(std::shared_ptr<label>);
 	virtual void visit(std::shared_ptr<label_stmt>);
 	virtual void visit(std::shared_ptr<goto_stmt>);
@@ -122,6 +128,7 @@ class block_visitor {
 	virtual void visit(std::shared_ptr<foreign_expr_base>);
 	virtual void visit(std::shared_ptr<member_access_expr>);
 	virtual void visit(std::shared_ptr<addr_of_expr>);
+	virtual void visit(std::shared_ptr<cast_expr>);
 
 	virtual void visit(std::shared_ptr<var>);
 	virtual void visit(std::shared_ptr<type>);
@@ -132,6 +139,7 @@ class block_visitor {
 	virtual void visit(std::shared_ptr<array_type>);
 	virtual void visit(std::shared_ptr<builder_var_type>);
 	virtual void visit(std::shared_ptr<named_type>);
+	virtual void visit(std::shared_ptr<anonymous_type>);
 
 	virtual void visit(std::shared_ptr<func_decl>);
 	virtual void visit(std::shared_ptr<struct_decl>);
diff --git a/include/blocks/c_code_generator.h b/include/blocks/c_code_generator.h
index 45711b5..cc215a1 100644
--- a/include/blocks/c_code_generator.h
+++ b/include/blocks/c_code_generator.h
@@ -32,63 +32,68 @@ 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(switch_stmt::Ptr) override;
+	virtual void visit(case_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;
+	virtual void visit(anonymous_type::Ptr) override;
 
-	virtual void visit(func_decl::Ptr);
-	virtual void visit(struct_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(struct_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(cast_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;
 
 	void print_pragma(stmt::Ptr);
+	void print_struct_type(struct_decl::Ptr a);
 	void handle_child(expr::Ptr parent, expr::Ptr child, bool is_left);
 
 	static void generate_code(block::Ptr ast, std::ostream &oss, int indent = 0, bool decl_only = false) {
@@ -135,6 +140,7 @@ class c_code_generator : public block_visitor {
 		/* Dump the type */
 		c_code_generator generator(oss);
 		sd->accept(&generator);
+		oss << std::endl;
 	}
 };
 } // namespace block
diff --git a/include/blocks/expr.h b/include/blocks/expr.h
index 41f13b6..619c8e5 100644
--- a/include/blocks/expr.h
+++ b/include/blocks/expr.h
@@ -404,12 +404,19 @@ class var_expr : public expr {
 	}
 
 	var::Ptr var1;
+	std::vector<block::Ptr> template_args;
 	virtual bool is_same(block::Ptr other) override {
 		if (!isa<var_expr>(other))
 			return false;
 		var_expr::Ptr other_expr = to<var_expr>(other);
 		if (!var1->is_same(other_expr->var1))
 			return false;
+		if (template_args.size() != other_expr->template_args.size())
+			return false;
+		for (unsigned i = 0; i < template_args.size(); i++) {
+			if (!(template_args[i]->is_same(other_expr->template_args[i])))
+				return false;
+		}
 		return true;
 	}
 	virtual block::Ptr clone_impl(void) override {
@@ -417,6 +424,9 @@ class var_expr : public expr {
 		// Vars are special cases and should not be cloned
 		// This is to avoid problems where vars are compared by pointers
 		np->var1 = var1;
+		for (auto a: template_args) {
+			np->template_args.push_back(clone(a));
+		}
 		return np;	
 	}
 };
@@ -750,6 +760,37 @@ 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
diff --git a/include/blocks/stmt.h b/include/blocks/stmt.h
index d585328..df464c5 100644
--- a/include/blocks/stmt.h
+++ b/include/blocks/stmt.h
@@ -100,10 +100,21 @@ class decl_stmt : public stmt {
 	var::Ptr decl_var;
 	// Optional initialization
 	expr::Ptr init_expr = nullptr;
+	bool is_typedef = false;
+	bool is_extern = false;
+	bool is_static = false;
 	virtual bool is_same(block::Ptr other) override {
 		if (!isa<decl_stmt>(other))
 			return false;
 		decl_stmt::Ptr other_stmt = to<decl_stmt>(other);
+
+		if (is_typedef != other_stmt->is_typedef)
+			return false;
+		if (is_extern != other_stmt->is_extern)
+			return false;
+		if (is_static != other_stmt->is_static)
+			return false;
+
 		if (!decl_var->is_same(other_stmt->decl_var))
 			return false;
 		if (init_expr == nullptr && other_stmt->init_expr != nullptr)
@@ -122,8 +133,11 @@ class decl_stmt : public stmt {
 		// they are compared by pointers sometimes
 
 		// If we _do_ end up duplicating them, 
-		// they should be consistently updated
+		// they should be consistently updated	
 		np->decl_var = decl_var;
+		np->is_typedef = is_typedef;
+		np->is_extern = is_extern;
+		np->is_static = is_static;	
 		np->init_expr = clone(init_expr);
 		return np;
 	}
@@ -173,6 +187,83 @@ class if_stmt : public stmt {
 		return np;
 	}
 };
+class case_stmt: public stmt {
+public:
+	typedef std::shared_ptr<case_stmt> Ptr;
+	virtual void dump(std::ostream&, int) override;
+	virtual void accept(block_visitor* a) override {
+		a->visit(self<case_stmt>());
+	}
+	// if default, int_const is set to nullptr;
+	bool is_default;
+	int_const::Ptr case_value;
+	// Can be null in case the branch is empty
+	stmt::Ptr branch;
+
+	virtual bool is_same(block::Ptr other) override {
+		if (!isa<case_stmt>(other))
+			return false;
+		case_stmt::Ptr other_stmt = to<case_stmt>(other);
+		if (is_default != other_stmt->is_default)
+			return false;
+		if (!is_default && !case_value->is_same(other_stmt->case_value))
+			return false;
+		if (branch != nullptr && other_stmt->branch == nullptr)
+			return false;
+		if (branch == nullptr && other_stmt->branch != nullptr)
+			return false;
+		if (branch!= nullptr && !branch->is_same(other_stmt->branch))
+			return false;
+		return true;
+	}
+	virtual block::Ptr clone_impl(void) override {
+		auto nc = clone_stmt(this);
+		nc->is_default = is_default;
+		if (case_value) 
+			nc->case_value = clone(case_value);
+		else 
+			nc->case_value = nullptr;
+		if (branch)
+			nc->branch = clone(branch);
+		else
+			nc->branch = nullptr;
+		return nc;
+	}
+};
+
+class switch_stmt: public stmt {
+public:
+	typedef std::shared_ptr<switch_stmt> Ptr;
+	virtual void dump(std::ostream&, int) override;
+	virtual void accept(block_visitor *a) override {
+		a->visit(self<switch_stmt>());
+	}
+	expr::Ptr cond;	
+	std::vector<case_stmt::Ptr> cases;
+	
+	virtual bool is_same(block::Ptr other) override {
+		if (!isa<switch_stmt>(other))
+			return false;
+		switch_stmt::Ptr other_stmt = to<switch_stmt>(other);
+		if (!cond->is_same(other_stmt->cond))
+			return false;
+		if (cases.size() != other_stmt->cases.size())
+			return false;
+		for (unsigned i = 0; i < cases.size(); i++) {
+			if (!(cases[i]->is_same(other_stmt->cases[i]))) 
+				return false;
+		}
+		return true;
+	}
+	virtual block::Ptr clone_impl(void) override {
+		auto nc = clone_stmt(this);
+		nc->cond = clone(cond);	
+		for (auto c: cases) {
+			nc->cases.push_back(clone(c));
+		}	
+		return nc;
+	}
+};
 class label : public block {
 public:
 	typedef std::shared_ptr<label> Ptr;
@@ -362,11 +453,27 @@ class func_decl : public stmt {
 	type::Ptr return_type;
 	std::vector<var::Ptr> args;
 	stmt::Ptr body;
+
+	bool is_decl_only = false;
+	bool is_variadic = false;
+	bool is_static = false;
+	bool is_inline = false;
+
 	virtual bool is_same(block::Ptr other) override {
 		// Functions don't have static offsets
 		if (!isa<func_decl>(other))
 			return false;
 		func_decl::Ptr other_func = to<func_decl>(other);
+
+		if (is_decl_only != other_func->is_decl_only) 
+			return false;
+		if (is_variadic != other_func->is_variadic) 
+			return false;
+		if (is_static != other_func->is_static) 
+			return false;
+		if (is_inline != other_func->is_inline) 
+			return false;
+
 		if (!return_type->is_same(other_func->return_type))
 			return false;
 		if (args.size() != other_func->args.size())
@@ -383,6 +490,12 @@ class func_decl : public stmt {
 		auto np = clone_stmt(this);
 		np->func_name = func_name;
 		np->return_type = clone(return_type);
+
+		np->is_decl_only = is_decl_only;
+		np->is_variadic = is_variadic;
+		np->is_static = is_static;
+		np->is_inline = is_inline;
+
 		for (auto arg: args) {
 			np->args.push_back(clone(arg));
 		}
@@ -402,6 +515,8 @@ class struct_decl : public stmt {
 
 	std::string struct_name;
 	std::vector<decl_stmt::Ptr> members;
+	bool is_union = false;
+	bool is_decl_only = false;
 	virtual bool is_same(block::Ptr other) override {
 		// Struct decls like Function Decls don't have static offsets
 		if (!isa<struct_decl>(other)) 
@@ -411,6 +526,12 @@ class struct_decl : public stmt {
 		if (struct_name != other_struct->struct_name)
 			return false;
 
+		if (is_union != other_struct->is_union) 
+			return false;
+
+		if (is_decl_only != other_struct->is_decl_only) 
+			return false;
+
 		if (members.size() != other_struct->members.size()) 
 			return false;
 		// We will look for exact struct matches including member names
@@ -424,6 +545,8 @@ class struct_decl : public stmt {
 	virtual block::Ptr clone_impl(void) override {
 		auto np = clone_stmt(this);
 		np->struct_name = struct_name;
+		np->is_union = is_union;
+		np->is_decl_only = is_decl_only;
 		for (auto mem: members) {
 			np->members.push_back(clone(mem));
 		}
diff --git a/include/blocks/var.h b/include/blocks/var.h
index 5e7cd62..02973f8 100644
--- a/include/blocks/var.h
+++ b/include/blocks/var.h
@@ -43,6 +43,7 @@ class scalar_type : public type {
 		VOID_TYPE,
 		FLOAT_TYPE,
 		DOUBLE_TYPE,
+		LONG_DOUBLE_TYPE,
 		BOOL_TYPE
 	} scalar_type_id;
 	virtual void accept(block_visitor *a) override {
@@ -112,11 +113,12 @@ class function_type : public type {
 
 	type::Ptr return_type;
 	std::vector<type::Ptr> arg_types;
-
+	bool is_variadic = false;
 	virtual void dump(std::ostream &, int) override;
 	virtual block::Ptr clone_impl(void) override {
 		auto np = clone_type(this);
 		np->return_type = clone(return_type);
+		np->is_variadic = is_variadic;
 		for (auto t: arg_types) {
 			np->arg_types.push_back(clone(t));
 		}
@@ -125,6 +127,7 @@ class function_type : public type {
 	virtual bool is_same(block::Ptr other) override {
 		if (!isa<function_type>(other)) return false;
 		function_type::Ptr ftype = to<function_type>(other);
+		if (is_variadic != ftype->is_variadic) return false;
 		if (!ftype->return_type->is_same(return_type)) return false;
 		if (ftype->arg_types.size() != arg_types.size()) return false;
 		for (unsigned i = 0; i < arg_types.size(); i++) {
@@ -213,6 +216,35 @@ class named_type : public type {
 		return true;
 	}
 };
+// This is specifically for the case where the type doesn't have a name
+// and directly references a struct decl.
+class anonymous_type : public type {
+public:
+	typedef std::shared_ptr<anonymous_type> Ptr;
+
+	// This is specifically a struct_decl, but since struct_decl isn't defined yet we
+	// will use a block
+	std::shared_ptr<block> ref_type;
+	virtual void accept(block_visitor *a) override {
+		a->visit(self<anonymous_type>());
+	}
+	virtual void dump(std::ostream&, int) override;
+	
+	virtual block::Ptr clone_impl(void) override {
+		auto np = clone_type(this);
+		np->ref_type = clone(ref_type);
+		return np;
+	}
+	virtual bool is_same(block::Ptr other) override {
+		if (!isa<anonymous_type>(other)) 
+			return false;
+		anonymous_type::Ptr atype = to<anonymous_type>(other);
+		if (!ref_type->is_same(atype->ref_type))
+			return false;
+		return true;
+	}
+};
+
 
 
 class var : public block {
diff --git a/include/builder/dyn_var.h b/include/builder/dyn_var.h
index 84e30ea..e310087 100644
--- a/include/builder/dyn_var.h
+++ b/include/builder/dyn_var.h
@@ -545,7 +545,22 @@ template <typename T>
 typename std::enable_if<std::is_base_of<var, T>::value>::type create_return_stmt(const T &a) {
 	create_return_stmt((builder)a);
 }
+template <typename T>
+dyn_var_mimic<T> cast_to(const builder& x) {
+	if (builder::builder_precheck()) {
+		return builder::create_builder_from_sequence();
+	}
+	get_run_state()->remove_node_from_sequence(x.block_expr);
+	tracer::tag offset = tracer::get_offset_in_function();
+	auto ce = std::make_shared<block::cast_expr>();
+	ce->static_offset = offset;
+	ce->expr1 = x.block_expr;
+	ce->type1 = dyn_var<T>::create_block_type();
+	builder b;
+	b.block_expr = ce;
+	builder::push_to_sequence(ce);
+	return (cast)b;
+}
 
 } // namespace builder
-
 #endif
diff --git a/samples/outputs.var_names/sample38 b/samples/outputs.var_names/sample38
index 993dfc5..04e0bbc 100644
--- a/samples/outputs.var_names/sample38
+++ b/samples/outputs.var_names/sample38
@@ -73,6 +73,6 @@ STMT_BLOCK
   FooT* ptr_3 = &g_0;
   ptr_3->member = 0;
   ptr_3->member = 1;
-  FooT i_4 = ptr_3[0];
+  FooT i_4 = *ptr_3;
   i_4.member = 3;
 }
diff --git a/samples/outputs.var_names/sample42 b/samples/outputs.var_names/sample42
index 2b51296..b1787a7 100644
--- a/samples/outputs.var_names/sample42
+++ b/samples/outputs.var_names/sample42
@@ -1,13 +1,13 @@
 void bar (void) {
   int y_0[10] = 0;
   for (int x_1 = 0; x_1 < 10; x_1 = x_1 + 1) {
-    y_0[0] = y_0[0] + x_1;
+    *y_0 = *y_0 + x_1;
     y_0[x_1] = y_0[x_1] * 2;
   }
   for (int x_2 = 0; x_2 < 10; (x_2 = x_2 + 1) - 1) {
-    y_0[0] = y_0[0] - x_2;
+    *y_0 = *y_0 - x_2;
     y_0[x_2] = y_0[x_2] / 2;
   }
-  (y_0[0] = y_0[0] + 1) - 1;
+  (*y_0 = *y_0 + 1) - 1;
 }
 
diff --git a/samples/outputs.var_names/sample57 b/samples/outputs.var_names/sample57
index 2d06169..dda1c8c 100644
--- a/samples/outputs.var_names/sample57
+++ b/samples/outputs.var_names/sample57
@@ -1,7 +1,7 @@
 void bar (void) {
   int x_0 = 0;
   int* y_1 = &x_0;
-  (y_1[0] = y_1[0] + 1) - 1;
+  (*y_1 = *y_1 + 1) - 1;
   int z_2 = 0;
   (z_2 = z_2 + 1) - 1;
   int a_3 = z_2;
diff --git a/samples/outputs.var_names/sample60 b/samples/outputs.var_names/sample60
index 1b0cd13..0e0e65d 100644
--- a/samples/outputs.var_names/sample60
+++ b/samples/outputs.var_names/sample60
@@ -17,6 +17,6 @@ void bar (void) {
     res_12 = m_4;
   }
   int* var14 = &x_0;
-  var14[0] = 0;
+  *var14 = 0;
 }
 
diff --git a/samples/outputs.var_names/sample68 b/samples/outputs.var_names/sample68
new file mode 100644
index 0000000..ba8daa6
--- /dev/null
+++ b/samples/outputs.var_names/sample68
@@ -0,0 +1,6 @@
+void bar (void) {
+  int* x_0 = (int*)malloc(4ll);
+  x_0[0] = 123;
+  free(x_0);
+}
+
diff --git a/samples/outputs/sample38 b/samples/outputs/sample38
index fd586bd..ef56c07 100644
--- a/samples/outputs/sample38
+++ b/samples/outputs/sample38
@@ -73,6 +73,6 @@ STMT_BLOCK
   FooT* var3 = &var0;
   var3->member = 0;
   var3->member = 1;
-  FooT var4 = var3[0];
+  FooT var4 = *var3;
   var4.member = 3;
 }
diff --git a/samples/outputs/sample42 b/samples/outputs/sample42
index 5f3dd65..96e6831 100644
--- a/samples/outputs/sample42
+++ b/samples/outputs/sample42
@@ -1,13 +1,13 @@
 void bar (void) {
   int var0[10] = 0;
   for (int var1 = 0; var1 < 10; var1 = var1 + 1) {
-    var0[0] = var0[0] + var1;
+    *var0 = *var0 + var1;
     var0[var1] = var0[var1] * 2;
   }
   for (int var2 = 0; var2 < 10; (var2 = var2 + 1) - 1) {
-    var0[0] = var0[0] - var2;
+    *var0 = *var0 - var2;
     var0[var2] = var0[var2] / 2;
   }
-  (var0[0] = var0[0] + 1) - 1;
+  (*var0 = *var0 + 1) - 1;
 }
 
diff --git a/samples/outputs/sample57 b/samples/outputs/sample57
index 2905aba..99a6710 100644
--- a/samples/outputs/sample57
+++ b/samples/outputs/sample57
@@ -1,7 +1,7 @@
 void bar (void) {
   int var0 = 0;
   int* var1 = &var0;
-  (var1[0] = var1[0] + 1) - 1;
+  (*var1 = *var1 + 1) - 1;
   int var2 = 0;
   (var2 = var2 + 1) - 1;
   int var3 = var2;
diff --git a/samples/outputs/sample60 b/samples/outputs/sample60
index d0c196d..d893b64 100644
--- a/samples/outputs/sample60
+++ b/samples/outputs/sample60
@@ -17,6 +17,6 @@ void bar (void) {
     var12 = var4;
   }
   int* var14 = &var0;
-  var14[0] = 0;
+  *var14 = 0;
 }
 
diff --git a/samples/outputs/sample68 b/samples/outputs/sample68
new file mode 100644
index 0000000..1cc508f
--- /dev/null
+++ b/samples/outputs/sample68
@@ -0,0 +1,6 @@
+void bar (void) {
+  int* var0 = (int*)malloc(4ll);
+  var0[0] = 123;
+  free(var0);
+}
+
diff --git a/samples/sample68.cpp b/samples/sample68.cpp
new file mode 100644
index 0000000..70b5b12
--- /dev/null
+++ b/samples/sample68.cpp
@@ -0,0 +1,28 @@
+// Include the headers
+#include "blocks/c_code_generator.h"
+#include "builder/static_var.h"
+#include "builder/dyn_var.h"
+#include <iostream>
+
+// Include the BuildIt types
+using builder::dyn_var;
+using builder::static_var;
+
+namespace runtime {
+static dyn_var<void*(size_t)> malloc = builder::with_name("malloc");
+static dyn_var<void(void*)> free = builder::with_name("free");
+}
+
+static void bar(void) {
+	dyn_var<int*> x = builder::cast_to<int*>(runtime::malloc(sizeof(int)));	
+	x[0] = 123;
+	runtime::free(x);
+}
+
+int main(int argc, char* argv[]) {
+	builder::builder_context context;
+	auto ast = context.extract_function_ast(bar, "bar");
+	block::c_code_generator::generate_code(ast, std::cout, 0);
+	return 0;
+}
+
diff --git a/src/blocks/block_replacer.cpp b/src/blocks/block_replacer.cpp
index d02e0bc..aa3e543 100644
--- a/src/blocks/block_replacer.cpp
+++ b/src/blocks/block_replacer.cpp
@@ -88,7 +88,10 @@ void block_replacer::visit(mod_expr::Ptr a) {
 	binary_helper(a);
 }
 void block_replacer::visit(var_expr::Ptr a) {
-	a->var1 = rewrite<var>(a->var1);
+	a->var1 = rewrite(a->var1);
+	for (unsigned i = 0; i < a->template_args.size(); i++) {
+		a->template_args[i] = rewrite(a->template_args[i]);
+	}
 	node = a;
 }
 void block_replacer::visit(const_expr::Ptr a) {
@@ -120,21 +123,35 @@ void block_replacer::visit(expr_stmt::Ptr a) {
 }
 void block_replacer::visit(stmt_block::Ptr a) {
 	for (unsigned int i = 0; i < a->stmts.size(); i++) {
-		auto tmp = rewrite<stmt>(a->stmts[i]);
+		auto tmp = rewrite(a->stmts[i]);
 		a->stmts.at(i) = tmp;
 	}
 	node = a;
 }
 void block_replacer::visit(decl_stmt::Ptr a) {
-	a->decl_var = rewrite<var>(a->decl_var);
+	a->decl_var = rewrite(a->decl_var);
 	if (a->init_expr != nullptr)
 		a->init_expr = rewrite(a->init_expr);
 	node = a;
 }
 void block_replacer::visit(if_stmt::Ptr a) {
 	a->cond = rewrite(a->cond);
-	a->then_stmt = rewrite<stmt>(a->then_stmt);
-	a->else_stmt = rewrite<stmt>(a->else_stmt);
+	a->then_stmt = rewrite(a->then_stmt);
+	a->else_stmt = rewrite(a->else_stmt);
+	node = a;
+}
+void block_replacer::visit(case_stmt::Ptr a) {
+	if (a->case_value)
+		a->case_value = rewrite(a->case_value);
+	if (a->branch)
+		a->branch = rewrite(a->branch);
+	node = a;
+}
+void block_replacer::visit(switch_stmt::Ptr a) {
+	a->cond = rewrite(a->cond);
+	for (unsigned i = 0; i < a->cases.size(); i++) {
+		a->cases[i] = rewrite(a->cases[i]);
+	}
 	node = a;
 }
 void block_replacer::visit(label::Ptr a) {
@@ -142,12 +159,12 @@ void block_replacer::visit(label::Ptr a) {
 }
 void block_replacer::visit(label_stmt::Ptr a) {
 	if (a->label1 != nullptr)
-		a->label1 = rewrite<label>(a->label1);
+		a->label1 = rewrite(a->label1);
 	node = a;
 }
 void block_replacer::visit(goto_stmt::Ptr a) {
 	if (a->label1 != nullptr)
-		a->label1 = rewrite<label>(a->label1);
+		a->label1 = rewrite(a->label1);
 	node = a;
 }
 void block_replacer::visit(break_stmt::Ptr a) {
@@ -158,14 +175,14 @@ void block_replacer::visit(continue_stmt::Ptr a) {
 }
 void block_replacer::visit(while_stmt::Ptr a) {
 	a->cond = rewrite(a->cond);
-	a->body = rewrite<stmt>(a->body);
+	a->body = rewrite(a->body);
 	node = a;
 }
 void block_replacer::visit(for_stmt::Ptr a) {
-	a->decl_stmt = rewrite<stmt>(a->decl_stmt);
+	a->decl_stmt = rewrite(a->decl_stmt);
 	a->cond = rewrite(a->cond);
 	a->update = rewrite(a->update);
-	a->body = rewrite<stmt>(a->body);
+	a->body = rewrite(a->body);
 	node = a;
 }
 void block_replacer::visit(sq_bkt_expr::Ptr a) {
@@ -195,7 +212,7 @@ void block_replacer::visit(foreign_expr_base::Ptr a) {
 	node = a;
 }
 void block_replacer::visit(var::Ptr a) {
-	a->var_type = rewrite<type>(a->var_type);
+	a->var_type = rewrite(a->var_type);
 	node = a;
 }
 void block_replacer::visit(type::Ptr a) {
@@ -205,50 +222,54 @@ void block_replacer::visit(scalar_type::Ptr a) {
 	node = a;
 }
 void block_replacer::visit(pointer_type::Ptr a) {
-	a->pointee_type = rewrite<type>(a->pointee_type);
+	a->pointee_type = rewrite(a->pointee_type);
 	node = a;
 }
 void block_replacer::visit(reference_type::Ptr a) {
-	a->referenced_type = rewrite<type>(a->referenced_type);
+	a->referenced_type = rewrite(a->referenced_type);
 	node = a;
 }
 void block_replacer::visit(function_type::Ptr a) {
-	a->return_type = rewrite<type>(a->return_type);
+	a->return_type = rewrite(a->return_type);
 	for (unsigned int i = 0; i < a->arg_types.size(); i++) {
-		auto tmp = rewrite<type>(a->arg_types[i]);
+		auto tmp = rewrite(a->arg_types[i]);
 		a->arg_types.at(i) = tmp;
 	}
 	node = a;
 }
 void block_replacer::visit(array_type::Ptr a) {
-	a->element_type = rewrite<type>(a->element_type);
+	a->element_type = rewrite(a->element_type);
 	node = a;
 }
 void block_replacer::visit(builder_var_type::Ptr a) {
-	a->closure_type = rewrite<type>(a->closure_type);
+	a->closure_type = rewrite(a->closure_type);
 	node = a;
 }
 void block_replacer::visit(named_type::Ptr a) {
 	std::vector<type::Ptr> new_args;
 	for (auto b : a->template_args) {
-		new_args.push_back(rewrite<type>(b));
+		new_args.push_back(rewrite(b));
 	}
 	a->template_args = new_args;
 	node = a;
 }
+void block_replacer::visit(anonymous_type::Ptr a) {
+	a->ref_type = rewrite(to<struct_decl>(a->ref_type));
+	node = a;
+}
 void block_replacer::visit(func_decl::Ptr a) {
-	a->return_type = rewrite<type>(a->return_type);
+	a->return_type = rewrite(a->return_type);
 	for (unsigned int i = 0; i < a->args.size(); i++) {
-		auto tmp = rewrite<var>(a->args[i]);
+		auto tmp = rewrite(a->args[i]);
 		a->args.at(i) = tmp;
 	}
-	a->body = rewrite<stmt>(a->body);
+	a->body = rewrite(a->body);
 	node = a;
 }
 
 void block_replacer::visit(struct_decl::Ptr a) {
 	for (unsigned int i = 0; i < a->members.size(); i++) {
-		auto tmp = rewrite<decl_stmt>(a->members[i]);
+		auto tmp = rewrite(a->members[i]);
 		a->members.at(i) = tmp;
 	}
 	node = a;
@@ -267,5 +288,11 @@ 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
diff --git a/src/blocks/block_visitor.cpp b/src/blocks/block_visitor.cpp
index 83e63f6..6baaf51 100644
--- a/src/blocks/block_visitor.cpp
+++ b/src/blocks/block_visitor.cpp
@@ -94,6 +94,9 @@ void block_visitor::visit(mod_expr::Ptr a) {
 }
 void block_visitor::visit(var_expr::Ptr a) {
 	a->var1->accept(this);
+	for (auto t: a->template_args) {
+		t->accept(this);
+	}
 }
 void block_visitor::visit(const_expr::Ptr a) {}
 void block_visitor::visit(int_const::Ptr a) {}
@@ -123,6 +126,17 @@ void block_visitor::visit(if_stmt::Ptr a) {
 	a->then_stmt->accept(this);
 	a->else_stmt->accept(this);
 }
+void block_visitor::visit(case_stmt::Ptr a) {
+	if (a->case_value)
+		a->case_value->accept(this);
+	if (a->branch)
+		a->branch->accept(this);
+}
+void block_visitor::visit(switch_stmt::Ptr a) {
+	a->cond->accept(this);
+	for (auto c: a->cases)
+		c->accept(this);
+}
 void block_visitor::visit(label::Ptr a) {}
 void block_visitor::visit(label_stmt::Ptr a) {
 	if (a->label1 != nullptr)
@@ -195,6 +209,9 @@ void block_visitor::visit(func_decl::Ptr a) {
 		arg->accept(this);
 	a->body->accept(this);
 }
+void block_visitor::visit(anonymous_type::Ptr x) {
+	x->ref_type->accept(this);
+}
 
 void block_visitor::visit(struct_decl::Ptr a) {
 	for (auto mem: a->members)
@@ -211,5 +228,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
diff --git a/src/blocks/c_code_generator.cpp b/src/blocks/c_code_generator.cpp
index 7a51e67..0bd858a 100644
--- a/src/blocks/c_code_generator.cpp
+++ b/src/blocks/c_code_generator.cpp
@@ -53,9 +53,19 @@ static precedence_t get_operator_precedence(expr::Ptr a) {
 	if (isa<var_expr>(a) || isa<const_expr>(a)) 
 		return {0, true};
 
+	// Special cases
+	if (isa<sq_bkt_expr>(a) && a->getBoolMetadata("deref_is_star")) {
+		auto sk = to<sq_bkt_expr>(a);
+		if (isa<int_const>(sk->index)) {
+			if (to<int_const>(sk->index)->value == 0) {
+				return {3, false};
+			}	
+		}
+	}
 	if (isa<function_call_expr>(a) || isa<sq_bkt_expr>(a) || isa<member_access_expr>(a)) {
 		return {2, true};	
-	} else if (isa<unary_minus_expr>(a) || isa<not_expr>(a) || isa<bitwise_not_expr>(a) || isa<addr_of_expr>(a)) {
+	} else if (isa<unary_minus_expr>(a) || isa<not_expr>(a) || isa<bitwise_not_expr>(a) || isa<addr_of_expr>(a) 
+		|| isa<cast_expr>(a)) {
 		return {3, false};
 	} else if (isa<mul_expr>(a) || isa<div_expr>(a) || isa<mod_expr>(a)) {
 		return {5, true};
@@ -101,6 +111,33 @@ void c_code_generator::handle_child(expr::Ptr parent, expr::Ptr child, bool is_l
 	if (bracket) oss << ")";
 }
 
+void c_code_generator::print_struct_type(struct_decl::Ptr a) {
+	if (a->is_union) oss << "union ";
+	else oss << "struct ";
+
+	oss << a->struct_name;
+
+	if (a->is_decl_only) {
+		return;
+	}
+
+	if (a->struct_name != "")
+		oss << " ";
+
+	oss << "{";
+	nextl();
+
+	curr_indent++;
+	for (auto mem: a->members) {
+		printer::indent(oss, curr_indent);
+		mem->accept(this);
+		nextl();
+	}
+	curr_indent--;
+	printer::indent(oss, curr_indent);
+	oss << "}";
+}
+
 
 void c_code_generator::visit(not_expr::Ptr a) {
 	oss << "!";
@@ -178,6 +215,15 @@ void c_code_generator::visit(mod_expr::Ptr a) {
 }
 void c_code_generator::visit(var_expr::Ptr a) {
 	oss << a->var1->var_name;
+	if (a->template_args.size() > 0) {
+		oss << "<";
+		for (unsigned i = 0; i < a->template_args.size(); i++) {
+			a->template_args[i]->accept(this);
+			if (i != a->template_args.size() - 1) 
+				oss << ", ";
+		}
+		oss << ">";
+	}
 }
 void c_code_generator::visit(int_const::Ptr a) {
 	oss << a->value;
@@ -279,6 +325,12 @@ static std::string complex_type_helper(type::Ptr a, std::string name) {
 			if (i + 1 < ft->arg_types.size()) 
 				ret += ", ";
 		}
+		if (ft->is_variadic) {
+			if (ft->arg_types.size() > 0) {
+				ret += ", ";
+			}
+			ret += "...";
+		}
 		ret += ")";
 		return complex_type_helper(ft->return_type, ret);
 	} else if (isa<scalar_type>(a)) {
@@ -324,6 +376,9 @@ static std::string complex_type_helper(type::Ptr a, std::string name) {
 			case scalar_type::DOUBLE_TYPE:
 				tp = "double";
 				break;
+			case scalar_type::LONG_DOUBLE_TYPE:
+				tp = "long double";
+				break;
 			case scalar_type::BOOL_TYPE:
 				tp = "bool";
 				break;
@@ -346,6 +401,13 @@ static std::string complex_type_helper(type::Ptr a, std::string name) {
 			ret += ">";
 		}
 		return ret + name;
+	} else if (isa<anonymous_type>(a)) {
+		auto at = to<anonymous_type>(a);
+		std::string ret = addQualifiers(a);
+		std::stringstream ss;
+		c_code_generator gen(ss);
+		gen.print_struct_type(to<struct_decl>(at->ref_type));
+		return ret + ss.str() +  name;
 	} else if (isa<reference_type>(a)) {
 		auto ptr = to<reference_type>(a);
 		std::string decorated = "&" + addQualifiers(ptr, false) + name;
@@ -374,6 +436,9 @@ void c_code_generator::visit(scalar_type::Ptr type) {
 void c_code_generator::visit(named_type::Ptr type) {
 	oss << complex_type_helper(type, "");
 }
+void c_code_generator::visit(anonymous_type::Ptr type) {
+	oss << complex_type_helper(type, "");
+}
 void c_code_generator::visit(pointer_type::Ptr type) {
 	oss << complex_type_helper(type, "");
 }
@@ -391,6 +456,12 @@ void c_code_generator::visit(var::Ptr var) {
 }
 
 void c_code_generator::visit(decl_stmt::Ptr a) {
+	if (a->is_typedef) 
+		oss << "typedef ";
+	if (a->is_extern)
+		oss << "extern ";
+	if (a->is_static)
+		oss << "static ";
 	oss << complex_type_helper(a->decl_var->var_type, " " + a->decl_var->var_name);
 	if (a->decl_var->hasMetadata<std::vector<std::string>>("attributes")) {
 		const auto &attributes = a->decl_var->getMetadata<std::vector<std::string>>("attributes");
@@ -441,6 +512,34 @@ void c_code_generator::visit(if_stmt::Ptr a) {
 		curr_indent--;
 	}
 }
+void c_code_generator::visit(case_stmt::Ptr a) {
+	if (a->is_default) {
+		oss << "default";
+	} else {
+		oss << "case ";
+		a->case_value->accept(this);
+	}
+	oss << ": ";
+	save_static_info(a);
+	if (a->branch)
+		a->branch->accept(this);
+}
+void c_code_generator::visit(switch_stmt::Ptr a) {
+	oss << "switch(";
+	a->cond->accept(this);
+	oss << ") {";
+	save_static_info(a);
+	nextl();
+	curr_indent++;
+	for (auto c: a->cases) {
+		printer::indent(oss, curr_indent);
+		c->accept(this);
+		nextl();
+	}
+	curr_indent--;
+	printer::indent(oss, curr_indent);
+	oss << "}";
+}
 void c_code_generator::visit(while_stmt::Ptr a) {
 	oss << "while (";
 	a->cond->accept(this);
@@ -486,11 +585,25 @@ void c_code_generator::visit(continue_stmt::Ptr a) {
 	oss << "continue;";
 }
 void c_code_generator::visit(sq_bkt_expr::Ptr a) {
+	bool star_added = false;
+	if (a->getBoolMetadata("deref_is_star")) {
+		if (isa<int_const>(a->index)) {
+			auto index = to<int_const>(a->index);
+			if (index->value == 0) {
+				star_added = true;
+				oss << "*";
+			}
+		}
+	}
+
 	handle_child(a, a->var_expr, true);
-	oss << "[";
-	// index never needs to be bracketed no matter what
-	a->index->accept(this);
-	oss << "]";
+
+	if (!star_added) {
+		oss << "[";
+		// index never needs to be bracketed no matter what
+		a->index->accept(this);
+		oss << "]";
+	}
 }
 void c_code_generator::visit(function_call_expr::Ptr a) {
 	handle_child(a, a->expr1, true);
@@ -522,6 +635,11 @@ void c_code_generator::visit(func_decl::Ptr a) {
 #endif
 
 	printer::indent(oss, curr_indent);
+	if (a->is_static)
+		oss << "static ";
+	if (a->is_inline)
+		oss << "inline ";
+	
 	a->return_type->accept(this);
 	if (a->hasMetadata<std::vector<std::string>>("attributes")) {
 		const auto &attributes = a->getMetadata<std::vector<std::string>>("attributes");
@@ -538,10 +656,14 @@ void c_code_generator::visit(func_decl::Ptr a) {
 		printDelim = true;
 		oss << complex_type_helper(arg->var_type, " " + arg->var_name);
 	}
+	if (a->is_variadic) {
+		oss << ", ...";
+		printDelim = true;
+	}
 	if (!printDelim)
 		oss << "void";
 	oss << ")";
-	if (decl_only) {
+	if (decl_only || a->is_decl_only) {
 		oss << ";";
 		return;
 	}
@@ -579,7 +701,6 @@ void c_code_generator::visit(struct_decl::Ptr a) {
 	curr_indent--;
 	printer::indent(oss, curr_indent);
 	oss << "};";
-	nextl();
 }
 void c_code_generator::visit(goto_stmt::Ptr a) {
 	// a->dump(oss, 1);
@@ -617,4 +738,11 @@ void c_code_generator::visit(addr_of_expr::Ptr a) {
 	oss << "&";
 	handle_child(a, a->expr1, false);
 }
+void c_code_generator::visit(cast_expr::Ptr a) {
+	oss << "(";
+	a->type1->accept(this);
+	oss << ")";
+	handle_child(a, a->expr1, false);
+}
+
 } // namespace block
diff --git a/src/blocks/expr.cpp b/src/blocks/expr.cpp
index 6768a2f..af5c55f 100644
--- a/src/blocks/expr.cpp
+++ b/src/blocks/expr.cpp
@@ -206,5 +206,11 @@ void addr_of_expr::dump(std::ostream &oss, int indent) {
 	oss << "ADDR_OF_EXPR" << std::endl;
 	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
diff --git a/src/blocks/rce.cpp b/src/blocks/rce.cpp
index 23a3571..c046046 100644
--- a/src/blocks/rce.cpp
+++ b/src/blocks/rce.cpp
@@ -136,11 +136,11 @@ class phase1_visitor: public block_replacer {
 		if (value_map.size() > 0 && has_side_effects(ws->body))
 			value_map.clear();
 		ws->cond = rewrite(ws->cond);
-		ws->body = rewrite<stmt>(ws->body);
+		ws->body = rewrite(ws->body);
 	}
 	virtual void visit(for_stmt::Ptr fs) override {
 		node = fs;
-		fs->decl_stmt = rewrite<stmt>(fs->decl_stmt);
+		fs->decl_stmt = rewrite(fs->decl_stmt);
 		if (has_side_effects(fs->cond))
 			value_map.clear();
 		if (has_side_effects(fs->update))
@@ -151,7 +151,7 @@ class phase1_visitor: public block_replacer {
 			value_map.clear();
 		fs->cond = rewrite(fs->cond);
 		fs->update = rewrite(fs->update);
-		fs->body = rewrite<stmt>(fs->body);
+		fs->body = rewrite(fs->body);
 	}
 	virtual void visit(if_stmt::Ptr is) override {
 		node = is;
@@ -161,8 +161,8 @@ class phase1_visitor: public block_replacer {
 		// if statements don't have the problem with the body
 		// but there could be gotos 
 		// so we will handle labels separately
-		is->then_stmt = rewrite<stmt>(is->then_stmt);
-		is->else_stmt = rewrite<stmt>(is->else_stmt);
+		is->then_stmt = rewrite(is->then_stmt);
+		is->else_stmt = rewrite(is->else_stmt);
 	}
 
 
@@ -269,26 +269,26 @@ class phase2_visitor: public block_replacer {
 		// TODO: Just like Phase 1 maybe there is a way to optimize this
 		purge_side_effects(ws->body);
 		ws->cond = rewrite(ws->cond);
-		ws->body = rewrite<stmt>(ws->body);
+		ws->body = rewrite(ws->body);
 	}
 
 	virtual void visit(for_stmt::Ptr fs) override {
 		node = fs;
-		fs->decl_stmt = rewrite<stmt>(fs->decl_stmt);
+		fs->decl_stmt = rewrite(fs->decl_stmt);
 		purge_side_effects(fs->cond);
 		purge_side_effects(fs->update);
 		// Similar to while loop, purge side effects from body
 		purge_side_effects(fs->body);
 		fs->cond = rewrite(fs->cond);
 		fs->update = rewrite(fs->update);
-		fs->body = rewrite<stmt>(fs->body);
+		fs->body = rewrite(fs->body);
 	}
 	virtual void visit(if_stmt::Ptr is) override {
 		node = is;
 		purge_side_effects(is->cond);
 		is->cond = rewrite(is->cond);
-		is->then_stmt = rewrite<stmt>(is->then_stmt);
-		is->else_stmt = rewrite<stmt>(is->else_stmt);
+		is->then_stmt = rewrite(is->then_stmt);
+		is->else_stmt = rewrite(is->else_stmt);
 	}
 	
 	virtual void visit(var_expr::Ptr ve) override {
diff --git a/src/blocks/stmt.cpp b/src/blocks/stmt.cpp
index 9f72e47..1aa249e 100644
--- a/src/blocks/stmt.cpp
+++ b/src/blocks/stmt.cpp
@@ -35,6 +35,21 @@ void if_stmt::dump(std::ostream &oss, int indent) {
 	then_stmt->dump(oss, indent + 1);
 	else_stmt->dump(oss, indent + 1);
 }
+void case_stmt::dump(std::ostream &oss, int indent) {
+	printer::indent(oss, indent);
+	oss << "CASE_STMT (" << is_default << ")" << std::endl;
+	if (case_value)
+		case_value->dump(oss, indent + 1);
+	if (branch)
+		branch->dump(oss, indent + 1);
+}
+void switch_stmt::dump(std::ostream& oss, int indent) {
+	printer::indent(oss, indent);
+	oss << "SWITCH_STMT" << std::endl;
+	cond->dump(oss, indent + 1);
+	for (auto c: cases)
+		c->dump(oss, indent + 1);
+}
 void label_stmt::dump(std::ostream &oss, int indent) {
 	printer::indent(oss, indent);
 	oss << "LABEL_STMT" << std::endl;
diff --git a/src/blocks/var.cpp b/src/blocks/var.cpp
index 0b936da..3c2b8f5 100644
--- a/src/blocks/var.cpp
+++ b/src/blocks/var.cpp
@@ -41,6 +41,8 @@ void scalar_type::dump(std::ostream &oss, int indent) {
 		oss << "FLOAT";
 	else if (scalar_type_id == DOUBLE_TYPE)
 		oss << "DOUBLE";
+	else if (scalar_type_id == LONG_DOUBLE_TYPE)
+		oss << "LONG_DOUBLE";
 	else if (scalar_type_id == BOOL_TYPE)
 		oss << "BOOL";
 	oss << ")" << std::endl;
@@ -86,4 +88,9 @@ void named_type::dump(std::ostream &oss, int indent) {
 	for (unsigned int i = 0; i < template_args.size(); i++)
 		template_args[i]->dump(oss, indent + 1);
 }
+void anonymous_type::dump(std::ostream &oss, int indent) {
+	printer::indent(oss, indent);
+	oss << "ANONYMOUS_TYPE" << std::endl;
+	ref_type->dump(oss, indent + 1);
+}
 } // namespace block

From 4ee2d933d4c645e4a69da4dd2594023dbb3b1102 Mon Sep 17 00:00:00 2001
From: Ajay Brahmakshatriya <ajaybr@mit.edu>
Date: Wed, 10 Dec 2025 11:15:08 -0500
Subject: [PATCH 2/2] Added support for escaping string constants

---
 samples/sample45.cpp            |  2 +-
 src/blocks/c_code_generator.cpp | 36 ++++++++++++++++++++++++++++++++-
 2 files changed, 36 insertions(+), 2 deletions(-)

diff --git a/samples/sample45.cpp b/samples/sample45.cpp
index 4f29dcb..4a06414 100644
--- a/samples/sample45.cpp
+++ b/samples/sample45.cpp
@@ -11,7 +11,7 @@ static void foo(dyn_var<int> count, char to_print, std::set<char> &working_set,
 	for (dyn_var<int> i = 0; i < count; i++) {
 		myprintf("%c", to_print);
 	}
-	myprintf("\\n");
+	myprintf("\n");
 	if (to_print < 'z') {
 		if (done_set.find(to_print + 1) == done_set.end())
 			working_set.insert(to_print + 1);
diff --git a/src/blocks/c_code_generator.cpp b/src/blocks/c_code_generator.cpp
index 0bd858a..8f31d97 100644
--- a/src/blocks/c_code_generator.cpp
+++ b/src/blocks/c_code_generator.cpp
@@ -243,8 +243,42 @@ void c_code_generator::visit(float_const::Ptr a) {
 		oss << ".0";
 	oss << "f";
 }
+static std::string escapeString(const std::string& input) {
+    std::string output;
+
+    for (unsigned char c : input) {
+        switch (c) {
+            // Standard C Escape Sequences
+            case '\a': output += "\\a"; break; // Bell
+            case '\b': output += "\\b"; break; // Backspace
+            case '\f': output += "\\f"; break; // Form feed
+            case '\n': output += "\\n"; break; // Newline
+            case '\r': output += "\\r"; break; // Carriage return
+            case '\t': output += "\\t"; break; // Horizontal tab
+            case '\v': output += "\\v"; break; // Vertical tab
+            
+            // Critical Syntax Characters
+            case '\\': output += "\\\\"; break; // Backslash
+            case '"':  output += "\\\""; break; // Double quote
+            
+            default:
+                // If it is a printable character (like 'A', '1', '!', ' '), append it.
+                if (std::isprint(c)) {
+                    output += c;
+                } 
+                // Otherwise, escape it as a Hex value (e.g., ESC becomes \x1B).
+                else {
+                    char buf[5]; // Big enough for \xHH + null terminator
+                    std::snprintf(buf, sizeof(buf), "\\x%02X", c);
+                    output += buf;
+                }
+                break;
+        }
+    }
+    return output;
+}
 void c_code_generator::visit(string_const::Ptr a) {
-	oss << "\"" << a->value << "\"";
+	oss << "\"" << escapeString(a->value) << "\"";
 }
 void c_code_generator::visit(assign_expr::Ptr a) {
 	handle_child(a, a->var1, true);