surpass 0.0.9 → 0.1.0

data/lib/surpass/ExcelFormulaParser.rb

@@ -5,7 +5,7 @@
 # Generated using ANTLR version: 3.2.1-SNAPSHOT Dec 18, 2009 04:29:28
 # Ruby runtime library version: 1.3.1
 # Input grammar file: ExcelFormula.g
-# Generated at: 2010-05-03 16:34:32
+# Generated at: 2010-06-13 10:19:27
 # 
 
 # ~~~> start load path setup
@@ -77,13 +77,13 @@ module ExcelFormula
 
     # define the token constants
     define_tokens(:GE => 8, :LT => 7, :NUM_CONST => 21, :PERCENT => 16, 
-                  :REF2D => 22, :CONCAT => 10, :RP => 29, :LP => 26, :INT_CONST => 20, 
+                  :REF2D => 22, :CONCAT => 10, :RP => 25, :LP => 24, :INT_CONST => 20, 
                   :STR_CONST => 19, :POWER => 15, :SUB => 12, :FUNC_CHOOSE => 30, 
-                  :SEMICOLON => 27, :BANG => 24, :TRUE_CONST => 17, :EOF => -1, 
-                  :MUL => 13, :COLON => 23, :NAME => 31, :FALSE_CONST => 18, 
-                  :COMMA => 28, :GT => 6, :DIGIT => 33, :EQ => 4, :DIV => 14, 
-                  :FUNC_IF => 25, :QUOTENAME => 32, :LE => 9, :NE => 5, 
-                  :ADD => 11)
+                  :SEMICOLON => 28, :BANG => 26, :TRUE_CONST => 17, :EOF => -1, 
+                  :MUL => 13, :ALPHA => 34, :COLON => 23, :NAME => 31, :FALSE_CONST => 18, 
+                  :WS => 35, :COMMA => 29, :GT => 6, :DIGIT => 33, :EQ => 4, 
+                  :DIV => 14, :FUNC_IF => 27, :QUOTENAME => 32, :LE => 9, 
+                  :NE => 5, :ADD => 11)
 
     # register the proper human-readable name or literal value
     # for each token type
@@ -94,8 +94,9 @@ module ExcelFormula
     register_names("EQ", "NE", "GT", "LT", "GE", "LE", "CONCAT", "ADD", 
                    "SUB", "MUL", "DIV", "POWER", "PERCENT", "TRUE_CONST", 
                    "FALSE_CONST", "STR_CONST", "INT_CONST", "NUM_CONST", 
-                   "REF2D", "COLON", "BANG", "FUNC_IF", "LP", "SEMICOLON", 
-                   "COMMA", "RP", "FUNC_CHOOSE", "NAME", "QUOTENAME", "DIGIT")
+                   "REF2D", "COLON", "LP", "RP", "BANG", "FUNC_IF", "SEMICOLON", 
+                   "COMMA", "FUNC_CHOOSE", "NAME", "QUOTENAME", "DIGIT", 
+                   "ALPHA", "WS")
     
   end
 
@@ -142,7 +143,7 @@ module ExcelFormula
 
       begin
         # at line 25:7: expr[\"V\"]
-        @state.following.push(TOKENS_FOLLOWING_expr_IN_formula_60)
+        @state.following.push(TOKENS_FOLLOWING_expr_IN_formula_56)
         expr("V")
         @state.following.pop
 
@@ -170,7 +171,7 @@ module ExcelFormula
 
       begin
         # at line 29:7: prec0_expr[arg_type] ( ( EQ | NE | GT | LT | GE | LE ) prec0_expr[arg_type] )*
-        @state.following.push(TOKENS_FOLLOWING_prec0_expr_IN_expr_79)
+        @state.following.push(TOKENS_FOLLOWING_prec0_expr_IN_expr_75)
         prec0_expr(arg_type)
         @state.following.pop
         # at line 30:9: ( ( EQ | NE | GT | LT | GE | LE ) prec0_expr[arg_type] )*
@@ -196,48 +197,48 @@ module ExcelFormula
             case alt_1
             when 1
               # at line 32:19: EQ
-              match(EQ, TOKENS_FOLLOWING_EQ_IN_expr_124)
+              match(EQ, TOKENS_FOLLOWING_EQ_IN_expr_120)
               # --> action
                op = [PTGEQ].pack('C') 
               # <-- action
 
             when 2
               # at line 33:19: NE
-              match(NE, TOKENS_FOLLOWING_NE_IN_expr_146)
+              match(NE, TOKENS_FOLLOWING_NE_IN_expr_142)
               # --> action
                op = [PTGNE].pack('C') 
               # <-- action
 
             when 3
               # at line 34:19: GT
-              match(GT, TOKENS_FOLLOWING_GT_IN_expr_168)
+              match(GT, TOKENS_FOLLOWING_GT_IN_expr_164)
               # --> action
                op = [PTGGT].pack('C') 
               # <-- action
 
             when 4
               # at line 35:19: LT
-              match(LT, TOKENS_FOLLOWING_LT_IN_expr_190)
+              match(LT, TOKENS_FOLLOWING_LT_IN_expr_186)
               # --> action
                op = [PTGLT].pack('C') 
               # <-- action
 
             when 5
               # at line 36:19: GE
-              match(GE, TOKENS_FOLLOWING_GE_IN_expr_212)
+              match(GE, TOKENS_FOLLOWING_GE_IN_expr_208)
               # --> action
                op = [PTGGE].pack('C') 
               # <-- action
 
             when 6
               # at line 37:19: LE
-              match(LE, TOKENS_FOLLOWING_LE_IN_expr_234)
+              match(LE, TOKENS_FOLLOWING_LE_IN_expr_230)
               # --> action
                op = [PTGLE].pack('C') 
               # <-- action
 
             end
-            @state.following.push(TOKENS_FOLLOWING_prec0_expr_IN_expr_265)
+            @state.following.push(TOKENS_FOLLOWING_prec0_expr_IN_expr_261)
             prec0_expr(arg_type)
             @state.following.pop
             # --> action
@@ -273,7 +274,7 @@ module ExcelFormula
 
       begin
         # at line 45:7: prec1_expr[arg_type] ( ( CONCAT ) prec1_expr[arg_type] )*
-        @state.following.push(TOKENS_FOLLOWING_prec1_expr_IN_prec0_expr_297)
+        @state.following.push(TOKENS_FOLLOWING_prec1_expr_IN_prec0_expr_293)
         prec1_expr(arg_type)
         @state.following.pop
         # at line 46:9: ( ( CONCAT ) prec1_expr[arg_type] )*
@@ -285,12 +286,12 @@ module ExcelFormula
             # at line 47:13: ( CONCAT ) prec1_expr[arg_type]
             # at line 47:13: ( CONCAT )
             # at line 48:17: CONCAT
-            match(CONCAT, TOKENS_FOLLOWING_CONCAT_IN_prec0_expr_340)
+            match(CONCAT, TOKENS_FOLLOWING_CONCAT_IN_prec0_expr_336)
             # --> action
              op = [PTGCONCAT].pack('C') 
             # <-- action
 
-            @state.following.push(TOKENS_FOLLOWING_prec1_expr_IN_prec0_expr_370)
+            @state.following.push(TOKENS_FOLLOWING_prec1_expr_IN_prec0_expr_366)
             prec1_expr(arg_type)
             @state.following.pop
             # --> action
@@ -326,7 +327,7 @@ module ExcelFormula
 
       begin
         # at line 55:7: prec2_expr[arg_type] ( ( ADD | SUB ) prec2_expr[arg_type] )*
-        @state.following.push(TOKENS_FOLLOWING_prec2_expr_IN_prec1_expr_402)
+        @state.following.push(TOKENS_FOLLOWING_prec2_expr_IN_prec1_expr_398)
         prec2_expr(arg_type)
         @state.following.pop
         # at line 56:9: ( ( ADD | SUB ) prec2_expr[arg_type] )*
@@ -351,20 +352,20 @@ module ExcelFormula
             case alt_4
             when 1
               # at line 58:19: ADD
-              match(ADD, TOKENS_FOLLOWING_ADD_IN_prec1_expr_447)
+              match(ADD, TOKENS_FOLLOWING_ADD_IN_prec1_expr_443)
               # --> action
                op = [PTGADD].pack('C') 
               # <-- action
 
             when 2
               # at line 59:19: SUB
-              match(SUB, TOKENS_FOLLOWING_SUB_IN_prec1_expr_469)
+              match(SUB, TOKENS_FOLLOWING_SUB_IN_prec1_expr_465)
               # --> action
                op = [PTGSUB].pack('C') 
               # <-- action
 
             end
-            @state.following.push(TOKENS_FOLLOWING_prec2_expr_IN_prec1_expr_499)
+            @state.following.push(TOKENS_FOLLOWING_prec2_expr_IN_prec1_expr_495)
             prec2_expr(arg_type)
             @state.following.pop
             # --> action
@@ -400,7 +401,7 @@ module ExcelFormula
 
       begin
         # at line 67:7: prec3_expr[arg_type] ( ( MUL | DIV ) prec3_expr[arg_type] )*
