excel_to_code 0.0.1

data/src/compile/c/map_formulae_to_c.rb

@@ -0,0 +1,184 @@
+require_relative 'map_values_to_c'
+
+class MapFormulaeToC < MapValuesToC
+  
+  attr_accessor :sheet_names
+  attr_accessor :worksheet
+  attr_reader :initializers
+  attr_reader :counter
+  
+  def initialize
+    reset
+  end
+  
+  def reset
+    @initializers = []
+    @counter = 0
+  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',
+    'COSH' => 'cosh',
+    'COUNT' => 'count',
+    'COUNTA' => 'counta',
+    'FIND2' => 'find_2',
+    'FIND3' => 'find',
+    'IF2' => 'excel_if_2',
+    'IF3' => 'excel_if',
+    'IFERROR' => 'iferror',
+    'INDEX2' => 'excel_index_2',
+    'INDEX3' => 'excel_index',
+    'LEFT1' => 'left_1',
+    'LEFT2' => 'left',
+    'MATCH2' => 'excel_match_2',
+    'MATCH3' => 'excel_match',
+    'MAX' => 'max',
+    'MIN' => 'min',
+    'MOD' => 'mod',
+    'PMT' => 'pmt',
+    'ROUND' => 'excel_round',
+    'ROUNDDOWN' => 'rounddown',
+    'ROUNDUP' => 'roundup',
+    'string_join' => 'string_join',
+    'SUBTOTAL' => 'subtotal',
+    'SUM' => 'sum',
+    'SUMIF2' => 'sumif_2',
+    'SUMIF3' => 'sumif',
+    'SUMIFS' => 'sumifs',
+    'SUMPRODUCT' => 'sumproduct',
+    'VLOOKUP3' => 'vlookup_3',
+    'VLOOKUP4' => 'vlookup',
+    '^' => 'power'
+  }
+  
+  def prefix(symbol,ast)
+    return map(ast) if symbol == "+"
+    return "negative(#{map(ast)})"
+  end
+  
+  def brackets(*contents)
+    "(#{contents.map { |a| map(a) }.join(',')})"
+  end
+  
+  def arithmetic(left,operator,right)
+    "#{FUNCTIONS[operator.last]}(#{map(left)},#{map(right)})"
+  end
+  
+  def string_join(*strings)
+    any_number_of_argument_function('string_join',strings)
+  end
+  
+  def comparison(left,operator,right)
+    "#{FUNCTIONS[operator.last]}(#{map(left)},#{map(right)})"
+  end
+  
+  def function(function_name,*arguments)
+    # Some functions are special cases
+    if self.respond_to?("function_#{function_name.downcase}")
+      send("function_#{function_name.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)
+      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(",")})"
+
+    # 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(",")})"
+
+    else
+      raise NotSupportedException.new("Function #{function_name} with #{arguments.size} arguments not supported")
+    end
+  end
+  
+  FUNCTIONS_WITH_ANY_NUMBER_OF_ARGUMENTS = %w{SUM AND AVERAGE COUNT COUNTA MAX MIN SUMPRODUCT}
+  
+  def function_pi() 
+    "M_PI"
+  end
+  
+  def function_choose(index,*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)})"
+  end
+
+  def function_sumifs(sum_range,*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)})"
+  end
+  
+  def map_arguments_to_array(arguments)
+    # First we have to create an excel array
+    array_name = "array#{@counter}"
+    @counter +=1
+    arguments_size = arguments.size
+    arguments = arguments.map { |a| map(a) }.join(',')
+    initializers << "ExcelValue #{array_name}[] = {#{arguments}};"
+    "#{arguments_size}, #{array_name}"
+  end
+  
+  def cell(reference)
+    # FIXME: What a cludge.
+    if reference =~ /common\d+/
+      "_#{reference}()"
+    else
+      reference.downcase.gsub('$','')
+    end
+  end
+  
+  def sheet_reference(sheet,reference)
+    "#{sheet_names[sheet]}_#{map(reference).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
+    
+    # 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)
+      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
+    range_name = array_name+"_ev"
+    initializers << "ExcelValue #{range_name} = new_excel_range(#{array_name},#{number_of_rows},#{number_of_columns});"
+
+    range_name
+  end
+
+
+end

data/src/compile/c/map_sheet_names_to_c_names.rb

@@ -0,0 +1,19 @@
+class MapSheetNamesToCNames
+  
+  def self.rewrite(*args)
+    self.new.rewrite(*args)
+  end
+  
+  def rewrite(input,output)
+    c_names_assigned = {}
+    input.lines do |line|
+      excel_worksheet_name = line.split("\t").first
+      c_name = excel_worksheet_name.downcase.gsub(/[^a-z0-9]+/,'_')
+      c_name = "s"+c_name if c_name[0] !~ /[a-z]/
+      c_name = ruby_name + "2" if c_names_assigned.has_key?(c_name)
+      c_name.succ! while c_names_assigned.has_key?(c_name)
+      output.puts "#{excel_worksheet_name}\t#{c_name}"
+      c_names_assigned[c_name] = excel_worksheet_name
+    end
+  end
+end

