excel_to_code 0.0.14 → 0.1.1

data/README.md

@@ -39,3 +39,4 @@ There are some how to guides in the doc folder.
 3. Doesn't implement all functions (see doc/Which_functions_are_implemented.md)
 4. Doesn't implement references that involve range unions and lists
 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

data/src/commands/excel_to_c.rb

@@ -58,6 +58,9 @@ class ExcelToC < ExcelToX
       close(i)
     end
     
+    # Need to make sure there are enough refs for named references as well
+    number_of_refs += named_references_to_keep.size
+
     o.puts "// end of definitions"
     o.puts
     o.puts "// Used to decide whether to recalculate a cell"
@@ -126,6 +129,30 @@ class ExcelToC < ExcelToX
       o.puts
       close(i)
     end
+
+    # Output the named references
+
+    # Getters
+    o.puts "// Start of named references"
+    i = input('Named references to keep')
+    w.rewind
+    c.gettable = lambda { |ref| true }
+    c.settable = lambda { |ref| false }
+    c.worksheet = ""
+    c.rewrite(i,w,o)
+    close(i)
+
+    # Setters
+    i = input('Named references to set')
+    w.rewind # Worksheet C names
+    
+    c = CompileNamedReferenceSetters.new
+    c.cells_that_can_be_set_at_runtime = cells_that_can_be_set_at_runtime
+    c.rewrite(i,w,o)
+
+    close(i)
+    o.puts "// End of named references"
+
     close(w,o)
   end
   
@@ -161,6 +188,102 @@ class ExcelToC < ExcelToX
       
     code = <<END
 require 'ffi'
