surpass 0.0.7 → 0.0.9

Sign up to get free protection for your applications and to get access to all the features.
Files changed (34) hide show
  1. data/History.txt +2 -2
  2. data/Rakefile +14 -16
  3. data/debug-examples/formula-cell.bin +0 -0
  4. data/debug-examples/formula-cell.rb +14 -0
  5. data/debug-examples/formula-record.bin +0 -0
  6. data/debug-examples/formula-record.rb +15 -0
  7. data/lib/surpass/ExcelFormula.g +82 -84
  8. data/lib/surpass/ExcelFormula.tokens +29 -29
  9. data/lib/surpass/ExcelFormulaLexer.rb +1283 -842
  10. data/lib/surpass/ExcelFormulaParser.rb +1654 -491
  11. data/lib/surpass/biff_record.rb +2 -2
  12. data/lib/surpass/formula.rb +25 -0
  13. data/lib/surpass/row.rb +1 -1
  14. data/lib/surpass/utilities.rb +32 -0
  15. data/lib/surpass/workbook.rb +1 -1
  16. data/lib/surpass/worksheet.rb +4 -4
  17. data/lib/surpass.rb +12 -2
  18. data/surpass.gemspec +8 -9
  19. metadata +26 -25
  20. data/lib/surpass/excel_formula.rb +0 -23
  21. data/out.bin +0 -0
  22. data/tasks/ann.rake +0 -80
  23. data/tasks/bones.rake +0 -20
  24. data/tasks/gem.rake +0 -201
  25. data/tasks/git.rake +0 -40
  26. data/tasks/notes.rake +0 -27
  27. data/tasks/post_load.rake +0 -34
  28. data/tasks/rdoc.rake +0 -51
  29. data/tasks/rubyforge.rake +0 -55
  30. data/tasks/setup.rb +0 -292
  31. data/tasks/spec.rake +0 -54
  32. data/tasks/svn.rake +0 -47
  33. data/tasks/test.rake +0 -40
  34. data/tasks/zentest.rake +0 -36
data/lib/surpass/ExcelFormulaParser.rb CHANGED
@@ -1,602 +1,1765 @@
1
- # ExcelFormulaParser (ExcelFormula.g)
2
- # Generated by ANTLR 3.1.2-2008-10-21 on 2009-06-15 23:03:59
3
-
4
- require 'ExcelFormulaLexer' unless defined?(ExcelFormulaLexer)
5
-
6
- class ExcelFormulaParser
7
- attr_reader :lexer
8
-
9
- TOKENS = [
10
- ["EQ", 1],
11
- ["CONCAT", 2],
12
- ["ADD", 3],
13
- ["SUB", 4],
14
- ["MUL", 5],
15
- ["DIV", 6],
16
- ["POWER", 7],
17
- ["PERCENT", 8],
18
- ["TRUE_CONST", 9],
19
- ["FALSE_CONST", 10],
20
- ["STR_CONST", 11],
21
- ["INT_CONST", 12],
22
- ["NUM_CONST", 13],
23
- ["REF2D", 14],
24
- ["COLON", 15],
25
- ["LT", 16],
26
- ["GT", 17],
27
- ["NE", 18],
28
- ["LE", 19],
29
- ["GE", 20],
30
- ["SEMICOLON", 21],
31
- ["COMMA", 22],
32
- ["LP", 23],
33
- ["RP", 24],
34
- ["BANG", 25],
35
- ["DIGIT", 26],
36
- ["NAME", 27],
37
- ["QUOTENAME", 28],
38
- ["FUNC_IF", 29],
39
- ["FUNC_CHOOSE", 30]
40
- ].inject({}) { |hash, pair|
41
- name = pair[0]
42
- index = pair[1] + 3 # hardcoded for now... no way to get this value from ANTLR
43
-
44
- if name[0] == ?'
45
- hash[:"T__#{index}"] = index
46
- else
47
- hash[:"#{name}"] = index
48
- end
49
-
50
- hash
51
- }
1
+ #!/usr/bin/env ruby
2
+ #
3
+ # ExcelFormula.g
4
+ #
5
+ # Generated using ANTLR version: 3.2.1-SNAPSHOT Dec 18, 2009 04:29:28
6
+ # Ruby runtime library version: 1.3.1
7
+ # Input grammar file: ExcelFormula.g
8
+ # Generated at: 2010-05-03 16:34:32
9
+ #
10
+
11
+ # ~~~> start load path setup
12
+ this_directory = File.expand_path( File.dirname( __FILE__ ) )
13
+ $:.unshift( this_directory ) unless $:.include?( this_directory )
14
+
15
+ antlr_load_failed = proc do
16
+ load_path = $LOAD_PATH.map { |dir| ' - ' << dir }.join( $/ )
17
+ raise LoadError, <<-END.strip!
18
+
19
+ Failed to load the ANTLR3 runtime library (version 1.3.1):
20
+
21
+ Ensure the library has been installed on your system and is available
22
+ on the load path. If rubygems is available on your system, this can
23
+ be done with the command:
24
+
25
+ gem install antlr3
26
+
27
+ Current load path:
28
+ #{ load_path }
29
+
30
+ END
31
+ end
32
+
33
+ defined?(ANTLR3) or begin
34
+
35
+ # 1: try to load the ruby antlr3 runtime library from the system path
36
+ require 'antlr3'
37
+
38
+ rescue LoadError
39
+
40
+ # 2: try to load rubygems if it isn't already loaded
41
+ defined?(Gem) or begin
42
+ require 'rubygems'
43
+ rescue LoadError
44
+ antlr_load_failed.call
45
+ end
46
+
47
+ # 3: try to activate the antlr3 gem
48
+ begin
49
+ Gem.activate( 'antlr3', '= 1.3.1' )
50
+ rescue Gem::LoadError
51
+ antlr_load_failed.call
52
+ end
53
+
54
+ require 'antlr3'
55
+
56
+ end
57
+ # <~~~ end load path setup
58
+
59
+ # - - - - - - begin action @parser::header - - - - - -
60
+ # ExcelFormula.g
61
+
62
+
63
+ RVA_DELTA = {"R" => 0, "V" => 0x20, "A" => 0x40}
64
+ RVA_DELTA_REF = {"R" => 0, "V" => 0x20, "A" => 0x40, "D" => 0x20}
65
+ RVA_DELTA_AREA = {"R" => 0, "V" => 0x20, "A" => 0x40, "D" => 0}
66
+
67
+ # - - - - - - end action @parser::header - - - - - - -
68
+
69
+
70
+ module ExcelFormula
71
+ # TokenData defines all of the token type integer values
72
+ # as constants, which will be included in all
73
+ # ANTLR-generated recognizers.
74
+ const_defined?(:TokenData) or TokenData = ANTLR3::TokenScheme.new
75
+
76
+ module TokenData
77
+
78
+ # define the token constants
79
+ define_tokens(:GE => 8, :LT => 7, :NUM_CONST => 21, :PERCENT => 16,
80
+ :REF2D => 22, :CONCAT => 10, :RP => 29, :LP => 26, :INT_CONST => 20,
81
+ :STR_CONST => 19, :POWER => 15, :SUB => 12, :FUNC_CHOOSE => 30,
82
+ :SEMICOLON => 27, :BANG => 24, :TRUE_CONST => 17, :EOF => -1,
83
+ :MUL => 13, :COLON => 23, :NAME => 31, :FALSE_CONST => 18,
84
+ :COMMA => 28, :GT => 6, :DIGIT => 33, :EQ => 4, :DIV => 14,
85
+ :FUNC_IF => 25, :QUOTENAME => 32, :LE => 9, :NE => 5,
86
+ :ADD => 11)
87
+
88
+ # register the proper human-readable name or literal value
89
+ # for each token type
90
+ #
91
+ # this is necessary because anonymous tokens, which are
92
+ # created from literal values in the grammar, do not
93
+ # have descriptive names
94
+ register_names("EQ", "NE", "GT", "LT", "GE", "LE", "CONCAT", "ADD",
95
+ "SUB", "MUL", "DIV", "POWER", "PERCENT", "TRUE_CONST",
96
+ "FALSE_CONST", "STR_CONST", "INT_CONST", "NUM_CONST",
97
+ "REF2D", "COLON", "BANG", "FUNC_IF", "LP", "SEMICOLON",
98
+ "COMMA", "RP", "FUNC_CHOOSE", "NAME", "QUOTENAME", "DIGIT")
52
99
 
53
- TOKENS[:EOF] = -1
54
-
55
- def initialize(input)
56
- if input.respond_to?(:to_str) || input.respond_to?(:read)
57
- input = ExcelFormulaLexer.new(input)
58
- end
100
+ end
59
101
 
60
- @lexer = input
61
- @input = TokenStream.new(input)
62
- @backtracking = 0
63
- @failed = false
64
102
 
103
+ class Parser < ANTLR3::Parser
104
+ @grammar_home = ExcelFormula
65
105
 
66
- @rpn = ''
67
- @sheet_references = []
68
- @xcall_references = []
106
+ RULE_METHODS = [:formula, :expr, :prec0_expr, :prec1_expr, :prec2_expr,
107
+ :prec3_expr, :prec4_expr, :prec5_expr, :primary, :expr_list,
108
+ :sheet].freeze
69
109
 
70
110
 
71
- end
111
+ include TokenData
72
112
 
73
- # 22:1: formula : expr[\"V\"] ;
74
- def formula()
113
+ generated_using( "ExcelFormula.g", "3.2.1-SNAPSHOT Dec 18, 2009 04:29:28", "1.3.1" )
75
114
 
115
+ def initialize(input, options = {})
116
+ super(input, options)
76
117
 
118
+ # - - - - - - begin action @parser::init - - - - - -
119
+ # ExcelFormula.g
77
120
 
78
- # 23:7: expr[\"V\"]
79
- expr("V")
80
121
 
122
+ @rpn = ''
123
+ @sheet_references = []
124
+ @xcall_references = []
81
125
 
126
+ # - - - - - - end action @parser::init - - - - - - -
82
127
 
83
128
 
84
129
  end
85
130
 
86
- # 26:1: expr[arg_type] : prec0_expr[arg_type] ( ( EQ ) prec0_expr[arg_type] )* ;
87
- def expr(arg_type)
88
-
131
+ attr_accessor :rpn
89
132
 
133
+ # - - - - - - - - - - - - Rules - - - - - - - - - - - - -
90
134
 
91
- # 27:7: prec0_expr[arg_type] ( ( EQ ) prec0_expr[arg_type] )*
92
- prec0_expr(arg_type)
135
+ # parser rule formula
136
+ #
137
+ # (in ExcelFormula.g)
138
+ # 24:1: formula : expr[\"V\"] ;
139
+ def formula
140
+ # -> uncomment the next line to manually enable rule tracing
141
+ # trace_in(__method__, 1)
93
142
 
94
- # 28:9: ( ( EQ ) prec0_expr[arg_type] )*
95
- while true
96
- alt1 = 2
97
- #
98
- look_ahead1_0 = look_ahead(1)
99
- if look_ahead1_0 == :EQ
100
- alt1 = 1
101
- end
102
- case alt1
103
- when 1
104
- # 29:13: ( EQ ) prec0_expr[arg_type]
105
- # 30:19: EQ
106
- match(:EQ)
107
- op = [PTGEQ].pack('C')
108
- prec0_expr(arg_type)
109
-
110
- @rpn += op
111
- else
112
- break
113
- end
114
- end
143
+ begin
144
+ # at line 25:7: expr[\"V\"]
145
+ @state.following.push(TOKENS_FOLLOWING_expr_IN_formula_60)
146
+ expr("V")
147
+ @state.following.pop
115
148
 
