add types to parser

+ No actual type checking is implemented as of yet, but with references
  and pointers I should be able to start playing around with checking
  move semantics and so on

+ Might at some point also look into type propagation for let,
  annoying to have to specify the same thing twice.

4 files changed, 124 insertions, 30 deletions

diff --git a/src/ast.c b/src/ast.c
index 102dff5..4baad56 100644
--- a/src/ast.c
+++ b/src/ast.c
@@ -174,6 +174,7 @@ void ast_dump(int depth, struct ast *n)
 #define DUMP(x) case x: dump(depth, #x); break;
 	switch (n->k) {
 	DUMP(AST_CLOSURE);
+	DUMP(AST_IF);
 	DUMP(AST_LET);
 	DUMP(AST_INIT);
 	DUMP(AST_CALL);
diff --git a/src/lexer.l b/src/lexer.l
index fe748e2..a150798 100644
--- a/src/lexer.l
+++ b/src/lexer.l
@@ -125,6 +125,11 @@ STRING		\"(\\.|[^"\\])*\"
 "<<"		{return LSHIFT;}
 ">>"		{return RSHIFT;}
 
+"if"		{return IF;}
+"else"		{return ELSE;}
+
+"mut"		{return MUT;}
+
 {STRING} {
 	/* seems risky, I know, but letting the parser choose when to allocate a
 	 * new string seems to help with syntax error cleanup */
diff --git a/src/lower.c b/src/lower.c
index 46ce2c3..cf36fb0 100644
--- a/src/lower.c
+++ b/src/lower.c
@@ -31,10 +31,14 @@ static void indent(struct state *state)
 		putchar(' ');
 }
 
+static int lower_var(struct ast *expr);
+
 static int lower_expr(struct state *state, struct ast *expr);
 static int lower_block(struct state *state, struct ast *block);
 static int lower_closure(struct state *state, struct ast *closure);
+static int lower_statement(struct state *state, struct ast *stmt);
 
+static int lower_type(struct type *type);
 static int lower_types(struct type *types);
 
 static int lower_binop(struct state *state, struct ast *binop)
@@ -105,14 +109,8 @@ static int lower_exprs(struct state *state, struct ast *exprs)
 	return 0;
 }
 
-static int lower_type(struct type *type)
+static int lower_type_construct(struct type *type)
 {
-	if (type->k == TYPE_ID) {
-		printf("%s", tid_str(type));
-		return 0;
-	}
-
-	assert(type->k == TYPE_CONSTRUCT);
 	printf("%s", tconstruct_id(type));
 	printf("<");
 
@@ -123,6 +121,51 @@ static int lower_type(struct type *type)
 	return 0;
 }
 
