excel_to_code 0.3.4 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9a337c16718282fa8bbce1da4a51cb81d2ad6651
-  data.tar.gz: fbfa6de417b5b4f8fe626244b234876cd00f430c
+  metadata.gz: 1b7eaef5e426ea529d3b33d237e2d41adc37c305
+  data.tar.gz: ac576e8a20ca8bc58f9839c1018f45210cc9d0a6
 SHA512:
-  metadata.gz: cf150004e0ad6ad4cf8d17d4abc740c4b5e33e3224c39091a2d9b9edc65d4e66de2ba047446c9cbc04fe7c33f680ed156300dc10ca568f38e7c6e97a70896a7e
-  data.tar.gz: 28bbe1191e5da2bbcbc63d4bda866f6f1720c619212659d6aeaece6c9e21baa7597b95ec7e6d77718895ff9bed54f9cc07c4cd5674a8918fb73874ebfbd12044
+  metadata.gz: adb264736922ee868d1890cc9c390e8d34e29e4f31aa6be954a3980f49f5d9a02510d609ab1e72436be78ec6ad79359b0d5868d0e202e8732ffa837f535557be
+  data.tar.gz: 4ce4a712b27076f76ae665dd158e0b7153ebdfea42643a8f8568bf4c8eeb58f0c7c7e6d84c4a33a13580f1a0781072f1bdff03a0406386998f304f6218f2c994

data/bin/excel_to_c

@@ -74,6 +74,10 @@ END
     command.create_rakefile = false
   end
 
+  opts.on('--write-tests-in-c', "Write tests in pure C (normally written in ruby") do
+    command.write_tests_in_c = true
+  end
+
   opts.on("-h", "--help", "Show this message") do
     puts opts
     exit

data/src/commands/excel_to_c.rb

@@ -8,11 +8,14 @@ class ExcelToC < ExcelToX
   attr_accessor :create_rakefile
   # If true, creates a Makefile, if false, doesn't (default false)
   attr_accessor :create_makefile
+  # If true, writes tests in C rather than in ruby
+  attr_accessor :write_tests_in_c
   
   def set_defaults
     super
     @create_rakefile = true if @create_rakefile == nil
     @create_makefile = false if @create_makefile == nil
+    @write_tests_in_c = false if @write_tests_in_c == nil
   end
 
   def language
@@ -24,7 +27,10 @@ class ExcelToC < ExcelToX
     write_out_excel_as_code
     write_build_script
     write_fuby_ffi_interface
-    write_tests
+    if write_tests_in_c
+      write_tests_as_c
+    end
+    write_tests_as_ruby
   end
     
   def write_out_excel_as_code
@@ -352,8 +358,8 @@ END
     close(o)
   end
   
-  def write_tests
-    log.info "Writing tests" 
+  def write_tests_as_ruby
+    log.info "Writing tests in ruby" 
 
     name = output_name.downcase
     o = output("test_#{name}.rb")    
@@ -370,11 +376,27 @@ END
     o.puts "  def worksheet; @worksheet ||= init_spreadsheet; end"
     o.puts "  def init_spreadsheet; #{ruby_module_name}.new end"
     
-    CompileToCUnitTest.rewrite(Hash[@references_to_test_array], sloppy_tests, @worksheet_c_names, @constants, o)
+    CompileToRubyUnitTest.rewrite(Hash[@references_to_test_array], sloppy_tests, @worksheet_c_names, @constants, o)
     o.puts "end"
     close(o)
   end
 
+  def write_tests_as_c
+    log.info "Writing tests in C" 
+
+    name = output_name.downcase
+    o = output("test_#{name}.c")    
+    o.puts "#include \"#{name}.c\""
+    o.puts "int main() {"
+    o.puts "  printf(\"\\n\\nRunning tests on #{name}\\n\\n\");"
+    CompileToCUnitTest.rewrite(Hash[@references_to_test_array], sloppy_tests, @worksheet_c_names, @constants, o)
+    o.puts "  free_all_allocated_memory();"
+    o.puts "  printf(\"\\n\\nFinished tests on #{name}\\n\\n\");"
+    o.puts "  return 0;"
+    o.puts "}"
+    close(o)
+  end
+  
   
   def compile_code
     return unless actually_compile_code || actually_run_tests
@@ -386,7 +408,10 @@ END
   
   def run_tests
     return unless actually_run_tests
-    puts "Running the resulting tests"
+    log.info "Running the resulting tests"
+    if write_tests_as_c
+      puts `cd #{File.join(output_directory)}; gcc "test_#{output_name.downcase}.c"; ./a.out`
+    end
     puts `cd #{File.join(output_directory)}; ruby "test_#{output_name.downcase}.rb"`
   end
   

data/src/commands/excel_to_ruby.rb

@@ -94,7 +94,7 @@ class ExcelToRuby < ExcelToX
     o.puts "class Test#{ruby_module_name} < Minitest::Unit::TestCase"
     o.puts "  def worksheet; @worksheet ||= #{ruby_module_name}.new; end"
 
-    CompileToCUnitTest.rewrite(Hash[@references_to_test_array], sloppy_tests, @worksheet_c_names, @constants, o)
+    CompileToRubyUnitTest.rewrite(Hash[@references_to_test_array], sloppy_tests, @worksheet_c_names, @constants, o)
 
     o.puts "end"   
     close(o)

data/src/commands/excel_to_x.rb

@@ -1032,6 +1032,11 @@ class ExcelToX
         end
       end
 
+      @named_references.each do |ref, ast|
+        inline_replacer.current_sheet_name = ref.is_a?(Array) ? [ref.first] : []
+        inline_replacer.map(ast)
+      end
+
       simplify(references_that_need_updating)
 
       replacements_made_in_the_last_pass += inline_replacer.count_replaced