149
+ rescue ANTLR3::Error::RecognitionError => re
150
+ report_error(re)
151
+ recover(re)
116
152
 
153
+ ensure
154
+ # -> uncomment the next line to manually enable rule tracing
155
+ # trace_out(__method__, 1)
117
156
 
157
+ end
158
+
159
+ return
118
160
  end
119
161
 
120
- # 42:1: prec0_expr[arg_type] : prec1_expr[arg_type] ( ( CONCAT ) prec1_expr[arg_type] )* ;
121
- def prec0_expr(arg_type)
122
162
 
163
+ # parser rule expr
164
+ #
165
+ # (in ExcelFormula.g)
166
+ # 28:1: expr[arg_type] : prec0_expr[arg_type] ( ( EQ | NE | GT | LT | GE | LE ) prec0_expr[arg_type] )* ;
167
+ def expr(arg_type)
168
+ # -> uncomment the next line to manually enable rule tracing
169
+ # trace_in(__method__, 2)
123
170
 
171
+ begin
172
+ # at line 29:7: prec0_expr[arg_type] ( ( EQ | NE | GT | LT | GE | LE ) prec0_expr[arg_type] )*
173
+ @state.following.push(TOKENS_FOLLOWING_prec0_expr_IN_expr_79)
174
+ prec0_expr(arg_type)
175
+ @state.following.pop
176
+ # at line 30:9: ( ( EQ | NE | GT | LT | GE | LE ) prec0_expr[arg_type] )*
177
+ loop do # decision 2
178
+ alt_2 = 2
179
+ alt_2 = @dfa2.predict(@input)
180
+ case alt_2
181
+ when 1
182
+ # at line 31:13: ( EQ | NE | GT | LT | GE | LE ) prec0_expr[arg_type]
183
+ # at line 31:13: ( EQ | NE | GT | LT | GE | LE )
184
+ alt_1 = 6
185
+ case look_1 = @input.peek(1)
186
+ when EQ then alt_1 = 1
187
+ when NE then alt_1 = 2
188
+ when GT then alt_1 = 3
189
+ when LT then alt_1 = 4
190
+ when GE then alt_1 = 5
191
+ when LE then alt_1 = 6
192
+ else
193
+ nvae = NoViableAlternative("", 1, 0)
194
+ raise nvae
195
+ end
196
+ case alt_1
197
+ when 1
198
+ # at line 32:19: EQ
199
+ match(EQ, TOKENS_FOLLOWING_EQ_IN_expr_124)
200
+ # --> action
201
+ op = [PTGEQ].pack('C')
202
+ # <-- action
124
203
 
125
- # 43:7: prec1_expr[arg_type] ( ( CONCAT ) prec1_expr[arg_type] )*
126
- prec1_expr(arg_type)
204
+ when 2
205
+ # at line 33:19: NE
206
+ match(NE, TOKENS_FOLLOWING_NE_IN_expr_146)
207
+ # --> action
208
+ op = [PTGNE].pack('C')
209
+ # <-- action
127
210
 
128
- # 44:9: ( ( CONCAT ) prec1_expr[arg_type] )*
129
- while true
130
- alt2 = 2
131
- #
132
- look_ahead2_0 = look_ahead(1)
133
- if look_ahead2_0 == :CONCAT
134
- alt2 = 1
135
- end
136
- case alt2
137
- when 1
138
- # 45:13: ( CONCAT ) prec1_expr[arg_type]
139
- # 46:17: CONCAT
140
- match(:CONCAT)
141
- op = [PTGCONCAT].pack('C')
142
- prec1_expr(arg_type)
143
-
144
- @rpn += op
145
- else
146
- break
147
- end
148
- end
211
+ when 3
212
+ # at line 34:19: GT
213
+ match(GT, TOKENS_FOLLOWING_GT_IN_expr_168)
214
+ # --> action
215
+ op = [PTGGT].pack('C')
216
+ # <-- action
149
217
 
218
+ when 4
219
+ # at line 35:19: LT
220
+ match(LT, TOKENS_FOLLOWING_LT_IN_expr_190)
221
+ # --> action
222
+ op = [PTGLT].pack('C')
223
+ # <-- action
150
224
 
225
+ when 5
226
+ # at line 36:19: GE
227
+ match(GE, TOKENS_FOLLOWING_GE_IN_expr_212)
228
+ # --> action
229
+ op = [PTGGE].pack('C')
230
+ # <-- action
231
+
232
+ when 6
233
+ # at line 37:19: LE
234
+ match(LE, TOKENS_FOLLOWING_LE_IN_expr_234)
235
+ # --> action
236
+ op = [PTGLE].pack('C')
237
+ # <-- action
151
238
 
239
+ end
240
+ @state.following.push(TOKENS_FOLLOWING_prec0_expr_IN_expr_265)
241
+ prec0_expr(arg_type)
242
+ @state.following.pop
243
+ # --> action
244
+ @rpn += op
245
+ # <-- action
246
+
247
+ else
248
+ break # out of loop for decision 2
249
+ end
250
+ end # loop for decision 2
251
+
252
+ rescue ANTLR3::Error::RecognitionError => re
253
+ report_error(re)
254
+ recover(re)
255
+
256
+ ensure
257
+ # -> uncomment the next line to manually enable rule tracing
258
+ # trace_out(__method__, 2)
259
+
260
+ end
261
+
262
+ return
152
263
  end
153
264
 
154
- # 52:1: prec1_expr[arg_type] : prec2_expr[arg_type] ( ( ADD | SUB ) prec2_expr[arg_type] )* ;
155
- def prec1_expr(arg_type)
156
265
 
266
+ # parser rule prec0_expr
267
+ #
268
+ # (in ExcelFormula.g)
269
+ # 44:1: prec0_expr[arg_type] : prec1_expr[arg_type] ( ( CONCAT ) prec1_expr[arg_type] )* ;
270
+ def prec0_expr(arg_type)
271
+ # -> uncomment the next line to manually enable rule tracing
272
+ # trace_in(__method__, 3)
157
273
 
274
+ begin
275
+ # at line 45:7: prec1_expr[arg_type] ( ( CONCAT ) prec1_expr[arg_type] )*
276
+ @state.following.push(TOKENS_FOLLOWING_prec1_expr_IN_prec0_expr_297)
277
+ prec1_expr(arg_type)
278
+ @state.following.pop
279
+ # at line 46:9: ( ( CONCAT ) prec1_expr[arg_type] )*
280
+ loop do # decision 3
281
+ alt_3 = 2
282
+ alt_3 = @dfa3.predict(@input)
283
+ case alt_3
284
+ when 1
285
+ # at line 47:13: ( CONCAT ) prec1_expr[arg_type]
286
+ # at line 47:13: ( CONCAT )
287
+ # at line 48:17: CONCAT
288
+ match(CONCAT, TOKENS_FOLLOWING_CONCAT_IN_prec0_expr_340)
289
+ # --> action
290
+ op = [PTGCONCAT].pack('C')
291
+ # <-- action
292
+
293
+ @state.following.push(TOKENS_FOLLOWING_prec1_expr_IN_prec0_expr_370)
294
+ prec1_expr(arg_type)
295
+ @state.following.pop
296
+ # --> action
297
+ @rpn += op
298
+ # <-- action
299
+
300
+ else
301
+ break # out of loop for decision 3
302
+ end
303
+ end # loop for decision 3
304
+
305
+ rescue ANTLR3::Error::RecognitionError => re
306
+ report_error(re)
307
+ recover(re)
308
+
309
+ ensure
310
+ # -> uncomment the next line to manually enable rule tracing
311
+ # trace_out(__method__, 3)
312
+
313
+ end
314
+
315
+ return
316
+ end
158
317
 
159
- # 53:7: prec2_expr[arg_type] ( ( ADD | SUB ) prec2_expr[arg_type] )*
160
- prec2_expr(arg_type)
161
318
 
162
- # 54:9: ( ( ADD | SUB ) prec2_expr[arg_type] )*
163
- while true
164
- alt4 = 2
165
- #
166
- look_ahead4_0 = look_ahead(1)
167
- if (TOKENS[look_ahead4_0] >= 6 && TOKENS[look_ahead4_0] <= 7)
168
- alt4 = 1
169
- end
170
- case alt4
171
- when 1
172
- # 55:13: ( ADD | SUB ) prec2_expr[arg_type]
173
- # 55:13: ( ADD | SUB )
174
- alt3 = 2
175
- #
176
- look_ahead3_0 = look_ahead(1)
177
- if look_ahead3_0 == :ADD
178
- alt3 = 1
179
- elsif look_ahead3_0 == :SUB
180
- alt3 = 2
181
- else
182
- raise "Expected: "
183
- end
184
- case alt3
185
- when 1
186
- # 56:19: ADD
187
- match(:ADD)
188
- op = [PTGADD].pack('C')
189
- when 2
190
- # 57:19: SUB
191
- match(:SUB)
192
- op = [PTGSUB].pack('C')
193
- end
194
- prec2_expr(arg_type)
319
+ # parser rule prec1_expr
320
+ #
321
+ # (in ExcelFormula.g)
322
+ # 54:1: prec1_expr[arg_type] : prec2_expr[arg_type] ( ( ADD | SUB ) prec2_expr[arg_type] )* ;
323
+ def prec1_expr(arg_type)
324
+ # -> uncomment the next line to manually enable rule tracing
325
+ # trace_in(__method__, 4)
195
326
 
196
- @rpn += op
197
- else
198
- break
327
+ begin
328
+ # at line 55:7: prec2_expr[arg_type] ( ( ADD | SUB ) prec2_expr[arg_type] )*
329
+ @state.following.push(TOKENS_FOLLOWING_prec2_expr_IN_prec1_expr_402)
330
+ prec2_expr(arg_type)
331
+ @state.following.pop
332
+ # at line 56:9: ( ( ADD | SUB ) prec2_expr[arg_type] )*
333
+ loop do # decision 5
334
+ alt_5 = 2
335
+ alt_5 = @dfa5.predict(@input)
336
+ case alt_5
337
+ when 1
338
+ # at line 57:13: ( ADD | SUB ) prec2_expr[arg_type]
339
+ # at line 57:13: ( ADD | SUB )
340
+ alt_4 = 2
341
+ look_4_0 = @input.peek(1)
342
+
343
+ if (look_4_0 == ADD)
344
+ alt_4 = 1
345
+ elsif (look_4_0 == SUB)
346
+ alt_4 = 2
347
+ else
348
+ nvae = NoViableAlternative("", 4, 0)
349
+ raise nvae
199
350
  end
200
- end
201
-
351
+ case alt_4
352
+ when 1
353
+ # at line 58:19: ADD
354
+ match(ADD, TOKENS_FOLLOWING_ADD_IN_prec1_expr_447)
355
+ # --> action
356
+ op = [PTGADD].pack('C')
357
+ # <-- action
202
358
 
359
+ when 2
360
+ # at line 59:19: SUB
361
+ match(SUB, TOKENS_FOLLOWING_SUB_IN_prec1_expr_469)
362
+ # --> action
363
+ op = [PTGSUB].pack('C')
364
+ # <-- action
203
365
 
366
+ end
367
+ @state.following.push(TOKENS_FOLLOWING_prec2_expr_IN_prec1_expr_499)
368
+ prec2_expr(arg_type)
369
+ @state.following.pop
370
+ # --> action
371
+ @rpn += op
372
+ # <-- action
373
+
374
+ else
375
+ break # out of loop for decision 5
376
+ end
377
+ end # loop for decision 5
378
+
379
+ rescue ANTLR3::Error::RecognitionError => re
380
+ report_error(re)
381
+ recover(re)
382
+
383
+ ensure
384
+ # -> uncomment the next line to manually enable rule tracing
385
+ # trace_out(__method__, 4)
386
+
387
+ end
388
+
389
+ return
204
390
  end
