excel_to_code 0.1.23 → 0.2.0

data/src/compile/c/compile_named_reference_setters.rb

@@ -25,7 +25,7 @@ class MapNamedReferenceToCSetter
   end
 
   def cell(reference)
-    reference.downcase.gsub('$','')
+    Reference.for(reference).unfix.downcase.to_s
   end
 
   def sheet_reference(sheet,reference)
@@ -56,7 +56,7 @@ class MapNamedReferenceToCSetter
     settable_refs = cells_that_can_be_set_at_runtime[sheet]
     return false unless settable_refs
     return true if settable_refs == :all
-    settable_refs.include?(reference.upcase) 
+    settable_refs.include?(reference.upcase.to_sym) 
   end
 
 end
@@ -71,12 +71,10 @@ class CompileNamedReferenceSetters
 
   def rewrite(named_references, sheet_names, output)
     mapper = MapNamedReferenceToCSetter.new
-    mapper.sheet_names = Hash[sheet_names.readlines.map { |line| line.strip.split("\t")}]
+    mapper.sheet_names = sheet_names
     mapper.cells_that_can_be_set_at_runtime = cells_that_can_be_set_at_runtime
 
-    named_references.each_line do |line|
-      name, reference = line.split("\t")
-      ast = eval(reference)
+    named_references.each do |name, ast|
       output.puts "void set_#{name}(ExcelValue newValue) {"
       output.puts mapper.map(ast)
       output.puts "}"

data/src/compile/c/compile_to_c.rb

@@ -4,28 +4,32 @@ class CompileToC
   
   attr_accessor :settable
   attr_accessor :gettable
-  attr_accessor :worksheet
   attr_accessor :variable_set_counter
   
   def self.rewrite(*args)
     self.new.rewrite(*args)
   end
   
-  def rewrite(input,sheet_names_file,output)
+  def rewrite(formulae, sheet_names, output)
     self.settable ||= lambda { |ref| false }
     self.gettable ||= lambda { |ref| true }
     @variable_set_counter ||= 0
+
     mapper = MapFormulaeToC.new
-    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.each_line do |line|
+    mapper.sheet_names = sheet_names
+    formulae.each do |ref, ast|
       begin
-        ref, formula = line.split("\t")
-        ast = eval(formula)
+        worksheet = ref.first
+        cell = ref.last
+        mapper.worksheet = worksheet
+        worksheet_c_name = mapper.sheet_names[worksheet.to_s] || worksheet.to_s
         calculation = mapper.map(ast)
-        name = c_name ? "#{c_name}_#{ref.downcase}" : ref.downcase
+        name = worksheet_c_name.length > 0 ? "#{worksheet_c_name}_#{cell.downcase}" : cell.downcase
+        
+        # Declare function as static so it can be inlined where possible
         static_or_not = gettable.call(ref) ? "" : "static "
+
+        # Settable functions need a default value and then a function for getting and setting
         if settable.call(ref)
           output.puts "ExcelValue #{name}_default() {"
           mapper.initializers.each do |i|
@@ -34,25 +38,34 @@ class CompileToC
           output.puts "  return #{calculation};"
           output.puts "}"
           output.puts "static ExcelValue #{name}_variable;"
-          output.puts "ExcelValue #{name}() { if(variable_set[#{@variable_set_counter}] == 1) { return #{name}_variable; } else { return #{c_name}_#{ref.downcase}_default(); } }"
+          output.puts "ExcelValue #{name}() { if(variable_set[#{@variable_set_counter}] == 1) { return #{name}_variable; } else { return #{name}_default(); } }"
           output.puts "void set_#{name}(ExcelValue newValue) { variable_set[#{@variable_set_counter}] = 1; #{name}_variable = newValue; }"
+          output.puts
+        # Other functions just have a getter
         else