-        @state.following.push(TOKENS_FOLLOWING_prec3_expr_IN_prec2_expr_532)
+        @state.following.push(TOKENS_FOLLOWING_prec3_expr_IN_prec2_expr_528)
         prec3_expr(arg_type)
         @state.following.pop
         # at line 68:9: ( ( MUL | DIV ) prec3_expr[arg_type] )*
@@ -425,20 +426,20 @@ module ExcelFormula
             case alt_6
             when 1
               # at line 70:19: MUL
-              match(MUL, TOKENS_FOLLOWING_MUL_IN_prec2_expr_577)
+              match(MUL, TOKENS_FOLLOWING_MUL_IN_prec2_expr_573)
               # --> action
                op = [PTGMUL].pack('C') 
               # <-- action
 
             when 2
               # at line 71:19: DIV
-              match(DIV, TOKENS_FOLLOWING_DIV_IN_prec2_expr_599)
+              match(DIV, TOKENS_FOLLOWING_DIV_IN_prec2_expr_595)
               # --> action
                op = [PTGDIV].pack('C') 
               # <-- action
 
             end
-            @state.following.push(TOKENS_FOLLOWING_prec3_expr_IN_prec2_expr_629)
+            @state.following.push(TOKENS_FOLLOWING_prec3_expr_IN_prec2_expr_625)
             prec3_expr(arg_type)
             @state.following.pop
             # --> action
@@ -467,32 +468,32 @@ module ExcelFormula
     # parser rule prec3_expr
     # 
     # (in ExcelFormula.g)
-    # 77:1: prec3_expr[arg_type] : prec5_expr[arg_type] ( ( POWER ) prec5_expr[arg_type] )* ;
+    # 77:1: prec3_expr[arg_type] : prec4_expr[arg_type] ( ( POWER ) prec4_expr[arg_type] )* ;
     def prec3_expr(arg_type)
       # -> uncomment the next line to manually enable rule tracing
       # trace_in(__method__, 6)
 
       begin
-        # at line 78:7: prec5_expr[arg_type] ( ( POWER ) prec5_expr[arg_type] )*
-        @state.following.push(TOKENS_FOLLOWING_prec5_expr_IN_prec3_expr_661)
-        prec5_expr(arg_type)
+        # at line 78:7: prec4_expr[arg_type] ( ( POWER ) prec4_expr[arg_type] )*
+        @state.following.push(TOKENS_FOLLOWING_prec4_expr_IN_prec3_expr_657)
+        prec4_expr(arg_type)
         @state.following.pop
-        # at line 79:9: ( ( POWER ) prec5_expr[arg_type] )*
+        # at line 79:9: ( ( POWER ) prec4_expr[arg_type] )*
         loop do # decision 8
           alt_8 = 2
           alt_8 = @dfa8.predict(@input)
           case alt_8
           when 1
-            # at line 80:13: ( POWER ) prec5_expr[arg_type]
+            # at line 80:13: ( POWER ) prec4_expr[arg_type]
             # at line 80:13: ( POWER )
             # at line 81:17: POWER
-            match(POWER, TOKENS_FOLLOWING_POWER_IN_prec3_expr_704)
+            match(POWER, TOKENS_FOLLOWING_POWER_IN_prec3_expr_700)
             # --> action
              op = [PTGPOWER].pack('C') 
             # <-- action
 
-            @state.following.push(TOKENS_FOLLOWING_prec5_expr_IN_prec3_expr_734)
-            prec5_expr(arg_type)
+            @state.following.push(TOKENS_FOLLOWING_prec4_expr_IN_prec3_expr_730)
+            prec4_expr(arg_type)
             @state.following.pop
             # --> action
              @rpn += op 
@@ -527,20 +528,16 @@ module ExcelFormula
 
       begin
         # at line 88:7: prec5_expr[arg_type] ( PERCENT )?
-        @state.following.push(TOKENS_FOLLOWING_prec5_expr_IN_prec4_expr_766)
+        @state.following.push(TOKENS_FOLLOWING_prec5_expr_IN_prec4_expr_762)
         prec5_expr(arg_type)
         @state.following.pop
         # at line 89:9: ( PERCENT )?
         alt_9 = 2
-        look_9_0 = @input.peek(1)
-
-        if (look_9_0 == PERCENT) 
-          alt_9 = 1
-        end
+        alt_9 = @dfa9.predict(@input)
         case alt_9
         when 1
           # at line 90:13: PERCENT
-          match(PERCENT, TOKENS_FOLLOWING_PERCENT_IN_prec4_expr_791)
+          match(PERCENT, TOKENS_FOLLOWING_PERCENT_IN_prec4_expr_787)
           # --> action
            @rpn += [PTGPERCENT].pack('C') 
           # <-- action
@@ -576,14 +573,14 @@ module ExcelFormula
         case alt_10
         when 1
           # at line 95:7: primary[arg_type]
-          @state.following.push(TOKENS_FOLLOWING_primary_IN_prec5_expr_822)
+          @state.following.push(TOKENS_FOLLOWING_primary_IN_prec5_expr_818)
           primary(arg_type)
           @state.following.pop
 
         when 2
           # at line 96:7: SUB primary[arg_type]
-          match(SUB, TOKENS_FOLLOWING_SUB_IN_prec5_expr_831)
-          @state.following.push(TOKENS_FOLLOWING_primary_IN_prec5_expr_833)
+          match(SUB, TOKENS_FOLLOWING_SUB_IN_prec5_expr_827)
+          @state.following.push(TOKENS_FOLLOWING_primary_IN_prec5_expr_829)
           primary(arg_type)
           @state.following.pop
           # --> action
@@ -608,7 +605,7 @@ module ExcelFormula
     # parser rule primary
     # 
     # (in ExcelFormula.g)
-    # 99:1: primary[arg_type] : ( TRUE_CONST | FALSE_CONST | str_tok= STR_CONST | int_tok= INT_CONST | num_tok= NUM_CONST | ref2d_tok= REF2D | ref2d1_tok= REF2D COLON ref2d2_tok= REF2D | sheet1= sheet ( COLON sheet2= sheet )? BANG ref3d_ref2d= REF2D ( COLON ref3d_ref2d2= REF2D )? | FUNC_IF LP expr[\"V\"] ( SEMICOLON | COMMA ) expr[arg_type] ( SEMICOLON | COMMA ) expr[arg_type] RP | FUNC_CHOOSE LP expr[\"V\"] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )* RP | name_tok= NAME | func_tok= NAME LP arg_count= expr_list[arg_type_list, min_argc, max_argc] RP | LP expr[arg_type] RP );
+    # 99:1: primary[arg_type] : ( TRUE_CONST | FALSE_CONST | str_tok= STR_CONST | int_tok= INT_CONST | num_tok= NUM_CONST | ref2d_tok= REF2D | ref2d1_tok= REF2D COLON ref2d2_tok= REF2D | LP expr[arg_type] RP | sheet1= sheet ( COLON sheet2= sheet )? BANG ref3d_ref2d= REF2D ( COLON ref3d_ref2d2= REF2D )? | FUNC_IF LP expr[\"V\"] ( SEMICOLON | COMMA ) expr[arg_type] ( SEMICOLON | COMMA ) expr[arg_type] RP | FUNC_CHOOSE LP expr[\"V\"] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )* RP | name_tok= NAME | func_tok= NAME LP arg_count= expr_list[arg_type_list, min_argc, max_argc] RP );
     def primary(arg_type)
       # -> uncomment the next line to manually enable rule tracing
       # trace_in(__method__, 9)
@@ -627,13 +624,13 @@ module ExcelFormula
       arg_count = nil
 
       begin
-        # at line 100:5: ( TRUE_CONST | FALSE_CONST | str_tok= STR_CONST | int_tok= INT_CONST | num_tok= NUM_CONST | ref2d_tok= REF2D | ref2d1_tok= REF2D COLON ref2d2_tok= REF2D | sheet1= sheet ( COLON sheet2= sheet )? BANG ref3d_ref2d= REF2D ( COLON ref3d_ref2d2= REF2D )? | FUNC_IF LP expr[\"V\"] ( SEMICOLON | COMMA ) expr[arg_type] ( SEMICOLON | COMMA ) expr[arg_type] RP | FUNC_CHOOSE LP expr[\"V\"] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )* RP | name_tok= NAME | func_tok= NAME LP arg_count= expr_list[arg_type_list, min_argc, max_argc] RP | LP expr[arg_type] RP )
+        # at line 100:5: ( TRUE_CONST | FALSE_CONST | str_tok= STR_CONST | int_tok= INT_CONST | num_tok= NUM_CONST | ref2d_tok= REF2D | ref2d1_tok= REF2D COLON ref2d2_tok= REF2D | LP expr[arg_type] RP | sheet1= sheet ( COLON sheet2= sheet )? BANG ref3d_ref2d= REF2D ( COLON ref3d_ref2d2= REF2D )? | FUNC_IF LP expr[\"V\"] ( SEMICOLON | COMMA ) expr[arg_type] ( SEMICOLON | COMMA ) expr[arg_type] RP | FUNC_CHOOSE LP expr[\"V\"] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )* RP | name_tok= NAME | func_tok= NAME LP arg_count= expr_list[arg_type_list, min_argc, max_argc] RP )
         alt_15 = 13
         alt_15 = @dfa15.predict(@input)
         case alt_15
         when 1
           # at line 100:7: TRUE_CONST
