excel_to_code 0.2.28 → 0.2.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0f1d440b53cf5789e80137607f6d172546f719b7
-  data.tar.gz: 49eb81b9dce39eab5c56afe5cbc8a251d1539994
+  metadata.gz: fa747184660d6eb2e3a92bce25849e0683eff073
+  data.tar.gz: a959fd27d7000dc9167a4e63972a544fef83e0a8
 SHA512:
-  metadata.gz: 58d2670adbdf448425a435297478cfdfb8f4350d2d68a8e85fdcf7a4b8a778b8aa9aab856b4693b54325707950fac0f7bb39600e5b180f1b95ea43032d5056c4
-  data.tar.gz: edc5688112befeb6935b394a8169bdf683ab5071dff8423cd615336539144f55f7b3f488d6ede08eba68fbc2c501a64decb37fe98740f440c1e140f0ac422aaf
+  metadata.gz: 28b6848296a487e694634a2e208b7b96972d8b7efea4ca7d9eebd5d9c5bf5f667274638f367b757aae365acf32375beb45a2ab5502e900a3cc3ed5243e897732
+  data.tar.gz: 600e18d8bdafd963d5dce0e626eb7821368855c69bb4df82acb06d618778c09b7283cef1e912c2d23cb9a575c3d65e531e6dec26bb0fd82ae5cb4f18b6e6e659

data/README.md

@@ -46,3 +46,5 @@ There are some how to guides in the doc folder.
 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
+8. The generated code uses floating point, rather than fully precise arithmetic, so results can differ slightly
+9. The generated code uses the sprintf approach to rounding (even-odd) rather than excel's 0.5 rounds away from zero.

data/src/commands/excel_to_x.rb

@@ -1,6 +1,7 @@
 # coding: utf-8
 require 'fileutils'
 require 'logger'
+require 'tmpdir'
 require_relative '../excel_to_code'
 
 # FIXME: Correct case for all worksheet references
@@ -120,16 +121,6 @@ class ExcelToX
   # cells on tha sheet and nothing else.
   attr_accessor :isolate
 
-  # Deprecated
-  def run_in_memory=(boolean)
-    $stderr.puts "The run_in_memory switch is deprecated (it is now always true). Please remove calls to it"
-  end 
-  
-  # Deprecated
-  def intermediate_directory=(dirname)
-    $stderr.puts "The intermediate_directory switch is deprecated (nowdays, no intermediate files are written). Please remove calls to it"
-  end
-
   # This is the main method. Once all the above attributes have been set, it should be called to actually do the work.
   def go!
     # This sorts out the settings
@@ -211,7 +202,9 @@ class ExcelToX
     # These compile and run the code version of the excel (implemented in subclasses)
     compile_code
     run_tests
-    
+
+    cleanup
+
     log.info "The generated code is available in #{File.join(output_directory)}"
   end
   
@@ -219,8 +212,11 @@ class ExcelToX
   def set_defaults
     raise ExcelToCodeException.new("No excel file has been specified") unless excel_file
     
-    self.output_directory ||= File.join(File.dirname(excel_file),File.basename(excel_file,".*"),language)
-    self.xml_directory ||= File.join(File.dirname(excel_file),File.basename(excel_file,".*"),'xml')
+    self.output_directory ||= Dir.pwd
+    unless self.xml_directory
+      self.xml_directory ||= Dir.mktmpdir
+      @delete_xml_directory_at_end = true
+    end
     
     self.output_name ||= "Excelspreadsheet"
     
@@ -240,7 +236,7 @@ class ExcelToX
     self.extract_repeated_parts_of_formulae = true if @extract_repeated_parts_of_formulae == nil
     self.should_inline_formulae_that_are_only_used_once = true if @should_inline_formulae_that_are_only_used_once == nil
 
-    # This setting is used for debugging, and makes the system only do the conversion on a subset of the the
+    # This setting is used for debugging, and makes the system only do the conversion on a subset of the worksheets
     if self.isolate
       self.isolate = [self.isolate] unless self.isolate.is_a?(Array)
       self.cells_to_keep ||= {}