-          output.puts "#{static_or_not}ExcelValue #{name}() {"
-          output.puts "  static ExcelValue result;"
-          output.puts "  if(variable_set[#{@variable_set_counter}] == 1) { return result;}"
-          mapper.initializers.each do |i|
-            output.puts "  #{i}"
+          # In simple cases, don't bother memoizing the result
+          simple = (ast[0] == :constant) || (ast[0] == :cell && ast[1] =~ /common\d+/) || (ast[0] == :blank) || (ast[0] == :error)
+
+          if simple
+            output.puts "#{static_or_not}ExcelValue #{name}() { return #{calculation}; }"
+          else
+            output.puts "#{static_or_not}ExcelValue #{name}() {"
+            output.puts "  static ExcelValue result;"
+            output.puts "  if(variable_set[#{@variable_set_counter}] == 1) { return result;}"
+            mapper.initializers.each do |i|
+              output.puts "  #{i}"
+            end
+            output.puts "  result = #{calculation};"
+            output.puts "  variable_set[#{@variable_set_counter}] = 1;"
+            output.puts "  return result;"
+            output.puts "}"
+            output.puts
           end
-          output.puts "  result = #{calculation};"
-          output.puts "  variable_set[#{@variable_set_counter}] = 1;"
-          output.puts "  return result;"
-          output.puts "}"
         end
-        output.puts
         @variable_set_counter += 1
         mapper.reset
       rescue Exception => e
-        puts "Exception at line #{line}"
+        puts "Exception at #{ref} #{ast}"
         raise
       end      
     end

data/src/compile/c/compile_to_c_header.rb

@@ -1,6 +1,5 @@
 class CompileToCHeader
   
-  attr_accessor :worksheet
   attr_accessor :gettable
   attr_accessor :settable
   
@@ -8,17 +7,18 @@ class CompileToCHeader
     self.new.rewrite(*args)
   end
   
-  def rewrite(input,sheet_names_file,output,defaults = nil)
-    c_name = Hash[sheet_names_file.readlines.map { |line| line.strip.split("\t")}][worksheet]
+  def rewrite(formulae, c_name_for_worksheet_name, output)
     self.gettable ||= lambda { |ref| true }
     self.settable ||= lambda { |ref| false }
-    input.each_line do |line|
+    formulae.each do |ref, ast|
       begin
-        ref, formula = line.split("\t")
         static_or_not = (gettable.call(ref) || settable.call(ref)) ? "" : "static "
-        output.puts "#{static_or_not}ExcelValue #{c_name}_#{ref.downcase}();"
+        worksheet = c_name_for_worksheet_name[ref.first.to_s] || ref.first.to_s
+        ref = ref.last.downcase
+        name =  worksheet.length > 0 ? "#{worksheet}_#{ref}" : ref
+        output.puts "#{static_or_not}ExcelValue #{name}();"
       rescue Exception => e
-        puts "Exception at line #{line}"
+        puts "Exception at  #{ref} #{ast}"
         raise
       end      
     end

data/src/compile/c/excel_to_c_runtime.c

@@ -755,7 +755,7 @@ static ExcelValue excel_match(ExcelValue lookup_value, ExcelValue lookup_array,
 }
 
 static ExcelValue excel_match_2(ExcelValue lookup_value, ExcelValue lookup_array ) {
-	return excel_match(lookup_value,lookup_array,new_excel_number(0));
+	return excel_match(lookup_value, lookup_array, ZERO);
 }
 
 static ExcelValue find(ExcelValue find_text_v, ExcelValue within_text_v, ExcelValue start_number_v) {
@@ -843,12 +843,12 @@ static ExcelValue left(ExcelValue string_v, ExcelValue number_of_characters_v) {
 	  printf("Out of memory");
 	  exit(-1);
 	}
-	free_later(left_string);
 	memcpy(left_string,string,number_of_characters);
 	left_string[number_of_characters] = '\0';
 	if(string_must_be_freed == 1) {
 		free(string);
 	}
+	free_later(left_string);
 	return new_excel_string(left_string);
 }
 
@@ -1331,7 +1331,6 @@ static ExcelValue string_join(int number_of_arguments, ExcelValue *arguments) {
 	  printf("Out of memory");
 	  exit(-1);
 	}
-	free_later(string);
 	char *current_string;
 	int current_string_length;
 	int must_free_current_string;
