surpass 0.0.7 → 0.0.9

data/History.txt

@@ -1,4 +1,4 @@
-== 1.0.0 / 2009-10-27
+== 0.0.9 / 2010-05-03
 
 * 1 major enhancement
-  * Birthday!
+  * Some formula support enabled, see examples/formulas.rb to see what is supported.

data/Rakefile

@@ -4,27 +4,25 @@
 
 begin
   require 'bones'
-  Bones.setup
 rescue LoadError
-  begin
-    load 'tasks/setup.rb'
-  rescue LoadError
-    raise RuntimeError, '### please install the "bones" gem ###'
-  end
+  abort '### Please install the "bones" gem ###'
 end
 
 ensure_in_path 'lib'
 require 'surpass'
 
-task :default => 'spec:run'
-
-PROJ.name = 'surpass'
-PROJ.authors = 'Ana Nelson'
-PROJ.email = 'ana@ananelson.com'
-PROJ.url = 'http://surpass.rubyforge.org'
-PROJ.version = Surpass::VERSION
-PROJ.rubyforge.name = 'surpass'
+Bones {
+  name     'surpass'
+  authors  'Ana Nelson'
+  email    'ana@ananelson.com'
+  url      'http://surpass.rubyforge.org'
+  version  Surpass::VERSION
+}
 
-PROJ.spec.opts << '--color'
+task :default => 'spec:run'
+task 'gem:release' => 'test:run'
 
-# EOF
+desc "run antlr compiler"
+task :antlr do
+  `cd lib/surpass; antlr4ruby ExcelFormula.g`
+end

data/debug-examples/formula-cell.rb

@@ -0,0 +1,14 @@
+require "lib/surpass"
+
+class Parent
+  def index
+    0
+  end
+end
+
+cell = FormulaCell.new(Parent.new, 0, 0, ExcelFormula.new("1"))
+
+File.open("formula-cell.bin", "w") do |f|
+  f.write cell.to_biff
+end
+

data/debug-examples/formula-record.rb

@@ -0,0 +1,15 @@
+require "lib/surpass"
+
+class Parent
+  def index
+    0
+  end
+end
+
+rpn = ExcelFormula.new("1").to_biff
+record = FormulaRecord.new(0, 0, 0, rpn)
+
+File.open("formula-record.bin", "w") do |f|
+  f.write record.to_biff
+end
+

data/lib/surpass/ExcelFormula.g