@@ -251,7 +247,6 @@ class ExcelToX
       log.warn "Isolating #{@isolate} worksheet(s). No other sheets will be converted"
     end
   end
-  
 
   # Creates any directories that are needed
   def sort_out_output_directories    
@@ -503,6 +498,7 @@ class ExcelToX
     @table_rids = extractor.table_rids
     @tables = {}
     @table_areas = {}
+    @table_data = {}
     extract_tables
   end
   
@@ -529,6 +525,7 @@ class ExcelToX
             table = Table.new(table_name, *details)
             @tables[name] = table
             @table_areas[name.to_sym] = table.all
+            @table_data[name.to_sym] = table.data
           end
         end
       end
@@ -540,6 +537,10 @@ class ExcelToX
     @table_areas.each do |name, reference|
       @table_areas[name] = @replace_ranges_with_array_literals_replacer.map(reference)
     end
+
+    @table_data.each do |name, reference|
+      @table_data[name] = @replace_ranges_with_array_literals_replacer.map(reference)
+    end
     
   end
 
@@ -687,7 +688,7 @@ class ExcelToX
     log.info "Expanding #{@formulae_array.size} array formulae"
     # FIMXE: Refactor this
 
-    named_reference_replacer = ReplaceNamedReferencesAst.new(@named_references)
+    named_reference_replacer = ReplaceNamedReferencesAst.new(@named_references, nil, @table_data)
     table_reference_replacer = ReplaceTableReferenceAst.new(@tables)
     @replace_ranges_with_array_literals_replacer ||= ReplaceRangesWithArrayLiteralsAst.new
     expand_array_formulae_replacer = AstExpandArrayFormulae.new
@@ -885,7 +886,7 @@ class ExcelToX
     @shared_string_replacer ||= ReplaceSharedStringAst.new(@shared_strings)
     @replace_arithmetic_on_ranges_replacer ||= ReplaceArithmeticOnRangesAst.new
     @wrap_formulae_that_return_arrays_replacer ||= WrapFormulaeThatReturnArraysAndAReNotInArraysAst.new
-    @named_reference_replacer ||= ReplaceNamedReferencesAst.new(@named_references) 
+    @named_reference_replacer ||= ReplaceNamedReferencesAst.new(@named_references, nil, @table_data) 
     @table_reference_replacer ||= ReplaceTableReferenceAst.new(@tables)
     @replace_ranges_with_array_literals_replacer ||= ReplaceRangesWithArrayLiteralsAst.new
     @replace_arrays_with_single_cells_replacer ||= ReplaceArraysWithSingleCellsAst.new
@@ -893,6 +894,8 @@ class ExcelToX
     @sheetless_cell_reference_replacer ||= RewriteCellReferencesToIncludeSheetAst.new
     @replace_references_to_blanks_with_zeros ||= ReplaceReferencesToBlanksWithZeros.new(@formulae, nil, inline_ast_decision)
 
+    #require 'pry'; binding.pry
+
     cells.each do |ref, ast|
       begin
         @sheetless_cell_reference_replacer.worksheet = ref.first
@@ -919,27 +922,32 @@ class ExcelToX
         raise
       end
     end
+    #require 'pry'; binding.pry
   end
 
   # These types of cells don't conatain formulae and can therefore be skipped
   VALUE_TYPE = {:number => true, :string => true, :blank => true, :null => true, :error => true, :boolean_true => true, :boolean_false => true}
+
+  def must_keep?(ref)
+    must_keep_in_sheet = @cells_that_can_be_set_at_runtime[ref.first]
+    return false unless must_keep_in_sheet
+    return true if must_keep_in_sheet == :all
+    must_keep_in_sheet.include?(ref.last)
+  end
   
   def inline_ast_decision  
     @inline_ast_decision ||= lambda do |sheet, cell, references|