@@ -1381,6 +1380,7 @@ static ExcelValue string_join(int number_of_arguments, ExcelValue *arguments) {
 	}
 	string = realloc(string,used_length+1);
   string[used_length] = '\0';
+	free_later(string);
 	return new_excel_string(string);
 }
 
@@ -1750,8 +1750,8 @@ static ExcelValue text(ExcelValue number_v, ExcelValue format_v) {
   if(strcmp(format_v.string,"0%") == 0) {
     // FIXME: Too little? 
     s = malloc(100);
-    free_later(s);
     sprintf(s, "%d%%",(int) round(number_v.number*100));
+    free_later(s);
     result = new_excel_string(s);
   } else {
     return format_v;
@@ -2283,6 +2283,10 @@ int test_functions() {
   assert(string_join(2, string_join_array_4).string[8] == '\0');
 	// ... should convert TRUE and FALSE into strings
   assert(string_join(3,string_join_array_5).string[4] == 'T');
+  // Should deal with very long string joins
+	ExcelValue string_join_array_6[] = {new_excel_string("0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"), new_excel_string("012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789")};
+  assert(string_join(2, string_join_array_6).string[0] == '0');
+  free_all_allocated_memory();
 	
   // Test SUBTOTAL function
   ExcelValue subtotal_array_1[] = {new_excel_number(10),new_excel_number(100),BLANK};

data/src/compile/c/map_formulae_to_c.rb

@@ -17,67 +17,67 @@ class MapFormulaeToC < MapValuesToC
   end
   
   FUNCTIONS = {
-    '*' => 'multiply',
-    '+' => 'add',
-    '-' => 'subtract',
-    '/' => 'divide',
-    '<' => 'less_than',
-    '<=' => 'less_than_or_equal',
-    '<>' => 'not_equal',
-    '=' => 'excel_equal',
-    '>' => 'more_than',
-    '>=' => 'more_than_or_equal',
-    'ABS' => 'excel_abs',
-    'AND' => 'excel_and',
-    'AVERAGE' => 'average',
-    'CHOOSE' => 'choose',
-    'CONCATENATE' => 'string_join',
-    'COSH' => 'cosh',
-    'COUNT' => 'count',
-    'COUNTA' => 'counta',
-    'FIND2' => 'find_2',
-    'FIND3' => 'find',
-    'HLOOKUP3' => 'hlookup_3',
-    'HLOOKUP4' => 'hlookup',
-    'IF2' => 'excel_if_2',
-    'IF3' => 'excel_if',
-    'IFERROR' => 'iferror',
-    'INDEX2' => 'excel_index_2',
-    'INDEX3' => 'excel_index',
-    'INT' => 'excel_int',
-    'ISNUMBER' => 'excel_isnumber',
-    'LARGE' => 'large',
-    'LEFT1' => 'left_1',
-    'LEFT2' => 'left',
-    'LOG1' => 'excel_log',
-    'LOG2' => 'excel_log_2',
-    'MATCH2' => 'excel_match_2',
-    'MATCH3' => 'excel_match',
-    'MAX' => 'max',
-    'MIN' => 'min',
-    'MMULT' => 'mmult',
-    'MOD' => 'mod',
-    'PMT' => 'pmt',
-    'PV3' => 'pv_3',
-    'PV4' => 'pv_4',
-    'PV5' => 'pv_5',
-    'RANK2' => 'rank_2',
-    'RANK3' => 'rank',
-    'ROUND' => 'excel_round',
-    'ROUNDDOWN' => 'rounddown',
-    'ROUNDUP' => 'roundup',
-    'string_join' => 'string_join',
-    'SUBTOTAL' => 'subtotal',
-    'SUM' => 'sum',
-    'SUMIF2' => 'sumif_2',
-    'SUMIF3' => 'sumif',
-    'SUMIFS' => 'sumifs',
-    'TEXT2' => 'text',
-    'SUMPRODUCT' => 'sumproduct',
-    'VLOOKUP3' => 'vlookup_3',
-    'VLOOKUP4' => 'vlookup',
-    '^' => 'power',
-    'POWER' => 'power'
+    :'*' => 'multiply',
+    :'+' => 'add',
+    :'-' => 'subtract',
+    :'/' => 'divide',
+    :'<' => 'less_than',
+    :'<=' => 'less_than_or_equal',
+    :'<>' => 'not_equal',
+    :'=' => 'excel_equal',
+    :'>' => 'more_than',
+    :'>=' => 'more_than_or_equal',
+    :'ABS' => 'excel_abs',
+    :'AND' => 'excel_and',
+    :'AVERAGE' => 'average',
+    :'CHOOSE' => 'choose',
+    :'CONCATENATE' => 'string_join',
+    :'COSH' => 'cosh',
+    :'COUNT' => 'count',
+    :'COUNTA' => 'counta',
+    :'FIND2' => 'find_2',
+    :'FIND3' => 'find',
+    :'HLOOKUP3' => 'hlookup_3',
+    :'HLOOKUP4' => 'hlookup',
+    :'IF2' => 'excel_if_2',
+    :'IF3' => 'excel_if',
+    :'IFERROR' => 'iferror',
+    :'INDEX2' => 'excel_index_2',
+    :'INDEX3' => 'excel_index',
+    :'INT' => 'excel_int',
+    :'ISNUMBER' => 'excel_isnumber',
+    :'LARGE' => 'large',
+    :'LEFT1' => 'left_1',
+    :'LEFT2' => 'left',
+    :'LOG1' => 'excel_log',
+    :'LOG2' => 'excel_log_2',
+    :'MATCH2' => 'excel_match_2',
+    :'MATCH3' => 'excel_match',
+    :'MAX' => 'max',
+    :'MIN' => 'min',
+    :'MMULT' => 'mmult',
+    :'MOD' => 'mod',
+    :'PMT' => 'pmt',
+    :'PV3' => 'pv_3',
+    :'PV4' => 'pv_4',
+    :'PV5' => 'pv_5',
+    :'RANK2' => 'rank_2',
+    :'RANK3' => 'rank',
+    :'ROUND' => 'excel_round',
+    :'ROUNDDOWN' => 'rounddown',
+    :'ROUNDUP' => 'roundup',
+    :'string_join' => 'string_join',
+    :'SUBTOTAL' => 'subtotal',
+    :'SUM' => 'sum',
+    :'SUMIF2' => 'sumif_2',
+    :'SUMIF3' => 'sumif',
+    :'SUMIFS' => 'sumifs',
+    :'TEXT2' => 'text',
+    :'SUMPRODUCT' => 'sumproduct',
+    :'VLOOKUP3' => 'vlookup_3',
+    :'VLOOKUP4' => 'vlookup',
+    :'^' => 'power',
+    :'POWER' => 'power'
   }
   
   def prefix(symbol,ast)
@@ -103,19 +103,19 @@ class MapFormulaeToC < MapValuesToC
   
   def function(function_name,*arguments)
     # Some functions are special cases
-    if self.respond_to?("function_#{function_name.downcase}")
-      send("function_#{function_name.downcase}",*arguments)
+    if self.respond_to?("function_#{function_name.to_s.downcase}")
+      send("function_#{function_name.to_s.downcase}",*arguments)
     # Some arguments can take any number of arguments, which we need to treat separately
-    elsif FUNCTIONS_WITH_ANY_NUMBER_OF_ARGUMENTS.include?(function_name)
+    elsif FUNCTIONS_WITH_ANY_NUMBER_OF_ARGUMENTS.include?(function_name.to_s)
       any_number_of_argument_function(function_name,arguments)
 
     # Check for whether this function has variants based on the number of arguments
-    elsif FUNCTIONS.has_key?("#{function_name}#{arguments.size}")
-      "#{FUNCTIONS["#{function_name}#{arguments.size}"]}(#{arguments.map { |a| map(a) }.join(",")})"
+    elsif FUNCTIONS.has_key?("#{function_name.to_s}#{arguments.size}".to_sym)
+      "#{FUNCTIONS["#{function_name.to_s}#{arguments.size}".to_sym]}(#{arguments.map { |a| map(a) }.join(",")})"
 
     # Then check for whether it is just a standard type
-    elsif FUNCTIONS.has_key?(function_name)
-      "#{FUNCTIONS[function_name]}(#{arguments.map { |a| map(a) }.join(",")})"
+    elsif FUNCTIONS.has_key?(function_name.to_sym)
+      "#{FUNCTIONS[function_name.to_sym]}(#{arguments.map { |a| map(a) }.join(",")})"
 
     else
       raise NotSupportedException.new("Function #{function_name} with #{arguments.size} arguments not supported")
@@ -129,20 +129,20 @@ class MapFormulaeToC < MapValuesToC
   end
   
   def function_choose(index,*arguments)
-    "#{FUNCTIONS["CHOOSE"]}(#{map(index)}, #{map_arguments_to_array(arguments)})"
+    "#{FUNCTIONS[:CHOOSE]}(#{map(index)}, #{map_arguments_to_array(arguments)})"
   end
   
   def function_subtotal(type,*arguments)
-    "#{FUNCTIONS["SUBTOTAL"]}(#{map(type)}, #{map_arguments_to_array(arguments)})"
+    "#{FUNCTIONS[:SUBTOTAL]}(#{map(type)}, #{map_arguments_to_array(arguments)})"
   end
 
   def function_sumifs(sum_range,*criteria)
-    "#{FUNCTIONS["SUMIFS"]}(#{map(sum_range)}, #{map_arguments_to_array(criteria)})"
+    "#{FUNCTIONS[:SUMIFS]}(#{map(sum_range)}, #{map_arguments_to_array(criteria)})"
   end
 
   
   def any_number_of_argument_function(function_name,arguments)    
-    "#{FUNCTIONS[function_name]}(#{map_arguments_to_array(arguments)})"
+    "#{FUNCTIONS[function_name.to_sym]}(#{map_arguments_to_array(arguments)})"
   end
   
   def map_arguments_to_array(arguments)
@@ -158,35 +158,34 @@ class MapFormulaeToC < MapValuesToC
   def cell(reference)
     # FIXME: What a cludge.
     if reference =~ /common\d+/
-      "_#{reference}()"
+      "#{reference}()"
     else
-      reference.downcase.gsub('$','')
+      reference.to_s.downcase.gsub('$','')
     end
   end
   
   def sheet_reference(sheet,reference)
-    "#{sheet_names[sheet]}_#{map(reference).downcase}()"
+    "#{sheet_names[sheet]}_#{map(reference).to_s.downcase}()"
   end
 
   def array(*rows)
     # Make sure we get the right dimensions
     number_of_rows = rows.size
-    number_of_columns = rows.max { |r| r.size }.size - 1
-    
+    number_of_columns = rows[0].size - 1
+    size = number_of_rows * number_of_columns
+
     # First we have to create an excel array
     array_name = "array#{@counter}"
     @counter +=1
 
-    cells = rows.map do |r|
-      r.shift if r.first == :row
-      r.map do |c| 
-        map(c)
+    initializers << "static ExcelValue #{array_name}[#{size}];"
+    i = 0
+    rows.each do |row|
+      row.each do |cell|
+        next if cell.is_a?(Symbol)
+        initializers << "#{array_name}[#{i}] = #{map(cell)};"
+        i += 1
       end
-    end.flatten
-    
-    initializers << "static ExcelValue #{array_name}[#{cells.size}];"
-    cells.each_with_index do |c,i|
-      initializers << "#{array_name}[#{i}] = #{c};"
     end
     
     # Then we need to assign it to an excel value

data/src/compile/c/map_values_to_c.rb

@@ -66,7 +66,13 @@ class MapValuesToC
     "#DIV/0!" => "DIV0",
     "#REF!" => "REF",
     "#N/A" => "NA",
-    "#NUM!" => "NUM"
+    "#NUM!" => "NUM",
+    :"#NAME?" => "NAME",
+    :"#VALUE!" => "VALUE",
+    :"#DIV/0!" => "DIV0",
+    :"#REF!" => "REF",
+    :"#N/A" => "NA",
+    :"#NUM!" => "NUM"
   }
   
   REVERSE_ERRORS = ERRORS.invert