@@ -1209,6 +1214,10 @@ class ExcelToX
       r.map(ast)
     end
 
+    @named_references.each do |ref, ast|
+      r.map(ast)
+    end
+
     @constants = r.constants.invert
   end
   

data/src/compile/c/a.out.dSYM/Contents/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+	<dict>
+		<key>CFBundleDevelopmentRegion</key>
+		<string>English</string>
+		<key>CFBundleIdentifier</key>
+		<string>com.apple.xcode.dsym.a.out</string>
+		<key>CFBundleInfoDictionaryVersion</key>
+		<string>6.0</string>
+		<key>CFBundlePackageType</key>
+		<string>dSYM</string>
+		<key>CFBundleSignature</key>
+		<string>????</string>
+		<key>CFBundleShortVersionString</key>
+		<string>1.0</string>
+		<key>CFBundleVersion</key>
+		<string>1</string>
+	</dict>
+</plist>

data/src/compile/c/compile_to_c_unit_test.rb

@@ -1,7 +1,21 @@
-require_relative "../ruby/compile_to_ruby_unit_test"
+require_relative "map_values_to_c"
 
-class CompileToCUnitTest < CompileToRubyUnitTest
+class CompileToCUnitTest
 
-  # Now produces tests just like the Ruby version
+  def self.rewrite(*args)
+    self.new.rewrite(*args)
+  end
+  
+  def rewrite(input, sloppy, sheet_names, constants,  o)
+    mapper = MapValuesToC.new
+    input.each do |ref, ast|
+      worksheet_c_name = sheet_names[ref.first.to_s] || ref.first.to_s #FIXME: Need to make it the actual c_name
+      cell = ref.last
+      value = mapper.map(ast)
+      full_reference = worksheet_c_name.length > 0 ? "#{worksheet_c_name}_#{cell.downcase}()" : "#{cell.downcase}()"
+      test_name = "'#{ref.first.to_s}'!#{cell.upcase}"
+      o.puts "  assert_equal(#{value}, #{full_reference}, #{test_name.inspect});"
+    end
+  end
   
 end

data/src/compile/c/excel_to_c_runtime.c

