commit
message
[Parser] removing rule index names because it actually doesn't make it easier to read.
author
Ben Vogt <[email protected]>
date
2017-09-01 22:14:13
stats
2 file(s) changed,
785 insertions(+),
810 deletions(-)
files
src/Parser/Parser.ts
tests/SheetFormulaTest.ts
1diff --git a/src/Parser/Parser.ts b/src/Parser/Parser.ts
2index e614c78..bccd719 100644
3--- a/src/Parser/Parser.ts
4+++ b/src/Parser/Parser.ts
5@@ -43,7 +43,6 @@ const HASH_SIGN_RULE = /^(?:[#])/; // rule 35
6 const END_OF_STRING_RULE = /^(?:$)/; // rule 36
7
8
9-
10 // Sequential rules to use when parsing a given input.
11 const RULES = [
12 WHITE_SPACE_RULE,
13@@ -85,47 +84,6 @@ const RULES = [
14 END_OF_STRING_RULE
15 ];
16
17-// While it is unlikely that an index for a given rule will change, initializing them with `indexOf` will allow me to
18-// change their ordering without having to find and replace indexes manually.
19-const WHITE_SPACE_RULE_INDEX = RULES.indexOf(WHITE_SPACE_RULE);
20-const DOUBLE_QUOTES_RULE_INDEX = RULES.indexOf(DOUBLE_QUOTES_RULE);
21-const SINGLE_QUOTES_RULE_INDEX = RULES.indexOf(SINGLE_QUOTES_RULE);
22-const FORMULA_NAME_RULE_INDEX = RULES.indexOf(FORMULA_NAME_RULE);
23-const DATE_RULE_INDEX = RULES.indexOf(DATE_RULE);
24-const TIME_RULE_INDEX = RULES.indexOf(TIME_RULE);
25-const $_A1_CELL_RULE_INDEX = RULES.indexOf($_A1_CELL_RULE);
26-const A1_CELL_RULE_INDEX = RULES.indexOf(A1_CELL_RULE);
27-const FORMULA_NAME_SIMPLE_RULE_INDEX = RULES.indexOf(FORMULA_NAME_SIMPLE_RULE);
28-const VARIABLE_RULE_INDEX = RULES.indexOf(VARIABLE_RULE);
29-const SIMPLE_VARIABLE_RILE_INDEX = RULES.indexOf(SIMPLE_VARIABLE_RILE);
30-const INTEGER_RULE_INDEX = RULES.indexOf(INTEGER_RULE);
31-const OPEN_AND_CLOSE_OF_ARRAY_RULE_INDEX = RULES.indexOf(OPEN_AND_CLOSE_OF_ARRAY_RULE);
32-const DOLLAR_SIGN_RULE_INDEX = RULES.indexOf(DOLLAR_SIGN_RULE);
33-const AMPERSAND_SIGN_RULE_INDEX = RULES.indexOf(AMPERSAND_SIGN_RULE);
34-const SINGLE_WHITESPACE_RULE_INDEX = RULES.indexOf(SINGLE_WHITESPACE_RULE);
35-const PERIOD_RULE_INDEX = RULES.indexOf(PERIOD_RULE);
36-const COLON_RULE_INDEX = RULES.indexOf(COLON_RULE);
37-const SEMI_COLON_RULE_INDEX = RULES.indexOf(SEMI_COLON_RULE);
38-const COMMA_RULE_INDEX = RULES.indexOf(COMMA_RULE);
39-const ASTERISK_RULE_INDEX = RULES.indexOf(ASTERISK_RULE);
40-const FORWARD_SLASH_RULE_INDEX = RULES.indexOf(FORWARD_SLASH_RULE);
41-const MINUS_SIGN_RULE_INDEX = RULES.indexOf(MINUS_SIGN_RULE);
42-const PLUS_SIGN_RULE_INDEX = RULES.indexOf(PLUS_SIGN_RULE);
43-const CARET_SIGN_RULE_INDEX = RULES.indexOf(CARET_SIGN_RULE);
44-const OPEN_PAREN_RULE_INDEX = RULES.indexOf(OPEN_PAREN_RULE);
45-const CLOSE_PAREN_RULE_INDEX = RULES.indexOf(CLOSE_PAREN_RULE);
46-const GREATER_THAN_SIGN_RULE_INDEX = RULES.indexOf(GREATER_THAN_SIGN_RULE);
47-const LESS_THAN_SIGN_RULE_INDEX = RULES.indexOf(LESS_THAN_SIGN_RULE);
48-const NOT_RULE_INDEX = RULES.indexOf(NOT_RULE);
49-const OPEN_DOUBLE_QUOTE_INDEX = RULES.indexOf(OPEN_DOUBLE_QUOTE);
50-const OPEN_SINGLE_QUITE_INDEX = RULES.indexOf(OPEN_SINGLE_QUITE);
51-const EXCLAMATION_POINT_RULE_INDEX = RULES.indexOf(EXCLAMATION_POINT_RULE);
52-const EQUALS_SIGN_RULE_INDEX = RULES.indexOf(EQUALS_SIGN_RULE);
53-const PERCENT_SIGN_RULE_INDEX = RULES.indexOf(PERCENT_SIGN_RULE);
54-const HASH_SIGN_RULE_INDEX = RULES.indexOf(HASH_SIGN_RULE);
55-const END_OF_STRING_RULE_INDEX = RULES.indexOf(END_OF_STRING_RULE);
56-
57-
58 /**
59 * Actions to take when processing tokens one by one. We're always either taking the next token, reducing our current
60 * tokens, or accepting and returning.
61@@ -277,138 +235,138 @@ let Parser = (function () {
62 for (obj = obj || {}, l = k.length; l--; obj[k[l]] = v) {}
63 return obj;
64 };
65- const $V0 = [DOUBLE_QUOTES_RULE_INDEX, DATE_RULE_INDEX];
66- const $V1 = [DOUBLE_QUOTES_RULE_INDEX, TIME_RULE_INDEX];
67- const $V2 = [DOUBLE_QUOTES_RULE_INDEX, A1_CELL_RULE_INDEX];
68- const $V3 = [DOUBLE_QUOTES_RULE_INDEX, SIMPLE_VARIABLE_RILE_INDEX];
69- const $V4 = [DOUBLE_QUOTES_RULE_INDEX, FORMULA_NAME_SIMPLE_RULE_INDEX];
70- const $V5 = [DOUBLE_QUOTES_RULE_INDEX, VARIABLE_RULE_INDEX];
71- const $V6 = [DOUBLE_QUOTES_RULE_INDEX, INTEGER_RULE_INDEX];
72- const $V7 = [DOUBLE_QUOTES_RULE_INDEX, PERIOD_RULE_INDEX];
73- const $V8 = [DOUBLE_QUOTES_RULE_INDEX, COLON_RULE_INDEX];
74- const $V9 = [DOUBLE_QUOTES_RULE_INDEX, AMPERSAND_SIGN_RULE_INDEX];
75- const $Va = [DOUBLE_QUOTES_RULE_INDEX, SINGLE_WHITESPACE_RULE_INDEX];
76- const $Vb = [DOUBLE_QUOTES_RULE_INDEX, SEMI_COLON_RULE_INDEX];
77- const $Vc = [DOUBLE_QUOTES_RULE_INDEX, ASTERISK_RULE_INDEX];
78- const $Vd = [DOUBLE_QUOTES_RULE_INDEX, FORWARD_SLASH_RULE_INDEX];
79- const $Ve = [DOUBLE_QUOTES_RULE_INDEX, MINUS_SIGN_RULE_INDEX];
80- const $Vf = [DOUBLE_QUOTES_RULE_INDEX, PLUS_SIGN_RULE_INDEX];
81- const $Vg = [DOUBLE_QUOTES_RULE_INDEX, CARET_SIGN_RULE_INDEX];
82- const $Vh = [DOUBLE_QUOTES_RULE_INDEX, OPEN_PAREN_RULE_INDEX];
83- const $Vi = [DOUBLE_QUOTES_RULE_INDEX, CLOSE_PAREN_RULE_INDEX];
84- const $Vj = [DOUBLE_QUOTES_RULE_INDEX, GREATER_THAN_SIGN_RULE_INDEX];
85- const $Vk = [DOUBLE_QUOTES_RULE_INDEX, LESS_THAN_SIGN_RULE_INDEX];
86- const $Vl = [DOUBLE_QUOTES_RULE_INDEX, NOT_RULE_INDEX];
87+ const $V0 = [1, 4];
88+ const $V1 = [1, 5];
89+ const $V2 = [1, 7];
90+ const $V3 = [1, 10];
91+ const $V4 = [1, 8];
92+ const $V5 = [1, 9];
93+ const $V6 = [1, 11];
94+ const $V7 = [1, 16];
95+ const $V8 = [1, 17];
96+ const $V9 = [1, 14];
97+ const $Va = [1, 15];
98+ const $Vb = [1, 18];
99+ const $Vc = [1, 20];
100+ const $Vd = [1, 21];
101+ const $Ve = [1, 22];
102+ const $Vf = [1, 23];
103+ const $Vg = [1, 24];
104+ const $Vh = [1, 25];
105+ const $Vi = [1, 26];
106+ const $Vj = [1, 27];
107+ const $Vk = [1, 28];
108+ const $Vl = [1, 29];
109 const $Vm = [
110- TIME_RULE_INDEX,
111- INTEGER_RULE_INDEX,
112- OPEN_AND_CLOSE_OF_ARRAY_RULE_INDEX,
113- DOLLAR_SIGN_RULE_INDEX,
114- SINGLE_WHITESPACE_RULE_INDEX,
115- PERIOD_RULE_INDEX,
116- COLON_RULE_INDEX,
117- SEMI_COLON_RULE_INDEX,
118- COMMA_RULE_INDEX,
119- ASTERISK_RULE_INDEX,
120- FORWARD_SLASH_RULE_INDEX,
121- MINUS_SIGN_RULE_INDEX,
122- OPEN_DOUBLE_QUOTE_INDEX,
123- OPEN_SINGLE_QUITE_INDEX
124+ 5,
125+ 11,
126+ 12,
127+ 13,
128+ 15,
129+ 16,
130+ 17,
131+ 18,
132+ 19,
133+ 20,
134+ 21,
135+ 22,
136+ 30,
137+ 31
138 ];
139 const $Vn = [
140- TIME_RULE_INDEX,
141- INTEGER_RULE_INDEX,
142- OPEN_AND_CLOSE_OF_ARRAY_RULE_INDEX,
143- DOLLAR_SIGN_RULE_INDEX,
144- SINGLE_WHITESPACE_RULE_INDEX,
145- PERIOD_RULE_INDEX,
146- COLON_RULE_INDEX,
147- SEMI_COLON_RULE_INDEX,
148- COMMA_RULE_INDEX,
149- ASTERISK_RULE_INDEX,
150- FORWARD_SLASH_RULE_INDEX,
151- MINUS_SIGN_RULE_INDEX,
152- OPEN_DOUBLE_QUOTE_INDEX,
153- OPEN_SINGLE_QUITE_INDEX,
154- EQUALS_SIGN_RULE_INDEX
155+ 5,
156+ 11,
157+ 12,
158+ 13,
159+ 15,
160+ 16,
161+ 17,
162+ 18,
163+ 19,
164+ 20,
165+ 21,
166+ 22,
167+ 30,
168+ 31,
169+ 33
170 ];
171- const $Vo = [DOUBLE_QUOTES_RULE_INDEX, 38]; // index 38?
172+ const $Vo = [1, 38]; // index 38?
173 const $Vp = [
174- TIME_RULE_INDEX,
175- INTEGER_RULE_INDEX,
176- OPEN_AND_CLOSE_OF_ARRAY_RULE_INDEX,
177- DOLLAR_SIGN_RULE_INDEX,
178- SINGLE_WHITESPACE_RULE_INDEX,
179- PERIOD_RULE_INDEX,
180- COLON_RULE_INDEX,
181- SEMI_COLON_RULE_INDEX,
182- COMMA_RULE_INDEX,
183- ASTERISK_RULE_INDEX,
184- FORWARD_SLASH_RULE_INDEX,
185- MINUS_SIGN_RULE_INDEX,
186- OPEN_DOUBLE_QUOTE_INDEX,
187- OPEN_SINGLE_QUITE_INDEX,
188- HASH_SIGN_RULE_INDEX,
189+ 5,
190+ 11,
191+ 12,
192+ 13,
193+ 15,
194+ 16,
195+ 17,
196+ 18,
197+ 19,
198+ 20,
199+ 21,
200+ 22,
201+ 30,
202+ 31,
203+ 35,
204 38 // index 38?
205 ];
206 const $Vq = [
207- TIME_RULE_INDEX,
208- OPEN_AND_CLOSE_OF_ARRAY_RULE_INDEX,
209- DOLLAR_SIGN_RULE_INDEX,
210- SINGLE_WHITESPACE_RULE_INDEX,
211- PERIOD_RULE_INDEX,
212- COLON_RULE_INDEX,
213- SEMI_COLON_RULE_INDEX,
214- COMMA_RULE_INDEX,
215- OPEN_DOUBLE_QUOTE_INDEX,
216- OPEN_SINGLE_QUITE_INDEX
217+ 5,
218+ 12,
219+ 13,
220+ 15,
221+ 16,
222+ 17,
223+ 18,
224+ 19,
225+ 30,
226+ 31
227 ];
228 const $Vr = [
229- TIME_RULE_INDEX,
230- OPEN_AND_CLOSE_OF_ARRAY_RULE_INDEX,
231- SINGLE_WHITESPACE_RULE_INDEX,
232- PERIOD_RULE_INDEX,
233- COLON_RULE_INDEX,
234- SEMI_COLON_RULE_INDEX,
235- OPEN_DOUBLE_QUOTE_INDEX,
236- OPEN_SINGLE_QUITE_INDEX
237+ 5,
238+ 12,
239+ 15,
240+ 16,
241+ 17,
242+ 18,
243+ 30,
244+ 31
245 ];
246 const $Vs = [
247- TIME_RULE_INDEX,
248- OPEN_AND_CLOSE_OF_ARRAY_RULE_INDEX,
249- DOLLAR_SIGN_RULE_INDEX,
250- SINGLE_WHITESPACE_RULE_INDEX,
251- PERIOD_RULE_INDEX,
252- COLON_RULE_INDEX,
253- SEMI_COLON_RULE_INDEX,
254- COMMA_RULE_INDEX,
255- ASTERISK_RULE_INDEX,
256- FORWARD_SLASH_RULE_INDEX,
257- OPEN_DOUBLE_QUOTE_INDEX,
258- OPEN_SINGLE_QUITE_INDEX
259+ 5,
260+ 12,
261+ 13,
262+ 15,
263+ 16,
264+ 17,
265+ 18,
266+ 19,
267+ 20,
268+ 21,
269+ 30,
270+ 31
271 ];
272 const $Vt = [
273- SINGLE_WHITESPACE_RULE_INDEX,
274- OPEN_DOUBLE_QUOTE_INDEX,
275- OPEN_SINGLE_QUITE_INDEX
276+ 15,
277+ 30,
278+ 31
279 ];
280 const $Vu = [
281- TIME_RULE_INDEX,
282- INTEGER_RULE_INDEX,
283- OPEN_AND_CLOSE_OF_ARRAY_RULE_INDEX,
284- DOLLAR_SIGN_RULE_INDEX,
285- SINGLE_WHITESPACE_RULE_INDEX,
286- PERIOD_RULE_INDEX,
287- COLON_RULE_INDEX,
288- SEMI_COLON_RULE_INDEX,
289- COMMA_RULE_INDEX,
290- ASTERISK_RULE_INDEX,
291- FORWARD_SLASH_RULE_INDEX,
292- MINUS_SIGN_RULE_INDEX,
293- OPEN_DOUBLE_QUOTE_INDEX,
294- OPEN_SINGLE_QUITE_INDEX,
295- EXCLAMATION_POINT_RULE_INDEX,
296- END_OF_STRING_RULE_INDEX
297+ 5,
298+ 11,
299+ 12,
300+ 13,
301+ 15,
302+ 16,
303+ 17,
304+ 18,
305+ 19,
306+ 20,
307+ 21,
308+ 22,
309+ 30,
310+ 31,
311+ 32,
312+ 36
313 ];
314 let parser = {
315 lexer: undefined,
316@@ -648,498 +606,498 @@ let Parser = (function () {
317 */
318 table: [
319 ObjectFromPairs.of([
320- SINGLE_QUOTES_RULE_INDEX, 13,
321- FORMULA_NAME_RULE_INDEX, 1,
322- DATE_RULE_INDEX, 2,
323- $_A1_CELL_RULE_INDEX, 3,
324- A1_CELL_RULE_INDEX, $V0,
325- FORMULA_NAME_SIMPLE_RULE_INDEX, $V1,
326- VARIABLE_RULE_INDEX, 6,
327- SIMPLE_VARIABLE_RILE_INDEX, $V2,
328- DOLLAR_SIGN_RULE_INDEX, $V3,
329- AMPERSAND_SIGN_RULE_INDEX, $V4,
330- COMMA_RULE_INDEX, $V5,
331- PLUS_SIGN_RULE_INDEX, $V6,
332- OPEN_PAREN_RULE_INDEX, 12,
333- CLOSE_PAREN_RULE_INDEX, $V7,
334- LESS_THAN_SIGN_RULE_INDEX, $V8,
335- EXCLAMATION_POINT_RULE_INDEX, $V9,
336- PERCENT_SIGN_RULE_INDEX, $Va,
337- END_OF_STRING_RULE_INDEX, $Vb
338+ 2, 13,
339+ 3, 1,
340+ 4, 2,
341+ 6, 3,
342+ 7, $V0,
343+ 8, $V1,
344+ 9, 6,
345+ 10, $V2,
346+ 13, $V3,
347+ 14, $V4,
348+ 19, $V5,
349+ 23, $V6,
350+ 25, 12,
351+ 26, $V7,
352+ 28, $V8,
353+ 32, $V9,
354+ 34, $Va,
355+ 36, $Vb
356 ]),
357 ObjectFromPairs.of([
358- DOUBLE_QUOTES_RULE_INDEX, [3]
359+ 1, [3]
360 ]),
361 ObjectFromPairs.of([
362- TIME_RULE_INDEX, [LexActions.SHIFT, 19],
363- INTEGER_RULE_INDEX, $Vc,
364- OPEN_AND_CLOSE_OF_ARRAY_RULE_INDEX, $Vd,
365- DOLLAR_SIGN_RULE_INDEX, $Ve,
366- PERIOD_RULE_INDEX, $Vf,
367- COLON_RULE_INDEX, $Vg,
368- SEMI_COLON_RULE_INDEX, $Vh,
369- COMMA_RULE_INDEX, $Vi,
370- ASTERISK_RULE_INDEX, $Vj,
371- FORWARD_SLASH_RULE_INDEX, $Vk,
372- MINUS_SIGN_RULE_INDEX, $Vl
373+ 5, [LexActions.SHIFT, 19],
374+ 11, $Vc,
375+ 12, $Vd,
376+ 13, $Ve,
377+ 16, $Vf,
378+ 17, $Vg,
379+ 18, $Vh,
380+ 19, $Vi,
381+ 20, $Vj,
382+ 21, $Vk,
383+ 22, $Vl
384 ]),
385- extendRules($Vm, [LexActions.REDUCE, 2], ObjectFromPairs.of([EQUALS_SIGN_RULE_INDEX, [LexActions.SHIFT, 30]])),
386+ extendRules($Vm, [LexActions.REDUCE, 2], ObjectFromPairs.of([33, [LexActions.SHIFT, 30]])),
387 extendRules($Vm, [LexActions.REDUCE, 3]),
388 extendRules($Vm, [LexActions.REDUCE, 4]),
389- extendRules($Vm, [LexActions.REDUCE, 5], ObjectFromPairs.of([HASH_SIGN_RULE_INDEX, [LexActions.SHIFT, 31]])),
390+ extendRules($Vm, [LexActions.REDUCE, 5], ObjectFromPairs.of([35, [LexActions.SHIFT, 31]])),
391 extendRules($Vm, [LexActions.REDUCE, 6]),
392 ObjectFromPairs.of([
393- SINGLE_QUOTES_RULE_INDEX, 13,
394- DATE_RULE_INDEX, 32,
395- $_A1_CELL_RULE_INDEX, 3,
396- A1_CELL_RULE_INDEX, $V0,
397- FORMULA_NAME_SIMPLE_RULE_INDEX, $V1,
398- VARIABLE_RULE_INDEX, 6,
399- SIMPLE_VARIABLE_RILE_INDEX, $V2,
400- DOLLAR_SIGN_RULE_INDEX, $V3,
401- AMPERSAND_SIGN_RULE_INDEX, $V4,
402- COMMA_RULE_INDEX, $V5,
403- PLUS_SIGN_RULE_INDEX, $V6,
404- OPEN_PAREN_RULE_INDEX, 12,
405- CLOSE_PAREN_RULE_INDEX, $V7,
406- LESS_THAN_SIGN_RULE_INDEX, $V8,
407- EXCLAMATION_POINT_RULE_INDEX, $V9,
408- PERCENT_SIGN_RULE_INDEX, $Va,
409- END_OF_STRING_RULE_INDEX, $Vb
410+ 2, 13,
411+ 4, 32,
412+ 6, 3,
413+ 7, $V0,
414+ 8, $V1,
415+ 9, 6,
416+ 10, $V2,
417+ 13, $V3,
418+ 14, $V4,
419+ 19, $V5,
420+ 23, $V6,
421+ 25, 12,
422+ 26, $V7,
423+ 28, $V8,
424+ 32, $V9,
425+ 34, $Va,
426+ 36, $Vb
427 ]),
428 ObjectFromPairs.of([
429- SINGLE_QUOTES_RULE_INDEX, 13,
430- DATE_RULE_INDEX, 33,
431- $_A1_CELL_RULE_INDEX, 3,
432- A1_CELL_RULE_INDEX, $V0,
433- FORMULA_NAME_SIMPLE_RULE_INDEX, $V1,
434- VARIABLE_RULE_INDEX, 6,
435- SIMPLE_VARIABLE_RILE_INDEX, $V2,
436- DOLLAR_SIGN_RULE_INDEX, $V3,
437- AMPERSAND_SIGN_RULE_INDEX, $V4,
438- COMMA_RULE_INDEX, $V5,
439- PLUS_SIGN_RULE_INDEX, $V6,
440- OPEN_PAREN_RULE_INDEX, 12,
441- CLOSE_PAREN_RULE_INDEX, $V7,
442- LESS_THAN_SIGN_RULE_INDEX, $V8,
443- EXCLAMATION_POINT_RULE_INDEX, $V9,
444- PERCENT_SIGN_RULE_INDEX, $Va,
445- END_OF_STRING_RULE_INDEX, $Vb
446+ 2, 13,
447+ 4, 33,
448+ 6, 3,
449+ 7, $V0,
450+ 8, $V1,
451+ 9, 6,
452+ 10, $V2,
453+ 13, $V3,
454+ 14, $V4,
455+ 19, $V5,
456+ 23, $V6,
457+ 25, 12,
458+ 26, $V7,
459+ 28, $V8,
460+ 32, $V9,
461+ 34, $Va,
462+ 36, $Vb
463 ]),
464 ObjectFromPairs.of([
465- SINGLE_QUOTES_RULE_INDEX, 13,
466- DATE_RULE_INDEX, 34,
467- $_A1_CELL_RULE_INDEX, 3,
468- A1_CELL_RULE_INDEX, $V0,
469- FORMULA_NAME_SIMPLE_RULE_INDEX, $V1,
470- VARIABLE_RULE_INDEX, 6,
471- SIMPLE_VARIABLE_RILE_INDEX, $V2,
472- DOLLAR_SIGN_RULE_INDEX, $V3,
473- AMPERSAND_SIGN_RULE_INDEX, $V4,
474- COMMA_RULE_INDEX, $V5,
475- PLUS_SIGN_RULE_INDEX, $V6,
476- OPEN_PAREN_RULE_INDEX, 12,
477- CLOSE_PAREN_RULE_INDEX, $V7,
478- LESS_THAN_SIGN_RULE_INDEX, $V8,
479- EXCLAMATION_POINT_RULE_INDEX, $V9,
480- PERCENT_SIGN_RULE_INDEX, $Va,
481- END_OF_STRING_RULE_INDEX, $Vb
482+ 2, 13,
483+ 4, 34,
484+ 6, 3,
485+ 7, $V0,
486+ 8, $V1,
487+ 9, 6,
488+ 10, $V2,
489+ 13, $V3,
490+ 14, $V4,
491+ 19, $V5,
492+ 23, $V6,
493+ 25, 12,
494+ 26, $V7,
495+ 28, $V8,
496+ 32, $V9,
497+ 34, $Va,
498+ 36, $Vb
499 ]),
500 ObjectFromPairs.of([
501- AMPERSAND_SIGN_RULE_INDEX, [LexActions.SHIFT, 35]
502+ 14, [LexActions.SHIFT, 35]
503 ]),
504 extendRules($Vm, [LexActions.REDUCE, 25]),
505 extendRules($Vm, [LexActions.REDUCE, 26], ObjectFromPairs.of([LexActions.REDUCE, 36, 32, [LexActions.SHIFT, 37], 36, $Vb])),
506- extendRules($Vn, [LexActions.REDUCE, 36], ObjectFromPairs.of([END_OF_STRING_RULE_INDEX, $Vo])),
507- extendRules($Vp, [LexActions.REDUCE, 38], ObjectFromPairs.of([EQUALS_SIGN_RULE_INDEX, [LexActions.SHIFT, 39]])),
508- extendRules($Vm, [LexActions.REDUCE, 28], ObjectFromPairs.of([GREATER_THAN_SIGN_RULE_INDEX, [LexActions.SHIFT, 40]])),
509- extendRules($Vm, [LexActions.REDUCE, 30], ObjectFromPairs.of([GREATER_THAN_SIGN_RULE_INDEX, [LexActions.SHIFT, 41]])),
510- ObjectFromPairs.of([EXCLAMATION_POINT_RULE_INDEX, [LexActions.SHIFT, 42]]),
511- ObjectFromPairs.of([DOUBLE_QUOTES_RULE_INDEX, [LexActions.ACCEPT, 1]]),
512+ extendRules($Vn, [LexActions.REDUCE, 36], ObjectFromPairs.of([36, $Vo])),
513+ extendRules($Vp, [LexActions.REDUCE, 38], ObjectFromPairs.of([33, [LexActions.SHIFT, 39]])),
514+ extendRules($Vm, [LexActions.REDUCE, 28], ObjectFromPairs.of([27, [LexActions.SHIFT, 40]])),
515+ extendRules($Vm, [LexActions.REDUCE, 30], ObjectFromPairs.of([27, [LexActions.SHIFT, 41]])),
516+ ObjectFromPairs.of([32, [LexActions.SHIFT, 42]]),
517+ ObjectFromPairs.of([1, [LexActions.ACCEPT, 1]]),
518 ObjectFromPairs.of([
519- SINGLE_QUOTES_RULE_INDEX, 13,
520- DATE_RULE_INDEX, 43,
521- $_A1_CELL_RULE_INDEX, 3,
522- A1_CELL_RULE_INDEX, $V0,
523- FORMULA_NAME_SIMPLE_RULE_INDEX, $V1,
524- VARIABLE_RULE_INDEX, 6,
525- SIMPLE_VARIABLE_RILE_INDEX, $V2,
526- DOLLAR_SIGN_RULE_INDEX, $V3,
527- AMPERSAND_SIGN_RULE_INDEX, $V4,
528- COMMA_RULE_INDEX, $V5,
529- PLUS_SIGN_RULE_INDEX, $V6,
530- OPEN_PAREN_RULE_INDEX, 12,
531- CLOSE_PAREN_RULE_INDEX, $V7,
532- LESS_THAN_SIGN_RULE_INDEX, $V8,
533- EXCLAMATION_POINT_RULE_INDEX, $V9,
534- PERCENT_SIGN_RULE_INDEX, $Va,
535- END_OF_STRING_RULE_INDEX, $Vb
536+ 2, 13,
537+ 4, 43,
538+ 6, 3,
539+ 7, $V0,
540+ 8, $V1,
541+ 9, 6,
542+ 10, $V2,
543+ 13, $V3,
544+ 14, $V4,
545+ 19, $V5,
546+ 23, $V6,
547+ 25, 12,
548+ 26, $V7,
549+ 28, $V8,
550+ 32, $V9,
551+ 34, $Va,
552+ 36, $Vb
553 ]),
554 ObjectFromPairs.of([
555- SINGLE_QUOTES_RULE_INDEX, 13,
556- DATE_RULE_INDEX, 44,
557- $_A1_CELL_RULE_INDEX, 3,
558- A1_CELL_RULE_INDEX, $V0,
559- FORMULA_NAME_SIMPLE_RULE_INDEX, $V1,
560- VARIABLE_RULE_INDEX, 6,
561- SIMPLE_VARIABLE_RILE_INDEX, $V2,
562- DOLLAR_SIGN_RULE_INDEX, $V3,
563- AMPERSAND_SIGN_RULE_INDEX, $V4,
564- COMMA_RULE_INDEX, $V5,
565- PLUS_SIGN_RULE_INDEX, $V6,
566- OPEN_PAREN_RULE_INDEX, 12,
567- CLOSE_PAREN_RULE_INDEX, $V7,
568- LESS_THAN_SIGN_RULE_INDEX, $V8,
569- EXCLAMATION_POINT_RULE_INDEX, $V9,
570- PERCENT_SIGN_RULE_INDEX, $Va,
571- END_OF_STRING_RULE_INDEX, $Vb
572+ 2, 13,
573+ 4, 44,
574+ 6, 3,
575+ 7, $V0,
576+ 8, $V1,
577+ 9, 6,
578+ 10, $V2,
579+ 13, $V3,
580+ 14, $V4,
581+ 19, $V5,
582+ 23, $V6,
583+ 25, 12,
584+ 26, $V7,
585+ 28, $V8,
586+ 32, $V9,
587+ 34, $Va,
588+ 36, $Vb
589 ]),
590 ObjectFromPairs.of([
591- SINGLE_QUOTES_RULE_INDEX, 13,
592- DATE_RULE_INDEX, 45,
593- $_A1_CELL_RULE_INDEX, 3,
594- A1_CELL_RULE_INDEX, $V0,
595- FORMULA_NAME_SIMPLE_RULE_INDEX, $V1,
596- VARIABLE_RULE_INDEX, 6,
597- SIMPLE_VARIABLE_RILE_INDEX, $V2,
598- DOLLAR_SIGN_RULE_INDEX, $V3,
599- AMPERSAND_SIGN_RULE_INDEX, $V4,
600- COMMA_RULE_INDEX, $V5,
601- PLUS_SIGN_RULE_INDEX, $V6,
602- OPEN_PAREN_RULE_INDEX, 12,
603- CLOSE_PAREN_RULE_INDEX, $V7,
604- LESS_THAN_SIGN_RULE_INDEX, $V8,
605- EXCLAMATION_POINT_RULE_INDEX, $V9,
606- PERCENT_SIGN_RULE_INDEX, $Va,
607- END_OF_STRING_RULE_INDEX, $Vb
608+ 2, 13,
609+ 4, 45,
610+ 6, 3,
611+ 7, $V0,
612+ 8, $V1,
613+ 9, 6,
614+ 10, $V2,
615+ 13, $V3,
616+ 14, $V4,
617+ 19, $V5,
618+ 23, $V6,
619+ 25, 12,
620+ 26, $V7,
621+ 28, $V8,
622+ 32, $V9,
623+ 34, $Va,
624+ 36, $Vb
625 ]),
626 ObjectFromPairs.of([
627- SINGLE_QUOTES_RULE_INDEX, 13,
628- DATE_RULE_INDEX, 48,
629- $_A1_CELL_RULE_INDEX, 3,
630- A1_CELL_RULE_INDEX, $V0,
631- FORMULA_NAME_SIMPLE_RULE_INDEX, $V1,
632- VARIABLE_RULE_INDEX, 6,
633- SIMPLE_VARIABLE_RILE_INDEX, $V2,
634- OPEN_AND_CLOSE_OF_ARRAY_RULE_INDEX, [1, 46],
635- DOLLAR_SIGN_RULE_INDEX, $V3,
636- AMPERSAND_SIGN_RULE_INDEX, $V4,
637- COLON_RULE_INDEX, [1, 47],
638- COMMA_RULE_INDEX, $V5,
639- PLUS_SIGN_RULE_INDEX, $V6,
640- OPEN_PAREN_RULE_INDEX, 12,
641- CLOSE_PAREN_RULE_INDEX, $V7,
642- LESS_THAN_SIGN_RULE_INDEX, $V8,
643- EXCLAMATION_POINT_RULE_INDEX, $V9,
644- PERCENT_SIGN_RULE_INDEX, $Va,
645- END_OF_STRING_RULE_INDEX, $Vb
646+ 2, 13,
647+ 4, 48,
648+ 6, 3,
649+ 7, $V0,
650+ 8, $V1,
651+ 9, 6,
652+ 10, $V2,
653+ 12, [1, 46],
654+ 13, $V3,
655+ 14, $V4,
656+ 17, [1, 47],
657+ 19, $V5,
658+ 23, $V6,
659+ 25, 12,
660+ 26, $V7,
661+ 28, $V8,
662+ 32, $V9,
663+ 34, $Va,
664+ 36, $Vb
665 ]),
666 ObjectFromPairs.of([
667- SINGLE_QUOTES_RULE_INDEX, 13,
668- DATE_RULE_INDEX, 50,
669- $_A1_CELL_RULE_INDEX, 3,
670- A1_CELL_RULE_INDEX, $V0,
671- FORMULA_NAME_SIMPLE_RULE_INDEX, $V1,
672- VARIABLE_RULE_INDEX, 6,
673- SIMPLE_VARIABLE_RILE_INDEX, $V2,
674- OPEN_AND_CLOSE_OF_ARRAY_RULE_INDEX, [1, 49],
675- DOLLAR_SIGN_RULE_INDEX, $V3,
676- AMPERSAND_SIGN_RULE_INDEX, $V4,
677- COMMA_RULE_INDEX, $V5,
678- PLUS_SIGN_RULE_INDEX, $V6,
679- OPEN_PAREN_RULE_INDEX, 12,
680- CLOSE_PAREN_RULE_INDEX, $V7,
681- LESS_THAN_SIGN_RULE_INDEX, $V8,
682- EXCLAMATION_POINT_RULE_INDEX, $V9,
683- PERCENT_SIGN_RULE_INDEX, $Va,
684- END_OF_STRING_RULE_INDEX, $Vb
685+ 2, 13,
686+ 4, 50,
687+ 6, 3,
688+ 7, $V0,
689+ 8, $V1,
690+ 9, 6,
691+ 10, $V2,
692+ 12, [1, 49],
693+ 13, $V3,
694+ 14, $V4,
695+ 19, $V5,
696+ 23, $V6,
697+ 25, 12,
698+ 26, $V7,
699+ 28, $V8,
700+ 32, $V9,
701+ 34, $Va,
702+ 36, $Vb
703 ]),
704 ObjectFromPairs.of([
705- SINGLE_QUOTES_RULE_INDEX, 13,
706- DATE_RULE_INDEX, 51,
707- $_A1_CELL_RULE_INDEX, 3,
708- A1_CELL_RULE_INDEX, $V0,
709- FORMULA_NAME_SIMPLE_RULE_INDEX, $V1,
710- VARIABLE_RULE_INDEX, 6,
711- SIMPLE_VARIABLE_RILE_INDEX, $V2,
712- DOLLAR_SIGN_RULE_INDEX, $V3,
713- AMPERSAND_SIGN_RULE_INDEX, $V4,
714- COMMA_RULE_INDEX, $V5,
715- PLUS_SIGN_RULE_INDEX, $V6,
716- OPEN_PAREN_RULE_INDEX, 12,
717- CLOSE_PAREN_RULE_INDEX, $V7,
718- LESS_THAN_SIGN_RULE_INDEX, $V8,
719- EXCLAMATION_POINT_RULE_INDEX, $V9,
720- PERCENT_SIGN_RULE_INDEX, $Va,
721- END_OF_STRING_RULE_INDEX, $Vb
722+ 2, 13,
723+ 4, 51,
724+ 6, 3,
725+ 7, $V0,
726+ 8, $V1,
727+ 9, 6,
728+ 10, $V2,
729+ 13, $V3,
730+ 14, $V4,
731+ 19, $V5,
732+ 23, $V6,
733+ 25, 12,
734+ 26, $V7,
735+ 28, $V8,
736+ 32, $V9,
737+ 34, $Va,
738+ 36, $Vb
739 ]),
740 ObjectFromPairs.of([
741- SINGLE_QUOTES_RULE_INDEX, 13,
742- DATE_RULE_INDEX, 52,
743- $_A1_CELL_RULE_INDEX, 3,
744- A1_CELL_RULE_INDEX, $V0,
745- FORMULA_NAME_SIMPLE_RULE_INDEX, $V1,
746- VARIABLE_RULE_INDEX, 6,
747- SIMPLE_VARIABLE_RILE_INDEX, $V2,
748- DOLLAR_SIGN_RULE_INDEX, $V3,
749- AMPERSAND_SIGN_RULE_INDEX, $V4,
750- COMMA_RULE_INDEX, $V5,
751- PLUS_SIGN_RULE_INDEX, $V6,
752- OPEN_PAREN_RULE_INDEX, 12,
753- CLOSE_PAREN_RULE_INDEX, $V7,
754- LESS_THAN_SIGN_RULE_INDEX, $V8,
755- EXCLAMATION_POINT_RULE_INDEX, $V9,
756- PERCENT_SIGN_RULE_INDEX, $Va,
757- END_OF_STRING_RULE_INDEX, $Vb
758+ 2, 13,
759+ 4, 52,
760+ 6, 3,
761+ 7, $V0,
762+ 8, $V1,
763+ 9, 6,
764+ 10, $V2,
765+ 13, $V3,
766+ 14, $V4,
767+ 19, $V5,
768+ 23, $V6,
769+ 25, 12,
770+ 26, $V7,
771+ 28, $V8,
772+ 32, $V9,
773+ 34, $Va,
774+ 36, $Vb
775 ]),
776 ObjectFromPairs.of([
777- SINGLE_QUOTES_RULE_INDEX, 13,
778- DATE_RULE_INDEX, 53,
779- $_A1_CELL_RULE_INDEX, 3,
780- A1_CELL_RULE_INDEX, $V0,
781- FORMULA_NAME_SIMPLE_RULE_INDEX, $V1,
782- VARIABLE_RULE_INDEX, 6,
783- SIMPLE_VARIABLE_RILE_INDEX, $V2,
784- DOLLAR_SIGN_RULE_INDEX, $V3,
785- AMPERSAND_SIGN_RULE_INDEX, $V4,
786- COMMA_RULE_INDEX, $V5,
787- PLUS_SIGN_RULE_INDEX, $V6,
788- OPEN_PAREN_RULE_INDEX, 12,
789- CLOSE_PAREN_RULE_INDEX, $V7,
790- LESS_THAN_SIGN_RULE_INDEX, $V8,
791- EXCLAMATION_POINT_RULE_INDEX, $V9,
792- PERCENT_SIGN_RULE_INDEX, $Va,
793- END_OF_STRING_RULE_INDEX, $Vb
794+ 2, 13,
795+ 4, 53,
796+ 6, 3,
797+ 7, $V0,
798+ 8, $V1,
799+ 9, 6,
800+ 10, $V2,
801+ 13, $V3,
802+ 14, $V4,
803+ 19, $V5,
804+ 23, $V6,
805+ 25, 12,
806+ 26, $V7,
807+ 28, $V8,
808+ 32, $V9,
809+ 34, $Va,
810+ 36, $Vb
811 ]),
812 ObjectFromPairs.of([
813- SINGLE_QUOTES_RULE_INDEX, 13,
814- DATE_RULE_INDEX, 54,
815- $_A1_CELL_RULE_INDEX, 3,
816- A1_CELL_RULE_INDEX, $V0,
817- FORMULA_NAME_SIMPLE_RULE_INDEX, $V1,
818- VARIABLE_RULE_INDEX, 6,
819- SIMPLE_VARIABLE_RILE_INDEX, $V2,
820- DOLLAR_SIGN_RULE_INDEX, $V3,
821- AMPERSAND_SIGN_RULE_INDEX, $V4,
822- COMMA_RULE_INDEX, $V5,
823- PLUS_SIGN_RULE_INDEX, $V6,
824- OPEN_PAREN_RULE_INDEX, 12,
825- CLOSE_PAREN_RULE_INDEX, $V7,
826- LESS_THAN_SIGN_RULE_INDEX, $V8,
827- EXCLAMATION_POINT_RULE_INDEX, $V9,
828- PERCENT_SIGN_RULE_INDEX, $Va,
829- END_OF_STRING_RULE_INDEX, $Vb
830+ 2, 13,
831+ 4, 54,
832+ 6, 3,
833+ 7, $V0,
834+ 8, $V1,
835+ 9, 6,
836+ 10, $V2,
837+ 13, $V3,
838+ 14, $V4,
839+ 19, $V5,
840+ 23, $V6,
841+ 25, 12,
842+ 26, $V7,
843+ 28, $V8,
844+ 32, $V9,
845+ 34, $Va,
846+ 36, $Vb
847 ]),
848 ObjectFromPairs.of([
849- SINGLE_QUOTES_RULE_INDEX, 13,
850- DATE_RULE_INDEX, 55,
851- $_A1_CELL_RULE_INDEX, 3,
852- A1_CELL_RULE_INDEX, $V0,
853- FORMULA_NAME_SIMPLE_RULE_INDEX, $V1,
854- VARIABLE_RULE_INDEX, 6,
855- SIMPLE_VARIABLE_RILE_INDEX, $V2,
856- DOLLAR_SIGN_RULE_INDEX, $V3,
857- AMPERSAND_SIGN_RULE_INDEX, $V4,
858- COMMA_RULE_INDEX, $V5,
859- PLUS_SIGN_RULE_INDEX, $V6,
860- OPEN_PAREN_RULE_INDEX, 12,
861- CLOSE_PAREN_RULE_INDEX, $V7,
862- LESS_THAN_SIGN_RULE_INDEX, $V8,
863- EXCLAMATION_POINT_RULE_INDEX, $V9,
864- PERCENT_SIGN_RULE_INDEX, $Va,
865- END_OF_STRING_RULE_INDEX, $Vb
866+ 2, 13,
867+ 4, 55,
868+ 6, 3,
869+ 7, $V0,
870+ 8, $V1,
871+ 9, 6,
872+ 10, $V2,
873+ 13, $V3,
874+ 14, $V4,
875+ 19, $V5,
876+ 23, $V6,
877+ 25, 12,
878+ 26, $V7,
879+ 28, $V8,
880+ 32, $V9,
881+ 34, $Va,
882+ 36, $Vb
883 ]),
884 ObjectFromPairs.of([ [LexActions.SHIFT, 56]]),
885 extendRules($Vp, [LexActions.REDUCE, 40]),
886 ObjectFromPairs.of([
887- INTEGER_RULE_INDEX, $Vc,
888- OPEN_AND_CLOSE_OF_ARRAY_RULE_INDEX, $Vd,
889- DOLLAR_SIGN_RULE_INDEX, $Ve,
890- SINGLE_WHITESPACE_RULE_INDEX, [LexActions.SHIFT, 57],
891- PERIOD_RULE_INDEX, $Vf,
892- COLON_RULE_INDEX, $Vg,
893- SEMI_COLON_RULE_INDEX, $Vh,
894- COMMA_RULE_INDEX, $Vi,
895- ASTERISK_RULE_INDEX, $Vj,
896- FORWARD_SLASH_RULE_INDEX, $Vk,
897- MINUS_SIGN_RULE_INDEX, $Vl
898+ 11, $Vc,
899+ 12, $Vd,
900+ 13, $Ve,
901+ 15, [LexActions.SHIFT, 57],
902+ 16, $Vf,
903+ 17, $Vg,
904+ 18, $Vh,
905+ 19, $Vi,
906+ 20, $Vj,
907+ 21, $Vk,
908+ 22, $Vl
909 ]),
910 extendRules($Vq, [LexActions.REDUCE, 21], ObjectFromPairs.of([
911- INTEGER_RULE_INDEX, $Vc,
912- ASTERISK_RULE_INDEX, $Vj,
913- FORWARD_SLASH_RULE_INDEX, $Vk,
914- MINUS_SIGN_RULE_INDEX, $Vl
915+ 11, $Vc,
916+ 20, $Vj,
917+ 21, $Vk,
918+ 22, $Vl
919 ])),
920 extendRules($Vq, [LexActions.REDUCE, 22], ObjectFromPairs.of([
921- INTEGER_RULE_INDEX, $Vc,
922- ASTERISK_RULE_INDEX, $Vj,
923- FORWARD_SLASH_RULE_INDEX, $Vk,
924- MINUS_SIGN_RULE_INDEX, $Vl])
925+ 11, $Vc,
926+ 20, $Vj,
927+ 21, $Vk,
928+ 22, $Vl])
929 ),
930 ObjectFromPairs.of([
931- SINGLE_QUOTES_RULE_INDEX, 13,
932- DATE_RULE_INDEX, 60,
933- $_A1_CELL_RULE_INDEX, 3,
934- A1_CELL_RULE_INDEX, $V0,
935- FORMULA_NAME_SIMPLE_RULE_INDEX, $V1,
936- VARIABLE_RULE_INDEX, 6,
937- SIMPLE_VARIABLE_RILE_INDEX, $V2,
938- DOLLAR_SIGN_RULE_INDEX, $V3,
939- AMPERSAND_SIGN_RULE_INDEX, $V4,
940- SINGLE_WHITESPACE_RULE_INDEX, [1, 58],
941- COMMA_RULE_INDEX, $V5,
942- PLUS_SIGN_RULE_INDEX, $V6,
943- CARET_SIGN_RULE_INDEX, 59,
944- OPEN_PAREN_RULE_INDEX, 12,
945- CLOSE_PAREN_RULE_INDEX, $V7,
946- LESS_THAN_SIGN_RULE_INDEX, $V8,
947- NOT_RULE_INDEX, [1, 61],
948- EXCLAMATION_POINT_RULE_INDEX, $V9,
949- PERCENT_SIGN_RULE_INDEX, $Va,
950- END_OF_STRING_RULE_INDEX, $Vb
951+ 2, 13,
952+ 4, 60,
953+ 6, 3,
954+ 7, $V0,
955+ 8, $V1,
956+ 9, 6,
957+ 10, $V2,
958+ 13, $V3,
959+ 14, $V4,
960+ 15, [1, 58],
961+ 19, $V5,
962+ 23, $V6,
963+ 24, 59,
964+ 25, 12,
965+ 26, $V7,
966+ 28, $V8,
967+ 29, [1, 61],
968+ 32, $V9,
969+ 34, $Va,
970+ 36, $Vb
971 ]),
972 extendRules($Vm, [LexActions.REDUCE, 27]),
973- ObjectFromPairs.of([END_OF_STRING_RULE_INDEX, $Vo]),
974- ObjectFromPairs.of([EXCLAMATION_POINT_RULE_INDEX, [LexActions.SHIFT, 62]]),
975- ObjectFromPairs.of([PERCENT_SIGN_RULE_INDEX, [LexActions.SHIFT, 63]]),
976- ObjectFromPairs.of([CLOSE_PAREN_RULE_INDEX, [LexActions.SHIFT, 64]]),
977- ObjectFromPairs.of([LESS_THAN_SIGN_RULE_INDEX, [LexActions.SHIFT, 65]]),
978+ ObjectFromPairs.of([36, $Vo]),
979+ ObjectFromPairs.of([32, [LexActions.SHIFT, 62]]),
980+ ObjectFromPairs.of([34, [LexActions.SHIFT, 63]]),
981+ ObjectFromPairs.of([26, [LexActions.SHIFT, 64]]),
982+ ObjectFromPairs.of([28, [LexActions.SHIFT, 65]]),
983 ObjectFromPairs.of([37, [LexActions.SHIFT, 66]]),
984 extendRules($Vm, [LexActions.REDUCE, 7]),
985 extendRules([5, 12, 15, 30, 31], [LexActions.REDUCE, 8], ObjectFromPairs.of([
986- INTEGER_RULE_INDEX, $Vc,
987- DOLLAR_SIGN_RULE_INDEX, $Ve,
988- PERIOD_RULE_INDEX, $Vf,
989- COLON_RULE_INDEX, $Vg,
990- SEMI_COLON_RULE_INDEX, $Vh,
991- COMMA_RULE_INDEX, $Vi,
992- ASTERISK_RULE_INDEX, $Vj,
993- FORWARD_SLASH_RULE_INDEX, $Vk,
994- MINUS_SIGN_RULE_INDEX, $Vl
995+ 11, $Vc,
996+ 13, $Ve,
997+ 16, $Vf,
998+ 17, $Vg,
999+ 18, $Vh,
1000+ 19, $Vi,
1001+ 20, $Vj,
1002+ 21, $Vk,
1003+ 22, $Vl
1004 ])),
1005 extendRules($Vq, [LexActions.REDUCE, 9], ObjectFromPairs.of([
1006- INTEGER_RULE_INDEX, $Vc,
1007- ASTERISK_RULE_INDEX, $Vj,
1008- FORWARD_SLASH_RULE_INDEX, $Vk,
1009- MINUS_SIGN_RULE_INDEX, $Vl
1010+ 11, $Vc,
1011+ 20, $Vj,
1012+ 21, $Vk,
1013+ 22, $Vl
1014 ])),
1015 ObjectFromPairs.of([
1016- SINGLE_QUOTES_RULE_INDEX, 13,
1017- DATE_RULE_INDEX, 67,
1018- $_A1_CELL_RULE_INDEX, 3,
1019- A1_CELL_RULE_INDEX, $V0,
1020- FORMULA_NAME_SIMPLE_RULE_INDEX, $V1,
1021- VARIABLE_RULE_INDEX, 6,
1022- SIMPLE_VARIABLE_RILE_INDEX, $V2,
1023- DOLLAR_SIGN_RULE_INDEX, $V3,
1024- AMPERSAND_SIGN_RULE_INDEX, $V4,
1025- COMMA_RULE_INDEX, $V5,
1026- PLUS_SIGN_RULE_INDEX, $V6,
1027- OPEN_PAREN_RULE_INDEX, 12,
1028- CLOSE_PAREN_RULE_INDEX, $V7,
1029- LESS_THAN_SIGN_RULE_INDEX, $V8,
1030- EXCLAMATION_POINT_RULE_INDEX, $V9,
1031- PERCENT_SIGN_RULE_INDEX, $Va,
1032- END_OF_STRING_RULE_INDEX, $Vb
1033+ 2, 13,
1034+ 4, 67,
1035+ 6, 3,
1036+ 7, $V0,
1037+ 8, $V1,
1038+ 9, 6,
1039+ 10, $V2,
1040+ 13, $V3,
1041+ 14, $V4,
1042+ 19, $V5,
1043+ 23, $V6,
1044+ 25, 12,
1045+ 26, $V7,
1046+ 28, $V8,
1047+ 32, $V9,
1048+ 34, $Va,
1049+ 36, $Vb
1050 ]),
1051 ObjectFromPairs.of([
1052- SINGLE_QUOTES_RULE_INDEX, 13,
1053- DATE_RULE_INDEX, 68,
1054- $_A1_CELL_RULE_INDEX, 3,
1055- A1_CELL_RULE_INDEX, $V0,
1056- FORMULA_NAME_SIMPLE_RULE_INDEX, $V1,
1057- VARIABLE_RULE_INDEX, 6,
1058- SIMPLE_VARIABLE_RILE_INDEX, $V2,
1059- DOLLAR_SIGN_RULE_INDEX, $V3,
1060- AMPERSAND_SIGN_RULE_INDEX, $V4,
1061- COMMA_RULE_INDEX, $V5,
1062- PLUS_SIGN_RULE_INDEX, $V6,
1063- OPEN_PAREN_RULE_INDEX, 12,
1064- CLOSE_PAREN_RULE_INDEX, $V7,
1065- LESS_THAN_SIGN_RULE_INDEX, $V8,
1066- EXCLAMATION_POINT_RULE_INDEX, $V9,
1067- PERCENT_SIGN_RULE_INDEX, $Va,
1068- END_OF_STRING_RULE_INDEX, $Vb
1069+ 2, 13,
1070+ 4, 68,
1071+ 6, 3,
1072+ 7, $V0,
1073+ 8, $V1,
1074+ 9, 6,
1075+ 10, $V2,
1076+ 13, $V3,
1077+ 14, $V4,
1078+ 19, $V5,
1079+ 23, $V6,
1080+ 25, 12,
1081+ 26, $V7,
1082+ 28, $V8,
1083+ 32, $V9,
1084+ 34, $Va,
1085+ 36, $Vb
1086 ]),
1087 extendRules($Vr, [LexActions.REDUCE, 16], ObjectFromPairs.of([
1088- INTEGER_RULE_INDEX, $Vc,
1089- DOLLAR_SIGN_RULE_INDEX, $Ve,
1090- COMMA_RULE_INDEX, $Vi,
1091- ASTERISK_RULE_INDEX, $Vj,
1092- FORWARD_SLASH_RULE_INDEX, $Vk,
1093- MINUS_SIGN_RULE_INDEX, $Vl
1094+ 11, $Vc,
1095+ 13, $Ve,
1096+ 19, $Vi,
1097+ 20, $Vj,
1098+ 21, $Vk,
1099+ 22, $Vl
1100 ])),
1101 ObjectFromPairs.of([
1102- SINGLE_QUOTES_RULE_INDEX, 13,
1103- DATE_RULE_INDEX, 69,
1104- $_A1_CELL_RULE_INDEX, 3,
1105- A1_CELL_RULE_INDEX, $V0,
1106- FORMULA_NAME_SIMPLE_RULE_INDEX, $V1,
1107- VARIABLE_RULE_INDEX, 6,
1108- SIMPLE_VARIABLE_RILE_INDEX, $V2,
1109- DOLLAR_SIGN_RULE_INDEX, $V3,
1110- AMPERSAND_SIGN_RULE_INDEX, $V4,
1111- COMMA_RULE_INDEX, $V5,
1112- PLUS_SIGN_RULE_INDEX, $V6,
1113- OPEN_PAREN_RULE_INDEX, 12,
1114- CLOSE_PAREN_RULE_INDEX, $V7,
1115- LESS_THAN_SIGN_RULE_INDEX, $V8,
1116- EXCLAMATION_POINT_RULE_INDEX, $V9,
1117- PERCENT_SIGN_RULE_INDEX, $Va,
1118- END_OF_STRING_RULE_INDEX, $Vb
1119+ 2, 13,
1120+ 4, 69,
1121+ 6, 3,
1122+ 7, $V0,
1123+ 8, $V1,
1124+ 9, 6,
1125+ 10, $V2,
1126+ 13, $V3,
1127+ 14, $V4,
1128+ 19, $V5,
1129+ 23, $V6,
1130+ 25, 12,
1131+ 26, $V7,
1132+ 28, $V8,
1133+ 32, $V9,
1134+ 34, $Va,
1135+ 36, $Vb
1136 ]),
1137- extendRules($Vr, [LexActions.REDUCE, 15], ObjectFromPairs.of([
1138- INTEGER_RULE_INDEX, $Vc,
1139- DOLLAR_SIGN_RULE_INDEX, $Ve,
1140- COMMA_RULE_INDEX, $Vi,
1141- ASTERISK_RULE_INDEX, $Vj,
1142- FORWARD_SLASH_RULE_INDEX, $Vk,
1143- MINUS_SIGN_RULE_INDEX, $Vl
1144+ extendRules($Vr, [LexActions.REDUCE, 15], ObjectFromPairs.of([ //51
1145+ 11, $Vc,
1146+ 13, $Ve,
1147+ 19, $Vi,
1148+ 20, $Vj,
1149+ 21, $Vk,
1150+ 22, $Vl
1151 ])),
1152 extendRules([5, 12, 15, 18, 30, 31], [LexActions.REDUCE, 14], ObjectFromPairs.of([
1153- INTEGER_RULE_INDEX, $Vc,
1154- DOLLAR_SIGN_RULE_INDEX, $Ve,
1155- PERIOD_RULE_INDEX, $Vf,
1156- COLON_RULE_INDEX, $Vg,
1157- COMMA_RULE_INDEX, $Vi,
1158- ASTERISK_RULE_INDEX, $Vj,
1159- FORWARD_SLASH_RULE_INDEX, $Vk,
1160- MINUS_SIGN_RULE_INDEX, $Vl
1161+ 11, $Vc,
1162+ 13, $Ve,
1163+ 16, $Vf,
1164+ 17, $Vg,
1165+ 19, $Vi,
1166+ 20, $Vj,
1167+ 21, $Vk,
1168+ 22, $Vl
1169 ])),
1170 extendRules($Vq, [LexActions.REDUCE, 17], ObjectFromPairs.of([
1171- INTEGER_RULE_INDEX, $Vc,
1172- ASTERISK_RULE_INDEX, $Vj,
1173- FORWARD_SLASH_RULE_INDEX, $Vk,
1174- MINUS_SIGN_RULE_INDEX, $Vl
1175+ 11, $Vc,
1176+ 20, $Vj,
1177+ 21, $Vk,
1178+ 22, $Vl
1179 ])),
1180 extendRules($Vs, [LexActions.REDUCE, 18], ObjectFromPairs.of([
1181- INTEGER_RULE_INDEX, $Vc,
1182- MINUS_SIGN_RULE_INDEX, $Vl
1183+ 11, $Vc,
1184+ 22, $Vl
1185 ])),
1186 extendRules($Vs, [LexActions.REDUCE, 19], ObjectFromPairs.of([
1187- INTEGER_RULE_INDEX, $Vc,
1188- MINUS_SIGN_RULE_INDEX, $Vl
1189+ 11, $Vc,
1190+ 22, $Vl
1191 ])),
1192- extendRules([5, 12, 13, 15, 16, 17, 18, 19, 20, 21, 22, 30, 31], [LexActions.REDUCE, 20], ObjectFromPairs.of([INTEGER_RULE_INDEX, $Vc])),
1193+ extendRules([5, 12, 13, 15, 16, 17, 18, 19, 20, 21, 22, 30, 31], [LexActions.REDUCE, 20], ObjectFromPairs.of([11, $Vc])),
1194 extendRules($Vn, [LexActions.REDUCE, 37]),
1195 extendRules($Vm, [LexActions.REDUCE, 10]),
1196 extendRules($Vm, [LexActions.REDUCE, 23]),
1197 ObjectFromPairs.of([
1198- SINGLE_WHITESPACE_RULE_INDEX, [LexActions.SHIFT, 70],
1199- OPEN_DOUBLE_QUOTE_INDEX, [LexActions.SHIFT, 71],
1200- OPEN_SINGLE_QUITE_INDEX, [LexActions.SHIFT, 72]
1201+ 15, [LexActions.SHIFT, 70],
1202+ 30, [LexActions.SHIFT, 71],
1203+ 31, [LexActions.SHIFT, 72]
1204 ]),
1205 extendRules($Vt, [LexActions.REDUCE, 32], ObjectFromPairs.of([
1206- INTEGER_RULE_INDEX, $Vc,
1207- OPEN_AND_CLOSE_OF_ARRAY_RULE_INDEX, $Vd,
1208- DOLLAR_SIGN_RULE_INDEX, $Ve,
1209- PERIOD_RULE_INDEX, $Vf,
1210- COLON_RULE_INDEX, $Vg,
1211- SEMI_COLON_RULE_INDEX, $Vh,
1212- COMMA_RULE_INDEX, $Vi,
1213- ASTERISK_RULE_INDEX, $Vj,
1214- FORWARD_SLASH_RULE_INDEX, $Vk,
1215- MINUS_SIGN_RULE_INDEX, $Vl
1216+ 11, $Vc,
1217+ 12, $Vd,
1218+ 13, $Ve,
1219+ 16, $Vf,
1220+ 17, $Vg,
1221+ 18, $Vh,
1222+ 19, $Vi,
1223+ 20, $Vj,
1224+ 21, $Vk,
1225+ 22, $Vl
1226 ])),
1227 extendRules($Vt, [LexActions.REDUCE, 33]), ObjectFromPairs.of([
1228 37, [LexActions.SHIFT, 73] // index 37?
1229@@ -1149,97 +1107,99 @@ let Parser = (function () {
1230 extendRules($Vm, [LexActions.REDUCE, 31]),
1231 extendRules($Vu, [LexActions.REDUCE, 41]),
1232 extendRules($Vr, [LexActions.REDUCE, 11], ObjectFromPairs.of([
1233- INTEGER_RULE_INDEX, $Vc,
1234- DOLLAR_SIGN_RULE_INDEX, $Ve,
1235- COMMA_RULE_INDEX, $Vi,
1236- ASTERISK_RULE_INDEX, $Vj,
1237- FORWARD_SLASH_RULE_INDEX, $Vk,
1238- MINUS_SIGN_RULE_INDEX, $Vl
1239+ 11, $Vc,
1240+ 13, $Ve,
1241+ 19, $Vi,
1242+ 20, $Vj,
1243+ 21, $Vk,
1244+ 22, $Vl
1245 ])),
1246 extendRules($Vr, [LexActions.REDUCE, 13], ObjectFromPairs.of([
1247- INTEGER_RULE_INDEX, $Vc,
1248- DOLLAR_SIGN_RULE_INDEX, $Ve,
1249- COMMA_RULE_INDEX, $Vi,
1250- ASTERISK_RULE_INDEX, $Vj,
1251- FORWARD_SLASH_RULE_INDEX, $Vk,
1252- MINUS_SIGN_RULE_INDEX, $Vl
1253+ 11, $Vc,
1254+ 13, $Ve,
1255+ 19, $Vi,
1256+ 20, $Vj,
1257+ 21, $Vk,
1258+ 22, $Vl
1259 ])),
1260 extendRules($Vr, [LexActions.REDUCE, 12], ObjectFromPairs.of([
1261- INTEGER_RULE_INDEX, $Vc,
1262- DOLLAR_SIGN_RULE_INDEX, $Ve,
1263- COMMA_RULE_INDEX, $Vi,
1264- ASTERISK_RULE_INDEX, $Vj,
1265- FORWARD_SLASH_RULE_INDEX, $Vk,
1266- MINUS_SIGN_RULE_INDEX, $Vl
1267+ 11, $Vc,
1268+ 13, $Ve,
1269+ 19, $Vi,
1270+ 20, $Vj,
1271+ 21, $Vk,
1272+ 22, $Vl
1273 ])),
1274 extendRules($Vm, [LexActions.REDUCE, 24]),
1275 ObjectFromPairs.of([
1276- SINGLE_QUOTES_RULE_INDEX, 13,
1277+ 2, 13,
1278 // As far as I can tell, some of these higher values are lazy ways of indicating an out-of-bounds "production"
1279 // index, forcing a default to len=1 when reducing values.
1280- DATE_RULE_INDEX, 74,
1281- $_A1_CELL_RULE_INDEX, 3,
1282- A1_CELL_RULE_INDEX, $V0,
1283- FORMULA_NAME_SIMPLE_RULE_INDEX, $V1,
1284- VARIABLE_RULE_INDEX, 6,
1285- SIMPLE_VARIABLE_RILE_INDEX, $V2,
1286- DOLLAR_SIGN_RULE_INDEX, $V3,
1287- AMPERSAND_SIGN_RULE_INDEX, $V4,
1288- COMMA_RULE_INDEX, $V5,
1289- PLUS_SIGN_RULE_INDEX, $V6,
1290- OPEN_PAREN_RULE_INDEX, 12,
1291- CLOSE_PAREN_RULE_INDEX, $V7,
1292- LESS_THAN_SIGN_RULE_INDEX, $V8,
1293- EXCLAMATION_POINT_RULE_INDEX, $V9,
1294- PERCENT_SIGN_RULE_INDEX, $Va,
1295- END_OF_STRING_RULE_INDEX, $Vb
1296+ 4, 74,
1297+ 6, 3,
1298+ 7, $V0,
1299+ 8, $V1,
1300+ 9, 6,
1301+ 10, $V2,
1302+ 13, $V3,
1303+ 14, $V4,
1304+ 19, $V5,
1305+ 23, $V6,
1306+ 25, 12,
1307+ 26, $V7,
1308+ 28, $V8,
1309+ 32, $V9,
1310+ 34, $Va,
1311+ 36, $Vb,
1312+ 12, $Vd,
1313 ]),
1314 ObjectFromPairs.of([
1315- SINGLE_QUOTES_RULE_INDEX, 13,
1316- DATE_RULE_INDEX, 75,
1317- $_A1_CELL_RULE_INDEX, 3,
1318- A1_CELL_RULE_INDEX, $V0,
1319- FORMULA_NAME_SIMPLE_RULE_INDEX, $V1,
1320- VARIABLE_RULE_INDEX, 6,
1321- SIMPLE_VARIABLE_RILE_INDEX, $V2,
1322- DOLLAR_SIGN_RULE_INDEX, $V3,
1323- AMPERSAND_SIGN_RULE_INDEX, $V4,
1324- COMMA_RULE_INDEX, $V5,
1325- PLUS_SIGN_RULE_INDEX, $V6,
1326- OPEN_PAREN_RULE_INDEX, 12,
1327- CLOSE_PAREN_RULE_INDEX, $V7,
1328- LESS_THAN_SIGN_RULE_INDEX, $V8,
1329- EXCLAMATION_POINT_RULE_INDEX, $V9,
1330- PERCENT_SIGN_RULE_INDEX, $Va,
1331- END_OF_STRING_RULE_INDEX, $Vb
1332+ 2, 13,
1333+ 4, 75,
1334+ 6, 3,
1335+ 7, $V0,
1336+ 8, $V1,
1337+ 9, 6,
1338+ 10, $V2,
1339+ 13, $V3,
1340+ 14, $V4,
1341+ 19, $V5,
1342+ 23, $V6,
1343+ 25, 12,
1344+ 26, $V7,
1345+ 28, $V8,
1346+ 32, $V9,
1347+ 34, $Va,
1348+ 36, $Vb,
1349+ 12, $Vd,
1350 ]),
1351 extendRules($Vu, [LexActions.REDUCE, 42]),
1352 extendRules($Vt, [LexActions.REDUCE, 34], ObjectFromPairs.of([
1353- INTEGER_RULE_INDEX, $Vc,
1354- OPEN_AND_CLOSE_OF_ARRAY_RULE_INDEX, $Vd,
1355- DOLLAR_SIGN_RULE_INDEX, $Ve,
1356- PERIOD_RULE_INDEX, $Vf,
1357- COLON_RULE_INDEX, $Vg,
1358- SEMI_COLON_RULE_INDEX, $Vh,
1359- COMMA_RULE_INDEX, $Vi,
1360- ASTERISK_RULE_INDEX, $Vj,
1361- FORWARD_SLASH_RULE_INDEX, $Vk,
1362- MINUS_SIGN_RULE_INDEX, $Vl
1363+ 11, $Vc,
1364+ 12, $Vd,
1365+ 13, $Ve,
1366+ 16, $Vf,
1367+ 17, $Vg,
1368+ 18, $Vh,
1369+ 19, $Vi,
1370+ 20, $Vj,
1371+ 21, $Vk,
1372+ 22, $Vl
1373 ])),
1374 extendRules($Vt, [LexActions.REDUCE, 35], ObjectFromPairs.of([
1375- INTEGER_RULE_INDEX, $Vc,
1376- OPEN_AND_CLOSE_OF_ARRAY_RULE_INDEX, $Vd,
1377- DOLLAR_SIGN_RULE_INDEX, $Ve,
1378- PERIOD_RULE_INDEX, $Vf,
1379- COLON_RULE_INDEX, $Vg,
1380- SEMI_COLON_RULE_INDEX, $Vh,
1381- COMMA_RULE_INDEX, $Vi,
1382- ASTERISK_RULE_INDEX, $Vj,
1383- FORWARD_SLASH_RULE_INDEX, $Vk,
1384- MINUS_SIGN_RULE_INDEX, $Vl
1385+ 11, $Vc,
1386+ 12, $Vd,
1387+ 13, $Ve,
1388+ 16, $Vf,
1389+ 17, $Vg,
1390+ 18, $Vh,
1391+ 19, $Vi,
1392+ 20, $Vj,
1393+ 21, $Vk,
1394+ 22, $Vl
1395 ]))
1396 ],
1397- defaultActions: ObjectFromPairs.of([COMMA_RULE_INDEX, [LexActions.REDUCE, 1]]),
1398+ defaultActions: ObjectFromPairs.of([19, [LexActions.REDUCE, 1]]),
1399 parseError: function parseError(str, hash) {
1400 if (hash.recoverable) {
1401 this.trace(str);
1402@@ -1373,7 +1333,7 @@ let Parser = (function () {
1403 expected = [];
1404 for (p in table[state]) {
1405 if (this.terminals_[p] && p > TERROR) {
1406- expected.push("'" + this.terminals_[p] + "'");
1407+ expected.push(this.terminals_[p]);
1408 }
1409 }
1410 if (lexer.showPosition) {
1411@@ -1389,6 +1349,7 @@ let Parser = (function () {
1412 line: lexer.yylineno,
1413 loc: yyloc,
1414 expected: expected,
1415+ state: state,
1416 recoverable: (error_rule_depth !== false)
1417 });
1418 } else if (preErrorSymbol !== EOF) {
1419@@ -1812,81 +1773,81 @@ let Parser = (function () {
1420
1421 mapActionToActionIndex: function (ruleIndex) {
1422 switch (ruleIndex) {
1423- case WHITE_SPACE_RULE_INDEX:
1424+ case 0:
1425 // skip whitespace
1426 break;
1427- case DOUBLE_QUOTES_RULE_INDEX:
1428+ case 1:
1429 return ReduceActions.LAST_NUMBER;
1430- case SINGLE_QUOTES_RULE_INDEX:
1431+ case 2:
1432 return ReduceActions.LAST_NUMBER;
1433- case FORMULA_NAME_RULE_INDEX:
1434+ case 3:
1435 return ReduceActions.CALL_FUNCTION_LAST_BLANK;
1436- case DATE_RULE_INDEX:
1437+ case 4:
1438 return ReduceActions.AMPERSAND;
1439- case TIME_RULE_INDEX:
1440+ case 5:
1441 return ReduceActions.EQUALS;
1442- case $_A1_CELL_RULE_INDEX:
1443+ case 6:
1444 return ReduceActions.I26;
1445- case A1_CELL_RULE_INDEX:
1446+ case 7:
1447 return ReduceActions.FIXED_CELL_VAL;
1448- case FORMULA_NAME_SIMPLE_RULE_INDEX:
1449+ case 8:
1450 return ReduceActions.CALL_FUNCTION_LAST_BLANK;
1451- case VARIABLE_RULE_INDEX:
1452+ case 9:
1453 return ReduceActions.ENSURE_IS_ARRAY;
1454- case SIMPLE_VARIABLE_RILE_INDEX:
1455+ case 10:
1456 return ReduceActions.ENSURE_IS_ARRAY;
1457- case INTEGER_RULE_INDEX:
1458+ case 11:
1459 return ReduceActions.REDUCE_INT;
1460- case OPEN_AND_CLOSE_OF_ARRAY_RULE_INDEX:
1461+ case 12:
1462 return ReduceActions.FIXED_CELL_RANGE_VAL;
1463- case DOLLAR_SIGN_RULE_INDEX:
1464+ case 13:
1465 // skip whitespace??
1466 break;
1467- case AMPERSAND_SIGN_RULE_INDEX:
1468+ case 14:
1469 return ReduceActions.LTE;
1470- case SINGLE_WHITESPACE_RULE_INDEX:
1471+ case 15:
1472 return ' ';
1473- case PERIOD_RULE_INDEX:
1474+ case 16:
1475 return ReduceActions.ENSURE_YYTEXT_ARRAY;
1476- case COLON_RULE_INDEX:
1477+ case 17:
1478 return ReduceActions.I27;
1479- case SEMI_COLON_RULE_INDEX:
1480+ case 18:
1481 return ReduceActions.CELL_VALUE;
1482- case COMMA_RULE_INDEX:
1483+ case 19:
1484 return ReduceActions.CELL_RANGE_VALUE;
1485- case ASTERISK_RULE_INDEX:
1486+ case 20:
1487 return ReduceActions.TO_POWER;
1488- case FORWARD_SLASH_RULE_INDEX:
1489+ case 21:
1490 return ReduceActions.INVERT_NUM;
1491- case MINUS_SIGN_RULE_INDEX:
1492+ case 22:
1493 return ReduceActions.DIVIDE;
1494- case PLUS_SIGN_RULE_INDEX:
1495+ case 23:
1496 return ReduceActions.NOT_EQ;
1497- case CARET_SIGN_RULE_INDEX:
1498+ case 24:
1499 return ReduceActions.TO_NUMBER_NAN_AS_ZERO;
1500- case OPEN_PAREN_RULE_INDEX:
1501+ case 25:
1502 return ReduceActions.NOT;
1503- case CLOSE_PAREN_RULE_INDEX:
1504+ case 26:
1505 return ReduceActions.GT;
1506- case GREATER_THAN_SIGN_RULE_INDEX:
1507+ case 27:
1508 return ReduceActions.MINUS;
1509- case LESS_THAN_SIGN_RULE_INDEX:
1510+ case 28:
1511 return ReduceActions.LT;
1512- case NOT_RULE_INDEX:
1513+ case 29:
1514 return ReduceActions.MULTIPLY;
1515- case OPEN_DOUBLE_QUOTE_INDEX:
1516+ case 30:
1517 return '"';
1518- case OPEN_SINGLE_QUITE_INDEX:
1519+ case 31:
1520 return "'";
1521- case EXCLAMATION_POINT_RULE_INDEX:
1522+ case 32:
1523 return "!";
1524- case EQUALS_SIGN_RULE_INDEX:
1525+ case 33:
1526 return ReduceActions.GTE;
1527- case PERCENT_SIGN_RULE_INDEX:
1528+ case 34:
1529 return ReduceActions.REDUCE_PERCENT;
1530- case HASH_SIGN_RULE_INDEX:
1531+ case 35:
1532 return ReduceActions.WRAP_CURRENT_INDEX_TOKEN_AS_ARRAY;
1533- case END_OF_STRING_RULE_INDEX:
1534+ case 36:
1535 return ReduceActions.AS_NUMBER;
1536 }
1537 },
1538diff --git a/tests/SheetFormulaTest.ts b/tests/SheetFormulaTest.ts
1539index c68e037..e1f497b 100644
1540--- a/tests/SheetFormulaTest.ts
1541+++ b/tests/SheetFormulaTest.ts
1542@@ -160,7 +160,7 @@ test("Sheet CONVERT", function(){
1543 });
1544
1545 test("Sheet CORREL", function(){
1546- assertFormulaEquals('=CORREL([9, 5],[10, 4])', 1);
1547+ assertFormulaEquals('=CORREL([9, 5], [10, 4])', 1);
1548 });
1549
1550 test("Sheet CHOOSE", function(){