formatting

4 files changed, 86 insertions, 79 deletions

diff --git a/include/ek/ast.h b/include/ek/ast.h
index 9c96832..de195c6 100644
--- a/include/ek/ast.h
+++ b/include/ek/ast.h
@@ -244,33 +244,33 @@ struct ast {
 };
 
 struct ast *gen_ast(enum ast_kind kind,
-		struct ast *a0,
-		struct ast *a1,
-		struct ast *a2,
-		struct ast *a3,
-		struct type *t1,
-		char *s,
-		long long v,
-		struct src_loc loc);
+                    struct ast *a0,
+                    struct ast *a1,
+                    struct ast *a2,
+                    struct ast *a3,
+                    struct type *t1,
+                    char *s,
+                    long long v,
+                    struct src_loc loc);
 
 struct type *tgen_type(enum type_kind kind,
-		struct type *t0,
-		struct type *t1,
-		struct ast *d,
-		struct ast *a,
-		char *id,
-		struct src_loc loc);
+                       struct type *t0,
+                       struct type *t1,
+                       struct ast *d,
+                       struct ast *a,
+                       char *id,
+                       struct src_loc loc);
 
-#define tgen_primitive(kind, id, def, loc)\
+#define tgen_primitive(kind, id, def, loc) \
 	tgen_type(kind, NULL, NULL, def, NULL, id, loc)
 
-#define tgen_id(id, loc)\
+#define tgen_id(id, loc) \
 	tgen_type(TYPE_ID, NULL, NULL, NULL, NULL, id, loc)
 
-#define tgen_struct(id, def, loc)\
+#define tgen_struct(id, def, loc) \
 	tgen_type(TYPE_STRUCT, NULL, NULL, def, NULL, id, loc)
 
-#define tgen_trait(id, def, loc)\
+#define tgen_trait(id, def, loc) \
 	tgen_type(TYPE_TRAIT, NULL, NULL, def, NULL, id, loc)
 
 static inline bool is_binop(struct ast *x)
@@ -364,9 +364,11 @@ static inline bool is_primitive(struct type *t)
 	return false;
 }
 
-#define gen_str_type1(k, s, t, a, loc) gen_ast(k, a, NULL, NULL, NULL, t, s, 0, loc)
+#define gen_str_type1(k, s, t, a, loc) gen_ast(k, a, NULL, NULL, NULL, t, s, 0, \
+					       loc)
 #define gen_str_type(k, s, t, loc) gen_str_type1(k, s, t, NULL, loc)
-#define gen_type(k, a, type, loc) gen_ast(k, a, NULL, NULL, NULL, type, NULL, 0, loc)
+#define gen_type(k, a, type, loc) gen_ast(k, a, NULL, NULL, NULL, type, NULL, 0, \
+					  loc)
 #define gen_str2(k, s, a, b, loc) gen_ast(k, a, b, NULL, NULL, NULL, s, 0, loc)
 #define gen_str1(k, s, a, loc) gen_str2(k, s, a, NULL, loc)
 #define gen_str(k, s, loc) gen_ast(k, NULL, NULL, NULL, NULL, NULL, s, 0, loc)
@@ -384,7 +386,7 @@ static inline bool is_primitive(struct type *t)
 
 /* kind of hacky but I guess it works, and allows us to check that the type is
  * correct every time */
-#define return_s(x, kind)  *({assert((x)->k == kind); &(x)->s;})
+#define return_s(x, kind) *({assert((x)->k == kind); &(x)->s;})
 #define return_a0(x, kind) *({assert((x)->k == kind); &(x)->a0;})
 #define return_a1(x, kind) *({assert((x)->k == kind); &(x)->a1;})
 #define return_a2(x, kind) *({assert((x)->k == kind); &(x)->a2;})
@@ -398,233 +400,233 @@ static inline bool is_primitive(struct type *t)
 #define if_cond(x) return_a0(x, AST_IF)
 #define if_body(x) return_a1(x, AST_IF)
 #define if_else(x) return_a2(x, AST_IF)
-#define gen_if(cond, body, else, loc)\
-	gen3(AST_IF, cond, body, else, loc)
+#define gen_if(cond, body, els, loc) \
+	gen3(AST_IF, cond, body, els, loc)
 
 #define fetch_id(x) return_s(x, AST_FETCH)
 #define fetch_type(x) return_t2(x, AST_FETCH)
