excel_to_code 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 880640b9610ce6658c3ba7a5ff8d6f96048d0705
-  data.tar.gz: 08f680f1229c0e00d769b3b7024e452a32a5ebd5
+  metadata.gz: 4e983a098e0ba3377ae5b0d42b53c5d627e765e8
+  data.tar.gz: dd9b3766572dd84f5bf980fb256bfd7ce70fdb49
 SHA512:
-  metadata.gz: 244303086ecf46f8be290f2d1c46f4c2b929c21b2bca0f7129d9edeb65e06e068824039250f650d12b3eaa4f85b2e9d08423b042cbf71b68e9a4d9f4c3311e4f
-  data.tar.gz: d40bf490120ec061bf94fbf65c32daf136edd1d9abefb833c1e1cf8a0c17940d80c6fe5e8ca8fd436c22aad17db8f3cbdc5312a55338317ab16614b7be107c98
+  metadata.gz: b829c3fb99bd61216b7df001ad320a9a0ecd6f6157fc07ac0c368417354e853544f25ae8b31b43dde6fb788480c6ac9e8559b6646fd8a5d55bd4a054885c0e62
+  data.tar.gz: 6d1f1519d8daf601c6028c6c116eadd8c76dada8edb5153ee42d49946fa97831b18d0d086e46a59b49823c6126e893638f0247c2e30b2de08a3f053a917bc49a

data/TODO

@@ -19,7 +19,6 @@ See doc/How_to_add_a_missing_function.md
 
 * Optimize IF, CHOOSE, MATCH, VLOOKUP and similar functions so that they don't have to calculate all their arguments
 * Fix it so that cells that are being reported as empty, that excel would give a numeric value of zero, are fixed
-* Fix so that detects when it has finished replacing cells with values, rather than just doing a fixed number of cycles
 
 ## Things that are badly written
 

data/src/commands/excel_to_c.rb

@@ -36,13 +36,14 @@ class ExcelToC < ExcelToX
     
     # Now we have to put all the initial definitions out
     o.puts "// definitions"
+    o.puts "static ExcelValue ORIGINAL_EXCEL_FILENAME = {.type = ExcelString, .string = #{excel_file.inspect} };"
 
     i = input("Common elements")
     c = CompileToCHeader.new
     c.gettable = lambda { |ref| false }
     c.rewrite(i,w,o)
     i.rewind
-    number_of_refs += i.lines.to_a.size
+    number_of_refs += i.each_line.to_a.size
     close(i)
 
     worksheets do |name,xml_filename|
@@ -54,7 +55,7 @@ class ExcelToC < ExcelToX
       i = input([name,"Formulae"])
       c.rewrite(i,w,o)
       i.rewind
-      number_of_refs += i.lines.to_a.size
+      number_of_refs += i.each_line.to_a.size
       close(i)
     end
     
@@ -82,7 +83,7 @@ class ExcelToC < ExcelToX
     o.puts "// starting the value constants"
     mapper = MapValuesToCStructs.new
     i = input("Constants")
-    i.lines do |line|
+    i.each_line do |line|
       begin
         ref, formula = line.split("\t")
         ast = eval(formula)
@@ -344,7 +345,7 @@ END
 
     # Getters
     i = input('Named references to keep')
-    i.lines.each do |line|
+    i.each_line do |line|
       name = line.strip.split("\t").first
       o.puts "  attach_function '#{name}', [], ExcelValue.by_value"
     end
@@ -352,7 +353,7 @@ END
 
     # Setters
     i = input('Named references to set')
-    i.lines.each do |line|
+    i.each_line do |line|
       name = line.strip.split("\t").first
       o.puts "  attach_function 'set_#{name}', [ExcelValue.by_value], :void"
     end

data/src/commands/excel_to_ruby.rb

@@ -30,6 +30,7 @@ class ExcelToRuby < ExcelToX
     o.puts ""
     o.puts "class #{ruby_module_name}"
     o.puts "  include ExcelFunctions"
+    o.puts "  def original_excel_filename; #{excel_file.inspect}; end"
     
     o.puts  
     o.puts "  # Starting common elements"