-      references_to_keep = @cells_that_can_be_set_at_runtime[sheet]
-      if references_to_keep && (references_to_keep == :all || references_to_keep.include?(cell))
+      ref = [sheet,cell]
+      if must_keep?(ref)
         false
       else
-        ast = references[[sheet,cell]]
+        ast = references[ref]
         if ast
           case ast.first
           when :number, :string; true
           when :blank, :null; true
           when :error; true
           when :boolean_true, :boolean_false; true
-          when :cell; true
-          when :sheet_reference
-            ast[2][0] != :named_reference
           else
             false
           end
@@ -993,6 +1001,7 @@ class ExcelToX
           inline_replacer.current_sheet_name = [ref.first]
           inline_replacer.map(ast)
           # If a formula references a cell containing a value, the reference is replaced with the value (e.g., if A1 := 2 and A2 := A1 + 1 then becomes: A2 := 2 + 1)
+          #require 'pry'; binding.pry if ref == [:"Outputs - Summary table", :E77]
           value_replacer.map(ast)
           column_and_row_function_replacement.current_reference = ref.last
           if column_and_row_function_replacement.replace(ast)
@@ -1316,4 +1325,9 @@ class ExcelToX
     @ruby_module_name
   end
 
+  def cleanup
+    log.info "Cleaning up"
+    FileUtils.remove_entry(self.xml_directory) if @delete_xml_directory_at_end
+  end
+
 end

data/src/compile/c/excel_to_c_runtime.c

@@ -4,6 +4,7 @@
 #include <stdlib.h>
 #include <ctype.h>
 #include <math.h>
+#include <locale.h>
 
 #ifndef NUMBER_OF_REFS
   #define NUMBER_OF_REFS 0
@@ -63,6 +64,7 @@ static ExcelValue find(ExcelValue string_to_look_for_v, ExcelValue string_to_loo
 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 iserr(ExcelValue value);
 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);
 static ExcelValue excel_isnumber(ExcelValue number);
@@ -670,6 +672,9 @@ static ExcelValue excel_index(ExcelValue array_v, ExcelValue row_number_v, Excel
 	
 	if(row_number > rows) return REF;
 	if(column_number > columns) return REF;
+
+  if(row_number == 0 && rows == 1) row_number = 1;
+  if(column_number == 0 && columns == 1) column_number = 1;
 		
 	if(row_number == 0) { // We need the whole column
 		if(column_number < 1) return REF;
@@ -1077,6 +1082,19 @@ static ExcelValue iferror(ExcelValue value, ExcelValue value_if_error) {
 	return value;
 }
 
+static ExcelValue iserr(ExcelValue value) {
+	if(value.type == ExcelError) {
+    if(value.number == NA.number) {
+      return FALSE;
+    } else {
+      return TRUE;
+    }
+  } else {
+    return FALSE;
+  }
+}
+
+
 // Order is TRUE, FALSE, String, Number; Blank is zero
 static ExcelValue more_than(ExcelValue a_v, ExcelValue b_v) {
   CHECK_FOR_PASSED_ERROR(a_v)
@@ -2015,6 +2033,8 @@ static ExcelValue sumproduct(int number_of_arguments, ExcelValue *arguments) {
   	return new_excel_number(sum);
 }
 
+// FIXME: This could do with being done properly, rather than
+// on a case by case basis.
 static ExcelValue text(ExcelValue number_v, ExcelValue format_v) {
   CHECK_FOR_PASSED_ERROR(number_v)
   CHECK_FOR_PASSED_ERROR(format_v)
@@ -2032,6 +2052,10 @@ static ExcelValue text(ExcelValue number_v, ExcelValue format_v) {
     return new_excel_string("");
   }
 
+  if(format_v.type == ExcelNumber && format_v.number == 0) {
+    format_v = new_excel_string("0");
+  }
+
   if(number_v.type == ExcelString) {
  	 	s = number_v.string;
 		if (s == NULL || *s == '\0' || isspace(*s)) {
@@ -2054,11 +2078,67 @@ static ExcelValue text(ExcelValue number_v, ExcelValue format_v) {
   if(strcmp(format_v.string,"0%") == 0) {
     // FIXME: Too little? 
     s = malloc(100);
-    sprintf(s, "%d%%",(int) round(number_v.number*100));
+    sprintf(s, "%0.0f%%", number_v.number*100);
+    free_later(s);
+    result = new_excel_string(s);
+  } 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);
+  } 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);
+  } 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);
+  } 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);
+  } 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);
+  } 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);
+  } 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);
+  } 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);
+  } 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);
+  } 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);
   } else {
-    return format_v;
+    return new_excel_string("Text format not recognised");
   }
 
   // inspect_excel_value(result);