data/src/compile/c/map_values_to_c.rb

@@ -0,0 +1,85 @@
+require_relative '../../util/not_supported_exception'
+
+class MapValuesToC
+
+  def map(ast)
+    if ast.is_a?(Array)
+      operator = ast[0]
+      if respond_to?(operator)
+        send(operator,*ast[1..-1])
+      else
+        raise NotSupportedException.new("#{operator} in #{ast.inspect} not supported")
+      end
+    else
+      raise NotSupportedException.new("#{ast} not supported")
+    end
+  end
+  
+  def blank
+    "BLANK"
+  end
+  
+  def constant(name)
+    name
+  end
+  
+  alias :null :blank
+    
+  def number(text)
+    n = case text
+    when /\./
+      text.to_f.to_s
+    when /e/i
+      text.to_f.to_s
+    else
+      text.to_i.to_s
+    end
+    
+    case n
+    when 0; "ZERO"
+    when 1; "ONE"
+    when 2; "TWO"
+    when 3; "THREE"
+    when 4; "FOUR"
+    when 5; "FIVE"
+    when 6; "SIX"
+    when 7; "SEVEN"
+    when 8; "EIGHT"
+    when 9; "NINE"
+    when 10; "TEN"
+    else   
+      "new_excel_number(#{n})"
+    end
+  end
+  
+  def percentage(text)
+    "new_excel_number(#{(text.to_f / 100.0).to_s})"
+  end
+  
+  def string(text)
+    "new_excel_string(#{text.inspect})"
+  end
+  
+  ERRORS = {
+    "#NAME?" => "NAME",
+    "#VALUE!" => "VALUE",
+    "#DIV/0!" => "DIV0",
+    "#REF!" => "REF",
+    "#N/A" => "NA"
+  }
+  
+  REVERSE_ERRORS = ERRORS.invert
+  
+  def error(text)
+    ERRORS[text] || (raise NotSupportedException.new("#{text.inspect} error not recognised"))
+  end
+  
+  def boolean_true
+    "TRUE"
+  end
+  
+  def boolean_false
+    "FALSE"
+  end
+  
+end

data/src/compile/c/map_values_to_c_structs.rb

@@ -0,0 +1,37 @@
+require_relative '../../util/not_supported_exception'
+
+class MapValuesToCStructs
+
+  def map(ast)
+    if ast.is_a?(Array)
+      operator = ast[0]
+      if respond_to?(operator)
+        send(operator,*ast[1..-1])
+      else
+        raise NotSupportedException.new("#{operator} in #{ast.inspect} not supported")
+      end
+    else
+      raise NotSupportedException.new("#{ast} not supported")
+    end
+  end
+  
+  def number(text)
+    n = case text
+    when /\./
+      text.to_f.to_s
+    when /e/i
+      text.to_f.to_s
+    else
+      text.to_i.to_s
+    end
+    "{.type = ExcelNumber, .number = #{n}}"
+  end
+  
+  def percentage(text)
+    "{.type = ExcelNumber, .number = #{(text.to_f / 100.0).to_s}}"
+  end
+  
+  def string(text)
+    "{.type = ExcelString, .string = #{text.inspect}}"
+  end  
+end

data/src/compile/ruby.rb

@@ -0,0 +1,3 @@
+require_relative 'ruby/compile_to_ruby'
+require_relative 'ruby/compile_to_ruby_unit_test'
+require_relative 'ruby/map_sheet_names_to_ruby_names'

data/src/compile/ruby/compile_to_ruby.rb

@@ -0,0 +1,33 @@
+require_relative 'map_formulae_to_ruby'
+
+class CompileToRuby
+  
+  attr_accessor :settable
+  attr_accessor :worksheet
+  
+  def self.rewrite(*args)
+    self.new.rewrite(*args)
+  end
+  
+  def rewrite(input,sheet_names_file,output,defaults = nil)
+    self.settable ||= lambda { |ref| false }
+    mapper = MapFormulaeToRuby.new
+    mapper.worksheet = worksheet
+    mapper.sheet_names = Hash[sheet_names_file.readlines.map { |line| line.strip.split("\t")}]
+    input.lines do |line|
+      begin
+        ref, formula = line.split("\t")
+        if settable.call(ref)
+          output.puts "  attr_accessor :#{ref.downcase} # Default: #{mapper.map(eval(formula))}"
+          defaults.puts "    @#{ref.downcase} = #{mapper.map(eval(formula))}" if defaults
+        else
+          output.puts "  def #{ref.downcase}; @#{ref.downcase} ||= #{mapper.map(eval(formula))}; end"
+        end
+      rescue Exception => e
+        puts "Exception at line #{line}"
+        raise
+      end      
+    end
+  end
+  
+end