205
391
 
206
- # 64:1: prec2_expr[arg_type] : prec3_expr[arg_type] ( ( MUL | DIV ) prec3_expr[arg_type] )* ;
207
- def prec2_expr(arg_type)
208
-
209
392
 
393
+ # parser rule prec2_expr
394
+ #
395
+ # (in ExcelFormula.g)
396
+ # 66:1: prec2_expr[arg_type] : prec3_expr[arg_type] ( ( MUL | DIV ) prec3_expr[arg_type] )* ;
397
+ def prec2_expr(arg_type)
398
+ # -> uncomment the next line to manually enable rule tracing
399
+ # trace_in(__method__, 5)
210
400
 
211
- # 65:7: prec3_expr[arg_type] ( ( MUL | DIV ) prec3_expr[arg_type] )*
401
+ begin
402
+ # at line 67:7: prec3_expr[arg_type] ( ( MUL | DIV ) prec3_expr[arg_type] )*
403
+ @state.following.push(TOKENS_FOLLOWING_prec3_expr_IN_prec2_expr_532)
212
404
  prec3_expr(arg_type)
213
-
214
- # 66:9: ( ( MUL | DIV ) prec3_expr[arg_type] )*
215
- while true
216
- alt6 = 2
217
- #
218
- look_ahead6_0 = look_ahead(1)
219
- if (TOKENS[look_ahead6_0] >= 8 && TOKENS[look_ahead6_0] <= 9)
220
- alt6 = 1
405
+ @state.following.pop
406
+ # at line 68:9: ( ( MUL | DIV ) prec3_expr[arg_type] )*
407
+ loop do # decision 7
408
+ alt_7 = 2
409
+ alt_7 = @dfa7.predict(@input)
410
+ case alt_7
411
+ when 1
412
+ # at line 69:13: ( MUL | DIV ) prec3_expr[arg_type]
413
+ # at line 69:13: ( MUL | DIV )
414
+ alt_6 = 2
415
+ look_6_0 = @input.peek(1)
416
+
417
+ if (look_6_0 == MUL)
418
+ alt_6 = 1
419
+ elsif (look_6_0 == DIV)
420
+ alt_6 = 2
421
+ else
422
+ nvae = NoViableAlternative("", 6, 0)
423
+ raise nvae
221
424
  end
222
- case alt6
223
- when 1
224
- # 67:13: ( MUL | DIV ) prec3_expr[arg_type]
225
- # 67:13: ( MUL | DIV )
226
- alt5 = 2
227
- #
228
- look_ahead5_0 = look_ahead(1)
229
- if look_ahead5_0 == :MUL
230
- alt5 = 1
231
- elsif look_ahead5_0 == :DIV
232
- alt5 = 2
233
- else
234
- raise "Expected: "
235
- end
236
- case alt5
237
- when 1
238
- # 68:19: MUL
239
- match(:MUL)
240
- op = [PTGMUL].pack('C')
241
- when 2
242
- # 69:19: DIV
243
- match(:DIV)
244
- op = [PTGDIV].pack('C')
245
- end
246
- prec3_expr(arg_type)
425
+ case alt_6
426
+ when 1
427
+ # at line 70:19: MUL
428
+ match(MUL, TOKENS_FOLLOWING_MUL_IN_prec2_expr_577)
429
+ # --> action
430
+ op = [PTGMUL].pack('C')
431
+ # <-- action
432
+
433
+ when 2
434
+ # at line 71:19: DIV
435
+ match(DIV, TOKENS_FOLLOWING_DIV_IN_prec2_expr_599)
436
+ # --> action
437
+ op = [PTGDIV].pack('C')
438
+ # <-- action
247
439
 
248
- @rpn += op
249
- else
250
- break
251
440
  end
252
- end
441
+ @state.following.push(TOKENS_FOLLOWING_prec3_expr_IN_prec2_expr_629)
442
+ prec3_expr(arg_type)
443
+ @state.following.pop
444
+ # --> action
445
+ @rpn += op
446
+ # <-- action
447
+
448
+ else
449
+ break # out of loop for decision 7
450
+ end
451
+ end # loop for decision 7
452
+
453
+ rescue ANTLR3::Error::RecognitionError => re
454
+ report_error(re)
455
+ recover(re)
456
+
457
+ ensure
458
+ # -> uncomment the next line to manually enable rule tracing
459
+ # trace_out(__method__, 5)
460
+
461
+ end
462
+
463
+ return
464
+ end
253
465
 
254
466
 
467
+ # parser rule prec3_expr
468
+ #
469
+ # (in ExcelFormula.g)
470
+ # 77:1: prec3_expr[arg_type] : prec5_expr[arg_type] ( ( POWER ) prec5_expr[arg_type] )* ;
471
+ def prec3_expr(arg_type)
472
+ # -> uncomment the next line to manually enable rule tracing
473
+ # trace_in(__method__, 6)
255
474
 
475
+ begin
476
+ # at line 78:7: prec5_expr[arg_type] ( ( POWER ) prec5_expr[arg_type] )*
477
+ @state.following.push(TOKENS_FOLLOWING_prec5_expr_IN_prec3_expr_661)
478
+ prec5_expr(arg_type)
479
+ @state.following.pop
480
+ # at line 79:9: ( ( POWER ) prec5_expr[arg_type] )*
481
+ loop do # decision 8
482
+ alt_8 = 2
483
+ alt_8 = @dfa8.predict(@input)
484
+ case alt_8
485
+ when 1
486
+ # at line 80:13: ( POWER ) prec5_expr[arg_type]
487
+ # at line 80:13: ( POWER )
488
+ # at line 81:17: POWER
489
+ match(POWER, TOKENS_FOLLOWING_POWER_IN_prec3_expr_704)
490
+ # --> action
491
+ op = [PTGPOWER].pack('C')
492
+ # <-- action
493
+
494
+ @state.following.push(TOKENS_FOLLOWING_prec5_expr_IN_prec3_expr_734)
495
+ prec5_expr(arg_type)
496
+ @state.following.pop
497
+ # --> action
498
+ @rpn += op
499
+ # <-- action
500
+
501
+ else
502
+ break # out of loop for decision 8
503
+ end
504
+ end # loop for decision 8
505
+
506
+ rescue ANTLR3::Error::RecognitionError => re
507
+ report_error(re)
508
+ recover(re)
509
+
510
+ ensure
511
+ # -> uncomment the next line to manually enable rule tracing
512
+ # trace_out(__method__, 6)
513
+
514
+ end
515
+
516
+ return
256
517
  end
257
518
 
258
- # 75:1: prec3_expr[arg_type] : prec5_expr[arg_type] ( ( POWER ) prec5_expr[arg_type] )* ;
259
- def prec3_expr(arg_type)
260
-
261
519
 
520
+ # parser rule prec4_expr
521
+ #
522
+ # (in ExcelFormula.g)
523
+ # 87:1: prec4_expr[arg_type] : prec5_expr[arg_type] ( PERCENT )? ;
524
+ def prec4_expr(arg_type)
525
+ # -> uncomment the next line to manually enable rule tracing
526
+ # trace_in(__method__, 7)
262
527
 
263
- # 76:7: prec5_expr[arg_type] ( ( POWER ) prec5_expr[arg_type] )*
528
+ begin
529
+ # at line 88:7: prec5_expr[arg_type] ( PERCENT )?
530
+ @state.following.push(TOKENS_FOLLOWING_prec5_expr_IN_prec4_expr_766)
264
531
  prec5_expr(arg_type)
532
+ @state.following.pop
533
+ # at line 89:9: ( PERCENT )?
534
+ alt_9 = 2
535
+ look_9_0 = @input.peek(1)
265
536
 
266
- # 77:9: ( ( POWER ) prec5_expr[arg_type] )*
267
- while true
268
- alt7 = 2
269
- #
270
- look_ahead7_0 = look_ahead(1)
271
- if look_ahead7_0 == :POWER
272
- alt7 = 1
273
- end
274
- case alt7
275
- when 1
276
- # 78:13: ( POWER ) prec5_expr[arg_type]
277
- # 79:17: POWER
278
- match(:POWER)
279
- op = [PTGPOWER].pack('C')
280
- prec5_expr(arg_type)
281
-
282
- @rpn += op
283
- else
284
- break
285
- end
537
+ if (look_9_0 == PERCENT)
538
+ alt_9 = 1
286
539
  end
540
+ case alt_9
541
+ when 1
542
+ # at line 90:13: PERCENT
543
+ match(PERCENT, TOKENS_FOLLOWING_PERCENT_IN_prec4_expr_791)
544
+ # --> action
545
+ @rpn += [PTGPERCENT].pack('C')
546
+ # <-- action
287
547
 
548
+ end
288
549
 
550
+ rescue ANTLR3::Error::RecognitionError => re
551
+ report_error(re)
552
+ recover(re)
289
553
 
290
- end
291
-
292
- # 85:1: prec4_expr[arg_type] : prec5_expr[arg_type] ( PERCENT )? ;
293
- def prec4_expr(arg_type)
294
-
554
+ ensure
555
+ # -> uncomment the next line to manually enable rule tracing
556
+ # trace_out(__method__, 7)
295
557
 
558
+ end
559
+
560
+ return
561
+ end
296
562
 
297
- # 86:7: prec5_expr[arg_type] ( PERCENT )?
298
- prec5_expr(arg_type)
299
563
 
300
- # 87:9: ( PERCENT )?
301
- alt8 = 2
302
- #
303
- look_ahead8_0 = look_ahead(1)
564
+ # parser rule prec5_expr
565
+ #
566
+ # (in ExcelFormula.g)
567
+ # 94:1: prec5_expr[arg_type] : ( primary[arg_type] | SUB primary[arg_type] );
568
+ def prec5_expr(arg_type)
569
+ # -> uncomment the next line to manually enable rule tracing
570
+ # trace_in(__method__, 8)
571
+
572
+ begin
573
+ # at line 95:5: ( primary[arg_type] | SUB primary[arg_type] )
574
+ alt_10 = 2
575
+ alt_10 = @dfa10.predict(@input)
576
+ case alt_10
577
+ when 1
578
+ # at line 95:7: primary[arg_type]
579
+ @state.following.push(TOKENS_FOLLOWING_primary_IN_prec5_expr_822)
580
+ primary(arg_type)
581
+ @state.following.pop
582
+
583
+ when 2
584
+ # at line 96:7: SUB primary[arg_type]
585
+ match(SUB, TOKENS_FOLLOWING_SUB_IN_prec5_expr_831)
586
+ @state.following.push(TOKENS_FOLLOWING_primary_IN_prec5_expr_833)
587
+ primary(arg_type)
588
+ @state.following.pop
589
+ # --> action
590
+ @rpn += [PTGUMINUS].pack('C')
591
+ # <-- action
304
592
 
305
- if look_ahead8_0 == :PERCENT
306
- alt8 = 1
307
- end
308
- case alt8
309
- when 1
310
- # 88:13: PERCENT
311
- match(:PERCENT)
312
- @rpn += [PTGPERCENT].pack('C')
313
593
  end
594
+ rescue ANTLR3::Error::RecognitionError => re
595
+ report_error(re)
596
+ recover(re)
314
597
 
598
+ ensure
599
+ # -> uncomment the next line to manually enable rule tracing
600
+ # trace_out(__method__, 8)
315
601
 
316
-
602
+ end
603
+
604
+ return
317
605
  end
318
606
 
