Radicalc  Diff

int ch;
char* buf;
int buf_len;

struct token* tokens;
int token_len;

int
int isidentch(int c) {
isidentch(int c) {
	return isalnum(c) || c == '_';
}

void
void next_ch() {
next_ch() {
	ch = getchar();
}

void
void accept_ch() {
accept_ch() {
	buf = realloc(buf, ++buf_len);
	buf[buf_len-1] = (char)ch;	
}

void
void skip_ws() {
skip_ws() {
	while(ch == ' ' || ch == '\t') {
		next_ch();
	}
}

void
void finalise_buf() {
finalise_buf() {
	buf = realloc(buf, ++buf_len);
	buf[buf_len-1] = 0;
}

void
void reset_buf() { /* warning, memory leaking by design */
reset_buf() { /* warning, memory leaking by design */
	buf = 0;
	buf_len = 0;
}

void
void add_token(enum token_type type, char* str) {
add_token(enum token_type type, char* str) {
	tokens = realloc(tokens, sizeof(struct token) * (++token_len));
	tokens[token_len - 1].type = type;
	tokens[token_len - 1].str = str;
}

void
void tokenise() {
tokenise() {
	enum token_type mode = TOK_NONE;
	reset_buf();
	tokens = 0;
	token_len = 0;
	next_ch();
	do {
		switch(mode) {

	enum node_type type;
	char* val;
	char* data_type_str;
	struct data_type* data_type;
	struct function* fun;
};

struct node*
struct node* node_new(enum node_type type) {
node_new(enum node_type type) {
	struct node* node = malloc(sizeof(struct node));
	node->childs = 0;
	node->child_count = 0;
	node->name = 0;
	node->type = type;
	node->val = 0;
	node->data_type_str = 0;
	node->data_type = 0;
	node->fun = 0;
	return node;
}

void
void node_add_child(struct node* parent, struct node* child) {
node_add_child(struct node* parent, struct node* child) {
	int new_size = sizeof(struct node*) * (++parent->child_count);
	parent->childs = realloc(parent->childs, new_size);
	parent->childs[parent->child_count-1] = child;
}

struct function_parameter {
	char* data_type_str;
	struct data_type* data_type;
	char* name;
};

struct function {
	char* name;
	char* return_type_str;
	struct data_type* return_type;
	struct function_parameter* params;
	int param_count;
	struct node* body;
};

struct function* function_new() {
struct function*
function_new() {
	struct function* fun = malloc(sizeof(struct function));
	fun->name = 0;
	fun->return_type_str = 0;
	fun->return_type = 0;
	fun->params = 0;
	fun->param_count = 0;
	fun->body = node_new(NODE_FUNBODY);
}

void
void function_add_param(struct function* fun, char* name, char* type) {
function_add_param(struct function* fun, char* name, char* type) {
	int new_size = sizeof(struct function_parameter) * (++fun->param_count);
	fun->params = realloc(fun->params, new_size);
	fun->params[fun->param_count-1].name = name;
	fun->params[fun->param_count-1].data_type_str = type;
}

struct token*
struct token* expect(enum token_type type) {
expect(enum token_type type) {
	if(type == tokens[parse_pos].type) {
		++parse_pos;
		return &tokens[parse_pos-1];
	}
	else {
		printf("expected (%d), got (%d), at (%d)\n",
		       type, tokens[parse_pos].type, parse_pos);
		exit(-1);
	}
}

int
int is_next_tok(enum token_type type) {
is_next_tok(enum token_type type) {
	return tokens[parse_pos].type == type;
}

struct node* p_expr();
struct node*
p_expr();

struct node* p_func_call() {
struct node*
p_func_call() {
	struct node* node = node_new(NODE_FUNCALL);
	node->name = expect(TOK_IDENT)->str;
	expect(TOK_PAREN_OPEN);
	if(tokens[parse_pos].type != TOK_PAREN_CLOSE) {
		node_add_child(node, p_expr());
		while(tokens[parse_pos].type == TOK_COMMA) {
			expect(TOK_COMMA);
			node_add_child(node, p_expr());
		}
	}
	expect(TOK_PAREN_CLOSE);
	return node;
}

struct node* p_var_use() {
struct node*
p_var_use() {
	struct node* node = node_new(NODE_VAR_USE);
	node->name = expect(TOK_IDENT)->str;
	return node;
}

struct node* p_expr() {
struct node*
p_expr() {
	switch(tokens[parse_pos].type) {
		case TOK_IDENT:
			if(tokens[parse_pos+1].type == TOK_PAREN_OPEN)
				return p_func_call();
			else
				return p_var_use();
		case TOK_LITERAL_INT:
		{
			struct node* node = node_new(NODE_LITERAL_INT);
			node->val = expect(TOK_LITERAL_INT)->str;
			return node;
		}
		default:
			printf("can't parse expression, (%d)\n", tokens[parse_pos].type);
			exit(-1);
	}
}

struct node* p_statement() {
struct node*
p_statement() {
	struct node* node;
	switch(tokens[parse_pos].type) {
		default:
			node = p_expr();
			expect(TOK_NEWLINE);
	}
	return node;
}

struct function* p_fun() {
struct function*
p_fun() {
	struct function* fun = function_new();
	expect(TOK_FUN);
	fun->name = expect(TOK_IDENT)->str;
	expect(TOK_PAREN_OPEN);
	if(tokens[parse_pos].type != TOK_PAREN_CLOSE) {
		for(;;) {
			char* name;

	expect(TOK_NEWLINE);
	return fun;
}

struct function** functions;
int function_count;

void
void add_function(struct function* function) {
add_function(struct function* function) {
	functions = realloc(functions, sizeof(struct function*)*(++function_count));
	functions[function_count-1] = function;
}


void
void parse() {
parse() {
	functions = 0;
	function_count = 0;
	parse_pos = 0;
	while(tokens[parse_pos].type != TOK_EOF) {
		switch(tokens[parse_pos].type) {
			case TOK_NEWLINE:
				break;

/*   ANNOTATE                                                                 */
/*                                                                            */
/******************************************************************************/

struct data_type* data_types;
int data_type_count;

void
void add_data_type(char* name) {
add_data_type(char* name) {
	int new_size = sizeof(struct data_type) * (++data_type_count);
	data_types = realloc(data_types, new_size);
	data_types[data_type_count-1].name = name;
}

void
void init_data_types() { /* internal data types */
init_data_types() { /* internal data types */
	data_types = 0;
	data_type_count = 0;
	add_data_type("void");
	add_data_type("i8");
	add_data_type("i16");
	add_data_type("i32");
	add_data_type("i64");
	add_data_type("u8");
	add_data_type("u16");
	add_data_type("u32");
	add_data_type("u64");
	add_data_type("f32");
	add_data_type("f64");
}

struct data_type* get_data_type(char* name) {
struct data_type*
get_data_type(char* name) {
	for(int i = 0; i < data_type_count; ++i) {
		if(strcmp(name, data_types[i].name) == 0)
			return &data_types[i];
	}
	return 0;
}

struct function*
struct function* get_function(char* name, struct data_type** params, int param_count) {
get_function(char* name, struct data_type** params, int param_count) {
	for(int i = 0; i < function_count; ++i) {
		struct function* fun = functions[i];
		if(strcmp(fun->name, name) == 0 && fun->param_count == param_count) {
			for(int j = 0; j < param_count; ++j) {
				if(fun->params[j].data_type != params[j])
					goto tryagain;
			}
			return fun;
		}
		tryagain: ;
	}
	return 0;
}


void
void annotate_data_type(struct data_type** data_type, char* name) {
annotate_data_type(struct data_type** data_type, char* name) {
	if(name == 0) { /* nullpointer == void */
		*data_type = &data_types[0];
		return;
	}

	for(int i = 0; i < data_type_count; ++i) {
		if(strcmp(data_types[i].name, name) == 0) {
			*data_type = &data_types[i];
			return;
		}
	}
	
	printf("unknown datatype '%s'\n", name);
	exit(-1);
}

void
void annotate_function_data_types(struct function* fun) {
annotate_function_data_types(struct function* fun) {
	annotate_data_type(&fun->return_type, fun->return_type_str);
	for(int i = 0; i < fun->param_count; ++i) {
		annotate_data_type(&fun->params[i].data_type, fun->params[i].data_type_str);
		annotate_data_type(&fun->params[i].data_type,
		                   fun->params[i].data_type_str);
	}
}

void
void annotate_node_data_types(struct node* node) {
annotate_node_data_types(struct node* node) {
	for(int i = 0; i < node->child_count; ++i) {
		annotate_node_data_types(node->childs[i]);
	}

	switch(node->type) {
		case NODE_LITERAL_INT:
			node->data_type = get_data_type("i32"); /* temporary */
			break;
		case NODE_FUNCALL: {
			int size = sizeof(struct data_type*) * node->child_count;
			struct data_type** params = malloc(size);
			for(int i = 0; i < node->child_count; ++i) {
				params[i] = node->childs[i]->data_type;
			}
			struct function* fun;
			struct function* fun = get_function(node->name, params, node->child_count);
			fun = get_function(node->name, params, node->child_count);
			if(!fun) {
				printf("error, function %s(", node->name);
				for(int i = 0; i < node->child_count; ++i) {
					printf("%s", params[i]->name);
					if(i < node->child_count-1)
						printf(", ");
				}

			break;
		default:
			printf("error, not yet annotating %i\n", node->type);
			exit(-1);
	}
}

void
void annotate_data_types() {
annotate_data_types() {
	for(int i = 0; i < function_count; ++i) {
		annotate_function_data_types(functions[i]);
	}
	
	/* done in seperate loop as the second step depends on all functions
	   having gone through the first step first */
	
	for(int i = 0; i < function_count; ++i) {
		annotate_node_data_types(functions[i]->body);
	}
}

/******************************************************************************/
/*                                                                            */
/*   MAIN                                                                     */
/*                                                                            */
/******************************************************************************/

void
void print_indent(int num) {
print_indent(int num) {
	for(int i = 0; i < num; ++i) printf("  ");
}


void
void print_data_type(struct data_type* data_type) {
print_data_type(struct data_type* data_type) {
	printf("%s", data_type->name);
}

void
void print_mangled_function_name(struct function* fun) {
print_mangled_function_name(struct function* fun) {
	printf("%s__%s", fun->name, fun->return_type->name);
	for(int i = 0; i < fun->param_count; ++i)
		printf("__%s", fun->params[i].data_type->name);
}

void
void print_tree(struct node* node, int indent) {
print_tree(struct node* node, int indent) {
	switch(node->type) {
		case NODE_ROOT:
			for(int j = 0; j < node->child_count; ++j) {
				print_tree(node->childs[j], 0);
				printf("\n");
			}
			break;

			printf("%s", node->val);
			break;
		default:
			printf("(UNKNOWN TOKEN)");
	}
}

void
void print_functions() {
print_functions() {
	for(int i = 0; i < function_count; ++i) {
		struct function* fun = functions[i];
		print_data_type(fun->return_type);
		printf(" ");
		print_mangled_function_name(fun);
		printf("(");
		for(int i = 0; i < fun->param_count; ++i) {

			print_tree(fun->body->childs[j], 1);
			printf(";\n");
		}
		printf("}\n\n");
	}
}

int
int main() {
main() {
	tokenise();
	parse();
	init_data_types();
	annotate_data_types();
	print_functions();
	return 0;
}