excel_to_code 0.2.1 → 0.2.3

data/src/compile/c/excel_to_c_runtime.c

@@ -5,16 +5,18 @@
 #include <ctype.h>
 #include <math.h>
 
-// To run the tests at the end of this file
-// cc excel_to_c_runtime; ./a.out
+#ifndef NUMBER_OF_REFS
+  #define NUMBER_OF_REFS 0
+#endif
 
-// FIXME: Extract a header file
+#ifndef EXCEL_FILENAME
+  #define EXCEL_FILENAME "NoExcelFilename" 
+#endif
 
-// I predefine an array of ExcelValues to store calculations
-// Probably bad practice. At the very least, I should make it
-// link to the cell reference in some way.
-#define MAX_EXCEL_VALUE_HEAP_SIZE 1000000
-#define MAX_MEMORY_TO_BE_FREED_HEAP_SIZE 1000000
+// Need to retain malloc'd values for a while, so can return to functions that use this library
+// So to avoid a memory leak we keep an array of all the values we have malloc'd, which we then
+// free when the reset() function is called.
+#define MEMORY_TO_BE_FREED_LATER_HEAP_INCREMENT 1000
 
 #define true 1
 #define false 0
@@ -92,26 +94,27 @@ static ExcelValue text(ExcelValue number_v, ExcelValue format_v);
 static ExcelValue vlookup_3(ExcelValue lookup_value_v,ExcelValue lookup_table_v, ExcelValue column_number_v);
 static ExcelValue vlookup(ExcelValue lookup_value_v,ExcelValue lookup_table_v, ExcelValue column_number_v, ExcelValue match_type_v);
 
-
-// My little heap for excel values
-ExcelValue cells[MAX_EXCEL_VALUE_HEAP_SIZE];
-int cell_counter = 0;
-
-#define HEAPCHECK if(cell_counter >= MAX_EXCEL_VALUE_HEAP_SIZE) { printf("ExcelValue heap full. Edit MAX_EXCEL_VALUE_HEAP_SIZE in the c source code."); exit(-1); }
-
 // My little heap for keeping pointers to memory that I need to reclaim
-void *memory_that_needs_to_be_freed[MAX_MEMORY_TO_BE_FREED_HEAP_SIZE];
+void **memory_that_needs_to_be_freed;
 int memory_that_needs_to_be_freed_counter = 0;