+static int lower_type_callable(struct type *type)
+{
+	printf("std::function<void(");
+
+	if (lower_types(tcallable_args(type)))
+		return -1;
+
+	printf(")>");
+	return 0;
+}
+
+static int lower_type_ref(struct type *type)
+{
+	if (lower_type(tref_base(type)))
+		return -1;
+
+	printf("&");
+	return 0;
+}
+
+static int lower_type_ptr(struct type *type)
+{
+	if (lower_type(tptr_base(type)))
+		return -1;
+
+	printf("*");
+	return 0;
+}
+
+static int lower_type(struct type *type)
+{
+	switch (type->k) {
+	case TYPE_ID: printf("%s", tid_str(type)); return 0;
+	case TYPE_CONSTRUCT: return lower_type_construct(type);
+	case TYPE_CALLABLE: return lower_type_callable(type);
+	case TYPE_REF: return lower_type_ref(type);
+	case TYPE_PTR: return lower_type_ptr(type);
+	default:
+		internal_error("missing type lowering");
+		return -1;
+	}
+
+	return 0;
+}
+
 static int lower_types(struct type *types)
 {
 	if (!types)
@@ -250,7 +293,11 @@ static int lower_call(struct state *state, struct ast *call)
 
 static int lower_let(struct state *state, struct ast *let)
 {
-	printf("auto %s = ", let_id(let));
+	if (lower_var(let_var(let)))
+		return -1;
+
+	printf(" = ");
+
 	if (lower_expr(state, let_expr(let)))
 		return -1;
 
@@ -258,11 +305,34 @@ static int lower_let(struct state *state, struct ast *let)
 	return 0;
 }
 
+static int lower_if(struct state *state, struct ast *stmt)
+{
+	printf("if (");
+	if (lower_expr(state, if_cond(stmt)))
+		return -1;
+
+	printf(") ");
+
+	if (lower_block(state, if_body(stmt)))
+		return -1;
+
+	if (!if_else(stmt))
+		return 0;
+
+	printf(" else ");
+	if (lower_block(state, if_else(stmt)))
+		return -1;
+
+	printf("\n");
+	return 0;
+}
+
 static int lower_statement(struct state *state, struct ast *stmt)
 {
 	switch (stmt->k) {
-	case AST_LET: return lower_let(state, stmt);
-	case AST_CALL: return lower_call(state, stmt);
+	case AST_LET:	return lower_let(state, stmt);
+	case AST_CALL:	return lower_call(state, stmt);
+	case AST_IF:	return lower_if(state, stmt);
 	default:
 		internal_error("missing statement lowering");
 		return -1;
@@ -290,15 +360,27 @@ static int lower_block(struct state *state, struct ast *block)
 	return 0;
 }
 
-static int lower_params(struct ast *params)
+static int lower_var(struct ast *var)
+{
+	if (lower_type(var_type(var)))
+		return -1;
+
+	printf(" %s", var_id(var));
+	return 0;
+}
+
+static int lower_vars(struct ast *vars)
 {
-	if (!params)
+	if (!vars)
 		return 0;
 
-	printf("auto %s", var_id(params));
+	if (lower_var(vars))
+		return -1;
 
-	foreach_node(param, params->n) {
-		printf(", auto %s", var_id(param));
+	foreach_node(var, vars->n) {
+		printf(", ");
+		if (lower_var(var))
+			return -1;
 	}
 
 	return 0;
@@ -307,7 +389,7 @@ static int lower_params(struct ast *params)
 static int lower_closure(struct state *state, struct ast *closure)
 {
 	printf("[&](");
-	if (lower_params(closure_bindings(closure)))
+	if (lower_vars(closure_bindings(closure)))
 		return -1;
 
 	printf(")");
@@ -327,7 +409,7 @@ static int lower_proto(struct ast *proc)
 
 	printf("%s(", proc_id(proc));
 
-	if (lower_params(proc_params(proc)))
+	if (lower_vars(proc_params(proc)))
 		return -1;
 
 	printf(");\n\n");
@@ -343,7 +425,7 @@ static int lower_proc(struct ast *proc)
 
 	printf("%s(", proc_id(proc));
 
-	if (lower_params(proc_params(proc)))
+	if (lower_vars(proc_params(proc)))
 		return -1;
 
 	printf(")\n");
diff --git a/src/parser.y b/src/parser.y
index ccff211..97a700e 100644
--- a/src/parser.y
+++ b/src/parser.y
@@ -69,7 +69,9 @@
 %token RBRACE "}"
 %token LBRACKET "["
 %token RBRACKET "]"
-%token AS "as"
+%token IF "if"
+%token ELSE "else"
+%token MUT "mut"
 %token DOT "."
 %token SCOPE "::"
 %token FATARROW "=>"
@@ -94,11 +96,12 @@
 %nterm <node> vars exprs statements closures
 %nterm <node> opt_vars opt_exprs opt_statements
 %nterm <node> rev_vars rev_exprs rev_closures rev_statements
-%nterm <node> let unop binop construct
+%nterm <node> let if unop binop construct
 
 %nterm <type> type rev_types types opt_types
 
 
+
 %{
 
 /** Modifies the signature of yylex to fit our parser better. */
@@ -176,7 +179,7 @@ static char *strip(const char *s);
 %start input;
 %%
 var
-	: ID { $$ = gen_var($1, src_loc(@$)); }
+	: type ID { $$ = gen_var($2, $1, src_loc(@$)); }
 
 rev_vars
 	: rev_vars "," var { $$ = $3; $$->n = $1; }
@@ -219,6 +222,9 @@ type
 	| APPLY "[" opt_types "]" {
 		$$ = tgen_construct($[APPLY], $[opt_types], src_loc(@$));
 	}
+	| "(" opt_types ")" { $$ = tgen_callable($2, src_loc(@$)); }
+	| "&" type { $$ = tgen_ref($2, src_loc(@$)); }
+	| "*" type { $$ = tgen_ptr($2, src_loc(@$)); }
 
 rev_types
 	: rev_types "," type { $$ = $3; $3->n = $$; }
@@ -290,11 +296,17 @@ call
 	}
 
 let
-	: expr "=>" ID ";" { $$ = gen_let($3, $1, src_loc(@$)); }
+	: expr "=>" var ";" { $$ = gen_let($3, $1, src_loc(@$)); }
+
+if
+	: "if" expr body { $$ = gen_if($2, $3, NULL, src_loc(@$)); }
+	| "if" expr body "else" body { $$ = gen_if($2, $3, $5, src_loc(@$)); }
+	| "if" expr body "else" if { $$ = gen_if($2, $3, $5, src_loc(@$)); }
 
 statement
 	: call
 	| let
+	| if
 	| ";" { $$ = gen_empty(src_loc(@$)); }
 
 rev_statements
@@ -419,14 +431,8 @@ static char *strip(const char *str)
 
 	/* skip quotation marks */
 	size_t j = 0;
-	for (size_t i = 1; i < len - 2; ++i) {
-		char c = str[i];
-
-		if (c == '\\')
-			c = match_escape(str[++i]);
-
-		buf[j++] = c;
-	}
+	for (size_t i = 1; i < len - 2; ++i)
+		buf[j++] = str[i];
 
 	buf[j] = 0;
 	free((void *)str);