excel_to_code 0.1.10 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4e983a098e0ba3377ae5b0d42b53c5d627e765e8
-  data.tar.gz: dd9b3766572dd84f5bf980fb256bfd7ce70fdb49
+  metadata.gz: ff7e5d635bef2732929fe6f7706995baa7cb5d52
+  data.tar.gz: c2fea67c08a78cd1fc818869492776f52d867ee1
 SHA512:
-  metadata.gz: b829c3fb99bd61216b7df001ad320a9a0ecd6f6157fc07ac0c368417354e853544f25ae8b31b43dde6fb788480c6ac9e8559b6646fd8a5d55bd4a054885c0e62
-  data.tar.gz: 6d1f1519d8daf601c6028c6c116eadd8c76dada8edb5153ee42d49946fa97831b18d0d086e46a59b49823c6126e893638f0247c2e30b2de08a3f053a917bc49a
+  metadata.gz: 17939af6392b8e9cc47fb773a6b431e7f217689fdf6ab9703b2276fdf19867536c21679a94d9eec59a3065f90db950985d68030bfedcdcbd083a22d5efe576ac
+  data.tar.gz: 05eb3b5352fb9559ae52ad4a97fdb753d1f6d8267c942566a1a1cf787dfbce15202d1182d682b4566155813fc78d7bb0ede20218293adc639fa337de725dcde8

data/README.md

@@ -40,8 +40,9 @@ There are some how to guides in the doc folder.
 # Limitations
 
 1. Not tested at all on Windows
-2. INDIRECT formula must be convertable at runtime into a standard formula
+2. INDIRECT and OFFSET formula must be convertable at runtime into a standard formula
 3. Doesn't implement all functions (see doc/Which_functions_are_implemented.md)
 4. Doesn't implement references that involve range unions and lists (but does implement standard ranges)
 5. Sometimes gives cells as being empty, when excel would give the cell as having a numeric value of zero
 6. The generated C version does not multithread and will give bad results if you try
+7. Newlines are removed from strings

data/src/commands/excel_to_c.rb

@@ -372,34 +372,25 @@ END
     o.puts "# Test for #{name}"
     o.puts "require 'rubygems'"
     o.puts "gem 'minitest'"
-    o.puts  "require 'test/unit'"
+    o.puts  "require 'minitest/autorun'"
     o.puts  "require_relative '#{output_name.downcase}'"
     o.puts
-    o.puts "class Test#{ruby_module_name} < Test::Unit::TestCase"
+    o.puts "class Test#{ruby_module_name} < Minitest::Test"
+    o.puts "  def self.runnable_methods"
+    o.puts "    puts 'Overriding minitest to run tests in a defined order'"
+    o.puts "    methods = methods_matching(/^test_/)"
+    o.puts "  end" 
     o.puts "  def worksheet; @worksheet ||= init_spreadsheet; end"
     o.puts "  def init_spreadsheet; #{ruby_module_name}Shim.new end"
     
-    all_formulae = all_formulae()
-    
-    worksheets do |name,xml_filename|
-      i = input([name,"Values"])
-      o.puts
-      o.puts "  # start of #{name}"  
-      c_name = c_name_for_worksheet_name(name)
-      if !cells_to_keep || cells_to_keep.empty? || cells_to_keep[name] == :all
-        refs_to_test = all_formulae[name].keys
-      else
-        refs_to_test = cells_to_keep[name]
-      end
-      if refs_to_test && !refs_to_test.empty?
-        refs_to_test = refs_to_test.map(&:upcase)
-        CompileToCUnitTest.rewrite(i, sloppy_tests, c_name, refs_to_test, o)
-      end
-      close(i)
-    end
+    i = input("References to test")
+    CompileToCUnitTest.rewrite(i, sloppy_tests, o)
+    close(i)
+
     o.puts "end"
     close(o)
   end
+
   
   def compile_code
     return unless actually_compile_code || actually_run_tests