-#define gen_fetch(id, type, loc)\
+#define gen_fetch(id, type, loc) \
 	gen_str_type(AST_FETCH, id, type, loc)
 
 #define label_id(x) return_s(x, AST_LABEL)
 #define label_defers(x) return_a0(x, AST_LABEL)
-#define gen_label(id, defers, loc)\
+#define gen_label(id, defers, loc) \
 	gen_str1(AST_LABEL, id, defers, loc)
 
 #define arr_base(x) return_a0(x, AST_ARR)
 #define arr_idx(x) return_a1(x, AST_ARR)
-#define gen_arr(base, idx, loc)\
+#define gen_arr(base, idx, loc) \
 	gen2(AST_ARR, base, idx, loc)
 
 #define goto_label(x) return_s(x, AST_GOTO)
 #define goto_defers(x) return_a0(x, AST_GOTO)
-#define gen_goto(label, defers, loc)\
+#define gen_goto(label, defers, loc) \
 	gen_str1(AST_GOTO, label, defers, loc)
 
 #define alias_id(x) return_s(x, AST_ALIAS_DEF)
 #define alias_type(x) return_t2(x, AST_ALIAS_DEF)
-#define gen_alias(id, type, loc)\
+#define gen_alias(id, type, loc) \
 	gen_str_type(AST_ALIAS_DEF, id, type, loc)
 
 #define trait_id(x) return_s(x, AST_TRAIT_DEF)
 #define trait_params(x) return_a0(x, AST_TRAIT_DEF)
 #define trait_raw_body(x) return_a1(x, AST_TRAIT_DEF)
 #define trait_body(x) return_a2(x, AST_TRAIT_DEF)
-#define gen_trait(id, params, body, loc)\
+#define gen_trait(id, params, body, loc) \
 	gen_str2(AST_TRAIT_DEF, id, params, body, loc)
 
 #define cast_expr(x) return_a0(x, AST_CAST)
 #define cast_type(x) return_t2(x, AST_CAST)
-#define gen_cast(expr, type, loc)\
+#define gen_cast(expr, type, loc) \
 	gen_type(AST_CAST, expr, type, loc)
 
 #define opassign_left(x) ({assert(is_opassign(x)); x->a0;})
 #define opassign_right(x) ({assert(is_opassign(x)); x->a1;})
-#define gen_opassign(op, left, right, loc)\
+#define gen_opassign(op, left, right, loc) \
 	gen2(op, left, right, loc)
 
 #define binop_left(x) ({assert(is_binop(x)); x->a0;})
 #define binop_right(x) ({assert(is_binop(x)); x->a1;})
-#define gen_binop(op, left, right, loc)\
+#define gen_binop(op, left, right, loc) \
 	gen2(op, left, right, loc)
 
 #define comparison_left(x) ({assert(is_comparison(x)); x->a0;})
 #define comparison_right(x) ({assert(is_comparison(x)); x->a1;})
-#define gen_comparison(op, left, right, loc)\
+#define gen_comparison(op, left, right, loc) \
 	gen2(op, left, right, loc)
 
 #define unop_expr(x) ({assert(is_unop(x)); x->a0;})
-#define gen_unop(op, expr, loc)\
+#define gen_unop(op, expr, loc) \
 	gen1(op, expr, loc)
 
 #define call_expr(x) return_a0(x, AST_CALL)
 #define call_args(x) return_a1(x, AST_CALL)
-#define gen_call(expr, args, loc)\
+#define gen_call(expr, args, loc) \
 	gen2(AST_CALL, expr, args, loc)
 
 #define defer_expr(x) return_a0(x, AST_DEFER)
-#define gen_defer(expr, loc)\
+#define gen_defer(expr, loc) \
 	gen1(AST_DEFER, expr, loc)
 
 #define macro_def_id(x) return_s(x, AST_MACRO_DEF)
 #define macro_def_params(x) return_a0(x, AST_MACRO_DEF)
 #define macro_def_body(x) return_a1(x, AST_MACRO_DEF)
-#define gen_macro_def(id, params, body, loc)\
+#define gen_macro_def(id, params, body, loc) \
 	gen_str2(AST_MACRO_DEF, id, params, body, loc)
 
 #define macro_expand_id(x) return_s(x, AST_MACRO_EXPAND)
 #define macro_expand_args(x) return_a0(x, AST_MACRO_EXPAND)