@@ -66,7 +67,7 @@ class ExcelToRuby < ExcelToX
     o.puts "  # starting initializer"
     o.puts "  def initialize"
     d = input('Defaults')
-    d.lines do |line|
+    d.each_line do |line|
       o.puts line
     end
     o.puts "  end"

data/src/commands/excel_to_x.rb

@@ -110,9 +110,11 @@ class ExcelToX
     self.cells_that_can_be_set_at_runtime ||= {}
     
     # Make sure that all the cell names are downcase and don't have any $ in them
-    cells_that_can_be_set_at_runtime.keys.each do |sheet|
-      next unless cells_that_can_be_set_at_runtime[sheet].is_a?(Array)
-      cells_that_can_be_set_at_runtime[sheet] = cells_that_can_be_set_at_runtime[sheet].map { |reference| reference.gsub('$','').upcase }
+    if cells_that_can_be_set_at_runtime.is_a?(Hash)
+      cells_that_can_be_set_at_runtime.keys.each do |sheet|
+        next unless cells_that_can_be_set_at_runtime[sheet].is_a?(Array)
+        cells_that_can_be_set_at_runtime[sheet] = cells_that_can_be_set_at_runtime[sheet].map { |reference| reference.gsub('$','').upcase }
+      end
     end
 
     # Make sure that all the cell names are downcase and don't have any $ in them
@@ -168,9 +170,9 @@ class ExcelToX
     simplify_worksheets # Replacing shared strings and named references with their actual values, tidying arithmetic
 
     # In case this hasn't been set by the user
-    if cells_that_can_be_set_at_runtime.empty?
+    if @cells_that_can_be_set_at_runtime.empty?
       log.info "Creating a good set of cells that should be settable"
-      create_a_good_set_of_cells_that_should_be_settable_at_runtime
+      @cells_that_can_be_set_at_runtime = a_good_set_of_cells_that_should_be_settable_at_runtime
     end
 
     if named_references_that_can_be_set_at_runtime == :where_possible
@@ -313,7 +315,7 @@ class ExcelToX
     table_filenames = input(name, "Worksheet tables")
     tables = intermediate(name, "Worksheet tables")
     table_extractor = ExtractTable.new(name)
-    table_filenames.lines.each do |line|
+    table_filenames.each_line do |line|
       table_xml = xml(File.join('worksheets',line.strip))
       table_extractor.extract(table_xml, tables)
     end
@@ -328,7 +330,7 @@ class ExcelToX
     worksheets do |name,xml_filename|
       log.info "Merging table files for #{name}"
       worksheet_table_file = input([name, "Worksheet tables"])
-      worksheet_table_file.lines do |line|
+      worksheet_table_file.each_line do |line|
         merged_table_file.puts line
       end
       close worksheet_table_file
@@ -477,6 +479,9 @@ class ExcelToX
   def work_out_which_named_references_can_be_set_at_runtime
     return unless @named_references_that_can_be_set_at_runtime
     return unless @named_references_that_can_be_set_at_runtime == :where_possible
+    cells_that_can_be_set = @cells_that_can_be_set_at_runtime
+    cells_that_can_be_set = a_good_set_of_cells_that_should_be_settable_at_runtime if cells_that_can_be_set == :named_references_only
+    cells_that_can_be_set_due_to_named_reference = Hash.new { |h,k| h[k] = Array.new  }
     @named_references_that_can_be_set_at_runtime = []
     all_named_references = named_references
     @named_references_to_keep.each do |name|
@@ -484,23 +489,34 @@ class ExcelToX
       if ref.first == :sheet_reference
         sheet = ref[1]
         cell = ref[2][1].gsub('$','')
-        s = @cells_that_can_be_set_at_runtime[sheet]
-        @named_references_that_can_be_set_at_runtime << name if s && s.include?(cell)
+        s = cells_that_can_be_set[sheet]
+        if s && s.include?(cell)
+          @named_references_that_can_be_set_at_runtime << name 
+          cells_that_can_be_set_due_to_named_reference[sheet] << cell
+          cells_that_can_be_set_due_to_named_reference[sheet].uniq!
+        end
       elsif ref.first.is_a?(Array)
         ref = ref.first