+require 'singleton'
+
+class #{ruby_module_name}Shim
+
+  # WARNING: this is not thread safe
+  def initialize
+    reset
+  end
+
+  def reset
+    #{ruby_module_name}.reset
+  end
+
+  def method_missing(name, *arguments)
+    if arguments.size == 0
+      get(name)
+    elsif arguments.size == 1
+      set(name, arguments.first)
+    else
+      super
+    end 
+  end
+
+  def get(name)
+    return 0 unless #{ruby_module_name}.respond_to?(name)
+    excel_value = #{ruby_module_name}.send(name)
+    case excel_value[:type]
+    when :ExcelNumber; excel_value[:number]
+    when :ExcelString; excel_value[:string].read_string.force_encoding("utf-8")
+    when :ExcelBoolean; excel_value[:number] == 1
+    when :ExcelEmpty; nil
+    when :ExcelRange
+      r = excel_value[:rows]
+      c = excel_value[:columns]
+      p = excel_value[:array]
+      s = #{ruby_module_name}::ExcelValue.size
+      a = Array.new(r) { Array.new(c) }
+      (0...r).each do |row|
+        (0...c).each do |column|
+          a[row][column] = ruby_from_excel_value(#{ruby_module_name}::ExcelValue.new(p + (((row*c)+column)*s)))
+        end
+      end 
+      return a
+    when :ExcelError; [:value,:name,:div0,:ref,:na][excel_value[:number]]
+    else
+      raise Exception.new("ExcelValue type \u0023{excel_value[:type].inspect} not recognised")
+    end
+  end
+
+  def set(name, ruby_value)
+    name = name.to_s
+    name = "set_\#{name[0..-2]}" if name.end_with?('=')
+    return false unless #{ruby_module_name}.respond_to?(name)
+    Getsetranges.send(name, excel_value_from_ruby_value(ruby_value))
+  end
+
+  def excel_value_from_ruby_value(ruby_value, excel_value = #{ruby_module_name}::ExcelValue.new)
+    case ruby_value
+    when Numeric
+      excel_value[:type] = :ExcelNumber
+      excel_value[:number] = ruby_value
+    when String
+      excel_value[:type] = :ExcelString
+      excel_value[:string] = FFI::MemoryPointer.from_string(ruby_value.encode('utf-8'))
+    when TrueClass, FalseClass
+      excel_value[:type] = :ExcelBoolean
+      excel_value[:number] = ruby_value ? 1 : 0
+    when nil
+      excel_value[:type] = :ExcelEmpty
+    when Array
+      excel_value[:type] = :ExcelRange
+      # Presumed to be a row unless specified otherwise
+      if ruby_value.first.is_a?(Array)
+        excel_value[:rows] = ruby_value.size
+        excel_value[:columns] = ruby_value.first.size
+      else
+        excel_value[:rows] = 1
+        excel_value[:columns] = ruby_value.size
+      end
+      ruby_values = ruby_value.flatten
+      pointer = FFI::MemoryPointer.new(#{ruby_module_name}::ExcelValue, ruby_values.size)
+      excel_value[:array] = pointer
+      ruby_values.each.with_index do |v,i|
+        excel_value_from_ruby_value(v, #{ruby_module_name}::ExcelValue.new(pointer[i]))
+      end
+    when Symbol
+      excel_value[:type] = :ExcelError
+      excel_value[:number] = [:value, :name, :div0, :ref, :na].index(ruby_value)
+    else
+      raise Exception.new("Ruby value \u0023{ruby_value.inspect} not translatable into excel")
+    end
+    excel_value
+  end
+
+end
+    
 
 module #{ruby_module_name}
   extend FFI::Library
@@ -170,7 +293,7 @@ module #{ruby_module_name}
   class ExcelValue < FFI::Struct
     layout :type, ExcelType,
   	       :number, :double,
-  	       :string, :string,
+  	       :string, :pointer,
          	 :array, :pointer,
            :rows, :int,
            :columns, :int             
@@ -196,6 +319,7 @@ END
         end
       end
 
+      # Put in place the getters
       if !cells_to_keep || cells_to_keep.empty? || cells_to_keep[name] == :all
         getable_refs = all_formulae[name].keys
       elsif !cells_to_keep[name] && settable_refs
@@ -210,6 +334,28 @@ END
         
       o.puts "  # end of #{name}"
     end
+
+    # Now put in place the getters and setters for the named references
+    o.puts "  # Start of named references"
+
+    # Getters
+    i = input('Named references to keep')
+    i.lines.each do |line|
+      name = line.strip.split("\t").first
+      o.puts "  attach_function '#{name}', [], ExcelValue.by_value"
+    end
+    close(i)
+
+    # Setters
+    i = input('Named references to set')
+    i.lines.each do |line|
+      name = line.strip.split("\t").first
+      o.puts "  attach_function 'set_#{name}', [ExcelValue.by_value], :void"
+    end
+
+    close(i)
+    o.puts "  # End of named references"
+
     o.puts "end"  
     close(o)
   end
@@ -225,8 +371,8 @@ END
     o.puts  "require_relative '#{output_name.downcase}'"
     o.puts
     o.puts "class Test#{ruby_module_name} < Test::Unit::TestCase"
-    o.puts "  def spreadsheet; @spreadsheet ||= init_spreadsheet; end"
-    o.puts "  def init_spreadsheet; #{ruby_module_name} end"
+    o.puts "  def worksheet; @worksheet ||= init_spreadsheet; end"
+    o.puts "  def init_spreadsheet; #{ruby_module_name}Shim.new end"
     
     all_formulae = all_formulae()
     

data/src/commands/excel_to_x.rb

@@ -32,6 +32,18 @@ class ExcelToX
   # It is a hash. The keys are the sheet names. The values are either the symbol :all to specify that all cells on that sheet 
   # should be setable, or an array of cell names on that sheet that should be settable (e.g., A1)
   attr_accessor :cells_that_can_be_set_at_runtime
+
+  # Optional attribute. Specifies which named references to be turned into setters
+  #
+  # Should be an array of strings. Each string is a named reference. Case sensitive.
+  # To specify a named reference scoped to a worksheet, use ['worksheet', 'named reference'] instead
+  # of a string.
+  #
+  # Each named reference then has a function in the resulting C code of the form
+  # void set_named_reference_mangled_into_a_c_function(ExcelValue newValue)
+  #
+  # By default, no named references are output
+  attr_accessor :named_references_that_can_be_set_at_runtime
   
   # Optional attribute. Specifies which cells must appear in the final generated code.
   # The default is that all cells in the original spreadsheet appear in the final code.
@@ -45,6 +57,18 @@ class ExcelToX
   # It is a hash. The keys are the sheet names. The values are either the symbol :all to specify that all cells on that sheet 
   # should be lept, or an array of cell names on that sheet that should be kept (e.g., A1)
   attr_accessor :cells_to_keep
+ 
+  # Optional attribute. Specifies which named references should be included in the output
+  # Should be an array of strings. Each string is a named reference. Case sensitive.
+  #
+  # To specify a named reference scoped to a worksheet, use ['worksheet', 'named reference'] instead
+  # of a string.
+  #
+  # Each named reference then has a function in the resulting C code of the form
+  # ExcelValue named_reference_mangled_into_a_c_function()
+  #
+  # By default, no named references are output
+  attr_accessor :named_references_to_keep
   
   # Optional attribute. Boolean. Not relevant to all types of code output
   #   * true - the generated c code is compiled
@@ -128,16 +152,22 @@ class ExcelToX
     # * Mergining all the different types of formulae and values into a single file
     rewrite_worksheets
     
+    # These perform a series of transformations to the information
+    # with the intent of removing any redundant calculations
+    # that are in the excel.
+    simplify_worksheets # Replacing shared strings and named references with their actual values, tidying arithmetic
+
+    transfer_named_references_to_keep_into_cells_to_keep
+    transfer_named_references_that_can_be_set_at_runtime_into_cells_that_can_be_set_at_runtime
+    
     # In case this hasn't been set by the user
     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
     end
-    
-    # These perform a series of transformations to the information
-    # with the intent of removing any redundant calculations
-    # that are in the excel.
-    simplify_worksheets # Replacing shared strings and named references with their actual values, tidying arithmetic
+
+    filter_named_references
+
     replace_formulae_with_their_results
     remove_any_cells_not_needed_for_outputs
     inline_formulae_that_are_only_used_once
@@ -190,8 +220,9 @@ class ExcelToX
   def extract_named_references
     extract ExtractNamedReferences, 'workbook.xml', 'Named references'
     apply_rewrite RewriteFormulaeToAst, 'Named references'
+    replace ReplaceRangesWithArrayLiterals, 'Named references', 'Named references'
   end
-  
+
   # Excel keeps a list of worksheet names. To get the mapping between
   # human and computer name  correct we have to look in the workbook 
   # relationships files. We also need to mangle the name into something
@@ -202,7 +233,7 @@ class ExcelToX
     rewrite RewriteWorksheetNames, 'Worksheet names', 'Workbook relationships', 'Worksheet names'
     rewrite MapSheetNamesToCNames, 'Worksheet names', 'Worksheet C names'
   end
-  
+
   # We want a central list of the maximum extent of each worksheet
   # so that we can convert column (e.g., C:F) and row (e.g., 13:18)
   # references into equivalent area references (e.g., C1:F30)
@@ -293,6 +324,10 @@ class ExcelToX
     end
   end
   
+  # In Excel we can have references like A:Z and 5:20 which mean all cells in columns 
+  # A to Z and all cells in rows 5 to 20 respectively. This function translates these
+  # into more conventional references (e.g., A5:Z20) based on the maximum area that 
+  # has been used on a worksheet
   def rewrite_row_and_column_references(name,xml_filename)
     dimensions = input('Worksheet dimensions')
     
@@ -344,6 +379,104 @@ class ExcelToX
     end
     required_refs
   end
+
+  # Returns a hash of named references, and the ast of their links
+  # where the named reference is global the key will be a string of
+  # its name and case sensitive.
+  # where the named reference is coped to a worksheet, the key will be
+  # a two element array. The first element will be the sheet name. The
+  # second will be the name. 
+  def named_references
+    return @named_references if @named_references
+    @named_references = {}
+    i = input('Named references')
+    i.lines.each do |line|
+      sheet, name, ref = *line.split("\t")
+      key = sheet.size != 0 ? [sheet, name] : name
+      @named_references[key] = eval(ref)
+    end
+    close(i)
+    @named_references
+  end
+
+  # This makes sure that cells_to_keep includes named_references_to_keep
+  def transfer_named_references_to_keep_into_cells_to_keep
+    log.debug "Started transfering named references to keep into cells to keep"
+    return unless @named_references_to_keep
+    @cells_to_keep ||= {}
+    all_named_references = named_references
+    @named_references_to_keep.each do |name|
+      ref = all_named_references[name]
+      if ref
+        add_ref_to_hash(ref, @cells_to_keep)
+      else
+        log.warn "Named reference #{name} not found"
+      end
+    end
+  end
+
+  def transfer_named_references_that_can_be_set_at_runtime_into_cells_that_can_be_set_at_runtime
+    log.debug "Started transfering named references that can be set at runtime into cells that can be set at runtime"
+    return unless @named_references_that_can_be_set_at_runtime
+    @cells_that_can_be_set_at_runtime ||= {}
+    all_named_references = named_references
+    @named_references_that_can_be_set_at_runtime.each do |name|
+      ref = all_named_references[name]
+      if ref
+        add_ref_to_hash(ref, @cells_that_can_be_set_at_runtime)
+      else
+        log.warn "Named reference #{name} not found"
+      end
+    end
+  end
+
+  def add_ref_to_hash(ref, hash)
+    if ref.first == :sheet_reference
+      sheet = ref[1]
+      cell = ref[2][1].gsub('$','')
+      hash[sheet] ||= []
+      return if hash[sheet] == :all
+      hash[sheet] << cell unless hash[sheet].include?(cell)
+    elsif ref.first == :array
+      ref.shift
+      ref.each do |row|
+        row.shift
+        row.each do |cell|
+          add_ref_to_hash(cell, hash)
+        end
+      end
+    else
+      log.error "Weird reference in named reference #{ref}"
+    end
+  end
+
+  # FIXME: Feels like a kludge
+  def filter_named_references
+    @named_references_to_keep ||= []
+    @named_references_that_can_be_set_at_runtime ||= []
+
+    i = input('Named references')
+    o = intermediate('Named references to keep')
+    i.lines.each 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)
+    end
+    close(o)
+
+    i.rewind
+    o = intermediate('Named references to set')
+    i.lines.each 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)
+    end
+    close(o)
+
+    # FIXME: Might result in getter and setter having different names
+    rewrite RewriteNamedReferenceNames, 'Named references to keep', 'Worksheet C names', 'Named references to keep'
+    rewrite RewriteNamedReferenceNames, 'Named references to set', 'Worksheet C names', 'Named references to set'
+  end
     
   def simplify_worksheets
     worksheets do |name,xml_filename|
@@ -583,7 +716,8 @@ class ExcelToX
     close(output)
   end
   
-  # If no settable cells have been specified, then we assume that
+  # If nothing has been specified in named_refernces_that_can_be_set_at_runtime 
+  # 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
@@ -636,7 +770,7 @@ class ExcelToX
       i.lines do |line|
         line =~ /^(.*?)\t(.*)$/
         ref, ast = $1, $2
-        r[$1] = eval($2)
+        r[ref] = eval(ast)
       end
     end 
     references

data/src/compile/c.rb

@@ -3,3 +3,4 @@ require_relative 'c/compile_to_c_header'
 require_relative 'c/map_sheet_names_to_c_names'
 require_relative "c/compile_to_c_unit_test"
 require_relative "c/map_values_to_c_structs"
+require_relative "c/compile_named_reference_setters"

data/src/compile/c/compile_named_reference_setters.rb

@@ -0,0 +1,90 @@
+class MapNamedReferenceToCSetter
+
+  attr_accessor :sheet_names
+  attr_accessor :cells_that_can_be_set_at_runtime
+
+  def initialize
+    reset
+  end
+
+  def reset
+    @new_value_name = "newValue"
+  end
+
+  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 cell(reference)
+    reference.downcase.gsub('$','')
+  end
+
+  def sheet_reference(sheet,reference)
+    s = sheet_names[sheet]
+    c = map(reference)
+    return "  // #{s}_#{c} not settable" unless settable(sheet, c)
+    "  set_#{s}_#{c}(#{@new_value_name});"
+  end
+
+  def array(*rows)
+    counter = -1
+
+    result = rows.map do |r|
+      r.shift if r.first == :row
+      r.map do |c| 
+        counter += 1
+        @new_value_name = "array[#{counter}]"
+        map(c)
+      end
+    end.flatten.join("\n")
+    
+    @new_value_name = "newValue"
+
+    "  ExcelValue *array = newValue.array;\n#{result}"
+  end
+
+  def settable(sheet, reference)
+    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) 
+  end
+
+end
+
+class CompileNamedReferenceSetters
+
+  attr_accessor :cells_that_can_be_set_at_runtime
+
+  def self.rewrite(*args)
+    new.rewrite(*args)
+  end
+
+  def rewrite(named_references, sheet_names, output)
+    mapper = MapNamedReferenceToCSetter.new
+    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|
+      name, reference = line.split("\t")
+      ast = eval(reference)
+      output.puts "void set_#{name}(ExcelValue newValue) {"
+      output.puts mapper.map(ast)
+      output.puts "}"
+      output.puts
+    end
+    output
+  end
+
+
+
+end

data/src/compile/c/compile_to_c.rb

@@ -24,7 +24,7 @@ class CompileToC
         ref, formula = line.split("\t")
         ast = eval(formula)
         calculation = mapper.map(ast)
-        name = "#{c_name}_#{ref.downcase}"
+        name = c_name ? "#{c_name}_#{ref.downcase}" : ref.downcase
         static_or_not = gettable.call(ref) ? "" : "static "
         if settable.call(ref)
           output.puts "ExcelValue #{name}_default() {"
@@ -58,4 +58,4 @@ class CompileToC
     end
   end
   
-end
+end

data/src/compile/c/compile_to_c_unit_test.rb

@@ -1,72 +1,7 @@
-class CompileToCUnitTest
+require_relative "../ruby/compile_to_ruby_unit_test"
 
-  attr_accessor :epsilon
-  attr_accessor :delta
+class CompileToCUnitTest < CompileToRubyUnitTest
 
-  def initialize
-    @epsilon = 0.001
-    @delta = 0.001
-  end
-  
-  def self.rewrite(*args)
-    self.new.rewrite(*args)
-  end
-  
-  def rewrite(input, sloppy, c_name, refs_to_test, output)
-    input.lines do |line|
-      begin
-        ref, formula = line.split("\t")
-        next unless refs_to_test.include?(ref.upcase)
-        output.puts "def test_#{c_name}_#{ref.downcase}"
-        output.puts "  r = spreadsheet.#{c_name}_#{ref.downcase}"
-        ast = eval(formula)
-        case ast.first
-        when :number, :percentage
-          unless sloppy
-            output.puts "  assert_equal(:ExcelNumber,r[:type])"
-            output.puts "  assert_equal(#{ast.last.to_f.to_s},r[:number])"
-          else
-            if ast.last.to_f == 0
-              output.puts "  pass if r[:type] == :ExcelEmpty"
-            end
-            
-            output.puts "  assert_equal(:ExcelNumber,r[:type])"
-
-            if ast.last.to_f <= 1
-              output.puts "  assert_in_delta(#{ast.last.to_f.to_s},r[:number],#{@delta})"
-            else
-              output.puts "  assert_in_epsilon(#{ast.last.to_f.to_s},r[:number],#{@epsilon})"
-            end
-          end
-        when :error
-          output.puts "  assert_equal(:ExcelError,r[:type])"
-        when :string
-          output.puts "  assert_equal(:ExcelString,r[:type])"
-          output.puts "  assert_equal(#{ast.last.inspect},r[:string].force_encoding('utf-8'))" 
-        when :boolean_true
-          output.puts "  assert_equal(:ExcelBoolean,r[:type])"
-          output.puts "  assert_equal(1,r[:number])" 
-        when :boolean_false
-          output.puts "  assert_equal(:ExcelBoolean,r[:type])"
-          output.puts "  assert_equal(0,r[:number])"           
-        when :blank
-          unless sloppy
-            output.puts "  assert_equal(:ExcelEmpty,r[:type])"
-          else
-            output.puts "  pass if r[:type] == :ExcelEmpty"
-            output.puts "  assert_equal(:ExcelNumber,r[:type])"
-            output.puts "  assert_in_delta(0.0,r[:number],#{@delta})"
-          end
-        else
-          raise NotSupportedException.new("#{ast} type can't be tested")
-        end
-        output.puts "end"
-        output.puts
-      rescue Exception => e
-        puts "Exception at line #{line}"
-        raise
-      end      
-    end
-  end
+  # Now produces tests just like the Ruby version
   
 end

data/src/compile/c/excel_to_c_runtime.c

@@ -1117,6 +1117,7 @@ static ExcelValue string_join(int number_of_arguments, ExcelValue *arguments) {
 		used_length = used_length + current_string_length;
 	}
 	string = realloc(string,used_length+1);
+  string[used_length] = '\0';
 	return new_excel_string(string);
 }
 