data/src/commands/excel_to_ruby.rb

@@ -90,27 +90,10 @@ class ExcelToRuby < ExcelToX
     o.puts
     o.puts "class Test#{ruby_module_name} < Test::Unit::TestCase"
     o.puts "  def worksheet; @worksheet ||= #{ruby_module_name}.new; end"
-    
-    c = CompileToRubyUnitTest.new
-    formulae = all_formulae()
-    
-    worksheets do |name,xml_filename|
-      i = input(name,"Values")
-      o.puts "  # Start of #{name}"
-      c_name = c_name_for_worksheet_name(name)
-      if !cells_to_keep || cells_to_keep.empty? || cells_to_keep[name] == :all
-        refs_to_test = formulae[name].keys
-      else
-        refs_to_test = cells_to_keep[name]
-      end
-      if refs_to_test && !refs_to_test.empty?
-        refs_to_test = refs_to_test.map(&:upcase)
-        c.rewrite(i, sloppy_tests, c_name, refs_to_test, o)
-      end
-      o.puts "  # End of #{name}"
-      o.puts ""
-      close(i)
-    end 
+
+    i = input("References to test")
+    CompileToCUnitTest.rewrite(i, sloppy_tests, o)
+    close(i)
     o.puts "end"   
     close(o)
   end

data/src/commands/excel_to_x.rb

@@ -186,6 +186,7 @@ class ExcelToX
     inline_formulae_that_are_only_used_once
     separate_formulae_elements
     replace_values_with_constants
+    create_sorted_references_to_test
 
     # This actually creates the code (implemented in subclasses)
     write_code
@@ -601,6 +602,9 @@ class ExcelToX
       r.sheet_name = name
       replace r, [name, 'Formulae'], 'Named references', [name, 'Formulae']
       
+      # The result of the indirect might contain arithmetic, which we need to simplify
+      replace SimplifyArithmetic,   [name, 'Formulae'], [name, 'Formulae']      
+
       # The result of the indirect might be a table reference, which we need to simplify
       r = ReplaceTableReferences.new
       r.sheet_name = name
@@ -734,6 +738,51 @@ class ExcelToX
     remove_any_cells_not_needed_for_outputs
   end
   
+  # This comes up with a list of references to test, in the form of a file called 'References to test'.
+  # It is structured to contain one reference per row:
+  # worksheet_c_name \t ref \t value_ast
+  # These will be sorted so that later refs depend on earlier refs. This should mean that the first test that 
+  # fails will be the root cause of the problem
+  def create_sorted_references_to_test
+    all_formulae = all_formulae()
+    references_to_test = {}
+
+    # First get the list of references we should test
+    worksheets do |name, xml_filename|
+      log.info "Workingout references to test for #{name}"
+
+      # Either keep all the cells on the sheet  
+      if !cells_to_keep || cells_to_keep.empty? || cells_to_keep[name] == :all
+        keep = all_formulae[name].keys || []
+      else # Or just those specified as cells that will be kept
+        keep = cells_to_keep[name] || []
+      end
+
+      # Now go through and match the cells to keep with their values
+      i = input([name,"Values"])
+      i.each_line do |line|
+        ref, formula = line.split("\t")
+        next unless keep.include?(ref.upcase)
+        references_to_test[[name, ref]] = formula
+      end
+      close(i)
+    end
+    
+    # Now work out dependency tree
+    sorted_references = SortIntoCalculationOrder.new.sort(all_formulae)
+
+    references_to_test_file = intermediate("References to test")
+    sorted_references.each do |ref|
+      ast = references_to_test[ref]
+      next unless ast
+      c_name = c_name_for_worksheet_name(ref[0])
+      references_to_test_file.puts "#{c_name}\t#{ref[1]}\t#{ast}"
+    end
+
+    close references_to_test_file
+  end
+
+
   # This looks for repeated formula parts, and separates them out. It is the opposite of inlining:
   # e.g., A1 := (B1 + B3) + B10; A2 := (B1 + B3) + 3 gets transformed to: Common1 := B1 + B3 ; A1 := Common1 + B10 ; A2 := Common1 + 3
   def separate_formulae_elements