-        p ref
-        settable = ref.all? do |row|
-          ref.all? do |column|
-            p column
-            sheet = column[1]
-            cell = column[2][1].gsub('$','')
-            s = @cells_that_can_be_set_at_runtime[sheet]
-            s && s.include?(cell)
+        settable = ref.all? do |r|
+          sheet = r[1]
+          cell = r[2][1].gsub('$','')
+          s = cells_that_can_be_set[sheet]
+          s && s.include?(cell)
+        end
+        if settable
+          @named_references_that_can_be_set_at_runtime << name 
+          ref.each do |r| 
+            sheet = r[1]
+            cell = r[2][1].gsub('$','')
+            cells_that_can_be_set_due_to_named_reference[sheet] << cell
+            cells_that_can_be_set_due_to_named_reference[sheet].uniq!
           end
         end
-        @named_references_that_can_be_set_at_runtime << name if settable
       end
     end
+    if @cells_that_can_be_set_at_runtime == :named_references_only
+      @cells_that_can_be_set_at_runtime = cells_that_can_be_set_due_to_named_reference
+    end
   end
 
   # FIXME: Feels like a kludge
@@ -510,7 +526,7 @@ class ExcelToX
 
     i = input('Named references')
     o = intermediate('Named references to keep')
-    i.lines.each do |line|
+    i.each_line do |line|
       sheet, name, ref = *line.split("\t")
       key = sheet.length != 0 ? [sheet, name] : name
       o.puts line if named_references_to_keep.include?(key) || named_references_that_can_be_set_at_runtime.include?(key)
@@ -519,7 +535,7 @@ class ExcelToX
 
     i.rewind
     o = intermediate('Named references to set')
-    i.lines.each do |line|
+    i.each_line do |line|
       sheet, name, ref = *line.split("\t")
       key = sheet.length != 0 ? [sheet, name] : name
       o.puts line if named_references_that_can_be_set_at_runtime.include?(key)
@@ -550,25 +566,35 @@ class ExcelToX
     end
   end
     
-  # FIXME: This should work out how often it needs to operate, rather than having a hardwired 4
   def replace_formulae_with_their_results
-    4.times do 
-      replace_indirects
+    number_of_passes = 0
+    begin 
+      number_of_passes += 1
+      @replacements_made_in_the_last_pass = 0
+      replace_indirects_and_offsets
       replace_formulae_with_calculated_values
       replace_references_to_values_with_values
-    end
+      log.info "Pass #{number_of_passes}: Made #{@replacements_made_in_the_last_pass} replacements"
+      if number_of_passes > 20
+        log.warn "Made more than 20 passes, so aborting"
+        break
+      end
+    end while @replacements_made_in_the_last_pass > 0
   end
   
-  # There is no support for INDIRECT in the ruby or c runtime
+  # There is no support for INDIRECT or OFFSET in the ruby or c runtime
   # However, in many cases it isn't needed, because we can work
-  # out the value of the indirect at compile time and eliminate it
-  def replace_indirects
+  # out the value of the indirect or OFFSET at compile time and eliminate it
+  def replace_indirects_and_offsets
     worksheets do |name,xml_filename|
-      log.info "Replacing indirects in #{name}"
+      log.info "Replacing INDIRECT, OFFSET and COLUMN functions in #{name}"
       
       # First of all we replace any indirects where their values can be calculated at compile time with those
-      # calculated values (e.g., INDIRECT("A"&1) can be turned into A1)
-      replace ReplaceIndirectsWithReferences, [name, 'Formulae'],  [name, 'Formulae']
+      # calculated values (e.g., INDIRECT("A"&1) can be turned into A1 and OFFSET(A1,1,1,2,2) can be turned into B2:C3)
+      [ReplaceIndirectsWithReferences.new, ReplaceOffsetsWithReferences.new, ReplaceColumnWithColumnNumber.new].each do |r|
+        replace r, [name, 'Formulae'],  [name, 'Formulae']
+        @replacements_made_in_the_last_pass += r.replacements_made_in_the_last_pass
+      end
       
       # The result of the indirect might be a named reference, which we need to simplify
       r = ReplaceNamedReferences.new
