Fibonacci test

lambdaworks/lib/lambdaworks.h

@@ -30,7 +30,6 @@ void mul(felt_t a, felt_t b, felt_t result);
 
 /* Writes the result variable with a / b. */
 void lw_div(felt_t a, felt_t b, felt_t result);
-
 #ifdef __cplusplus
 }
 #endif

src/cairo_runner.c

@@ -1,9 +1,8 @@
 #include "cairo_runner.h"
-#include "program.h"
 #include "relocatable.h"
 #include "vm.h"
 
-cairo_runner runner_new(struct program program) {
+cairo_runner runner_new(Program program) {
 	virtual_machine vm = vm_new();
 	cairo_runner runner = {program, vm, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}};
 	return runner;

src/cairo_runner.h

@@ -2,12 +2,12 @@
 #define RUNNER_H
 
 #include "clist.h"
-#include "program.h"
+#include "parser.h"
 #include "relocatable.h"
 #include "vm.h"
 
 typedef struct cairo_runner {
-	struct program program;
+	Program program;
 	virtual_machine vm;
 	relocatable program_base;
 	relocatable execution_base;
@@ -18,7 +18,7 @@ typedef struct cairo_runner {
 } cairo_runner;
 
 // Creates a new, empty cairo_runner
-cairo_runner runner_new(struct program program);
+cairo_runner runner_new(Program program);
 
 // Frees resources used by the cairo_runner struct
 void runner_free(cairo_runner *runner);

src/parser.cpp

@@ -46,11 +46,7 @@ void parse_attributes(simdjson::dom::array attributes_array, Program *program) {
 void parse_data(simdjson::dom::array data_array, Program *program) {
 
 	size_t elements = data_array.size();
-	program->data = (felt_t *)malloc(elements * sizeof(felt_t));
-	if (program->data == NULL) {
-		printf("Data allocation failed\n");
-		return;
-	}
+	program->data = CList_init(sizeof(maybe_relocatable));
 	// Loop through the elements in the data array
 	for (size_t i = 0; i < elements; ++i) {
 		// Get the element at the current index
@@ -65,11 +61,8 @@ void parse_data(simdjson::dom::array data_array, Program *program) {
 		// Convert the unsigned integer to the felt_t array
 		felt_t felt;
 		from(felt, num);
-
-		// Copy the elements from felt to the program's data array
-		for (int j = 0; j < 4; ++j) {
-			program->data[i][j] = felt[j];
-		}
+		maybe_relocatable relocatable_elem = maybe_relocatable_from_felt_limbs(felt);
+		program->data->add(program->data, &relocatable_elem);
 	}
 }
 
@@ -99,21 +92,33 @@ void parse_data(simdjson::dom::array data_array, Program *program) {
 // 	}
 // }
 
-void free_program(Program *program) {
+void program_free(Program *program) {
 	if (program->attributes.length > 0) {
 		for (size_t i = 0; i < program->attributes.length; ++i) {
 			free(program->attributes.data[i]);
 		}
 	}
 	free(program->attributes.data);
 	free(program->compiler_version);
-	free(program->data);
+	program->data->free(program->data);
 	// free(program->debug_info.fileContent.start);
-	free(program);
+}
+
+Program get_empty_program(void) {
+	StringArray empty_array;
+	empty_array.length = 0;
+	empty_array.data = NULL;
+	Program *program_ptr;
+	program_ptr = (Program *)malloc(sizeof(Program));
+	program_ptr->attributes = empty_array;
+	program_ptr->compiler_version = NULL;
+	program_ptr->data = CList_init(sizeof(maybe_relocatable));
+	program_ptr->main = 0;
+	return Program(*program_ptr);
 }
 
 // Function to parse the JSON file and populate the Program struct
-Program *parse_json_filename(const char *filename) {
+Program parse_json_filename(const char *filename) {
 	// Add using namespace inside the parse_json function
 	using namespace simdjson;
 
@@ -136,7 +141,6 @@ Program *parse_json_filename(const char *filename) {
 	// Parse attributes array
 	dom::array attributes_array = root["attributes"].get_array();
 	parse_attributes(attributes_array, program);
-
 	// Parse compiler version
 	const char *compiler_version = root["compiler_version"].get_c_str().value();
 	program->compiler_version = (char *)malloc(strlen(compiler_version) * sizeof(char) + 1);
@@ -154,5 +158,8 @@ Program *parse_json_filename(const char *filename) {
 	// dom::element debug_info = root["debug_info"];
 	// parse_debug_info(debug_info, program);
 
-	return program;
+	// Parse main field (hardcoded right now)
+	program->main = 0;
+
+	return Program(*program);
 }

src/parser.h

@@ -1,5 +1,7 @@
 #pragma once
 #include "../lambdaworks/lib/lambdaworks.h"
+#include "clist.h"
+#include "relocatable.h"
 #include "stddef.h"
 #include "stdint.h"
 
@@ -56,19 +58,21 @@ typedef struct {
 
 typedef struct {
 	StringArray attributes;
-	StringArray builtins;
+	// StringArray builtins;
 	char *compiler_version;
-	felt_t *data;
-	DebugInfo debug_info;
-	StringArray hints;
-	Identifiers *identifiers;
-	StringArray main_scope;
-	char *prime;
+	CList *data;
+	// DebugInfo debug_info;
+	// StringArray hints;
+	// Identifiers *identifiers;
+	// StringArray main_scope;
+	// char *prime;
+	int main;
 } Program;
-void free_program(Program *program);
+
+void program_free(Program *program);
 uint64_t hex_string_to_uint64(const char *hex);
-Program *parse_json_filename(const char *filename);
-Program *parse_json_data(const char *parse_json_data);
+Program get_empty_program(void);
+Program parse_json_filename(const char *filename);
 #ifdef __cplusplus
 } // extern "C"
 #endif

src/program.c

@@ -1,3 +1,3 @@
 #include "program.h"
 
-void program_free(struct program *program) { program->data->free(program->data); }
+void program_free_aux(struct program *program) { program->data->free(program->data); }

src/program.h

@@ -9,6 +9,6 @@ struct program {
 };
 
 // Frees resources used by program struct
-void program_free(struct program *program);
+void program_free_aux(struct program *program);
 
 #endif

src/relocatable.h

@@ -3,6 +3,10 @@
 #include "../lambdaworks/lib/lambdaworks.h"
 #include <stdbool.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct relocatable {
 	unsigned int segment_index;
 	unsigned int offset;
@@ -19,7 +23,10 @@ typedef struct maybe_relocatable {
 } maybe_relocatable;
 
 bool maybe_relocatable_equal(maybe_relocatable a, maybe_relocatable b);
-
 maybe_relocatable maybe_relocatable_from_felt_limbs(limb_t *felt);
 
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
 #endif

test/fibonacci_test.c

@@ -0,0 +1,13 @@
+#include "fibonacci_test.h"
+#include "stdio.h"
+
+// This test does the following things
+// Parses fibonacci json into custom program struct
+// Initializes a runner with data field in the struct
+// Runs cairo run with initialized runner
+void fib_test(void) {
+	Program program = parse_json_filename("cairo_programs/fibonacci.json");
+	cairo_runner runner = runner_new(program);
+	relocatable relocatable = runner_initialize(&runner);
+	printf("%u", relocatable.offset);
+}

test/fibonacci_test.h

@@ -0,0 +1,8 @@
+#ifndef FIB_TEST_H
+#define FIB_TEST_H
+#include "cairo_runner.h"
+#include "parser.h"
+
+void fib_test(void);
+
+#endif

test/parser_test.c

@@ -6,34 +6,34 @@
 #include <stdlib.h>
 #include <string.h>
 
-void parsing_attributes_test(Program *program) {
+void parsing_attributes_test(Program program) {
 	printf("Test: parsing__empty_attributes_array\n");
 
 	char *expected[] = {"attr1", "attr2"};
 	size_t num_values = sizeof(expected) / sizeof(expected[0]);
-	assert(num_values == program->attributes.length);
+	assert(num_values == program.attributes.length);
 	for (size_t i = 0; i < num_values; ++i) {
-		assert(strcmp(expected[i], program->attributes.data[i]) == 0);
+		assert(strcmp(expected[i], program.attributes.data[i]) == 0);
 	}
 	printf("OK! \n");
 }
 
-void parsing_empty_attributes_test(Program *program) {
+void parsing_empty_attributes_test(Program program) {
 	printf("Test: parsing__empty_attributes_array\n");
 	size_t num_values = 0;
-	assert(num_values == program->attributes.length);
-	assert(program->attributes.data == NULL);
+	assert(num_values == program.attributes.length);
+	assert(program.attributes.data == NULL);
 	printf("OK! \n");
 }
 
-void parsing_compiler_version(Program *program) {
+void parsing_compiler_version(Program program) {
 	printf("Test: parsing_compiler_version\n");
 	char *expected = "0.10.3";
-	assert(strcmp(expected, program->compiler_version) == 0);
+	assert(strcmp(expected, program.compiler_version) == 0);
 	printf("OK! \n");
 }
 
-void parsing_data_test(Program *program) {
+void parsing_data_test(Program program) {
 	printf("Test: parsing_data_array\n");
 
 	char *hex_values[] = {
@@ -75,23 +75,23 @@ void parsing_data_test(Program *program) {
 		uint64_t num = hex_string_to_uint64(hex_values[i]);
 		felt_t expected;
 		from(expected, num);
-		for (size_t j = 0; j < 4; ++j) {
-			assert(expected[j] == program->data[i][j]);
-		}
+		maybe_relocatable expected_elem = maybe_relocatable_from_felt_limbs(expected);
+		maybe_relocatable *program_value = program.data->at(program.data, i);
+		assert(maybe_relocatable_equal(expected_elem, *program_value));
 	}
 	printf("OK! \n");
 }
 
 void parsing_tests(void) {
 
 	const char *filename = "cairo_programs/fibonacci.json";
-	Program *program = parse_json_filename(filename);
+	Program program = parse_json_filename(filename);
 	printf("---------------------------------\n");
 	parsing_empty_attributes_test(program);
 	printf("---------------------------------\n");
 	parsing_compiler_version(program);
 	printf("---------------------------------\n");
 	parsing_data_test(program);
 	printf("---------------------------------\n");
-	free_program(program);
+	program_free(&program);
 }

test/runner_tests.c

@@ -1,20 +1,19 @@
 #include "runner_tests.h"
 #include "clist.h"
 #include "memory.h"
-#include "program.h"
 #include "run_context.h"
 #include "utils.h"
 #include "vm.h"
 #include <assert.h>
 #include <stdio.h>
+#include <stdlib.h>
 
 void initialize_runner_no_builtins_no_proof_mode_non_empty_program(void) {
-	struct CList *program_data = CList_init(sizeof(maybe_relocatable));
+	Program program = get_empty_program();
 	felt_t felt_one;
 	one(felt_one);
 	maybe_relocatable elem = maybe_relocatable_from_felt_limbs(felt_one);
-	program_data->add(program_data, &elem);
-	struct program program = {0, program_data};
+	program.data->add(program.data, &elem);
 	cairo_runner runner = runner_new(program);
 	runner_initialize(&runner);
 
@@ -57,9 +56,8 @@ void initialize_runner_no_builtins_no_proof_mode_non_empty_program(void) {
 }
 
 void initialize_runner_no_builtins_no_proof_mode_empty_program(void) {
-	struct CList *program_data = CList_init(sizeof(maybe_relocatable));
-	struct program program = {0, program_data};
-	cairo_runner runner = runner_new(program);
+	Program empty_program = get_empty_program();
+	cairo_runner runner = runner_new(empty_program);
 	runner_initialize(&runner);
 
 	// Check runner data
@@ -104,5 +102,5 @@ void runner_tests(void) {
 	initialize_runner_no_builtins_no_proof_mode_empty_program();
 	printf("--------------------------------- \n");
 	printf("Test: initialize_runner_no_builtins_no_proof_mode_non_empty_program \n");
-	initialize_runner_no_builtins_no_proof_mode_empty_program();
+	initialize_runner_no_builtins_no_proof_mode_non_empty_program();
 }

test/test.c

@@ -1,5 +1,6 @@
 #include "decoder_test.h"
 #include "felt_test.h"
+#include "fibonacci_test.h"
 #include "memory_tests.h"
 #include "parser_test.h"
 #include "runner_tests.h"
@@ -11,7 +12,8 @@ int main(__attribute__((unused)) int argc, __attribute__((unused)) char **argv)
 	felt_tests();
 	decoding_tests();
 	memory_tests();
-	runner_tests();
 	parsing_tests();
+	runner_tests();
+	// fib_test();
 	return 0;
 }