data/src/compile/ruby/compile_to_ruby_unit_test.rb

@@ -0,0 +1,28 @@
+require_relative "map_values_to_ruby"
+
+class CompileToRubyUnitTest
+  
+  def self.rewrite(*args)
+    self.new.rewrite(*args)
+  end
+  
+  def rewrite(input,output)
+    mapper = MapValuesToRuby.new
+    input.lines do |line|
+      ref, formula = line.split("\t")
+      ast = eval(formula)
+      value = mapper.map(ast)
+      full_reference = "worksheet.#{ref.downcase}"
+      if ast.first == :number
+        if value == "0" # Need to do a slightly different test, because needs to pass if nil returned, as well as zero
+          output.puts "  def test_#{ref.downcase}; assert_in_epsilon(#{value},#{full_reference} || 0); end"      
+        else
+          output.puts "  def test_#{ref.downcase}; assert_in_epsilon(#{value},#{full_reference}); end"      
+        end
+      else
+        output.puts "  def test_#{ref.downcase}; assert_equal(#{value},#{full_reference}); end"
+      end
+    end
+  end
+  
+end

data/src/compile/ruby/excel_to_ruby_runtime.rb

@@ -0,0 +1 @@
+require_relative '../../excel/excel_functions'

data/src/compile/ruby/map_formulae_to_ruby.rb

@@ -0,0 +1,95 @@
+require_relative 'map_values_to_ruby'
+
+class MapFormulaeToRuby < MapValuesToRuby
+  
+  attr_accessor :sheet_names
+  attr_accessor :worksheet
+  
+  FUNCTIONS = {
+    '*' => 'multiply',
+    '+' => 'add',
+    '-' => 'subtract',
+    '/' => 'divide',
+    '<' => 'less_than?',
+    '<=' => 'less_than_or_equal?',
+    '<>' => 'not_equal?',
+    '=' => 'excel_equal?',
+    '>' => 'more_than?',
+    '>=' => 'more_than_or_equal?',
+    'ABS' => 'abs',
+    'AND' => 'excel_and',
+    'AVERAGE' => 'average',
+    'CHOOSE' => 'choose',
+    'COSH' => 'cosh',
+    'COUNT' => 'count',
+    'COUNTA' => 'counta',
+    'FIND' => 'find',
+    'IF' => 'excel_if',
+    'IFERROR' => 'iferror',
+    'INDEX' => 'index',
+    'LEFT' => 'left',
+    'MATCH' => 'excel_match',
+    'MAX' => 'max',
+    'MIN' => 'min',
+    'MOD' => 'mod',
+    'PI' => 'pi',
+    'PMT' => 'pmt',
+    'ROUND' => 'round',
+    'ROUNDDOWN' => 'rounddown',
+    'ROUNDUP' => 'roundup',
+    'SUBTOTAL' => 'subtotal',
+    'SUM' => 'sum',
+    'SUMIF' => 'sumif',
+    'SUMIFS' => 'sumifs',
+    'SUMPRODUCT' => 'sumproduct',
+    'VLOOKUP' => 'vlookup',
+    '^' => 'power'
+  }
+  
+  def prefix(symbol,ast)
+    return map(ast) if symbol == "+"
+    return "negative(#{map(ast)})"
+  end
+  
+  def brackets(*contents)
+    "(#{contents.map { |a| map(a) }.join(',')})"
+  end
+  
+  def arithmetic(left,operator,right)
+    "#{FUNCTIONS[operator.last]}(#{map(left)},#{map(right)})"
+  end
+  
+  def string_join(*strings)
+    "string_join(#{strings.map {|a| map(a)}.join(',')})"
+  end
+  
+  def comparison(left,operator,right)
+    "#{FUNCTIONS[operator.last]}(#{map(left)},#{map(right)})"
+  end
+  
+  def function(function_name,*arguments)
+    if FUNCTIONS.has_key?(function_name)
+      "#{FUNCTIONS[function_name]}(#{arguments.map { |a| map(a) }.join(",")})"
+    else
+      raise NotSupportedException.new("Function #{function_name} not supported")
+    end
+  end
+  
+  def cell(reference)
+    reference.downcase.gsub('$','')
+  end
+  
+  def sheet_reference(sheet,reference)
+    return map(reference) if worksheet && worksheet == sheet
+    "#{sheet_names[sheet]}.#{map(reference)}"
+  end
+  
+  def array(*rows)
+    "[#{rows.map {|r| map(r)}.join(",")}]"
+  end
+  
+  def row(*cells)
+    "[#{cells.map {|r| map(r)}.join(",")}]"
+  end
+  
+end