data/src/compile/c/excel_to_c_runtime_test.c

@@ -221,6 +221,28 @@ int test_functions() {
   assert(iferror(new_excel_string("ok"),ONE).type == ExcelString);
   assert(iferror(VALUE,ONE).type == ExcelNumber);		
 
+  // Test the ISERR function
+  assert(iserr(NA).type == ExcelBoolean);
+  assert(iserr(NA).number == 0);
+  assert(iserr(DIV0).type == ExcelBoolean);
+  assert(iserr(DIV0).type == ExcelBoolean);
+  assert(iserr(REF).number == 1);
+  assert(iserr(REF).type == ExcelBoolean);
+  assert(iserr(VALUE).number == 1);
+  assert(iserr(VALUE).type == ExcelBoolean);
+  assert(iserr(NAME).number == 1);
+  assert(iserr(NAME).number == 1);
+  assert(iserr(BLANK).type == ExcelBoolean);
+  assert(iserr(BLANK).type == ExcelBoolean);
+  assert(iserr(TRUE).type == ExcelBoolean);
+  assert(iserr(TRUE).type == ExcelBoolean);
+  assert(iserr(FALSE).number == 0);
+  assert(iserr(FALSE).number == 0);
+  assert(iserr(ONE).number == 0);
+  assert(iserr(ONE).number == 0);
+  assert(iserr(new_excel_string("Hello")).number == 0);
+  assert(iserr(new_excel_string("Hello")).number == 0);
+
   // 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);
@@ -268,6 +290,10 @@ int test_functions() {
   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);
+  // ... it should return a single value if single column and passed zero as column number
+  assert(excel_index(index_array_1_v_column,new_excel_number(2.0), ZERO).number == 20);
+  assert(excel_index(index_array_1_v_row,ZERO, new_excel_number(2.0)).number == 20);
+
 
   // LEFT(string,[characters])
   // ... should return the left n characters from a string
@@ -672,9 +698,19 @@ int test_functions() {
   // 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(new_excel_string("0.00251"), new_excel_string("0.0%")).string, "0.3%") == 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);
+  assert(strcmp(text(new_excel_number(1.1518), new_excel_string("0")).string, "1") == 0);
+  assert(strcmp(text(new_excel_number(1.1518), ZERO).string, "1") == 0);
+  assert(strcmp(text(new_excel_number(1.1518), new_excel_string("0.0")).string, "1.2") == 0);
+  assert(strcmp(text(new_excel_number(1.1518), new_excel_string("0.00")).string, "1.15") == 0);
+  assert(strcmp(text(new_excel_number(12.51), new_excel_string("0000")).string, "0013") == 0);
+  assert(strcmp(text(new_excel_number(125101), new_excel_string("0000")).string, "125101") == 0);
+  assert(strcmp(text(new_excel_number(123456789.123456), new_excel_string("#,##")).string, "123,456,789") == 0);
+  assert(strcmp(text(new_excel_number(123456789.123456), new_excel_string("#,##0")).string, "123,456,789") == 0);
+  assert(strcmp(text(new_excel_number(123456789.123456), new_excel_string("#,##0.0")).string, "123,456,789.1") == 0);
 
   // Test LOG
   // One argument variant assumes LOG base 10

data/src/compile/c/map_formulae_to_c.rb

@@ -46,6 +46,7 @@ class MapFormulaeToC < MapValuesToC
     :'IF2' => 'excel_if_2',
     :'IF3' => 'excel_if',
     :'IFERROR' => 'iferror',
+    :'ISERR' => 'iserr',
     :'INDEX2' => 'excel_index_2',
     :'INDEX3' => 'excel_index',
     :'INT' => 'excel_int',
@@ -56,6 +57,7 @@ class MapFormulaeToC < MapValuesToC
     :'LEFT2' => 'left',
     :'LEN' => 'len',
     :'LN' => 'ln',
+    :'LOG10' => 'excel_log',
     :'LOG1' => 'excel_log',
     :'LOG2' => 'excel_log_2',
     :'MATCH2' => 'excel_match_2',

data/src/compile/ruby/map_formulae_to_ruby.rb

@@ -36,12 +36,14 @@ class MapFormulaeToRuby < MapValuesToRuby
     :'INDEX' => 'index',
     :'INT' => 'int',
     :'ISBLANK' => 'isblank',
+    :'ISERR' => 'iserr',
     :'ISNUMBER' => 'isnumber',
     :'LARGE' => 'large',
     :'LEFT' => 'left',
     :'LEN' => 'len',
     :'LN' => 'ln',
     :'LOG' => 'log',
+    :'LOG10' => 'log',
     :'LOWER' => 'lower',
     :'MATCH' => 'excel_match',
     :'MAX' => 'max',

data/src/excel/excel_functions/index.rb

@@ -37,12 +37,14 @@ module ExcelFunctions
   def index_for_whole_row(array,row_number)
     return :ref if row_number < 1
     return :ref if row_number > array.length
+    return index_for_row_column(array, row_number, 1) if array.first.length == 1
     [array[row_number-1]]
   end
   
   def index_for_whole_column(array,column_number)
     return :ref if column_number < 1
     return :ref if column_number > array[0].length
+    return index_for_row_column(array, 1, column_number) if array.length == 1
     array.map { |row| [row[column_number-1]]}
   end
 end

data/src/excel/excel_functions/iserr.rb

@@ -0,0 +1,9 @@
+module ExcelFunctions
+  
+  def iserr(a)
+    return false if a == :na
+    return true if a.is_a?(Symbol)
+    false
+  end
+  
+end

data/src/excel/excel_functions/text.rb

@@ -3,6 +3,7 @@ module ExcelFunctions
   def text(number, format)
     number ||= 0
     return "" unless format
+    format = "0" if format == 0.0
 
     if number.is_a?(String)
       begin
@@ -15,10 +16,19 @@ module ExcelFunctions
     return format if format.is_a?(Symbol)
 
     case format
-    when '0%'
-      "#{(number * 100).round}%"
+    when /^(0(\.0*)?)%/
+      text(number*100, $1)+"%"
+    when /^(0+)$/
+      sprintf("%0#{$1.length}.0f", number)
+    when /#,#+(0\.0+)?/
+      formated_with_decimals = text(number, $1 || "0")
+      parts = formated_with_decimals.split('.')
+      parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1,")
+      parts.join('.')
+    when /0\.(0+)/
+      sprintf("%.#{$1.length}f", number)
     else
-      format
+      raise ExcelToCodeException.new("in TEXT function format #{format} not yet supported by excel_to_code")
     end
   end
   

data/src/excel/excel_functions.rb

@@ -111,3 +111,5 @@ require_relative 'excel_functions/ensure_is_number'
 require_relative 'excel_functions/value'
 
 require_relative 'excel_functions/ln'
+
+require_relative 'excel_functions/iserr'

data/src/excel/formula_peg.rb

@@ -27,7 +27,7 @@ class Formula < RubyPeg
   
   def function
     node :function do
-      terminal(/[A-Z]+/) && ignore { terminal("(") } && space && optional { argument } && any_number_of { (space && ignore { terminal(",") } && space && argument) } && space && ignore { terminal(")") }
+      terminal(/(LOG10)|[A-Z]+/) && ignore { terminal("(") } && space && optional { argument } && any_number_of { (space && ignore { terminal(",") } && space && argument) } && space && ignore { terminal(")") }
     end
   end
   

data/src/excel/formula_peg.txt

@@ -2,7 +2,7 @@ formula                         := space? expression+
 expression                       = string_join | comparison | arithmetic | thing
 thing                            = percentage | function | array | brackets | any_reference | string | number | boolean | prefix | error | named_reference 
 argument                         = expression | null
-function                        := /[A-Z]+/ `'(' space argument? (space `',' space argument)* space `')'
+function                        := /(LOG10)|[A-Z]+/ `'(' space argument? (space `',' space argument)* space `')'
 brackets                        := `'(' space expression+ space `')'
 array							:= `'{' space  row ( space `';' space row )* space `'}'
 row								:= basic_type ( space `',' space basic_type )*