319
- # 92:1: prec5_expr[arg_type] : ( primary[arg_type] | SUB primary[arg_type] );
320
- def prec5_expr(arg_type)
321
-
322
607
 
608
+ # parser rule primary
609
+ #
610
+ # (in ExcelFormula.g)
611
+ # 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 );
612
+ def primary(arg_type)
613
+ # -> uncomment the next line to manually enable rule tracing
614
+ # trace_in(__method__, 9)
615
+ str_tok = nil
616
+ int_tok = nil
617
+ num_tok = nil
618
+ ref2d_tok = nil
619
+ ref2d1_tok = nil
620
+ ref2d2_tok = nil
621
+ ref3d_ref2d = nil
622
+ ref3d_ref2d2 = nil
623
+ name_tok = nil
624
+ func_tok = nil
625
+ sheet1 = nil
626
+ sheet2 = nil
627
+ arg_count = nil
628
+
629
+ begin
630
+ # 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 )
631
+ alt_15 = 13
632
+ alt_15 = @dfa15.predict(@input)
633
+ case alt_15
634
+ when 1
635
+ # at line 100:7: TRUE_CONST
636
+ match(TRUE_CONST, TOKENS_FOLLOWING_TRUE_CONST_IN_primary_854)
637
+ # --> action
638
+
639
+ @rpn += [PTGBOOL, 1].pack("C2")
640
+
641
+ # <-- action
642
+
643
+ when 2
644
+ # at line 104:7: FALSE_CONST
645
+ match(FALSE_CONST, TOKENS_FOLLOWING_FALSE_CONST_IN_primary_872)
646
+ # --> action
647
+
648
+ @rpn += [PTGBOOL, 0].pack("C2")
649
+
650
+ # <-- action
651
+
652
+ when 3
653
+ # at line 108:7: str_tok= STR_CONST
654
+ str_tok = match(STR_CONST, TOKENS_FOLLOWING_STR_CONST_IN_primary_894)
655
+ # --> action
656
+
657
+ s = str_tok.text.gsub("\"", "")
658
+ @rpn += [PTGSTR].pack("C") + [s.length].pack('v') + s
659
+
660
+ # <-- action
661
+
662
+ when 4
663
+ # at line 113:7: int_tok= INT_CONST
664
+ int_tok = match(INT_CONST, TOKENS_FOLLOWING_INT_CONST_IN_primary_916)
665
+ # --> action
666
+
667
+ int_value = int_tok.text.to_i
668
+ if int_value <= 65535
669
+ @rpn += [PTGINT, int_value].pack("Cv")
670
+ else
671
+ @rpn += [PTGNUM, int_value.to_f].pack("CE")
672
+ end
673
+
674
+ # <-- action
675
+
676
+ when 5
677
+ # at line 122:7: num_tok= NUM_CONST
678
+ num_tok = match(NUM_CONST, TOKENS_FOLLOWING_NUM_CONST_IN_primary_934)
679
+ # --> action
680
+
681
+ @rpn += [PTGNUM, num_tok.text.to_f].pack("CE")
682
+
683
+ # <-- action
684
+
685
+ when 6
686
+ # at line 126:7: ref2d_tok= REF2D
687
+ ref2d_tok = match(REF2D, TOKENS_FOLLOWING_REF2D_IN_primary_956)
688
+ # --> action
689
+
690
+ r, c = Utilities.cell_to_packed_rowcol(ref2d_tok.text)
691
+ ptg = PTGREFR + RVA_DELTA[arg_type]
692
+ @rpn += [ptg, r, c].pack("Cv2")
693
+
694
+ # <-- action
695
+
696
+ when 7
697
+ # at line 132:7: ref2d1_tok= REF2D COLON ref2d2_tok= REF2D
698
+ ref2d1_tok = match(REF2D, TOKENS_FOLLOWING_REF2D_IN_primary_978)
699
+ match(COLON, TOKENS_FOLLOWING_COLON_IN_primary_980)
700
+ ref2d2_tok = match(REF2D, TOKENS_FOLLOWING_REF2D_IN_primary_986)
701
+ # --> action
702
+
703
+ r1, c1 = Utilities.cell_to_packed_rowcol(ref2d1_tok.text)
704
+ r2, c2 = Utilities.cell_to_packed_rowcol(ref2d2_tok.text)
705
+ ptg = PTGAREAR + RVA_DELTA[arg_type]
706
+ @rpn += [ptg, r1, r2, c1, c2].pack("Cv4")
707
+
708
+ # <-- action
709
+
710
+ when 8
711
+ # at line 140:7: sheet1= sheet ( COLON sheet2= sheet )? BANG ref3d_ref2d= REF2D ( COLON ref3d_ref2d2= REF2D )?
712
+ @state.following.push(TOKENS_FOLLOWING_sheet_IN_primary_1010)
713
+ sheet1 = sheet
714
+ @state.following.pop
715
+ # --> action
716
+
717
+ sheet2 = sheet1
718
+
719
+ # <-- action
720
+ # at line 144:9: ( COLON sheet2= sheet )?
721
+ alt_11 = 2
722
+ look_11_0 = @input.peek(1)
723
+
724
+ if (look_11_0 == COLON)
725
+ alt_11 = 1
726
+ end
727
+ case alt_11
728
+ when 1
729
+ # at line 144:11: COLON sheet2= sheet
730
+ match(COLON, TOKENS_FOLLOWING_COLON_IN_primary_1032)
731
+ @state.following.push(TOKENS_FOLLOWING_sheet_IN_primary_1038)
732
+ sheet2 = sheet
733
+ @state.following.pop
734
+
735
+ end
736
+ match(BANG, TOKENS_FOLLOWING_BANG_IN_primary_1043)
737
+ ref3d_ref2d = match(REF2D, TOKENS_FOLLOWING_REF2D_IN_primary_1047)
738
+ # --> action
739
+
740
+ ptg = PTGREF3DR + RVA_DELTA[arg_type]
741
+ rpn_ref2d = ""
742
+ r1, c1 = Utilities.cell_to_packed_rowcol(ref3d_ref2d.text)
743
+ rpn_ref2d = [0x0000, r1, c1].pack("v3")
744
+
745
+ # <-- action
746
+ # at line 151:9: ( COLON ref3d_ref2d2= REF2D )?
747
+ alt_12 = 2
748
+ alt_12 = @dfa12.predict(@input)
749
+ case alt_12
750
+ when 1
751
+ # at line 151:11: COLON ref3d_ref2d2= REF2D
752
+ match(COLON, TOKENS_FOLLOWING_COLON_IN_primary_1069)
753
+ ref3d_ref2d2 = match(REF2D, TOKENS_FOLLOWING_REF2D_IN_primary_1074)
754
+ # --> action
755
+
756
+ ptg = PTGAREA3DR + RVA_DELTA[arg_type]
757
+ r2, c2 = Utilities.cell_to_packed_rowcol(ref3d_ref2d2.text)
758
+ rpn_ref2d = [0x0000, r1, r2, c1, c2].pack("v5")
759
+
760
+ # <-- action
761
+
762
+ end
763
+ # --> action
764
+
765
+ @rpn += [ptg].pack("C")
766
+ @sheet_references << [sheet1, sheet2, @rpn.size]
767
+ @rpn += rpn_ref2d
768
+
769
+ # <-- action
770
+
771
+ when 9
772
+ # at line 163:7: FUNC_IF LP expr[\"V\"] ( SEMICOLON | COMMA ) expr[arg_type] ( SEMICOLON | COMMA ) expr[arg_type] RP
773
+ match(FUNC_IF, TOKENS_FOLLOWING_FUNC_IF_IN_primary_1117)
774
+ match(LP, TOKENS_FOLLOWING_LP_IN_primary_1127)
775
+ @state.following.push(TOKENS_FOLLOWING_expr_IN_primary_1129)
776
+ expr("V")
777
+ @state.following.pop
778
+ if @input.peek(1).between?(SEMICOLON, COMMA)
779
+ @input.consume
780
+ @state.error_recovery = false
781
+ else
782
+ mse = MismatchedSet(nil)
783
+ raise mse
784
+ end
785
+
786
+
787
+ # --> action
788
+
789
+ @rpn += [PTGATTR, 0x02, 0].pack("C2v") # tAttrIf
790
+ pos0 = @rpn.size - 2
791
+
792
+ # <-- action
793
+ @state.following.push(TOKENS_FOLLOWING_expr_IN_primary_1158)
794
+ expr(arg_type)
795
+ @state.following.pop
796
+ if @input.peek(1).between?(SEMICOLON, COMMA)
797
+ @input.consume
798
+ @state.error_recovery = false
799
+ else
800
+ mse = MismatchedSet(nil)
801
+ raise mse
802
+ end
803
+
804
+
805
+ # --> action
806
+
807
+ @rpn += [PTGATTR, 0x08, 0].pack("C2v") # tAttrSkip
808
+ pos1 = @rpn.length - 2
809
+
810
+ rem = @rpn.length - (pos0 + 2)
811
+ @rpn = @rpn[0..pos0] + [pos1-pos0].pack("v") + @rpn[pos0+2, rem] # TODO Check for OBO
812
+
813
+ # <-- action
814
+ @state.following.push(TOKENS_FOLLOWING_expr_IN_primary_1187)
815
+ expr(arg_type)
816
+ @state.following.pop
817
+ match(RP, TOKENS_FOLLOWING_RP_IN_primary_1190)
818
+ # --> action
819
+
820
+ @rpn += [PTGATTR, 0x08, 3].pack("C2v") # tAttrSkip
821
+ @rpn += [PTGFUNCVARR, 3, 1].pack("C2v") # 3 = nargs, 1 = IF func
822
+ pos2 = @rpn.length
823
+
824
+ rem = @rpn.length - (pos1 + 2)
825
+ @rpn = @rpn[0..pos1] + [pos2-(pos1+2)-1].pack("v") + @rpn[pos1+2, rem] # TODO Check for OBO
826
+
827
+ # <-- action
828
+
829
+ when 10
830
+ # at line 186:7: FUNC_CHOOSE LP expr[\"V\"] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )* RP
831
+ match(FUNC_CHOOSE, TOKENS_FOLLOWING_FUNC_CHOOSE_IN_primary_1208)
832
+ # --> action
833
+
834
+ arg_type = "R"
835
+ rpn_chunks = []
836
+
837
+ # <-- action
838
+ match(LP, TOKENS_FOLLOWING_LP_IN_primary_1228)
839
+ @state.following.push(TOKENS_FOLLOWING_expr_IN_primary_1230)
840
+ expr("V")
841
+ @state.following.pop
842
+ # --> action
843
+
844
+ rpn_start = @rpn.length
845
+ ref_markers = [@sheet_references.length]
846
+
847
+ # <-- action
848
+ # at line 196:9: ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )*
849
+ loop do # decision 14
850
+ alt_14 = 2
851
+ look_14_0 = @input.peek(1)
852
+
853
+ if (look_14_0.between?(SEMICOLON, COMMA))
854
+ alt_14 = 1
323
855
 
324
- # 93:5: ( primary[arg_type] | SUB primary[arg_type] )
325
- alt9 = 2
326
- #
327
- look_ahead9_0 = look_ahead(1)
328
- if (TOKENS[look_ahead9_0] >= 12 && TOKENS[look_ahead9_0] <= 17)
329
- alt9 = 1
330
- elsif look_ahead9_0 == :SUB
331
- alt9 = 2
332
- else
333
- raise "Expected: "
334
- end
335
- case alt9
856
+ end
857
+ case alt_14
336
858
  when 1