-          match(TRUE_CONST, TOKENS_FOLLOWING_TRUE_CONST_IN_primary_854)
+          match(TRUE_CONST, TOKENS_FOLLOWING_TRUE_CONST_IN_primary_850)
           # --> action
 
                       @rpn += [PTGBOOL, 1].pack("C2")
@@ -642,7 +639,7 @@ module ExcelFormula
 
         when 2
           # at line 104:7: FALSE_CONST
-          match(FALSE_CONST, TOKENS_FOLLOWING_FALSE_CONST_IN_primary_872)
+          match(FALSE_CONST, TOKENS_FOLLOWING_FALSE_CONST_IN_primary_868)
           # --> action
 
                       @rpn += [PTGBOOL, 0].pack("C2")
@@ -651,7 +648,7 @@ module ExcelFormula
 
         when 3
           # at line 108:7: str_tok= STR_CONST
-          str_tok = match(STR_CONST, TOKENS_FOLLOWING_STR_CONST_IN_primary_894)
+          str_tok = match(STR_CONST, TOKENS_FOLLOWING_STR_CONST_IN_primary_890)
           # --> action
 
                       s = str_tok.text.gsub("\"", "")
@@ -661,7 +658,7 @@ module ExcelFormula
 
         when 4
           # at line 113:7: int_tok= INT_CONST
-          int_tok = match(INT_CONST, TOKENS_FOLLOWING_INT_CONST_IN_primary_916)
+          int_tok = match(INT_CONST, TOKENS_FOLLOWING_INT_CONST_IN_primary_912)
           # --> action
 
                   int_value = int_tok.text.to_i
@@ -675,7 +672,7 @@ module ExcelFormula
 
         when 5
           # at line 122:7: num_tok= NUM_CONST
-          num_tok = match(NUM_CONST, TOKENS_FOLLOWING_NUM_CONST_IN_primary_934)
+          num_tok = match(NUM_CONST, TOKENS_FOLLOWING_NUM_CONST_IN_primary_930)
           # --> action
 
                       @rpn += [PTGNUM, num_tok.text.to_f].pack("CE")
@@ -684,32 +681,45 @@ module ExcelFormula
 
         when 6
           # at line 126:7: ref2d_tok= REF2D
-          ref2d_tok = match(REF2D, TOKENS_FOLLOWING_REF2D_IN_primary_956)
+          ref2d_tok = match(REF2D, TOKENS_FOLLOWING_REF2D_IN_primary_952)
           # --> action
 
                     r, c = Utilities.cell_to_packed_rowcol(ref2d_tok.text) 
-                    ptg = PTGREFR + RVA_DELTA[arg_type]
+                    ptg = PTGREFR + RVA_DELTA_REF[arg_type]
                     @rpn += [ptg, r, c].pack("Cv2")
                   
           # <-- action
 
         when 7
           # at line 132:7: ref2d1_tok= REF2D COLON ref2d2_tok= REF2D
-          ref2d1_tok = match(REF2D, TOKENS_FOLLOWING_REF2D_IN_primary_978)
-          match(COLON, TOKENS_FOLLOWING_COLON_IN_primary_980)
-          ref2d2_tok = match(REF2D, TOKENS_FOLLOWING_REF2D_IN_primary_986)
+          ref2d1_tok = match(REF2D, TOKENS_FOLLOWING_REF2D_IN_primary_974)
+          match(COLON, TOKENS_FOLLOWING_COLON_IN_primary_976)
+          ref2d2_tok = match(REF2D, TOKENS_FOLLOWING_REF2D_IN_primary_982)
           # --> action
 
                       r1, c1 = Utilities.cell_to_packed_rowcol(ref2d1_tok.text) 
                       r2, c2 = Utilities.cell_to_packed_rowcol(ref2d2_tok.text)
-                      ptg = PTGAREAR + RVA_DELTA[arg_type]
+                      ptg = PTGAREAR + RVA_DELTA_AREA[arg_type]
                       @rpn += [ptg, r1, r2, c1, c2].pack("Cv4")
                   
           # <-- action
 
         when 8
-          # at line 140:7: sheet1= sheet ( COLON sheet2= sheet )? BANG ref3d_ref2d= REF2D ( COLON ref3d_ref2d2= REF2D )?
-          @state.following.push(TOKENS_FOLLOWING_sheet_IN_primary_1010)
+          # at line 139:7: LP expr[arg_type] RP
+          match(LP, TOKENS_FOLLOWING_LP_IN_primary_1000)
+          @state.following.push(TOKENS_FOLLOWING_expr_IN_primary_1002)
+          expr(arg_type)
+          @state.following.pop
+          match(RP, TOKENS_FOLLOWING_RP_IN_primary_1005)
+          # --> action
+
+                      @rpn += [PTGPAREN].pack('C')
+                  
+          # <-- action
+
+        when 9
+          # at line 143:7: sheet1= sheet ( COLON sheet2= sheet )? BANG ref3d_ref2d= REF2D ( COLON ref3d_ref2d2= REF2D )?
+          @state.following.push(TOKENS_FOLLOWING_sheet_IN_primary_1028)
           sheet1 = sheet
           @state.following.pop
           # --> action
@@ -717,7 +727,7 @@ module ExcelFormula
                       sheet2 = sheet1
                   
           # <-- action
-          # at line 144:9: ( COLON sheet2= sheet )?
+          # at line 147:9: ( COLON sheet2= sheet )?
           alt_11 = 2
           look_11_0 = @input.peek(1)
 
@@ -726,34 +736,33 @@ module ExcelFormula
           end
           case alt_11
           when 1
-            # at line 144:11: COLON sheet2= sheet
-            match(COLON, TOKENS_FOLLOWING_COLON_IN_primary_1032)
-            @state.following.push(TOKENS_FOLLOWING_sheet_IN_primary_1038)
+            # at line 147:11: COLON sheet2= sheet
+            match(COLON, TOKENS_FOLLOWING_COLON_IN_primary_1050)
+            @state.following.push(TOKENS_FOLLOWING_sheet_IN_primary_1056)
             sheet2 = sheet
             @state.following.pop
 
           end
-          match(BANG, TOKENS_FOLLOWING_BANG_IN_primary_1043)
-          ref3d_ref2d = match(REF2D, TOKENS_FOLLOWING_REF2D_IN_primary_1047)
+          match(BANG, TOKENS_FOLLOWING_BANG_IN_primary_1061)
+          ref3d_ref2d = match(REF2D, TOKENS_FOLLOWING_REF2D_IN_primary_1065)
           # --> action
 
-                      ptg = PTGREF3DR + RVA_DELTA[arg_type]
-                      rpn_ref2d = ""
+                      ptg = PTGREF3DR + RVA_DELTA_REF[arg_type]
                       r1, c1 = Utilities.cell_to_packed_rowcol(ref3d_ref2d.text)
                       rpn_ref2d = [0x0000, r1, c1].pack("v3")
                   
           # <-- action
-          # at line 151:9: ( COLON ref3d_ref2d2= REF2D )?
+          # at line 153:9: ( COLON ref3d_ref2d2= REF2D )?
           alt_12 = 2
           alt_12 = @dfa12.predict(@input)
           case alt_12
           when 1
-            # at line 151:11: COLON ref3d_ref2d2= REF2D
-            match(COLON, TOKENS_FOLLOWING_COLON_IN_primary_1069)
-            ref3d_ref2d2 = match(REF2D, TOKENS_FOLLOWING_REF2D_IN_primary_1074)
+            # at line 153:11: COLON ref3d_ref2d2= REF2D
+            match(COLON, TOKENS_FOLLOWING_COLON_IN_primary_1087)
+            ref3d_ref2d2 = match(REF2D, TOKENS_FOLLOWING_REF2D_IN_primary_1092)
             # --> action
 
-                            ptg = PTGAREA3DR + RVA_DELTA[arg_type]
+                            ptg = PTGAREA3DR + RVA_DELTA_AREA[arg_type]
                             r2, c2 = Utilities.cell_to_packed_rowcol(ref3d_ref2d2.text)
                             rpn_ref2d = [0x0000, r1, r2, c1, c2].pack("v5")
                         
@@ -768,11 +777,11 @@ module ExcelFormula
                   
           # <-- action
 
