excel_to_code 0.3.17 → 0.3.18.beta.1

data/src/compile/c/run_c_unit_tests

@@ -0,0 +1,3 @@
+#!/bin/bash
+clang excel_to_c_runtime_test.c
+./a.out

data/src/compile/cd.rb

@@ -0,0 +1,6 @@
+require_relative 'c/compile_to_c'
+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/go.rb

@@ -0,0 +1,3 @@
+require_relative 'go/compile_to_go'
+require_relative 'go/compile_to_go_test'
+require_relative 'go/map_values_to_go'

data/src/compile/go/compile_to_go.rb

@@ -0,0 +1,85 @@
+
+class CompileToGo
+  
+  attr_accessor :settable
+  attr_accessor :gettable
+  attr_accessor :sheet_names
+  
+  def struct_type
+    "spreadsheet"
+  end
+
+  def self.rewrite(*args)
+    self.new.rewrite(*args)
+  end
+  
+  def rewrite(formulae, sheet_names, output)
+    self.settable ||= lambda { |ref| false }
+    self.gettable ||= lambda { |ref| true }
+    self.sheet_names = sheet_names
+
+    m = MapValuesToGo.new
+
+    # The struct
+    output.puts "type #{struct_type} struct {"
+    formulae.each do |ref, _|
+      output.puts "  #{variable_name(ref)} cachedValue"
+    end
+    output.puts "}"
+
+    # The initializer
+    output.puts <<~END
+
+    func New() #{struct_type} {
+      return #{struct_type}{}
+    }
+
+    END
+
+    formulae.each do |ref, ast|
+      v = variable_name(ref)
+      output.puts <<~END
+        func (s *#{struct_type}) #{getter_method_name(ref)}() (interface{}, error) {
+          if !s.#{v}.isCached() {
+            s.#{v}.set(#{m.map(ast)})
+          }
+          return s.#{v}.get()
+        }
+
+      END
+      if settable.call(ref)
+        output.puts <<~END
+
+        func (s *#{struct_type}) #{setter_method_name(ref)}(v interface{}) {
+            s.#{v}.set(v)
+        }
+
+        END
+      end
+    end
+  end
+
+  def getter_method_name(ref)
+    v = variable_name(ref)
+    if gettable.call(ref)
+      v[0] = v[0].upcase!
+    else
+      v[0] = v[0].downcase!
+    end
+    v
+  end
+
+  def setter_method_name(ref)
+    v = variable_name(ref)
+    v[0].upcase!
+    "Set#{v}"
+  end
+
+  def variable_name(ref)
+    worksheet = ref.first
+    cell = ref.last
+    worksheet_name = sheet_names[worksheet.to_s] || worksheet.to_s
+    return worksheet_name.length > 0 ? "#{worksheet_name.downcase}#{cell.upcase}" : cell.downcase
+  end
+  
+end

data/src/compile/go/compile_to_go_test.rb

@@ -0,0 +1,73 @@
+
+class CompileToGoTest
+  
+  attr_accessor :settable
+  attr_accessor :gettable
+  attr_accessor :sheet_names
+  
+  def struct_type
+    "spreadsheet"
+  end
+
+  def self.rewrite(*args)
+    self.new.rewrite(*args)
+  end
+  
+  def rewrite(formulae, sheet_names, output)
+    self.settable ||= lambda { |ref| false }
+    self.gettable ||= lambda { |ref| true }
+    self.sheet_names = sheet_names
+
+    m = MapValuesToGo.new
+
+    formulae.each do |ref, ast|
+      next unless gettable.call(ref)
+      n = getter_method_name(ref)
+
+      if ast.first == :error
+        output.puts <<~END
+        func Test#{n}(t *testing.T) {
+          s := New()
+          e := #{m.map(ast)}
+          a, err := s.#{n}()
+          if err != e {
+              t.Errorf("#{n} = (%v, %v), want (nil, %v)", a, err, e)
+          }
+        }
+
+        END
+
+      else 
+        output.puts <<~END
+        func Test#{n}(t *testing.T) {
+          s := New()
+          e := #{m.map(ast)}
+          a, err := s.#{n}()
+          if a != e || err != nil {
+              t.Errorf("#{n} = (%v, %v), want (%v, nil)", a, err, e)
+          }
+        }
+
+        END
+      end
+    end
+  end
+
+  def getter_method_name(ref)
+    v = variable_name(ref)
+    if gettable.call(ref)
+      v[0] = v[0].upcase!
+    else
+      v[0] = v[0].downcase!
+    end
+    v
+  end
+
+  def variable_name(ref)
+    worksheet = ref.first
+    cell = ref.last
+    worksheet_name = sheet_names[worksheet.to_s] || worksheet.to_s
+    return worksheet_name.length > 0 ? "#{worksheet_name.downcase}#{cell.upcase}" : cell.downcase
+  end
+  
+end

data/src/compile/go/excel.go