337
- # 93:7: primary[arg_type]
338
- primary(arg_type)
859
+ # at line 197:13: ( SEMICOLON | COMMA ) ( expr[arg_type] | )
860
+ if @input.peek(1).between?(SEMICOLON, COMMA)
861
+ @input.consume
862
+ @state.error_recovery = false
863
+ else
864
+ mse = MismatchedSet(nil)
865
+ raise mse
866
+ end
867
+
868
+
869
+ # --> action
870
+ mark = @rpn.length
871
+ # <-- action
872
+ # at line 199:17: ( expr[arg_type] | )
873
+ alt_13 = 2
874
+ alt_13 = @dfa13.predict(@input)
875
+ case alt_13
876
+ when 1
877
+ # at line 200:19: expr[arg_type]
878
+ @state.following.push(TOKENS_FOLLOWING_expr_IN_primary_1327)
879
+ expr(arg_type)
880
+ @state.following.pop
881
+
882
+ when 2
883
+ # at line 201:19:
884
+ # --> action
885
+ @rpn += [PTGMISSARG].pack("C")
886
+ # <-- action
887
+
888
+ end
889
+ # --> action
890
+
891
+ rem = @rpn.length - mark
892
+ rpn_chunks << @rpn[mark, rem]
893
+ ref_markers << @sheet_references.size
894
+
895
+ # <-- action
896
+
897
+ else
898
+ break # out of loop for decision 14
899
+ end
900
+ end # loop for decision 14
901
+ match(RP, TOKENS_FOLLOWING_RP_IN_primary_1405)
902
+ # --> action
903
+
904
+ @rpn = @rpn[0..rpn_start]
905
+ nc = rpn_chunks.length
906
+ chunklens = rpn_chunks.collect {|c| c.length}
907
+ skiplens = [0] * nc
908
+ skiplens[-1] = 3
909
+
910
+ (nc-1).downto(1) do |i|
911
+ skiplens[i-1] = skiplens[i] + chunklens[i] + 4
912
+ end
913
+ jump_pos = [2 * nc + 2]
914
+
915
+ (0...nc).each do |i|
916
+ jump_pos.append(jump_pos[-1] + chunklens[ic] + 4)
917
+ end
918
+ chunk_shift = 2 * nc + 6 # size of tAttrChoose
919
+
920
+ (0...nc).each do |i|
921
+ (ref_markers[i]...ref_markers[i+1]).each do |r|
922
+ ref = @sheet_references[r]
923
+ @sheet_references[r] = [ref[0], ref[1], ref[2] + chunk_shift]
924
+ end
925
+ chunk_shift += 4 # size of tAttrSkip
926
+ end
927
+
928
+ choose_rpn = []
929
+ choose_rpn << [PTGATTR, 0x04, nc].pack("CCv") # 0x04 is tAttrChoose
930
+ choose_rpn << jump_pos.pack("v*")
931
+
932
+ (0...nc).each do |i|
933
+ choose_rpn << rpn_chunks[i]
934
+ choose_rpn << [PTGATTR, 0x08, skiplens[i]].pack("CCv") # 0x08 is tAttrSkip
935
+ end
936
+ choose_rpn << [PTGFUNCVARV, nc+1, 100].pack("CCv") # 100 is CHOOSE fn
937
+ @rpn += choose_rpn.join
938
+
939
+ # <-- action
940
+
941
+ when 11
942
+ # at line 246:7: name_tok= NAME
943
+ name_tok = match(NAME, TOKENS_FOLLOWING_NAME_IN_primary_1427)
944
+ # --> action
945
+
946
+ raise "[formula] found unexpected NAME token #{name_tok.text}"
947
+
948
+ # <-- action
949
+
950
+ when 12
951
+ # at line 250:7: func_tok= NAME LP arg_count= expr_list[arg_type_list, min_argc, max_argc] RP
952
+ func_tok = match(NAME, TOKENS_FOLLOWING_NAME_IN_primary_1449)
953
+ # --> action
954
+
955
+ func_toku = func_tok.text.upcase
956
+ if STD_FUNC_BY_NAME.has_key?(func_toku)
957
+ opcode, min_argc, max_argc, func_type, arg_type_str = STD_FUNC_BY_NAME[func_toku]
958
+ arg_type_list = arg_type_str.split
959
+ else
960
+ raise "[formula] unknown function #{func_tok.text}"
961
+ end
962
+ xcall = (opcode < 0)
339
963
 
340
- when 2
341
- # 94:7: SUB primary[arg_type]
342
- match(:SUB)
343
- primary(arg_type)
964
+ if xcall
965
+ @xcall_references << [func_toku, @rpn.size + 1]
966
+ @rpn += [PTGNAMEXR, 0xadde, 0xefbe, 0x0000].pack("Cvvv")
967
+ end
968
+
969
+ # <-- action
970
+ match(LP, TOKENS_FOLLOWING_LP_IN_primary_1469)
971
+ @state.following.push(TOKENS_FOLLOWING_expr_list_IN_primary_1475)
972
+ arg_count = expr_list(arg_type_list, min_argc, max_argc)
973
+ @state.following.pop
974
+ match(RP, TOKENS_FOLLOWING_RP_IN_primary_1478)
975
+ # --> action
976
+
977
+ if (arg_count > max_argc) || (arg_count < min_argc)
978
+ raise "#{arg_count} parameters for function: #{func_tok.text}"
979
+ end
344
980
 
345
- @rpn += [PTGUMINUS].pack('C')
346
- end
981
+ if xcall
982
+ func_ptg = PTGFUNCVARR + RVA_DELTA[func_type]
983
+ @rpn += [func_ptg, arg_count + 1, 255].pack("CCv") # 255 is magic XCALL function
984
+ elsif (min_argc == max_argc)
985
+ func_ptg = PTGFUNCR + RVA_DELTA[func_type]
986
+ @rpn += [func_ptg, opcode].pack("Cv")
987
+ elsif (arg_count == 1) && (func_tok.text.upcase == "SUM")
988
+ @rpn += [PTGATTR, 0x10, 0].pack("CCv") # tAttrSum
989
+ else
990
+ func_ptg = PTGFUNCVARR + RVA_DELTA[func_type]
991
+ @rpn += [func_ptg, arg_count, opcode].pack("CCv")
992
+ end
993
+
994
+ # <-- action
995
+
996
+ when 13
997
+ # at line 285:7: LP expr[arg_type] RP
998
+ match(LP, TOKENS_FOLLOWING_LP_IN_primary_1496)
999
+ @state.following.push(TOKENS_FOLLOWING_expr_IN_primary_1498)
1000
+ expr(arg_type)
1001
+ @state.following.pop
1002
+ match(RP, TOKENS_FOLLOWING_RP_IN_primary_1501)
1003
+ # --> action
1004
+
1005
+ @rpn += [PTGPAREN].pack('C')
1006
+
1007
+ # <-- action
347
1008
 
1009
+ end
1010
+ rescue ANTLR3::Error::RecognitionError => re
1011
+ report_error(re)
1012
+ recover(re)
348
1013
 
1014
+ ensure
1015
+ # -> uncomment the next line to manually enable rule tracing
1016
+ # trace_out(__method__, 9)
349
1017
 
1018
+ end
1019
+
1020
+ return
350
1021
  end
351
1022
 
352
- # 97: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 );
353
- def primary(arg_type)
354
- _str_tok = nil
355
- _int_tok = nil
356
- _num_tok = nil
357
- _ref2d_tok = nil
358
- _ref2d1_tok = nil
359
- _ref2d2_tok = nil
360
-
361
1023
 
1024
+ # parser rule expr_list
1025
+ #
1026
+ # (in ExcelFormula.g)
1027
+ # 292:1: expr_list[arg_type_list, min_argc, max_argc] returns [arg_cnt] : ( expr[arg_type] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )* | );
1028
+ def expr_list(arg_type_list, min_argc, max_argc)
1029
+ # -> uncomment the next line to manually enable rule tracing
1030
+ # trace_in(__method__, 10)
1031
+ arg_cnt = nil
1032
+
1033
+ begin
1034
+ # at line 297:5: ( expr[arg_type] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )* | )
1035
+ alt_18 = 2
1036
+ alt_18 = @dfa18.predict(@input)
1037
+ case alt_18
1038
+ when 1
1039
+ # at line 297:7: expr[arg_type] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )*
1040
+ @state.following.push(TOKENS_FOLLOWING_expr_IN_expr_list_1542)
1041
+ expr(arg_type)
1042
+ @state.following.pop
1043
+ # --> action
1044
+ arg_cnt += 1
1045
+ # <-- action
1046
+ # at line 298:5: ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )*
1047
+ loop do # decision 17
1048
+ alt_17 = 2
1049
+ look_17_0 = @input.peek(1)
1050
+
1051
+ if (look_17_0.between?(SEMICOLON, COMMA))
1052
+ alt_17 = 1
362
1053
 
363
-
364
- # 98: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 )
365
- alt10 = 7
366
- alt10 = DFA10.predict(self, @input)
367
- case alt10
1054
+ end
1055
+ case alt_17
368
1056
  when 1
369
- # 98:7: TRUE_CONST
370
- match(:TRUE_CONST)
371
-
372
- @rpn += [PTGBOOL, 1].pack("C2")
373
-
374
- when 2
375
- # 102:7: FALSE_CONST
376
- match(:FALSE_CONST)
377
-
378
- @rpn += [PTGBOOL, 0].pack("C2")
379
-
380
- when 3
381
- # 106:7: str_tok= STR_CONST
382
- _str_tok = @input.look_ahead(1)
383
- match(:STR_CONST)
384
-
385
- @rpn += [PTGSTR].pack('C') + upack1(str_tok.text[1, -1]) #TODO
386
-
387
- when 4
388
- # 110:7: int_tok= INT_CONST
389
- _int_tok = @input.look_ahead(1)
390
- match(:INT_CONST)
391
-
392
- int_value = int_tok.text.to_i
393
- if int_value <= 65535
394
- @rpn += [PTGINT, int_value].pack("Cv")
395
- else
396
- @rpn += [PTGNUM, int_value.to_f].pack("CE")
397
- end
398
-
399
- when 5
400
- # 119:7: num_tok= NUM_CONST
401
- _num_tok = @input.look_ahead(1)
402
- match(:NUM_CONST)
1057
+ # at line 299:9: ( SEMICOLON | COMMA ) ( expr[arg_type] | )
1058
+ # --> action
1059
+
1060
+ if arg_cnt < arg_type_list.size
1061
+ arg_type = arg_type_list[arg_cnt]
1062
+ else
1063
+ arg_type = arg_type_list[-1]
1064
+ end
1065
+ if arg_type == "+"
1066
+ arg_type = arg_type_list[-2]
1067
+ end
1068
+
1069
+ # <-- action
1070
+ if @input.peek(1).between?(SEMICOLON, COMMA)
1071
+ @input.consume
1072
+ @state.error_recovery = false
1073
+ else
1074
+ mse = MismatchedSet(nil)
1075
+ raise mse
1076
+ end
1077
+
1078
+
1079
+ # at line 310:13: ( expr[arg_type] | )
1080
+ alt_16 = 2
1081
+ alt_16 = @dfa16.predict(@input)
1082
+ case alt_16
1083
+ when 1
1084
+ # at line 311:19: expr[arg_type]
1085
+ @state.following.push(TOKENS_FOLLOWING_expr_IN_expr_list_1611)
1086
+ expr(arg_type)
1087
+ @state.following.pop
1088
+
1089
+ when 2
1090
+ # at line 312:19:
1091
+ # --> action
1092
+ @rpn += [PTGMISSARG].pack("B")
1093
+ # <-- action
1094
+
1095
+ end
1096
+ # --> action
1097
+ arg_cnt += 1
1098
+ # <-- action
1099
+
1100
+ else
1101
+ break # out of loop for decision 17
1102
+ end
1103
+ end # loop for decision 17
403
1104
 