-        when 9
-          # at line 163:7: FUNC_IF LP expr[\"V\"] ( SEMICOLON | COMMA ) expr[arg_type] ( SEMICOLON | COMMA ) expr[arg_type] RP
-          match(FUNC_IF, TOKENS_FOLLOWING_FUNC_IF_IN_primary_1117)
-          match(LP, TOKENS_FOLLOWING_LP_IN_primary_1127)
-          @state.following.push(TOKENS_FOLLOWING_expr_IN_primary_1129)
+        when 10
+          # at line 165:7: FUNC_IF LP expr[\"V\"] ( SEMICOLON | COMMA ) expr[arg_type] ( SEMICOLON | COMMA ) expr[arg_type] RP
+          match(FUNC_IF, TOKENS_FOLLOWING_FUNC_IF_IN_primary_1135)
+          match(LP, TOKENS_FOLLOWING_LP_IN_primary_1145)
+          @state.following.push(TOKENS_FOLLOWING_expr_IN_primary_1147)
           expr("V")
           @state.following.pop
           if @input.peek(1).between?(SEMICOLON, COMMA)
@@ -790,7 +799,7 @@ module ExcelFormula
                       pos0 = @rpn.size - 2
                   
           # <-- action
-          @state.following.push(TOKENS_FOLLOWING_expr_IN_primary_1158)
+          @state.following.push(TOKENS_FOLLOWING_expr_IN_primary_1176)
           expr(arg_type)
           @state.following.pop
           if @input.peek(1).between?(SEMICOLON, COMMA)
@@ -805,44 +814,42 @@ module ExcelFormula
           # --> action
 
                       @rpn += [PTGATTR, 0x08, 0].pack("C2v") # tAttrSkip
-                      pos1 = @rpn.length - 2
+                      pos1 = @rpn.size - 2
 
-                      rem = @rpn.length - (pos0 + 2)
-                      @rpn = @rpn[0..pos0] + [pos1-pos0].pack("v") + @rpn[pos0+2, rem] # TODO Check for OBO
+                      @rpn = @rpn[0...pos0] + [pos1-pos0].pack("v") + @rpn[(pos0+2)...(@rpn.size)] 
                   
           # <-- action
-          @state.following.push(TOKENS_FOLLOWING_expr_IN_primary_1187)
+          @state.following.push(TOKENS_FOLLOWING_expr_IN_primary_1205)
           expr(arg_type)
           @state.following.pop
-          match(RP, TOKENS_FOLLOWING_RP_IN_primary_1190)
+          match(RP, TOKENS_FOLLOWING_RP_IN_primary_1208)
           # --> action
 
                       @rpn += [PTGATTR, 0x08, 3].pack("C2v") # tAttrSkip
                       @rpn += [PTGFUNCVARR, 3, 1].pack("C2v") # 3 = nargs, 1 = IF func
-                      pos2 = @rpn.length
+                      pos2 = @rpn.size
 
-                      rem = @rpn.length - (pos1 + 2)
-                      @rpn = @rpn[0..pos1] + [pos2-(pos1+2)-1].pack("v") + @rpn[pos1+2, rem] # TODO Check for OBO
+                      @rpn = @rpn[0...pos1] + [pos2-(pos1+2)-1].pack("v") + @rpn[(pos1+2)...(@rpn.size)]
                   
           # <-- action
 
-        when 10
+        when 11
           # at line 186:7: FUNC_CHOOSE LP expr[\"V\"] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )* RP
-          match(FUNC_CHOOSE, TOKENS_FOLLOWING_FUNC_CHOOSE_IN_primary_1208)
+          match(FUNC_CHOOSE, TOKENS_FOLLOWING_FUNC_CHOOSE_IN_primary_1226)
           # --> action
 
                       arg_type = "R"
                       rpn_chunks = []
                   
           # <-- action
-          match(LP, TOKENS_FOLLOWING_LP_IN_primary_1228)
-          @state.following.push(TOKENS_FOLLOWING_expr_IN_primary_1230)
+          match(LP, TOKENS_FOLLOWING_LP_IN_primary_1246)
+          @state.following.push(TOKENS_FOLLOWING_expr_IN_primary_1248)
           expr("V")
           @state.following.pop
           # --> action
 
-                      rpn_start = @rpn.length
-                      ref_markers = [@sheet_references.length]
+                      rpn_start = @rpn.size
+                      ref_markers = [@sheet_references.size]
                   
           # <-- action
           # at line 196:9: ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )*
@@ -867,7 +874,7 @@ module ExcelFormula
 
 
               # --> action
-               mark = @rpn.length 
+               mark = @rpn.size 
               # <-- action
               # at line 199:17: ( expr[arg_type] | )
               alt_13 = 2
@@ -875,7 +882,7 @@ module ExcelFormula
               case alt_13
               when 1
                 # at line 200:19: expr[arg_type]
-                @state.following.push(TOKENS_FOLLOWING_expr_IN_primary_1327)
+                @state.following.push(TOKENS_FOLLOWING_expr_IN_primary_1345)
                 expr(arg_type)
                 @state.following.pop
 
@@ -888,7 +895,7 @@ module ExcelFormula
               end
               # --> action
 
-                                  rem = @rpn.length - mark
+                                  rem = @rpn.size - mark
                                   rpn_chunks << @rpn[mark, rem]
                                   ref_markers << @sheet_references.size
                               
@@ -898,24 +905,24 @@ module ExcelFormula
               break # out of loop for decision 14
             end
           end # loop for decision 14
-          match(RP, TOKENS_FOLLOWING_RP_IN_primary_1405)
+          match(RP, TOKENS_FOLLOWING_RP_IN_primary_1423)
           # --> action
 
-                      @rpn = @rpn[0..rpn_start]
+                      @rpn = @rpn[0...rpn_start]
                       nc = rpn_chunks.length
                       chunklens = rpn_chunks.collect {|c| c.length}
                       skiplens = [0] * nc
-                      skiplens[-1] = 3
+                      skiplens[nc-1] = 3
 
                       (nc-1).downto(1) do |i|
                         skiplens[i-1] = skiplens[i] + chunklens[i] + 4
                       end
-                      jump_pos = [2 * nc + 2]
+                      jump_pos = [2*nc + 2]
 
                       (0...nc).each do |i|
-                        jump_pos.append(jump_pos[-1] + chunklens[ic] + 4)
+                        jump_pos << (jump_pos.last + chunklens[i] + 4)
                       end
-                      chunk_shift = 2 * nc + 6 # size of tAttrChoose
+                      chunk_shift = 2*nc + 6 # size of tAttrChoose
 
                       (0...nc).each do |i|
                         (ref_markers[i]...ref_markers[i+1]).each do |r|
@@ -938,18 +945,18 @@ module ExcelFormula
                   
           # <-- action
 
-        when 11
+        when 12
           # at line 246:7: name_tok= NAME
-          name_tok = match(NAME, TOKENS_FOLLOWING_NAME_IN_primary_1427)
+          name_tok = match(NAME, TOKENS_FOLLOWING_NAME_IN_primary_1445)
           # --> action
 
                     raise "[formula] found unexpected NAME token #{name_tok.text}"
                   
           # <-- action
 
-        when 12
+        when 13
           # at line 250:7: func_tok= NAME LP arg_count= expr_list[arg_type_list, min_argc, max_argc] RP
-          func_tok = match(NAME, TOKENS_FOLLOWING_NAME_IN_primary_1449)
+          func_tok = match(NAME, TOKENS_FOLLOWING_NAME_IN_primary_1467)
           # --> action
 
                     func_toku = func_tok.text.upcase
@@ -967,15 +974,15 @@ module ExcelFormula
                     end
                   
           # <-- action
-          match(LP, TOKENS_FOLLOWING_LP_IN_primary_1469)
-          @state.following.push(TOKENS_FOLLOWING_expr_list_IN_primary_1475)
+          match(LP, TOKENS_FOLLOWING_LP_IN_primary_1487)
+          @state.following.push(TOKENS_FOLLOWING_expr_list_IN_primary_1493)
           arg_count = expr_list(arg_type_list, min_argc, max_argc)
           @state.following.pop
-          match(RP, TOKENS_FOLLOWING_RP_IN_primary_1478)
+          match(RP, TOKENS_FOLLOWING_RP_IN_primary_1496)
           # --> action
 
                     if (arg_count > max_argc) || (arg_count < min_argc)
-                       raise "#{arg_count} parameters for function: #{func_tok.text}"
+                       raise "incorrect number #{arg_count} of parameters for function: #{func_tok.text}"
                     end
 
                     if xcall
@@ -984,28 +991,15 @@ module ExcelFormula
                     elsif (min_argc == max_argc)
                         func_ptg = PTGFUNCR + RVA_DELTA[func_type]
                         @rpn += [func_ptg, opcode].pack("Cv") 
-                    elsif (arg_count == 1) && (func_tok.text.upcase == "SUM")
+                    elsif (arg_count == 1) && (func_tok.text.upcase === "SUM")
                         @rpn += [PTGATTR, 0x10, 0].pack("CCv") # tAttrSum
                     else
-                      func_ptg = PTGFUNCVARR + RVA_DELTA[func_type]
+                        func_ptg = PTGFUNCVARR + RVA_DELTA[func_type]
                         @rpn += [func_ptg, arg_count, opcode].pack("CCv")
                     end
                   
           # <-- action
 
