excel_to_code 0.3.18.beta.1 → 0.3.18.beta.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 295445022d29e71173d548f2fbfae87804c2fc19f6ba111c5efdec35657cf7a6
-  data.tar.gz: 025fd8e7080d061732be7f357ff242e2fb51fe64bb985c33c2703b8ae342cf01
+  metadata.gz: 454aafc3c0b81b49d23e47d43c6c9481e05bfd2f203a54cbb4f843a443c2a940
+  data.tar.gz: f91a141c594eade7eb307230be6b942d909081266e6ea13124ebce0539174161
 SHA512:
-  metadata.gz: 6049e42f81bcecf1942c68141cc735406f0227c59c77d0008249bc8e7c3f7480f9090b554ceb62ab27a519861cc00a11c0ccd2673b89de91213fbd90336a12fd
-  data.tar.gz: aa5aba794f98a99481171bf0753f090495f556c8da38a9ff37be8a1c0994fe92b9df15a9bf1f5f787120a23061c17ca6436cf486b2844dbbd628b4cc7cfe4d80
+  metadata.gz: ff5152ff1c3e2db4456ade2ae8602cf68d52cc62dfcaa4bd8e102d1c3083a42bb32b337d4618ca3bfacf97bec9bcf35eddaea3e9e3a9ecc10aba2a52d75d68bf
+  data.tar.gz: aa9fe6581068e15768d53e2b9a9d2692383c487559808a32f1e86df41d0c3ba5b3b50a01884c7b7e5086c8142ba507b48ab6498a10fbad26a4c71b4ddb57f147

data/src/commands/excel_to_x.rb

@@ -342,7 +342,7 @@ class ExcelToX
       begin
         parsed = CachingFormulaParser.parse(reference, treat_external_references_as_local)
         if parsed
-          @named_references[name] = parsed
+          @named_references[name] = deep_copy(parsed)
         else
           $stderr.puts "Named reference #{name} #{reference} not parsed"
           exit
@@ -363,6 +363,15 @@ class ExcelToX
 
   end
 
+	def deep_copy(ast)
+		return ast if ast.is_a?(Symbol)
+		return ast if ast.is_a?(Numeric)
+		return ast.dup unless ast.is_a?(Array)
+		ast.map do |a|
+			deep_copy(a)
+		end
+	end
+
   # Named references can be simple cell references, 
   # or they can be ranges, or errors, or table references
   # this function converts all the different types into
@@ -375,7 +384,7 @@ class ExcelToX
     @named_references.each do |name, reference|
       reference = table_reference_replacer.map(reference)
       reference = @replace_ranges_with_array_literals_replacer.map(reference)
-      @named_references[name] = reference
+      @named_references[name] = deep_copy(reference)
     end
 
   end
@@ -1133,7 +1142,7 @@ class ExcelToX
       replacements_made_in_the_last_pass += indirect_replacement.count_replaced
 
       log.info "Pass #{number_of_passes}: Made #{replacements_made_in_the_last_pass} replacements"
-    end while replacements_made_in_the_last_pass > 0 && number_of_passes < 20
+    end while replacements_made_in_the_last_pass > 0 && number_of_passes < 50
   end
 
   

data/src/compile/c/excel_to_c_runtime.c

@@ -86,6 +86,7 @@ static ExcelValue max(int number_of_arguments, ExcelValue *arguments);
 static ExcelValue min(int number_of_arguments, ExcelValue *arguments);
 static ExcelValue mmult(ExcelValue a_v, ExcelValue b_v);
 static ExcelValue mod(ExcelValue a_v, ExcelValue b_v);
+static ExcelValue mround(ExcelValue value_v, ExcelValue multiple_v);
 static ExcelValue na();
 static ExcelValue negative(ExcelValue a_v);
 static ExcelValue excel_not(ExcelValue a_v);