@@ -812,6 +861,7 @@ class ExcelToX
     count.each do |sheet,keys|
       keys.each do |ref,count|
         next unless count >= 1
+        next unless references[sheet]
         ast = references[sheet][ref]
         next unless ast
         if [:blank,:number,:null,:string,:shared_string,:constant,:percentage,:error,:boolean_true,:boolean_false].include?(ast.first)
@@ -954,6 +1004,7 @@ class ExcelToX
     filename = versioned_filename_write(intermediate_directory,*args)
     if run_in_memory
       @files ||= {}
+      remove_obsolete_versioned_filenames(intermediate_directory, *args)
       @files[filename] = StringIO.new("",'w')
     else
       FileUtils.mkdir_p(File.dirname(filename))
@@ -979,6 +1030,15 @@ class ExcelToX
     @ruby_module_name = @ruby_module_name.gsub(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }.gsub('/', '::')
     @ruby_module_name
   end
+
+  def remove_obsolete_versioned_filenames(*args)
+    return unless run_in_memory
+    standardised_name = standardise_name(args)
+    counter = @versioned_filenames[standardised_name] || 0
+    0.upto(counter-1).map do |c|
+      @files.delete(filename_with_counter(c, args))
+    end
+  end
   
   def versioned_filename_read(*args)
     @versioned_filenames ||= {}

data/src/compile/c/excel_to_c_runtime.c

@@ -55,6 +55,8 @@ static ExcelValue less_than(ExcelValue a_v, ExcelValue b_v);
 static ExcelValue less_than_or_equal(ExcelValue a_v, ExcelValue b_v);
 static ExcelValue find_2(ExcelValue string_to_look_for_v, ExcelValue string_to_look_in_v);
 static ExcelValue find(ExcelValue string_to_look_for_v, ExcelValue string_to_look_in_v, ExcelValue position_to_start_at_v);
+static ExcelValue hlookup_3(ExcelValue lookup_value_v,ExcelValue lookup_table_v, ExcelValue row_number_v);
+static ExcelValue hlookup(ExcelValue lookup_value_v,ExcelValue lookup_table_v, ExcelValue row_number_v, ExcelValue match_type_v);
 static ExcelValue iferror(ExcelValue value, ExcelValue value_if_error);
 static ExcelValue excel_index(ExcelValue array_v, ExcelValue row_number_v, ExcelValue column_number_v);
 static ExcelValue excel_index_2(ExcelValue array_v, ExcelValue row_number_v);