data/src/excel/table.rb

@@ -110,6 +110,10 @@ class Table
   def all
     ast_for_area @area.excel_start, @area.excel_finish
   end
+
+  def data
+    ast_for_area @data_area.excel_start, @data_area.excel_finish
+  end
   
   def ast_for_area(start,finish)
     [:sheet_reference,@worksheet,[:area,start.to_sym,finish.to_sym]]

data/src/excel_to_code.rb

@@ -1,5 +1,5 @@
 class ExcelToCode
-  def self.version() "0.2.28" end
+  def self.version() "0.2.29" end
 end
 
 require_relative 'commands'

data/src/simplify/inline_formulae.rb

@@ -11,10 +11,17 @@ class InlineFormulaeAst
   
   def map(ast)
     return ast unless ast.is_a?(Array)
-    if respond_to?(ast[0])
-      send(ast[0], ast) 
-    else # In this case needs to be an else because don't want to map first argument in OFFSET(cell_to_offset_from_shouldn't_be_mapped, rows, columns)
-      ast.each { |a| map(a) }
+    case ast[0]
+    when :function
+      function(ast)
+    when :sheet_reference
+      sheet_reference(ast)
+    when :cell
+      cell(ast)
+    else
+      ast.each do |a| 
+        map(a) if a.is_a?(Array)
+      end
     end
     ast
   end
