Radicalc  Diff

/*                                                                            */
/*   TOKENISER                                                                */
/*                                                                            */
/******************************************************************************/

enum token_type {
	TOK_NONE,
	TOK_PAREN_OPEN, TOK_PAREN_CLOSE, TOK_COMMA, TOK_NEWLINE, TOK_EOF,
	TOK_FUN, TOK_END,
	TOK_IDENT, TOK_LITERAL_INT
};

struct token {
	enum token_type type;
	char* str;

					next_ch();
					skip_ws();
				}
				else if(ch == ')') {
					add_token(TOK_PAREN_CLOSE, 0);
					next_ch();
					skip_ws();
				}
				else if(ch == ',') {
					add_token(TOK_COMMA, 0);
					next_ch();
					skip_ws();
				}
				else if(ch == '\n' || ch == '\r') {
					add_token(TOK_NEWLINE, 0);
					next_ch();
					/* collapse all versions, and multiples to a single token */
					while(ch == '\n' || ch == '\r') next_ch();
					skip_ws();

enum node_type { NODE_ROOT, NODE_FUNDEF, NODE_FUNCALL, NODE_LITERAL_INT };

struct node {
	struct node** childs;
	int child_count;
	char* name;
	enum node_type type;
	char* val;
};

struct node* 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;
	return node;
}

void 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 token* 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 is_next_tok(enum token_type type) {
	return tokens[parse_pos].type == type;
}

struct node* p_expr();

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

struct node* p_var_use() {
	/* todo: implement */
}

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() {
	printf("p_statement\n");
	struct node* node;
	switch(tokens[parse_pos].type) {
		default:
			node = p_expr();
			expect(TOK_NEWLINE);
	}
	return node;
}

struct node* p_fun() {
	printf("p_fun\n");
	struct node* node = node_new(NODE_FUNDEF);
	expect(TOK_FUN);
	node->name = expect(TOK_IDENT)->str;
	expect(TOK_PAREN_OPEN);
	expect(TOK_PAREN_CLOSE);
	expect(TOK_NEWLINE);
	while(!is_next_tok(TOK_END)) {

			}
			printf("}\n");
			break;
		case NODE_FUNCALL:
			print_indent(indent);
			printf("%s(\n", node->name);
			for(int j = 0; j < node->child_count; ++j) {
				print_tree(node->childs[j], indent+1);
				if(j < node->child_count-1)
					printf(",\n");
				else
					printf("\n");
			}
			print_indent(indent);
			printf(")");
			break;
		case NODE_LITERAL_INT:
			print_indent(indent);
			printf("%s", node->val);
			break;
		default:
			printf("(UNKNOWN TOKEN)");
	}
}

int main() {
	tokenise();
	print_tokens();
	struct node* node = parse();
	print_tree(node, 0);
	return 0;
}