404
- @rpn += [ptgNum, num_tok.text.to_f].pack("CE")
405
-
406
- when 6
407
- # 123:7: ref2d_tok= REF2D
408
- _ref2d_tok = @input.look_ahead(1)
409
- match(:REF2D)
1105
+ when 2
1106
+ # at line 317:5:
410
1107
 
411
- r, c = Utils.cell_to_packed_rowcol(ref2d_tok.text) # TODO
412
- ptg = PTGREFR + RVA_DELTA[arg_type]
413
- @rpn += [ptg, r, c].pack("Cv2")
414
-
415
- when 7
416
- # 129:7: ref2d1_tok= REF2D COLON ref2d2_tok= REF2D
417
- _ref2d1_tok = @input.look_ahead(1)
418
- match(:REF2D)
419
- match(:COLON)
420
- _ref2d2_tok = @input.look_ahead(1)
421
- match(:REF2D)
422
-
423
- r1, c1 = Utils.cell_to_packed_rowcol(ref2d1_tok.text) #TODO
424
- r2, c2 = Utils.cell_to_packed_rowcol(ref2d2_tok.text) #TODO
425
- ptg = PTGAREAR + RVA_DELTA[arg_type]
426
- self.rpn += struct.pack("Cv4", ptg, r1, r2, c1, c2)
427
-
428
1108
  end
1109
+ rescue ANTLR3::Error::RecognitionError => re
1110
+ report_error(re)
1111
+ recover(re)
429
1112
 
1113
+ ensure
1114
+ # -> uncomment the next line to manually enable rule tracing
1115
+ # trace_out(__method__, 10)
430
1116
 
431
-
1117
+ end
1118
+
1119
+ return arg_cnt
432
1120
  end
433
1121
 
434
1122
 
435
- attr_accessor :rpn
436
-
437
-
438
- private
1123
+ # parser rule sheet
1124
+ #
1125
+ # (in ExcelFormula.g)
1126
+ # 319:1: sheet returns [ref] : (sheet_ref_name= NAME | sheet_ref_int= INT_CONST | sheet_ref_quote= QUOTENAME );
1127
+ def sheet
1128
+ # -> uncomment the next line to manually enable rule tracing
1129
+ # trace_in(__method__, 11)
1130
+ ref = nil
1131
+ sheet_ref_name = nil
1132
+ sheet_ref_int = nil
1133
+ sheet_ref_quote = nil
1134
+
1135
+ begin
1136
+ # at line 320:5: (sheet_ref_name= NAME | sheet_ref_int= INT_CONST | sheet_ref_quote= QUOTENAME )
1137
+ alt_19 = 3
1138
+ case look_19 = @input.peek(1)
1139
+ when NAME then alt_19 = 1
1140
+ when INT_CONST then alt_19 = 2
1141
+ when QUOTENAME then alt_19 = 3
1142
+ else
1143
+ nvae = NoViableAlternative("", 19, 0)
1144
+ raise nvae
1145
+ end
1146
+ case alt_19
1147
+ when 1
1148
+ # at line 320:7: sheet_ref_name= NAME
1149
+ sheet_ref_name = match(NAME, TOKENS_FOLLOWING_NAME_IN_sheet_1701)
1150
+ # --> action
1151
+ ref = sheet_ref_name.text
1152
+ # <-- action
1153
+
1154
+ when 2
1155
+ # at line 322:7: sheet_ref_int= INT_CONST
1156
+ sheet_ref_int = match(INT_CONST, TOKENS_FOLLOWING_INT_CONST_IN_sheet_1721)
1157
+ # --> action
1158
+ ref = sheet_ref_int.text
1159
+ # <-- action
1160
+
1161
+ when 3
1162
+ # at line 324:7: sheet_ref_quote= QUOTENAME
1163
+ sheet_ref_quote = match(QUOTENAME, TOKENS_FOLLOWING_QUOTENAME_IN_sheet_1741)
1164
+ # --> action
1165
+ ref = sheet_ref_quote.text[1, len(sheet_ref_quote.text) - 1].replace("''", "'")
1166
+ # <-- action
439
1167
 
440
- class TokenStream
441
- attr_reader :index
1168
+ end
1169
+ rescue ANTLR3::Error::RecognitionError => re
1170
+ report_error(re)
1171
+ recover(re)
442
1172
 
443
- def initialize(input)
444
- @buffer = []
445
- @input = input
446
- @channel = nil
1173
+ ensure
1174
+ # -> uncomment the next line to manually enable rule tracing
1175
+ # trace_out(__method__, 11)
447
1176
 
448
- @index = 0;
449
- end
1177
+ end
1178
+
1179
+ return ref
1180
+ end
450
1181
 
451
- # returns a Token
452
- def look_ahead(pos)
453
- offset = @index + pos - 1
454
1182
 
455
- while @buffer[-1] != :EOF && @buffer.length < offset + 1
456
- token = @input.next_token
457
- if token == :EOF || token.channel == @channel
458
- @buffer << token
459
- end
460
- end
461
1183
 
462
- offset = -1 if offset >= @buffer.length
463
- if offset < @buffer.length
464
- @buffer[offset]
465
- end
1184
+ # - - - - - - - - - - DFA definitions - - - - - - - - - - -
1185
+ class DFA2 < ANTLR3::DFA
1186
+ EOT = unpack(10, -1)
1187
+ EOF = unpack(1, 1, 9, -1)
1188
+ MIN = unpack(1, 4, 9, -1)
1189
+ MAX = unpack(1, 29, 9, -1)
1190
+ ACCEPT = unpack(1, -1, 1, 2, 2, -1, 1, 1, 5, -1)
1191
+ SPECIAL = unpack(10, -1)
1192
+ TRANSITION = [
1193
+ unpack(6, 4, 17, -1, 3, 1),
1194
+ unpack(),
1195
+ unpack(),
1196
+ unpack(),
1197
+ unpack(),
1198
+ unpack(),
1199
+ unpack(),
1200
+ unpack(),
1201
+ unpack(),
1202
+ unpack()
1203
+ ].freeze
1204
+
1205
+ ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z |
1206
+ if a > 0 and z < 0
1207
+ MAX[ i ] %= 0x10000
466
1208
  end
467
-
468
- def mark
469
- @state = { :index => @index }
470
- return 0
1209
+ end
1210
+
1211
+ @decision = 2
1212
+
1213
+
1214
+ def description
1215
+ <<-'__dfa_description__'.strip!
1216
+ ()* loopback of 30:9: ( ( EQ | NE | GT | LT | GE | LE ) prec0_expr[arg_type] )*
1217
+ __dfa_description__
1218
+ end
1219
+ end
1220
+ class DFA3 < ANTLR3::DFA
1221
+ EOT = unpack(11, -1)
1222
+ EOF = unpack(1, 1, 10, -1)
1223
+ MIN = unpack(1, 4, 10, -1)
1224
+ MAX = unpack(1, 29, 10, -1)
1225
+ ACCEPT = unpack(1, -1, 1, 2, 8, -1, 1, 1)
1226
+ SPECIAL = unpack(11, -1)
1227
+ TRANSITION = [
1228
+ unpack(6, 1, 1, 10, 16, -1, 3, 1),
1229
+ unpack(),
1230
+ unpack(),
1231
+ unpack(),
1232
+ unpack(),
1233
+ unpack(),
1234
+ unpack(),
1235
+ unpack(),
1236
+ unpack(),
1237
+ unpack(),
1238
+ unpack()
1239
+ ].freeze
1240
+
1241
+ ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z |
1242
+ if a > 0 and z < 0
1243
+ MAX[ i ] %= 0x10000
471
1244
  end
472
-
473
- def rewind(marker)
474
- @index = @state[:index]
1245
+ end
1246
+
1247
+ @decision = 3
1248
+
1249
+
1250
+ def description
1251
+ <<-'__dfa_description__'.strip!
1252
+ ()* loopback of 46:9: ( ( CONCAT ) prec1_expr[arg_type] )*
1253
+ __dfa_description__
1254
+ end
1255
+ end
1256
+ class DFA5 < ANTLR3::DFA
1257
+ EOT = unpack(13, -1)
1258
+ EOF = unpack(1, 1, 12, -1)
1259
+ MIN = unpack(1, 4, 12, -1)
1260
+ MAX = unpack(1, 29, 12, -1)
1261
+ ACCEPT = unpack(1, -1, 1, 2, 9, -1, 1, 1, 1, -1)
1262
+ SPECIAL = unpack(13, -1)
1263
+ TRANSITION = [
1264
+ unpack(7, 1, 2, 11, 14, -1, 3, 1),
1265
+ unpack(),
1266
+ unpack(),
1267
+ unpack(),
1268
+ unpack(),
1269
+ unpack(),
1270
+ unpack(),
1271
+ unpack(),
1272
+ unpack(),
1273
+ unpack(),
1274
+ unpack(),
1275
+ unpack(),
1276
+ unpack()
1277
+ ].freeze
1278
+
1279
+ ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z |
1280
+ if a > 0 and z < 0
1281
+ MAX[ i ] %= 0x10000
475
1282
  end
476
-
477
- def consume
478
- look_ahead(1) # force a read from the input if necessary
479
- @index = @index + 1
1283
+ end
1284
+
1285
+ @decision = 5
1286
+
1287
+
1288
+ def description
1289
+ <<-'__dfa_description__'.strip!
1290
+ ()* loopback of 56:9: ( ( ADD | SUB ) prec2_expr[arg_type] )*
1291
+ __dfa_description__
1292
+ end
1293
+ end
1294
+ class DFA7 < ANTLR3::DFA
1295
+ EOT = unpack(15, -1)
1296
+ EOF = unpack(1, 1, 14, -1)
1297
+ MIN = unpack(1, 4, 14, -1)
1298
+ MAX = unpack(1, 29, 14, -1)
1299
+ ACCEPT = unpack(1, -1, 1, 2, 11, -1, 1, 1, 1, -1)
1300
+ SPECIAL = unpack(15, -1)
1301
+ TRANSITION = [
1302
+ unpack(9, 1, 2, 13, 12, -1, 3, 1),
1303
+ unpack(),
1304
+ unpack(),
1305
+ unpack(),
1306
+ unpack(),
1307
+ unpack(),
1308
+ unpack(),
1309
+ unpack(),
1310
+ unpack(),
1311
+ unpack(),
1312
+ unpack(),
1313
+ unpack(),
1314
+ unpack(),
1315
+ unpack(),
1316
+ unpack()
1317
+ ].freeze
1318
+
1319
+ ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z |
1320
+ if a > 0 and z < 0
1321
+ MAX[ i ] %= 0x10000
480
1322
  end
1323
+ end
1324
+
1325
+ @decision = 7
1326
+
1327
+
1328
+ def description
1329
+ <<-'__dfa_description__'.strip!
1330
+ ()* loopback of 68:9: ( ( MUL | DIV ) prec3_expr[arg_type] )*
1331
+ __dfa_description__
1332
+ end
481
1333
  end