@@ -589,7 +615,10 @@ class ExcelToX
   # If a formula's value can be calculated at compile time, it is replaced with its calculated value (e.g., 1+1 gets replaced with 2)
   def replace_formulae_with_calculated_values    
     worksheets do |name,xml_filename|
-      replace ReplaceFormulaeWithCalculatedValues, [name, 'Formulae'],  [name, 'Formulae']
+      r = ReplaceFormulaeWithCalculatedValues.new
+      r.excel_file = excel_file
+      replace r, [name, 'Formulae'],  [name, 'Formulae']
+      @replacements_made_in_the_last_pass += r.replacements_made_in_the_last_pass
     end
   end
 
@@ -623,6 +652,7 @@ class ExcelToX
       r.default_sheet_name = name
       replace r, [name, 'Formulae'],  [name, 'Formulae']
     end
+    @replacements_made_in_the_last_pass += r.replacements_made_in_the_last_pass
   end
   
   # If 'cells to keep' are specified, then other cells are removed, unless
@@ -773,10 +803,11 @@ class ExcelToX
   # or in cells_that_can_be_set_at_runtime, then we assume that
   # all value cells should be settable if they are referenced by
   # any other forumla.
-  def create_a_good_set_of_cells_that_should_be_settable_at_runtime
+  def a_good_set_of_cells_that_should_be_settable_at_runtime
     references = all_formulae
     counter = CountFormulaReferences.new
     count = counter.count(references)
+    settable_cells = {}
 
     count.each do |sheet,keys|
       keys.each do |ref,count|
@@ -784,11 +815,12 @@ class ExcelToX
         ast = references[sheet][ref]
         next unless ast
         if [:blank,:number,:null,:string,:shared_string,:constant,:percentage,:error,:boolean_true,:boolean_false].include?(ast.first)
-          @cells_that_can_be_set_at_runtime[sheet] ||= []
-          @cells_that_can_be_set_at_runtime[sheet] << ref.upcase
+          settable_cells[sheet] ||= []
+          settable_cells[sheet] << ref.upcase
         end
       end
-    end    
+    end
+    return settable_cells
   end
   
   # UTILITY FUNCTIONS
@@ -820,7 +852,7 @@ class ExcelToX
     worksheets do |name,xml_filename|
       r = references[name] = {}
       i = input([name,'Formulae'])
-      i.lines do |line|
+      i.each_line do |line|
         line =~ /^(.*?)\t(.*)$/
         ref, ast = $1, $2
         r[ref] = eval(ast)
@@ -841,7 +873,7 @@ class ExcelToX
   def worksheets(&block)
     unless @worksheet_filenames
       worksheet_names = input('Worksheet names')
-      @worksheet_filenames = worksheet_names.lines.map do |line|
+      @worksheet_filenames = worksheet_names.each_line.map do |line|
         name, filename = *line.split("\t")
         [name, filename.strip]
       end

data/src/compile/c/compile_named_reference_setters.rb

@@ -74,7 +74,7 @@ class CompileNamedReferenceSetters
     mapper.sheet_names = Hash[sheet_names.readlines.map { |line| line.strip.split("\t")}]
     mapper.cells_that_can_be_set_at_runtime = cells_that_can_be_set_at_runtime
 
-    named_references.lines do |line|
+    named_references.each_line do |line|
       name, reference = line.split("\t")
       ast = eval(reference)
       output.puts "void set_#{name}(ExcelValue newValue) {"

data/src/compile/c/compile_to_c.rb

@@ -19,7 +19,7 @@ class CompileToC
     mapper.worksheet = worksheet
     mapper.sheet_names = Hash[sheet_names_file.readlines.map { |line| line.strip.split("\t")}]
     c_name = mapper.sheet_names[worksheet] || worksheet
-    input.lines do |line|
+    input.each_line do |line|
       begin
         ref, formula = line.split("\t")
         ast = eval(formula)

data/src/compile/c/compile_to_c_header.rb