-#define gen_macro_expand(id, args, loc)\
+#define gen_macro_expand(id, args, loc) \
 	gen_str1(AST_MACRO_EXPAND, id, args, loc)
 
 #define type_expand_id(x) return_s(x, AST_TYPE_EXPAND)
 #define type_expand_args(x) return_t2(x, AST_TYPE_EXPAND)
-#define gen_type_expand(id, args, loc)\
+#define gen_type_expand(id, args, loc) \
 	gen_str_type(AST_TYPE_EXPAND, id, args, loc)
 
 #define proc_id(x) return_s(x, AST_PROC_DEF)
 #define proc_params(x) return_a0(x, AST_PROC_DEF)
 #define proc_rtype(x) return_t2(x, AST_PROC_DEF)
 #define proc_body(x) return_a1(x, AST_PROC_DEF)
-#define gen_proc(id, params, rtype, body, loc)\
+#define gen_proc(id, params, rtype, body, loc) \
 	gen_ast(AST_PROC_DEF, params, body, NULL, NULL, rtype, id, 0, loc)
 
 #define dot_id(x) return_s(x, AST_DOT)
 #define dot_expr(x) return_a0(x, AST_DOT)
-#define gen_dot(id, expr, loc)\
+#define gen_dot(id, expr, loc) \
 	gen_str1(AST_DOT, id, expr, loc)
 
 #define as_type(x) return_t2(x, AST_AS)
-#define gen_as(type, loc)\
+#define gen_as(type, loc) \
 	gen_type(NULL, type, loc)
 
 #define sizeof_expr(x) return_a0(x, AST_SIZEOF)
-#define gen_sizeof(expr, loc)\
+#define gen_sizeof(expr, loc) \
 	gen1(AST_SIZEOF, expr, loc)
 
 #define var_id(x) return_s(x, AST_VAR_DEF)
 #define var_type(x) return_t2(x, AST_VAR_DEF)
 #define var_init(x) return_a0(x, AST_VAR_DEF)
-#define gen_var(id, type, init, loc)\
+#define gen_var(id, type, init, loc) \
 	gen_ast(AST_VAR_DEF, init, NULL, NULL, NULL, type, id, 1, loc)
 
 #define for_pre(x) return_a0(x, AST_FOR)
 #define for_cond(x) return_a1(x, AST_FOR)
 #define for_post(x) return_a2(x, AST_FOR)
 #define for_body(x) return_a3(x, AST_FOR)
-#define gen_for(pre, cond, post, body, loc)\
+#define gen_for(pre, cond, post, body, loc) \
 	gen4(AST_FOR, pre, cond, post, body, loc)
 
 #define while_cond(x) return_a0(x, AST_WHILE)
 #define while_body(x) return_a1(x, AST_WHILE)
-#define gen_while(cond, body, loc)\
+#define gen_while(cond, body, loc) \
 	gen2(AST_WHILE, cond, body, loc)
 
 #define do_while_cond(x) return_a0(x, AST_DO_WHILE)
 #define do_while_body(x) return_a1(x, AST_DO_WHILE)
-#define gen_do_while(cond, body, loc)\
+#define gen_do_while(cond, body, loc) \
 	gen2(AST_DO_WHILE, cond, body, loc)
 
 #define continue_defers(x) return_a0(x, AST_CONTINUE)
-#define gen_continue(defers, loc)\
+#define gen_continue(defers, loc) \
 	gen1(AST_CONTINUE, defers, loc)
 
 #define break_defers(x) return_a0(x, AST_BREAK)
-#define gen_break(defers, loc)\
+#define gen_break(defers, loc) \
 	gen1(AST_BREAK, defers, loc)
 
 #define return_expr(x) return_a0(x, AST_RETURN)
 #define return_defers(x) return_a1(x, AST_RETURN)
-#define gen_return(expr, defers, loc)\
+#define gen_return(expr, defers, loc) \
 	gen2(AST_RETURN, expr, defers, loc)
 
 #define block_body(x) return_a0(x, AST_BLOCK)
 #define block_defers(x) return_a1(x, AST_BLOCK)
-#define gen_block(body, defers, loc)\
+#define gen_block(body, defers, loc) \
 	gen2(AST_BLOCK, body, defers, loc)
 
 #define import_file(x) return_s(x, AST_IMPORT)