482
-
483
- def match(token = nil)
484
- if token.nil? || look_ahead(1) == token
485
- @input.consume
486
- @failed = false
487
- return
488
- elsif @backtracking > 0
489
- @failed = true
490
- else
491
- raise "Expected #{token}"
1334
+ class DFA8 < ANTLR3::DFA
1335
+ EOT = unpack(16, -1)
1336
+ EOF = unpack(1, 1, 15, -1)
1337
+ MIN = unpack(1, 4, 15, -1)
1338
+ MAX = unpack(1, 29, 15, -1)
1339
+ ACCEPT = unpack(1, -1, 1, 2, 13, -1, 1, 1)
1340
+ SPECIAL = unpack(16, -1)
1341
+ TRANSITION = [
1342
+ unpack(11, 1, 1, 15, 11, -1, 3, 1),
1343
+ unpack(),
1344
+ unpack(),
1345
+ unpack(),
1346
+ unpack(),
1347
+ unpack(),
1348
+ unpack(),
1349
+ unpack(),
1350
+ unpack(),
1351
+ unpack(),
1352
+ unpack(),
1353
+ unpack(),
1354
+ unpack(),
1355
+ unpack(),
1356
+ unpack(),
1357
+ unpack()
1358
+ ].freeze
1359
+
1360
+ ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z |
1361
+ if a > 0 and z < 0
1362
+ MAX[ i ] %= 0x10000
492
1363
  end
1364
+ end
1365
+
1366
+ @decision = 8
1367
+
1368
+
1369
+ def description
1370
+ <<-'__dfa_description__'.strip!
1371
+ ()* loopback of 79:9: ( ( POWER ) prec5_expr[arg_type] )*
1372
+ __dfa_description__
1373
+ end
493
1374
  end
494
-
495
- def look_ahead(k)
496
- token = @input.look_ahead(k)
497
- if token != :EOF
498
- token = token.token_type
1375
+ class DFA10 < ANTLR3::DFA
1376
+ EOT = unpack(13, -1)
1377
+ EOF = unpack(13, -1)
1378
+ MIN = unpack(1, 12, 12, -1)
1379
+ MAX = unpack(1, 32, 12, -1)
1380
+ ACCEPT = unpack(1, -1, 1, 1, 10, -1, 1, 2)
1381
+ SPECIAL = unpack(13, -1)
1382
+ TRANSITION = [
1383
+ unpack(1, 12, 4, -1, 6, 1, 2, -1, 2, 1, 3, -1, 3, 1),
1384
+ unpack(),
1385
+ unpack(),
1386
+ unpack(),
1387
+ unpack(),
1388
+ unpack(),
1389
+ unpack(),
1390
+ unpack(),
1391
+ unpack(),
1392
+ unpack(),
1393
+ unpack(),
1394
+ unpack(),
1395
+ unpack()
1396
+ ].freeze
1397
+
1398
+ ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z |
1399
+ if a > 0 and z < 0
1400
+ MAX[ i ] %= 0x10000
499
1401
  end
500
-
501
- token
1402
+ end
1403
+
1404
+ @decision = 10
1405
+
1406
+
1407
+ def description
1408
+ <<-'__dfa_description__'.strip!
1409
+ 94:1: prec5_expr[arg_type] : ( primary[arg_type] | SUB primary[arg_type] );
1410
+ __dfa_description__
1411
+ end
1412
+ end
1413
+ class DFA15 < ANTLR3::DFA
1414
+ EOT = unpack(66, -1)
1415
+ EOF = unpack(4, -1, 1, 12, 1, -1, 1, 31, 1, 48, 58, -1)
1416
+ MIN = unpack(1, 17, 3, -1, 1, 4, 1, -1, 2, 4, 58, -1)
1417
+ MAX = unpack(1, 32, 3, -1, 1, 29, 1, -1, 2, 29, 58, -1)
1418
+ ACCEPT = unpack(1, -1, 1, 1, 1, 2, 1, 3, 1, -1, 1, 5, 2, -1, 1, 8,
1419
+ 1, 9, 1, 10, 1, 13, 1, 4, 17, -1, 1, 7, 1, 6, 15,
1420
+ -1, 1, 12, 1, 11, 17, -1)
1421
+ SPECIAL = unpack(66, -1)
1422
+ TRANSITION = [
1423
+ unpack(1, 1, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 2, -1, 1, 9, 1, 11, 3,
1424
+ -1, 1, 10, 1, 7, 1, 8),
1425
+ unpack(),
1426
+ unpack(),
1427
+ unpack(),
1428
+ unpack(13, 12, 6, -1, 2, 8, 2, -1, 3, 12),
1429
+ unpack(),
1430
+ unpack(13, 31, 6, -1, 1, 30, 3, -1, 3, 31),
1431
+ unpack(13, 48, 6, -1, 2, 8, 1, -1, 1, 47, 3, 48),
1432
+ unpack(),
1433
+ unpack(),
1434
+ unpack(),
1435
+ unpack(),
1436
+ unpack(),
1437
+ unpack(),
1438
+ unpack(),
1439
+ unpack(),
1440
+ unpack(),
1441
+ unpack(),
1442
+ unpack(),
1443
+ unpack(),
1444
+ unpack(),
1445
+ unpack(),
1446
+ unpack(),
1447
+ unpack(),
1448
+ unpack(),
1449
+ unpack(),
1450
+ unpack(),
1451
+ unpack(),
1452
+ unpack(),
1453
+ unpack(),
1454
+ unpack(),
1455
+ unpack(),
1456
+ unpack(),
1457
+ unpack(),
1458
+ unpack(),
1459
+ unpack(),
1460
+ unpack(),
1461
+ unpack(),
1462
+ unpack(),
1463
+ unpack(),
1464
+ unpack(),
1465
+ unpack(),
1466
+ unpack(),
1467
+ unpack(),
1468
+ unpack(),
1469
+ unpack(),
1470
+ unpack(),
1471
+ unpack(),
1472
+ unpack(),
1473
+ unpack(),
1474
+ unpack(),
1475
+ unpack(),
1476
+ unpack(),
1477
+ unpack(),
1478
+ unpack(),
1479
+ unpack(),
1480
+ unpack(),
1481
+ unpack(),
1482
+ unpack(),
1483
+ unpack(),
1484
+ unpack(),
1485
+ unpack(),
1486
+ unpack(),
1487
+ unpack(),
1488
+ unpack(),
1489
+ unpack()
1490
+ ].freeze
1491
+
1492
+ ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z |
1493
+ if a > 0 and z < 0
1494
+ MAX[ i ] %= 0x10000
1495
+ end
1496
+ end
1497
+
1498
+ @decision = 15
1499
+
1500
+
1501
+ def description
1502
+ <<-'__dfa_description__'.strip!
1503
+ 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 );
1504
+ __dfa_description__
1505
+ end
1506
+ end
1507
+ class DFA12 < ANTLR3::DFA
1508
+ EOT = unpack(18, -1)
1509
+ EOF = unpack(1, 2, 17, -1)
1510
+ MIN = unpack(1, 4, 17, -1)
1511
+ MAX = unpack(1, 29, 17, -1)
1512
+ ACCEPT = unpack(1, -1, 1, 1, 1, 2, 15, -1)
1513
+ SPECIAL = unpack(18, -1)
1514
+ TRANSITION = [
1515
+ unpack(13, 2, 6, -1, 1, 1, 3, -1, 3, 2),
1516
+ unpack(),
1517
+ unpack(),
1518
+ unpack(),
1519
+ unpack(),
1520
+ unpack(),
1521
+ unpack(),
1522
+ unpack(),
1523
+ unpack(),
1524
+ unpack(),
1525
+ unpack(),
1526
+ unpack(),
1527
+ unpack(),
1528
+ unpack(),
1529
+ unpack(),
1530
+ unpack(),
1531
+ unpack(),
1532
+ unpack()
1533
+ ].freeze
1534
+
1535
+ ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z |
1536
+ if a > 0 and z < 0
1537
+ MAX[ i ] %= 0x10000
1538
+ end
1539
+ end
1540
+
1541
+ @decision = 12
1542
+
1543
+
1544
+ def description
1545
+ <<-'__dfa_description__'.strip!
1546
+ 151:9: ( COLON ref3d_ref2d2= REF2D )?
1547
+ __dfa_description__
1548
+ end
502
1549
  end
1550
+ class DFA13 < ANTLR3::DFA
1551
+ EOT = unpack(15, -1)
1552
+ EOF = unpack(15, -1)
1553
+ MIN = unpack(1, 12, 14, -1)
1554
+ MAX = unpack(1, 32, 14, -1)
1555
+ ACCEPT = unpack(1, -1, 1, 1, 11, -1, 1, 2, 1, -1)
1556
+ SPECIAL = unpack(15, -1)
1557
+ TRANSITION = [
1558
+ unpack(1, 1, 4, -1, 6, 1, 2, -1, 2, 1, 3, 13, 3, 1),
1559
+ unpack(),
1560
+ unpack(),
1561
+ unpack(),
1562
+ unpack(),
1563
+ unpack(),
1564
+ unpack(),
1565
+ unpack(),
1566
+ unpack(),
1567
+ unpack(),
1568
+ unpack(),
1569
+ unpack(),
1570
+ unpack(),
1571
+ unpack(),
1572
+ unpack()
1573
+ ].freeze
1574
+
1575
+ ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z |
1576
+ if a > 0 and z < 0
1577
+ MAX[ i ] %= 0x10000
1578
+ end
1579
+ end
1580
+
1581
+ @decision = 13
1582
+
1583
+
1584
+ def description
1585
+ <<-'__dfa_description__'.strip!
1586
+ 199:17: ( expr[arg_type] | )
1587
+ __dfa_description__
1588
+ end
1589
+ end
1590
+ class DFA18 < ANTLR3::DFA
1591
+ EOT = unpack(14, -1)
1592
+ EOF = unpack(14, -1)
1593
+ MIN = unpack(1, 12, 13, -1)
1594
+ MAX = unpack(1, 32, 13, -1)
1595
+ ACCEPT = unpack(1, -1, 1, 1, 11, -1, 1, 2)
1596
+ SPECIAL = unpack(14, -1)
1597
+ TRANSITION = [
1598
+ unpack(1, 1, 4, -1, 6, 1, 2, -1, 2, 1, 2, -1, 1, 13, 3, 1),
1599
+ unpack(),
1600
+ unpack(),
1601
+ unpack(),
1602
+ unpack(),
1603
+ unpack(),
1604
+ unpack(),
1605
+ unpack(),
1606
+ unpack(),
1607
+ unpack(),
1608
+ unpack(),
1609
+ unpack(),
1610
+ unpack(),
1611
+ unpack()
1612
+ ].freeze
1613
+
1614
+ ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z |
1615
+ if a > 0 and z < 0
1616
+ MAX[ i ] %= 0x10000
1617
+ end
1618
+ end
1619
+
1620
+ @decision = 18
1621
+
1622
+
1623
+ def description
1624
+ <<-'__dfa_description__'.strip!
1625
+ 292:1: expr_list[arg_type_list, min_argc, max_argc] returns [arg_cnt] : ( expr[arg_type] ( ( SEMICOLON | COMMA ) ( expr[arg_type] | ) )* | );
1626
+ __dfa_description__
1627
+ end
1628
+ end
1629
+ class DFA16 < ANTLR3::DFA
1630
+ EOT = unpack(15, -1)
1631
+ EOF = unpack(15, -1)
1632
+ MIN = unpack(1, 12, 14, -1)
1633
+ MAX = unpack(1, 32, 14, -1)
1634
+ ACCEPT = unpack(1, -1, 1, 1, 11, -1, 1, 2, 1, -1)
1635
+ SPECIAL = unpack(15, -1)
1636
+ TRANSITION = [
1637
+ unpack(1, 1, 4, -1, 6, 1, 2, -1, 2, 1, 3, 13, 3, 1),
1638
+ unpack(),
1639
+ unpack(),
1640
+ unpack(),
1641
+ unpack(),
1642
+ unpack(),
1643
+ unpack(),
1644
+ unpack(),
1645
+ unpack(),
1646
+ unpack(),
1647
+ unpack(),
1648
+ unpack(),
1649
+ unpack(),
1650
+ unpack(),
1651
+ unpack()
1652
+ ].freeze
1653
+
1654
+ ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z |
1655
+ if a > 0 and z < 0
1656
+ MAX[ i ] %= 0x10000
1657
+ end
1658
+ end
1659
+
1660
+ @decision = 16
1661
+
1662
+
1663
+ def description
1664
+ <<-'__dfa_description__'.strip!
1665
+ 310:13: ( expr[arg_type] | )
1666
+ __dfa_description__
1667
+ end
1668
+ end
1669
+
1670
+
1671
+ private
503
1672
 