-        when 13
-          # at line 285:7: LP expr[arg_type] RP
-          match(LP, TOKENS_FOLLOWING_LP_IN_primary_1496)
-          @state.following.push(TOKENS_FOLLOWING_expr_IN_primary_1498)
-          expr(arg_type)
-          @state.following.pop
-          match(RP, TOKENS_FOLLOWING_RP_IN_primary_1501)
-          # --> action
-
-                      @rpn += [PTGPAREN].pack('C')
-                  
-          # <-- action
-
         end
       rescue ANTLR3::Error::RecognitionError => re
         report_error(re)
@@ -1024,26 +1018,36 @@ module ExcelFormula
     # parser rule expr_list
     # 
     # (in ExcelFormula.g)
-    # 292:1: expr_list[arg_type_list, min_argc, max_argc] returns [arg_cnt] : ( expr[arg_type] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )* | );
+    # 288:1: expr_list[arg_type_list, min_argc, max_argc] returns [arg_cnt] : ( ( expr[arg_type] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )* ) | );
     def expr_list(arg_type_list, min_argc, max_argc)
       # -> uncomment the next line to manually enable rule tracing
       # trace_in(__method__, 10)
       arg_cnt = nil
+      # - - - - @init action - - - -
+
+        arg_cnt = 0
+
+        # Set these for processing first argument, 
+        # it's simpler because first argument type can't be '...'
+        arg_type = arg_type_list.first
+
+        # need to check for '-' for a fn with no arguments
+        arg_cnt += 1 unless arg_type === '-'
+
 
       begin
-        # at line 297:5: ( expr[arg_type] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )* | )
+        # at line 300:5: ( ( expr[arg_type] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )* ) | )
         alt_18 = 2
         alt_18 = @dfa18.predict(@input)
         case alt_18
         when 1
-          # at line 297:7: expr[arg_type] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )*
-          @state.following.push(TOKENS_FOLLOWING_expr_IN_expr_list_1542)
+          # at line 301:5: ( expr[arg_type] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )* )
+          # at line 301:5: ( expr[arg_type] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )* )
+          # at line 301:6: expr[arg_type] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )*
+          @state.following.push(TOKENS_FOLLOWING_expr_IN_expr_list_1540)
           expr(arg_type)
           @state.following.pop
-          # --> action
-           arg_cnt += 1 
-          # <-- action
-          # at line 298:5: ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )*
+          # at line 302:9: ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )*
           loop do # decision 17
             alt_17 = 2
             look_17_0 = @input.peek(1)
@@ -1054,19 +1058,7 @@ module ExcelFormula
             end
             case alt_17
             when 1
-              # at line 299:9: ( SEMICOLON | COMMA ) ( expr[arg_type] | )
-              # --> action
-
-                          if arg_cnt < arg_type_list.size
-                              arg_type = arg_type_list[arg_cnt]
-                          else
-                              arg_type = arg_type_list[-1]
-                          end
-                          if arg_type == "+"
-                              arg_type = arg_type_list[-2]
-                          end
-                      
-              # <-- action
+              # at line 303:14: ( SEMICOLON | COMMA ) ( expr[arg_type] | )
               if @input.peek(1).between?(SEMICOLON, COMMA)
                 @input.consume
                 @state.error_recovery = false
@@ -1076,34 +1068,52 @@ module ExcelFormula
               end
 
 
-              # at line 310:13: ( expr[arg_type] | )
+              # --> action
+               arg_cnt += 1 
+              # <-- action
+              # at line 304:17: ( expr[arg_type] | )
               alt_16 = 2
               alt_16 = @dfa16.predict(@input)
               case alt_16
               when 1
-                # at line 311:19: expr[arg_type]
-                @state.following.push(TOKENS_FOLLOWING_expr_IN_expr_list_1611)
+                # at line 306:22: expr[arg_type]
+                @state.following.push(TOKENS_FOLLOWING_expr_IN_expr_list_1634)
                 expr(arg_type)
                 @state.following.pop
+                # --> action
+
+                                        if arg_cnt - 2 < arg_type_list.size
+                                           arg_type = arg_type_list[arg_cnt - 2]
+                                        else
+                                          if arg_type_list.last === "..."
+                                             # e.g. "V R ..." arbitrary number of args of type R
+                                             # this will always be last element in arg_type_list
+                                             # 2nd to last element will provide type
+                                             arg_type = arg_type_list[arg_type_list.size - 2]
+                                          else
+                                            # Just read last element normally.
+                                            arg_type = arg_type_list[arg_cnt - 2]
+                                          end
+                                        end
+                                     
+                # <-- action
 
               when 2
-                # at line 312:19: 
+                # at line 323:19: 
                 # --> action
-                 @rpn += [PTGMISSARG].pack("B") 
+                 @rpn += [PTGMISSARG].pack("C") 
                 # <-- action
 
               end
-              # --> action
-               arg_cnt += 1 
-              # <-- action
 
             else
               break # out of loop for decision 17
             end
           end # loop for decision 17
 
+
         when 2
-          # at line 317:5: 
+          # at line 328:5: 
 
         end
       rescue ANTLR3::Error::RecognitionError => re
@@ -1123,7 +1133,7 @@ module ExcelFormula
     # parser rule sheet
     # 
     # (in ExcelFormula.g)
-    # 319:1: sheet returns [ref] : (sheet_ref_name= NAME | sheet_ref_int= INT_CONST | sheet_ref_quote= QUOTENAME );
+    # 330:1: sheet returns [ref] : (sheet_ref_name= NAME | sheet_ref_int= INT_CONST | sheet_ref_quote= QUOTENAME );
     def sheet
       # -> uncomment the next line to manually enable rule tracing
       # trace_in(__method__, 11)
@@ -1133,7 +1143,7 @@ module ExcelFormula
       sheet_ref_quote = nil
 
       begin
-        # at line 320:5: (sheet_ref_name= NAME | sheet_ref_int= INT_CONST | sheet_ref_quote= QUOTENAME )
+        # at line 331:5: (sheet_ref_name= NAME | sheet_ref_int= INT_CONST | sheet_ref_quote= QUOTENAME )
         alt_19 = 3
         case look_19 = @input.peek(1)
         when NAME then alt_19 = 1
@@ -1145,22 +1155,22 @@ module ExcelFormula
         end
         case alt_19
         when 1
-          # at line 320:7: sheet_ref_name= NAME
-          sheet_ref_name = match(NAME, TOKENS_FOLLOWING_NAME_IN_sheet_1701)
+          # at line 331:7: sheet_ref_name= NAME
+          sheet_ref_name = match(NAME, TOKENS_FOLLOWING_NAME_IN_sheet_1768)
           # --> action
            ref = sheet_ref_name.text 
           # <-- action
 
         when 2
-          # at line 322:7: sheet_ref_int= INT_CONST
-          sheet_ref_int = match(INT_CONST, TOKENS_FOLLOWING_INT_CONST_IN_sheet_1721)
+          # at line 333:7: sheet_ref_int= INT_CONST
+          sheet_ref_int = match(INT_CONST, TOKENS_FOLLOWING_INT_CONST_IN_sheet_1788)
           # --> action
            ref = sheet_ref_int.text 
           # <-- action
 
         when 3
-          # at line 324:7: sheet_ref_quote= QUOTENAME
-          sheet_ref_quote = match(QUOTENAME, TOKENS_FOLLOWING_QUOTENAME_IN_sheet_1741)
+          # at line 335:7: sheet_ref_quote= QUOTENAME
+          sheet_ref_quote = match(QUOTENAME, TOKENS_FOLLOWING_QUOTENAME_IN_sheet_1808)
           # --> action
            ref = sheet_ref_quote.text[1, len(sheet_ref_quote.text) - 1].replace("''", "'") 
           # <-- action