-#define gen_import(f, loc)\
+#define gen_import(f, loc) \
 	gen_str(AST_IMPORT, f, loc)
 
 #define embed_file(x) return_s(x, AST_EMBED)
-#define gen_embed(f, loc)\
+#define gen_embed(f, loc) \
 	gen_str(AST_EMBED, f, loc)
 
 #define enum_id(x) return_s(x, AST_ENUM_DEF)
 #define enum_type(x) return_t2(x, AST_ENUM_DEF)
 #define enum_body(x) return_a0(x, AST_ENUM_DEF)
-#define gen_enum(id, type, body, loc)\
+#define gen_enum(id, type, body, loc) \
 	gen_ast(AST_ENUM_DEF, body, NULL, NULL, NULL, type, id, 0, loc)
 
 #define struct_id(x) return_s(x, AST_STRUCT_DEF)
 #define struct_params(x) return_a0(x, AST_STRUCT_DEF)
 #define struct_body(x) return_a1(x, AST_STRUCT_DEF)
-#define gen_struct(id, params, body, loc)\
+#define gen_struct(id, params, body, loc) \
 	gen_str2(AST_STRUCT_DEF, id, params, body, loc)
 
 #define val_id(x) return_s(x, AST_VAL)
 #define val_val(x) return_a0(x, AST_VAL)
-#define gen_val(id, val, loc)\
+#define gen_val(id, val, loc) \
 	gen_str1(AST_VAL, id, val, loc)
 
 #define switch_cond(x) return_a0(x, AST_SWITCH)
 #define switch_cases(x) return_a1(x, AST_SWITCH)
-#define gen_switch(cond, cases, loc)\
+#define gen_switch(cond, cases, loc) \
 	gen2(AST_SWITCH, cond, cases, loc)
 
 #define case_cond(x) return_a0(x, AST_CASE)
 #define case_body(x) return_a1(x, AST_CASE)
-#define gen_case(cond, body, loc)\
+#define gen_case(cond, body, loc) \
 	gen2(AST_CASE, cond, body, loc)
 
 #define str_val(x) return_s(x, AST_CONST_STR)
-#define gen_const_str(s, loc)\
+#define gen_const_str(s, loc) \
 	gen_ast(AST_CONST_STR, NULL, NULL, NULL, NULL, NULL, s, 0, loc)
 
 #define int_val(x) *({assert(x->k == AST_CONST_INT); &x->v;})
-#define gen_const_int(i, loc)\
+#define gen_const_int(i, loc) \
 	gen_ast(AST_CONST_INT, NULL, NULL, NULL, NULL, NULL, NULL, i, loc)
 
 #define char_val(x) *({assert(x->k == AST_CONST_CHAR); &x->v;})
-#define gen_const_char(i, loc)\
+#define gen_const_char(i, loc) \
 	gen_ast(AST_CONST_CHAR, NULL, NULL, NULL, NULL, NULL, NULL, i, loc)
 
 #define bool_val(x) *({assert(x->k == AST_CONST_CHAR); &x->v;})
-#define gen_const_bool(i, loc)\
+#define gen_const_bool(i, loc) \
 	gen_ast(AST_CONST_BOOL, NULL, NULL, NULL, NULL, NULL, NULL, i, loc)
 
 #define init_args(x) return_t1(x, AST_INIT)
 #define init_body(x) return_a0(x, AST_INIT)
-#define init_id(x)   return_s(x, AST_INIT)
-#define gen_init(id, targs, body, loc)\
+#define init_id(x) return_s(x, AST_INIT)
+#define gen_init(id, targs, body, loc) \
 	gen_str_type1(AST_INIT, id, targs, body, loc)
 
 #define assign_to(x) return_a0(x, AST_ASSIGN)
 #define assign_from(x) return_a1(x, AST_ASSIGN)
-#define gen_assign(from, to, loc)\
+#define gen_assign(from, to, loc) \
 	gen2(AST_ASSIGN, from, to, loc)
 
 #define id_str(x) return_s(x, AST_ID)
-#define gen_id(id, loc)\
+#define gen_id(id, loc) \
 	gen_str(AST_ID, id, loc)
 
-#define gen_empty(loc)\
+#define gen_empty(loc) \
 	gen1(AST_EMPTY, NULL, loc)
 
 /* types */
 #define callable_ptypes(x) return_t0(x, TYPE_CALLABLE)
 #define callable_rtype(x) return_t1(x, TYPE_CALLABLE)