@@ -957,13 +959,19 @@ static ExcelValue multiply(ExcelValue a_v, ExcelValue b_v) {
 static ExcelValue sum(int array_size, ExcelValue *array) {
 	double total = 0;
 	int i;
+  ExcelValue r;
 	for(i=0;i<array_size;i++) {
     switch(array[i].type) {
       case ExcelNumber:
         total += array[i].number;
         break;
       case ExcelRange:
-        total += number_from(sum( array[i].rows * array[i].columns, array[i].array ));
+        r = sum( array[i].rows * array[i].columns, array[i].array );
+        if(r.type == ExcelError) {
+          return r;
+        } else {
+          total += number_from(r);
+        }
         break;
       case ExcelError:
         return array[i];
@@ -1133,7 +1141,12 @@ static ExcelValue power(ExcelValue a_v, ExcelValue b_v) {
 	NUMBER(a_v, a)
 	NUMBER(b_v, b)
 	CHECK_FOR_CONVERSION_ERROR
-	return new_excel_number(pow(a,b));
+  double result = pow(a,b);
+  if(isnan(result) == 1) {
+    return NUM;
+  } else {
+    return new_excel_number(result);
+  }
 }
 
 static ExcelValue excel_round(ExcelValue number_v, ExcelValue decimal_places_v) {
@@ -1635,6 +1648,9 @@ static ExcelValue vlookup(ExcelValue lookup_value_v,ExcelValue lookup_table_v, E
   if(lookup_value_v.type == ExcelEmpty) return NA;
   if(lookup_table_v.type != ExcelRange) return NA;
   if(column_number_v.type != ExcelNumber) return NA;
+  if(match_type_v.type == ExcelNumber && match_type_v.number >= 0 && match_type_v.number <= 1) {
+    match_type_v.type = ExcelBoolean;
+  }
   if(match_type_v.type != ExcelBoolean) return NA;
     
   int i;
@@ -1671,6 +1687,57 @@ static ExcelValue vlookup(ExcelValue lookup_value_v,ExcelValue lookup_table_v, E
   return NA;
 }
 
+static ExcelValue hlookup_3(ExcelValue lookup_value_v,ExcelValue lookup_table_v, ExcelValue row_number_v) {
+  return hlookup(lookup_value_v,lookup_table_v,row_number_v,TRUE);
+}
+
+static ExcelValue hlookup(ExcelValue lookup_value_v,ExcelValue lookup_table_v, ExcelValue row_number_v, ExcelValue match_type_v) {
+  CHECK_FOR_PASSED_ERROR(lookup_value_v)
+  CHECK_FOR_PASSED_ERROR(lookup_table_v)
+  CHECK_FOR_PASSED_ERROR(row_number_v)
+  CHECK_FOR_PASSED_ERROR(match_type_v)
+
+  if(lookup_value_v.type == ExcelEmpty) return NA;
+  if(lookup_table_v.type != ExcelRange) return NA;
+  if(row_number_v.type != ExcelNumber) return NA;
+  if(match_type_v.type == ExcelNumber && match_type_v.number >= 0 && match_type_v.number <= 1) {
+    match_type_v.type = ExcelBoolean;
+  }
+  if(match_type_v.type != ExcelBoolean) return NA;
+    
+  int i;
+  int last_good_match = 0;
+  int rows = lookup_table_v.rows;
+  int columns = lookup_table_v.columns;
+  ExcelValue *array = lookup_table_v.array;
+  ExcelValue possible_match_v;
+  
+  if(row_number_v.number > rows) return REF;
+  if(row_number_v.number < 1) return VALUE;
+  
+  if(match_type_v.number == false) { // Exact match required
+    for(i=0; i< columns; i++) {
+      possible_match_v = array[i];
+      if(excel_equal(lookup_value_v,possible_match_v).number == true) {
+        return array[((((int) row_number_v.number)-1)*columns)+(i)];
+      }
+    }
+    return NA;
+  } else { // Highest value that is less than or equal
+    for(i=0; i< columns; i++) {
+      possible_match_v = array[i];
+      if(lookup_value_v.type != possible_match_v.type) continue;
+      if(more_than(possible_match_v,lookup_value_v).number == true) {
+        if(i == 0) return NA;
+        return array[((((int) row_number_v.number)-1)*columns)+(i-1)];
+      } else {
+        last_good_match = i;
+      }
+    }
+    return array[((((int) row_number_v.number)-1)*columns)+(last_good_match)];
+  }
+  return NA;
+}
 
 
 int test_functions() {
@@ -2038,9 +2105,10 @@ int test_functions() {
     assert((pmt(new_excel_number(0),new_excel_number(2),new_excel_number(10)).number - -5) < 0.01);
 
 	// Test power
-    // ... should return sum of its arguments
+    // ... 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);
@@ -2256,6 +2324,9 @@ int test_functions() {
   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
@@ -2265,6 +2336,38 @@ int test_functions() {
   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);

data/src/compile/c/map_formulae_to_c.rb

@@ -36,6 +36,8 @@ class MapFormulaeToC < MapValuesToC
     'COUNTA' => 'counta',
     'FIND2' => 'find_2',
     'FIND3' => 'find',
+    'HLOOKUP3' => 'hlookup_3',
+    'HLOOKUP4' => 'hlookup',
     'IF2' => 'excel_if_2',
     'IF3' => 'excel_if',
     'IFERROR' => 'iferror',

data/src/compile/ruby/compile_to_ruby_unit_test.rb

@@ -15,11 +15,10 @@ class CompileToRubyUnitTest
     self.new.rewrite(*args)
   end
   
-  def rewrite(input, sloppy, c_name, refs_to_test, o)
+  def rewrite(input, sloppy, o)
     mapper = MapValuesToRuby.new
     input.each_line do |line|
-      ref, formula = line.split("\t")
-      next unless refs_to_test.include?(ref.upcase)
+      c_name, ref, formula = line.split("\t")
       ast = eval(formula)
       value = mapper.map(ast)
       full_reference = "worksheet.#{c_name}_#{ref.downcase}"

data/src/compile/ruby/map_formulae_to_ruby.rb

@@ -25,6 +25,7 @@ class MapFormulaeToRuby < MapValuesToRuby
     'COUNT' => 'count',
     'COUNTA' => 'counta',
     'FIND' => 'find',
+    'HLOOKUP' => 'hlookup',
     'IF' => 'excel_if',
     'IFERROR' => 'iferror',
     'INDEX' => 'index',

data/src/excel/excel_functions.rb

@@ -79,3 +79,5 @@ require_relative 'excel_functions/mid'
 require_relative 'excel_functions/pv'
 
 require_relative 'excel_functions/text'
+
+require_relative 'excel_functions/hlookup'

data/src/excel/excel_functions/hlookup.rb

@@ -0,0 +1,48 @@
+module ExcelFunctions
+  
+  def hlookup(lookup_value, lookup_table, row_number, match_type = true)    
+    return lookup_value if lookup_value.is_a?(Symbol)
+    return lookup_table if lookup_table.is_a?(Symbol)
+    return row_number if row_number.is_a?(Symbol)
+    return match_type if match_type.is_a?(Symbol)
+    
+    return :na if lookup_value == nil
+    return :na if lookup_table == nil
+    return :na if row_number == nil
+    return :na if match_type == nil
+  
+    lookup_value = lookup_value.downcase if lookup_value.is_a?(String)
+    
+    last_good_match = 0
+
+    return :value unless row_number > 0
+    return :ref unless row_number <= lookup_table.size
+
+    lookup_table.first.each_with_index do |possible_match, column_number|
+      
+      next if lookup_value.is_a?(String) && !possible_match.is_a?(String)
+      next if lookup_value.is_a?(Numeric) && !possible_match.is_a?(Numeric)
+      
+      possible_match.downcase! if lookup_value.is_a?(String)
+
+      if lookup_value == possible_match
+        return lookup_table[row_number-1][column_number]
+      elsif match_type == true
+        if possible_match > lookup_value
+          return :na if column_number == 0
+          return lookup_table[row_number-1][last_good_match]
+        else
+          last_good_match = column_number
+        end
+      end      
+    end
+
+    # We don't have a match
+    if match_type == true
+      return lookup_table[row_number - 1][last_good_match]
+    else
+      return :na
+    end
+  end
+  
+end

data/src/excel/excel_functions/multiply.rb

@@ -4,9 +4,6 @@ require_relative 'apply_to_range'
 module ExcelFunctions
   
   def multiply(a,b)
-  begin
-    # return apply_to_range(a,b) { |a,b| multiply(a,b) } if a.is_a?(Array) || b.is_a?(Array)
-    
     a = number_argument(a)
     b = number_argument(b)
     
@@ -14,11 +11,6 @@ module ExcelFunctions
     return b if b.is_a?(Symbol)
     
     a * b
-    
-  rescue Error => e
-    print e.backtrace.join('\n')
-    raise
-  end
   end
   
 end

data/src/excel/formula_peg.rb

@@ -18,7 +18,7 @@ class Formula < RubyPeg
   end
   
   def thing
-    function || array || brackets || any_reference || string || percentage || number || boolean || prefix || named_reference
+    function || array || brackets || any_reference || string || percentage || number || boolean || prefix || error || named_reference
   end
   
   def argument
@@ -235,4 +235,10 @@ class Formula < RubyPeg
     end
   end
   
+  def error
+    node :error do
+      terminal("#REF!") || terminal("#NAME?") || terminal("#VALUE!") || terminal("#DIV/0!") || terminal("#N/A") || terminal("#NUM!")
+    end
+  end
+  
 end

data/src/excel/formula_peg.txt

@@ -1,6 +1,6 @@
 formula                         := space? expression+
 expression                       = string_join | comparison | arithmetic | thing
-thing                            = function | array | brackets | any_reference | string | percentage | number | boolean | prefix | named_reference 
+thing                            = function | array | brackets | any_reference | string | percentage | number | boolean | prefix | error | named_reference 
 argument                         = expression | null
 function                        := /[A-Z]+/ `'(' space argument? (space `',' space argument)* space `')'
 brackets                        := `'(' space expression+ space `')'
@@ -42,4 +42,5 @@ boolean_false                   := `'FALSE'
 prefix                          := /[-+]/ thing
 space                            = `/[ \n]*/
 null                            := &','
+error                           := '#REF!' | '#NAME?' | '#VALUE!' | '#DIV/0!' | '#N/A' | '#NUM!'
 

data/src/extract/extract_shared_formulae.rb

@@ -3,10 +3,12 @@ require_relative 'extract_formulae'
 class ExtractSharedFormulae < ExtractFormulae
   
   attr_accessor :shared_range
+  attr_accessor :shared_formula_identifier
   
   def start_formula(type,attributes)
     return unless type == 'shared' && attributes.assoc('ref')
     @shared_range = attributes.assoc('ref').last
+    @shared_formula_identifier = attributes.assoc('si').last
     @parsing = true
   end
   
@@ -16,6 +18,8 @@ class ExtractSharedFormulae < ExtractFormulae
     output.write "\t"
     output.write @shared_range
     output.write "\t"
+    output.write @shared_formula_identifier
+    output.write "\t"
     output.write @formula.join.gsub(/[\n\r]+/,'')
     output.write "\n"
   end

data/src/extract/extract_shared_formulae_targets.rb

@@ -2,13 +2,18 @@ require_relative 'extract_formulae'
 
 class ExtractSharedFormulaeTargets < ExtractFormulae
   
+  attr_accessor :shared_formula_identifier
+
   def start_formula(type,attributes)
     return unless type == 'shared'
+    @shared_formula_identifier = attributes.assoc('si').last
     @parsing = true
   end
   
   def write_formula
     output.write @ref
+    output.write "\t"
+    output.write @shared_formula_identifier
     output.write "\n"
   end
   

data/src/rewrite/rewrite_shared_formulae.rb

@@ -6,14 +6,14 @@ class RewriteSharedFormulae
   end
   
   def rewrite(input, shared_targets, output)
-    shared_targets = shared_targets.each_line.map(&:strip).to_a
+    shared_targets = Hash[*shared_targets.each_line.map { |l| l.split("\t").map(&:strip) }.flatten]
     input.each_line do |line|
-      ref, copy_range, formula = line.split("\t")
-      share_formula(ref, formula, copy_range, shared_targets, output)
+      ref, copy_range,  shared_formula_identifier, formula = line.split("\t")
+      share_formula(ref, formula, copy_range, shared_formula_identifier, shared_targets, output)
     end
   end
   
-  def share_formula(ref, formula, copy_range, shared_targets, output)
+  def share_formula(ref, formula, copy_range, shared_formula_identifier, shared_targets, output)
     shared_ast = eval(formula)
     copier = AstCopyFormula.new
     copy_range = Area.for(copy_range)
@@ -30,6 +30,7 @@ class RewriteSharedFormulae
     copy_range.offsets.each do |row,column|
       new_ref = start_reference.offset(row,column)
       next unless shared_targets.include?(new_ref)
+      next unless shared_formula_identifier == shared_targets[new_ref]
       copier.rows_to_move = row + offset_from_formula_to_start_rows
       copier.columns_to_move = column + offset_from_formula_to_start_columns
       ast = copier.copy(shared_ast)

data/src/rewrite/rewrite_values_to_ast.rb

@@ -8,6 +8,7 @@ class RewriteValuesToAst
   
   # input should be in the form: 'thing\tthing\tformula\n' where the last field is always a forumla
   # output will be in the form 'thing\tthing\tast\n'
+  # FIXME: Removes newlines and other unprintables from str types. Should actually process them.
   def rewrite(input,output)
     input.each_line do |line|
       line =~ /^(.*?)\t(.*?)\t(.*)\n/
@@ -17,7 +18,7 @@ class RewriteValuesToAst
       when 's'; [:shared_string,value]
       when 'n'; [:number,value]
       when 'e'; [:error,value]
-      when 'str'; [:string,value]
+      when 'str'; [:string,value.gsub(/_x[0-9A-F]{4}_/,'')]
       else
         $stderr.puts "Type #{type} not known in #{line}"
         [:parse_error,line.inspect]

data/src/simplify.rb

@@ -15,3 +15,4 @@ require_relative "simplify/identify_repeated_formula_elements"
 require_relative "simplify/replace_common_elements_in_formulae"
 require_relative "simplify/replace_arrays_with_single_cells"
 require_relative "simplify/replace_values_with_constants"
+require_relative "simplify/sort_into_calculation_order"

data/src/simplify/map_formulae_to_values.rb

@@ -108,6 +108,7 @@ class MapFormulaeToValues
     return  [:function, "INDEX", array_mapped, map(row_number), map(column_number)] unless array_as_values
 
     result = @calculator.send(MapFormulaeToRuby::FUNCTIONS["INDEX"],array_as_values,row_as_number,column_as_number)
+    result = [:number, 0] if result == [:blank]
     result = ast_for_value(result)
     result    
   end
@@ -119,6 +120,7 @@ class MapFormulaeToValues
     array_as_values = array_as_values(array)
     return  [:function, "INDEX", array_mapped, map(row_number)] unless array_as_values
     result = @calculator.send(MapFormulaeToRuby::FUNCTIONS["INDEX"],array_as_values,row_as_number)
+    result = [:number, 0] if result == [:blank]
     result = ast_for_value(result)
     result
   end

data/src/simplify/replace_ranges_with_array_literals.rb

@@ -17,7 +17,12 @@ class ReplaceRangesWithArrayLiteralsAst
   def sheet_reference(sheet,reference)
     if reference.first == :area
       area = Area.for("#{reference[1]}:#{reference[2]}")
-      area.to_array_literal(sheet)
+      a = area.to_array_literal(sheet)
+      
+      # Don't convert single cell ranges
+      return a[1][1] if a.size == 2 && a[1].size == 2
+      a
+
     else
       [:sheet_reference,sheet,reference]
     end
@@ -25,7 +30,11 @@ class ReplaceRangesWithArrayLiteralsAst
   
   def area(start,finish)
     area = Area.for("#{start}:#{finish}")
-    area.to_array_literal
+    a = area.to_array_literal
+
+    # Don't convert single cell ranges
+    return a[1][1] if a.size == 2 && a[1].size == 2
+    a
   end
   
 end

data/src/simplify/sort_into_calculation_order.rb

@@ -0,0 +1,65 @@
+class SortIntoCalculationOrder
+  
+  attr_accessor :references
+  attr_accessor :current_sheet
+  attr_accessor :ordered_references
+  
+  
+  # FIXME: Probably not the best algorithm for this
+  def sort(references)
+    @current_sheet = []
+    @ordered_references = []
+    @references = references
+
+    # First we find the references that are at the top of the tree
+    references_with_counts = CountFormulaReferences.new.count(references)
+    tops = []
+    references_with_counts.each do |sheet, references|
+      references.each do |cell, count|
+        next unless count == 0
+        tops << [sheet, cell]
+      end
+    end
+    # Then we have to work through those tops
+    # recursively adding the cells that they depend on
+    tops.each do |ref|
+      add_ordered_references_for ref
+    end
+    @ordered_references
+  end
+  
+  def add_ordered_references_for(ref)
+    sheet = ref.first
+    cell = ref.last
+    current_sheet.push(sheet)
+    ast = @references[sheet][cell]
+    map(ast)
+    current_sheet.pop
+    ordered_references << ref
+  end  
+
+  def map(ast)
+    return ast unless ast.is_a?(Array)
+    operator = ast[0]
+    if respond_to?(operator)
+      send(operator,*ast[1..-1])
+    else
+      ast[1..-1].each do |a|
+        map(a)
+      end
+    end
+  end
+  
+  def sheet_reference(sheet,reference)
+    ref = [sheet, reference.last.gsub('$','')]
+    return if @ordered_references.include?(ref)
+    add_ordered_references_for(ref)
+  end
+  
+  def cell(reference)
+    ref = [current_sheet.last, reference.gsub('$','')]
+    return if @ordered_references.include?(ref)
+    add_ordered_references_for(ref)
+  end
+   
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: excel_to_code
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.11
 platform: ruby
 authors:
 - Thomas Counsell, Green on Black Ltd
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-25 00:00:00.000000000 Z
+date: 2013-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubypeg
@@ -79,12 +79,12 @@ description: "# excel_to_code\n\nConverts some excel spreadsheets (.xlsx, not .x
   use sudo\n3. bundle\n4. rspec spec/*\n\nTo test the C runtime:\n1. cd src/compile/c\n2.
   cc excel_to_c_runtime\n3. ./a.out\n\n# Hacking excel_to_code\n\nThere are some how
   to guides in the doc folder. \n\n# Limitations\n\n1. Not tested at all on Windows\n2.
-  INDIRECT formula must be convertable at runtime into a standard formula\n3. Doesn't
-  implement all functions (see doc/Which_functions_are_implemented.md)\n4. Doesn't
-  implement references that involve range unions and lists (but does implement standard
-  ranges)\n5. Sometimes gives cells as being empty, when excel would give the cell
-  as having a numeric value of zero\n6. The generated C version does not multithread
-  and will give bad results if you try\n"
+  INDIRECT and OFFSET formula must be convertable at runtime into a standard formula\n3.
+  Doesn't implement all functions (see doc/Which_functions_are_implemented.md)\n4.
+  Doesn't implement references that involve range unions and lists (but does implement
+  standard ranges)\n5. Sometimes gives cells as being empty, when excel would give
+  the cell as having a numeric value of zero\n6. The generated C version does not
+  multithread and will give bad results if you try\n7. Newlines are removed from strings\n"
 email: tamc@greenonblack.com
 executables:
 - excel_to_c
@@ -133,6 +133,7 @@ files:
 - src/excel/excel_functions/excel_if.rb
 - src/excel/excel_functions/excel_match.rb
 - src/excel/excel_functions/find.rb
+- src/excel/excel_functions/hlookup.rb
 - src/excel/excel_functions/iferror.rb
 - src/excel/excel_functions/index.rb
 - src/excel/excel_functions/int.rb
@@ -222,6 +223,7 @@ files:
 - src/simplify/replace_table_references.rb
 - src/simplify/replace_values_with_constants.rb
 - src/simplify/simplify_arithmetic.rb
+- src/simplify/sort_into_calculation_order.rb
 - src/simplify.rb
 - src/util/not_supported_exception.rb
 - src/util/try.rb