#include <stdio.h>
#include "common.h"

#if defined(STRUCT)
#include "struct.c"
#elif defined(FPTR)
#include "fptr.c"
#endif

int main()
{
	/* predefine variables so gen_varref can just return a pointer to speed
	 * things up and hopefully match real AST runners more closely */
	proc *proc = gen_proc(
			/* input parameters, pointers to matrixes
			 * MATRIX_SIZE*MATRIX_SIZE */
			"A", "B", "C",
			/* temporary variables */
			"R", "I", "J", "K");

	/* A[I][K] */
	node *fetch_a =
		gen_load(
			gen_add(
				gen_var(proc, "A"),
				gen_mul(
					gen_const(sizeof(intptr_t)),
					gen_add(
						gen_var(proc, "K"),
						gen_mul(
							gen_var(proc, "I"),
							gen_const(MATRIX_SIZE))))));

	/* B[K][J] */
	node *fetch_b =
		gen_load(
			gen_add(
				gen_var(proc, "B"),
				gen_mul(
					gen_const(sizeof(intptr_t)),
					gen_add(
						gen_var(proc, "J"),
						gen_mul(
							gen_var(proc, "K"),
							gen_const(MATRIX_SIZE))))));

	/* R += fetch_a * fetch_b */
	node *inner_body =
		gen_assign(
			gen_varref(proc, "R"),
			gen_add(
				gen_var(proc, "R"),
				gen_mul(fetch_a, fetch_b)));

	/* for (intptr_t K = 0; K < MATRIX_SIZE; ++K) inner_body */
	node *inner_loop =
		gen_for(
			gen_assign(
				gen_varref(proc, "K"),
				gen_const(0)),

			gen_lt(
				gen_var(proc, "K"),
				gen_const(MATRIX_SIZE)),

			gen_assign(
				gen_varref(proc, "K"),
				gen_add(
					gen_var(proc, "K"),
					gen_const(1))),

			inner_body);

	/* &C[I][J] */
	node *ref_c =
		gen_add(
			gen_var(proc, "C"),
			gen_mul(
				gen_const(sizeof(intptr_t)),
				gen_add(
					gen_var(proc, "J"),
					gen_mul(
						gen_var(proc, "I"),
						gen_const(MATRIX_SIZE)))));

	/* R = 0; inner_loop; *ref_c = R */
	node *midder_body =
		gen_body(
			gen_assign(
				gen_varref(proc, "R"),
				gen_const(0)),

			inner_loop,

			gen_store(
				ref_c,
				gen_var(proc, "R")));

	/* for (intptr_t J = 0; J < MATRIX_SIZE; ++J) midder_body */
	node *midder_loop =
		gen_for(
			gen_assign(
				gen_varref(proc, "J"),
				gen_const(0)),

			gen_lt(
				gen_var(proc, "J"),
				gen_const(MATRIX_SIZE)),

			gen_assign(
				gen_varref(proc, "J"),
				gen_add(
					gen_var(proc, "J"),
					gen_const(1))),

			midder_body);

	/* for (intptr_t I = 0; I < MATRIX_SIZE; ++I) midder_loop */
	node *outer_loop =
		gen_for(
			gen_assign(
				gen_varref(proc, "I"),
				gen_const(0)),

			gen_lt(
				gen_var(proc, "I"),
				gen_const(MATRIX_SIZE)),

			gen_assign(
				gen_varref(proc, "I"),
				gen_add(
					gen_var(proc, "I"),
					gen_const(1))),

			midder_loop);

	intptr_t *A = calloc(MATRIX_SIZE * MATRIX_SIZE, sizeof(intptr_t));
	assert(A);

	intptr_t *B = calloc(MATRIX_SIZE * MATRIX_SIZE, sizeof(intptr_t));
	assert(B);

	intptr_t *C = calloc(MATRIX_SIZE * MATRIX_SIZE, sizeof(intptr_t));
	assert(C);

	init_matrices(A, B);

	proc_set(proc, "A", (intptr_t)A);
	proc_set(proc, "B", (intptr_t)B);
	proc_set(proc, "C", (intptr_t)C);

	run(outer_loop);

	printf("%zu\n", hash(C));
}