@@ -12,7 +12,7 @@ class CompileToCHeader
     c_name = Hash[sheet_names_file.readlines.map { |line| line.strip.split("\t")}][worksheet]
     self.gettable ||= lambda { |ref| true }
     self.settable ||= lambda { |ref| false }
-    input.lines do |line|
+    input.each_line do |line|
       begin
         ref, formula = line.split("\t")
         static_or_not = (gettable.call(ref) || settable.call(ref)) ? "" : "static "

data/src/compile/c/excel_to_c_runtime.c

@@ -67,6 +67,9 @@ static ExcelValue mod(ExcelValue a_v, ExcelValue b_v);
 static ExcelValue negative(ExcelValue a_v);
 static ExcelValue pmt(ExcelValue rate_v, ExcelValue number_of_periods_v, ExcelValue present_value_v);
 static ExcelValue power(ExcelValue a_v, ExcelValue b_v);
+static ExcelValue pv_3(ExcelValue a_v, ExcelValue b_v, ExcelValue c_v);
+static ExcelValue pv_4(ExcelValue a_v, ExcelValue b_v, ExcelValue c_v, ExcelValue d_v);
+static ExcelValue pv_5(ExcelValue a_v, ExcelValue b_v, ExcelValue c_v, ExcelValue d_v, ExcelValue e_v);
 static ExcelValue excel_round(ExcelValue number_v, ExcelValue decimal_places_v);
 static ExcelValue rounddown(ExcelValue number_v, ExcelValue decimal_places_v);
 static ExcelValue roundup(ExcelValue number_v, ExcelValue decimal_places_v);