@@ -1190,7 +1200,7 @@ module ExcelFormula
       ACCEPT = unpack(1, -1, 1, 2, 2, -1, 1, 1, 5, -1)
       SPECIAL = unpack(10, -1)
       TRANSITION = [
-        unpack(6, 4, 17, -1, 3, 1),
+        unpack(6, 4, 15, -1, 1, 1, 2, -1, 2, 1),
         unpack(),
         unpack(),
         unpack(),
@@ -1225,7 +1235,7 @@ module ExcelFormula
       ACCEPT = unpack(1, -1, 1, 2, 8, -1, 1, 1)
       SPECIAL = unpack(11, -1)
       TRANSITION = [
-        unpack(6, 1, 1, 10, 16, -1, 3, 1),
+        unpack(6, 1, 1, 10, 14, -1, 1, 1, 2, -1, 2, 1),
         unpack(),
         unpack(),
         unpack(),
@@ -1261,7 +1271,7 @@ module ExcelFormula
       ACCEPT = unpack(1, -1, 1, 2, 9, -1, 1, 1, 1, -1)
       SPECIAL = unpack(13, -1)
       TRANSITION = [
-        unpack(7, 1, 2, 11, 14, -1, 3, 1),
+        unpack(7, 1, 2, 11, 12, -1, 1, 1, 2, -1, 2, 1),
         unpack(),
         unpack(),
         unpack(),
@@ -1299,7 +1309,7 @@ module ExcelFormula
       ACCEPT = unpack(1, -1, 1, 2, 11, -1, 1, 1, 1, -1)
       SPECIAL = unpack(15, -1)
       TRANSITION = [
-        unpack(9, 1, 2, 13, 12, -1, 3, 1),
+        unpack(9, 1, 2, 13, 10, -1, 1, 1, 2, -1, 2, 1),
         unpack(),
         unpack(),
         unpack(),
@@ -1339,7 +1349,7 @@ module ExcelFormula
       ACCEPT = unpack(1, -1, 1, 2, 13, -1, 1, 1)
       SPECIAL = unpack(16, -1)
       TRANSITION = [
-        unpack(11, 1, 1, 15, 11, -1, 3, 1),
+        unpack(11, 1, 1, 15, 9, -1, 1, 1, 2, -1, 2, 1),
         unpack(),
         unpack(),
         unpack(),
@@ -1368,7 +1378,49 @@ module ExcelFormula
 
       def description
         <<-'__dfa_description__'.strip!
-          ()* loopback of 79:9: ( ( POWER ) prec5_expr[arg_type] )*
+          ()* loopback of 79:9: ( ( POWER ) prec4_expr[arg_type] )*
+        __dfa_description__
+      end
+    end
+    class DFA9 < ANTLR3::DFA
+      EOT = unpack(17, -1)
+      EOF = unpack(1, 2, 16, -1)
+      MIN = unpack(1, 4, 16, -1)
+      MAX = unpack(1, 29, 16, -1)
+      ACCEPT = unpack(1, -1, 1, 1, 1, 2, 14, -1)
+      SPECIAL = unpack(17, -1)
+      TRANSITION = [
+        unpack(12, 2, 1, 1, 8, -1, 1, 2, 2, -1, 2, 2),
+        unpack(),
+        unpack(),
+        unpack(),
+        unpack(),
+        unpack(),
+        unpack(),
+        unpack(),
+        unpack(),
+        unpack(),
+        unpack(),
+        unpack(),
+        unpack(),
+        unpack(),
+        unpack(),
+        unpack(),
+        unpack()
+      ].freeze
+      
+      ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z |
+        if a > 0 and z < 0
+          MAX[ i ] %= 0x10000
+        end
+      end
+      
+      @decision = 9
+      
+
+      def description
+        <<-'__dfa_description__'.strip!
+          89:9: ( PERCENT )?
         __dfa_description__
       end
     end
@@ -1380,7 +1432,7 @@ module ExcelFormula
       ACCEPT = unpack(1, -1, 1, 1, 10, -1, 1, 2)
       SPECIAL = unpack(13, -1)
       TRANSITION = [
-        unpack(1, 12, 4, -1, 6, 1, 2, -1, 2, 1, 3, -1, 3, 1),
+        unpack(1, 12, 4, -1, 6, 1, 1, -1, 1, 1, 2, -1, 1, 1, 2, -1, 3, 1),
         unpack(),
         unpack(),
         unpack(),
@@ -1412,24 +1464,25 @@ module ExcelFormula
     end
     class DFA15 < ANTLR3::DFA
       EOT = unpack(66, -1)
-      EOF = unpack(4, -1, 1, 12, 1, -1, 1, 31, 1, 48, 58, -1)
-      MIN = unpack(1, 17, 3, -1, 1, 4, 1, -1, 2, 4, 58, -1)
-      MAX = unpack(1, 32, 3, -1, 1, 29, 1, -1, 2, 29, 58, -1)
-      ACCEPT = unpack(1, -1, 1, 1, 1, 2, 1, 3, 1, -1, 1, 5, 2, -1, 1, 8, 
-                      1, 9, 1, 10, 1, 13, 1, 4, 17, -1, 1, 7, 1, 6, 15, 
-                      -1, 1, 12, 1, 11, 17, -1)
+      EOF = unpack(4, -1, 1, 12, 1, -1, 1, 31, 1, -1, 1, 49, 57, -1)
+      MIN = unpack(1, 17, 3, -1, 1, 4, 1, -1, 1, 4, 1, -1, 1, 4, 57, -1)
+      MAX = unpack(1, 32, 3, -1, 1, 29, 1, -1, 1, 29, 1, -1, 1, 29, 57, 
+                   -1)
+      ACCEPT = unpack(1, -1, 1, 1, 1, 2, 1, 3, 1, -1, 1, 5, 1, -1, 1, 8, 
+                      1, -1, 1, 9, 1, 10, 1, 11, 1, 4, 17, -1, 1, 7, 1, 
+                      6, 17, -1, 1, 12, 15, -1, 1, 13)
       SPECIAL = unpack(66, -1)
       TRANSITION = [
-        unpack(1, 1, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 2, -1, 1, 9, 1, 11, 3, 
-               -1, 1, 10, 1, 7, 1, 8),
+        unpack(1, 1, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 1, -1, 1, 7, 2, -1, 1, 
+               10, 2, -1, 1, 11, 1, 8, 1, 9),
         unpack(),
         unpack(),
         unpack(),
-        unpack(13, 12, 6, -1, 2, 8, 2, -1, 3, 12),
+        unpack(13, 12, 6, -1, 1, 9, 1, -1, 1, 12, 1, 9, 1, -1, 2, 12),
         unpack(),
-        unpack(13, 31, 6, -1, 1, 30, 3, -1, 3, 31),
-        unpack(13, 48, 6, -1, 2, 8, 1, -1, 1, 47, 3, 48),
+        unpack(13, 31, 6, -1, 1, 30, 1, -1, 1, 31, 2, -1, 2, 31),
         unpack(),
+        unpack(13, 49, 6, -1, 1, 9, 1, 65, 1, 49, 1, 9, 1, -1, 2, 49),
         unpack(),
         unpack(),
         unpack(),
@@ -1500,7 +1553,7 @@ module ExcelFormula
 
       def description
         <<-'__dfa_description__'.strip!
-          99:1: primary[arg_type] : ( TRUE_CONST | FALSE_CONST | str_tok= STR_CONST | int_tok= INT_CONST | num_tok= NUM_CONST | ref2d_tok= REF2D | ref2d1_tok= REF2D COLON ref2d2_tok= REF2D | sheet1= sheet ( COLON sheet2= sheet )? BANG ref3d_ref2d= REF2D ( COLON ref3d_ref2d2= REF2D )? | FUNC_IF LP expr[\"V\"] ( SEMICOLON | COMMA ) expr[arg_type] ( SEMICOLON | COMMA ) expr[arg_type] RP | FUNC_CHOOSE LP expr[\"V\"] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )* RP | name_tok= NAME | func_tok= NAME LP arg_count= expr_list[arg_type_list, min_argc, max_argc] RP | LP expr[arg_type] RP );
+          99:1: primary[arg_type] : ( TRUE_CONST | FALSE_CONST | str_tok= STR_CONST | int_tok= INT_CONST | num_tok= NUM_CONST | ref2d_tok= REF2D | ref2d1_tok= REF2D COLON ref2d2_tok= REF2D | LP expr[arg_type] RP | sheet1= sheet ( COLON sheet2= sheet )? BANG ref3d_ref2d= REF2D ( COLON ref3d_ref2d2= REF2D )? | FUNC_IF LP expr[\"V\"] ( SEMICOLON | COMMA ) expr[arg_type] ( SEMICOLON | COMMA ) expr[arg_type] RP | FUNC_CHOOSE LP expr[\"V\"] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )* RP | name_tok= NAME | func_tok= NAME LP arg_count= expr_list[arg_type_list, min_argc, max_argc] RP );
         __dfa_description__
       end
     end
@@ -1512,7 +1565,7 @@ module ExcelFormula
       ACCEPT = unpack(1, -1, 1, 1, 1, 2, 15, -1)
       SPECIAL = unpack(18, -1)
       TRANSITION = [
-        unpack(13, 2, 6, -1, 1, 1, 3, -1, 3, 2),
+        unpack(13, 2, 6, -1, 1, 1, 1, -1, 1, 2, 2, -1, 2, 2),
         unpack(),
         unpack(),
         unpack(),
@@ -1543,7 +1596,7 @@ module ExcelFormula
 
       def description
         <<-'__dfa_description__'.strip!
-          151:9: ( COLON ref3d_ref2d2= REF2D )?
+          153:9: ( COLON ref3d_ref2d2= REF2D )?
         __dfa_description__
       end
     end
@@ -1555,7 +1608,8 @@ module ExcelFormula
       ACCEPT = unpack(1, -1, 1, 1, 11, -1, 1, 2, 1, -1)
       SPECIAL = unpack(15, -1)
       TRANSITION = [
-        unpack(1, 1, 4, -1, 6, 1, 2, -1, 2, 1, 3, 13, 3, 1),
+        unpack(1, 1, 4, -1, 6, 1, 1, -1, 1, 1, 1, 13, 1, -1, 1, 1, 2, 13, 
+               3, 1),
         unpack(),
         unpack(),
         unpack(),
@@ -1595,7 +1649,8 @@ module ExcelFormula
       ACCEPT = unpack(1, -1, 1, 1, 11, -1, 1, 2)
       SPECIAL = unpack(14, -1)
       TRANSITION = [
-        unpack(1, 1, 4, -1, 6, 1, 2, -1, 2, 1, 2, -1, 1, 13, 3, 1),
+        unpack(1, 1, 4, -1, 6, 1, 1, -1, 1, 1, 1, 13, 1, -1, 1, 1, 2, -1, 
+               3, 1),
         unpack(),
         unpack(),
         unpack(),
@@ -1622,7 +1677,7 @@ module ExcelFormula
 
       def description
         <<-'__dfa_description__'.strip!
-          292:1: expr_list[arg_type_list, min_argc, max_argc] returns [arg_cnt] : ( expr[arg_type] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )* | );
+          288:1: expr_list[arg_type_list, min_argc, max_argc] returns [arg_cnt] : ( ( expr[arg_type] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )* ) | );
         __dfa_description__
       end
     end
@@ -1634,7 +1689,8 @@ module ExcelFormula
       ACCEPT = unpack(1, -1, 1, 1, 11, -1, 1, 2, 1, -1)
       SPECIAL = unpack(15, -1)
       TRANSITION = [
-        unpack(1, 1, 4, -1, 6, 1, 2, -1, 2, 1, 3, 13, 3, 1),
+        unpack(1, 1, 4, -1, 6, 1, 1, -1, 1, 1, 1, 13, 1, -1, 1, 1, 2, 13, 
+               3, 1),
         unpack(),
         unpack(),
         unpack(),
@@ -1662,7 +1718,7 @@ module ExcelFormula
 
       def description
         <<-'__dfa_description__'.strip!
-          310:13: ( expr[arg_type] | )
+          304:17: ( expr[arg_type] | )
         __dfa_description__
       end
     end
@@ -1677,6 +1733,7 @@ module ExcelFormula
       @dfa5 = DFA5.new(self, 5)
       @dfa7 = DFA7.new(self, 7)
       @dfa8 = DFA8.new(self, 8)
+      @dfa9 = DFA9.new(self, 9)
       @dfa10 = DFA10.new(self, 10)
       @dfa15 = DFA15.new(self, 15)
       @dfa12 = DFA12.new(self, 12)
@@ -1685,78 +1742,78 @@ module ExcelFormula
       @dfa16 = DFA16.new(self, 16)
 
     end
-    TOKENS_FOLLOWING_expr_IN_formula_60 = Set[1]
-    TOKENS_FOLLOWING_prec0_expr_IN_expr_79 = Set[1, 4, 5, 6, 7, 8, 9]
-    TOKENS_FOLLOWING_EQ_IN_expr_124 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
-    TOKENS_FOLLOWING_NE_IN_expr_146 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
-    TOKENS_FOLLOWING_GT_IN_expr_168 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
-    TOKENS_FOLLOWING_LT_IN_expr_190 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
-    TOKENS_FOLLOWING_GE_IN_expr_212 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
-    TOKENS_FOLLOWING_LE_IN_expr_234 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
-    TOKENS_FOLLOWING_prec0_expr_IN_expr_265 = Set[1, 4, 5, 6, 7, 8, 9]
-    TOKENS_FOLLOWING_prec1_expr_IN_prec0_expr_297 = Set[1, 10]
-    TOKENS_FOLLOWING_CONCAT_IN_prec0_expr_340 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
-    TOKENS_FOLLOWING_prec1_expr_IN_prec0_expr_370 = Set[1, 10]
-    TOKENS_FOLLOWING_prec2_expr_IN_prec1_expr_402 = Set[1, 11, 12]
-    TOKENS_FOLLOWING_ADD_IN_prec1_expr_447 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
-    TOKENS_FOLLOWING_SUB_IN_prec1_expr_469 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
-    TOKENS_FOLLOWING_prec2_expr_IN_prec1_expr_499 = Set[1, 11, 12]
-    TOKENS_FOLLOWING_prec3_expr_IN_prec2_expr_532 = Set[1, 13, 14]
-    TOKENS_FOLLOWING_MUL_IN_prec2_expr_577 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
-    TOKENS_FOLLOWING_DIV_IN_prec2_expr_599 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
-    TOKENS_FOLLOWING_prec3_expr_IN_prec2_expr_629 = Set[1, 13, 14]
-    TOKENS_FOLLOWING_prec5_expr_IN_prec3_expr_661 = Set[1, 15]
-    TOKENS_FOLLOWING_POWER_IN_prec3_expr_704 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
-    TOKENS_FOLLOWING_prec5_expr_IN_prec3_expr_734 = Set[1, 15]
-    TOKENS_FOLLOWING_prec5_expr_IN_prec4_expr_766 = Set[1, 16]
-    TOKENS_FOLLOWING_PERCENT_IN_prec4_expr_791 = Set[1]
-    TOKENS_FOLLOWING_primary_IN_prec5_expr_822 = Set[1]
-    TOKENS_FOLLOWING_SUB_IN_prec5_expr_831 = Set[17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
-    TOKENS_FOLLOWING_primary_IN_prec5_expr_833 = Set[1]
-    TOKENS_FOLLOWING_TRUE_CONST_IN_primary_854 = Set[1]
-    TOKENS_FOLLOWING_FALSE_CONST_IN_primary_872 = Set[1]
-    TOKENS_FOLLOWING_STR_CONST_IN_primary_894 = Set[1]
-    TOKENS_FOLLOWING_INT_CONST_IN_primary_916 = Set[1]
-    TOKENS_FOLLOWING_NUM_CONST_IN_primary_934 = Set[1]
-    TOKENS_FOLLOWING_REF2D_IN_primary_956 = Set[1]
-    TOKENS_FOLLOWING_REF2D_IN_primary_978 = Set[23]
-    TOKENS_FOLLOWING_COLON_IN_primary_980 = Set[22]
-    TOKENS_FOLLOWING_REF2D_IN_primary_986 = Set[1]
-    TOKENS_FOLLOWING_sheet_IN_primary_1010 = Set[23, 24]
-    TOKENS_FOLLOWING_COLON_IN_primary_1032 = Set[20, 31, 32]
-    TOKENS_FOLLOWING_sheet_IN_primary_1038 = Set[24]
-    TOKENS_FOLLOWING_BANG_IN_primary_1043 = Set[22]
-    TOKENS_FOLLOWING_REF2D_IN_primary_1047 = Set[1, 23]
-    TOKENS_FOLLOWING_COLON_IN_primary_1069 = Set[22]
-    TOKENS_FOLLOWING_REF2D_IN_primary_1074 = Set[1]
-    TOKENS_FOLLOWING_FUNC_IF_IN_primary_1117 = Set[26]
-    TOKENS_FOLLOWING_LP_IN_primary_1127 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
-    TOKENS_FOLLOWING_expr_IN_primary_1129 = Set[27, 28]
-    TOKENS_FOLLOWING_set_IN_primary_1132 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
-    TOKENS_FOLLOWING_expr_IN_primary_1158 = Set[27, 28]
-    TOKENS_FOLLOWING_set_IN_primary_1161 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
-    TOKENS_FOLLOWING_expr_IN_primary_1187 = Set[29]
-    TOKENS_FOLLOWING_RP_IN_primary_1190 = Set[1]
-    TOKENS_FOLLOWING_FUNC_CHOOSE_IN_primary_1208 = Set[26]
-    TOKENS_FOLLOWING_LP_IN_primary_1228 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
-    TOKENS_FOLLOWING_expr_IN_primary_1230 = Set[27, 28, 29]
-    TOKENS_FOLLOWING_set_IN_primary_1265 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 27, 28, 29, 30, 31, 32]
-    TOKENS_FOLLOWING_expr_IN_primary_1327 = Set[27, 28, 29]
-    TOKENS_FOLLOWING_RP_IN_primary_1405 = Set[1]
-    TOKENS_FOLLOWING_NAME_IN_primary_1427 = Set[1]
-    TOKENS_FOLLOWING_NAME_IN_primary_1449 = Set[26]
-    TOKENS_FOLLOWING_LP_IN_primary_1469 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 29, 30, 31, 32]
-    TOKENS_FOLLOWING_expr_list_IN_primary_1475 = Set[29]
-    TOKENS_FOLLOWING_RP_IN_primary_1478 = Set[1]
-    TOKENS_FOLLOWING_LP_IN_primary_1496 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
-    TOKENS_FOLLOWING_expr_IN_primary_1498 = Set[29]
-    TOKENS_FOLLOWING_RP_IN_primary_1501 = Set[1]
-    TOKENS_FOLLOWING_expr_IN_expr_list_1542 = Set[1, 27, 28]
-    TOKENS_FOLLOWING_set_IN_expr_list_1571 = Set[1, 12, 17, 18, 19, 20, 21, 22, 25, 26, 27, 28, 30, 31, 32]
-    TOKENS_FOLLOWING_expr_IN_expr_list_1611 = Set[1, 27, 28]
-    TOKENS_FOLLOWING_NAME_IN_sheet_1701 = Set[1]
-    TOKENS_FOLLOWING_INT_CONST_IN_sheet_1721 = Set[1]
-    TOKENS_FOLLOWING_QUOTENAME_IN_sheet_1741 = Set[1]
+    TOKENS_FOLLOWING_expr_IN_formula_56 = Set[1]
+    TOKENS_FOLLOWING_prec0_expr_IN_expr_75 = Set[1, 4, 5, 6, 7, 8, 9]
+    TOKENS_FOLLOWING_EQ_IN_expr_120 = Set[12, 17, 18, 19, 20, 21, 22, 24, 27, 30, 31, 32]
+    TOKENS_FOLLOWING_NE_IN_expr_142 = Set[12, 17, 18, 19, 20, 21, 22, 24, 27, 30, 31, 32]
+    TOKENS_FOLLOWING_GT_IN_expr_164 = Set[12, 17, 18, 19, 20, 21, 22, 24, 27, 30, 31, 32]
+    TOKENS_FOLLOWING_LT_IN_expr_186 = Set[12, 17, 18, 19, 20, 21, 22, 24, 27, 30, 31, 32]
+    TOKENS_FOLLOWING_GE_IN_expr_208 = Set[12, 17, 18, 19, 20, 21, 22, 24, 27, 30, 31, 32]
+    TOKENS_FOLLOWING_LE_IN_expr_230 = Set[12, 17, 18, 19, 20, 21, 22, 24, 27, 30, 31, 32]
+    TOKENS_FOLLOWING_prec0_expr_IN_expr_261 = Set[1, 4, 5, 6, 7, 8, 9]
+    TOKENS_FOLLOWING_prec1_expr_IN_prec0_expr_293 = Set[1, 10]
+    TOKENS_FOLLOWING_CONCAT_IN_prec0_expr_336 = Set[12, 17, 18, 19, 20, 21, 22, 24, 27, 30, 31, 32]
+    TOKENS_FOLLOWING_prec1_expr_IN_prec0_expr_366 = Set[1, 10]
+    TOKENS_FOLLOWING_prec2_expr_IN_prec1_expr_398 = Set[1, 11, 12]
+    TOKENS_FOLLOWING_ADD_IN_prec1_expr_443 = Set[12, 17, 18, 19, 20, 21, 22, 24, 27, 30, 31, 32]
+    TOKENS_FOLLOWING_SUB_IN_prec1_expr_465 = Set[12, 17, 18, 19, 20, 21, 22, 24, 27, 30, 31, 32]
+    TOKENS_FOLLOWING_prec2_expr_IN_prec1_expr_495 = Set[1, 11, 12]
+    TOKENS_FOLLOWING_prec3_expr_IN_prec2_expr_528 = Set[1, 13, 14]
+    TOKENS_FOLLOWING_MUL_IN_prec2_expr_573 = Set[12, 17, 18, 19, 20, 21, 22, 24, 27, 30, 31, 32]
+    TOKENS_FOLLOWING_DIV_IN_prec2_expr_595 = Set[12, 17, 18, 19, 20, 21, 22, 24, 27, 30, 31, 32]
+    TOKENS_FOLLOWING_prec3_expr_IN_prec2_expr_625 = Set[1, 13, 14]
+    TOKENS_FOLLOWING_prec4_expr_IN_prec3_expr_657 = Set[1, 15]
+    TOKENS_FOLLOWING_POWER_IN_prec3_expr_700 = Set[12, 17, 18, 19, 20, 21, 22, 24, 27, 30, 31, 32]
+    TOKENS_FOLLOWING_prec4_expr_IN_prec3_expr_730 = Set[1, 15]
+    TOKENS_FOLLOWING_prec5_expr_IN_prec4_expr_762 = Set[1, 16]
+    TOKENS_FOLLOWING_PERCENT_IN_prec4_expr_787 = Set[1]
+    TOKENS_FOLLOWING_primary_IN_prec5_expr_818 = Set[1]
+    TOKENS_FOLLOWING_SUB_IN_prec5_expr_827 = Set[17, 18, 19, 20, 21, 22, 24, 27, 30, 31, 32]
+    TOKENS_FOLLOWING_primary_IN_prec5_expr_829 = Set[1]
+    TOKENS_FOLLOWING_TRUE_CONST_IN_primary_850 = Set[1]
+    TOKENS_FOLLOWING_FALSE_CONST_IN_primary_868 = Set[1]
+    TOKENS_FOLLOWING_STR_CONST_IN_primary_890 = Set[1]
+    TOKENS_FOLLOWING_INT_CONST_IN_primary_912 = Set[1]
+    TOKENS_FOLLOWING_NUM_CONST_IN_primary_930 = Set[1]
+    TOKENS_FOLLOWING_REF2D_IN_primary_952 = Set[1]
+    TOKENS_FOLLOWING_REF2D_IN_primary_974 = Set[23]
+    TOKENS_FOLLOWING_COLON_IN_primary_976 = Set[22]
+    TOKENS_FOLLOWING_REF2D_IN_primary_982 = Set[1]
+    TOKENS_FOLLOWING_LP_IN_primary_1000 = Set[12, 17, 18, 19, 20, 21, 22, 24, 27, 30, 31, 32]
+    TOKENS_FOLLOWING_expr_IN_primary_1002 = Set[25]
+    TOKENS_FOLLOWING_RP_IN_primary_1005 = Set[1]
+    TOKENS_FOLLOWING_sheet_IN_primary_1028 = Set[23, 26]
+    TOKENS_FOLLOWING_COLON_IN_primary_1050 = Set[20, 31, 32]
+    TOKENS_FOLLOWING_sheet_IN_primary_1056 = Set[26]
+    TOKENS_FOLLOWING_BANG_IN_primary_1061 = Set[22]
+    TOKENS_FOLLOWING_REF2D_IN_primary_1065 = Set[1, 23]
+    TOKENS_FOLLOWING_COLON_IN_primary_1087 = Set[22]
+    TOKENS_FOLLOWING_REF2D_IN_primary_1092 = Set[1]
+    TOKENS_FOLLOWING_FUNC_IF_IN_primary_1135 = Set[24]
+    TOKENS_FOLLOWING_LP_IN_primary_1145 = Set[12, 17, 18, 19, 20, 21, 22, 24, 27, 30, 31, 32]
+    TOKENS_FOLLOWING_expr_IN_primary_1147 = Set[28, 29]
+    TOKENS_FOLLOWING_set_IN_primary_1150 = Set[12, 17, 18, 19, 20, 21, 22, 24, 27, 30, 31, 32]
+    TOKENS_FOLLOWING_expr_IN_primary_1176 = Set[28, 29]
+    TOKENS_FOLLOWING_set_IN_primary_1179 = Set[12, 17, 18, 19, 20, 21, 22, 24, 27, 30, 31, 32]
+    TOKENS_FOLLOWING_expr_IN_primary_1205 = Set[25]
+    TOKENS_FOLLOWING_RP_IN_primary_1208 = Set[1]
+    TOKENS_FOLLOWING_FUNC_CHOOSE_IN_primary_1226 = Set[24]
+    TOKENS_FOLLOWING_LP_IN_primary_1246 = Set[12, 17, 18, 19, 20, 21, 22, 24, 27, 30, 31, 32]
+    TOKENS_FOLLOWING_expr_IN_primary_1248 = Set[25, 28, 29]
+    TOKENS_FOLLOWING_set_IN_primary_1283 = Set[12, 17, 18, 19, 20, 21, 22, 24, 25, 27, 28, 29, 30, 31, 32]
+    TOKENS_FOLLOWING_expr_IN_primary_1345 = Set[25, 28, 29]
+    TOKENS_FOLLOWING_RP_IN_primary_1423 = Set[1]
+    TOKENS_FOLLOWING_NAME_IN_primary_1445 = Set[1]
+    TOKENS_FOLLOWING_NAME_IN_primary_1467 = Set[24]
+    TOKENS_FOLLOWING_LP_IN_primary_1487 = Set[12, 17, 18, 19, 20, 21, 22, 24, 25, 27, 30, 31, 32]
+    TOKENS_FOLLOWING_expr_list_IN_primary_1493 = Set[25]
+    TOKENS_FOLLOWING_RP_IN_primary_1496 = Set[1]
+    TOKENS_FOLLOWING_expr_IN_expr_list_1540 = Set[1, 28, 29]
+    TOKENS_FOLLOWING_set_IN_expr_list_1566 = Set[1, 12, 17, 18, 19, 20, 21, 22, 24, 27, 28, 29, 30, 31, 32]
+    TOKENS_FOLLOWING_expr_IN_expr_list_1634 = Set[1, 28, 29]
+    TOKENS_FOLLOWING_NAME_IN_sheet_1768 = Set[1]
+    TOKENS_FOLLOWING_INT_CONST_IN_sheet_1788 = Set[1]
+    TOKENS_FOLLOWING_QUOTENAME_IN_sheet_1808 = Set[1]
 
   end # class Parser < ANTLR3::Parser