1673
+ def initialize_dfas
1674
+ super rescue nil
1675
+ @dfa2 = DFA2.new(self, 2)
1676
+ @dfa3 = DFA3.new(self, 3)
1677
+ @dfa5 = DFA5.new(self, 5)
1678
+ @dfa7 = DFA7.new(self, 7)
1679
+ @dfa8 = DFA8.new(self, 8)
1680
+ @dfa10 = DFA10.new(self, 10)
1681
+ @dfa15 = DFA15.new(self, 15)
1682
+ @dfa12 = DFA12.new(self, 12)
1683
+ @dfa13 = DFA13.new(self, 13)
1684
+ @dfa18 = DFA18.new(self, 18)
1685
+ @dfa16 = DFA16.new(self, 16)
504
1686
 
505
- class DFA
506
- def initialize(eot, eof, min, max, accept, special, transition)
507
- @eot = eot
508
- @eof = eof
509
- @min = min
510
- @max = max
511
- @accept = accept
512
- @special = special
513
- @transition = transition
514
- end
515
-
516
- def predict(parser, input)
517
- mark = input.mark()
518
- s = 0 # we always start at s0
519
- begin
520
- loop do
521
- special_state = @special[s]
522
- if special_state >= 0
523
- s = parser.special_state_transition(special_state)
524
- input.consume()
525
- next
526
- end
527
-
528
- if @accept[s] >= 1
529
- return @accept[s]
530
- end
531
-
532
- # look for a normal char transition
533
- c = input.look_ahead(1).to_i
534
- if c != :EOF && c >= @min[s] && c <= @max[s]
535
- next_state = @transition[s][c - @min[s]] # move to next state
536
- if next_state < 0
537
- # was in range but not a normal transition
538
- # must check EOT, which is like the else clause.
539
- # eot[s]>=0 indicates that an EOT edge goes to another
540
- # state.
541
- if @eot[s] >= 0 # EOT Transition to accept state?
542
- s = @eot[s]
543
- input.consume()
544
- next
545
- end
546
- raise "No viable alt"
547
- end
548
- s = next_state
549
- input.consume()
550
- next
551
- end
552
- if @eot[s] >= 0 # EOT Transition?
553
- s = @eot[s]
554
- input.consume()
555
- next
556
- end
557
- if c == :EOF && @eof[s] >= 0 # EOF Transition to accept state?
558
- return @accept[@eof[s]]
559
- end
560
-
561
- # not in range and not EOF/EOT, must be invalid symbol
562
- raise "No viable alt"
563
- end
564
- ensure
565
- input.rewind(mark)
566
- end
567
- end
568
- end
569
-
570
- DFA10 = DFA.new(
571
- [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],
572
- [-1,-1,-1,-1,-1,-1,8,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],
573
- [12,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0],
574
- [17,0,0,0,0,0,18,0,0,0,0,0,0,0,0,0,0],
575
- [-1,1,2,3,4,5,-1,7,6,-1,-1,-1,-1,-1,-1,-1,-1],
576
- [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],
577
- [
578
- [1,2,3,4,5,6],
579
- [],
580
- [],
581
- [],
582
- [],
583
- [],
584
- [8,8,8,8,8,8,8,8,-1,-1,-1,-1,-1,-1,7],
585
- [],
586
- [],
587
- [],
588
- [],
589
- [],
590
- [],
591
- [],
592
- [],
593
- [],
594
- []
595
- ])
596
-
597
- def special_state_transition(s)
598
- -1
599
1687
  end
1688
+ TOKENS_FOLLOWING_expr_IN_formula_60 = Set[1]
1689
+ TOKENS_FOLLOWING_prec0_expr_IN_expr_79 = Set[1, 4, 5, 6, 7, 8, 9]
1690
+ TOKENS_FOLLOWING_EQ_IN_expr_124 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
1691
+ TOKENS_FOLLOWING_NE_IN_expr_146 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
1692
+ TOKENS_FOLLOWING_GT_IN_expr_168 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
1693
+ TOKENS_FOLLOWING_LT_IN_expr_190 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
1694
+ TOKENS_FOLLOWING_GE_IN_expr_212 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
1695
+ TOKENS_FOLLOWING_LE_IN_expr_234 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
1696
+ TOKENS_FOLLOWING_prec0_expr_IN_expr_265 = Set[1, 4, 5, 6, 7, 8, 9]
1697
+ TOKENS_FOLLOWING_prec1_expr_IN_prec0_expr_297 = Set[1, 10]
1698
+ TOKENS_FOLLOWING_CONCAT_IN_prec0_expr_340 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
1699
+ TOKENS_FOLLOWING_prec1_expr_IN_prec0_expr_370 = Set[1, 10]
1700
+ TOKENS_FOLLOWING_prec2_expr_IN_prec1_expr_402 = Set[1, 11, 12]
1701
+ TOKENS_FOLLOWING_ADD_IN_prec1_expr_447 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
1702
+ TOKENS_FOLLOWING_SUB_IN_prec1_expr_469 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
1703
+ TOKENS_FOLLOWING_prec2_expr_IN_prec1_expr_499 = Set[1, 11, 12]
1704
+ TOKENS_FOLLOWING_prec3_expr_IN_prec2_expr_532 = Set[1, 13, 14]
1705
+ TOKENS_FOLLOWING_MUL_IN_prec2_expr_577 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
1706
+ TOKENS_FOLLOWING_DIV_IN_prec2_expr_599 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
1707
+ TOKENS_FOLLOWING_prec3_expr_IN_prec2_expr_629 = Set[1, 13, 14]
1708
+ TOKENS_FOLLOWING_prec5_expr_IN_prec3_expr_661 = Set[1, 15]
1709
+ TOKENS_FOLLOWING_POWER_IN_prec3_expr_704 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
1710
+ TOKENS_FOLLOWING_prec5_expr_IN_prec3_expr_734 = Set[1, 15]
1711
+ TOKENS_FOLLOWING_prec5_expr_IN_prec4_expr_766 = Set[1, 16]
1712
+ TOKENS_FOLLOWING_PERCENT_IN_prec4_expr_791 = Set[1]
1713
+ TOKENS_FOLLOWING_primary_IN_prec5_expr_822 = Set[1]
1714
+ TOKENS_FOLLOWING_SUB_IN_prec5_expr_831 = Set[17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
1715
+ TOKENS_FOLLOWING_primary_IN_prec5_expr_833 = Set[1]
1716
+ TOKENS_FOLLOWING_TRUE_CONST_IN_primary_854 = Set[1]
1717
+ TOKENS_FOLLOWING_FALSE_CONST_IN_primary_872 = Set[1]
1718
+ TOKENS_FOLLOWING_STR_CONST_IN_primary_894 = Set[1]
1719
+ TOKENS_FOLLOWING_INT_CONST_IN_primary_916 = Set[1]
1720
+ TOKENS_FOLLOWING_NUM_CONST_IN_primary_934 = Set[1]
1721
+ TOKENS_FOLLOWING_REF2D_IN_primary_956 = Set[1]
1722
+ TOKENS_FOLLOWING_REF2D_IN_primary_978 = Set[23]
1723
+ TOKENS_FOLLOWING_COLON_IN_primary_980 = Set[22]
1724
+ TOKENS_FOLLOWING_REF2D_IN_primary_986 = Set[1]
1725
+ TOKENS_FOLLOWING_sheet_IN_primary_1010 = Set[23, 24]
1726
+ TOKENS_FOLLOWING_COLON_IN_primary_1032 = Set[20, 31, 32]
1727
+ TOKENS_FOLLOWING_sheet_IN_primary_1038 = Set[24]
1728
+ TOKENS_FOLLOWING_BANG_IN_primary_1043 = Set[22]
1729
+ TOKENS_FOLLOWING_REF2D_IN_primary_1047 = Set[1, 23]
1730
+ TOKENS_FOLLOWING_COLON_IN_primary_1069 = Set[22]
1731
+ TOKENS_FOLLOWING_REF2D_IN_primary_1074 = Set[1]
1732
+ TOKENS_FOLLOWING_FUNC_IF_IN_primary_1117 = Set[26]
1733
+ TOKENS_FOLLOWING_LP_IN_primary_1127 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
1734
+ TOKENS_FOLLOWING_expr_IN_primary_1129 = Set[27, 28]
1735
+ TOKENS_FOLLOWING_set_IN_primary_1132 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
1736
+ TOKENS_FOLLOWING_expr_IN_primary_1158 = Set[27, 28]
1737
+ TOKENS_FOLLOWING_set_IN_primary_1161 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
1738
+ TOKENS_FOLLOWING_expr_IN_primary_1187 = Set[29]
1739
+ TOKENS_FOLLOWING_RP_IN_primary_1190 = Set[1]
1740
+ TOKENS_FOLLOWING_FUNC_CHOOSE_IN_primary_1208 = Set[26]
1741
+ TOKENS_FOLLOWING_LP_IN_primary_1228 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
1742
+ TOKENS_FOLLOWING_expr_IN_primary_1230 = Set[27, 28, 29]
1743
+ TOKENS_FOLLOWING_set_IN_primary_1265 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 27, 28, 29, 30, 31, 32]
1744
+ TOKENS_FOLLOWING_expr_IN_primary_1327 = Set[27, 28, 29]
1745
+ TOKENS_FOLLOWING_RP_IN_primary_1405 = Set[1]
1746
+ TOKENS_FOLLOWING_NAME_IN_primary_1427 = Set[1]
1747
+ TOKENS_FOLLOWING_NAME_IN_primary_1449 = Set[26]
1748
+ TOKENS_FOLLOWING_LP_IN_primary_1469 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 29, 30, 31, 32]
1749
+ TOKENS_FOLLOWING_expr_list_IN_primary_1475 = Set[29]
1750
+ TOKENS_FOLLOWING_RP_IN_primary_1478 = Set[1]
1751
+ TOKENS_FOLLOWING_LP_IN_primary_1496 = Set[12, 17, 18, 19, 20, 21, 22, 25, 26, 30, 31, 32]
1752
+ TOKENS_FOLLOWING_expr_IN_primary_1498 = Set[29]
1753
+ TOKENS_FOLLOWING_RP_IN_primary_1501 = Set[1]
1754
+ TOKENS_FOLLOWING_expr_IN_expr_list_1542 = Set[1, 27, 28]
1755
+ TOKENS_FOLLOWING_set_IN_expr_list_1571 = Set[1, 12, 17, 18, 19, 20, 21, 22, 25, 26, 27, 28, 30, 31, 32]
1756
+ TOKENS_FOLLOWING_expr_IN_expr_list_1611 = Set[1, 27, 28]
1757
+ TOKENS_FOLLOWING_NAME_IN_sheet_1701 = Set[1]
1758
+ TOKENS_FOLLOWING_INT_CONST_IN_sheet_1721 = Set[1]
1759
+ TOKENS_FOLLOWING_QUOTENAME_IN_sheet_1741 = Set[1]
1760
+
1761
+ end # class Parser < ANTLR3::Parser
1762
+
1763
+ at_exit { Parser.main(ARGV) } if __FILE__ == $0
1764
+ end
600
1765
 
601
- public :special_state_transition
602
- end