@@ -77,6 +80,7 @@ static ExcelValue sumifs(ExcelValue sum_range_v, int number_of_arguments, ExcelV
 static ExcelValue sumif(ExcelValue check_range_v, ExcelValue criteria_v, ExcelValue sum_range_v );
 static ExcelValue sumif_2(ExcelValue check_range_v, ExcelValue criteria_v);
 static ExcelValue sumproduct(int number_of_arguments, ExcelValue *arguments);
+static ExcelValue text(ExcelValue number_v, ExcelValue format_v);
 static ExcelValue vlookup_3(ExcelValue lookup_value_v,ExcelValue lookup_table_v, ExcelValue column_number_v);
 static ExcelValue vlookup(ExcelValue lookup_value_v,ExcelValue lookup_table_v, ExcelValue column_number_v, ExcelValue match_type_v);
 
@@ -122,7 +126,7 @@ static ExcelValue new_excel_number(double number) {
 static ExcelValue new_excel_string(char *string) {
 	cell_counter++;
 	HEAPCHECK
-	ExcelValue new_cell = 	cells[cell_counter];
+	ExcelValue new_cell = cells[cell_counter];
 	new_cell.type = ExcelString;
 	new_cell.string = string;
 	return new_cell;
@@ -1071,6 +1075,57 @@ static ExcelValue pmt(ExcelValue rate_v, ExcelValue number_of_periods_v, ExcelVa
 	return new_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) {
+  return pv_4(rate_v, nper_v, pmt_v, ZERO);
+}
+
+static ExcelValue pv_4(ExcelValue rate_v, ExcelValue nper_v, ExcelValue pmt_v, ExcelValue fv_v) {
+  return pv_5(rate_v, nper_v, pmt_v, fv_v, ZERO);
+}
+
+static ExcelValue pv_5(ExcelValue rate_v, ExcelValue nper_v, ExcelValue pmt_v, ExcelValue fv_v, ExcelValue type_v ) {
+  CHECK_FOR_PASSED_ERROR(rate_v)
+  CHECK_FOR_PASSED_ERROR(nper_v)
+  CHECK_FOR_PASSED_ERROR(pmt_v)
+  CHECK_FOR_PASSED_ERROR(fv_v)
+  CHECK_FOR_PASSED_ERROR(type_v)
+
+  NUMBER(rate_v, rate)
+  NUMBER(nper_v, nper)
+  NUMBER(pmt_v, payment)
+  NUMBER(fv_v, fv)
+  NUMBER(type_v, start_of_period)
+  CHECK_FOR_CONVERSION_ERROR
+
+  if(rate< 0) {
+    return VALUE;
+  }
+
+  double present_value = 0;
+
+  // Sum up the payments
+  if(rate == 0) {
+    present_value = -payment * nper;
+  } else {
+    present_value = -payment * ((1-pow(1+rate,-nper))/rate);
+  }
+
+  // Adjust for beginning or end of period
+  if(start_of_period == 0) {
+   // Do Nothing
+  } else if(start_of_period == 1) {
+   present_value = present_value * (1+rate);
+  } else {
+   return VALUE;
+  } 
+
+  // Add on the final value
+  present_value = present_value - (fv/pow(1+rate,nper));
+  
+  return new_excel_number(present_value);
+}
+
+
 static ExcelValue power(ExcelValue a_v, ExcelValue b_v) {
 	CHECK_FOR_PASSED_ERROR(a_v)
 	CHECK_FOR_PASSED_ERROR(b_v)
@@ -1517,6 +1572,56 @@ static ExcelValue sumproduct(int number_of_arguments, ExcelValue *arguments) {
   	return new_excel_number(sum);
 }
 
+static ExcelValue text(ExcelValue number_v, ExcelValue format_v) {
+  CHECK_FOR_PASSED_ERROR(number_v)
+  CHECK_FOR_PASSED_ERROR(format_v)
+
+	char *s;
+	char *p;
+	double n;
+  ExcelValue result;
+
+  if(number_v.type == ExcelEmpty) {
+    number_v = ZERO;
+  }
+
+  if(format_v.type == ExcelEmpty) {
+    return new_excel_string("");
+  }
+
+  if(number_v.type == ExcelString) {
+ 	 	s = number_v.string;
+		if (s == NULL || *s == '\0' || isspace(*s)) {
+			number_v = ZERO;
+		}	        
+		n = strtod (s, &p);
+		if(*p == '\0') {
+		  number_v = new_excel_number(n);
+		}
+  }
+
+  if(number_v.type != ExcelNumber) {
+    return number_v;
+  }
+
+  if(format_v.type != ExcelString) {
+    return format_v;
+  }
+
+  if(format_v.string == "0%") {
+    // FIXME: Too little? 
+    s = malloc(100);
+    free_later(s);
+    sprintf(s, "%d%%",(int) round(number_v.number*100));
+    result = new_excel_string(s);
+  } else {
+    return format_v;
+  }
+
+  // inspect_excel_value(result);
+  return result;
+}
+
 static ExcelValue vlookup_3(ExcelValue lookup_value_v,ExcelValue lookup_table_v, ExcelValue column_number_v) {
   return vlookup(lookup_value_v,lookup_table_v,column_number_v,TRUE);
 }
@@ -2165,7 +2270,18 @@ int test_functions() {
   ExcelValue sum_array_0_v = new_excel_range(sum_array_0,3,1);
   ExcelValue sum_array_1[] = {sum_array_0_v};
   assert(sum(1,sum_array_1).number == 1253.8718091935484);
+
+  // Test PV
+  assert((int) pv_3(new_excel_number(0.03), new_excel_number(12), new_excel_number(100)).number == -995);
+  assert((int) pv_4(new_excel_number(0.03), new_excel_number(12), new_excel_number(-100), new_excel_number(100)).number == 925);
+  assert((int) pv_5(new_excel_number(0.03), new_excel_number(12), new_excel_number(-100), new_excel_number(-100), new_excel_number(1)).number == 1095);
   
+  // Test TEXT
+  assert(strcmp(text(new_excel_number(1.0), new_excel_string("0%")).string, "100%") == 0);
+  assert(strcmp(text(new_excel_string("1"), new_excel_string("0%")).string, "100%") == 0);
+  assert(strcmp(text(BLANK, new_excel_string("0%")).string, "0%") == 0);
+  assert(strcmp(text(new_excel_number(1.0), BLANK).string, "") == 0);
+  assert(strcmp(text(new_excel_string("ASGASD"), new_excel_string("0%")).string, "ASGASD") == 0);
   // Release memory
   free_all_allocated_memory();