@@ -1878,13 +1879,20 @@ int test_functions() {
 	// ... should return a string by combining its arguments
 	// inspect_excel_value(string_join(2, string_join_array_1));
   assert(string_join(2, string_join_array_1).string[6] == 'w');
+  assert(string_join(2, string_join_array_1).string[11] == '\0');
 	// ... should cope with an arbitrary number of arguments
   assert(string_join(3, string_join_array_2).string[11] == '!');
+  assert(string_join(3, string_join_array_3).string[12] == '\0');
 	// ... should convert values to strings as it goes
   assert(string_join(2, string_join_array_3).string[4] == '1');
-	// ... should convert integer values into strings without decimal points
-  assert(string_join(2, string_join_array_3).string[7] == '\0');
+  assert(string_join(2, string_join_array_3).string[5] == '0');
+  assert(string_join(2, string_join_array_3).string[6] == '\0');
+	// ... should convert integer values into strings without decimal points, and float values with decimal points
+  assert(string_join(2, string_join_array_4).string[4] == '1');
+  assert(string_join(2, string_join_array_4).string[5] == '0');
+  assert(string_join(2, string_join_array_4).string[6] == '.');
   assert(string_join(2, string_join_array_4).string[7] == '5');
+  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');
 	

data/src/compile/c/map_sheet_names_to_c_names.rb

@@ -10,7 +10,7 @@ class MapSheetNamesToCNames
       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 = c_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

data/src/rewrite.rb

@@ -8,3 +8,4 @@ require_relative "rewrite/rewrite_values_to_ast"
 require_relative "rewrite/rewrite_relationship_id_to_filename"
 require_relative "rewrite/rewrite_merge_formulae_and_values"
 require_relative "rewrite/rewrite_cell_references_to_include_sheet"
+require_relative "rewrite/rewrite_named_reference_names"

data/src/rewrite/rewrite_named_reference_names.rb

@@ -0,0 +1,35 @@
+class RewriteNamedReferenceNames
+
+  def self.rewrite(*args)
+    self.new.rewrite(*args)
+  end
+  
+  # Expects named reference in the form:
+  # sheet_name_or_blank_for_global\tnamed_reference_name\treference\n
+  # Outputs named references in the form:
+  # name\treference\n
+  # where name incorporates the sheet name and has been rewritten in a way
+  # that works as a c function name and (hopefully) won't clash with any
+  # existing names 
+  # FIXME: but could still clash with function names and methods in the ruby shim
+  def rewrite(named_references, worksheet_names, output)
+    worksheet_names = Hash[worksheet_names.readlines.map { |line| line.strip.split("\t")}]
+    c_names_assigned = worksheet_names.invert
+
+    named_references.lines do |line|
+      sheet, name, reference = line.split("\t")
+      sheet = worksheet_names[sheet]
+      if sheet
+        c_name = "#{sheet}_#{name}"
+      else
+        c_name = name
+        c_name = "n"+c_name if c_name[0] !~ /[a-zA-Z]/
+      end
+      c_name = c_name.downcase.gsub(/[^a-z0-9]+/,'_')
+      c_name = c_name + "2" if c_names_assigned.has_key?(c_name)
+      c_name.succ! while c_names_assigned.has_key?(c_name)
+      output.puts "#{c_name}\t#{reference}"
+      c_names_assigned[c_name] = c_name
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: excel_to_code
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-17 00:00:00.000000000 Z
+date: 2012-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubypeg
@@ -90,7 +90,8 @@ description: ! "# excel_to_code\n\nConverts some excel spreadsheets (.xlsx, not
   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\n5. Sometimes gives cells
-  as being empty, when excel would give the cell as having a numeric value of zero\n"
+  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"
 email: tamc@greenonblack.com
 executables:
 - excel_to_c
@@ -104,6 +105,7 @@ files:
 - src/commands/excel_to_ruby.rb
 - src/commands/excel_to_x.rb
 - src/commands.rb
+- src/compile/c/compile_named_reference_setters.rb
 - src/compile/c/compile_to_c.rb
 - src/compile/c/compile_to_c_header.rb
 - src/compile/c/compile_to_c_unit_test.rb
@@ -194,6 +196,7 @@ files:
 - src/rewrite/rewrite_cell_references_to_include_sheet.rb
 - src/rewrite/rewrite_formulae_to_ast.rb
 - src/rewrite/rewrite_merge_formulae_and_values.rb
+- src/rewrite/rewrite_named_reference_names.rb
 - src/rewrite/rewrite_relationship_id_to_filename.rb
 - src/rewrite/rewrite_shared_formulae.rb
 - src/rewrite/rewrite_values_to_ast.rb