@@ -107,6 +108,9 @@ static ExcelValue rounddown(ExcelValue number_v, ExcelValue decimal_places_v);
 static ExcelValue roundup(ExcelValue number_v, ExcelValue decimal_places_v);
 static ExcelValue excel_int(ExcelValue number_v);
 static ExcelValue string_join(int number_of_arguments, ExcelValue *arguments);
+static ExcelValue substitute_3(ExcelValue string_v, ExcelValue old_string_v, ExcelValue new_string_v);
+static ExcelValue substitute_4(ExcelValue string_v, ExcelValue old_string_v, ExcelValue new_string_v, ExcelValue occurrence_number_v);
+static ExcelValue substitute(ExcelValue string_v, ExcelValue old_string_v, ExcelValue new_string_v, int occurrence);
 static ExcelValue subtotal(ExcelValue type, int number_of_arguments, ExcelValue *arguments);
 static ExcelValue sumifs(ExcelValue sum_range_v, int number_of_arguments, ExcelValue *arguments);
 static ExcelValue sumif(ExcelValue check_range_v, ExcelValue criteria_v, ExcelValue sum_range_v );
@@ -305,7 +309,50 @@ static double number_from(ExcelValue v) {
   return 0;
 }
 
-#define NUMBER(value_name, name) double name; if(value_name.type == ExcelError) { return value_name; }; name = number_from(value_name);
+static char* string_from(ExcelValue v) {
+		char *string;
+		switch (v.type) {
+  	  case ExcelString:
+	  		return v.string;
+	  		break;
+  	  case ExcelNumber:
+		    string = malloc(20);
+		  	if(string == 0) {
+		  	  printf("Out of memory in string_from");
+		  	  exit(-1);
+		  	}
+			  snprintf(string,20,"%g",v.number);
+        free_later(string);
+        return string;
+			  break;
+		  case ExcelBoolean:
+		  	if(v.number == true) {
+		  		string = "TRUE";
+          free_later(string);
+          return string;
+  			} else {
+		  		string = "FALSE";
+          free_later(string);
+          return string;
+  			}
+        break;
+		  case ExcelEmpty:
+		  	string = "";
+        free_later(string);
+        break;
+      case ExcelError:
+        conversion_error = 1;
+        return 0;
+	  	case ExcelRange:
+        conversion_error = 1;
+        return 0;
+		}
+    conversion_error = 1;
+    return 0;
+}
+
+#define NUMBER(value_name, name) double name; if(value_name.type == ExcelError) { conversion_error = 0; return value_name; }; name = number_from(value_name);
+#define STRING(value_name, name) char *name; if(value_name.type == ExcelError) { conversion_error = 0; return value_name; }; name = string_from(value_name);
 #define CHECK_FOR_CONVERSION_ERROR 	if(conversion_error) { conversion_error = 0; return VALUE; };
 #define CHECK_FOR_PASSED_ERROR(name) 	if(name.type == ExcelError) return name;
 