@@ -45,8 +52,8 @@ class InlineFormulaeAst
     ref = ast[2][1].to_s.upcase.gsub('$','').to_sym
     # FIXME: Need to check if valid worksheet and return [:error, "#REF!"] if not
     # Now check user preference on this
-    ast_to_inline = ast_to_inline(sheet, ref)
     return unless inline_ast.call(sheet,ref, references)
+    ast_to_inline = ast_or_blank(sheet, ref)
     @count_replaced += 1
     current_sheet_name.push(sheet)
     map(ast_to_inline)
@@ -58,8 +65,8 @@ class InlineFormulaeAst
   def cell(ast)
     sheet = current_sheet_name.last
     ref = ast[1].to_s.upcase.gsub('$', '').to_sym
-    ast_to_inline = ast_to_inline(sheet, ref)
     if inline_ast.call(sheet, ref, references)
+      ast_to_inline = ast_or_blank(sheet, ref)
       @count_replaced += 1
       map(ast_to_inline)
       ast.replace(ast_to_inline)
@@ -69,7 +76,7 @@ class InlineFormulaeAst
     end
   end
 
-  def ast_to_inline(sheet, ref)
+  def ast_or_blank(sheet, ref)
     ast_to_inline = references[[sheet, ref]]
     return ast_to_inline if ast_to_inline
     # Need to add a new blank cell and return ast for an inlined blank

data/src/simplify/map_formulae_to_values.rb