@@ -0,0 +1,171 @@
+// excel replicates values and functions from Microsoft Excel
+package excel
+
+import (
+	"fmt"
+	"strconv"
+)
+
+// cachedValue wraps the different possible Excel Values
+//
+// Later, we may have one for each Excel type
+// which is why we use wrappers.
+type cachedValue struct {
+	// v is the cached value, in this case of any type
+	v interface{}
+	// c is whether it is cached
+	c bool
+}
+
+func (c *cachedValue) isCached() bool {
+	return c.c
+}
+
+func (c *cachedValue) set(v interface{}) {
+	c.v = v
+	c.c = true
+}
+
+// get returns the cached value. If the cached
+// value is an Excel Error that is returned as
+// the second argument. If the item isn't cached
+// then will return a NotCachedError.
+func (c *cachedValue) get() (interface{}, error) {
+	if !c.c {
+		return nil, notCachedError{}
+	}
+	if err, ok := c.v.(error); ok {
+		return nil, err
+	}
+	return c.v, nil
+}
+
+type notCachedError struct{}
+
+func (e notCachedError) Error() string {
+	return "Get() called but nothing cached"
+}
+
+// Blank is an empty Excel cell.
+type Blank struct{}
+
+// The Excel #VALUE! error
+type ValueError struct {
+	value interface{}
+	cast  string
+}
+
+// The Excel #NAME? error
+type NameError struct{}
+
+// The Excel #DIV/0! error
+type Div0Error struct{}
+
+// The Excel #REF! error
+type RefError struct{}
+
+// The Excel #N/A error
+type NAError struct{}
+
+// The Excel #NUM! error
+type NumError struct{}
+
+func (e ValueError) Error() string {
+	return fmt.Sprintf("#VALUE!: could not convert %v to %v", e.value, e.cast)
+}
+
+func (e NameError) Error() string {
+	return "#NAME?"
+}
+
+func (e Div0Error) Error() string {
+	return "#DIV/0!"
+}
+
+func (e RefError) Error() string {
+	return "#REF!"
+}
+
+func (e NAError) Error() string {
+	return "#N/A"
+}
+
+func (e NumError) Error() string {
+	return "#DIV/0!"
+}
+
+func excel_if(c interface{}, t, f func() interface{}) interface{} {
+	b, err := boolean(c)
+	if err != nil {
+		return err
+	}
+	if b {
+		if t == nil {
+			return true
+		} else {
+			return t()
+		}
+	} else {
+		if f == nil {
+			return false
+		} else {
+			return f()
+		}
+	}
+}
+
+func add(a, b interface{}) interface{} {
+	n1, err := number(a)
+	if err != nil {
+		return err
+	}
+	n2, err := number(b)
+	if err != nil {
+		return err
+	}
+	return n1 + n2
+}
+
+func number(a interface{}) (float64, error) {
+	switch a := a.(type) {
+	case Blank:
+		return 0, nil
+	case float64:
+		return a, nil
+	case bool:
+		if a {
+			return 1, nil
+		} else {
+			return 0, nil
+		}
+	case error:
+		return 0, a
+	case string:
+		i, err := strconv.ParseFloat(a, 64)
+		if err != nil {
+			return 0, ValueError{a, "float64"}
+		}
+		return i, nil
+	default:
+		return 0, ValueError{a, "float64"}
+	}
+}
+
+func boolean(a interface{}) (bool, error) {
+	switch a := a.(type) {
+	case Blank:
+		return false, nil
+	case float64:
+		if a == 0 {
+			return false, nil
+		} else {
+			return true, nil
+		}
+	case bool:
+		return a, nil
+	case error:
+		return false, a
+	default:
+		return false, ValueError{a, "bool"}
+	}
+}

data/src/compile/go/excel_test.go

@@ -0,0 +1,54 @@
+package excel
+
+import "testing"
+
+type Spreadsheet struct {
+	inputA1  interface{}
+	inputA2  interface{}
+	outputA1 interface{}
+}
+
+func (s *Spreadsheet) InputA1() interface{} {
+	if s.inputA1 == nil {
+		s.inputA1 = Blank{}
+	}
+	return s.inputA1
+}
+
+func (s *Spreadsheet) SetInputA1(value interface{}) {
+	s.inputA1 = value
+}
+
+func (s *Spreadsheet) InputA2() interface{} {
+	if s.inputA2 == nil {
+		s.inputA2 = Blank{}
+	}
+	return s.inputA2
+}
+
+func (s *Spreadsheet) SetInputA2(value interface{}) {
+	s.inputA2 = value
+}
+
+func (s *Spreadsheet) OutputA1() interface{} {
+	if s.outputA1 == nil {
+		inputA1 := s.InputA1()
+		inputA2 := s.InputA2()
+		sum := add(inputA1, inputA2)
+		s.outputA1 = excel_if(sum, func() interface{} {
+			return Blank{}
+		}, s.InputA1)
+	}
+	return s.outputA1
+}
+
+func TestHelloWorld(t *testing.T) {
+	s := Spreadsheet{}
+	s.SetInputA1(1.0)
+	s.SetInputA2(1.0)
+	//inputA1 := s.InputA1()
+	outputA1 := s.OutputA1()
+	if outputA1 != 1 {
+		t.Errorf("%v = %v, want %v", "s.OutputA1()", outputA1, 1)
+	}
+}

data/src/compile/go/map_values_to_go.rb

@@ -0,0 +1,67 @@
+require_relative '../../util/not_supported_exception'
+
+class MapValuesToGo
+
+  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 inlined_blank
+    "Blank{}"
+  end
+  
+  def constant(name)
+    name
+  end
+  
+  alias :null :blank
+    
+  def number(text)
+    text.to_s
+  end
+  
+  def percentage(text)
+    (text.to_f / 100.0).to_s
+  end
+  
+  def string(text)
+    text.inspect
+  end
+  
+  ERRORS = {
+    :"#NAME?" => "NameError{}",
+    :"#VALUE!" => "ValueError{}",
+    :"#DIV/0!" => "Div0Error{}",
+    :"#REF!" => "RefError{}",
+    :"#N/A" => "NAError{}",
+    :"#NUM!" => "NumError{}"
+  }
+  
+  REVERSE_ERRORS = ERRORS.invert
+  
+  def error(text)
+    ERRORS[text.to_sym] || (raise NotSupportedException.new("#{text.inspect} error not recognised"))
+  end
+  
+  def boolean_true
+    "true"
+  end
+  
+  def boolean_false
+    "false"
+  end
+  
+end