@@ -149,9 +149,9 @@ void reset() {
 
 // 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})
+#define EXCEL_NUMBER(numberdouble) ((ExcelValue) {.type = ExcelNumber, .number = numberdouble})
+#define EXCEL_STRING(stringchar) ((ExcelValue) {.type = ExcelString, .string = stringchar})
+#define 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
@@ -305,7 +305,7 @@ static ExcelValue add(ExcelValue a_v, ExcelValue b_v) {
 	NUMBER(a_v, a)
 	NUMBER(b_v, b)
 	CHECK_FOR_CONVERSION_ERROR
-	return new_excel_number(a + b);
+	return EXCEL_NUMBER(a + b);
 }
 
 static ExcelValue ensure_is_number(ExcelValue maybe_number_v) {
@@ -317,7 +317,7 @@ static ExcelValue ensure_is_number(ExcelValue maybe_number_v) {
   }
   NUMBER(maybe_number_v, maybe_number)
 	CHECK_FOR_CONVERSION_ERROR
-	return new_excel_number(maybe_number);
+	return EXCEL_NUMBER(maybe_number);
 }
 
 static ExcelValue excel_log(ExcelValue number) {
@@ -334,7 +334,7 @@ static ExcelValue excel_log_2(ExcelValue number_v, ExcelValue base_v) {
   if(n<=0) { return NUM; }
   if(b<=0) { return NUM; }
 
-  return	new_excel_number(log(n)/log(b));
+  return	EXCEL_NUMBER(log(n)/log(b));
 }
 
 static ExcelValue ln(ExcelValue number_v) {
@@ -344,7 +344,7 @@ static ExcelValue ln(ExcelValue number_v) {
 
   if(n<=0) { return NUM; }
 
-  return	new_excel_number(log(n));
+  return	EXCEL_NUMBER(log(n));
 }
 
 static ExcelValue excel_exp(ExcelValue number_v) {
@@ -352,7 +352,7 @@ static ExcelValue excel_exp(ExcelValue number_v) {
 	NUMBER(number_v, n)
 	CHECK_FOR_CONVERSION_ERROR
 
-  return	new_excel_number(exp(n));
+  return	EXCEL_NUMBER(exp(n));
 }
 
 static ExcelValue excel_and(int array_size, ExcelValue *array) {
@@ -430,7 +430,7 @@ static ExcelValue average(int array_size, ExcelValue *array) {
 	struct average_result r = calculate_average(array_size, array);
 	if(r.has_error == true) return r.error;
 	if(r.count == 0) return DIV0;
-	return new_excel_number(r.sum/r.count);
+	return EXCEL_NUMBER(r.sum/r.count);
 }
 
 static ExcelValue forecast(ExcelValue required_x_v, ExcelValue known_y, ExcelValue known_x) {
@@ -498,7 +498,7 @@ static ExcelValue forecast(ExcelValue required_x_v, ExcelValue known_y, ExcelVal
   b = b_numerator / b_denominator;
   a = mean_y.number - (b*mean_x.number);
 
-  return new_excel_number(a + (b*required_x));
+  return EXCEL_NUMBER(a + (b*required_x));
 }
 
 static ExcelValue choose(ExcelValue index_v, int array_size, ExcelValue *array) {
@@ -536,7 +536,7 @@ static ExcelValue count(int array_size, ExcelValue *array) {
 			 break;
 		 }
 	 }
-	 return new_excel_number(n);
+	 return EXCEL_NUMBER(n);
 }
 
 static ExcelValue counta(int array_size, ExcelValue *array) {
@@ -560,7 +560,7 @@ static ExcelValue counta(int array_size, ExcelValue *array) {
   		  break;
     }
 	 }
-	 return new_excel_number(n);
+	 return EXCEL_NUMBER(n);
 }
 
 static ExcelValue divide(ExcelValue a_v, ExcelValue b_v) {
@@ -570,7 +570,7 @@ static ExcelValue divide(ExcelValue a_v, ExcelValue b_v) {
 	NUMBER(b_v, b)
 	CHECK_FOR_CONVERSION_ERROR
 	if(b == 0) return DIV0;
-	return new_excel_number(a / b);
+	return EXCEL_NUMBER(a / b);
 }
 
 static ExcelValue excel_equal(ExcelValue a_v, ExcelValue b_v) {
@@ -580,17 +580,17 @@ static ExcelValue excel_equal(ExcelValue a_v, ExcelValue b_v) {
 	if(a_v.type != b_v.type) return FALSE;
 	
 	switch (a_v.type) {
-  	  case ExcelNumber:
+  	case ExcelNumber:
 	  case ExcelBoolean: 
 	  case ExcelEmpty: 
 			if(a_v.number != b_v.number) return FALSE;
 			return TRUE;
 	  case ExcelString:
 	  	if(strcasecmp(a_v.string,b_v.string) != 0 ) return FALSE;
-		return TRUE;
-  	  case ExcelError:
-		return a_v;
-  	  case ExcelRange:
+		  return TRUE;
+  	case ExcelError:
+		  return a_v;
+  	case ExcelRange:
   		return NA;
   }
   return FALSE;
@@ -694,7 +694,7 @@ static ExcelValue excel_index(ExcelValue array_v, ExcelValue row_number_v, Excel
 			}			
 			result_index++;
 		}
-		return new_excel_range(result,rows,1);
+		return EXCEL_RANGE(result,rows,1);
 	} else if(column_number == 0 ) { // We need the whole row
 		if(row_number < 1) return REF;
 		ExcelValue *result = (ExcelValue*) new_excel_value_array(columns);
@@ -712,7 +712,7 @@ static ExcelValue excel_index(ExcelValue array_v, ExcelValue row_number_v, Excel
 			}
 			result_index++;
 		}
-		return new_excel_range(result,1,columns);
+		return EXCEL_RANGE(result,1,columns);
 	} else { // We need a precise point
 		if(row_number < 1) return REF;
 		if(column_number < 1) return REF;
@@ -781,18 +781,18 @@ static ExcelValue large(ExcelValue range_v, ExcelValue k_v) {
   int i; 
   for(i = 0; i < range_size; i++ ) {
     x_v = array_v[i];
-    if(x_v.type == ExcelError) { return x_v; };
+    if(x_v.type == ExcelError) { free(sorted); return x_v; };
     if(x_v.type == ExcelNumber) {
       sorted[sorted_size] = x_v.number;
       sorted_size++;
     }
   }
   // Check other bound
-  if(k > sorted_size) { return NUM; }
+  if(k > sorted_size) { free(sorted); return NUM; }
 
   qsort(sorted, sorted_size, sizeof (double), compare_doubles);
 
-  ExcelValue result = new_excel_number(sorted[sorted_size - k]);
+  ExcelValue result = EXCEL_NUMBER(sorted[sorted_size - k]);
   free(sorted);
   return result;
 }
@@ -836,7 +836,7 @@ static ExcelValue excel_match(ExcelValue lookup_value, ExcelValue lookup_array,
 			for(i = 0; i < size; i++ ) {
 				x = array[i];
 				if(x.type == ExcelEmpty) x = ZERO;
-				if(excel_equal(lookup_value,x).number == true) return new_excel_number(i+1);
+				if(excel_equal(lookup_value,x).number == true) return EXCEL_NUMBER(i+1);
 			}
 			return NA;
 			break;
@@ -846,10 +846,10 @@ static ExcelValue excel_match(ExcelValue lookup_value, ExcelValue lookup_array,
 				if(x.type == ExcelEmpty) x = ZERO;
 				if(more_than(x,lookup_value).number == true) {
 					if(i==0) return NA;
-					return new_excel_number(i);
+					return EXCEL_NUMBER(i);
 				}
 			}
-			return new_excel_number(size);
+			return EXCEL_NUMBER(size);
 			break;
 		case -1:
 			for(i = 0; i < size; i++ ) {
@@ -857,10 +857,10 @@ static ExcelValue excel_match(ExcelValue lookup_value, ExcelValue lookup_array,
 				if(x.type == ExcelEmpty) x = ZERO;
 				if(less_than(x,lookup_value).number == true) {
 					if(i==0) return NA;
-					return new_excel_number(i);
+					return EXCEL_NUMBER(i);
 				}
 			}
-			return new_excel_number(size-1);
+			return EXCEL_NUMBER(size-1);
 			break;
 	}
 	return NA;
@@ -904,7 +904,7 @@ static ExcelValue find(ExcelValue find_text_v, ExcelValue within_text_v, ExcelVa
 	within_text_offset = within_text + (start_number - 1);
 	result = strstr(within_text_offset,find_text);
 	if(result) {
-		return new_excel_number(result - within_text + 1);
+		return EXCEL_NUMBER(result - within_text + 1);
 	}
 	return VALUE;
 }
@@ -929,10 +929,10 @@ static ExcelValue left(ExcelValue string_v, ExcelValue number_of_characters_v) {
 	char *string;
 	int string_must_be_freed = 0;
 	switch (string_v.type) {
-  	  case ExcelString:
+  	case ExcelString:
   		string = string_v.string;
   		break;
-  	  case ExcelNumber:
+  	case ExcelNumber:
 		  string = malloc(20); // Freed
 		  if(string == 0) {
 			  printf("Out of memory in left");
@@ -944,15 +944,19 @@ static ExcelValue left(ExcelValue string_v, ExcelValue number_of_characters_v) {
 	  case ExcelBoolean:
 	  	if(string_v.number == true) {
 	  		string = "TRUE";
-		} else {
-			string = "FALSE";
-		}
-		break;
+		  } else {
+			  string = "FALSE";
+		  }
+		  break;
 	  case ExcelEmpty:	  	 
-  	  case ExcelError:
-  	  case ExcelRange:
-		return string_v;
+  	case ExcelError:
+  	case ExcelRange:
+		  return string_v;
 	}
+
+  if(number_of_characters > strlen(string)) {
+    number_of_characters = strlen(string);
+  }
 	
 	char *left_string = malloc(number_of_characters+1); // Freed
 	if(left_string == 0) {
@@ -965,7 +969,7 @@ static ExcelValue left(ExcelValue string_v, ExcelValue number_of_characters_v) {
 		free(string);
 	}
 	free_later(left_string);
-	return new_excel_string(left_string);
+	return EXCEL_STRING(left_string);
 }
 
 static ExcelValue left_1(ExcelValue string_v) {
@@ -979,10 +983,10 @@ static ExcelValue len(ExcelValue string_v) {
 	char *string;
 	int string_must_be_freed = 0;
 	switch (string_v.type) {
-  	  case ExcelString:
+  	case ExcelString:
   		string = string_v.string;
   		break;
-  	  case ExcelNumber:
+  	case ExcelNumber:
 		  string = malloc(20); // Freed
 		  if(string == 0) {
 			  printf("Out of memory in len");
@@ -994,21 +998,21 @@ static ExcelValue len(ExcelValue string_v) {
 	  case ExcelBoolean:
 	  	if(string_v.number == true) {
 	  		string = "TRUE";
-		} else {
-			string = "FALSE";
-		}
-		break;
+		  } else {
+			  string = "FALSE";
+		  }
+		  break;
 	  case ExcelEmpty:	  	 
-  	  case ExcelError:
-  	  case ExcelRange:
-		return string_v;
+  	case ExcelError:
+  	case ExcelRange:
+		  return string_v;
 	}
 
   int length = strlen(string);
 	if(string_must_be_freed == 1) {
 		free(string);
 	}
-	return new_excel_number(length);
+	return EXCEL_NUMBER(length);
 }
 
 static ExcelValue right(ExcelValue string_v, ExcelValue number_of_characters_v) {
@@ -1027,10 +1031,10 @@ static ExcelValue right(ExcelValue string_v, ExcelValue number_of_characters_v)
 	char *string;
 	int string_must_be_freed = 0;
 	switch (string_v.type) {
-  	  case ExcelString:
+  	case ExcelString:
   		string = string_v.string;
   		break;
-  	  case ExcelNumber:
+  	case ExcelNumber:
 		  string = malloc(20); // Freed
 		  if(string == 0) {
 			  printf("Out of memory in right");
@@ -1042,14 +1046,14 @@ static ExcelValue right(ExcelValue string_v, ExcelValue number_of_characters_v)
 	  case ExcelBoolean:
 	  	if(string_v.number == true) {
 	  		string = "TRUE";
-		} else {
-			string = "FALSE";
-		}
-		break;
+		  } else {
+			  string = "FALSE";
+		  }
+		  break;
 	  case ExcelEmpty:	  	 
-  	  case ExcelError:
-  	  case ExcelRange:
-		return string_v;
+  	case ExcelError:
+  	case ExcelRange:
+		  return string_v;
 	}
 	
 	char *right_string = malloc(number_of_characters+1); // Freed
@@ -1058,20 +1062,16 @@ static ExcelValue right(ExcelValue string_v, ExcelValue number_of_characters_v)
 	  exit(-1);
 	}
   int length = strlen(string);
-  if(length < number_of_characters) {
-    if(string_must_be_freed == 1) {
-      free(string);
-    }
-    return new_excel_string("");
-  } else {
-    memcpy(right_string,string+length-number_of_characters,number_of_characters);
-    right_string[number_of_characters] = '\0';
-    if(string_must_be_freed == 1) {
-      free(string);
-    }
-    free_later(right_string);
-    return new_excel_string(right_string);
+  if(number_of_characters > length) {
+    number_of_characters = length;
   }
+  memcpy(right_string,string+length-number_of_characters,number_of_characters);
+  right_string[number_of_characters] = '\0';
+  if(string_must_be_freed == 1) {
+    free(string);
+  }
+  free_later(right_string);
+  return EXCEL_STRING(right_string);
 }
 
 static ExcelValue right_1(ExcelValue string_v) {
@@ -1272,7 +1272,7 @@ static ExcelValue subtract(ExcelValue a_v, ExcelValue b_v) {
 	NUMBER(a_v, a)
 	NUMBER(b_v, b)
 	CHECK_FOR_CONVERSION_ERROR
-	return new_excel_number(a - b);
+	return EXCEL_NUMBER(a - b);
 }
 
 static ExcelValue multiply(ExcelValue a_v, ExcelValue b_v) {
@@ -1281,7 +1281,7 @@ static ExcelValue multiply(ExcelValue a_v, ExcelValue b_v) {
 	NUMBER(a_v, a)
 	NUMBER(b_v, b)
 	CHECK_FOR_CONVERSION_ERROR
-	return new_excel_number(a * b);
+	return EXCEL_NUMBER(a * b);
 }
 
 static ExcelValue sum(int array_size, ExcelValue *array) {
@@ -1308,7 +1308,7 @@ static ExcelValue sum(int array_size, ExcelValue *array) {
         break;
     }
 	}
-	return new_excel_number(total);
+	return EXCEL_NUMBER(total);
 }
 
 static ExcelValue npv(ExcelValue rate_v, int number_of_arguments, ExcelValue *arguments) {
@@ -1346,7 +1346,7 @@ static ExcelValue npv(ExcelValue rate_v, int number_of_arguments, ExcelValue *ar
       n++;
     }
   }
-  return new_excel_number(npv);
+  return EXCEL_NUMBER(npv);
 }
 
 static ExcelValue max(int number_of_arguments, ExcelValue *arguments) {
@@ -1380,7 +1380,7 @@ static ExcelValue max(int number_of_arguments, ExcelValue *arguments) {
 		any_number_found = 1;
 		biggest_number_found = 0;
 	}
-	return new_excel_number(biggest_number_found);	
+	return EXCEL_NUMBER(biggest_number_found);	
 }
 
 static ExcelValue min(int number_of_arguments, ExcelValue *arguments) {
@@ -1414,7 +1414,7 @@ static ExcelValue min(int number_of_arguments, ExcelValue *arguments) {
 		any_number_found = 1;
 		smallest_number_found = 0;
 	}
-	return new_excel_number(smallest_number_found);	
+	return EXCEL_NUMBER(smallest_number_found);	
 }
 
 static ExcelValue mmult_error(ExcelValue a_v, ExcelValue b_v) {
@@ -1429,7 +1429,7 @@ static ExcelValue mmult_error(ExcelValue a_v, ExcelValue b_v) {
       result[(i*columns) + j] = VALUE;
     }
   }
-  return new_excel_range(result, rows, columns);
+  return EXCEL_RANGE(result, rows, columns);
 }
 
 static ExcelValue mmult(ExcelValue a_v, ExcelValue b_v) {
@@ -1461,10 +1461,10 @@ static ExcelValue mmult(ExcelValue a_v, ExcelValue b_v) {
         if(b.type != ExcelNumber) { return mmult_error(a_v, b_v); }
         sum = sum + (a.number * b.number);
       }
-      result[(i*b_columns)+j] = new_excel_number(sum);
+      result[(i*b_columns)+j] = EXCEL_NUMBER(sum);
     }
   }
-  return new_excel_range(result, a_rows, b_columns);
+  return EXCEL_RANGE(result, a_rows, b_columns);
 }
 
 static ExcelValue mod(ExcelValue a_v, ExcelValue b_v) {
@@ -1475,14 +1475,14 @@ static ExcelValue mod(ExcelValue a_v, ExcelValue b_v) {
 	NUMBER(b_v, b)
 	CHECK_FOR_CONVERSION_ERROR
 	if(b == 0) return DIV0;
-	return new_excel_number(fmod(a,b));
+	return EXCEL_NUMBER(fmod(a,b));
 }
 
 static ExcelValue negative(ExcelValue a_v) {
 	CHECK_FOR_PASSED_ERROR(a_v)
 	NUMBER(a_v, a)
 	CHECK_FOR_CONVERSION_ERROR
-	return new_excel_number(-a);
+	return EXCEL_NUMBER(-a);
 }
 
 static ExcelValue pmt(ExcelValue rate_v, ExcelValue number_of_periods_v, ExcelValue present_value_v) {
@@ -1495,8 +1495,8 @@ static ExcelValue pmt(ExcelValue rate_v, ExcelValue number_of_periods_v, ExcelVa
 	NUMBER(present_value_v,present_value)
 	CHECK_FOR_CONVERSION_ERROR
 	
-	if(rate == 0) return new_excel_number(-(present_value / number_of_periods));
-	return new_excel_number(-present_value*(rate*(pow((1+rate),number_of_periods)))/((pow((1+rate),number_of_periods))-1));
+	if(rate == 0) return EXCEL_NUMBER(-(present_value / number_of_periods));
+	return EXCEL_NUMBER(-present_value*(rate*(pow((1+rate),number_of_periods)))/((pow((1+rate),number_of_periods))-1));
 }
 
 static ExcelValue pv_3(ExcelValue rate_v, ExcelValue nper_v, ExcelValue pmt_v) {
@@ -1546,7 +1546,7 @@ static ExcelValue pv_5(ExcelValue rate_v, ExcelValue nper_v, ExcelValue pmt_v, E
   // Add on the final value
   present_value = present_value - (fv/pow(1+rate,nper));
   
-  return new_excel_number(present_value);
+  return EXCEL_NUMBER(present_value);
 }
 
 
@@ -1561,7 +1561,7 @@ static ExcelValue power(ExcelValue a_v, ExcelValue b_v) {
   if(isnan(result) == 1) {
     return NUM;
   } else {
-    return new_excel_number(result);
+    return EXCEL_NUMBER(result);
   }
 }
 static ExcelValue rank(ExcelValue number_v, ExcelValue range_v, ExcelValue order_v) {
@@ -1602,7 +1602,7 @@ static ExcelValue rank(ExcelValue number_v, ExcelValue range_v, ExcelValue order
     }
   }
   if(found == false) { return NA; }
-  return new_excel_number(ranked);
+  return EXCEL_NUMBER(ranked);
 }
 
 static ExcelValue rank_2(ExcelValue number_v, ExcelValue range_v) {
@@ -1619,7 +1619,7 @@ static ExcelValue excel_round(ExcelValue number_v, ExcelValue decimal_places_v)
 		
 	double multiple = pow(10,decimal_places);
 	
-	return new_excel_number( round(number * multiple) / multiple );
+	return EXCEL_NUMBER( round(number * multiple) / multiple );
 }
 
 static ExcelValue rounddown(ExcelValue number_v, ExcelValue decimal_places_v) {
@@ -1632,7 +1632,7 @@ static ExcelValue rounddown(ExcelValue number_v, ExcelValue decimal_places_v) {
 		
 	double multiple = pow(10,decimal_places);
 	
-	return new_excel_number( trunc(number * multiple) / multiple );	
+	return EXCEL_NUMBER( trunc(number * multiple) / multiple );	
 }
 
 static ExcelValue roundup(ExcelValue number_v, ExcelValue decimal_places_v) {
@@ -1644,8 +1644,8 @@ static ExcelValue roundup(ExcelValue number_v, ExcelValue decimal_places_v) {
 	CHECK_FOR_CONVERSION_ERROR
 		
 	double multiple = pow(10,decimal_places);
-	if(number < 0) return new_excel_number( floor(number * multiple) / multiple );
-	return new_excel_number( ceil(number * multiple) / multiple );	
+	if(number < 0) return EXCEL_NUMBER( floor(number * multiple) / multiple );
+	return EXCEL_NUMBER( ceil(number * multiple) / multiple );	
 }
 
 static ExcelValue excel_int(ExcelValue number_v) {
@@ -1654,7 +1654,7 @@ static ExcelValue excel_int(ExcelValue number_v) {
 	NUMBER(number_v, number)
 	CHECK_FOR_CONVERSION_ERROR
 		
-	return new_excel_number(floor(number));
+	return EXCEL_NUMBER(floor(number));
 }
 
 static ExcelValue string_join(int number_of_arguments, ExcelValue *arguments) {
@@ -1683,7 +1683,7 @@ static ExcelValue string_join(int number_of_arguments, ExcelValue *arguments) {
 		  	  printf("Out of memory in string join");
 		  	  exit(-1);
 		  	}
-			must_free_current_string = 1;				  
+			  must_free_current_string = 1;				  
 			  snprintf(current_string,20,"%g",current_v.number);
 			  break;
 		  case ExcelBoolean:
@@ -1697,25 +1697,35 @@ static ExcelValue string_join(int number_of_arguments, ExcelValue *arguments) {
         current_string = "";
         break;
       case ExcelError:
+        free(string);
         return current_v;
 	  	case ExcelRange:
+        free(string);
         return VALUE;
 		}
 		current_string_length = strlen(current_string);
 		if( (used_length + current_string_length + 1) > allocated_length) {
-			allocated_length += 100;
+			allocated_length = used_length + current_string_length + 1 + 100;
 			string = realloc(string,allocated_length);
+      if(!string) {
+        printf("Out of memory in string join realloc trying to increase to %d", allocated_length);
+        exit(-1);
+      }
 		}
 		memcpy(string + used_length, current_string, current_string_length);
 		if(must_free_current_string == 1) {
 			free(current_string);
 		}
 		used_length = used_length + current_string_length;
-	}
+	} // Finished looping through passed strings
 	string = realloc(string,used_length+1);
+  if(!string) {
+    printf("Out of memory in string join realloc trying to increase to %d", used_length+1);
+    exit(-1);
+  }
   string[used_length] = '\0';
 	free_later(string);
-	return new_excel_string(string);
+	return EXCEL_STRING(string);
 }
 
 static ExcelValue subtotal(ExcelValue subtotal_type_v, int number_of_arguments, ExcelValue *arguments) {
@@ -1788,7 +1798,7 @@ static ExcelValue filter_range(ExcelValue original_range_v, int number_of_argume
       if(original_range_columns != 1) return VALUE;
       ExcelValue *tmp_array2 =  (ExcelValue*) new_excel_value_array(1);
       tmp_array2[0] = current_value;
-      criteria_range[i] =  new_excel_range(tmp_array2,1,1);
+      criteria_range[i] =  EXCEL_RANGE(tmp_array2,1,1);
     }
   }
   
@@ -1799,6 +1809,8 @@ static ExcelValue filter_range(ExcelValue original_range_v, int number_of_argume
 	  exit(-1);
   }
   char *s;
+  char *new_comparator;
+
   for(i = 0; i < number_of_criteria; i++) {
     current_value = arguments[(i*2)+1];
     
@@ -1806,26 +1818,38 @@ static ExcelValue filter_range(ExcelValue original_range_v, int number_of_argume
       s = current_value.string;
       if(s[0] == '<') {
         if( s[1] == '>') {
+          new_comparator = strndup(s+2,strlen(s)-2);
+          free_later(new_comparator);
           criteria[i].type = NotEqual;
-          criteria[i].comparator = new_excel_string(strndup(s+2,strlen(s)-2));
+          criteria[i].comparator = EXCEL_STRING(new_comparator);
         } else if(s[1] == '=') {
+          new_comparator = strndup(s+2,strlen(s)-2);
+          free_later(new_comparator);
           criteria[i].type = LessThanOrEqual;
-          criteria[i].comparator = new_excel_string(strndup(s+2,strlen(s)-2));
+          criteria[i].comparator = EXCEL_STRING(new_comparator);
         } else {
+          new_comparator = strndup(s+1,strlen(s)-1);
+          free_later(new_comparator);
           criteria[i].type = LessThan;
-          criteria[i].comparator = new_excel_string(strndup(s+1,strlen(s)-1));
+          criteria[i].comparator = EXCEL_STRING(new_comparator);
         }
       } else if(s[0] == '>') {
         if(s[1] == '=') {
+          new_comparator = strndup(s+2,strlen(s)-2);
+          free_later(new_comparator);
           criteria[i].type = MoreThanOrEqual;
-          criteria[i].comparator = new_excel_string(strndup(s+2,strlen(s)-2));
+          criteria[i].comparator = EXCEL_STRING(new_comparator);
         } else {
+          new_comparator = strndup(s+1,strlen(s)-1);
+          free_later(new_comparator);
           criteria[i].type = MoreThan;
-          criteria[i].comparator = new_excel_string(strndup(s+1,strlen(s)-1));
+          criteria[i].comparator = EXCEL_STRING(new_comparator);
         }
       } else if(s[0] == '=') {
+        new_comparator = strndup(s+1,strlen(s)-1);
+        free_later(new_comparator);
         criteria[i].type = Equal;
-        criteria[i].comparator = new_excel_string(strndup(s+1,strlen(s)-1));          
+        criteria[i].comparator = EXCEL_STRING(new_comparator);
       } else {
         criteria[i].type = Equal;
         criteria[i].comparator = current_value;          
@@ -1966,6 +1990,7 @@ static ExcelValue filter_range(ExcelValue original_range_v, int number_of_argume
           }
           break;
         case ExcelRange:
+          free(criteria);
           return VALUE;            
       }
       if(passed == 0) break;
@@ -1973,6 +1998,7 @@ static ExcelValue filter_range(ExcelValue original_range_v, int number_of_argume
     if(passed == 1) {
       current_value = original_range[j];
       if(current_value.type == ExcelError) {
+        free(criteria);
         return current_value;
       } else if(current_value.type == ExcelNumber) {
         filtered_range[number_of_filtered_values] = current_value;
@@ -1982,7 +2008,7 @@ static ExcelValue filter_range(ExcelValue original_range_v, int number_of_argume
   }
   // Tidy up
   free(criteria);
-  return new_excel_range(filtered_range, number_of_filtered_values, 1);
+  return EXCEL_RANGE(filtered_range, number_of_filtered_values, 1);
 }
 
 static ExcelValue sumifs(ExcelValue sum_range_v, int number_of_arguments, ExcelValue *arguments) {
@@ -2014,7 +2040,7 @@ static ExcelValue sumproduct(int number_of_arguments, ExcelValue *arguments) {
   int rows;
   int columns;
   ExcelValue current_value;
-  ExcelValue **ranges = malloc(sizeof(ExcelValue *)*number_of_arguments); // Added free statements
+  ExcelValue **ranges = malloc(sizeof(ExcelValue *)*number_of_arguments);
   if(ranges == 0) {
 	  printf("Out of memory in sumproduct\n");
 	  exit(-1);
@@ -2035,19 +2061,19 @@ static ExcelValue sumproduct(int number_of_arguments, ExcelValue *arguments) {
     current_value = arguments[a];
     switch(current_value.type) {
       case ExcelRange:
-        if(current_value.rows != rows || current_value.columns != columns) return VALUE;
+        if(current_value.rows != rows || current_value.columns != columns) { free(ranges);  return VALUE; }
         ranges[a] = current_value.array;
         break;
       case ExcelError:
-		free(ranges);
+		    free(ranges);
         return current_value;
         break;
       case ExcelEmpty:
-		free(ranges);
+		    free(ranges);
         return VALUE;
         break;
       default:
-        if(rows != 1 && columns !=1) return VALUE;
+        if(rows != 1 && columns !=1) { free(ranges); return VALUE; }
         ranges[a] = (ExcelValue*) new_excel_value_array(1);
         ranges[a][0] = arguments[a];
         break;
@@ -2069,7 +2095,7 @@ static ExcelValue sumproduct(int number_of_arguments, ExcelValue *arguments) {
 		}
 	}
 	free(ranges);
-  	return new_excel_number(sum);
+  return EXCEL_NUMBER(sum);
 }
 
 // FIXME: This could do with being done properly, rather than
@@ -2088,11 +2114,11 @@ static ExcelValue text(ExcelValue number_v, ExcelValue format_v) {
   }
 
   if(format_v.type == ExcelEmpty) {
-    return new_excel_string("");
+    return EXCEL_STRING("");
   }
 
   if(format_v.type == ExcelNumber && format_v.number == 0) {
-    format_v = new_excel_string("0");
+    format_v = EXCEL_STRING("0");
   }
 
   if(number_v.type == ExcelString) {
@@ -2102,7 +2128,7 @@ static ExcelValue text(ExcelValue number_v, ExcelValue format_v) {
 		}	        
 		n = strtod (s, &p);
 		if(*p == '\0') {
-		  number_v = new_excel_number(n);
+		  number_v = EXCEL_NUMBER(n);
 		}
   }
 
@@ -2114,77 +2140,40 @@ static ExcelValue text(ExcelValue number_v, ExcelValue format_v) {
     return format_v;
   }
 
+  // FIXME: Too little? 
+  s = malloc(100);
+  setlocale(LC_ALL,"");
+
   if(strcmp(format_v.string,"0%") == 0) {
-    // FIXME: Too little? 
-    s = malloc(100);
-    sprintf(s, "%0.0f%%", number_v.number*100);
-    free_later(s);
-    result = new_excel_string(s);
+    snprintf(s, 99, "%0.0f%%", number_v.number*100);
   } else if(strcmp(format_v.string,"0.0%") == 0) {
-    // FIXME: Too little? 
-    s = malloc(100);
-    sprintf(s, "%0.1f%%", number_v.number*100);
-    free_later(s);
-    result = new_excel_string(s);
+    snprintf(s, 99, "%0.1f%%", number_v.number*100);
   } else if(strcmp(format_v.string,"0") == 0) {
-    s = malloc(100);
-    sprintf(s, "%0.0f",number_v.number);
-    free_later(s);
-    result = new_excel_string(s);
+    snprintf(s, 99, "%0.0f",number_v.number);
   } else if(strcmp(format_v.string,"0.0") == 0) {
-    s = malloc(100);
-    sprintf(s, "%0.1f",number_v.number);
-    free_later(s);
-    result = new_excel_string(s);
+    snprintf(s, 99, "%0.1f",number_v.number);
   } else if(strcmp(format_v.string,"0.00") == 0) {
-    s = malloc(100);
-    sprintf(s, "%0.2f",number_v.number);
-    free_later(s);
-    result = new_excel_string(s);
+    snprintf(s, 99, "%0.2f",number_v.number);
   } else if(strcmp(format_v.string,"0.000") == 0) {
-    s = malloc(100);
-    sprintf(s, "%0.3f",number_v.number);
-    free_later(s);
-    result = new_excel_string(s);
+    snprintf(s, 99, "%0.3f",number_v.number);
   } else if(strcmp(format_v.string,"#,##") == 0) {
-    s = malloc(100);
-    setlocale(LC_ALL,"");
-    sprintf(s, "%'0.0f",number_v.number);
-    free_later(s);
-    result = new_excel_string(s);
+    snprintf(s, 99, "%'0.0f",number_v.number);
   } else if(strcmp(format_v.string,"#,##0") == 0) {
-    s = malloc(100);
-    setlocale(LC_ALL,"");
-    sprintf(s, "%'0.0f",number_v.number);
-    free_later(s);
-    result = new_excel_string(s);
+    snprintf(s, 99, "%'0.0f",number_v.number);
   } else if(strcmp(format_v.string,"#,##0.0") == 0) {
-    s = malloc(100);
-    setlocale(LC_ALL,"");
-    sprintf(s, "%'0.1f",number_v.number);
-    free_later(s);
-    result = new_excel_string(s);
+    snprintf(s, 99, "%'0.1f",number_v.number);
   } else if(strcmp(format_v.string,"#,##0.00") == 0) {
-    s = malloc(100);
-    setlocale(LC_ALL,"");
-    sprintf(s, "%'0.2f",number_v.number);
-    free_later(s);
-    result = new_excel_string(s);
+    snprintf(s, 99, "%'0.2f",number_v.number);
   } else if(strcmp(format_v.string,"#,##0.000") == 0) {
-    s = malloc(100);
-    setlocale(LC_ALL,"");
-    sprintf(s, "%'0.3f",number_v.number);
-    free_later(s);
-    result = new_excel_string(s);
+    snprintf(s, 99, "%'0.3f",number_v.number);
   } else if(strcmp(format_v.string,"0000") == 0) {
-    s = malloc(100);
-    sprintf(s, "%04.0f",number_v.number);
-    free_later(s);
-    result = new_excel_string(s);
+    snprintf(s, 99, "%04.0f",number_v.number);
   } else {
-    return new_excel_string("Text format not recognised");
+    snprintf(s, 99, "Text format not recognised");
   }
 
+  free_later(s);
+  result = EXCEL_STRING(s);
   // inspect_excel_value(result);
   return result;
 }
@@ -2298,5 +2287,62 @@ static ExcelValue value(ExcelValue string_v) {
 	CHECK_FOR_PASSED_ERROR(string_v)
 	NUMBER(string_v, a)
 	CHECK_FOR_CONVERSION_ERROR
-	return new_excel_number(a);
+	return EXCEL_NUMBER(a);
+}
+
+// Allows numbers to be 0.1% different
+static ExcelValue roughly_equal(ExcelValue a_v, ExcelValue b_v) {
+
+  if(a_v.type == ExcelEmpty && b_v.type == ExcelNumber && b_v.number == 0) return TRUE;
+  if(b_v.type == ExcelEmpty && a_v.type == ExcelNumber && a_v.number == 0) return TRUE;
+      
+	if(a_v.type != b_v.type) return FALSE;
+	
+  float epsilon, difference;
+
+	switch (a_v.type) {
+  	case ExcelNumber:
+      // FIXME: Arbitrary choice of epsilons
+      if(b_v.number > -1e-6 && b_v.number < 1e-6) {
+        epsilon = 1e-6;
+      } else {
+        epsilon = b_v.number * 0.001;
+      }
+      if(epsilon < 0) epsilon = -epsilon;
+      difference = a_v.number - b_v.number;
+      if(difference < 0) difference = -difference;
+      if(difference <= epsilon) return TRUE;
+      // For debuging: printf("a: %e b:%e d: %e e: %e", a_v.number, b_v.number, difference, epsilon);
+      return FALSE;
+	  case ExcelBoolean: 
+	  case ExcelEmpty: 
+			if(a_v.number != b_v.number) return FALSE;
+			return TRUE;
+	  case ExcelString:
+	  	if(strcasecmp(a_v.string,b_v.string) != 0 ) return FALSE;
+		  return TRUE;
+  	case ExcelError:
+			if(a_v.number != b_v.number) return FALSE;
+			return TRUE;
+  	case ExcelRange:
+  		return NA;
+  }
+  return FALSE;
+}
+  
+
+static void assert_equal(ExcelValue expected, ExcelValue actual, char location[]) {
+  ExcelValue comparison = roughly_equal(actual, expected);
+  if(comparison.type == ExcelBoolean && comparison.number == 1) {
+    putchar('.');
+  } else {
+    printf("\n\nFailed at %s\n", location);
+    printf("Expected: ");
+    inspect_excel_value(expected);
+    printf("Got:      ");
+    inspect_excel_value(actual);
+    putchar('\n');
+  }
 }
+
+