@@ -140,6 +140,12 @@ class MapFormulaeToValues
     ast.replace(formula_value( ast[1],*values))
   end
 
+  def map_text(ast)
+    values = ast[2..-1].map { |a| value(a, nil) }
+    return if values.any? { |a| a == :not_a_value }
+    ast.replace(formula_value( ast[1],*values))
+  end
+
   def map_if(ast)
     condition_ast = ast[2]
     true_option_ast = ast[3]

data/src/simplify/replace_arithmetic_on_ranges.rb

@@ -9,6 +9,8 @@ class ReplaceArithmeticOnRangesAst
         next
       when :sheet_reference, :table_reference, :local_table_reference
         next
+      when :function
+        function(ast)
       else
         map(a)
       end
@@ -18,6 +20,21 @@ class ReplaceArithmeticOnRangesAst
     ast
   end
 
+  # FIXME: Generalise this? Combine with Array formulae?
+  def function(ast)
+    unless [:RIGHT, :LEFT].include?(ast[1]) && ast[2][0] == :array
+      ast.each { |a| map(a) }
+      return
+    end
+    ast.replace(
+      array_map(ast[2]) do |cell|
+        a = ast.dup
+        a[2] = cell
+        a
+      end
+    )
+  end
+
   # FIXME: DRY THIS UP
   def comparison(ast)
     left, operator, right = ast[1], ast[2], ast[3]

data/src/simplify/replace_named_references.rb

@@ -1,9 +1,10 @@
 class NamedReferences
   
-  attr_accessor :named_references
+  attr_accessor :named_references, :table_data
   
-  def initialize(refs)
+  def initialize(refs, tables = {})
     @named_references = refs
+    @table_data = tables
   end
   
   def reference_for(sheet,named_reference)
@@ -11,6 +12,7 @@ class NamedReferences
     named_reference = named_reference.downcase.to_sym
     @named_references[[sheet, named_reference]] ||
     @named_references[named_reference] ||
+    @table_data[named_reference] ||
     [:error, :"#NAME?"]
   end
   
@@ -18,11 +20,11 @@ end
 
 class ReplaceNamedReferencesAst
   
-  attr_accessor :named_references, :default_sheet_name
+  attr_accessor :named_references, :default_sheet_name, :table_data
   
-  def initialize(named_references, default_sheet_name = nil)
-    @named_references, @default_sheet_name = named_references, default_sheet_name
-    @named_references = NamedReferences.new(@named_references) unless @named_references.is_a?(NamedReferences)
+  def initialize(named_references, default_sheet_name = nil, table_data = {})
+    @named_references, @default_sheet_name, @table_data = named_references, default_sheet_name, table_data
+    @named_references = NamedReferences.new(@named_references, @table_data) unless @named_references.is_a?(NamedReferences)
   end
   
   def map(ast)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: excel_to_code
 version: !ruby/object:Gem::Version
-  version: 0.2.28
+  version: 0.2.29
 platform: ruby
 authors:
 - Thomas Counsell, Green on Black Ltd
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-16 00:00:00.000000000 Z
+date: 2014-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubypeg
@@ -122,7 +122,10 @@ description: "# excel_to_code\n\nConverts some excel spreadsheets (.xlsx, not .x
   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"
+  multithread and will give bad results if you try\n7. Newlines are removed from strings\n8.
+  The generated code uses floating point, rather than fully precise arithmetic, so
+  results can differ slightly\n9. The generated code uses the sprintf approach to
+  rounding (even-odd) rather than excel's 0.5 rounds away from zero.\n"
 email: tamc@greenonblack.com
 executables:
 - excel_to_c
@@ -186,6 +189,7 @@ files:
 - src/excel/excel_functions/index.rb
 - src/excel/excel_functions/int.rb
 - src/excel/excel_functions/isblank.rb
+- src/excel/excel_functions/iserr.rb
 - src/excel/excel_functions/isnumber.rb
 - src/excel/excel_functions/large.rb
 - src/excel/excel_functions/left.rb