@@ -465,6 +512,7 @@ static ExcelValue rate(ExcelValue periods_v, ExcelValue payment_v, ExcelValue pr
   NUMBER(payment_v, payment)
   NUMBER(presentValue_v, presentValue)
   NUMBER(finalValue_v, finalValue)
+  CHECK_FOR_CONVERSION_ERROR;
 
   // FIXME: Only implemented the case where payment is zero
   if(payment != 0) {
@@ -474,6 +522,29 @@ static ExcelValue rate(ExcelValue periods_v, ExcelValue payment_v, ExcelValue pr
   return EXCEL_NUMBER(pow((finalValue/(-presentValue)),(1.0/periods))-1.0);
 }
 
+static ExcelValue mround(ExcelValue value_v, ExcelValue multiple_v) {
+  CHECK_FOR_PASSED_ERROR(value_v)
+  CHECK_FOR_PASSED_ERROR(multiple_v)
+
+  NUMBER(value_v, value)
+  NUMBER(multiple_v, multiple)
+  CHECK_FOR_CONVERSION_ERROR;
+
+  if( (value < 0) != (multiple < 0)) {
+    return NUM;
+  }
+
+  if(value == 0) {
+    return ZERO;
+  }
+
+  if(multiple == 0) {
+    return ZERO;
+  }
+
+  return EXCEL_NUMBER(round(value / multiple) * multiple);
+}
+
 static ExcelValue excel_and(int array_size, ExcelValue *array) {
 	int i;
 	ExcelValue current_excel_value, array_result;
@@ -1777,12 +1848,11 @@ static ExcelValue rank(ExcelValue number_v, ExcelValue range_v, ExcelValue order
 
   NUMBER(number_v, number)
   NUMBER(order_v, order)
+	CHECK_FOR_CONVERSION_ERROR
 
   ExcelValue *array;
   int size;
 
-	CHECK_FOR_CONVERSION_ERROR
-
   if(range_v.type != ExcelRange) {
     array = new_excel_value_array(1);
     array[0] = range_v;
@@ -1934,6 +2004,129 @@ static ExcelValue string_join(int number_of_arguments, ExcelValue *arguments) {
 	return EXCEL_STRING(string);
 }
 
+static ExcelValue substitute_3(ExcelValue string_v, ExcelValue old_string_v, ExcelValue new_string_v) {
+  // -1 means all occurrences
+  return substitute(string_v, old_string_v, new_string_v, -1);
+}
+
+static ExcelValue substitute_4(ExcelValue string_v, ExcelValue old_string_v, ExcelValue new_string_v, ExcelValue occurrence_number_v) {
+  CHECK_FOR_PASSED_ERROR(occurrence_number_v)
+  NUMBER(occurrence_number_v,occurrence_number)
+  CHECK_FOR_CONVERSION_ERROR
+  return substitute(string_v, old_string_v, new_string_v, occurrence_number);
+}
+
+// Pass < 0 to occurrence_n to replace all occurrences
+static ExcelValue substitute(ExcelValue string_v, ExcelValue old_string_v, ExcelValue new_string_v, int occurrence_n) {
+  STRING(string_v, original)
+  STRING(old_string_v, from_string)
+  STRING(new_string_v, to_string)
+  CHECK_FOR_CONVERSION_ERROR
+
+  char *new_string = 0; // Allocated below
+  int original_length = strlen(original);
+  int from_string_length = strlen(from_string);
+  int to_string_length = strlen(to_string);
+  int extra_space_per_replacement = (from_string_length < to_string_length) ? (to_string_length - from_string_length) : 0;
+
+  if(from_string_length == 0) {
+    return string_v;
+  }
+
+  int allocated_length = 0; // Adjusted below
+  int space_for_number_of_replacements = 0; // Adjusted below
+  int replacement_made = 0;
+  int number_of_matches = 0;
+  int insertion_point_offset = 0;
+  char *insertion_point = 0;
+  char *from_point = original;
+  char *match_point = 0;
+
+  if(extra_space_per_replacement > 0) {
+    space_for_number_of_replacements = 5;
+    // Arbitrarily assume 5 replacements as a starting point, plus one for terminator
+    allocated_length = original_length + (space_for_number_of_replacements * extra_space_per_replacement) + 1;
+  } else {
+    // Should be shorter or the same length
+    allocated_length = original_length + 1;
+  }
+
+  new_string = malloc(allocated_length);
+  insertion_point = new_string;
+
+	if(new_string == 0) {
+	  printf("Out of memory in substitute");
+	  exit(-1);
+	}
+
+  while((from_point-original) < original_length) {
+    match_point = strstr(from_point, from_string);
+
+    // No match found
+    if(match_point == NULL) {
+      // No match ever found? return the original
+      if(number_of_matches == 0) {
+        break; 
+      }
+      // Copy the remaining string into the target. We should always have space.
+      replacement_made = 1;
+      strcpy(insertion_point, from_point);
+      break;
+    }
+
+    number_of_matches = number_of_matches + 1;
+
+    // We may only want to replace a single occurrence
+    if(occurrence_n > 0 && occurrence_n != number_of_matches) {
+      // Copy the bit before
+      memcpy(insertion_point, from_point, match_point - from_point);
+      insertion_point = insertion_point + (match_point - from_point);
+
+      // Copy the original
+      memcpy(insertion_point, from_string, from_string_length);
+      insertion_point = insertion_point + from_string_length;
+
+      from_point = match_point + from_string_length;
+      continue;
+    }
+
+    // We want to replace this occurrence
+
+    // Check we hvae enough space for the replacement
+    if(extra_space_per_replacement > 0 && (number_of_matches > space_for_number_of_replacements)) {
+      space_for_number_of_replacements = space_for_number_of_replacements * 2;
+      allocated_length = original_length + (space_for_number_of_replacements * extra_space_per_replacement) + 1;
+      insertion_point_offset = insertion_point - new_string;
+      new_string = realloc(new_string,allocated_length);
+      insertion_point = new_string + insertion_point_offset;
+      if(!new_string) {
+        printf("Out of memory in string substitute realloc trying to increase length to %d", allocated_length);
+        exit(-1);
+      }
+    }
+
+    replacement_made = 1;
+
+    // Copy up to the match
+    memcpy(insertion_point, from_point, match_point - from_point);
+    insertion_point = insertion_point + (match_point - from_point);
+
+    // Copy the replacement
+    memcpy(insertion_point, to_string, to_string_length);
+    insertion_point = insertion_point + to_string_length;
+
+    from_point = match_point + from_string_length;
+  }
+
+  if(replacement_made == 1) {
+    free_later(new_string);
+    return EXCEL_STRING(new_string);
+  } else {
+    free(new_string);
+    return string_v;
+  }
+}
+
 static ExcelValue subtotal(ExcelValue subtotal_type_v, int number_of_arguments, ExcelValue *arguments) {
   CHECK_FOR_PASSED_ERROR(subtotal_type_v)
   NUMBER(subtotal_type_v,subtotal_type)
@@ -2821,6 +3014,11 @@ static ExcelValue curve_5(ExcelValue curveType, ExcelValue currentYear, ExcelVal
 }
 
 static ExcelValue scurve(ExcelValue currentYear_v, ExcelValue startValue_v, ExcelValue endValue_v, ExcelValue duration_v, ExcelValue startYear_v) {
+	CHECK_FOR_PASSED_ERROR(currentYear_v)
+	CHECK_FOR_PASSED_ERROR(startValue_v)
+	CHECK_FOR_PASSED_ERROR(endValue_v)
+	CHECK_FOR_PASSED_ERROR(duration_v)
+	CHECK_FOR_PASSED_ERROR(startYear_v)
 
 	NUMBER(currentYear_v, currentYear)
 	NUMBER(startValue_v, startValue)
@@ -2844,6 +3042,11 @@ static ExcelValue scurve(ExcelValue currentYear_v, ExcelValue startValue_v, Exce
 }
 
 static ExcelValue halfscurve(ExcelValue currentYear_v, ExcelValue startValue_v, ExcelValue endValue_v, ExcelValue duration_v, ExcelValue startYear_v) {
+	CHECK_FOR_PASSED_ERROR(currentYear_v)
+	CHECK_FOR_PASSED_ERROR(startValue_v)
+	CHECK_FOR_PASSED_ERROR(endValue_v)
+	CHECK_FOR_PASSED_ERROR(duration_v)
+	CHECK_FOR_PASSED_ERROR(startYear_v)
 
 	NUMBER(currentYear_v, currentYear)
 	NUMBER(startValue_v, startValue)
@@ -2867,6 +3070,11 @@ static ExcelValue halfscurve(ExcelValue currentYear_v, ExcelValue startValue_v,
 }
 
 static ExcelValue lcurve(ExcelValue currentYear_v, ExcelValue startValue_v, ExcelValue endValue_v, ExcelValue duration_v, ExcelValue startYear_v) {
+	CHECK_FOR_PASSED_ERROR(currentYear_v)
+	CHECK_FOR_PASSED_ERROR(startValue_v)
+	CHECK_FOR_PASSED_ERROR(endValue_v)
+	CHECK_FOR_PASSED_ERROR(duration_v)
+	CHECK_FOR_PASSED_ERROR(startYear_v)
 
 	NUMBER(currentYear_v, currentYear)
 	NUMBER(startValue_v, startValue)

data/src/compile/c/excel_to_c_runtime_test.c

@@ -1212,6 +1212,21 @@ int test_functions() {
   assert(excel_ceiling_math(EXCEL_NUMBER(136), EXCEL_NUMBER(10), ZERO).number == 140);
   assert(excel_ceiling_math(EXCEL_NUMBER(-136), EXCEL_NUMBER(10), ZERO).number == -130);
   assert(excel_ceiling_math(EXCEL_NUMBER(-136), EXCEL_NUMBER(10), ONE).number == -140);
+  
+  // MROUND
+  assert(mround(EXCEL_NUMBER(1), ZERO).number == 0.0);
+  assert(mround(ZERO, EXCEL_NUMBER(1)).number == 0.0);
+  assert(mround(EXCEL_NUMBER(1), EXCEL_NUMBER(1)).number == 1.0);
+  assert(mround(EXCEL_NUMBER(105), EXCEL_NUMBER(10)).number == 110);
+  assert(mround(EXCEL_NUMBER(1.05), EXCEL_NUMBER(0.1)).number == 1.10);
+  assert(mround(EXCEL_NUMBER(-1.05), EXCEL_NUMBER(-0.1)).number == -1.10);
+  assert(mround(EXCEL_NUMBER(-1.05), EXCEL_NUMBER(0.1)).type == ExcelError);
+
+  // SUBSTITUTE 3
+  assert_equal(EXCEL_STRING("Hello Bob, Dear Bob"), substitute_3(EXCEL_STRING("Hello Bob, Dear Bob"), EXCEL_STRING("Bill"), EXCEL_STRING("Frank")), "substitute('Hello Bob, Dear Bob', 'Bill', 'Frank') = 'Hello Bob, Dear Bob')");
+  assert_equal(EXCEL_STRING("Hello Frank, Dear Frank"), substitute_3(EXCEL_STRING("Hello Bob, Dear Bob"), EXCEL_STRING("Bob"), EXCEL_STRING("Frank")), "substitute('Hello Bob, Dear Bob', 'Bob', 'Frank') = 'Hello Frank, Dear Frank')");
+  assert_equal(EXCEL_STRING("Hello Bob, Dear Frank"), substitute_4(EXCEL_STRING("Hello Bob, Dear Bob"), EXCEL_STRING("Bob"), EXCEL_STRING("Frank"), TWO), "substitute('Hello Bob, Dear Bob', 'Bob', 'Frank', 2) = 'Hello Bob, Dear Frank')");
+  assert_equal(EXCEL_STRING("Hello Bob, Dear Bob"), substitute_4(EXCEL_STRING("Hello Bob, Dear Bob"), EXCEL_STRING("Bob"), EXCEL_STRING("Frank"), THREE), "substitute('Hello Bob, Dear Bob', 'Bob', 'Frank', 3) = 'Hello Bob, Dear Bob')");
 
   // curve (a custom climact function)
   assert_equal(
@@ -1239,6 +1254,20 @@ int test_functions() {
     "curve_5(blank, 2023, 0, 10, 10) == 5"
   );
 
+  // CONVERSION ERROR RESET
+  assert(conversion_error == 0);
+  assert_equal(
+    VALUE,
+    curve_5(
+      EXCEL_STRING("s"),
+      EXCEL_STRING("Should be a number"),
+      VALUE,
+      EXCEL_NUMBER(10),
+      EXCEL_NUMBER(10)
+    ),
+    "A messed up curve call"
+  );
+  assert(conversion_error == 0);
 
   // Release memory
   free_all_allocated_memory();
@@ -1249,6 +1278,8 @@ int test_functions() {
   return 0;
 }
 
+
+
 int main() {
   return test_functions();
 }

data/src/compile/c/map_formulae_to_c.rb

@@ -75,6 +75,7 @@ class MapFormulaeToC < MapValuesToC
     :'MIN' => 'min',
     :'MMULT' => 'mmult',
     :'MOD' => 'mod',
+    :'MROUND' => 'mround',
     :'NA' => 'na',
     :'NOT' => 'excel_not',
     :'OR' => 'excel_or',
@@ -97,6 +98,8 @@ class MapFormulaeToC < MapValuesToC
     :'ROUNDUP' => 'roundup',
     :'string_join' => 'string_join',
     :'SUBTOTAL' => 'subtotal',
+    :'SUBSTITUTE3' => 'substitute_3',
+    :'SUBSTITUTE4' => 'substitute_4',
     :'SUM' => 'sum',
     :'SUMIF2' => 'sumif_2',
     :'SUMIF3' => 'sumif',

data/src/compile/ruby/map_formulae_to_ruby.rb

@@ -22,7 +22,6 @@ class MapFormulaeToRuby < MapValuesToRuby
     :'AVERAGE' => 'average',
     :'AVERAGEIFS' => 'averageifs',
     :'CEILING' => 'ceiling',
-    :'_xlfn.CEILING.MATH' => 'ceiling',
     :'CELL' => 'cell',
     :'CHAR' => 'char',
     :'CHOOSE' => 'choose',
@@ -60,6 +59,7 @@ class MapFormulaeToRuby < MapValuesToRuby
     :'MIN' => 'min',
     :'MMULT' => 'mmult',
     :'MOD' => 'mod',
+    :'MROUND' => 'mround',
     :'NA' => 'na',
     :'NOT' => 'excel_not',
     :'NPV' => 'npv',
@@ -89,6 +89,7 @@ class MapFormulaeToRuby < MapValuesToRuby
     :'VALUE' => 'value',
     :'VLOOKUP' => 'vlookup',
     :'^' => 'power',
+    :'_xlfn.CEILING.MATH' => 'ceiling',
     :'_xlfn.FORECAST.LINEAR' => 'forecast',
     :'curve' => 'curve',
     :'halfscurve' => 'halfscurve',

data/src/excel/excel_functions.rb

@@ -148,3 +148,5 @@ require_relative 'excel_functions/replace'
 require_relative 'excel_functions/rate'
 
 require_relative 'excel_functions/ceiling'
+
+require_relative 'excel_functions/mround'

data/src/excel/excel_functions/mround.rb

@@ -0,0 +1,19 @@
+module ExcelFunctions
+  
+  def mround(value, multiple)
+    value = number_argument(value)
+    multiple = number_argument(multiple)
+    return value if value.is_a?(Symbol)
+    return multiple if multiple.is_a?(Symbol)
+
+    # Must both have the same sign
+    return :num unless (value < 0) == (multiple < 0)
+
+    # Zeros just return zero
+    return 0 if value == 0
+    return 0 if multiple == 0
+
+    (value.to_f / multiple.to_f).round * multiple.to_f
+  end
+  
+end

data/src/rewrite/ast_expand_array_formulae.rb

@@ -99,6 +99,10 @@ class AstExpandArrayFormulae
   def map_match(ast)
     array_map(ast, false, true, false)
   end
+
+  def map_offset(ast)
+    array_map(ast, true, false, false, false, false)
+  end
   
   def map_subtotal(ast)
     array_map ast, false, *Array.new(ast.length-3,true)

data/src/rewrite/rewrite_array_formulae.rb

@@ -34,11 +34,11 @@ class ExtractArrayFormulaForCell
     ast[@row_offset+1][@column_offset+1] # plus ones to skip tthe [:array,[:row,"cell"]] symbols
   end
   
-  FUNCTIONS_THAT_CAN_RETURN_ARRAYS = { INDEX: true,  MMULT: true}
+  FUNCTIONS_THAT_CAN_RETURN_ARRAYS = { INDEX: true,  MMULT: true, OFFSET: true}
   
   def map_function(ast)
     return ast unless FUNCTIONS_THAT_CAN_RETURN_ARRAYS.has_key?(ast[1])
-    [:function, :INDEX, ast, @fc.map([:number, (@row_offset+1)]), @fc.map([:number, (column_offset+1)])]
+    [:function, :INDEX, ast.dup, @fc.map([:number, (@row_offset+1)]), @fc.map([:number, (column_offset+1)])]
   end
   
 end

data/src/simplify/replace_arrays_with_single_cells.rb

@@ -67,6 +67,8 @@ class ReplaceArraysWithSingleCellsAst
         # Replacement made in check_match function
       elsif ast[1] == :INDIRECT && check_indirect(ast)
         # Replacement made in check function
+      elsif ast[1] == :OFFSET && check_offset(ast)
+        # Replacement made in check function
       elsif ast[0] == :function && ast[1] == :INDEX && check_index(ast)
         # Replacement made in check
       end
@@ -147,6 +149,32 @@ class ReplaceArraysWithSingleCellsAst
     true
   end
 
+  def check_offset(ast)
+    replacement_made = false
+    #We ALWAYS leave the reference unchanged
+    #if ast[2] && ast[2].first == :array 
+    #  replacement_made = true
+    #  ast[2] = try_and_convert_array(ast[2])
+    #end
+    if ast[3] && ast[3].first == :array
+      replacement_made = true
+      ast[3] = try_and_convert_array(ast[3])
+    end
+    if ast[4] && ast[4].first == :array
+      replacement_made = true
+      ast[4] = try_and_convert_array(ast[4])
+    end
+    if ast[5] && ast[5].first == :array
+      replacement_made = true
+      ast[5] = try_and_convert_array(ast[5])
+    end
+    if ast[6] && ast[6].first == :array
+      replacement_made = true
+      ast[6] = try_and_convert_array(ast[6])
+    end
+    replacement_made
+  end
+
   def check_sumifs(ast)
     replacement_made = false
     i = 4

data/src/simplify/replace_common_elements_in_formulae.rb

@@ -16,7 +16,7 @@ class ReplaceCommonElementsInFormulae
     input
   end
 
-  VALUES = {:number => true, :string => true, :blank => true, :null => true, :error => true, :boolean_true => true, :boolean_false => true, :sheet_reference => true, :cell => true, :row => true}
+  VALUES = {:number => true, :string => true, :blank => true, :null => true, :error => true, :boolean_true => true, :boolean_false => true, :sheet_reference => true, :cell => true, :row => true, :comparator => true}
   
   def replace_repeated_formulae(ast)
     return ast unless ast.is_a?(Array)

data/src/simplify/replace_named_references.rb

@@ -5,16 +5,31 @@ class NamedReferences
   def initialize(refs, tables = {})
     @named_references = refs
     @table_data = tables
+    @deepCopyCache = {}
   end
   
   def reference_for(sheet,named_reference)
     sheet = sheet.downcase
     named_reference = named_reference.downcase.to_sym
-    @named_references[[sheet, named_reference]] ||
+    ref = @named_references[[sheet, named_reference]] ||
     @named_references[named_reference] ||
     @table_data[named_reference] ||
     [:error, :"#NAME?"]
+    return @deepCopyCache[ref] if @deepCopyCache.key?(ref)
+    copy = deep_copy(ref)
+    @deepCopyCache[ref] = copy
+    return copy
   end
+
+  def deep_copy(ast)
+    return ast if ast.is_a?(Symbol)
+    return ast if ast.is_a?(Numeric)
+    return ast.dup unless ast.is_a?(Array)
+    ast.map do |a|
+      deep_copy(a)
+    end
+  end
+
   
 end
 

data/src/simplify/replace_offsets_with_references.rb

@@ -27,22 +27,49 @@ class ReplaceOffsetsWithReferencesAst
     reference = ast[2]
     row_offset = ast[3]
     column_offset = ast[4]
-    height = ast[5] || [:number, 1]
-    width = ast[6] || [:number, 1]
+    height = ast[5]
+    width = ast[6]
+
+    reference = reference.original unless %i{cell sheet_reference array}.include?(reference.first)
+    
+    unless height
+      if reference.first != :array
+        height = [:number, 1.0]
+      else
+        height = [:number, reference.length - 1]
+      end
+    end
+
+    unless width
+      if reference.first != :array
+        width = [:number, 1.0]
+      else
+        width = [:number, reference[1].length - 1]
+      end
+    end
+
+    if reference.first == :array
+      reference = reference[1][1].original
+    end
+
     [row_offset, column_offset, height, width].each do |arg|
        next unless arg.first == :error
        ast.replace(arg) 
        return
     end
+
     return unless [row_offset, column_offset, height, width].all? { |a| a.first == :number }
+
     if reference.first == :cell
-      ast.replace(offset_cell(reference, row_offset, column_offset, height, width))
+      ast.replace(offset_cell(reference, row_offset, column_offset, height, width, nil))
     elsif reference.first == :sheet_reference && reference[2].first == :cell
-      ast.replace([:sheet_reference, reference[1], offset_cell(reference[2], row_offset, column_offset, height, width)])
+      ast.replace(offset_cell(reference[2], row_offset, column_offset, height, width, reference[1]))
+    else
+      p "OFFSET reference is #{reference} from #{ast}, so not replacing"
     end
   end
 
-  def offset_cell(reference, row_offset, column_offset, height, width)
+  def offset_cell(reference, row_offset, column_offset, height, width, sheet)
 
     reference = reference[1]
     row_offset = row_offset[1].to_i
@@ -57,9 +84,14 @@ class ReplaceOffsetsWithReferencesAst
     start_reference = reference.offset(row_offset.to_i, column_offset.to_i)
     end_reference = reference.offset(row_offset.to_i + height.to_i - 1, column_offset.to_i + width.to_i - 1)
     if start_reference == end_reference
-      [:cell, start_reference]
+      if sheet 
+        return [:sheet_reference, sheet, [:cell, start_reference]]
+      else
+        return [:cell, start_reference]
+      end
     else
-      [:area, start_reference, end_reference]
+      area = Area.for("#{start_reference}:#{end_reference}")
+      return area.to_array_literal(sheet)
     end
   end
 

data/src/version.rb

@@ -1,4 +1,4 @@
 class ExcelToCode
-  def self.version() "0.3.18.beta.1" end
+  def self.version() "0.3.18.beta.2" end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: excel_to_code
 version: !ruby/object:Gem::Version
-  version: 0.3.18.beta.1
+  version: 0.3.18.beta.2
 platform: ruby
 authors:
 - Thomas Counsell, Green on Black Ltd
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-16 00:00:00.000000000 Z
+date: 2018-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubypeg
@@ -254,6 +254,7 @@ files:
 - src/excel/excel_functions/mod.rb
 - src/excel/excel_functions/more_than.rb
 - src/excel/excel_functions/more_than_or_equal.rb
+- src/excel/excel_functions/mround.rb
 - src/excel/excel_functions/multiply.rb
 - src/excel/excel_functions/na.rb
 - src/excel/excel_functions/negative.rb
@@ -369,7 +370,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Convert many .xlsx and .xlsm files into equivalent Ruby or C code that can