-#define tgen_callable(ptypes, rtype, loc)\
+#define tgen_callable(ptypes, rtype, loc) \
 	tgen2(TYPE_CALLABLE, ptypes, rtype, loc)
 
 #define ptr_base(x) return_t0(x, TYPE_PTR)
-#define tgen_ptr(base, loc)\
+#define tgen_ptr(base, loc) \
 	tgen1(TYPE_PTR, base, loc)
 
 #define construct_id(x) return_t0(x, TYPE_CONSTRUCT)
 #define construct_atypes(x) return_t1(x, TYPE_CONSTRUCT)
-#define tgen_construct(id, atypes, loc)\
+#define tgen_construct(id, atypes, loc) \
 	tgen_str1(TYPE_CONSTRUCT, id, atypes, loc)
 
 struct ast *clone_ast(struct ast *n);
@@ -642,8 +644,8 @@ void type_dump(struct type *node);
 void ast_append(struct ast *list, struct ast *elem);
 void type_append(struct type *list, struct type *elem);
 
-struct ast * ast_prepend(struct ast *list, struct ast *elem);
-struct type * type_prepend(struct type *list, struct type *elem);
+struct ast *ast_prepend(struct ast *list, struct ast *elem);
+struct type *type_prepend(struct type *list, struct type *elem);
 
 void ast_set_flags(struct ast *node, enum ast_flags flags);
 void ast_clear_flags(struct ast *node, enum ast_flags flags);
@@ -651,11 +653,15 @@ unsigned ast_flags(struct ast *node, enum ast_flags flags);
 
 typedef int (*ast_callback_t)(struct ast *, void *);
 typedef int (*type_callback_t)(struct type *, void *);
-int ast_visit(ast_callback_t before, ast_callback_t after, struct ast *node, void *data);
-int ast_visit_list(ast_callback_t before, ast_callback_t after, struct ast *node, void *data);
+int ast_visit(ast_callback_t before, ast_callback_t after, struct ast *node,
+              void *data);
+int ast_visit_list(ast_callback_t before, ast_callback_t after,
+                   struct ast *node, void *data);
 
-int type_visit(type_callback_t before, type_callback_t after, struct type *node, void *data);
-int type_visit_list(type_callback_t before, type_callback_t after, struct type *node, void *data);
+int type_visit(type_callback_t before, type_callback_t after, struct type *node,
+               void *data);
+int type_visit_list(type_callback_t before, type_callback_t after,
+                    struct type *node, void *data);
 
 /**
  * Number of elements in AST list.
diff --git a/include/ek/debug.h b/include/ek/debug.h
index 79cc1d1..19ed044 100644
--- a/include/ek/debug.h
+++ b/include/ek/debug.h
@@ -103,7 +103,8 @@ void semantic_warn(struct file_ctx ctx, struct ast *node, const char *fmt,
  * @param node AST node to print message with.
  * @param fmt Format string. Follows standard printf() formatting.
  */
-void semantic_error(struct file_ctx ctx, struct ast *node, const char *fmt, ...);
+void semantic_error(struct file_ctx ctx, struct ast *node, const char *fmt,
+                    ...);
 void type_error(struct file_ctx ctx, struct type *type, const char *fmt, ...);
 
 /**
diff --git a/include/ek/scope.h b/include/ek/scope.h
index 5c9f9eb..b747288 100644
--- a/include/ek/scope.h
+++ b/include/ek/scope.h
@@ -382,7 +382,7 @@ struct ast *file_scope_find_alias(struct scope *scope, char *id);
  */
 struct ast *file_scope_find_trait(struct scope *scope, char *id);
 
-#define foreach_visible(iter, init)\
+#define foreach_visible(iter, init) \
 	for (struct visible *iter = init; iter; iter = iter->next)
 
 #endif /* SCOPE_H */
diff --git a/include/ek/vec.h b/include/ek/vec.h
index 05155c8..981f511 100644
--- a/include/ek/vec.h
+++ b/include/ek/vec.h
@@ -29,7 +29,7 @@ void vec_sort(struct vec *v, vec_comp_t comp);
 #define vect_at(type, v, i) \
 	*(type *)vec_at(&v, i)
 
-#define vect_append(type, v, e)\
+#define vect_append(type, v, e) \
 	vec_append(&v, (type *)(e))
 
 #define vect_back(type, v) \