@@ -7,6 +7,8 @@ options {
 
 @header {
   RVA_DELTA = {"R" => 0, "V" => 0x20, "A" => 0x40}
+  RVA_DELTA_REF = {"R" => 0, "V" => 0x20, "A" => 0x40, "D" => 0x20}
+  RVA_DELTA_AREA = {"R" => 0, "V" => 0x20, "A" => 0x40, "D" => 0}
 }
 
 @init {
@@ -28,11 +30,11 @@ expr[arg_type]
         (
             (
                   EQ { op = [PTGEQ].pack('C') }
-/*                | NE { op = [PTGNE].pack('C') }         */
-/*                | GT { op = [PTGGT].pack('C') }         */
-/*                | LT { op = [PTGLT].pack('C') }         */
-/*                | GE { op = [PTGGE].pack('C') }         */
-/*                | LE { op = [PTGLE].pack('C') }         */
+                | NE { op = [PTGNE].pack('C') }
+                | GT { op = [PTGGT].pack('C') }
+                | LT { op = [PTGLT].pack('C') }
+                | GE { op = [PTGGE].pack('C') }
+                | LE { op = [PTGLE].pack('C') }
 
             )
             prec0_expr[arg_type] { @rpn += op }
@@ -105,7 +107,8 @@ primary[arg_type]
         }
     | str_tok = STR_CONST
         {
-            @rpn += [PTGSTR].pack('C') + upack1(str_tok.text[1, -1]) #TODO
+            s = str_tok.text.gsub("\"", "")
+            @rpn += [PTGSTR].pack("C") + [s.length].pack('v') + s
         }
     | int_tok = INT_CONST
     {
@@ -118,22 +121,23 @@ primary[arg_type]
     }
     | num_tok = NUM_CONST
         {
-            @rpn += [ptgNum, num_tok.text.to_f].pack("CE")
+            @rpn += [PTGNUM, num_tok.text.to_f].pack("CE")
         }
     | ref2d_tok = REF2D
         {
-          r, c = Utils.cell_to_packed_rowcol(ref2d_tok.text) # TODO
+          r, c = Utilities.cell_to_packed_rowcol(ref2d_tok.text) 
           ptg = PTGREFR + RVA_DELTA[arg_type]
           @rpn += [ptg, r, c].pack("Cv2")
         }
     | ref2d1_tok = REF2D COLON ref2d2_tok = REF2D
         {
-            r1, c1 = Utils.cell_to_packed_rowcol(ref2d1_tok.text) #TODO
-            r2, c2 = Utils.cell_to_packed_rowcol(ref2d2_tok.text) #TODO
+            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]
-            self.rpn += struct.pack("Cv4", ptg, r1, r2, c1, c2)
+            @rpn += [ptg, r1, r2, c1, c2].pack("Cv4")
         }
-/*    | sheet1 = sheet
+ 
+    | sheet1 = sheet
         { 
             sheet2 = sheet1
         }
@@ -141,13 +145,13 @@ primary[arg_type]
         {
             ptg = PTGREF3DR + RVA_DELTA[arg_type]
             rpn_ref2d = ""
-            r1, c1 = Utils.cell_to_packed_rowcol(ref3d_ref2d.text) #TODO
+            r1, c1 = Utilities.cell_to_packed_rowcol(ref3d_ref2d.text)
             rpn_ref2d = [0x0000, r1, c1].pack("v3")
         }
         ( COLON ref3d_ref2d2= REF2D
             {
                 ptg = PTGAREA3DR + RVA_DELTA[arg_type]
-                r2, c2 = Utils.cell_to_packed_rowcol(ref3d_ref2d2.text) #TODO
+                r2, c2 = Utilities.cell_to_packed_rowcol(ref3d_ref2d2.text)
                 rpn_ref2d = [0x0000, r1, r2, c1, c2].pack("v5")
             }
         )?
@@ -156,7 +160,7 @@ primary[arg_type]
             @sheet_references << [sheet1, sheet2, @rpn.size]
             @rpn += rpn_ref2d
         }
-        | FUNC_IF
+    | FUNC_IF
         LP expr["V"] (SEMICOLON | COMMA)
         {
             @rpn += [PTGATTR, 0x02, 0].pack("C2v") # tAttrIf
@@ -165,44 +169,48 @@ primary[arg_type]
         expr[arg_type] (SEMICOLON | COMMA)
         {
             @rpn += [PTGATTR, 0x08, 0].pack("C2v") # tAttrSkip
-            pos1 = @rpn.size - 2
-            @rpn = @rpn[0...pos0] + [pos1-pos0].pack("v") + @rpn[pos0+2...-1] # TODO
+            pos1 = @rpn.length - 2
+
+            rem = @rpn.length - (pos0 + 2)
+            @rpn = @rpn[0..pos0] + [pos1-pos0].pack("v") + @rpn[pos0+2, rem] # TODO Check for OBO
         }
         expr[arg_type] RP
         {
             @rpn += [PTGATTR, 0x08, 3].pack("C2v") # tAttrSkip
             @rpn += [PTGFUNCVARR, 3, 1].pack("C2v") # 3 = nargs, 1 = IF func
-            pos2 = @rpn.size
-            @rpn = @rpn[0...pos1] + [pos2-(pos1+2)-1].pack("v") + @rpn[pos1+2...-1] # TODO
+            pos2 = @rpn.length
+
+            rem = @rpn.length - (pos1 + 2)
+            @rpn = @rpn[0..pos1] + [pos2-(pos1+2)-1].pack("v") + @rpn[pos1+2, rem] # TODO Check for OBO
         }
-        | FUNC_CHOOSE
+    | FUNC_CHOOSE
         {
             arg_type = "R"
             rpn_chunks = []
         }
-        LP expr["V"] // first argument (the selector)
+        LP expr["V"]
         {
-            rpn_start = @rpn.size
-            ref_markers = [@sheet_references.size]
+            rpn_start = @rpn.length
+            ref_markers = [@sheet_references.length]
         }
         (
             (SEMICOLON | COMMA)
-                { mark = @rpn.size }
+                { mark = @rpn.length }
                 (
                   expr[arg_type]
                 | { @rpn += [PTGMISSARG].pack("C") }
                 )
                 {
-                    rpn_chunks.append(@rpn[mark...-1])
-                    ref_markers.append(@sheet_references.size)
+                    rem = @rpn.length - mark
+                    rpn_chunks << @rpn[mark, rem]
+                    ref_markers << @sheet_references.size
                 }
         )*
         RP
         {
-            # TODO test this, no idea if it works, just blindly translated
-            @rpn = @rpn[0...rpn_start]
-            nc = rpn_chunks.size
-            chunklens = rpn_chunks.collect {|c| c.size}
+            @rpn = @rpn[0..rpn_start]
+            nc = rpn_chunks.length
+            chunklens = rpn_chunks.collect {|c| c.length}
             skiplens = [0] * nc
             skiplens[-1] = 3
 
@@ -219,80 +227,73 @@ primary[arg_type]
             (0...nc).each do |i|
               (ref_markers[i]...ref_markers[i+1]).each do |r|
                 ref = @sheet_references[r]
-                @sheet_references[r] = [r[0], r[1], r[2] + chunk_shift]
+                @sheet_references[r] = [ref[0], ref[1], ref[2] + chunk_shift]
               end
               chunk_shift += 4 # size of tAttrSkip
             end
 
             choose_rpn = []
-            choose_rpn.append([PTGATTR, 0x04, nc].pack("CCv")) # 0x04 is tAttrChoose
-            choose_rpn.append(jump_pos.pack("v*"))
+            choose_rpn << [PTGATTR, 0x04, nc].pack("CCv") # 0x04 is tAttrChoose
+            choose_rpn << jump_pos.pack("v*")
             
             (0...nc).each do |i|
               choose_rpn << rpn_chunks[i]
               choose_rpn << [PTGATTR, 0x08, skiplens[i]].pack("CCv") # 0x08 is tAttrSkip
             end
-            choose_rpn.append([PTGFUNCVARV, nc+1, 100].pack("CCv")) # 100 is CHOOSE fn
+            choose_rpn << [PTGFUNCVARV, nc+1, 100].pack("CCv") # 100 is CHOOSE fn
             @rpn += choose_rpn.join
         }
-
     | name_tok = NAME
         {
-            raise "[formula] found unexpected NAME token #{name_tok.text}"
-            # TODO: handle references to defined names here
+          raise "[formula] found unexpected NAME token #{name_tok.text}"
         }
     | func_tok = NAME
         {
-          raise "not implemented"
-         # func_toku = func_tok.text.upper()
-         # if func_toku in all_funcs_by_name:
-         #     (opcode,
-         #     min_argc,
-         #     max_argc,
-         #     func_type,
-         #     arg_type_str) = all_funcs_by_name[func_toku]
-         #     arg_type_list = list(arg_type_str)
-         # else:
-         #     raise Exception("[formula] unknown function #{func_tok.text}")
-         # xcall = opcode < 0
-         # if xcall:
-         #     # The name of the add-in function is passed as the 1st arg
-         #     # of the hidden XCALL function
-         #     self.xcall_references.append((func_toku, len(self.rpn) + 1))
-         #     self.rpn += struct.pack("<BHHH",
-         #         ptgNameXR,
-         #         0xadde, # ##PATCHME## index to REF entry in EXTERNSHEET record
-         #         0xefbe, # ##PATCHME## one-based index to EXTERNNAME record
-         #         0x0000) # unused
+          func_toku = func_tok.text.upcase
+          if STD_FUNC_BY_NAME.has_key?(func_toku)
+              opcode, min_argc, max_argc, func_type, arg_type_str = STD_FUNC_BY_NAME[func_toku]
+              arg_type_list = arg_type_str.split
+          else
+              raise "[formula] unknown function #{func_tok.text}"
+          end
+          xcall = (opcode < 0)
+
+          if xcall
+            @xcall_references << [func_toku, @rpn.size + 1]
+            @rpn += [PTGNAMEXR, 0xadde, 0xefbe, 0x0000].pack("Cvvv")
+          end
         }
         LP arg_count = expr_list[arg_type_list, min_argc, max_argc] RP
         {
-          raise "not implemented"
-         # if arg_count > max_argc or arg_count < min_argc:
-         #     raise Exception, "#{arg_count} parameters for function: #{func_tok.text}"
-         # if xcall:
-         #     func_ptg = ptgFuncVarR + _RVAdelta[func_type]
-         #     self.rpn += struct.pack("<2BH", func_ptg, arg_count + 1, 255) # 255 is magic XCALL function
-         # elif min_argc == max_argc:
-         #     func_ptg = ptgFuncR + _RVAdelta[func_type]
-         #     self.rpn += struct.pack("<BH", func_ptg, opcode)
-         # elif arg_count == 1 and func_tok.text.upper() == "SUM":
-         #     self.rpn += struct.pack("<BBH", ptgAttr, 0x10, 0) # tAttrSum
-         # else:
-         #     func_ptg = ptgFuncVarR + _RVAdelta[func_type]
-         #     self.rpn += struct.pack("<2BH", func_ptg, arg_count, opcode)
+          if (arg_count > max_argc) || (arg_count < min_argc)
+             raise "#{arg_count} parameters for function: #{func_tok.text}"
+          end
+
+          if xcall
+              func_ptg = PTGFUNCVARR + RVA_DELTA[func_type]
+              @rpn += [func_ptg, arg_count + 1, 255].pack("CCv") # 255 is magic XCALL function
+          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")
+              @rpn += [PTGATTR, 0x10, 0].pack("CCv") # tAttrSum
+          else
+            func_ptg = PTGFUNCVARR + RVA_DELTA[func_type]
+              @rpn += [func_ptg, arg_count, opcode].pack("CCv")
+          end
         }
     | LP expr[arg_type] RP
         {
             @rpn += [PTGPAREN].pack('C')
         }
     ;
+    
 
 expr_list[arg_type_list, min_argc, max_argc] returns [arg_cnt]
 @members{
-        arg_cnt = 0
-        arg_type = arg_type_list[arg_cnt]
-    }
+    arg_cnt = 0
+    arg_type = arg_type_list[arg_cnt]
+}
     : expr[arg_type] { arg_cnt += 1 }
     (
         {
@@ -321,14 +322,10 @@ sheet returns[ref]
     | sheet_ref_int = INT_CONST
       { ref = sheet_ref_int.text }
     | sheet_ref_quote = QUOTENAME
-      { ref = sheet_ref_quote.text[1..-1].replace("''", "'") # TODO }
+      { ref = sheet_ref_quote.text[1, len(sheet_ref_quote.text) - 1].replace("''", "'") }
     ;
 
-*/
-
-;
-
-fragment
+    
 EQ: '=';
 LT: '<';
 GT: '>';
@@ -352,11 +349,11 @@ PERCENT: '%';
 POWER: '^';
 BANG: '!';
 
-DIGIT: '0'..'9';
+fragment DIGIT: '0'..'9';
 
 INT_CONST: DIGIT+ ;
-NUM_CONST: DIGIT* '.' DIGIT+ (('E'|'e') ('+'|'-')? DIGIT+)?; // \d*\.\d+(?:[Ee][+-]?\d+)?
-STR_CONST: '"' ~'"' '"'; // TODO add escape recognition
+NUM_CONST: DIGIT* '.' DIGIT+ (('E'|'e') ('+'|'-')? DIGIT+)?; 
+STR_CONST: '"' (~'"')+ '"';
 REF2D: '$'? ('A'..'I')? ('A'..'Z') '$'? DIGIT+;
 TRUE_CONST: ('T'|'t') ('R'|'r') ('U'|'u') ('E'|'e') ;
 FALSE_CONST: ('F'|'f') ('A'|'a') ('L'|'l') ('S'|'s') ('E'|'e') ;
@@ -364,3 +361,4 @@ NAME: '\w[\.\w]*' ;
 QUOTENAME: '\'(?:[^\']|\'\')*\'';
 FUNC_IF: 'IF';
 FUNC_CHOOSE: 'CHOOSE';
+

data/lib/surpass/ExcelFormula.tokens

@@ -1,30 +1,30 @@
-COMMA=25
-TRUE_CONST=12
-PERCENT=11
-POWER=10
-FUNC_CHOOSE=33
-BANG=28
-EQ=4
-QUOTENAME=31
-LT=19
-NE=21
-GT=20
-FUNC_IF=32
-RP=27
-FALSE_CONST=13
+GE=8
+LT=7
+NUM_CONST=21
+PERCENT=16
+REF2D=22
+CONCAT=10
+RP=29
 LP=26
-GE=23
-MUL=8
-NUM_CONST=16
-REF2D=17
-SEMICOLON=24
-CONCAT=5
-LE=22
-STR_CONST=14
-INT_CONST=15
-COLON=18
-DIV=9
-DIGIT=29
-NAME=30
-SUB=7
-ADD=6
+INT_CONST=20
+STR_CONST=19
+POWER=15
+SUB=12
+FUNC_CHOOSE=30
+SEMICOLON=27
+BANG=24
+TRUE_CONST=17
+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