From 5a5c16b89af6ee6f3cbef2b6ee86c7818b85828b Mon Sep 17 00:00:00 2001 From: Todd Date: Sat, 16 Sep 2017 12:12:55 -0500 Subject: [PATCH] formula: add initial support for cell arrays This is a pretty uncommon feature from what I can tell and is not fully supported. The example for the MDETERM function uses an array though, so this will at least add enough support for the examples to compute correctly. --- spreadsheet/formula/binaryexpr.go | 91 +- spreadsheet/formula/constarrayexpr.go | 32 + spreadsheet/formula/fnsimple.go | 13 + spreadsheet/formula/grammar.go | 196 +- spreadsheet/formula/grammar.y | 21 +- spreadsheet/formula/lexer.go | 3862 +++++++++-------- spreadsheet/formula/lexer.rl | 1 + spreadsheet/formula/result.go | 19 +- spreadsheet/formula/resulttype_string.go | 4 +- .../formula/testdata/formulareference.xlsx | Bin 11763 -> 11925 bytes spreadsheet/mergedcell.go | 2 - spreadsheet/workbook.go | 2 +- 12 files changed, 2291 insertions(+), 1952 deletions(-) create mode 100644 spreadsheet/formula/constarrayexpr.go diff --git a/spreadsheet/formula/binaryexpr.go b/spreadsheet/formula/binaryexpr.go index 9b191c7c..775cd1af 100644 --- a/spreadsheet/formula/binaryexpr.go +++ b/spreadsheet/formula/binaryexpr.go @@ -7,7 +7,10 @@ package formula -import "math" +import ( + "fmt" + "math" +) // BinOpType is the binary operation operator type //go:generate stringer -type=BinOpType @@ -46,6 +49,22 @@ func (b BinaryExpr) Eval(ctx Context, ev Evaluator) Result { lhs := b.lhs.Eval(ctx, ev) rhs := b.rhs.Eval(ctx, ev) + // peel off array/list ops first + if lhs.Type == rhs.Type { + if lhs.Type == ResultTypeArray { + if !sameDim(lhs.ValueArray, rhs.ValueArray) { + return MakeErrorResult("lhs/rhs should have same dimensions") + } + return arrayOp(b.op, lhs.ValueArray, rhs.ValueArray) + } else if lhs.Type == ResultTypeList { + if len(lhs.ValueList) != len(rhs.ValueList) { + return MakeErrorResult("lhs/rhs should have same dimensions") + } + return listOp(b.op, lhs.ValueList, rhs.ValueList) + } + + } + // TODO: check for and add support for binary operators on boolean values switch b.op { case BinOpTypePlus: @@ -128,3 +147,73 @@ func (b BinaryExpr) Eval(ctx Context, ev Evaluator) Result { func (b BinaryExpr) Reference(ctx Context, ev Evaluator) Reference { return ReferenceInvalid } + +// sameDim returns true if the arrays have the same dimensions. +func sameDim(lhs, rhs [][]Result) bool { + if len(lhs) != len(rhs) { + return false + } + for i := range lhs { + if len(lhs[i]) != len(rhs[i]) { + return false + } + } + return true +} + +func arrayOp(op BinOpType, lhs, rhs [][]Result) Result { + // we can assume the arrays are the same size here + res := [][]Result{} + for i := range lhs { + lst := listOp(op, lhs[i], rhs[i]) + if lst.Type == ResultTypeError { + return lst + } + res = append(res, lst.ValueList) + } + return MakeArrayResult(res) +} + +func listOp(op BinOpType, lhs, rhs []Result) Result { + res := []Result{} + // we can assume the arrays are the same size here + for i := range lhs { + l := lhs[i].AsNumber() + r := rhs[i].AsNumber() + if l.Type != ResultTypeNumber || r.Type != ResultTypeNumber { + return MakeErrorResult("non-nunmeric value in binary operation") + } + switch op { + case BinOpTypePlus: + res = append(res, MakeNumberResult(l.ValueNumber+r.ValueNumber)) + case BinOpTypeMinus: + res = append(res, MakeNumberResult(l.ValueNumber-r.ValueNumber)) + case BinOpTypeMult: + res = append(res, MakeNumberResult(l.ValueNumber*r.ValueNumber)) + case BinOpTypeDiv: + if r.ValueNumber == 0 { + return MakeErrorResultType(ErrorTypeDivideByZero, "") + } + res = append(res, MakeNumberResult(l.ValueNumber/r.ValueNumber)) + case BinOpTypeExp: + res = append(res, MakeNumberResult(math.Pow(l.ValueNumber, r.ValueNumber))) + case BinOpTypeLT: + res = append(res, MakeBoolResult(l.ValueNumber < r.ValueNumber)) + case BinOpTypeGT: + res = append(res, MakeBoolResult(l.ValueNumber > r.ValueNumber)) + case BinOpTypeEQ: + res = append(res, MakeBoolResult(l.ValueNumber == r.ValueNumber)) + case BinOpTypeLEQ: + res = append(res, MakeBoolResult(l.ValueNumber <= r.ValueNumber)) + case BinOpTypeGEQ: + res = append(res, MakeBoolResult(l.ValueNumber >= r.ValueNumber)) + case BinOpTypeNE: + res = append(res, MakeBoolResult(l.ValueNumber != r.ValueNumber)) + // TODO: support concat here + // case BinOpTypeConcat: + default: + return MakeErrorResult(fmt.Sprintf("unsupported list binary op %s", op)) + } + } + return MakeListResult(res) +} diff --git a/spreadsheet/formula/constarrayexpr.go b/spreadsheet/formula/constarrayexpr.go new file mode 100644 index 00000000..24ae7936 --- /dev/null +++ b/spreadsheet/formula/constarrayexpr.go @@ -0,0 +1,32 @@ +// Copyright 2017 Baliance. All rights reserved. +// +// Use of this source code is governed by the terms of the Affero GNU General +// Public License version 3.0 as published by the Free Software Foundation and +// appearing in the file LICENSE included in the packaging of this file. A +// commercial license can be purchased by contacting sales@baliance.com. + +package formula + +type ConstArrayExpr struct { + data [][]Expression +} + +func NewConstArrayExpr(data [][]Expression) Expression { + return &ConstArrayExpr{data} +} + +func (c ConstArrayExpr) Eval(ctx Context, ev Evaluator) Result { + res := [][]Result{} + for _, row := range c.data { + r := []Result{} + for _, col := range row { + r = append(r, col.Eval(ctx, ev)) + } + res = append(res, r) + } + return MakeArrayResult(res) +} + +func (c ConstArrayExpr) Reference(ctx Context, ev Evaluator) Reference { + return ReferenceInvalid +} diff --git a/spreadsheet/formula/fnsimple.go b/spreadsheet/formula/fnsimple.go index 9dd1e59d..bcf222a9 100644 --- a/spreadsheet/formula/fnsimple.go +++ b/spreadsheet/formula/fnsimple.go @@ -24,12 +24,25 @@ func Sum(args []Result) Result { // Sum returns zero with no arguments res := MakeNumberResult(0) for _, a := range args { + a = a.AsNumber() switch a.Type { case ResultTypeNumber: res.ValueNumber += a.ValueNumber case ResultTypeList: subSum := Sum(a.ValueList) + // error as sum returns only numbers and errors + if subSum.Type != ResultTypeNumber { + return subSum + } res.ValueNumber += subSum.ValueNumber + case ResultTypeArray: + for _, row := range a.ValueArray { + subSum := Sum(row) + if subSum.Type != ResultTypeNumber { + return subSum + } + res.ValueNumber += subSum.ValueNumber + } case ResultTypeString: // treated as zero by Excel case ResultTypeError: diff --git a/spreadsheet/formula/grammar.go b/spreadsheet/formula/grammar.go index 90af24c3..deaf777d 100644 --- a/spreadsheet/formula/grammar.go +++ b/spreadsheet/formula/grammar.go @@ -14,6 +14,7 @@ type yySymType struct { node *node expr Expression args []Expression + rows [][]Expression } const tokenHorizontalRange = 57346 @@ -45,6 +46,7 @@ const tokenNE = 57371 const tokenColon = 57372 const tokenComma = 57373 const tokenAmpersand = 57374 +const tokenSemi = 57375 var yyToknames = [...]string{ "$end", @@ -79,6 +81,7 @@ var yyToknames = [...]string{ "tokenColon", "tokenComma", "tokenAmpersand", + "tokenSemi", } var yyStatenames = [...]string{} @@ -94,76 +97,82 @@ var yyExca = [...]int{ const yyPrivate = 57344 -const yyLast = 149 +const yyLast = 175 var yyAct = [...]int{ - 3, 26, 27, 28, 62, 36, 28, 38, 39, 41, - 22, 37, 35, 40, 28, 35, 44, 63, 18, 20, - 17, 45, 46, 65, 11, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 64, 59, 42, - 24, 25, 26, 27, 28, 33, 29, 30, 31, 32, - 34, 9, 1, 35, 19, 10, 2, 8, 0, 0, - 0, 0, 61, 0, 66, 60, 24, 25, 26, 27, - 28, 33, 29, 30, 31, 32, 34, 0, 0, 35, - 24, 25, 26, 27, 28, 33, 29, 30, 31, 32, - 34, 0, 0, 35, 24, 25, 26, 27, 28, 0, - 0, 0, 0, 13, 14, 15, 16, 35, 23, 22, - 21, 5, 0, 12, 0, 6, 7, 0, 0, 0, - 4, 13, 14, 15, 16, 0, 23, 22, 21, 0, - 0, 12, 43, 6, 7, 13, 14, 15, 16, 0, - 23, 22, 21, 0, 0, 12, 0, 6, 7, + 3, 41, 18, 9, 70, 37, 29, 43, 44, 42, + 27, 28, 29, 45, 46, 36, 67, 71, 29, 23, + 49, 36, 47, 51, 65, 40, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 13, 19, + 64, 66, 42, 14, 15, 16, 17, 72, 21, 69, + 25, 26, 27, 28, 29, 34, 30, 31, 32, 33, + 35, 50, 75, 36, 11, 1, 20, 10, 73, 2, + 42, 74, 76, 68, 25, 26, 27, 28, 29, 34, + 30, 31, 32, 33, 35, 8, 0, 36, 25, 26, + 27, 28, 29, 34, 30, 31, 32, 33, 35, 0, + 0, 36, 25, 26, 27, 28, 29, 0, 0, 0, + 0, 14, 15, 16, 17, 36, 24, 23, 22, 5, + 0, 12, 0, 6, 7, 0, 0, 0, 4, 14, + 15, 16, 17, 0, 24, 23, 22, 38, 0, 12, + 48, 6, 7, 14, 15, 16, 17, 0, 24, 23, + 22, 38, 0, 12, 0, 6, 7, 14, 15, 16, + 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 39, } var yyPact = [...]int{ - 96, -1000, -1000, 61, 128, -13, 128, 128, -1000, -1000, - -1000, -1000, 128, -1000, -1000, -1000, -1000, -21, -3, -1000, - -1000, 114, -1000, -1000, 128, 128, 128, 128, 128, 128, - 128, 128, 128, 128, 128, 128, 61, 128, -20, -20, - 47, -3, -1000, -1000, -14, -1000, 61, -20, -20, -17, - -17, -1000, 75, 75, 75, 75, 75, 75, -9, 21, - -1000, -1000, -1000, 128, -1000, -1000, 61, + 104, -1000, -1000, 69, 136, 150, 136, 136, -1000, -1000, + -1000, -1000, 136, -1000, -1000, -1000, -1000, -1000, -16, 6, + -1000, -1000, 122, -1000, -1000, 136, 136, 136, 136, 136, + 136, 136, 136, 136, 136, 136, 136, 69, 36, 136, + 8, -15, -1000, -11, -11, 55, 6, -1000, -1000, -14, + -1000, 69, -11, -11, -17, -17, -1000, 83, 83, 83, + 83, 83, 83, -5, 31, -1000, 36, 36, -1000, -1000, + -1000, 136, -1000, -15, -1000, -1000, 69, } var yyPgo = [...]int{ - 0, 0, 57, 56, 55, 20, 54, 52, 51, 24, - 23, 21, 19, 18, 16, + 0, 0, 85, 69, 67, 2, 66, 65, 3, 64, + 62, 61, 48, 39, 38, 25, 20, 1, } var yyR1 = [...]int{ 0, 7, 3, 3, 3, 8, 8, 8, 8, 1, - 1, 1, 2, 2, 2, 2, 4, 4, 4, 13, - 5, 6, 12, 12, 12, 12, 12, 12, 12, 12, - 12, 12, 12, 12, 9, 9, 9, 14, 14, 11, - 10, 10, + 1, 1, 2, 2, 2, 2, 2, 14, 15, 15, + 17, 17, 4, 4, 4, 13, 5, 6, 12, 12, + 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, + 9, 9, 9, 16, 16, 11, 10, 10, } var yyR2 = [...]int{ 0, 1, 1, 2, 4, 1, 1, 1, 1, 2, - 2, 1, 1, 1, 1, 3, 1, 2, 1, 1, - 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 1, 2, 3, 1, 3, 1, - 1, 0, + 2, 1, 1, 1, 1, 3, 1, 3, 1, 3, + 1, 3, 1, 2, 1, 1, 1, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 1, 2, 3, 1, 3, 1, 1, 0, } var yyChk = [...]int{ -1000, -7, -3, -1, 24, 15, 19, 20, -2, -8, - -4, -9, 17, 7, 8, 9, 10, -5, -13, -6, - -12, 14, 13, 12, 19, 20, 21, 22, 23, 25, - 26, 27, 28, 24, 29, 32, -1, 24, -1, -1, - -1, 30, -5, 18, -14, -11, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 18, -5, 18, 31, 16, -10, -1, + -4, -9, 17, -14, 7, 8, 9, 10, -5, -13, + -6, -12, 14, 13, 12, 19, 20, 21, 22, 23, + 25, 26, 27, 28, 24, 29, 32, -1, 15, 24, + -15, -17, -8, -1, -1, -1, 30, -5, 18, -16, + -11, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 16, 33, 31, 18, -5, + 18, 31, 16, -17, -8, -10, -1, } var yyDef = [...]int{ 0, -2, 1, 2, 0, 0, 0, 0, 11, 12, - 13, 14, 0, 5, 6, 7, 8, 16, 0, 18, - 34, 0, 20, 19, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 3, 0, 9, 10, - 0, 0, 17, 35, 0, 37, 39, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 0, - 15, 21, 36, 41, 4, 38, 40, + 13, 14, 0, 16, 5, 6, 7, 8, 22, 0, + 24, 40, 0, 26, 25, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 18, 20, 9, 10, 0, 0, 23, 41, 0, + 43, 45, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 0, 17, 0, 0, 15, 27, + 42, 47, 4, 19, 21, 44, 46, } var yyTok1 = [...]int{ @@ -174,7 +183,7 @@ var yyTok2 = [...]int{ 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, - 32, + 32, 33, } var yyTok3 = [...]int{ 0, @@ -565,106 +574,131 @@ yydefault: yyVAL.expr = yyDollar[2].expr } case 17: - yyDollar = yyS[yypt-2 : yypt+1] + yyDollar = yyS[yypt-3 : yypt+1] { - yyVAL.expr = NewPrefixExpr(yyDollar[1].expr, yyDollar[2].expr) + yyVAL.expr = NewConstArrayExpr(yyDollar[2].rows) } - case 19: + case 18: yyDollar = yyS[yypt-1 : yypt+1] { - yyVAL.expr = NewSheetPrefixExpr(yyDollar[1].node.val) + yyVAL.rows = append(yyVAL.rows, yyDollar[1].args) + } + case 19: + yyDollar = yyS[yypt-3 : yypt+1] + { + yyVAL.rows = append(yyDollar[1].rows, yyDollar[3].args) } case 20: yyDollar = yyS[yypt-1 : yypt+1] { - yyVAL.expr = NewCellRef(yyDollar[1].node.val) + yyVAL.args = append(yyVAL.args, yyDollar[1].expr) } case 21: yyDollar = yyS[yypt-3 : yypt+1] { - yyVAL.expr = NewRange(yyDollar[1].expr, yyDollar[3].expr) - } - case 22: - yyDollar = yyS[yypt-3 : yypt+1] - { - yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypePlus, yyDollar[3].expr) + yyVAL.args = append(yyDollar[1].args, yyDollar[3].expr) } case 23: - yyDollar = yyS[yypt-3 : yypt+1] + yyDollar = yyS[yypt-2 : yypt+1] { - yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeMinus, yyDollar[3].expr) - } - case 24: - yyDollar = yyS[yypt-3 : yypt+1] - { - yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeMult, yyDollar[3].expr) + yyVAL.expr = NewPrefixExpr(yyDollar[1].expr, yyDollar[2].expr) } case 25: - yyDollar = yyS[yypt-3 : yypt+1] + yyDollar = yyS[yypt-1 : yypt+1] { - yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeDiv, yyDollar[3].expr) + yyVAL.expr = NewSheetPrefixExpr(yyDollar[1].node.val) } case 26: - yyDollar = yyS[yypt-3 : yypt+1] + yyDollar = yyS[yypt-1 : yypt+1] { - yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeExp, yyDollar[3].expr) + yyVAL.expr = NewCellRef(yyDollar[1].node.val) } case 27: yyDollar = yyS[yypt-3 : yypt+1] { - yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeLT, yyDollar[3].expr) + yyVAL.expr = NewRange(yyDollar[1].expr, yyDollar[3].expr) } case 28: yyDollar = yyS[yypt-3 : yypt+1] { - yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeGT, yyDollar[3].expr) + yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypePlus, yyDollar[3].expr) } case 29: yyDollar = yyS[yypt-3 : yypt+1] { - yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeLEQ, yyDollar[3].expr) + yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeMinus, yyDollar[3].expr) } case 30: yyDollar = yyS[yypt-3 : yypt+1] { - yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeGEQ, yyDollar[3].expr) + yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeMult, yyDollar[3].expr) } case 31: yyDollar = yyS[yypt-3 : yypt+1] { - yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeEQ, yyDollar[3].expr) + yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeDiv, yyDollar[3].expr) } case 32: yyDollar = yyS[yypt-3 : yypt+1] { - yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeNE, yyDollar[3].expr) + yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeExp, yyDollar[3].expr) } case 33: yyDollar = yyS[yypt-3 : yypt+1] { - yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeConcat, yyDollar[3].expr) + yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeLT, yyDollar[3].expr) + } + case 34: + yyDollar = yyS[yypt-3 : yypt+1] + { + yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeGT, yyDollar[3].expr) } case 35: - yyDollar = yyS[yypt-2 : yypt+1] + yyDollar = yyS[yypt-3 : yypt+1] { - yyVAL.expr = NewFunction(yyDollar[1].node.val, nil) + yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeLEQ, yyDollar[3].expr) } case 36: yyDollar = yyS[yypt-3 : yypt+1] { - yyVAL.expr = NewFunction(yyDollar[1].node.val, yyDollar[2].args) + yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeGEQ, yyDollar[3].expr) } case 37: - yyDollar = yyS[yypt-1 : yypt+1] + yyDollar = yyS[yypt-3 : yypt+1] { - yyVAL.args = append(yyVAL.args, yyDollar[1].expr) + yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeEQ, yyDollar[3].expr) } case 38: yyDollar = yyS[yypt-3 : yypt+1] { - yyVAL.args = append(yyDollar[1].args, yyDollar[3].expr) + yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeNE, yyDollar[3].expr) + } + case 39: + yyDollar = yyS[yypt-3 : yypt+1] + { + yyVAL.expr = NewBinaryExpr(yyDollar[1].expr, BinOpTypeConcat, yyDollar[3].expr) } case 41: + yyDollar = yyS[yypt-2 : yypt+1] + { + yyVAL.expr = NewFunction(yyDollar[1].node.val, nil) + } + case 42: + yyDollar = yyS[yypt-3 : yypt+1] + { + yyVAL.expr = NewFunction(yyDollar[1].node.val, yyDollar[2].args) + } + case 43: + yyDollar = yyS[yypt-1 : yypt+1] + { + yyVAL.args = append(yyVAL.args, yyDollar[1].expr) + } + case 44: + yyDollar = yyS[yypt-3 : yypt+1] + { + yyVAL.args = append(yyDollar[1].args, yyDollar[3].expr) + } + case 47: yyDollar = yyS[yypt-0 : yypt+1] { yyVAL.expr = NewEmptyExpr() diff --git a/spreadsheet/formula/grammar.y b/spreadsheet/formula/grammar.y index d9b2f0d0..86756cdd 100644 --- a/spreadsheet/formula/grammar.y +++ b/spreadsheet/formula/grammar.y @@ -14,12 +14,14 @@ package formula node *node expr Expression args []Expression + rows [][]Expression } %type formula formula1 initial reference referenceItem refFunctionCall %type start constant functionCall argument argument1 -%type binOp prefix -%type arguments +%type binOp prefix constArray +%type constArrayRows +%type arguments constArrayCols %token tokenHorizontalRange tokenReservedName tokenDDECall %token tokenBool tokenNumber tokenString tokenError tokenErrorRef tokenSheet tokenCell @@ -27,7 +29,7 @@ package formula %token tokenLBrace tokenRBrace tokenLParen tokenRParen %token tokenPlus tokenMinus tokenMult tokenDiv tokenExp tokenEQ tokenLT tokenGT tokenLEQ tokenGEQ tokenNE -%token tokenColon tokenComma tokenAmpersand +%token tokenColon tokenComma tokenAmpersand tokenSemi %left tokenEQ tokenLT tokenGT tokenLEQ tokenGEQ tokenNE %left tokenPlus tokenMinus @@ -61,8 +63,19 @@ formula1: | reference | functionCall | tokenLParen formula tokenRParen { $$ = $2 } + | constArray ; +constArray: tokenLBrace constArrayRows tokenRBrace { $$ = NewConstArrayExpr($2)} ; +constArrayRows: + constArrayCols { $$ = append($$, $1) } + | constArrayRows tokenSemi constArrayCols { $$ = append($1, $3)}; + +constArrayCols: + constant { $$ = append($$,$1) } + | constArrayCols tokenComma constant { $$ = append($1,$3)} + + reference: referenceItem | prefix referenceItem { $$ = NewPrefixExpr($1,$2)} @@ -70,7 +83,7 @@ reference: prefix: tokenSheet { $$ = NewSheetPrefixExpr($1.val) }; -referenceItem: tokenCell { $$ = NewCellRef($1.val)} ; +referenceItem: tokenCell { $$ = NewCellRef($1.val)} ; refFunctionCall: referenceItem tokenColon referenceItem { $$ = NewRange($1,$3) }; diff --git a/spreadsheet/formula/lexer.go b/spreadsheet/formula/lexer.go index a57e1adf..25ecf369 100644 --- a/spreadsheet/formula/lexer.go +++ b/spreadsheet/formula/lexer.go @@ -14,47 +14,13 @@ import ( ) // line 20 "lexer.go" -var _formula_actions []byte = []byte{ - 0, 1, 2, 1, 9, 1, 10, 1, 11, - 1, 12, 1, 13, 1, 14, 1, 15, - 1, 16, 1, 17, 1, 18, 1, 19, - 1, 20, 1, 21, 1, 22, 1, 23, - 1, 24, 1, 25, 1, 26, 1, 27, - 1, 28, 1, 29, 1, 30, 1, 31, - 1, 32, 1, 33, 1, 34, 1, 35, - 1, 36, 1, 37, 1, 38, 1, 39, - 2, 0, 1, 2, 3, 4, 2, 3, - 5, 2, 3, 6, 2, 3, 7, 2, - 3, 8, -} - -var _formula_to_state_actions []byte = []byte{ - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 65, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, -} - -var _formula_from_state_actions []byte = []byte{ - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, -} - const formula_start int = 44 const formula_first_final int = 44 const formula_error int = 0 const formula_en_main int = 44 -// line 105 "lexer.rl" +// line 106 "lexer.rl" func (l *Lexer) lex(r io.Reader) { cs, p, pe := 0, 0, 0 @@ -88,7 +54,7 @@ func (l *Lexer) lex(r io.Reader) { eof = pe } - // line 97 "lexer.go" + // line 63 "lexer.go" { cs = formula_start ts = 0 @@ -96,1879 +62,2055 @@ func (l *Lexer) lex(r io.Reader) { act = 0 } - // line 105 "lexer.go" + // line 71 "lexer.go" { - var _acts int - var _nacts uint - if p == pe { goto _test_eof } - if cs == 0 { - goto _out - } - _resume: - _acts = int(_formula_from_state_actions[cs]) - _nacts = uint(_formula_actions[_acts]) - _acts++ - for ; _nacts > 0; _nacts-- { - _acts++ - switch _formula_actions[_acts-1] { - case 2: - // line 1 "NONE" - - ts = p - - // line 127 "lexer.go" - } - } - switch cs { case 44: - switch data[p] { - case 34: - goto tr3 - case 35: - goto tr52 - case 36: - goto tr53 - case 38: - goto tr54 - case 39: - goto tr55 - case 40: - goto tr56 - case 41: - goto tr57 - case 42: - goto tr58 - case 43: - goto tr59 - case 44: - goto tr60 - case 45: - goto tr61 - case 47: - goto tr62 - case 58: - goto tr64 - case 60: - goto tr65 - case 61: - goto tr66 - case 62: - goto tr67 - case 70: - goto tr69 - case 84: - goto tr70 - case 94: - goto tr71 - case 95: - goto tr72 - case 123: - goto tr73 - case 125: - goto tr74 - } - switch { - case data[p] < 59: - switch { - case data[p] > 37: - if 48 <= data[p] && data[p] <= 57 { - goto tr63 - } - case data[p] >= 33: - goto tr6 - } - case data[p] > 63: - switch { - case data[p] > 90: - if 91 <= data[p] && data[p] <= 93 { - goto tr6 - } - case data[p] >= 65: - goto tr68 - } - default: - goto tr6 - } - goto tr1 + goto st_case_44 case 1: - switch data[p] { - case 33: - goto tr2 - case 47: - goto tr0 - case 123: - goto tr0 - case 125: - goto tr0 - } - switch { - case data[p] < 37: - if 34 <= data[p] && data[p] <= 35 { - goto tr0 - } - case data[p] > 45: - switch { - case data[p] > 63: - if 91 <= data[p] && data[p] <= 95 { - goto tr0 - } - case data[p] >= 58: - goto tr0 - } - default: - goto tr0 - } - goto tr1 + goto st_case_1 case 0: - goto _out + goto st_case_0 case 2: - if data[p] == 34 { - goto tr4 - } - goto tr3 + goto st_case_2 case 45: - if data[p] == 34 { - goto tr3 - } - goto tr75 + goto st_case_45 case 3: - switch data[p] { - case 78: - goto tr5 - case 82: - goto tr7 - } - goto tr6 + goto st_case_3 case 4: - switch data[p] { - case 47: - goto tr8 - case 85: - goto tr9 - } - goto tr6 + goto st_case_4 case 5: - if data[p] == 65 { - goto tr10 - } - goto tr6 + goto st_case_5 case 6: - switch data[p] { - case 76: - goto tr11 - case 77: - goto tr12 - } - goto tr6 + goto st_case_6 case 7: - if data[p] == 76 { - goto tr12 - } - goto tr6 + goto st_case_7 case 8: - if data[p] == 33 { - goto tr10 - } - goto tr6 + goto st_case_8 case 9: - if data[p] == 69 { - goto tr13 - } - goto tr6 + goto st_case_9 case 10: - if data[p] == 70 { - goto tr14 - } - goto tr6 + goto st_case_10 case 11: - if data[p] == 33 { - goto tr15 - } - goto tr6 + goto st_case_11 case 12: - switch data[p] { - case 33: - goto tr2 - case 47: - goto tr6 - case 123: - goto tr6 - case 125: - goto tr6 - } - switch { - case data[p] < 48: - switch { - case data[p] > 35: - if 37 <= data[p] && data[p] <= 45 { - goto tr6 - } - case data[p] >= 34: - goto tr6 - } - case data[p] > 57: - switch { - case data[p] < 65: - if 58 <= data[p] && data[p] <= 63 { - goto tr6 - } - case data[p] > 90: - if 91 <= data[p] && data[p] <= 95 { - goto tr6 - } - default: - goto tr17 - } - default: - goto tr16 - } - goto tr1 + goto st_case_12 case 13: - switch data[p] { - case 33: - goto tr2 - case 47: - goto tr6 - case 58: - goto tr18 - case 123: - goto tr6 - case 125: - goto tr6 - } - switch { - case data[p] < 48: - switch { - case data[p] > 35: - if 37 <= data[p] && data[p] <= 45 { - goto tr6 - } - case data[p] >= 34: - goto tr6 - } - case data[p] > 57: - switch { - case data[p] > 63: - if 91 <= data[p] && data[p] <= 95 { - goto tr6 - } - case data[p] >= 59: - goto tr6 - } - default: - goto tr16 - } - goto tr1 + goto st_case_13 case 14: - if data[p] == 36 { - goto tr19 - } - if 48 <= data[p] && data[p] <= 57 { - goto tr20 - } - goto tr0 + goto st_case_14 case 15: - if 48 <= data[p] && data[p] <= 57 { - goto tr20 - } - goto tr0 + goto st_case_15 case 46: - if 48 <= data[p] && data[p] <= 57 { - goto tr20 - } - goto tr76 + goto st_case_46 case 16: - switch data[p] { - case 33: - goto tr2 - case 36: - goto tr21 - case 47: - goto tr6 - case 123: - goto tr6 - case 125: - goto tr6 - } - switch { - case data[p] < 58: - switch { - case data[p] > 45: - if 48 <= data[p] && data[p] <= 57 { - goto tr22 - } - case data[p] >= 34: - goto tr6 - } - case data[p] > 63: - switch { - case data[p] > 90: - if 91 <= data[p] && data[p] <= 95 { - goto tr6 - } - case data[p] >= 65: - goto tr17 - } - default: - goto tr6 - } - goto tr1 + goto st_case_16 case 17: - switch data[p] { - case 33: - goto tr2 - case 47: - goto tr0 - case 123: - goto tr0 - case 125: - goto tr0 - } - switch { - case data[p] < 48: - switch { - case data[p] > 35: - if 37 <= data[p] && data[p] <= 45 { - goto tr0 - } - case data[p] >= 34: - goto tr0 - } - case data[p] > 57: - switch { - case data[p] > 63: - if 91 <= data[p] && data[p] <= 95 { - goto tr0 - } - case data[p] >= 58: - goto tr0 - } - default: - goto tr22 - } - goto tr1 + goto st_case_17 case 47: - switch data[p] { - case 33: - goto tr2 - case 47: - goto tr77 - case 123: - goto tr77 - case 125: - goto tr77 - } - switch { - case data[p] < 48: - switch { - case data[p] > 35: - if 37 <= data[p] && data[p] <= 45 { - goto tr77 - } - case data[p] >= 34: - goto tr77 - } - case data[p] > 57: - switch { - case data[p] > 63: - if 91 <= data[p] && data[p] <= 95 { - goto tr77 - } - case data[p] >= 58: - goto tr77 - } - default: - goto tr22 - } - goto tr1 + goto st_case_47 case 18: - switch data[p] { - case 39: - goto tr6 - case 42: - goto tr6 - case 47: - goto tr6 - case 58: - goto tr6 - case 63: - goto tr6 - } - if 91 <= data[p] && data[p] <= 93 { - goto tr6 - } - goto tr23 + goto st_case_18 case 19: - switch data[p] { - case 39: - goto tr24 - case 42: - goto tr6 - case 47: - goto tr6 - case 58: - goto tr6 - case 63: - goto tr6 - } - if 91 <= data[p] && data[p] <= 93 { - goto tr6 - } - goto tr23 + goto st_case_19 case 20: - if data[p] == 33 { - goto tr25 - } - goto tr6 + goto st_case_20 case 48: - switch data[p] { - case 33: - goto tr2 - case 46: - goto tr79 - case 58: - goto tr18 - case 101: - goto tr80 - case 123: - goto tr78 - case 125: - goto tr78 - } - switch { - case data[p] < 48: - switch { - case data[p] > 35: - if 37 <= data[p] && data[p] <= 47 { - goto tr78 - } - case data[p] >= 34: - goto tr78 - } - case data[p] > 57: - switch { - case data[p] > 63: - if 91 <= data[p] && data[p] <= 95 { - goto tr78 - } - case data[p] >= 59: - goto tr78 - } - default: - goto tr63 - } - goto tr1 + goto st_case_48 case 49: - switch data[p] { - case 33: - goto tr2 - case 47: - goto tr78 - case 101: - goto tr80 - case 123: - goto tr78 - case 125: - goto tr78 - } - switch { - case data[p] < 48: - switch { - case data[p] > 35: - if 37 <= data[p] && data[p] <= 45 { - goto tr78 - } - case data[p] >= 34: - goto tr78 + goto st_case_49 + case 21: + goto st_case_21 + case 50: + goto st_case_50 + case 51: + goto st_case_51 + case 52: + goto st_case_52 + case 22: + goto st_case_22 + case 23: + goto st_case_23 + case 53: + goto st_case_53 + case 24: + goto st_case_24 + case 25: + goto st_case_25 + case 26: + goto st_case_26 + case 27: + goto st_case_27 + case 28: + goto st_case_28 + case 54: + goto st_case_54 + case 29: + goto st_case_29 + case 30: + goto st_case_30 + case 31: + goto st_case_31 + case 32: + goto st_case_32 + case 33: + goto st_case_33 + case 34: + goto st_case_34 + case 35: + goto st_case_35 + case 36: + goto st_case_36 + case 37: + goto st_case_37 + case 38: + goto st_case_38 + case 39: + goto st_case_39 + case 40: + goto st_case_40 + case 41: + goto st_case_41 + case 42: + goto st_case_42 + case 43: + goto st_case_43 + case 55: + goto st_case_55 + } + goto st_out + tr0: + // line 1 "NONE" + + switch act { + case 0: + { + { + goto st0 } - case data[p] > 57: - switch { - case data[p] > 63: - if 91 <= data[p] && data[p] <= 95 { - goto tr78 - } - case data[p] >= 58: - goto tr78 + } + case 1: + { + p = (te) - 1 + l.emit(tokenBool, data[ts:te]) + } + case 2: + { + p = (te) - 1 + l.emit(tokenNumber, data[ts:te]) + } + case 3: + { + p = (te) - 1 + l.emit(tokenCell, data[ts:te]) + } + case 4: + { + p = (te) - 1 + l.emit(tokenDDECall, data[ts:te]) + } + case 13: + { + p = (te) - 1 + l.emit(tokenString, data[ts+1:te-1]) + } + } + + goto st44 + tr2: + // line 62 "lexer.rl" + + te = p + 1 + { + l.emit(tokenSheet, data[ts:te-1]) + } + goto st44 + tr10: + // line 59 "lexer.rl" + + te = p + 1 + { + l.emit(tokenError, data[ts:te]) + } + goto st44 + tr15: + // line 60 "lexer.rl" + + te = p + 1 + { + l.emit(tokenErrorRef, data[ts:te]) + } + goto st44 + tr25: + // line 63 "lexer.rl" + + te = p + 1 + { + l.emit(tokenSheet, data[ts+1:te-2]) + } + goto st44 + tr26: + // line 56 "lexer.rl" + + p = (te) - 1 + { + l.emit(tokenNumber, data[ts:te]) + } + goto st44 + tr31: + // line 67 "lexer.rl" + + te = p + 1 + { + l.emit(tokenFunctionBultin, data[ts:te-1]) + } + goto st44 + tr48: + // line 68 "lexer.rl" + + te = p + 1 + { + l.emit(tokenFunctionBultin, data[ts:te-1]) + } + goto st44 + tr54: + // line 74 "lexer.rl" + + te = p + 1 + { + l.emit(tokenAmpersand, data[ts:te]) + } + goto st44 + tr56: + // line 77 "lexer.rl" + + te = p + 1 + { + l.emit(tokenLParen, data[ts:te]) + } + goto st44 + tr57: + // line 78 "lexer.rl" + + te = p + 1 + { + l.emit(tokenRParen, data[ts:te]) + } + goto st44 + tr58: + // line 81 "lexer.rl" + + te = p + 1 + { + l.emit(tokenMult, data[ts:te]) + } + goto st44 + tr59: + // line 79 "lexer.rl" + + te = p + 1 + { + l.emit(tokenPlus, data[ts:te]) + } + goto st44 + tr60: + // line 93 "lexer.rl" + + te = p + 1 + { + l.emit(tokenComma, data[ts:te]) + } + goto st44 + tr61: + // line 80 "lexer.rl" + + te = p + 1 + { + l.emit(tokenMinus, data[ts:te]) + } + goto st44 + tr62: + // line 82 "lexer.rl" + + te = p + 1 + { + l.emit(tokenDiv, data[ts:te]) + } + goto st44 + tr64: + // line 91 "lexer.rl" + + te = p + 1 + { + l.emit(tokenColon, data[ts:te]) + } + goto st44 + tr65: + // line 92 "lexer.rl" + + te = p + 1 + { + l.emit(tokenSemi, data[ts:te]) + } + goto st44 + tr67: + // line 86 "lexer.rl" + + te = p + 1 + { + l.emit(tokenEQ, data[ts:te]) + } + goto st44 + tr72: + // line 83 "lexer.rl" + + te = p + 1 + { + l.emit(tokenExp, data[ts:te]) + } + goto st44 + tr74: + // line 75 "lexer.rl" + + te = p + 1 + { + l.emit(tokenLBrace, data[ts:te]) + } + goto st44 + tr75: + // line 76 "lexer.rl" + + te = p + 1 + { + l.emit(tokenRBrace, data[ts:te]) + } + goto st44 + tr76: + // line 71 "lexer.rl" + + te = p + p-- + { + l.emit(tokenString, data[ts+1:te-1]) + } + goto st44 + tr77: + // line 61 "lexer.rl" + + te = p + p-- + { + l.emit(tokenHorizontalRange, data[ts:te]) + } + goto st44 + tr78: + // line 57 "lexer.rl" + + te = p + p-- + { + l.emit(tokenCell, data[ts:te]) + } + goto st44 + tr79: + // line 56 "lexer.rl" + + te = p + p-- + { + l.emit(tokenNumber, data[ts:te]) + } + goto st44 + tr82: + // line 84 "lexer.rl" + + te = p + p-- + { + l.emit(tokenLT, data[ts:te]) + } + goto st44 + tr83: + // line 87 "lexer.rl" + + te = p + 1 + { + l.emit(tokenLEQ, data[ts:te]) + } + goto st44 + tr84: + // line 89 "lexer.rl" + + te = p + 1 + { + l.emit(tokenNE, data[ts:te]) + } + goto st44 + tr85: + // line 85 "lexer.rl" + + te = p + p-- + { + l.emit(tokenGT, data[ts:te]) + } + goto st44 + tr86: + // line 88 "lexer.rl" + + te = p + 1 + { + l.emit(tokenGEQ, data[ts:te]) + } + goto st44 + tr87: + // line 64 "lexer.rl" + + te = p + p-- + { + l.emit(tokenReservedName, data[ts:te]) + } + goto st44 + st44: + // line 1 "NONE" + + ts = 0 + + // line 1 "NONE" + + act = 0 + + if p++; p == pe { + goto _test_eof44 + } + st_case_44: + // line 1 "NONE" + + ts = p + + // line 425 "lexer.go" + switch data[p] { + case 34: + goto st2 + case 35: + goto st3 + case 36: + goto st12 + case 38: + goto tr54 + case 39: + goto st18 + case 40: + goto tr56 + case 41: + goto tr57 + case 42: + goto tr58 + case 43: + goto tr59 + case 44: + goto tr60 + case 45: + goto tr61 + case 47: + goto tr62 + case 58: + goto tr64 + case 59: + goto tr65 + case 60: + goto st51 + case 61: + goto tr67 + case 62: + goto st52 + case 63: + goto st0 + case 70: + goto st25 + case 84: + goto st29 + case 94: + goto tr72 + case 95: + goto st33 + case 123: + goto tr74 + case 125: + goto tr75 + } + switch { + case data[p] < 48: + if 33 <= data[p] && data[p] <= 37 { + goto st0 + } + case data[p] > 57: + switch { + case data[p] > 90: + if 91 <= data[p] && data[p] <= 93 { + goto st0 + } + case data[p] >= 65: + goto st22 + } + default: + goto tr63 + } + goto st1 + st1: + if p++; p == pe { + goto _test_eof1 + } + st_case_1: + switch data[p] { + case 33: + goto tr2 + case 47: + goto tr0 + case 123: + goto tr0 + case 125: + goto tr0 + } + switch { + case data[p] < 37: + if 34 <= data[p] && data[p] <= 35 { + goto tr0 + } + case data[p] > 45: + switch { + case data[p] > 63: + if 91 <= data[p] && data[p] <= 95 { + goto tr0 + } + case data[p] >= 58: + goto tr0 + } + default: + goto tr0 + } + goto st1 + st_case_0: + st0: + cs = 0 + goto _out + st2: + if p++; p == pe { + goto _test_eof2 + } + st_case_2: + if data[p] == 34 { + goto tr4 + } + goto st2 + tr4: + // line 1 "NONE" + + te = p + 1 + + // line 71 "lexer.rl" + + act = 13 + goto st45 + st45: + if p++; p == pe { + goto _test_eof45 + } + st_case_45: + // line 554 "lexer.go" + if data[p] == 34 { + goto st2 + } + goto tr76 + st3: + if p++; p == pe { + goto _test_eof3 + } + st_case_3: + switch data[p] { + case 78: + goto st4 + case 82: + goto st9 + } + goto st0 + st4: + if p++; p == pe { + goto _test_eof4 + } + st_case_4: + switch data[p] { + case 47: + goto st5 + case 85: + goto st6 + } + goto st0 + st5: + if p++; p == pe { + goto _test_eof5 + } + st_case_5: + if data[p] == 65 { + goto tr10 + } + goto st0 + st6: + if p++; p == pe { + goto _test_eof6 + } + st_case_6: + switch data[p] { + case 76: + goto st7 + case 77: + goto st8 + } + goto st0 + st7: + if p++; p == pe { + goto _test_eof7 + } + st_case_7: + if data[p] == 76 { + goto st8 + } + goto st0 + st8: + if p++; p == pe { + goto _test_eof8 + } + st_case_8: + if data[p] == 33 { + goto tr10 + } + goto st0 + st9: + if p++; p == pe { + goto _test_eof9 + } + st_case_9: + if data[p] == 69 { + goto st10 + } + goto st0 + st10: + if p++; p == pe { + goto _test_eof10 + } + st_case_10: + if data[p] == 70 { + goto st11 + } + goto st0 + st11: + if p++; p == pe { + goto _test_eof11 + } + st_case_11: + if data[p] == 33 { + goto tr15 + } + goto st0 + st12: + if p++; p == pe { + goto _test_eof12 + } + st_case_12: + switch data[p] { + case 33: + goto tr2 + case 47: + goto st0 + case 123: + goto st0 + case 125: + goto st0 + } + switch { + case data[p] < 48: + switch { + case data[p] > 35: + if 37 <= data[p] && data[p] <= 45 { + goto st0 + } + case data[p] >= 34: + goto st0 + } + case data[p] > 57: + switch { + case data[p] < 65: + if 58 <= data[p] && data[p] <= 63 { + goto st0 + } + case data[p] > 90: + if 91 <= data[p] && data[p] <= 95 { + goto st0 } default: + goto st16 + } + default: + goto st13 + } + goto st1 + st13: + if p++; p == pe { + goto _test_eof13 + } + st_case_13: + switch data[p] { + case 33: + goto tr2 + case 47: + goto st0 + case 58: + goto st14 + case 123: + goto st0 + case 125: + goto st0 + } + switch { + case data[p] < 48: + switch { + case data[p] > 35: + if 37 <= data[p] && data[p] <= 45 { + goto st0 + } + case data[p] >= 34: + goto st0 + } + case data[p] > 57: + switch { + case data[p] > 63: + if 91 <= data[p] && data[p] <= 95 { + goto st0 + } + case data[p] >= 59: + goto st0 + } + default: + goto st13 + } + goto st1 + st14: + if p++; p == pe { + goto _test_eof14 + } + st_case_14: + if data[p] == 36 { + goto st15 + } + if 48 <= data[p] && data[p] <= 57 { + goto st46 + } + goto tr0 + st15: + if p++; p == pe { + goto _test_eof15 + } + st_case_15: + if 48 <= data[p] && data[p] <= 57 { + goto st46 + } + goto tr0 + st46: + if p++; p == pe { + goto _test_eof46 + } + st_case_46: + if 48 <= data[p] && data[p] <= 57 { + goto st46 + } + goto tr77 + st16: + if p++; p == pe { + goto _test_eof16 + } + st_case_16: + switch data[p] { + case 33: + goto tr2 + case 36: + goto st17 + case 47: + goto st0 + case 123: + goto st0 + case 125: + goto st0 + } + switch { + case data[p] < 58: + switch { + case data[p] > 45: + if 48 <= data[p] && data[p] <= 57 { + goto tr22 + } + case data[p] >= 34: + goto st0 + } + case data[p] > 63: + switch { + case data[p] > 90: + if 91 <= data[p] && data[p] <= 95 { + goto st0 + } + case data[p] >= 65: + goto st16 + } + default: + goto st0 + } + goto st1 + st17: + if p++; p == pe { + goto _test_eof17 + } + st_case_17: + switch data[p] { + case 33: + goto tr2 + case 47: + goto tr0 + case 123: + goto tr0 + case 125: + goto tr0 + } + switch { + case data[p] < 48: + switch { + case data[p] > 35: + if 37 <= data[p] && data[p] <= 45 { + goto tr0 + } + case data[p] >= 34: + goto tr0 + } + case data[p] > 57: + switch { + case data[p] > 63: + if 91 <= data[p] && data[p] <= 95 { + goto tr0 + } + case data[p] >= 58: + goto tr0 + } + default: + goto tr22 + } + goto st1 + tr22: + // line 1 "NONE" + + te = p + 1 + + // line 57 "lexer.rl" + + act = 3 + goto st47 + st47: + if p++; p == pe { + goto _test_eof47 + } + st_case_47: + // line 853 "lexer.go" + switch data[p] { + case 33: + goto tr2 + case 47: + goto tr78 + case 123: + goto tr78 + case 125: + goto tr78 + } + switch { + case data[p] < 48: + switch { + case data[p] > 35: + if 37 <= data[p] && data[p] <= 45 { + goto tr78 + } + case data[p] >= 34: + goto tr78 + } + case data[p] > 57: + switch { + case data[p] > 63: + if 91 <= data[p] && data[p] <= 95 { + goto tr78 + } + case data[p] >= 58: + goto tr78 + } + default: + goto tr22 + } + goto st1 + st18: + if p++; p == pe { + goto _test_eof18 + } + st_case_18: + switch data[p] { + case 39: + goto st0 + case 42: + goto st0 + case 47: + goto st0 + case 58: + goto st0 + case 63: + goto st0 + } + if 91 <= data[p] && data[p] <= 93 { + goto st0 + } + goto st19 + st19: + if p++; p == pe { + goto _test_eof19 + } + st_case_19: + switch data[p] { + case 39: + goto st20 + case 42: + goto st0 + case 47: + goto st0 + case 58: + goto st0 + case 63: + goto st0 + } + if 91 <= data[p] && data[p] <= 93 { + goto st0 + } + goto st19 + st20: + if p++; p == pe { + goto _test_eof20 + } + st_case_20: + if data[p] == 33 { + goto tr25 + } + goto st0 + tr63: + // line 1 "NONE" + + te = p + 1 + + // line 56 "lexer.rl" + + act = 2 + goto st48 + st48: + if p++; p == pe { + goto _test_eof48 + } + st_case_48: + // line 952 "lexer.go" + switch data[p] { + case 33: + goto tr2 + case 46: + goto tr80 + case 58: + goto st14 + case 101: + goto st21 + case 123: + goto tr79 + case 125: + goto tr79 + } + switch { + case data[p] < 48: + switch { + case data[p] > 35: + if 37 <= data[p] && data[p] <= 47 { + goto tr79 + } + case data[p] >= 34: goto tr79 } - goto tr1 - case 21: - switch data[p] { - case 33: - goto tr2 - case 47: - goto tr26 - case 123: - goto tr26 - case 125: - goto tr26 - } + case data[p] > 57: switch { - case data[p] < 48: - switch { - case data[p] > 35: - if 37 <= data[p] && data[p] <= 45 { - goto tr26 - } - case data[p] >= 34: - goto tr26 - } - case data[p] > 57: - switch { - case data[p] > 63: - if 91 <= data[p] && data[p] <= 95 { - goto tr26 - } - case data[p] >= 58: - goto tr26 - } - default: - goto tr27 - } - goto tr1 - case 50: - switch data[p] { - case 33: - goto tr2 - case 47: - goto tr78 - case 123: - goto tr78 - case 125: - goto tr78 - } - switch { - case data[p] < 48: - switch { - case data[p] > 35: - if 37 <= data[p] && data[p] <= 45 { - goto tr78 - } - case data[p] >= 34: - goto tr78 - } - case data[p] > 57: - switch { - case data[p] > 63: - if 91 <= data[p] && data[p] <= 95 { - goto tr78 - } - case data[p] >= 58: - goto tr78 - } - default: - goto tr27 - } - goto tr1 - case 51: - switch data[p] { - case 61: - goto tr82 - case 62: - goto tr83 - } - goto tr81 - case 52: - if data[p] == 61 { - goto tr85 - } - goto tr84 - case 22: - switch data[p] { - case 33: - goto tr2 - case 36: - goto tr21 - case 46: - goto tr28 - case 123: - goto tr6 - case 125: - goto tr6 - } - switch { - case data[p] < 58: - switch { - case data[p] > 47: - if 48 <= data[p] && data[p] <= 57 { - goto tr29 - } - case data[p] >= 34: - goto tr6 - } case data[p] > 63: - switch { - case data[p] > 90: - if 91 <= data[p] && data[p] <= 95 { - goto tr6 - } - case data[p] >= 65: - goto tr30 + if 91 <= data[p] && data[p] <= 95 { + goto tr79 } - default: - goto tr6 + case data[p] >= 59: + goto tr79 } - goto tr1 - case 23: - switch data[p] { - case 33: - goto tr2 - case 40: - goto tr31 - case 46: - goto tr28 - case 123: - goto tr0 - case 125: - goto tr0 - } - switch { - case data[p] < 48: - switch { - case data[p] > 35: - if 37 <= data[p] && data[p] <= 47 { - goto tr0 - } - case data[p] >= 34: - goto tr0 - } - case data[p] > 57: - switch { - case data[p] < 65: - if 58 <= data[p] && data[p] <= 63 { - goto tr0 - } - case data[p] > 90: - if 91 <= data[p] && data[p] <= 95 { - goto tr0 - } - default: - goto tr28 - } - default: - goto tr28 - } - goto tr1 - case 53: - switch data[p] { - case 33: - goto tr2 - case 40: - goto tr31 - case 46: - goto tr28 - case 123: - goto tr77 - case 125: - goto tr77 - } - switch { - case data[p] < 48: - switch { - case data[p] > 35: - if 37 <= data[p] && data[p] <= 47 { - goto tr77 - } - case data[p] >= 34: - goto tr77 - } - case data[p] > 57: - switch { - case data[p] < 65: - if 58 <= data[p] && data[p] <= 63 { - goto tr77 - } - case data[p] > 90: - if 91 <= data[p] && data[p] <= 95 { - goto tr77 - } - default: - goto tr28 - } - default: - goto tr29 - } - goto tr1 - case 24: - switch data[p] { - case 33: - goto tr2 - case 36: - goto tr21 - case 40: - goto tr31 - case 46: - goto tr28 - case 123: - goto tr0 - case 125: - goto tr0 - } - switch { - case data[p] < 58: - switch { - case data[p] > 47: - if 48 <= data[p] && data[p] <= 57 { - goto tr29 - } - case data[p] >= 34: - goto tr0 - } - case data[p] > 63: - switch { - case data[p] > 90: - if 91 <= data[p] && data[p] <= 95 { - goto tr0 - } - case data[p] >= 65: - goto tr30 - } - default: - goto tr0 - } - goto tr1 - case 25: - switch data[p] { - case 33: - goto tr2 - case 36: - goto tr21 - case 46: - goto tr28 - case 65: - goto tr32 - case 123: - goto tr6 - case 125: - goto tr6 - } - switch { - case data[p] < 58: - switch { - case data[p] > 47: - if 48 <= data[p] && data[p] <= 57 { - goto tr29 - } - case data[p] >= 34: - goto tr6 - } - case data[p] > 63: - switch { - case data[p] > 90: - if 91 <= data[p] && data[p] <= 95 { - goto tr6 - } - case data[p] >= 66: - goto tr30 - } - default: - goto tr6 - } - goto tr1 - case 26: - switch data[p] { - case 33: - goto tr2 - case 36: - goto tr21 - case 40: - goto tr31 - case 46: - goto tr28 - case 76: - goto tr33 - case 123: - goto tr6 - case 125: - goto tr6 - } - switch { - case data[p] < 58: - switch { - case data[p] > 47: - if 48 <= data[p] && data[p] <= 57 { - goto tr29 - } - case data[p] >= 34: - goto tr6 - } - case data[p] > 63: - switch { - case data[p] > 90: - if 91 <= data[p] && data[p] <= 95 { - goto tr6 - } - case data[p] >= 65: - goto tr30 - } - default: - goto tr6 - } - goto tr1 - case 27: - switch data[p] { - case 33: - goto tr2 - case 36: - goto tr21 - case 40: - goto tr31 - case 46: - goto tr28 - case 83: - goto tr34 - case 123: - goto tr6 - case 125: - goto tr6 - } - switch { - case data[p] < 58: - switch { - case data[p] > 47: - if 48 <= data[p] && data[p] <= 57 { - goto tr29 - } - case data[p] >= 34: - goto tr6 - } - case data[p] > 63: - switch { - case data[p] > 90: - if 91 <= data[p] && data[p] <= 95 { - goto tr6 - } - case data[p] >= 65: - goto tr30 - } - default: - goto tr6 - } - goto tr1 - case 28: - switch data[p] { - case 33: - goto tr2 - case 36: - goto tr21 - case 40: - goto tr31 - case 46: - goto tr28 - case 69: - goto tr35 - case 123: - goto tr6 - case 125: - goto tr6 - } - switch { - case data[p] < 58: - switch { - case data[p] > 47: - if 48 <= data[p] && data[p] <= 57 { - goto tr29 - } - case data[p] >= 34: - goto tr6 - } - case data[p] > 63: - switch { - case data[p] > 90: - if 91 <= data[p] && data[p] <= 95 { - goto tr6 - } - case data[p] >= 65: - goto tr30 - } - default: - goto tr6 - } - goto tr1 - case 54: - switch data[p] { - case 33: - goto tr2 - case 36: - goto tr21 - case 40: - goto tr31 - case 46: - goto tr28 - case 123: - goto tr0 - case 125: - goto tr0 - } - switch { - case data[p] < 58: - switch { - case data[p] > 47: - if 48 <= data[p] && data[p] <= 57 { - goto tr29 - } - case data[p] >= 34: - goto tr0 - } - case data[p] > 63: - switch { - case data[p] > 90: - if 91 <= data[p] && data[p] <= 95 { - goto tr0 - } - case data[p] >= 65: - goto tr30 - } - default: - goto tr0 - } - goto tr1 - case 29: - switch data[p] { - case 33: - goto tr2 - case 36: - goto tr21 - case 46: - goto tr28 - case 79: - goto tr36 - case 82: - goto tr37 - case 123: - goto tr6 - case 125: - goto tr6 - } - switch { - case data[p] < 58: - switch { - case data[p] > 47: - if 48 <= data[p] && data[p] <= 57 { - goto tr29 - } - case data[p] >= 34: - goto tr6 - } - case data[p] > 63: - switch { - case data[p] > 90: - if 91 <= data[p] && data[p] <= 95 { - goto tr6 - } - case data[p] >= 65: - goto tr30 - } - default: - goto tr6 - } - goto tr1 - case 30: - switch data[p] { - case 33: - goto tr2 - case 36: - goto tr21 - case 40: - goto tr31 - case 46: - goto tr28 - case 68: - goto tr38 - case 123: - goto tr6 - case 125: - goto tr6 - } - switch { - case data[p] < 58: - switch { - case data[p] > 47: - if 48 <= data[p] && data[p] <= 57 { - goto tr29 - } - case data[p] >= 34: - goto tr6 - } - case data[p] > 63: - switch { - case data[p] > 90: - if 91 <= data[p] && data[p] <= 95 { - goto tr6 - } - case data[p] >= 65: - goto tr30 - } - default: - goto tr6 - } - goto tr1 - case 31: - switch data[p] { - case 33: - goto tr2 - case 36: - goto tr21 - case 40: - goto tr31 - case 46: - goto tr28 - case 79: - goto tr39 - case 123: - goto tr6 - case 125: - goto tr6 - } - switch { - case data[p] < 58: - switch { - case data[p] > 47: - if 48 <= data[p] && data[p] <= 57 { - goto tr29 - } - case data[p] >= 34: - goto tr6 - } - case data[p] > 63: - switch { - case data[p] > 90: - if 91 <= data[p] && data[p] <= 95 { - goto tr6 - } - case data[p] >= 65: - goto tr30 - } - default: - goto tr6 - } - goto tr1 - case 32: - switch data[p] { - case 33: - goto tr2 - case 36: - goto tr21 - case 40: - goto tr31 - case 46: - goto tr28 - case 85: - goto tr34 - case 123: - goto tr6 - case 125: - goto tr6 - } - switch { - case data[p] < 58: - switch { - case data[p] > 47: - if 48 <= data[p] && data[p] <= 57 { - goto tr29 - } - case data[p] >= 34: - goto tr6 - } - case data[p] > 63: - switch { - case data[p] > 90: - if 91 <= data[p] && data[p] <= 95 { - goto tr6 - } - case data[p] >= 65: - goto tr30 - } - default: - goto tr6 - } - goto tr1 + default: + goto tr63 + } + goto st1 + tr80: + // line 1 "NONE" + + te = p + 1 + + // line 56 "lexer.rl" + + act = 2 + goto st49 + st49: + if p++; p == pe { + goto _test_eof49 + } + st_case_49: + // line 1004 "lexer.go" + switch data[p] { case 33: - if data[p] == 120 { - goto tr40 - } - goto tr6 - case 34: - if data[p] == 108 { - goto tr41 - } - goto tr6 - case 35: - switch data[p] { - case 102: - goto tr42 - case 110: - goto tr43 - } - goto tr6 - case 36: - if data[p] == 110 { - goto tr44 - } - goto tr6 - case 37: - if data[p] == 46 { - goto tr45 - } - goto tr6 - case 38: - if data[p] == 95 { - goto tr46 - } - if 65 <= data[p] && data[p] <= 90 { - goto tr46 - } - goto tr6 - case 39: - if data[p] == 46 { - goto tr47 - } + goto tr2 + case 47: + goto tr79 + case 101: + goto st21 + case 123: + goto tr79 + case 125: + goto tr79 + } + switch { + case data[p] < 48: switch { - case data[p] > 57: - if 65 <= data[p] && data[p] <= 90 { - goto tr47 + case data[p] > 35: + if 37 <= data[p] && data[p] <= 45 { + goto tr79 } - case data[p] >= 48: - goto tr47 - } - goto tr6 - case 40: - switch data[p] { - case 40: - goto tr48 - case 46: - goto tr47 + case data[p] >= 34: + goto tr79 } + case data[p] > 57: switch { - case data[p] > 57: - if 65 <= data[p] && data[p] <= 90 { - goto tr47 + case data[p] > 63: + if 91 <= data[p] && data[p] <= 95 { + goto tr79 } - case data[p] >= 48: - goto tr47 + case data[p] >= 58: + goto tr79 } - goto tr6 - case 41: - if data[p] == 109 { - goto tr49 + default: + goto tr80 + } + goto st1 + st21: + if p++; p == pe { + goto _test_eof21 + } + st_case_21: + switch data[p] { + case 33: + goto tr2 + case 47: + goto tr26 + case 123: + goto tr26 + case 125: + goto tr26 + } + switch { + case data[p] < 48: + switch { + case data[p] > 35: + if 37 <= data[p] && data[p] <= 45 { + goto tr26 + } + case data[p] >= 34: + goto tr26 } - goto tr6 - case 42: - if data[p] == 46 { - goto tr50 + case data[p] > 57: + switch { + case data[p] > 63: + if 91 <= data[p] && data[p] <= 95 { + goto tr26 + } + case data[p] >= 58: + goto tr26 } - goto tr6 - case 43: - if data[p] == 95 { - goto tr51 + default: + goto tr27 + } + goto st1 + tr27: + // line 1 "NONE" + + te = p + 1 + + // line 56 "lexer.rl" + + act = 2 + goto st50 + st50: + if p++; p == pe { + goto _test_eof50 + } + st_case_50: + // line 1092 "lexer.go" + switch data[p] { + case 33: + goto tr2 + case 47: + goto tr79 + case 123: + goto tr79 + case 125: + goto tr79 + } + switch { + case data[p] < 48: + switch { + case data[p] > 35: + if 37 <= data[p] && data[p] <= 45 { + goto tr79 + } + case data[p] >= 34: + goto tr79 } - if 65 <= data[p] && data[p] <= 90 { - goto tr51 - } - goto tr6 - case 55: - if data[p] == 95 { - goto tr51 - } - if 65 <= data[p] && data[p] <= 90 { - goto tr51 + case data[p] > 57: + switch { + case data[p] > 63: + if 91 <= data[p] && data[p] <= 95 { + goto tr79 + } + case data[p] >= 58: + goto tr79 } + default: + goto tr27 + } + goto st1 + st51: + if p++; p == pe { + goto _test_eof51 + } + st_case_51: + switch data[p] { + case 61: + goto tr83 + case 62: + goto tr84 + } + goto tr82 + st52: + if p++; p == pe { + goto _test_eof52 + } + st_case_52: + if data[p] == 61 { goto tr86 } - - tr6: - cs = 0 - goto _again - tr1: - cs = 1 - goto _again - tr3: - cs = 2 - goto _again - tr52: - cs = 3 - goto _again - tr5: - cs = 4 - goto _again - tr8: - cs = 5 - goto _again - tr9: - cs = 6 - goto _again - tr11: - cs = 7 - goto _again - tr12: - cs = 8 - goto _again - tr7: - cs = 9 - goto _again - tr13: - cs = 10 - goto _again - tr14: - cs = 11 - goto _again - tr53: - cs = 12 - goto _again - tr16: - cs = 13 - goto _again - tr18: - cs = 14 - goto _again - tr19: - cs = 15 - goto _again - tr17: - cs = 16 - goto _again - tr21: - cs = 17 - goto _again - tr55: - cs = 18 - goto _again - tr23: - cs = 19 - goto _again - tr24: - cs = 20 - goto _again - tr80: - cs = 21 - goto _again - tr68: - cs = 22 - goto _again - tr28: - cs = 23 - goto _again - tr30: - cs = 24 - goto _again - tr69: - cs = 25 - goto _again - tr32: - cs = 26 - goto _again - tr33: - cs = 27 - goto _again - tr34: - cs = 28 - goto _again - tr70: - cs = 29 - goto _again - tr36: - cs = 30 - goto _again - tr38: - cs = 31 - goto _again - tr37: - cs = 32 - goto _again - tr72: - cs = 33 - goto _again - tr40: - cs = 34 - goto _again - tr41: - cs = 35 - goto _again - tr42: - cs = 36 - goto _again - tr44: - cs = 37 - goto _again - tr45: - cs = 38 - goto _again - tr46: - cs = 39 - goto _again - tr47: - cs = 40 - goto _again - tr43: - cs = 41 - goto _again - tr49: - cs = 42 - goto _again - tr50: - cs = 43 - goto _again - tr0: - cs = 44 - goto f0 - tr2: - cs = 44 - goto f1 - tr10: - cs = 44 - goto f3 - tr15: - cs = 44 - goto f4 - tr25: - cs = 44 - goto f6 - tr26: - cs = 44 - goto f7 - tr31: - cs = 44 - goto f9 - tr48: - cs = 44 - goto f12 - tr54: - cs = 44 - goto f15 - tr56: - cs = 44 - goto f16 - tr57: - cs = 44 - goto f17 - tr58: - cs = 44 - goto f18 - tr59: - cs = 44 - goto f19 - tr60: - cs = 44 - goto f20 - tr61: - cs = 44 - goto f21 - tr62: - cs = 44 - goto f22 - tr64: - cs = 44 - goto f23 - tr66: - cs = 44 - goto f24 - tr71: - cs = 44 - goto f25 - tr73: - cs = 44 - goto f26 - tr74: - cs = 44 - goto f27 - tr75: - cs = 44 - goto f28 - tr76: - cs = 44 - goto f29 - tr77: - cs = 44 - goto f30 - tr78: - cs = 44 - goto f31 - tr81: - cs = 44 - goto f32 - tr82: - cs = 44 - goto f33 - tr83: - cs = 44 - goto f34 - tr84: - cs = 44 - goto f35 - tr85: - cs = 44 - goto f36 - tr86: - cs = 44 - goto f37 - tr4: - cs = 45 - goto f2 - tr20: - cs = 46 - goto _again - tr22: - cs = 47 - goto f5 - tr63: - cs = 48 - goto f8 - tr79: - cs = 49 - goto f8 - tr27: - cs = 50 - goto f8 - tr65: - cs = 51 - goto _again - tr67: - cs = 52 - goto _again + goto tr85 + st22: + if p++; p == pe { + goto _test_eof22 + } + st_case_22: + switch data[p] { + case 33: + goto tr2 + case 36: + goto st17 + case 46: + goto st23 + case 123: + goto st0 + case 125: + goto st0 + } + switch { + case data[p] < 58: + switch { + case data[p] > 47: + if 48 <= data[p] && data[p] <= 57 { + goto tr29 + } + case data[p] >= 34: + goto st0 + } + case data[p] > 63: + switch { + case data[p] > 90: + if 91 <= data[p] && data[p] <= 95 { + goto st0 + } + case data[p] >= 65: + goto st24 + } + default: + goto st0 + } + goto st1 + st23: + if p++; p == pe { + goto _test_eof23 + } + st_case_23: + switch data[p] { + case 33: + goto tr2 + case 40: + goto tr31 + case 46: + goto st23 + case 123: + goto tr0 + case 125: + goto tr0 + } + switch { + case data[p] < 48: + switch { + case data[p] > 35: + if 37 <= data[p] && data[p] <= 47 { + goto tr0 + } + case data[p] >= 34: + goto tr0 + } + case data[p] > 57: + switch { + case data[p] < 65: + if 58 <= data[p] && data[p] <= 63 { + goto tr0 + } + case data[p] > 90: + if 91 <= data[p] && data[p] <= 95 { + goto tr0 + } + default: + goto st23 + } + default: + goto st23 + } + goto st1 tr29: - cs = 53 - goto f5 + // line 1 "NONE" + + te = p + 1 + + // line 57 "lexer.rl" + + act = 3 + goto st53 + st53: + if p++; p == pe { + goto _test_eof53 + } + st_case_53: + // line 1245 "lexer.go" + switch data[p] { + case 33: + goto tr2 + case 40: + goto tr31 + case 46: + goto st23 + case 123: + goto tr78 + case 125: + goto tr78 + } + switch { + case data[p] < 48: + switch { + case data[p] > 35: + if 37 <= data[p] && data[p] <= 47 { + goto tr78 + } + case data[p] >= 34: + goto tr78 + } + case data[p] > 57: + switch { + case data[p] < 65: + if 58 <= data[p] && data[p] <= 63 { + goto tr78 + } + case data[p] > 90: + if 91 <= data[p] && data[p] <= 95 { + goto tr78 + } + default: + goto st23 + } + default: + goto tr29 + } + goto st1 + st24: + if p++; p == pe { + goto _test_eof24 + } + st_case_24: + switch data[p] { + case 33: + goto tr2 + case 36: + goto st17 + case 40: + goto tr31 + case 46: + goto st23 + case 123: + goto tr0 + case 125: + goto tr0 + } + switch { + case data[p] < 58: + switch { + case data[p] > 47: + if 48 <= data[p] && data[p] <= 57 { + goto tr29 + } + case data[p] >= 34: + goto tr0 + } + case data[p] > 63: + switch { + case data[p] > 90: + if 91 <= data[p] && data[p] <= 95 { + goto tr0 + } + case data[p] >= 65: + goto st24 + } + default: + goto tr0 + } + goto st1 + st25: + if p++; p == pe { + goto _test_eof25 + } + st_case_25: + switch data[p] { + case 33: + goto tr2 + case 36: + goto st17 + case 46: + goto st23 + case 65: + goto st26 + case 123: + goto st0 + case 125: + goto st0 + } + switch { + case data[p] < 58: + switch { + case data[p] > 47: + if 48 <= data[p] && data[p] <= 57 { + goto tr29 + } + case data[p] >= 34: + goto st0 + } + case data[p] > 63: + switch { + case data[p] > 90: + if 91 <= data[p] && data[p] <= 95 { + goto st0 + } + case data[p] >= 66: + goto st24 + } + default: + goto st0 + } + goto st1 + st26: + if p++; p == pe { + goto _test_eof26 + } + st_case_26: + switch data[p] { + case 33: + goto tr2 + case 36: + goto st17 + case 40: + goto tr31 + case 46: + goto st23 + case 76: + goto st27 + case 123: + goto st0 + case 125: + goto st0 + } + switch { + case data[p] < 58: + switch { + case data[p] > 47: + if 48 <= data[p] && data[p] <= 57 { + goto tr29 + } + case data[p] >= 34: + goto st0 + } + case data[p] > 63: + switch { + case data[p] > 90: + if 91 <= data[p] && data[p] <= 95 { + goto st0 + } + case data[p] >= 65: + goto st24 + } + default: + goto st0 + } + goto st1 + st27: + if p++; p == pe { + goto _test_eof27 + } + st_case_27: + switch data[p] { + case 33: + goto tr2 + case 36: + goto st17 + case 40: + goto tr31 + case 46: + goto st23 + case 83: + goto st28 + case 123: + goto st0 + case 125: + goto st0 + } + switch { + case data[p] < 58: + switch { + case data[p] > 47: + if 48 <= data[p] && data[p] <= 57 { + goto tr29 + } + case data[p] >= 34: + goto st0 + } + case data[p] > 63: + switch { + case data[p] > 90: + if 91 <= data[p] && data[p] <= 95 { + goto st0 + } + case data[p] >= 65: + goto st24 + } + default: + goto st0 + } + goto st1 + st28: + if p++; p == pe { + goto _test_eof28 + } + st_case_28: + switch data[p] { + case 33: + goto tr2 + case 36: + goto st17 + case 40: + goto tr31 + case 46: + goto st23 + case 69: + goto tr35 + case 123: + goto st0 + case 125: + goto st0 + } + switch { + case data[p] < 58: + switch { + case data[p] > 47: + if 48 <= data[p] && data[p] <= 57 { + goto tr29 + } + case data[p] >= 34: + goto st0 + } + case data[p] > 63: + switch { + case data[p] > 90: + if 91 <= data[p] && data[p] <= 95 { + goto st0 + } + case data[p] >= 65: + goto st24 + } + default: + goto st0 + } + goto st1 tr35: - cs = 54 - goto f10 + // line 1 "NONE" + + te = p + 1 + + // line 55 "lexer.rl" + + act = 1 + goto st54 tr39: + // line 1 "NONE" + + te = p + 1 + + // line 58 "lexer.rl" + + act = 4 + goto st54 + st54: + if p++; p == pe { + goto _test_eof54 + } + st_case_54: + // line 1524 "lexer.go" + switch data[p] { + case 33: + goto tr2 + case 36: + goto st17 + case 40: + goto tr31 + case 46: + goto st23 + case 123: + goto tr0 + case 125: + goto tr0 + } + switch { + case data[p] < 58: + switch { + case data[p] > 47: + if 48 <= data[p] && data[p] <= 57 { + goto tr29 + } + case data[p] >= 34: + goto tr0 + } + case data[p] > 63: + switch { + case data[p] > 90: + if 91 <= data[p] && data[p] <= 95 { + goto tr0 + } + case data[p] >= 65: + goto st24 + } + default: + goto tr0 + } + goto st1 + st29: + if p++; p == pe { + goto _test_eof29 + } + st_case_29: + switch data[p] { + case 33: + goto tr2 + case 36: + goto st17 + case 46: + goto st23 + case 79: + goto st30 + case 82: + goto st32 + case 123: + goto st0 + case 125: + goto st0 + } + switch { + case data[p] < 58: + switch { + case data[p] > 47: + if 48 <= data[p] && data[p] <= 57 { + goto tr29 + } + case data[p] >= 34: + goto st0 + } + case data[p] > 63: + switch { + case data[p] > 90: + if 91 <= data[p] && data[p] <= 95 { + goto st0 + } + case data[p] >= 65: + goto st24 + } + default: + goto st0 + } + goto st1 + st30: + if p++; p == pe { + goto _test_eof30 + } + st_case_30: + switch data[p] { + case 33: + goto tr2 + case 36: + goto st17 + case 40: + goto tr31 + case 46: + goto st23 + case 68: + goto st31 + case 123: + goto st0 + case 125: + goto st0 + } + switch { + case data[p] < 58: + switch { + case data[p] > 47: + if 48 <= data[p] && data[p] <= 57 { + goto tr29 + } + case data[p] >= 34: + goto st0 + } + case data[p] > 63: + switch { + case data[p] > 90: + if 91 <= data[p] && data[p] <= 95 { + goto st0 + } + case data[p] >= 65: + goto st24 + } + default: + goto st0 + } + goto st1 + st31: + if p++; p == pe { + goto _test_eof31 + } + st_case_31: + switch data[p] { + case 33: + goto tr2 + case 36: + goto st17 + case 40: + goto tr31 + case 46: + goto st23 + case 79: + goto tr39 + case 123: + goto st0 + case 125: + goto st0 + } + switch { + case data[p] < 58: + switch { + case data[p] > 47: + if 48 <= data[p] && data[p] <= 57 { + goto tr29 + } + case data[p] >= 34: + goto st0 + } + case data[p] > 63: + switch { + case data[p] > 90: + if 91 <= data[p] && data[p] <= 95 { + goto st0 + } + case data[p] >= 65: + goto st24 + } + default: + goto st0 + } + goto st1 + st32: + if p++; p == pe { + goto _test_eof32 + } + st_case_32: + switch data[p] { + case 33: + goto tr2 + case 36: + goto st17 + case 40: + goto tr31 + case 46: + goto st23 + case 85: + goto st28 + case 123: + goto st0 + case 125: + goto st0 + } + switch { + case data[p] < 58: + switch { + case data[p] > 47: + if 48 <= data[p] && data[p] <= 57 { + goto tr29 + } + case data[p] >= 34: + goto st0 + } + case data[p] > 63: + switch { + case data[p] > 90: + if 91 <= data[p] && data[p] <= 95 { + goto st0 + } + case data[p] >= 65: + goto st24 + } + default: + goto st0 + } + goto st1 + st33: + if p++; p == pe { + goto _test_eof33 + } + st_case_33: + if data[p] == 120 { + goto st34 + } + goto st0 + st34: + if p++; p == pe { + goto _test_eof34 + } + st_case_34: + if data[p] == 108 { + goto st35 + } + goto st0 + st35: + if p++; p == pe { + goto _test_eof35 + } + st_case_35: + switch data[p] { + case 102: + goto st36 + case 110: + goto st41 + } + goto st0 + st36: + if p++; p == pe { + goto _test_eof36 + } + st_case_36: + if data[p] == 110 { + goto st37 + } + goto st0 + st37: + if p++; p == pe { + goto _test_eof37 + } + st_case_37: + if data[p] == 46 { + goto st38 + } + goto st0 + st38: + if p++; p == pe { + goto _test_eof38 + } + st_case_38: + if data[p] == 95 { + goto st39 + } + if 65 <= data[p] && data[p] <= 90 { + goto st39 + } + goto st0 + st39: + if p++; p == pe { + goto _test_eof39 + } + st_case_39: + if data[p] == 46 { + goto st40 + } + switch { + case data[p] > 57: + if 65 <= data[p] && data[p] <= 90 { + goto st40 + } + case data[p] >= 48: + goto st40 + } + goto st0 + st40: + if p++; p == pe { + goto _test_eof40 + } + st_case_40: + switch data[p] { + case 40: + goto tr48 + case 46: + goto st40 + } + switch { + case data[p] > 57: + if 65 <= data[p] && data[p] <= 90 { + goto st40 + } + case data[p] >= 48: + goto st40 + } + goto st0 + st41: + if p++; p == pe { + goto _test_eof41 + } + st_case_41: + if data[p] == 109 { + goto st42 + } + goto st0 + st42: + if p++; p == pe { + goto _test_eof42 + } + st_case_42: + if data[p] == 46 { + goto st43 + } + goto st0 + st43: + if p++; p == pe { + goto _test_eof43 + } + st_case_43: + if data[p] == 95 { + goto st55 + } + if 65 <= data[p] && data[p] <= 90 { + goto st55 + } + goto st0 + st55: + if p++; p == pe { + goto _test_eof55 + } + st_case_55: + if data[p] == 95 { + goto st55 + } + if 65 <= data[p] && data[p] <= 90 { + goto st55 + } + goto tr87 + st_out: + _test_eof44: + cs = 44 + goto _test_eof + _test_eof1: + cs = 1 + goto _test_eof + _test_eof2: + cs = 2 + goto _test_eof + _test_eof45: + cs = 45 + goto _test_eof + _test_eof3: + cs = 3 + goto _test_eof + _test_eof4: + cs = 4 + goto _test_eof + _test_eof5: + cs = 5 + goto _test_eof + _test_eof6: + cs = 6 + goto _test_eof + _test_eof7: + cs = 7 + goto _test_eof + _test_eof8: + cs = 8 + goto _test_eof + _test_eof9: + cs = 9 + goto _test_eof + _test_eof10: + cs = 10 + goto _test_eof + _test_eof11: + cs = 11 + goto _test_eof + _test_eof12: + cs = 12 + goto _test_eof + _test_eof13: + cs = 13 + goto _test_eof + _test_eof14: + cs = 14 + goto _test_eof + _test_eof15: + cs = 15 + goto _test_eof + _test_eof46: + cs = 46 + goto _test_eof + _test_eof16: + cs = 16 + goto _test_eof + _test_eof17: + cs = 17 + goto _test_eof + _test_eof47: + cs = 47 + goto _test_eof + _test_eof18: + cs = 18 + goto _test_eof + _test_eof19: + cs = 19 + goto _test_eof + _test_eof20: + cs = 20 + goto _test_eof + _test_eof48: + cs = 48 + goto _test_eof + _test_eof49: + cs = 49 + goto _test_eof + _test_eof21: + cs = 21 + goto _test_eof + _test_eof50: + cs = 50 + goto _test_eof + _test_eof51: + cs = 51 + goto _test_eof + _test_eof52: + cs = 52 + goto _test_eof + _test_eof22: + cs = 22 + goto _test_eof + _test_eof23: + cs = 23 + goto _test_eof + _test_eof53: + cs = 53 + goto _test_eof + _test_eof24: + cs = 24 + goto _test_eof + _test_eof25: + cs = 25 + goto _test_eof + _test_eof26: + cs = 26 + goto _test_eof + _test_eof27: + cs = 27 + goto _test_eof + _test_eof28: + cs = 28 + goto _test_eof + _test_eof54: cs = 54 - goto f11 - tr51: + goto _test_eof + _test_eof29: + cs = 29 + goto _test_eof + _test_eof30: + cs = 30 + goto _test_eof + _test_eof31: + cs = 31 + goto _test_eof + _test_eof32: + cs = 32 + goto _test_eof + _test_eof33: + cs = 33 + goto _test_eof + _test_eof34: + cs = 34 + goto _test_eof + _test_eof35: + cs = 35 + goto _test_eof + _test_eof36: + cs = 36 + goto _test_eof + _test_eof37: + cs = 37 + goto _test_eof + _test_eof38: + cs = 38 + goto _test_eof + _test_eof39: + cs = 39 + goto _test_eof + _test_eof40: + cs = 40 + goto _test_eof + _test_eof41: + cs = 41 + goto _test_eof + _test_eof42: + cs = 42 + goto _test_eof + _test_eof43: + cs = 43 + goto _test_eof + _test_eof55: cs = 55 - goto _again + goto _test_eof - f3: - _acts = 3 - goto execFuncs - f4: - _acts = 5 - goto execFuncs - f1: - _acts = 7 - goto execFuncs - f6: - _acts = 9 - goto execFuncs - f9: - _acts = 11 - goto execFuncs - f12: - _acts = 13 - goto execFuncs - f15: - _acts = 15 - goto execFuncs - f26: - _acts = 17 - goto execFuncs - f27: - _acts = 19 - goto execFuncs - f16: - _acts = 21 - goto execFuncs - f17: - _acts = 23 - goto execFuncs - f19: - _acts = 25 - goto execFuncs - f21: - _acts = 27 - goto execFuncs - f18: - _acts = 29 - goto execFuncs - f22: - _acts = 31 - goto execFuncs - f25: - _acts = 33 - goto execFuncs - f24: - _acts = 35 - goto execFuncs - f33: - _acts = 37 - goto execFuncs - f36: - _acts = 39 - goto execFuncs - f34: - _acts = 41 - goto execFuncs - f23: - _acts = 43 - goto execFuncs - f20: - _acts = 45 - goto execFuncs - f31: - _acts = 47 - goto execFuncs - f30: - _acts = 49 - goto execFuncs - f29: - _acts = 51 - goto execFuncs - f37: - _acts = 53 - goto execFuncs - f28: - _acts = 55 - goto execFuncs - f32: - _acts = 57 - goto execFuncs - f35: - _acts = 59 - goto execFuncs - f7: - _acts = 61 - goto execFuncs - f0: - _acts = 63 - goto execFuncs - f10: - _acts = 68 - goto execFuncs - f8: - _acts = 71 - goto execFuncs - f5: - _acts = 74 - goto execFuncs - f11: - _acts = 77 - goto execFuncs - f2: - _acts = 80 - goto execFuncs - - execFuncs: - _nacts = uint(_formula_actions[_acts]) - _acts++ - for ; _nacts > 0; _nacts-- { - _acts++ - switch _formula_actions[_acts-1] { - case 3: - // line 1 "NONE" - - te = p + 1 - - case 4: - // line 55 "lexer.rl" - - act = 1 - case 5: - // line 56 "lexer.rl" - - act = 2 - case 6: - // line 57 "lexer.rl" - - act = 3 - case 7: - // line 58 "lexer.rl" - - act = 4 - case 8: - // line 71 "lexer.rl" - - act = 13 - case 9: - // line 59 "lexer.rl" - - te = p + 1 - { - l.emit(tokenError, data[ts:te]) - } - case 10: - // line 60 "lexer.rl" - - te = p + 1 - { - l.emit(tokenErrorRef, data[ts:te]) - } - case 11: - // line 62 "lexer.rl" - - te = p + 1 - { - l.emit(tokenSheet, data[ts:te-1]) - } - case 12: - // line 63 "lexer.rl" - - te = p + 1 - { - l.emit(tokenSheet, data[ts+1:te-2]) - } - case 13: - // line 67 "lexer.rl" - - te = p + 1 - { - l.emit(tokenFunctionBultin, data[ts:te-1]) - } - case 14: - // line 68 "lexer.rl" - - te = p + 1 - { - l.emit(tokenFunctionBultin, data[ts:te-1]) - } - case 15: - // line 74 "lexer.rl" - - te = p + 1 - { - l.emit(tokenAmpersand, data[ts:te]) - } - case 16: - // line 75 "lexer.rl" - - te = p + 1 - { - l.emit(tokenLBrace, data[ts:te]) - } - case 17: - // line 76 "lexer.rl" - - te = p + 1 - { - l.emit(tokenRBrace, data[ts:te]) - } - case 18: - // line 77 "lexer.rl" - - te = p + 1 - { - l.emit(tokenLParen, data[ts:te]) - } - case 19: - // line 78 "lexer.rl" - - te = p + 1 - { - l.emit(tokenRParen, data[ts:te]) - } - case 20: - // line 79 "lexer.rl" - - te = p + 1 - { - l.emit(tokenPlus, data[ts:te]) - } - case 21: - // line 80 "lexer.rl" - - te = p + 1 - { - l.emit(tokenMinus, data[ts:te]) - } - case 22: - // line 81 "lexer.rl" - - te = p + 1 - { - l.emit(tokenMult, data[ts:te]) - } - case 23: - // line 82 "lexer.rl" - - te = p + 1 - { - l.emit(tokenDiv, data[ts:te]) - } - case 24: - // line 83 "lexer.rl" - - te = p + 1 - { - l.emit(tokenExp, data[ts:te]) - } - case 25: - // line 86 "lexer.rl" - - te = p + 1 - { - l.emit(tokenEQ, data[ts:te]) - } - case 26: - // line 87 "lexer.rl" - - te = p + 1 - { - l.emit(tokenLEQ, data[ts:te]) - } - case 27: - // line 88 "lexer.rl" - - te = p + 1 - { - l.emit(tokenGEQ, data[ts:te]) - } - case 28: - // line 89 "lexer.rl" - - te = p + 1 - { - l.emit(tokenNE, data[ts:te]) - } - case 29: - // line 91 "lexer.rl" - - te = p + 1 - { - l.emit(tokenColon, data[ts:te]) - } - case 30: - // line 92 "lexer.rl" - - te = p + 1 - { - l.emit(tokenComma, data[ts:te]) - } - case 31: - // line 56 "lexer.rl" - - te = p - p-- - { - l.emit(tokenNumber, data[ts:te]) - } - case 32: - // line 57 "lexer.rl" - - te = p - p-- - { - l.emit(tokenCell, data[ts:te]) - } - case 33: - // line 61 "lexer.rl" - - te = p - p-- - { - l.emit(tokenHorizontalRange, data[ts:te]) - } - case 34: - // line 64 "lexer.rl" - - te = p - p-- - { - l.emit(tokenReservedName, data[ts:te]) - } - case 35: - // line 71 "lexer.rl" - - te = p - p-- - { - l.emit(tokenString, data[ts+1:te-1]) - } - case 36: - // line 84 "lexer.rl" - - te = p - p-- - { - l.emit(tokenLT, data[ts:te]) - } - case 37: - // line 85 "lexer.rl" - - te = p - p-- - { - l.emit(tokenGT, data[ts:te]) - } - case 38: - // line 56 "lexer.rl" - - p = (te) - 1 - { - l.emit(tokenNumber, data[ts:te]) - } - case 39: - // line 1 "NONE" - - switch act { - case 0: - { - cs = 0 - goto _again - } - case 1: - { - p = (te) - 1 - l.emit(tokenBool, data[ts:te]) - } - case 2: - { - p = (te) - 1 - l.emit(tokenNumber, data[ts:te]) - } - case 3: - { - p = (te) - 1 - l.emit(tokenCell, data[ts:te]) - } - case 4: - { - p = (te) - 1 - l.emit(tokenDDECall, data[ts:te]) - } - case 13: - { - p = (te) - 1 - l.emit(tokenString, data[ts+1:te-1]) - } - } - - // line 1627 "lexer.go" - } - } - goto _again - - _again: - _acts = int(_formula_to_state_actions[cs]) - _nacts = uint(_formula_actions[_acts]) - _acts++ - for ; _nacts > 0; _nacts-- { - _acts++ - switch _formula_actions[_acts-1] { - case 0: - // line 1 "NONE" - - ts = 0 - - case 1: - // line 1 "NONE" - - act = 0 - - // line 1648 "lexer.go" - } - } - - if cs == 0 { - goto _out - } - if p++; p != pe { - goto _resume - } _test_eof: { } @@ -1979,39 +2121,39 @@ func (l *Lexer) lex(r io.Reader) { case 2: goto tr0 case 45: - goto tr75 + goto tr76 case 14: goto tr0 case 15: goto tr0 case 46: - goto tr76 + goto tr77 case 17: goto tr0 case 47: - goto tr77 + goto tr78 case 48: - goto tr78 + goto tr79 case 49: - goto tr78 + goto tr79 case 21: goto tr26 case 50: - goto tr78 + goto tr79 case 51: - goto tr81 + goto tr82 case 52: - goto tr84 + goto tr85 case 23: goto tr0 case 53: - goto tr77 + goto tr78 case 24: goto tr0 case 54: goto tr0 case 55: - goto tr86 + goto tr87 } } @@ -2020,7 +2162,7 @@ func (l *Lexer) lex(r io.Reader) { } } - // line 141 "lexer.rl" + // line 142 "lexer.rl" if ts > 0 { // currently parsing a token, so shift it to the diff --git a/spreadsheet/formula/lexer.rl b/spreadsheet/formula/lexer.rl index ff72f53e..1c10045f 100644 --- a/spreadsheet/formula/lexer.rl +++ b/spreadsheet/formula/lexer.rl @@ -89,6 +89,7 @@ import ( '<>' { l.emit(tokenNE,data[ts:te]) }; ':' { l.emit(tokenColon,data[ts:te]) }; + ';' { l.emit(tokenSemi,data[ts:te]) }; ',' { l.emit(tokenComma,data[ts:te]) }; *|; diff --git a/spreadsheet/formula/result.go b/spreadsheet/formula/result.go index 83613198..3b9a25db 100644 --- a/spreadsheet/formula/result.go +++ b/spreadsheet/formula/result.go @@ -22,6 +22,7 @@ const ( ResultTypeNumber ResultTypeString ResultTypeList + ResultTypeArray ResultTypeError ResultTypeEmpty ) @@ -31,11 +32,12 @@ type Result struct { ValueNumber float64 ValueString string ValueList []Result + ValueArray [][]Result ErrorMessage string Type ResultType } -// Value returns a string version of the formula. +// Value returns a string version of the result. func (r Result) Value() string { switch r.Type { case ResultTypeNumber: @@ -44,6 +46,11 @@ func (r Result) Value() string { return r.ValueString case ResultTypeString: return r.ValueString + case ResultTypeList: + if len(r.ValueList) == 0 { + return "" + } + return r.ValueList[0].Value() default: return "unhandled result value" } @@ -138,3 +145,13 @@ func MakeStringResult(s string) Result { func MakeEmptyResult() Result { return Result{Type: ResultTypeEmpty} } + +// MakeArrayResult constructs an array result (matrix). +func MakeArrayResult(arr [][]Result) Result { + return Result{Type: ResultTypeArray, ValueArray: arr} +} + +// MakeListResult constructs a list result. +func MakeListResult(list []Result) Result { + return Result{Type: ResultTypeList, ValueList: list} +} diff --git a/spreadsheet/formula/resulttype_string.go b/spreadsheet/formula/resulttype_string.go index 0b232f6e..8159b116 100644 --- a/spreadsheet/formula/resulttype_string.go +++ b/spreadsheet/formula/resulttype_string.go @@ -4,9 +4,9 @@ package formula import "fmt" -const _ResultType_name = "ResultTypeUnknownResultTypeNumberResultTypeStringResultTypeListResultTypeErrorResultTypeEmpty" +const _ResultType_name = "ResultTypeUnknownResultTypeNumberResultTypeStringResultTypeListResultTypeArrayResultTypeErrorResultTypeEmpty" -var _ResultType_index = [...]uint8{0, 17, 33, 49, 63, 78, 93} +var _ResultType_index = [...]uint8{0, 17, 33, 49, 63, 78, 93, 108} func (i ResultType) String() string { if i >= ResultType(len(_ResultType_index)-1) { diff --git a/spreadsheet/formula/testdata/formulareference.xlsx b/spreadsheet/formula/testdata/formulareference.xlsx index 8553cd8cb9e9fd4e91e1c35129e89f9d56027821..defcd9a0540cb209bf916a7b6d5fc9201e9f23e2 100644 GIT binary patch delta 9458 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 delta 9268 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