-
-#define MEMORY_THAT_NEEDS_TO_BE_FREED_HEAP_CHECK 
+int memory_that_needs_to_be_freed_size = -1;
 
 static void free_later(void *pointer) {
+	if(memory_that_needs_to_be_freed_counter >= memory_that_needs_to_be_freed_size) { 
+    if(memory_that_needs_to_be_freed_size <= 0) {
+      memory_that_needs_to_be_freed = malloc(MEMORY_TO_BE_FREED_LATER_HEAP_INCREMENT*sizeof(void*));
+      memory_that_needs_to_be_freed_size = MEMORY_TO_BE_FREED_LATER_HEAP_INCREMENT;
+    } else {
+      memory_that_needs_to_be_freed_size += MEMORY_TO_BE_FREED_LATER_HEAP_INCREMENT;
+      memory_that_needs_to_be_freed = realloc(memory_that_needs_to_be_freed, memory_that_needs_to_be_freed_size * sizeof(void*));
+      if(!memory_that_needs_to_be_freed) {
+        printf("Could not allocate new memory to memory that needs to be freed array. halting.");
+        exit(-1);
+      }
+    }
+  }
 	memory_that_needs_to_be_freed[memory_that_needs_to_be_freed_counter] = pointer;
 	memory_that_needs_to_be_freed_counter++;
-	if(memory_that_needs_to_be_freed_counter >= MAX_MEMORY_TO_BE_FREED_HEAP_SIZE) { 
-		printf("Memory that needs to be freed heap full. Edit MAX_MEMORY_TO_BE_FREED_HEAP_SIZE in the c source code"); 
-		exit(-1);
-	}
 }
 
 static void free_all_allocated_memory() {
@@ -122,35 +125,19 @@ static void free_all_allocated_memory() {
 	memory_that_needs_to_be_freed_counter = 0;
 }
 
-// The object initializers
-static ExcelValue new_excel_number(double number) {
-	cell_counter++;
-	HEAPCHECK
-	ExcelValue new_cell = 	cells[cell_counter];
-	new_cell.type = ExcelNumber;
-	new_cell.number = number;
-	return new_cell;
-};
+static int variable_set[NUMBER_OF_REFS];
 
-static ExcelValue new_excel_string(char *string) {
-	cell_counter++;
-	HEAPCHECK
-	ExcelValue new_cell = cells[cell_counter];
-	new_cell.type = ExcelString;
-	new_cell.string = string;
-	return new_cell;
-};
+// Resets all cached and malloc'd values
+void reset() {
+  free_all_allocated_memory();
+  memset(variable_set, 0, sizeof(variable_set));
+}
 
-static ExcelValue new_excel_range(void *array, int rows, int columns) {
-	cell_counter++;
-	HEAPCHECK
-	ExcelValue new_cell = cells[cell_counter];
-	new_cell.type = ExcelRange;
-	new_cell.array = array;
-	new_cell.rows = rows;
-	new_cell.columns = columns;
-	return new_cell;
-};
+// Handy macros
+
+#define new_excel_number(numberdouble) ((ExcelValue) {.type = ExcelNumber, .number = numberdouble})
+#define new_excel_string(stringchar) ((ExcelValue) {.type = ExcelString, .string = stringchar})
+#define new_excel_range(arrayofvalues, rangerows, rangecolumns) ((ExcelValue) {.type = ExcelRange, .array = arrayofvalues, .rows = rangerows, .columns = rangecolumns})
 
 static void * new_excel_value_array(int size) {
 	ExcelValue *pointer = malloc(sizeof(ExcelValue)*size); // Freed later
@@ -163,6 +150,8 @@ static void * new_excel_value_array(int size) {
 };
 
 // Constants
+static ExcelValue ORIGINAL_EXCEL_FILENAME = {.type = ExcelString, .string = EXCEL_FILENAME };
+
 const ExcelValue BLANK = {.type = ExcelEmpty, .number = 0};
 
 const ExcelValue ZERO = {.type = ExcelNumber, .number = 0};
@@ -292,7 +281,7 @@ static ExcelValue excel_abs(ExcelValue a_v) {
 	if(a >= 0.0 ) {
 		return a_v;
 	} else {
-		return new_excel_number(-a);
+		return (ExcelValue) {.type = ExcelNumber, .number = -a};
 	}
 }
 
@@ -1864,759 +1853,3 @@ static ExcelValue hlookup(ExcelValue lookup_value_v,ExcelValue lookup_table_v, E
   }
   return NA;
 }
-
-
-int test_functions() {
-	// Test ABS
-	assert(excel_abs(ONE).number == 1);
-	assert(excel_abs(new_excel_number(-1)).number == 1);
-	assert(excel_abs(VALUE).type == ExcelError);
-	
-	// Test ADD
-	assert(add(ONE,new_excel_number(-2.5)).number == -1.5);
-	assert(add(ONE,VALUE).type == ExcelError);
-	
-	// Test AND
-	ExcelValue true_array1[] = { TRUE, new_excel_number(10)};
-	ExcelValue true_array2[] = { ONE };
-	ExcelValue false_array1[] = { FALSE, new_excel_number(10)};
-	ExcelValue false_array2[] = { TRUE, new_excel_number(0)};
-	// ExcelValue error_array1[] = { new_excel_number(10)}; // Not implemented
-	ExcelValue error_array2[] = { TRUE, NA};
-	assert(excel_and(2,true_array1).number == 1);
-	assert(excel_and(1,true_array2).number == 1);
-	assert(excel_and(2,false_array1).number == 0);
-	assert(excel_and(2,false_array2).number == 0);
-	// assert(excel_and(1,error_array1).type == ExcelError); // Not implemented
-	assert(excel_and(2,error_array2).type == ExcelError);
-	
-	// Test AVERAGE
-	ExcelValue array1[] = { new_excel_number(10), new_excel_number(5), TRUE, FALSE};
-	ExcelValue array1_v = new_excel_range(array1,2,2);
-	ExcelValue array2[] = { array1_v, new_excel_number(9), new_excel_string("Hello")};
-	ExcelValue array3[] = { array1_v, new_excel_number(9), new_excel_string("Hello"), VALUE};
-	assert(average(4, array1).number == 7.5);
-	assert(average(3, array2).number == 8);
-	assert(average(4, array3).type == ExcelError);
-	
-	// Test CHOOSE
-	assert(choose(ONE,4,array1).number == 10);
-	assert(choose(new_excel_number(4),4,array1).type == ExcelBoolean);
-	assert(choose(new_excel_number(0),4,array1).type == ExcelError);
-	assert(choose(new_excel_number(5),4,array1).type == ExcelError);
-	assert(choose(ONE,4,array3).type == ExcelError);	
-	
-	// Test COUNT
-	assert(count(4,array1).number == 2);
-	assert(count(3,array2).number == 3);
-	assert(count(4,array3).number == 3);
-
-  // Test Large
-  ExcelValue large_test_array_1[] = { new_excel_number(10), new_excel_number(100), new_excel_number(500), BLANK };
-  ExcelValue large_test_array_1_v = new_excel_range(large_test_array_1, 1, 4);
-  assert(large(large_test_array_1_v, new_excel_number(1)).number == 500);
-  assert(large(large_test_array_1_v, new_excel_number(2)).number == 100);
-  assert(large(large_test_array_1_v, new_excel_number(3)).number == 10);
-  assert(large(large_test_array_1_v, new_excel_number(4)).type == ExcelError);
-  assert(large(new_excel_number(500), new_excel_number(1)).number == 500);
-  ExcelValue large_test_array_2[] = { new_excel_number(10), new_excel_number(100), new_excel_number(500), VALUE };
-  ExcelValue large_test_array_2_v = new_excel_range(large_test_array_2, 1, 4);
-  assert(large(large_test_array_2_v,new_excel_number(2)).type == ExcelError);
-  assert(large(new_excel_number(500),VALUE).type == ExcelError);
-
-	
-	// Test COUNTA
-	ExcelValue count_a_test_array_1[] = { new_excel_number(10), new_excel_number(5), TRUE, FALSE, new_excel_string("Hello"), VALUE, BLANK};
-  ExcelValue count_a_test_array_1_v = new_excel_range(count_a_test_array_1,7,1);
-  ExcelValue count_a_test_array_2[] = {new_excel_string("Bye"),count_a_test_array_1_v};
-	assert(counta(7, count_a_test_array_1).number == 6);
-  assert(counta(2, count_a_test_array_2).number == 7);
-	
-	// Test divide
-	assert(divide(new_excel_number(12.4),new_excel_number(3.2)).number == 3.875);
-	assert(divide(new_excel_number(12.4),new_excel_number(0)).type == ExcelError);
-	
-	// Test excel_equal
-	assert(excel_equal(new_excel_number(1.2),new_excel_number(3.4)).type == ExcelBoolean);
-	assert(excel_equal(new_excel_number(1.2),new_excel_number(3.4)).number == false);
-	assert(excel_equal(new_excel_number(1.2),new_excel_number(1.2)).number == true);
-	assert(excel_equal(new_excel_string("hello"), new_excel_string("HELLO")).number == true);
-	assert(excel_equal(new_excel_string("hello world"), new_excel_string("HELLO")).number == false);
-	assert(excel_equal(new_excel_string("1"), ONE).number == false);
-	assert(excel_equal(DIV0, ONE).type == ExcelError);
-
-	// Test not_equal
-	assert(not_equal(new_excel_number(1.2),new_excel_number(3.4)).type == ExcelBoolean);
-	assert(not_equal(new_excel_number(1.2),new_excel_number(3.4)).number == true);
-	assert(not_equal(new_excel_number(1.2),new_excel_number(1.2)).number == false);
-	assert(not_equal(new_excel_string("hello"), new_excel_string("HELLO")).number == false);
-	assert(not_equal(new_excel_string("hello world"), new_excel_string("HELLO")).number == true);
-	assert(not_equal(new_excel_string("1"), ONE).number == true);
-	assert(not_equal(DIV0, ONE).type == ExcelError);
-	
-	// Test excel_if
-	// Two argument version
-	assert(excel_if_2(TRUE,new_excel_number(10)).type == ExcelNumber);
-	assert(excel_if_2(TRUE,new_excel_number(10)).number == 10);
-	assert(excel_if_2(FALSE,new_excel_number(10)).type == ExcelBoolean);
-	assert(excel_if_2(FALSE,new_excel_number(10)).number == false);
-	assert(excel_if_2(NA,new_excel_number(10)).type == ExcelError);
-	// Three argument version
-	assert(excel_if(TRUE,new_excel_number(10),new_excel_number(20)).type == ExcelNumber);
-	assert(excel_if(TRUE,new_excel_number(10),new_excel_number(20)).number == 10);
-	assert(excel_if(FALSE,new_excel_number(10),new_excel_number(20)).type == ExcelNumber);
-	assert(excel_if(FALSE,new_excel_number(10),new_excel_number(20)).number == 20);
-	assert(excel_if(NA,new_excel_number(10),new_excel_number(20)).type == ExcelError);
-	assert(excel_if(TRUE,new_excel_number(10),NA).type == ExcelNumber);
-	assert(excel_if(TRUE,new_excel_number(10),NA).number == 10);
-	
-	// Test excel_match
-	ExcelValue excel_match_array_1[] = { new_excel_number(10), new_excel_number(100) };
-	ExcelValue excel_match_array_1_v = new_excel_range(excel_match_array_1,1,2);
-	ExcelValue excel_match_array_2[] = { new_excel_string("Pear"), new_excel_string("Bear"), new_excel_string("Apple") };
-	ExcelValue excel_match_array_2_v = new_excel_range(excel_match_array_2,3,1);
-	ExcelValue excel_match_array_4[] = { ONE, BLANK, new_excel_number(0) };
-	ExcelValue excel_match_array_4_v = new_excel_range(excel_match_array_4,1,3);
-	ExcelValue excel_match_array_5[] = { ONE, new_excel_number(0), BLANK };
-	ExcelValue excel_match_array_5_v = new_excel_range(excel_match_array_5,1,3);
-	
-	// Two argument version
-	assert(excel_match_2(new_excel_number(10),excel_match_array_1_v).number == 1);
-	assert(excel_match_2(new_excel_number(100),excel_match_array_1_v).number == 2);
-	assert(excel_match_2(new_excel_number(1000),excel_match_array_1_v).type == ExcelError);
-    assert(excel_match_2(new_excel_number(0), excel_match_array_4_v).number == 2);
-    assert(excel_match_2(BLANK, excel_match_array_5_v).number == 2);
-
-	// Three argument version	
-    assert(excel_match(new_excel_number(10.0), excel_match_array_1_v, new_excel_number(0) ).number == 1);
-    assert(excel_match(new_excel_number(100.0), excel_match_array_1_v, new_excel_number(0) ).number == 2);
-    assert(excel_match(new_excel_number(1000.0), excel_match_array_1_v, new_excel_number(0) ).type == ExcelError);
-    assert(excel_match(new_excel_string("bEAr"), excel_match_array_2_v, new_excel_number(0) ).number == 2);
-    assert(excel_match(new_excel_number(1000.0), excel_match_array_1_v, ONE ).number == 2);
-    assert(excel_match(new_excel_number(1.0), excel_match_array_1_v, ONE ).type == ExcelError);
-    assert(excel_match(new_excel_string("Care"), excel_match_array_2_v, new_excel_number(-1) ).number == 1  );
-    assert(excel_match(new_excel_string("Zebra"), excel_match_array_2_v, new_excel_number(-1) ).type == ExcelError);
-    assert(excel_match(new_excel_string("a"), excel_match_array_2_v, new_excel_number(-1) ).number == 2);
-	
-	// When not given a range
-    assert(excel_match(new_excel_number(10.0), new_excel_number(10), new_excel_number(0.0)).number == 1);
-    assert(excel_match(new_excel_number(20.0), new_excel_number(10), new_excel_number(0.0)).type == ExcelError);
-    assert(excel_match(new_excel_number(10.0), excel_match_array_1_v, BLANK).number == 1);
-
-	// Test more than on
-	// .. numbers
-    assert(more_than(ONE,new_excel_number(2)).number == false);
-    assert(more_than(ONE,ONE).number == false);
-    assert(more_than(ONE,new_excel_number(0)).number == true);
-	// .. booleans
-    assert(more_than(FALSE,FALSE).number == false);
-    assert(more_than(FALSE,TRUE).number == false);
-    assert(more_than(TRUE,FALSE).number == true);
-    assert(more_than(TRUE,TRUE).number == false);
-	// ..strings
-    assert(more_than(new_excel_string("HELLO"),new_excel_string("Ardvark")).number == true);		
-    assert(more_than(new_excel_string("HELLO"),new_excel_string("world")).number == false);
-    assert(more_than(new_excel_string("HELLO"),new_excel_string("hello")).number == false);
-	// ..blanks
-    assert(more_than(BLANK,ONE).number == false);
-    assert(more_than(BLANK,new_excel_number(-1)).number == true);
-    assert(more_than(ONE,BLANK).number == true);
-    assert(more_than(new_excel_number(-1),BLANK).number == false);
-
-	// Test less than on
-	// .. numbers
-    assert(less_than(ONE,new_excel_number(2)).number == true);
-    assert(less_than(ONE,ONE).number == false);
-    assert(less_than(ONE,new_excel_number(0)).number == false);
-	// .. booleans
-    assert(less_than(FALSE,FALSE).number == false);
-    assert(less_than(FALSE,TRUE).number == true);
-    assert(less_than(TRUE,FALSE).number == false);
-    assert(less_than(TRUE,TRUE).number == false);
-	// ..strings
-    assert(less_than(new_excel_string("HELLO"),new_excel_string("Ardvark")).number == false);		
-    assert(less_than(new_excel_string("HELLO"),new_excel_string("world")).number == true);
-    assert(less_than(new_excel_string("HELLO"),new_excel_string("hello")).number == false);
-	// ..blanks
-    assert(less_than(BLANK,ONE).number == true);
-    assert(less_than(BLANK,new_excel_number(-1)).number == false);
-    assert(less_than(ONE,BLANK).number == false);
-    assert(less_than(new_excel_number(-1),BLANK).number == true);
-
-	// Test FIND function
-	// ... should find the first occurrence of one string in another, returning :value if the string doesn't match
-	assert(find_2(new_excel_string("one"),new_excel_string("onetwothree")).number == 1);
-	assert(find_2(new_excel_string("one"),new_excel_string("twoonethree")).number == 4);
-	assert(find_2(new_excel_string("one"),new_excel_string("twoonthree")).type == ExcelError);
-    // ... should find the first occurrence of one string in another after a given index, returning :value if the string doesn't match
-	assert(find(new_excel_string("one"),new_excel_string("onetwothree"),ONE).number == 1);
-	assert(find(new_excel_string("one"),new_excel_string("twoonethree"),new_excel_number(5)).type == ExcelError);
-	assert(find(new_excel_string("one"),new_excel_string("oneone"),new_excel_number(2)).number == 4);
-    // ... should be possible for the start_num to be a string, if that string converts to a number
-	assert(find(new_excel_string("one"),new_excel_string("oneone"),new_excel_string("2")).number == 4);
-    // ... should return a :value error when given anything but a number as the third argument
-	assert(find(new_excel_string("one"),new_excel_string("oneone"),new_excel_string("a")).type == ExcelError);
-    // ... should return a :value error when given a third argument that is less than 1 or greater than the length of the string
-	assert(find(new_excel_string("one"),new_excel_string("oneone"),new_excel_number(0)).type == ExcelError);
-	assert(find(new_excel_string("one"),new_excel_string("oneone"),new_excel_number(-1)).type == ExcelError);
-	assert(find(new_excel_string("one"),new_excel_string("oneone"),new_excel_number(7)).type == ExcelError);
-	// ... BLANK in the first argument matches any character
-	assert(find_2(BLANK,new_excel_string("abcdefg")).number == 1);
-	assert(find(BLANK,new_excel_string("abcdefg"),new_excel_number(4)).number == 4);
-    // ... should treat BLANK in the second argument as an empty string
-	assert(find_2(BLANK,BLANK).number == 1);
-	assert(find_2(new_excel_string("a"),BLANK).type == ExcelError);
-	// ... should return an error if any argument is an error
-	assert(find(new_excel_string("one"),new_excel_string("onetwothree"),NA).type == ExcelError);
-	assert(find(new_excel_string("one"),NA,ONE).type == ExcelError);
-	assert(find(NA,new_excel_string("onetwothree"),ONE).type == ExcelError);
-	
-	// Test the IFERROR function
-    assert(iferror(new_excel_string("ok"),ONE).type == ExcelString);
-	assert(iferror(VALUE,ONE).type == ExcelNumber);		
-	
-	// Test the INDEX function
-	ExcelValue index_array_1[] = { new_excel_number(10), new_excel_number(20), BLANK };
-	ExcelValue index_array_1_v_column = new_excel_range(index_array_1,3,1);
-	ExcelValue index_array_1_v_row = new_excel_range(index_array_1,1,3);
-	ExcelValue index_array_2[] = { BLANK, ONE, new_excel_number(10), new_excel_number(11), new_excel_number(100), new_excel_number(101) };
-	ExcelValue index_array_2_v = new_excel_range(index_array_2,3,2);
-	// ... if given one argument should return the value at that offset in the range
-	assert(excel_index_2(index_array_1_v_column,new_excel_number(2.0)).number == 20);
-	assert(excel_index_2(index_array_1_v_row,new_excel_number(2.0)).number == 20);
-	// ... but not if the range is not a single row or single column
-	assert(excel_index_2(index_array_2_v,new_excel_number(2.0)).type == ExcelError);
-    // ... it should return the value in the array at position row_number, column_number
-	assert(excel_index(new_excel_number(10),ONE,ONE).number == 10);
-	assert(excel_index(index_array_2_v,new_excel_number(1.0),new_excel_number(2.0)).number == 1);
-	assert(excel_index(index_array_2_v,new_excel_number(2.0),new_excel_number(1.0)).number == 10);
-	assert(excel_index(index_array_2_v,new_excel_number(3.0),new_excel_number(1.0)).number == 100);
-	assert(excel_index(index_array_2_v,new_excel_number(3.0),new_excel_number(3.0)).type == ExcelError);
-	// ... it should return ZERO not blank, if a blank cell is picked
-	assert(excel_index(index_array_2_v,new_excel_number(1.0),new_excel_number(1.0)).type == ExcelNumber);
-	assert(excel_index(index_array_2_v,new_excel_number(1.0),new_excel_number(1.0)).number == 0);
-	assert(excel_index_2(index_array_1_v_row,new_excel_number(3.0)).type == ExcelNumber);
-	assert(excel_index_2(index_array_1_v_row,new_excel_number(3.0)).number == 0);
-	// ... it should return the whole row if given a zero column number
-	ExcelValue index_result_1_v = excel_index(index_array_2_v,new_excel_number(1.0),new_excel_number(0.0));
-	assert(index_result_1_v.type == ExcelRange);
-	assert(index_result_1_v.rows == 1);
-	assert(index_result_1_v.columns == 2);
-	ExcelValue *index_result_1_a = index_result_1_v.array;
-	assert(index_result_1_a[0].number == 0);
-	assert(index_result_1_a[1].number == 1);
-	// ... it should return the whole column if given a zero row number
-	ExcelValue index_result_2_v = excel_index(index_array_2_v,new_excel_number(0),new_excel_number(1.0));
-	assert(index_result_2_v.type == ExcelRange);
-	assert(index_result_2_v.rows == 3);
-	assert(index_result_2_v.columns == 1);
-	ExcelValue *index_result_2_a = index_result_2_v.array;
-	assert(index_result_2_a[0].number == 0);
-	assert(index_result_2_a[1].number == 10);
-	assert(index_result_2_a[2].number == 100);
-    // ... it should return a :ref error when given arguments outside array range
-	assert(excel_index_2(index_array_1_v_row,new_excel_number(-1)).type == ExcelError);
-	assert(excel_index_2(index_array_1_v_row,new_excel_number(4)).type == ExcelError);
-    // ... it should treat BLANK as zero if given as a required row or column number
-	assert(excel_index(index_array_2_v,new_excel_number(1.0),BLANK).type == ExcelRange);
-	assert(excel_index(index_array_2_v,BLANK,new_excel_number(2.0)).type == ExcelRange);
-    // ... it should return an error if an argument is an error
-	assert(excel_index(NA,NA,NA).type == ExcelError);
-	
-	// LEFT(string,[characters])
-	// ... should return the left n characters from a string
-    assert(strcmp(left_1(new_excel_string("ONE")).string,"O") == 0);
-    assert(strcmp(left(new_excel_string("ONE"),ONE).string,"O") == 0);
-    assert(strcmp(left(new_excel_string("ONE"),new_excel_number(3)).string,"ONE") == 0);
-	// ... should turn numbers into strings before processing
-	assert(strcmp(left(new_excel_number(1.31e12),new_excel_number(3)).string, "131") == 0);
-	// ... should turn booleans into the words TRUE and FALSE before processing
-    assert(strcmp(left(TRUE,new_excel_number(3)).string,"TRU") == 0);
-	assert(strcmp(left(FALSE,new_excel_number(3)).string,"FAL") == 0);
-	// ... should return BLANK if given BLANK for either argument
-	assert(left(BLANK,new_excel_number(3)).type == ExcelEmpty);
-	assert(left(new_excel_string("ONE"),BLANK).type == ExcelEmpty);
-	// ... should return an error if an argument is an error
-    assert(left_1(NA).type == ExcelError);
-    assert(left(new_excel_string("ONE"),NA).type == ExcelError);
-	
-	// Test less than or equal to
-	// .. numbers
-    assert(less_than_or_equal(ONE,new_excel_number(2)).number == true);
-    assert(less_than_or_equal(ONE,ONE).number == true);
-    assert(less_than_or_equal(ONE,new_excel_number(0)).number == false);
-	// .. booleans
-    assert(less_than_or_equal(FALSE,FALSE).number == true);
-    assert(less_than_or_equal(FALSE,TRUE).number == true);
-    assert(less_than_or_equal(TRUE,FALSE).number == false);
-    assert(less_than_or_equal(TRUE,TRUE).number == true);
-	// ..strings
-    assert(less_than_or_equal(new_excel_string("HELLO"),new_excel_string("Ardvark")).number == false);		
-    assert(less_than_or_equal(new_excel_string("HELLO"),new_excel_string("world")).number == true);
-    assert(less_than_or_equal(new_excel_string("HELLO"),new_excel_string("hello")).number == true);
-	// ..blanks
-    assert(less_than_or_equal(BLANK,ONE).number == true);
-    assert(less_than_or_equal(BLANK,new_excel_number(-1)).number == false);
-    assert(less_than_or_equal(ONE,BLANK).number == false);
-    assert(less_than_or_equal(new_excel_number(-1),BLANK).number == true);
-
-	// Test MAX
-	assert(max(4, array1).number == 10);
-	assert(max(3, array2).number == 10);
-	assert(max(4, array3).type == ExcelError);
-
-	// Test MIN
-	assert(min(4, array1).number == 5);
-	assert(min(3, array2).number == 5);
-	assert(min(4, array3).type == ExcelError);
-
-	// Test MOD
-    // ... should return the remainder of a number
-	assert(mod(new_excel_number(10), new_excel_number(3)).number == 1.0);
-	assert(mod(new_excel_number(10), new_excel_number(5)).number == 0.0);
-    // ... should be possible for the the arguments to be strings, if they convert to a number
-	assert(mod(new_excel_string("3.5"),new_excel_string("2")).number == 1.5);
-    // ... should treat BLANK as zero
-	assert(mod(BLANK,new_excel_number(10)).number == 0);
-	assert(mod(new_excel_number(10),BLANK).type == ExcelError);
-	assert(mod(BLANK,BLANK).type == ExcelError);
-    // ... should treat true as 1 and FALSE as 0
-	assert((mod(new_excel_number(1.1),TRUE).number - 0.1) < 0.001);	
-	assert(mod(new_excel_number(1.1),FALSE).type == ExcelError);
-	assert(mod(FALSE,new_excel_number(10)).number == 0);
-    // ... should return an error when given inappropriate arguments
-	assert(mod(new_excel_string("Asdasddf"),new_excel_string("adsfads")).type == ExcelError);
-    // ... should return an error if an argument is an error
-	assert(mod(new_excel_number(1),VALUE).type == ExcelError);
-	assert(mod(VALUE,new_excel_number(1)).type == ExcelError);
-	assert(mod(VALUE,VALUE).type == ExcelError);
-	
-	// Test more than or equal to on
-	// .. numbers
-    assert(more_than_or_equal(ONE,new_excel_number(2)).number == false);
-    assert(more_than_or_equal(ONE,ONE).number == true);
-    assert(more_than_or_equal(ONE,new_excel_number(0)).number == true);
-	// .. booleans
-    assert(more_than_or_equal(FALSE,FALSE).number == true);
-    assert(more_than_or_equal(FALSE,TRUE).number == false);
-    assert(more_than_or_equal(TRUE,FALSE).number == true);
-    assert(more_than_or_equal(TRUE,TRUE).number == true);
-	// ..strings
-    assert(more_than_or_equal(new_excel_string("HELLO"),new_excel_string("Ardvark")).number == true);		
-    assert(more_than_or_equal(new_excel_string("HELLO"),new_excel_string("world")).number == false);
-    assert(more_than_or_equal(new_excel_string("HELLO"),new_excel_string("hello")).number == true);
-	// ..blanks
-    assert(more_than_or_equal(BLANK,BLANK).number == true);
-    assert(more_than_or_equal(BLANK,ONE).number == false);
-    assert(more_than_or_equal(BLANK,new_excel_number(-1)).number == true);
-    assert(more_than_or_equal(ONE,BLANK).number == true);
-    assert(more_than_or_equal(new_excel_number(-1),BLANK).number == false);	
-	
-	// Test negative
-    // ... should return the negative of its arguments
-	assert(negative(new_excel_number(1)).number == -1);
-	assert(negative(new_excel_number(-1)).number == 1);
-    // ... should treat strings that only contain numbers as numbers
-	assert(negative(new_excel_string("10")).number == -10);
-	assert(negative(new_excel_string("-1.3")).number == 1.3);
-    // ... should return an error when given inappropriate arguments
-	assert(negative(new_excel_string("Asdasddf")).type == ExcelError);
-    // ... should treat BLANK as zero
-	assert(negative(BLANK).number == 0);
-	
-	// Test PMT(rate,number_of_periods,present_value) - optional arguments not yet implemented
-    // ... should calculate the monthly payment required for a given principal, interest rate and loan period
-    assert((pmt(new_excel_number(0.1),new_excel_number(10),new_excel_number(100)).number - -16.27) < 0.01);
-    assert((pmt(new_excel_number(0.0123),new_excel_number(99.1),new_excel_number(123.32)).number - -2.159) < 0.01);
-    assert((pmt(new_excel_number(0),new_excel_number(2),new_excel_number(10)).number - -5) < 0.01);
-
-	// Test power
-    // ... should return power of its arguments
-	assert(power(new_excel_number(2),new_excel_number(3)).number == 8);
-	assert(power(new_excel_number(4.0),new_excel_number(0.5)).number == 2.0);
-	assert(power(new_excel_number(-4.0),new_excel_number(0.5)).type == ExcelError);
-	
-	// Test round
-    assert(excel_round(new_excel_number(1.1), new_excel_number(0)).number == 1.0);
-    assert(excel_round(new_excel_number(1.5), new_excel_number(0)).number == 2.0);
-    assert(excel_round(new_excel_number(1.56),new_excel_number(1)).number == 1.6);
-    assert(excel_round(new_excel_number(-1.56),new_excel_number(1)).number == -1.6);
-
-	// Test rounddown
-    assert(rounddown(new_excel_number(1.1), new_excel_number(0)).number == 1.0);
-    assert(rounddown(new_excel_number(1.5), new_excel_number(0)).number == 1.0);
-    assert(rounddown(new_excel_number(1.56),new_excel_number(1)).number == 1.5);
-    assert(rounddown(new_excel_number(-1.56),new_excel_number(1)).number == -1.5);	
-
-	// Test int
-    assert(excel_int(new_excel_number(8.9)).number == 8.0);
-    assert(excel_int(new_excel_number(-8.9)).number == -9.0);
-
-	// Test roundup
-    assert(roundup(new_excel_number(1.1), new_excel_number(0)).number == 2.0);
-    assert(roundup(new_excel_number(1.5), new_excel_number(0)).number == 2.0);
-    assert(roundup(new_excel_number(1.56),new_excel_number(1)).number == 1.6);
-    assert(roundup(new_excel_number(-1.56),new_excel_number(1)).number == -1.6);	
-	
-	// Test string joining
-	ExcelValue string_join_array_1[] = {new_excel_string("Hello "), new_excel_string("world")};
-	ExcelValue string_join_array_2[] = {new_excel_string("Hello "), new_excel_string("world"), new_excel_string("!")};
-	ExcelValue string_join_array_3[] = {new_excel_string("Top "), new_excel_number(10.0)};
-	ExcelValue string_join_array_4[] = {new_excel_string("Top "), new_excel_number(10.5)};	
-	ExcelValue string_join_array_5[] = {new_excel_string("Top "), TRUE, FALSE};	
-	// ... should return a string by combining its arguments
-	// inspect_excel_value(string_join(2, string_join_array_1));
-  assert(string_join(2, string_join_array_1).string[6] == 'w');
-  assert(string_join(2, string_join_array_1).string[11] == '\0');
-	// ... should cope with an arbitrary number of arguments
-  assert(string_join(3, string_join_array_2).string[11] == '!');
-  assert(string_join(3, string_join_array_3).string[12] == '\0');
-	// ... should convert values to strings as it goes
-  assert(string_join(2, string_join_array_3).string[4] == '1');
-  assert(string_join(2, string_join_array_3).string[5] == '0');
-  assert(string_join(2, string_join_array_3).string[6] == '\0');
-	// ... should convert integer values into strings without decimal points, and float values with decimal points
-  assert(string_join(2, string_join_array_4).string[4] == '1');
-  assert(string_join(2, string_join_array_4).string[5] == '0');
-  assert(string_join(2, string_join_array_4).string[6] == '.');
-  assert(string_join(2, string_join_array_4).string[7] == '5');
-  assert(string_join(2, string_join_array_4).string[8] == '\0');
-	// ... should convert TRUE and FALSE into strings
-  assert(string_join(3,string_join_array_5).string[4] == 'T');
-  // Should deal with very long string joins
-	ExcelValue string_join_array_6[] = {new_excel_string("0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"), new_excel_string("012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789")};
-  assert(string_join(2, string_join_array_6).string[0] == '0');
-  free_all_allocated_memory();
-	
-  // Test SUBTOTAL function
-  ExcelValue subtotal_array_1[] = {new_excel_number(10),new_excel_number(100),BLANK};
-  ExcelValue subtotal_array_1_v = new_excel_range(subtotal_array_1,3,1);
-  ExcelValue subtotal_array_2[] = {new_excel_number(1),new_excel_string("two"),subtotal_array_1_v};
-  
-  // new_excel_number(1.0); 
-  // inspect_excel_value(new_excel_number(1.0)); 
-  // inspect_excel_value(new_excel_range(subtotal_array_2,3,1)); 
-  // inspect_excel_value(subtotal(new_excel_number(1.0),3,subtotal_array_2)); 
-  
-  assert(subtotal(new_excel_number(1.0),3,subtotal_array_2).number == 111.0/3.0);
-  assert(subtotal(new_excel_number(2.0),3,subtotal_array_2).number == 3);
-  assert(subtotal(new_excel_number(3.0),7, count_a_test_array_1).number == 6);
-  assert(subtotal(new_excel_number(3.0),3,subtotal_array_2).number == 4);
-  assert(subtotal(new_excel_number(9.0),3,subtotal_array_2).number == 111);
-  assert(subtotal(new_excel_number(101.0),3,subtotal_array_2).number == 111.0/3.0);
-  assert(subtotal(new_excel_number(102.0),3,subtotal_array_2).number == 3);
-  assert(subtotal(new_excel_number(103.0),3,subtotal_array_2).number == 4);
-  assert(subtotal(new_excel_number(109.0),3,subtotal_array_2).number == 111);
-  
-  // Test SUMIFS function
-  ExcelValue sumifs_array_1[] = {new_excel_number(10),new_excel_number(100),BLANK};
-  ExcelValue sumifs_array_1_v = new_excel_range(sumifs_array_1,3,1);
-  ExcelValue sumifs_array_2[] = {new_excel_string("pear"),new_excel_string("bear"),new_excel_string("apple")};
-  ExcelValue sumifs_array_2_v = new_excel_range(sumifs_array_2,3,1);
-  ExcelValue sumifs_array_3[] = {new_excel_number(1),new_excel_number(2),new_excel_number(3),new_excel_number(4),new_excel_number(5),new_excel_number(5)};
-  ExcelValue sumifs_array_3_v = new_excel_range(sumifs_array_3,6,1);
-  ExcelValue sumifs_array_4[] = {new_excel_string("CO2"),new_excel_string("CH4"),new_excel_string("N2O"),new_excel_string("CH4"),new_excel_string("N2O"),new_excel_string("CO2")};
-  ExcelValue sumifs_array_4_v = new_excel_range(sumifs_array_4,6,1);
-  ExcelValue sumifs_array_5[] = {new_excel_string("1A"),new_excel_string("1A"),new_excel_string("1A"),new_excel_number(4),new_excel_number(4),new_excel_number(5)};
-  ExcelValue sumifs_array_5_v = new_excel_range(sumifs_array_5,6,1);
-  
-  // ... should only sum values that meet all of the criteria
-  ExcelValue sumifs_array_6[] = { sumifs_array_1_v, new_excel_number(10), sumifs_array_2_v, new_excel_string("Bear") };
-  assert(sumifs(sumifs_array_1_v,4,sumifs_array_6).number == 0.0);
-  
-  ExcelValue sumifs_array_7[] = { sumifs_array_1_v, new_excel_number(10), sumifs_array_2_v, new_excel_string("Pear") };
-  assert(sumifs(sumifs_array_1_v,4,sumifs_array_7).number == 10.0);
-  
-  // ... should work when single cells are given where ranges expected
-  ExcelValue sumifs_array_8[] = { new_excel_string("CAR"), new_excel_string("CAR"), new_excel_string("FCV"), new_excel_string("FCV")};
-  assert(sumifs(new_excel_number(0.143897265452564), 4, sumifs_array_8).number == 0.143897265452564);
-
-  // ... should match numbers with strings that contain numbers
-  ExcelValue sumifs_array_9[] = { new_excel_number(10), new_excel_string("10.0")};
-  assert(sumifs(new_excel_number(100),2,sumifs_array_9).number == 100);
-  
-  ExcelValue sumifs_array_10[] = { sumifs_array_4_v, new_excel_string("CO2"), sumifs_array_5_v, new_excel_number(2)};
-  assert(sumifs(sumifs_array_3_v,4, sumifs_array_10).number == 0);
-  
-  // ... should match with strings that contain criteria
-  ExcelValue sumifs_array_10a[] = { sumifs_array_3_v, new_excel_string("=5")};
-  assert(sumifs(sumifs_array_3_v,2, sumifs_array_10a).number == 10);
-
-  ExcelValue sumifs_array_10b[] = { sumifs_array_3_v, new_excel_string("<>3")};
-  assert(sumifs(sumifs_array_3_v,2, sumifs_array_10b).number == 17);
-
-  ExcelValue sumifs_array_10c[] = { sumifs_array_3_v, new_excel_string("<3")};
-  assert(sumifs(sumifs_array_3_v,2, sumifs_array_10c).number == 3);
-  
-  ExcelValue sumifs_array_10d[] = { sumifs_array_3_v, new_excel_string("<=3")};
-  assert(sumifs(sumifs_array_3_v,2, sumifs_array_10d).number == 6);
-
-  ExcelValue sumifs_array_10e[] = { sumifs_array_3_v, new_excel_string(">3")};
-  assert(sumifs(sumifs_array_3_v,2, sumifs_array_10e).number == 14);
-
-  ExcelValue sumifs_array_10f[] = { sumifs_array_3_v, new_excel_string(">=3")};
-  assert(sumifs(sumifs_array_3_v,2, sumifs_array_10f).number == 17);
-  
-  // ... should treat BLANK as an empty string when in the check_range, but not in the criteria
-  ExcelValue sumifs_array_11[] = { BLANK, new_excel_number(20)};
-  assert(sumifs(new_excel_number(100),2,sumifs_array_11).number == 0);
-  
-  ExcelValue sumifs_array_12[] = {BLANK, new_excel_string("")};
-  assert(sumifs(new_excel_number(100),2,sumifs_array_12).number == 100);
-  
-  ExcelValue sumifs_array_13[] = {BLANK, BLANK};
-  assert(sumifs(new_excel_number(100),2,sumifs_array_13).number == 0);
-    
-  // ... should return an error if range argument is an error
-  assert(sumifs(REF,2,sumifs_array_13).type == ExcelError);
-  
-  
-  // Test SUMIF
-  // ... where there is only a check range
-  assert(sumif_2(sumifs_array_1_v,new_excel_string(">0")).number == 110.0);
-  assert(sumif_2(sumifs_array_1_v,new_excel_string(">10")).number == 100.0);
-  assert(sumif_2(sumifs_array_1_v,new_excel_string("<100")).number == 10.0);
-  
-  // ... where there is a seprate sum range
-  ExcelValue sumif_array_1[] = {new_excel_number(15),new_excel_number(20), new_excel_number(30)};
-  ExcelValue sumif_array_1_v = new_excel_range(sumif_array_1,3,1);
-  assert(sumif(sumifs_array_1_v,new_excel_string("10"),sumif_array_1_v).number == 15);
-  
-  
-  // Test SUMPRODUCT
-  ExcelValue sumproduct_1[] = { new_excel_number(10), new_excel_number(100), BLANK};
-  ExcelValue sumproduct_2[] = { BLANK, new_excel_number(100), new_excel_number(10), BLANK};
-  ExcelValue sumproduct_3[] = { BLANK };
-  ExcelValue sumproduct_4[] = { new_excel_number(10), new_excel_number(100), new_excel_number(1000)};
-  ExcelValue sumproduct_5[] = { new_excel_number(1), new_excel_number(2), new_excel_number(3)};
-  ExcelValue sumproduct_6[] = { new_excel_number(1), new_excel_number(2), new_excel_number(4), new_excel_number(5)};
-  ExcelValue sumproduct_7[] = { new_excel_number(10), new_excel_number(20), new_excel_number(40), new_excel_number(50)};
-  ExcelValue sumproduct_8[] = { new_excel_number(11), new_excel_number(21), new_excel_number(41), new_excel_number(51)};
-  ExcelValue sumproduct_9[] = { BLANK, BLANK };
-  
-  ExcelValue sumproduct_1_v = new_excel_range( sumproduct_1, 3, 1);
-  ExcelValue sumproduct_2_v = new_excel_range( sumproduct_2, 3, 1);
-  ExcelValue sumproduct_3_v = new_excel_range( sumproduct_3, 1, 1);
-  // ExcelValue sumproduct_4_v = new_excel_range( sumproduct_4, 1, 3); // Unused
-  ExcelValue sumproduct_5_v = new_excel_range( sumproduct_5, 3, 1);
-  ExcelValue sumproduct_6_v = new_excel_range( sumproduct_6, 2, 2);
-  ExcelValue sumproduct_7_v = new_excel_range( sumproduct_7, 2, 2);
-  ExcelValue sumproduct_8_v = new_excel_range( sumproduct_8, 2, 2);
-  ExcelValue sumproduct_9_v = new_excel_range( sumproduct_9, 2, 1);
-  
-  // ... should multiply together and then sum the elements in row or column areas given as arguments
-  ExcelValue sumproducta_1[] = {sumproduct_1_v, sumproduct_2_v};
-  assert(sumproduct(2,sumproducta_1).number == 100*100);
-
-  // ... should return :value when miss-matched array sizes
-  ExcelValue sumproducta_2[] = {sumproduct_1_v, sumproduct_3_v};
-  assert(sumproduct(2,sumproducta_2).type == ExcelError);
-
-  // ... if all its arguments are single values, should multiply them together
-  // ExcelValue *sumproducta_3 = sumproduct_4;
-  assert(sumproduct(3,sumproduct_4).number == 10*100*1000);
-
-  // ... if it only has one range as an argument, should add its elements together
-  ExcelValue sumproducta_4[] = {sumproduct_5_v};
-  assert(sumproduct(1,sumproducta_4).number == 1 + 2 + 3);
-
-  // ... if given multi row and column areas as arguments, should multipy the corresponding cell in each area and then add them all
-  ExcelValue sumproducta_5[] = {sumproduct_6_v, sumproduct_7_v, sumproduct_8_v};
-  assert(sumproduct(3,sumproducta_5).number == 1*10*11 + 2*20*21 + 4*40*41 + 5*50*51);
-
-  // ... should raise an error if BLANK values outside of an array
-  ExcelValue sumproducta_6[] = {BLANK,new_excel_number(1)};
-  assert(sumproduct(2,sumproducta_6).type == ExcelError);
-
-  // ... should ignore non-numeric values within an array
-  ExcelValue sumproducta_7[] = {sumproduct_9_v, sumproduct_9_v};
-  assert(sumproduct(2,sumproducta_7).number == 0);
-
-  // ... should return an error if an argument is an error
-  ExcelValue sumproducta_8[] = {VALUE};
-  assert(sumproduct(1,sumproducta_8).type == ExcelError);
-  
-  // Test VLOOKUP
-  ExcelValue vlookup_a1[] = {new_excel_number(1),new_excel_number(10),new_excel_number(2),new_excel_number(20),new_excel_number(3),new_excel_number(30)};
-  ExcelValue vlookup_a2[] = {new_excel_string("hello"),new_excel_number(10),new_excel_number(2),new_excel_number(20),new_excel_number(3),new_excel_number(30)};
-  ExcelValue vlookup_a3[] = {BLANK,new_excel_number(10),new_excel_number(2),new_excel_number(20),new_excel_number(3),new_excel_number(30)};
-  ExcelValue vlookup_a1_v = new_excel_range(vlookup_a1,3,2);
-  ExcelValue vlookup_a2_v = new_excel_range(vlookup_a2,3,2);
-  ExcelValue vlookup_a3_v = new_excel_range(vlookup_a3,3,2);
-  // ... should match the first argument against the first column of the table in the second argument, returning the value in the column specified by the third argument
-  assert(vlookup_3(new_excel_number(2.0),vlookup_a1_v,new_excel_number(2)).number == 20);
-  assert(vlookup_3(new_excel_number(1.5),vlookup_a1_v,new_excel_number(2)).number == 10);
-  assert(vlookup_3(new_excel_number(0.5),vlookup_a1_v,new_excel_number(2)).type == ExcelError);
-  assert(vlookup_3(new_excel_number(10),vlookup_a1_v,new_excel_number(2)).number == 30);
-  assert(vlookup_3(new_excel_number(2.6),vlookup_a1_v,new_excel_number(2)).number == 20);
-  // ... has a four argument variant that matches the lookup type
-  assert(vlookup(new_excel_number(2.6),vlookup_a1_v,new_excel_number(2),TRUE).number == 20);
-  assert(vlookup(new_excel_number(2.6),vlookup_a1_v,new_excel_number(2),FALSE).type == ExcelError);
-  assert(vlookup(new_excel_string("HELLO"),vlookup_a2_v,new_excel_number(2),FALSE).number == 10);
-  assert(vlookup(new_excel_string("HELMP"),vlookup_a2_v,new_excel_number(2),TRUE).number == 10);
-  // .. the four argument variant should accept 0 and 1 instead of TRUE and FALSE
-  assert(vlookup(new_excel_string("HELLO"),vlookup_a2_v,new_excel_number(2),ZERO).number == 10);
-  assert(vlookup(new_excel_string("HELMP"),vlookup_a2_v,new_excel_number(2),ONE).number == 10);
-  // ... BLANK should not match with anything" do
-  assert(vlookup_3(BLANK,vlookup_a3_v,new_excel_number(2)).type == ExcelError);
-  // ... should return an error if an argument is an error" do
-  assert(vlookup(VALUE,vlookup_a1_v,new_excel_number(2),FALSE).type == ExcelError);
-  assert(vlookup(new_excel_number(2.0),VALUE,new_excel_number(2),FALSE).type == ExcelError);
-  assert(vlookup(new_excel_number(2.0),vlookup_a1_v,VALUE,FALSE).type == ExcelError);
-  assert(vlookup(new_excel_number(2.0),vlookup_a1_v,new_excel_number(2),VALUE).type == ExcelError);
-  assert(vlookup(VALUE,VALUE,VALUE,VALUE).type == ExcelError);
-	
-  // Test HLOOKUP
-  ExcelValue hlookup_a1[] = {new_excel_number(1),new_excel_number(2),new_excel_number(3),new_excel_number(10),new_excel_number(20),new_excel_number(30)};
-  ExcelValue hlookup_a2[] = {new_excel_string("hello"),new_excel_number(2),new_excel_number(3),new_excel_number(10),new_excel_number(20),new_excel_number(30)};
-  ExcelValue hlookup_a3[] = {BLANK,new_excel_number(2),new_excel_number(3),new_excel_number(10),new_excel_number(20),new_excel_number(30)};
-  ExcelValue hlookup_a1_v = new_excel_range(hlookup_a1,2,3);
-  ExcelValue hlookup_a2_v = new_excel_range(hlookup_a2,2,3);
-  ExcelValue hlookup_a3_v = new_excel_range(hlookup_a3,2,3);
-  // ... should match the first argument against the first column of the table in the second argument, returning the value in the column specified by the third argument
-  assert(hlookup_3(new_excel_number(2.0),hlookup_a1_v,new_excel_number(2)).number == 20);
-  assert(hlookup_3(new_excel_number(1.5),hlookup_a1_v,new_excel_number(2)).number == 10);
-  assert(hlookup_3(new_excel_number(0.5),hlookup_a1_v,new_excel_number(2)).type == ExcelError);
-  assert(hlookup_3(new_excel_number(10),hlookup_a1_v,new_excel_number(2)).number == 30);
-  assert(hlookup_3(new_excel_number(2.6),hlookup_a1_v,new_excel_number(2)).number == 20);
-  // ... has a four argument variant that matches the lookup type
-  assert(hlookup(new_excel_number(2.6),hlookup_a1_v,new_excel_number(2),TRUE).number == 20);
-  assert(hlookup(new_excel_number(2.6),hlookup_a1_v,new_excel_number(2),FALSE).type == ExcelError);
-  assert(hlookup(new_excel_string("HELLO"),hlookup_a2_v,new_excel_number(2),FALSE).number == 10);
-  assert(hlookup(new_excel_string("HELMP"),hlookup_a2_v,new_excel_number(2),TRUE).number == 10);
-  // ... that four argument variant should accept 0 or 1 for the lookup type
-  assert(hlookup(new_excel_number(2.6),hlookup_a1_v,new_excel_number(2),ONE).number == 20);
-  assert(hlookup(new_excel_number(2.6),hlookup_a1_v,new_excel_number(2),ZERO).type == ExcelError);
-  assert(hlookup(new_excel_string("HELLO"),hlookup_a2_v,new_excel_number(2),ZERO).number == 10);
-  assert(hlookup(new_excel_string("HELMP"),hlookup_a2_v,new_excel_number(2),ONE).number == 10);
-  // ... BLANK should not match with anything" do
-  assert(hlookup_3(BLANK,hlookup_a3_v,new_excel_number(2)).type == ExcelError);
-  // ... should return an error if an argument is an error" do
-  assert(hlookup(VALUE,hlookup_a1_v,new_excel_number(2),FALSE).type == ExcelError);
-  assert(hlookup(new_excel_number(2.0),VALUE,new_excel_number(2),FALSE).type == ExcelError);
-  assert(hlookup(new_excel_number(2.0),hlookup_a1_v,VALUE,FALSE).type == ExcelError);
-  assert(hlookup(new_excel_number(2.0),hlookup_a1_v,new_excel_number(2),VALUE).type == ExcelError);
-  assert(hlookup(VALUE,VALUE,VALUE,VALUE).type == ExcelError);
-
-  // Test SUM
-  ExcelValue sum_array_0[] = {new_excel_number(1084.4557258064517),new_excel_number(32.0516914516129),new_excel_number(137.36439193548387)};
-  ExcelValue sum_array_0_v = new_excel_range(sum_array_0,3,1);
-  ExcelValue sum_array_1[] = {sum_array_0_v};
-  assert(sum(1,sum_array_1).number == 1253.8718091935484);
-
-  // Test PV
-  assert((int) pv_3(new_excel_number(0.03), new_excel_number(12), new_excel_number(100)).number == -995);
-  assert((int) pv_4(new_excel_number(0.03), new_excel_number(12), new_excel_number(-100), new_excel_number(100)).number == 925);
-  assert((int) pv_5(new_excel_number(0.03), new_excel_number(12), new_excel_number(-100), new_excel_number(-100), new_excel_number(1)).number == 1095);
-  
-  // Test TEXT
-  assert(strcmp(text(new_excel_number(1.0), new_excel_string("0%")).string, "100%") == 0);
-  assert(strcmp(text(new_excel_string("1"), new_excel_string("0%")).string, "100%") == 0);
-  assert(strcmp(text(BLANK, new_excel_string("0%")).string, "0%") == 0);
-  assert(strcmp(text(new_excel_number(1.0), BLANK).string, "") == 0);
-  assert(strcmp(text(new_excel_string("ASGASD"), new_excel_string("0%")).string, "ASGASD") == 0);
-
-  // Test LOG
-  // One argument variant assumes LOG base 10
-	assert(excel_log(new_excel_number(10)).number == 1);
-	assert(excel_log(new_excel_number(100)).number == 2);
-	assert(excel_log(new_excel_number(0)).type == ExcelError);
-  // Two argument variant allows LOG base to be specified
-	assert(excel_log_2(new_excel_number(8),new_excel_number(2)).number == 3.0);
-	assert(excel_log_2(new_excel_number(8),new_excel_number(0)).type == ExcelError);
-  
-  // Test MMULT (Matrix multiplication)
-  ExcelValue mmult_1[] = { ONE, TWO, THREE, FOUR};
-  ExcelValue mmult_2[] = { FOUR, THREE, TWO, ONE};
-  ExcelValue mmult_3[] = { ONE, TWO};
-  ExcelValue mmult_4[] = { THREE, FOUR};
-  ExcelValue mmult_5[] = { ONE, BLANK, THREE, FOUR};
-
-  ExcelValue mmult_1_v = new_excel_range( mmult_1, 2, 2);
-  ExcelValue mmult_2_v = new_excel_range( mmult_2, 2, 2);
-  ExcelValue mmult_3_v = new_excel_range( mmult_3, 1, 2);
-  ExcelValue mmult_4_v = new_excel_range( mmult_4, 2, 1);
-  ExcelValue mmult_5_v = new_excel_range( mmult_5, 2, 2);
-
-  // Treat the ranges as matrices and multiply them
-  ExcelValue mmult_result_1_v = mmult(mmult_1_v, mmult_2_v);
-  assert(mmult_result_1_v.type == ExcelRange);
-  assert(mmult_result_1_v.rows == 2);
-  assert(mmult_result_1_v.columns == 2);
-  ExcelValue *mmult_result_1_a = mmult_result_1_v.array;
-  assert(mmult_result_1_a[0].number == 8);
-  assert(mmult_result_1_a[1].number == 5);
-  assert(mmult_result_1_a[2].number == 20);
-  assert(mmult_result_1_a[3].number == 13);
-  
-  ExcelValue mmult_result_2_v = mmult(mmult_3_v, mmult_4_v);
-  assert(mmult_result_2_v.type == ExcelRange);
-  assert(mmult_result_2_v.rows == 1);
-  assert(mmult_result_2_v.columns == 1);
-  ExcelValue *mmult_result_2_a = mmult_result_2_v.array;
-  assert(mmult_result_2_a[0].number == 11);
-
-  // Return an error if any cells are not numbers
-  ExcelValue mmult_result_3_v = mmult(mmult_5_v, mmult_2_v);
-  assert(mmult_result_3_v.type == ExcelRange);
-  assert(mmult_result_3_v.rows == 2);
-  assert(mmult_result_3_v.columns == 2);
-  ExcelValue *mmult_result_3_a = mmult_result_3_v.array;
-  assert(mmult_result_3_a[0].type == ExcelError);
-  assert(mmult_result_3_a[1].type == ExcelError);
-  assert(mmult_result_3_a[2].type == ExcelError);
-  assert(mmult_result_3_a[3].type == ExcelError);
-  
-  // Returns errors if arguments are not ranges
-  // FIXME: Should work in edge case where passed two numbers which excel treats as ranges with one row and column
-  ExcelValue mmult_result_4_v = mmult(ONE, mmult_2_v);
-  assert(mmult_result_4_v.type == ExcelError);
-  
-  // Returns errors if the ranges aren't the right size to multiply
-  ExcelValue mmult_result_5_v = mmult(mmult_1_v, mmult_3_v);
-  assert(mmult_result_5_v.type == ExcelRange);
-  assert(mmult_result_5_v.rows == 2);
-  assert(mmult_result_5_v.columns == 2);
-  ExcelValue *mmult_result_5_a = mmult_result_5_v.array;
-  assert(mmult_result_5_a[0].type == ExcelError);
-  assert(mmult_result_5_a[1].type == ExcelError);
-  assert(mmult_result_5_a[2].type == ExcelError);
-  assert(mmult_result_5_a[3].type == ExcelError);
-
-  // Test the RANK() function
-  ExcelValue rank_1_a[] = { FIVE, BLANK, THREE, ONE, ONE, FOUR, FIVE, TRUE, SIX, new_excel_string("Hi")};
-  ExcelValue rank_2_a[] = { FIVE, BLANK, THREE, NA, ONE, FOUR, FIVE, TRUE, SIX, new_excel_string("Hi")};
-  ExcelValue rank_1_v = new_excel_range( rank_1_a, 2, 5);
-  ExcelValue rank_2_v = new_excel_range( rank_2_a, 2, 5);
-
-  // Basics
-  assert(rank(THREE, rank_1_v, ZERO).number == 5);
-  assert(rank_2(THREE, rank_1_v).number == 5);
-  assert(rank(THREE, rank_1_v, ONE).number == 3);
-  assert(rank(ONE, rank_1_v, ZERO).number == 6);
-  assert(rank(new_excel_string("3"), rank_1_v, ONE).number == 3);
-
-  // Errors
-  assert(rank(TEN, rank_1_v, ZERO).type == ExcelError);
-  assert(rank(THREE, rank_2_v, ZERO).type == ExcelError);
-
-
-  // Test the ISNUMBER function
-  assert(excel_isnumber(ONE).type == ExcelBoolean);
-  assert(excel_isnumber(ONE).number == 1);
-  assert(excel_isnumber(BLANK).type == ExcelBoolean);
-  assert(excel_isnumber(BLANK).number == 0);
-  assert(excel_isnumber(new_excel_string("Hello")).type == ExcelBoolean);
-  assert(excel_isnumber(new_excel_string("Hello")).number == 0);
-  assert(excel_isnumber(TRUE).type == ExcelBoolean);
-  assert(excel_isnumber(TRUE).number == 0);
-
-  // Release memory
-  free_all_allocated_memory();
-  
-  return 0;
-}
-
-int main() {
-	return test_functions();
-}