From cc27fb8aab364df801883c807fdae9fdb807e6bc Mon Sep 17 00:00:00 2001 From: Julius Volz Date: Thu, 25 Dec 2014 01:28:35 +0100 Subject: [PATCH] Rename remaining all-caps constants in AST layer. Change-Id: Ibe97e30981969056ffcdb89e63c1468ea1ffa140 --- rules/ast/ast.go | 112 +- rules/ast/functions.go | 74 +- rules/ast/functions_test.go | 2 +- rules/ast/printer.go | 58 +- rules/helpers.go | 24 +- rules/lexer.l.go | 3532 ++++++++++++++++++----------------- rules/parser.y.go | 2 +- rules/rules_test.go | 2 +- web/api/query.go | 4 +- 9 files changed, 1910 insertions(+), 1900 deletions(-) diff --git a/rules/ast/ast.go b/rules/ast/ast.go index 481cce615..9a62a8077 100644 --- a/rules/ast/ast.go +++ b/rules/ast/ast.go @@ -72,10 +72,10 @@ type ExprType int // because sometimes we need to pass around just the type without an object of // that type. const ( - SCALAR ExprType = iota - VECTOR - MATRIX - STRING + ScalarType ExprType = iota + VectorType + MatrixType + StringType ) // BinOpType is an enum for binary operator types. @@ -83,26 +83,26 @@ type BinOpType int // Possible binary operator types. const ( - ADD BinOpType = iota - SUB - MUL - DIV - MOD + Add BinOpType = iota + Sub + Mul + Div + Mod NE EQ GT LT GE LE - AND - OR + And + Or ) // shouldDropMetric indicates whether the metric name should be dropped after // applying this operator to a vector. func (opType BinOpType) shouldDropMetric() bool { switch opType { - case ADD, SUB, MUL, DIV, MOD: + case Add, Sub, Mul, Div, Mod: return true default: return false @@ -114,11 +114,11 @@ type AggrType int // Possible aggregation types. const ( - SUM AggrType = iota - AVG - MIN - MAX - COUNT + Sum AggrType = iota + Avg + Min + Max + Count ) // ---------------------------------------------------------------------------- @@ -274,34 +274,34 @@ type ( // Implementations. // Type implements the Node interface. -func (node ScalarLiteral) Type() ExprType { return SCALAR } +func (node ScalarLiteral) Type() ExprType { return ScalarType } // Type implements the Node interface. -func (node ScalarFunctionCall) Type() ExprType { return SCALAR } +func (node ScalarFunctionCall) Type() ExprType { return ScalarType } // Type implements the Node interface. -func (node ScalarArithExpr) Type() ExprType { return SCALAR } +func (node ScalarArithExpr) Type() ExprType { return ScalarType } // Type implements the Node interface. -func (node VectorSelector) Type() ExprType { return VECTOR } +func (node VectorSelector) Type() ExprType { return VectorType } // Type implements the Node interface. -func (node VectorFunctionCall) Type() ExprType { return VECTOR } +func (node VectorFunctionCall) Type() ExprType { return VectorType } // Type implements the Node interface. -func (node VectorAggregation) Type() ExprType { return VECTOR } +func (node VectorAggregation) Type() ExprType { return VectorType } // Type implements the Node interface. -func (node VectorArithExpr) Type() ExprType { return VECTOR } +func (node VectorArithExpr) Type() ExprType { return VectorType } // Type implements the Node interface. -func (node MatrixSelector) Type() ExprType { return MATRIX } +func (node MatrixSelector) Type() ExprType { return MatrixType } // Type implements the Node interface. -func (node StringLiteral) Type() ExprType { return STRING } +func (node StringLiteral) Type() ExprType { return StringType } // Type implements the Node interface. -func (node StringFunctionCall) Type() ExprType { return STRING } +func (node StringFunctionCall) Type() ExprType { return StringType } // Children implements the Node interface and returns an empty slice. func (node ScalarLiteral) Children() Nodes { return Nodes{} } @@ -458,9 +458,9 @@ func (node *VectorAggregation) groupedAggregationsToVector(aggregations map[uint vector := Vector{} for _, aggregation := range aggregations { switch node.aggrType { - case AVG: + case Avg: aggregation.value = aggregation.value / clientmodel.SampleValue(aggregation.groupCount) - case COUNT: + case Count: aggregation.value = clientmodel.SampleValue(aggregation.groupCount) default: // For other aggregations, we already have the right value. @@ -488,20 +488,20 @@ func (node *VectorAggregation) Eval(timestamp clientmodel.Timestamp) Vector { } switch node.aggrType { - case SUM: + case Sum: groupedResult.value += sample.Value - case AVG: + case Avg: groupedResult.value += sample.Value groupedResult.groupCount++ - case MAX: + case Max: if groupedResult.value < sample.Value { groupedResult.value = sample.Value } - case MIN: + case Min: if groupedResult.value > sample.Value { groupedResult.value = sample.Value } - case COUNT: + case Count: groupedResult.groupCount++ default: panic("Unknown aggregation type") @@ -626,18 +626,18 @@ func evalScalarBinop(opType BinOpType, lhs clientmodel.SampleValue, rhs clientmodel.SampleValue) clientmodel.SampleValue { switch opType { - case ADD: + case Add: return lhs + rhs - case SUB: + case Sub: return lhs - rhs - case MUL: + case Mul: return lhs * rhs - case DIV: + case Div: if rhs != 0 { return lhs / rhs } return clientmodel.SampleValue(math.Inf(int(rhs))) - case MOD: + case Mod: if rhs != 0 { return clientmodel.SampleValue(int(lhs) % int(rhs)) } @@ -680,18 +680,18 @@ func evalVectorBinop(opType BinOpType, lhs clientmodel.SampleValue, rhs clientmodel.SampleValue) (clientmodel.SampleValue, bool) { switch opType { - case ADD: + case Add: return lhs + rhs, true - case SUB: + case Sub: return lhs - rhs, true - case MUL: + case Mul: return lhs * rhs, true - case DIV: + case Div: if rhs != 0 { return lhs / rhs, true } return clientmodel.SampleValue(math.Inf(int(rhs))), true - case MOD: + case Mod: if rhs != 0 { return clientmodel.SampleValue(int(lhs) % int(rhs)), true } @@ -726,9 +726,9 @@ func evalVectorBinop(opType BinOpType, return lhs, true } return 0, false - case AND: + case And: return lhs, true - case OR: + case Or: return lhs, true // TODO: implement OR } panic("Not all enum values enumerated in switch") @@ -747,7 +747,7 @@ func labelsEqual(labels1, labels2 clientmodel.Metric) bool { // the expression. func (node *VectorArithExpr) Eval(timestamp clientmodel.Timestamp) Vector { result := Vector{} - if node.lhs.Type() == SCALAR && node.rhs.Type() == VECTOR { + if node.lhs.Type() == ScalarType && node.rhs.Type() == VectorType { lhs := node.lhs.(ScalarNode).Eval(timestamp) rhs := node.rhs.(VectorNode).Eval(timestamp) for _, rhsSample := range rhs { @@ -761,7 +761,7 @@ func (node *VectorArithExpr) Eval(timestamp clientmodel.Timestamp) Vector { } } return result - } else if node.lhs.Type() == VECTOR && node.rhs.Type() == SCALAR { + } else if node.lhs.Type() == VectorType && node.rhs.Type() == ScalarType { lhs := node.lhs.(VectorNode).Eval(timestamp) rhs := node.rhs.(ScalarNode).Eval(timestamp) for _, lhsSample := range lhs { @@ -775,7 +775,7 @@ func (node *VectorArithExpr) Eval(timestamp clientmodel.Timestamp) Vector { } } return result - } else if node.lhs.Type() == VECTOR && node.rhs.Type() == VECTOR { + } else if node.lhs.Type() == VectorType && node.rhs.Type() == VectorType { lhs := node.lhs.(VectorNode).Eval(timestamp) rhs := node.rhs.(VectorNode).Eval(timestamp) for _, lhsSample := range lhs { @@ -916,17 +916,17 @@ func NewFunctionCall(function *Function, args Nodes) (Node, error) { return nil, err } switch function.returnType { - case SCALAR: + case ScalarType: return &ScalarFunctionCall{ function: function, args: args, }, nil - case VECTOR: + case VectorType: return &VectorFunctionCall{ function: function, args: args, }, nil - case STRING: + case StringType: return &StringFunctionCall{ function: function, args: args, @@ -953,17 +953,17 @@ func nodesHaveTypes(nodes Nodes, exprTypes []ExprType) bool { // NewArithExpr returns a (not yet evaluated) expression node (of type // VectorArithExpr or ScalarArithExpr). func NewArithExpr(opType BinOpType, lhs Node, rhs Node) (Node, error) { - if !nodesHaveTypes(Nodes{lhs, rhs}, []ExprType{SCALAR, VECTOR}) { + if !nodesHaveTypes(Nodes{lhs, rhs}, []ExprType{ScalarType, VectorType}) { return nil, errors.New("binary operands must be of vector or scalar type") } - if opType == AND || opType == OR { - if lhs.Type() == SCALAR || rhs.Type() == SCALAR { + if opType == And || opType == Or { + if lhs.Type() == ScalarType || rhs.Type() == ScalarType { return nil, errors.New("AND and OR operators may only be used between vectors") } } - if lhs.Type() == VECTOR || rhs.Type() == VECTOR { + if lhs.Type() == VectorType || rhs.Type() == VectorType { return &VectorArithExpr{ opType: opType, lhs: lhs, diff --git a/rules/ast/functions.go b/rules/ast/functions.go index 3604cc87d..1ebcf2d1b 100644 --- a/rules/ast/functions.go +++ b/rules/ast/functions.go @@ -46,19 +46,19 @@ func (function *Function) CheckArgTypes(args []Node) error { for idx, argType := range function.argTypes { invalidType := false var expectedType string - if _, ok := args[idx].(ScalarNode); argType == SCALAR && !ok { + if _, ok := args[idx].(ScalarNode); argType == ScalarType && !ok { invalidType = true expectedType = "scalar" } - if _, ok := args[idx].(VectorNode); argType == VECTOR && !ok { + if _, ok := args[idx].(VectorNode); argType == VectorType && !ok { invalidType = true expectedType = "vector" } - if _, ok := args[idx].(MatrixNode); argType == MATRIX && !ok { + if _, ok := args[idx].(MatrixNode); argType == MatrixType && !ok { invalidType = true expectedType = "matrix" } - if _, ok := args[idx].(StringNode); argType == STRING && !ok { + if _, ok := args[idx].(StringNode); argType == StringType && !ok { invalidType = true expectedType = "string" } @@ -409,104 +409,104 @@ func absentImpl(timestamp clientmodel.Timestamp, args []Node) interface{} { var functions = map[string]*Function{ "abs": { name: "abs", - argTypes: []ExprType{VECTOR}, - returnType: VECTOR, + argTypes: []ExprType{VectorType}, + returnType: VectorType, callFn: absImpl, }, "absent": { name: "absent", - argTypes: []ExprType{VECTOR}, - returnType: VECTOR, + argTypes: []ExprType{VectorType}, + returnType: VectorType, callFn: absentImpl, }, "avg_over_time": { name: "avg_over_time", - argTypes: []ExprType{MATRIX}, - returnType: VECTOR, + argTypes: []ExprType{MatrixType}, + returnType: VectorType, callFn: avgOverTimeImpl, }, "bottomk": { name: "bottomk", - argTypes: []ExprType{SCALAR, VECTOR}, - returnType: VECTOR, + argTypes: []ExprType{ScalarType, VectorType}, + returnType: VectorType, callFn: bottomkImpl, }, "count_over_time": { name: "count_over_time", - argTypes: []ExprType{MATRIX}, - returnType: VECTOR, + argTypes: []ExprType{MatrixType}, + returnType: VectorType, callFn: countOverTimeImpl, }, "count_scalar": { name: "count_scalar", - argTypes: []ExprType{VECTOR}, - returnType: SCALAR, + argTypes: []ExprType{VectorType}, + returnType: ScalarType, callFn: countScalarImpl, }, "delta": { name: "delta", - argTypes: []ExprType{MATRIX, SCALAR}, - returnType: VECTOR, + argTypes: []ExprType{MatrixType, ScalarType}, + returnType: VectorType, callFn: deltaImpl, }, "drop_common_labels": { name: "drop_common_labels", - argTypes: []ExprType{VECTOR}, - returnType: VECTOR, + argTypes: []ExprType{VectorType}, + returnType: VectorType, callFn: dropCommonLabelsImpl, }, "max_over_time": { name: "max_over_time", - argTypes: []ExprType{MATRIX}, - returnType: VECTOR, + argTypes: []ExprType{MatrixType}, + returnType: VectorType, callFn: maxOverTimeImpl, }, "min_over_time": { name: "min_over_time", - argTypes: []ExprType{MATRIX}, - returnType: VECTOR, + argTypes: []ExprType{MatrixType}, + returnType: VectorType, callFn: minOverTimeImpl, }, "rate": { name: "rate", - argTypes: []ExprType{MATRIX}, - returnType: VECTOR, + argTypes: []ExprType{MatrixType}, + returnType: VectorType, callFn: rateImpl, }, "scalar": { name: "scalar", - argTypes: []ExprType{VECTOR}, - returnType: SCALAR, + argTypes: []ExprType{VectorType}, + returnType: ScalarType, callFn: scalarImpl, }, "sort": { name: "sort", - argTypes: []ExprType{VECTOR}, - returnType: VECTOR, + argTypes: []ExprType{VectorType}, + returnType: VectorType, callFn: sortImpl, }, "sort_desc": { name: "sort_desc", - argTypes: []ExprType{VECTOR}, - returnType: VECTOR, + argTypes: []ExprType{VectorType}, + returnType: VectorType, callFn: sortDescImpl, }, "sum_over_time": { name: "sum_over_time", - argTypes: []ExprType{MATRIX}, - returnType: VECTOR, + argTypes: []ExprType{MatrixType}, + returnType: VectorType, callFn: sumOverTimeImpl, }, "time": { name: "time", argTypes: []ExprType{}, - returnType: SCALAR, + returnType: ScalarType, callFn: timeImpl, }, "topk": { name: "topk", - argTypes: []ExprType{SCALAR, VECTOR}, - returnType: VECTOR, + argTypes: []ExprType{ScalarType, VectorType}, + returnType: VectorType, callFn: topkImpl, }, } diff --git a/rules/ast/functions_test.go b/rules/ast/functions_test.go index 86add4eae..8521417d5 100644 --- a/rules/ast/functions_test.go +++ b/rules/ast/functions_test.go @@ -23,7 +23,7 @@ import ( type emptyRangeNode struct{} -func (node emptyRangeNode) Type() ExprType { return MATRIX } +func (node emptyRangeNode) Type() ExprType { return MatrixType } func (node emptyRangeNode) NodeTreeToDotGraph() string { return "" } func (node emptyRangeNode) String() string { return "" } func (node emptyRangeNode) Children() Nodes { return Nodes{} } diff --git a/rules/ast/printer.go b/rules/ast/printer.go index 0155a5838..1e980b3e5 100644 --- a/rules/ast/printer.go +++ b/rules/ast/printer.go @@ -33,46 +33,46 @@ type OutputFormat int // Possible output formats. const ( - TEXT OutputFormat = iota + Text OutputFormat = iota JSON ) func (opType BinOpType) String() string { opTypeMap := map[BinOpType]string{ - ADD: "+", - SUB: "-", - MUL: "*", - DIV: "/", - MOD: "%", + Add: "+", + Sub: "-", + Mul: "*", + Div: "/", + Mod: "%", GT: ">", LT: "<", EQ: "==", NE: "!=", GE: ">=", LE: "<=", - AND: "AND", - OR: "OR", + And: "AND", + Or: "OR", } return opTypeMap[opType] } func (aggrType AggrType) String() string { aggrTypeMap := map[AggrType]string{ - SUM: "SUM", - AVG: "AVG", - MIN: "MIN", - MAX: "MAX", - COUNT: "COUNT", + Sum: "SUM", + Avg: "AVG", + Min: "MIN", + Max: "MAX", + Count: "COUNT", } return aggrTypeMap[aggrType] } func (exprType ExprType) String() string { exprTypeMap := map[ExprType]string{ - SCALAR: "scalar", - VECTOR: "vector", - MATRIX: "matrix", - STRING: "string", + ScalarType: "scalar", + VectorType: "vector", + MatrixType: "matrix", + StringType: "string", } return exprTypeMap[exprType] } @@ -164,38 +164,38 @@ func EvalToString(node Node, timestamp clientmodel.Timestamp, format OutputForma evalTimer := queryStats.GetTimer(stats.InnerEvalTime).Start() switch node.Type() { - case SCALAR: + case ScalarType: scalar := node.(ScalarNode).Eval(timestamp) evalTimer.Stop() switch format { - case TEXT: + case Text: return fmt.Sprintf("scalar: %v @[%v]", scalar, timestamp) case JSON: return TypedValueToJSON(scalar, "scalar") } - case VECTOR: + case VectorType: vector := node.(VectorNode).Eval(timestamp) evalTimer.Stop() switch format { - case TEXT: + case Text: return vector.String() case JSON: return TypedValueToJSON(vector, "vector") } - case MATRIX: + case MatrixType: matrix := node.(MatrixNode).Eval(timestamp) evalTimer.Stop() switch format { - case TEXT: + case Text: return matrix.String() case JSON: return TypedValueToJSON(matrix, "matrix") } - case STRING: + case StringType: str := node.(StringNode).Eval(timestamp) evalTimer.Stop() switch format { - case TEXT: + case Text: return str case JSON: return TypedValueToJSON(str, "string") @@ -216,17 +216,17 @@ func EvalToVector(node Node, timestamp clientmodel.Timestamp, storage local.Stor evalTimer := queryStats.GetTimer(stats.InnerEvalTime).Start() switch node.Type() { - case SCALAR: + case ScalarType: scalar := node.(ScalarNode).Eval(timestamp) evalTimer.Stop() return Vector{&Sample{Value: scalar}}, nil - case VECTOR: + case VectorType: vector := node.(VectorNode).Eval(timestamp) evalTimer.Stop() return vector, nil - case MATRIX: + case MatrixType: return nil, errors.New("matrices not supported by EvalToVector") - case STRING: + case StringType: str := node.(StringNode).Eval(timestamp) evalTimer.Stop() return Vector{ diff --git a/rules/helpers.go b/rules/helpers.go index 593859379..2f589bf68 100644 --- a/rules/helpers.go +++ b/rules/helpers.go @@ -69,11 +69,11 @@ func NewVectorAggregation(aggrTypeStr string, vector ast.Node, groupBy clientmod return nil, fmt.Errorf("operand of %v aggregation must be of vector type", aggrTypeStr) } var aggrTypes = map[string]ast.AggrType{ - "SUM": ast.SUM, - "MAX": ast.MAX, - "MIN": ast.MIN, - "AVG": ast.AVG, - "COUNT": ast.COUNT, + "SUM": ast.Sum, + "MAX": ast.Max, + "MIN": ast.Min, + "AVG": ast.Avg, + "COUNT": ast.Count, } aggrType, ok := aggrTypes[aggrTypeStr] if !ok { @@ -85,19 +85,19 @@ func NewVectorAggregation(aggrTypeStr string, vector ast.Node, groupBy clientmod // NewArithExpr is a convenience function to create a new AST arithmetic expression. func NewArithExpr(opTypeStr string, lhs ast.Node, rhs ast.Node) (ast.Node, error) { var opTypes = map[string]ast.BinOpType{ - "+": ast.ADD, - "-": ast.SUB, - "*": ast.MUL, - "/": ast.DIV, - "%": ast.MOD, + "+": ast.Add, + "-": ast.Sub, + "*": ast.Mul, + "/": ast.Div, + "%": ast.Mod, ">": ast.GT, "<": ast.LT, "==": ast.EQ, "!=": ast.NE, ">=": ast.GE, "<=": ast.LE, - "AND": ast.AND, - "OR": ast.OR, + "AND": ast.And, + "OR": ast.Or, } opType, ok := opTypes[opTypeStr] if !ok { diff --git a/rules/lexer.l.go b/rules/lexer.l.go index 5efe43f82..2a0f9e3ca 100644 --- a/rules/lexer.l.go +++ b/rules/lexer.l.go @@ -13,2125 +13,2135 @@ package rules import ( - "fmt" - "strconv" - "strings" + "fmt" + "strconv" + "strings" - clientmodel "github.com/prometheus/client_golang/model" + clientmodel "github.com/prometheus/client_golang/model" ) // Lex is called by the parser generated by "go tool yacc" to obtain each // token. The method is opened before the matching rules block and closed at // the end of the file. func (lexer *RulesLexer) Lex(lval *yySymType) int { - // Internal lexer states. - const ( - S_INITIAL = iota - S_COMMENTS - ) + // Internal lexer states. + const ( + S_INITIAL = iota + S_COMMENTS + ) - // We simulate multiple start symbols for closely-related grammars via dummy tokens. See - // http://www.gnu.org/software/bison/manual/html_node/Multiple-start_002dsymbols.html - // Reason: we want to be able to parse lists of named rules as well as single expressions. - if lexer.startToken != 0 { - startToken := lexer.startToken - lexer.startToken = 0 - return startToken - } - - c := lexer.current - currentState := 0 - - if lexer.empty { - c, lexer.empty = lexer.getChar(), false - } + // We simulate multiple start symbols for closely-related grammars via dummy tokens. See + // http://www.gnu.org/software/bison/manual/html_node/Multiple-start_002dsymbols.html + // Reason: we want to be able to parse lists of named rules as well as single expressions. + if lexer.startToken != 0 { + startToken := lexer.startToken + lexer.startToken = 0 + return startToken + } + c := lexer.current + currentState := 0 + if lexer.empty { + c, lexer.empty = lexer.getChar(), false + } yystate0: - lexer.buf = lexer.buf[:0] // The code before the first rule executed before every scan cycle (rule #0 / state 0 action) + lexer.buf = lexer.buf[:0] // The code before the first rule executed before every scan cycle (rule #0 / state 0 action) -switch yyt := currentState; yyt { -default: -panic(fmt.Errorf(`invalid start condition %d`, yyt)) -case 0: // start condition: INITIAL -goto yystart1 -case 1: // start condition: S_COMMENTS -goto yystart153 -} + switch yyt := currentState; yyt { + default: + panic(fmt.Errorf(`invalid start condition %d`, yyt)) + case 0: // start condition: INITIAL + goto yystart1 + case 1: // start condition: S_COMMENTS + goto yystart153 + } -goto yystate1 // silence unused label error + goto yystate0 // silence unused label error + goto yystate1 // silence unused label error yystate1: -c = lexer.getChar() + c = lexer.getChar() yystart1: -switch { -default: -goto yyabort -case c == '!': -goto yystate3 -case c == '"': -goto yystate5 -case c == '%' || c == '*': -goto yystate8 -case c == '(' || c == ')' || c == ',' || c == '[' || c == ']' || c == '{' || c == '}': -goto yystate12 -case c == '+': -goto yystate13 -case c == '-': -goto yystate14 -case c == '/': -goto yystate17 -case c == ':': -goto yystate23 -case c == '<' || c == '>': -goto yystate24 -case c == '=': -goto yystate25 -case c == 'A': -goto yystate26 -case c == 'B': -goto yystate36 -case c == 'C': -goto yystate38 -case c == 'D': -goto yystate42 -case c == 'E' || c == 'G' || c == 'H' || c == 'J' || c == 'L' || c == 'N' || c == 'Q' || c == 'R' || c >= 'T' && c <= 'V' || c >= 'X' && c <= 'Z' || c == '_' || c == 'e' || c == 'g' || c == 'h' || c == 'j' || c == 'l' || c == 'n' || c == 'q' || c == 'r' || c >= 't' && c <= 'v' || c >= 'x' && c <= 'z': -goto yystate27 -case c == 'F': -goto yystate53 -case c == 'I': -goto yystate56 -case c == 'K': -goto yystate58 -case c == 'M': -goto yystate71 -case c == 'O': -goto yystate74 -case c == 'P': -goto yystate75 -case c == 'S': -goto yystate84 -case c == 'W': -goto yystate91 -case c == '\'': -goto yystate9 -case c == '\t' || c == '\n' || c == '\r' || c == ' ': -goto yystate2 -case c == 'a': -goto yystate95 -case c == 'b': -goto yystate102 -case c == 'c': -goto yystate103 -case c == 'd': -goto yystate107 -case c == 'f': -goto yystate117 -case c == 'i': -goto yystate119 -case c == 'k': -goto yystate120 -case c == 'm': -goto yystate132 -case c == 'o': -goto yystate135 -case c == 'p': -goto yystate136 -case c == 's': -goto yystate144 -case c == 'w': -goto yystate150 -case c >= '0' && c <= '9': -goto yystate21 -} + switch { + default: + goto yyabort + case c == '!': + goto yystate3 + case c == '"': + goto yystate5 + case c == '%' || c == '*': + goto yystate8 + case c == '(' || c == ')' || c == ',' || c == '[' || c == ']' || c == '{' || c == '}': + goto yystate12 + case c == '+': + goto yystate13 + case c == '-': + goto yystate14 + case c == '/': + goto yystate17 + case c == ':': + goto yystate23 + case c == '<' || c == '>': + goto yystate24 + case c == '=': + goto yystate25 + case c == 'A': + goto yystate26 + case c == 'B': + goto yystate36 + case c == 'C': + goto yystate38 + case c == 'D': + goto yystate42 + case c == 'E' || c == 'G' || c == 'H' || c == 'J' || c == 'L' || c == 'N' || c == 'Q' || c == 'R' || c >= 'T' && c <= 'V' || c >= 'X' && c <= 'Z' || c == '_' || c == 'e' || c == 'g' || c == 'h' || c == 'j' || c == 'l' || c == 'n' || c == 'q' || c == 'r' || c >= 't' && c <= 'v' || c >= 'x' && c <= 'z': + goto yystate27 + case c == 'F': + goto yystate53 + case c == 'I': + goto yystate56 + case c == 'K': + goto yystate58 + case c == 'M': + goto yystate71 + case c == 'O': + goto yystate74 + case c == 'P': + goto yystate75 + case c == 'S': + goto yystate84 + case c == 'W': + goto yystate91 + case c == '\'': + goto yystate9 + case c == '\t' || c == '\n' || c == '\r' || c == ' ': + goto yystate2 + case c == 'a': + goto yystate95 + case c == 'b': + goto yystate102 + case c == 'c': + goto yystate103 + case c == 'd': + goto yystate107 + case c == 'f': + goto yystate117 + case c == 'i': + goto yystate119 + case c == 'k': + goto yystate120 + case c == 'm': + goto yystate132 + case c == 'o': + goto yystate135 + case c == 'p': + goto yystate136 + case c == 's': + goto yystate144 + case c == 'w': + goto yystate150 + case c >= '0' && c <= '9': + goto yystate21 + } yystate2: -c = lexer.getChar() -goto yyrule27 + c = lexer.getChar() + goto yyrule27 yystate3: -c = lexer.getChar() -switch { -default: -goto yyabort -case c == '=' || c == '~': -goto yystate4 -} + c = lexer.getChar() + switch { + default: + goto yyabort + case c == '=' || c == '~': + goto yystate4 + } yystate4: -c = lexer.getChar() -goto yyrule17 + c = lexer.getChar() + goto yyrule17 yystate5: -c = lexer.getChar() -switch { -default: -goto yyabort -case c == '"': -goto yystate6 -case c == '\\': -goto yystate7 -case c >= '\x01' && c <= '!' || c >= '#' && c <= '[' || c >= ']' && c <= 'ÿ': -goto yystate5 -} + c = lexer.getChar() + switch { + default: + goto yyabort + case c == '"': + goto yystate6 + case c == '\\': + goto yystate7 + case c >= '\x01' && c <= '!' || c >= '#' && c <= '[' || c >= ']' && c <= 'ÿ': + goto yystate5 + } yystate6: -c = lexer.getChar() -goto yyrule24 + c = lexer.getChar() + goto yyrule24 yystate7: -c = lexer.getChar() -switch { -default: -goto yyabort -case c >= '\x01' && c <= '\t' || c >= '\v' && c <= 'ÿ': -goto yystate5 -} + c = lexer.getChar() + switch { + default: + goto yyabort + case c >= '\x01' && c <= '\t' || c >= '\v' && c <= 'ÿ': + goto yystate5 + } yystate8: -c = lexer.getChar() -goto yyrule19 + c = lexer.getChar() + goto yyrule19 yystate9: -c = lexer.getChar() -switch { -default: -goto yyabort -case c == '\'': -goto yystate10 -case c == '\\': -goto yystate11 -case c >= '\x01' && c <= '&' || c >= '(' && c <= '[' || c >= ']' && c <= 'ÿ': -goto yystate9 -} + c = lexer.getChar() + switch { + default: + goto yyabort + case c == '\'': + goto yystate10 + case c == '\\': + goto yystate11 + case c >= '\x01' && c <= '&' || c >= '(' && c <= '[' || c >= ']' && c <= 'ÿ': + goto yystate9 + } yystate10: -c = lexer.getChar() -goto yyrule25 + c = lexer.getChar() + goto yyrule25 yystate11: -c = lexer.getChar() -switch { -default: -goto yyabort -case c >= '\x01' && c <= '\t' || c >= '\v' && c <= 'ÿ': -goto yystate9 -} + c = lexer.getChar() + switch { + default: + goto yyabort + case c >= '\x01' && c <= '\t' || c >= '\v' && c <= 'ÿ': + goto yystate9 + } yystate12: -c = lexer.getChar() -goto yyrule26 + c = lexer.getChar() + goto yyrule26 yystate13: -c = lexer.getChar() -goto yyrule18 + c = lexer.getChar() + goto yyrule18 yystate14: -c = lexer.getChar() -switch { -default: -goto yyrule18 -case c >= '0' && c <= '9': -goto yystate15 -} + c = lexer.getChar() + switch { + default: + goto yyrule18 + case c >= '0' && c <= '9': + goto yystate15 + } yystate15: -c = lexer.getChar() -switch { -default: -goto yyrule23 -case c == '.': -goto yystate16 -case c >= '0' && c <= '9': -goto yystate15 -} + c = lexer.getChar() + switch { + default: + goto yyrule23 + case c == '.': + goto yystate16 + case c >= '0' && c <= '9': + goto yystate15 + } yystate16: -c = lexer.getChar() -switch { -default: -goto yyrule23 -case c >= '0' && c <= '9': -goto yystate16 -} + c = lexer.getChar() + switch { + default: + goto yyrule23 + case c >= '0' && c <= '9': + goto yystate16 + } yystate17: -c = lexer.getChar() -switch { -default: -goto yyrule19 -case c == '*': -goto yystate18 -case c == '/': -goto yystate19 -} + c = lexer.getChar() + switch { + default: + goto yyrule19 + case c == '*': + goto yystate18 + case c == '/': + goto yystate19 + } yystate18: -c = lexer.getChar() -goto yyrule1 + c = lexer.getChar() + goto yyrule1 yystate19: -c = lexer.getChar() -switch { -default: -goto yyabort -case c == '\n': -goto yystate20 -case c >= '\x01' && c <= '\t' || c == '\v' || c == '\f' || c >= '\x0e' && c <= 'ÿ': -goto yystate19 -} + c = lexer.getChar() + switch { + default: + goto yyabort + case c == '\n': + goto yystate20 + case c >= '\x01' && c <= '\t' || c == '\v' || c == '\f' || c >= '\x0e' && c <= 'ÿ': + goto yystate19 + } yystate20: -c = lexer.getChar() -goto yyrule4 + c = lexer.getChar() + goto yyrule4 yystate21: -c = lexer.getChar() -switch { -default: -goto yyrule23 -case c == '.': -goto yystate16 -case c == 'd' || c == 'h' || c == 'm' || c == 's' || c == 'w' || c == 'y': -goto yystate22 -case c >= '0' && c <= '9': -goto yystate21 -} + c = lexer.getChar() + switch { + default: + goto yyrule23 + case c == '.': + goto yystate16 + case c == 'd' || c == 'h' || c == 'm' || c == 's' || c == 'w' || c == 'y': + goto yystate22 + case c >= '0' && c <= '9': + goto yystate21 + } yystate22: -c = lexer.getChar() -goto yyrule20 + c = lexer.getChar() + goto yyrule20 yystate23: -c = lexer.getChar() -switch { -default: -goto yyrule22 -case c >= '0' && c <= ':' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate23 -} + c = lexer.getChar() + switch { + default: + goto yyrule22 + case c >= '0' && c <= ':' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate23 + } yystate24: -c = lexer.getChar() -switch { -default: -goto yyrule16 -case c == '=': -goto yystate4 -} + c = lexer.getChar() + switch { + default: + goto yyrule16 + case c == '=': + goto yystate4 + } yystate25: -c = lexer.getChar() -switch { -default: -goto yyrule26 -case c == '=' || c == '~': -goto yystate4 -} + c = lexer.getChar() + switch { + default: + goto yyrule26 + case c == '=' || c == '~': + goto yystate4 + } yystate26: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'L': -goto yystate28 -case c == 'N': -goto yystate32 -case c == 'V': -goto yystate34 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'K' || c == 'M' || c >= 'O' && c <= 'U' || c >= 'W' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'L': + goto yystate28 + case c == 'N': + goto yystate32 + case c == 'V': + goto yystate34 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'K' || c == 'M' || c >= 'O' && c <= 'U' || c >= 'W' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate27: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate28: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'E': -goto yystate29 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'E': + goto yystate29 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate29: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'R': -goto yystate30 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'R': + goto yystate30 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate30: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'T': -goto yystate31 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'S' || c >= 'U' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'T': + goto yystate31 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'S' || c >= 'U' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate31: -c = lexer.getChar() -switch { -default: -goto yyrule5 -case c == ':': -goto yystate23 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule5 + case c == ':': + goto yystate23 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate32: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'D': -goto yystate33 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'C' || c >= 'E' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'D': + goto yystate33 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'C' || c >= 'E' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate33: -c = lexer.getChar() -switch { -default: -goto yyrule16 -case c == ':': -goto yystate23 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule16 + case c == ':': + goto yystate23 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate34: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'G': -goto yystate35 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'F' || c >= 'H' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'G': + goto yystate35 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'F' || c >= 'H' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate35: -c = lexer.getChar() -switch { -default: -goto yyrule14 -case c == ':': -goto yystate23 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule14 + case c == ':': + goto yystate23 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate36: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'Y': -goto yystate37 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'X' || c == 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'Y': + goto yystate37 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'X' || c == 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate37: -c = lexer.getChar() -switch { -default: -goto yyrule12 -case c == ':': -goto yystate23 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule12 + case c == ':': + goto yystate23 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate38: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'O': -goto yystate39 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'N' || c >= 'P' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'O': + goto yystate39 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'N' || c >= 'P' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate39: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'U': -goto yystate40 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'T' || c >= 'V' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'U': + goto yystate40 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'T' || c >= 'V' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate40: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'N': -goto yystate41 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'M' || c >= 'O' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'N': + goto yystate41 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'M' || c >= 'O' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate41: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'T': -goto yystate35 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'S' || c >= 'U' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'T': + goto yystate35 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'S' || c >= 'U' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate42: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'E': -goto yystate43 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'E': + goto yystate43 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate43: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'S': -goto yystate44 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'R' || c >= 'T' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'S': + goto yystate44 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'R' || c >= 'T' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate44: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'C': -goto yystate45 -case c >= '0' && c <= '9' || c == 'A' || c == 'B' || c >= 'D' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'C': + goto yystate45 + case c >= '0' && c <= '9' || c == 'A' || c == 'B' || c >= 'D' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate45: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'R': -goto yystate46 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'R': + goto yystate46 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate46: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'I': -goto yystate47 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'H' || c >= 'J' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'I': + goto yystate47 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'H' || c >= 'J' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate47: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'P': -goto yystate48 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'O' || c >= 'Q' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'P': + goto yystate48 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'O' || c >= 'Q' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate48: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'T': -goto yystate49 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'S' || c >= 'U' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'T': + goto yystate49 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'S' || c >= 'U' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate49: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'I': -goto yystate50 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'H' || c >= 'J' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'I': + goto yystate50 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'H' || c >= 'J' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate50: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'O': -goto yystate51 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'N' || c >= 'P' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'O': + goto yystate51 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'N' || c >= 'P' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate51: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'N': -goto yystate52 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'M' || c >= 'O' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'N': + goto yystate52 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'M' || c >= 'O' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate52: -c = lexer.getChar() -switch { -default: -goto yyrule10 -case c == ':': -goto yystate23 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule10 + case c == ':': + goto yystate23 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate53: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'O': -goto yystate54 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'N' || c >= 'P' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'O': + goto yystate54 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'N' || c >= 'P' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate54: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'R': -goto yystate55 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'R': + goto yystate55 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate55: -c = lexer.getChar() -switch { -default: -goto yyrule7 -case c == ':': -goto yystate23 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule7 + case c == ':': + goto yystate23 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate56: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'F': -goto yystate57 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'E' || c >= 'G' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'F': + goto yystate57 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'E' || c >= 'G' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate57: -c = lexer.getChar() -switch { -default: -goto yyrule6 -case c == ':': -goto yystate23 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule6 + case c == ':': + goto yystate23 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate58: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'E': -goto yystate59 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'E': + goto yystate59 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate59: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'E': -goto yystate60 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'E': + goto yystate60 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate60: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'P': -goto yystate61 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'O' || c >= 'Q' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'P': + goto yystate61 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'O' || c >= 'Q' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate61: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'I': -goto yystate62 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'H' || c >= 'J' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'I': + goto yystate62 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'H' || c >= 'J' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate62: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'N': -goto yystate63 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'M' || c >= 'O' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'N': + goto yystate63 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'M' || c >= 'O' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate63: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'G': -goto yystate64 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'F' || c >= 'H' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'G': + goto yystate64 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'F' || c >= 'H' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate64: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == '_': -goto yystate65 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == '_': + goto yystate65 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate65: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'E': -goto yystate66 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'E': + goto yystate66 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate66: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'X': -goto yystate67 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'W' || c == 'Y' || c == 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'X': + goto yystate67 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'W' || c == 'Y' || c == 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate67: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'T': -goto yystate68 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'S' || c >= 'U' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'T': + goto yystate68 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'S' || c >= 'U' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate68: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'R': -goto yystate69 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'R': + goto yystate69 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate69: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'A': -goto yystate70 -case c >= '0' && c <= '9' || c >= 'B' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'A': + goto yystate70 + case c >= '0' && c <= '9' || c >= 'B' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate70: -c = lexer.getChar() -switch { -default: -goto yyrule13 -case c == ':': -goto yystate23 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule13 + case c == ':': + goto yystate23 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate71: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'A': -goto yystate72 -case c == 'I': -goto yystate73 -case c >= '0' && c <= '9' || c >= 'B' && c <= 'H' || c >= 'J' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'A': + goto yystate72 + case c == 'I': + goto yystate73 + case c >= '0' && c <= '9' || c >= 'B' && c <= 'H' || c >= 'J' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate72: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'X': -goto yystate35 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'W' || c == 'Y' || c == 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'X': + goto yystate35 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'W' || c == 'Y' || c == 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate73: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'N': -goto yystate35 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'M' || c >= 'O' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'N': + goto yystate35 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'M' || c >= 'O' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate74: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'R': -goto yystate33 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'R': + goto yystate33 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate75: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'E': -goto yystate76 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'E': + goto yystate76 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate76: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'R': -goto yystate77 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'R': + goto yystate77 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate77: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'M': -goto yystate78 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'L' || c >= 'N' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'M': + goto yystate78 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'L' || c >= 'N' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate78: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'A': -goto yystate79 -case c >= '0' && c <= '9' || c >= 'B' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'A': + goto yystate79 + case c >= '0' && c <= '9' || c >= 'B' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate79: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'N': -goto yystate80 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'M' || c >= 'O' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'N': + goto yystate80 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'M' || c >= 'O' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate80: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'E': -goto yystate81 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'E': + goto yystate81 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'D' || c >= 'F' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate81: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'N': -goto yystate82 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'M' || c >= 'O' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'N': + goto yystate82 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'M' || c >= 'O' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate82: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'T': -goto yystate83 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'S' || c >= 'U' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'T': + goto yystate83 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'S' || c >= 'U' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate83: -c = lexer.getChar() -switch { -default: -goto yyrule11 -case c == ':': -goto yystate23 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule11 + case c == ':': + goto yystate23 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate84: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'U': -goto yystate85 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'T' || c >= 'V' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'U': + goto yystate85 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'T' || c >= 'V' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate85: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'M': -goto yystate86 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'L' || c >= 'N' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'M': + goto yystate86 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'L' || c >= 'N' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate86: -c = lexer.getChar() -switch { -default: -goto yyrule14 -case c == ':': -goto yystate23 -case c == 'M': -goto yystate87 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'L' || c >= 'N' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule14 + case c == ':': + goto yystate23 + case c == 'M': + goto yystate87 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'L' || c >= 'N' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate87: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'A': -goto yystate88 -case c >= '0' && c <= '9' || c >= 'B' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'A': + goto yystate88 + case c >= '0' && c <= '9' || c >= 'B' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate88: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'R': -goto yystate89 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'R': + goto yystate89 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Q' || c >= 'S' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate89: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'Y': -goto yystate90 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'X' || c == 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'Y': + goto yystate90 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'X' || c == 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate90: -c = lexer.getChar() -switch { -default: -goto yyrule9 -case c == ':': -goto yystate23 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule9 + case c == ':': + goto yystate23 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate91: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'I': -goto yystate92 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'H' || c >= 'J' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'I': + goto yystate92 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'H' || c >= 'J' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate92: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'T': -goto yystate93 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'S' || c >= 'U' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'T': + goto yystate93 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'S' || c >= 'U' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate93: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'H': -goto yystate94 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'G' || c >= 'I' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'H': + goto yystate94 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'G' || c >= 'I' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate94: -c = lexer.getChar() -switch { -default: -goto yyrule8 -case c == ':': -goto yystate23 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule8 + case c == ':': + goto yystate23 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate95: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'l': -goto yystate96 -case c == 'n': -goto yystate99 -case c == 'v': -goto yystate100 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'k' || c == 'm' || c >= 'o' && c <= 'u' || c >= 'w' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'l': + goto yystate96 + case c == 'n': + goto yystate99 + case c == 'v': + goto yystate100 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'k' || c == 'm' || c >= 'o' && c <= 'u' || c >= 'w' && c <= 'z': + goto yystate27 + } yystate96: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'e': -goto yystate97 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'e': + goto yystate97 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z': + goto yystate27 + } yystate97: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'r': -goto yystate98 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'q' || c >= 's' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'r': + goto yystate98 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'q' || c >= 's' && c <= 'z': + goto yystate27 + } yystate98: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 't': -goto yystate31 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 's' || c >= 'u' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 't': + goto yystate31 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 's' || c >= 'u' && c <= 'z': + goto yystate27 + } yystate99: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'd': -goto yystate33 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'c' || c >= 'e' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'd': + goto yystate33 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'c' || c >= 'e' && c <= 'z': + goto yystate27 + } yystate100: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'g': -goto yystate101 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'f' || c >= 'h' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'g': + goto yystate101 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'f' || c >= 'h' && c <= 'z': + goto yystate27 + } yystate101: -c = lexer.getChar() -switch { -default: -goto yyrule15 -case c == ':': -goto yystate23 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule15 + case c == ':': + goto yystate23 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate102: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'y': -goto yystate37 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'x' || c == 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'y': + goto yystate37 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'x' || c == 'z': + goto yystate27 + } yystate103: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'o': -goto yystate104 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'n' || c >= 'p' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'o': + goto yystate104 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'n' || c >= 'p' && c <= 'z': + goto yystate27 + } yystate104: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'u': -goto yystate105 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 't' || c >= 'v' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'u': + goto yystate105 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 't' || c >= 'v' && c <= 'z': + goto yystate27 + } yystate105: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'n': -goto yystate106 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'm' || c >= 'o' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'n': + goto yystate106 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'm' || c >= 'o' && c <= 'z': + goto yystate27 + } yystate106: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 't': -goto yystate101 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 's' || c >= 'u' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 't': + goto yystate101 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 's' || c >= 'u' && c <= 'z': + goto yystate27 + } yystate107: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'e': -goto yystate108 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'e': + goto yystate108 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z': + goto yystate27 + } yystate108: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 's': -goto yystate109 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'r' || c >= 't' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 's': + goto yystate109 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'r' || c >= 't' && c <= 'z': + goto yystate27 + } yystate109: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'c': -goto yystate110 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c == 'a' || c == 'b' || c >= 'd' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'c': + goto yystate110 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c == 'a' || c == 'b' || c >= 'd' && c <= 'z': + goto yystate27 + } yystate110: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'r': -goto yystate111 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'q' || c >= 's' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'r': + goto yystate111 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'q' || c >= 's' && c <= 'z': + goto yystate27 + } yystate111: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'i': -goto yystate112 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'h' || c >= 'j' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'i': + goto yystate112 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'h' || c >= 'j' && c <= 'z': + goto yystate27 + } yystate112: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'p': -goto yystate113 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'o' || c >= 'q' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'p': + goto yystate113 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'o' || c >= 'q' && c <= 'z': + goto yystate27 + } yystate113: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 't': -goto yystate114 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 's' || c >= 'u' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 't': + goto yystate114 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 's' || c >= 'u' && c <= 'z': + goto yystate27 + } yystate114: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'i': -goto yystate115 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'h' || c >= 'j' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'i': + goto yystate115 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'h' || c >= 'j' && c <= 'z': + goto yystate27 + } yystate115: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'o': -goto yystate116 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'n' || c >= 'p' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'o': + goto yystate116 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'n' || c >= 'p' && c <= 'z': + goto yystate27 + } yystate116: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'n': -goto yystate52 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'm' || c >= 'o' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'n': + goto yystate52 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'm' || c >= 'o' && c <= 'z': + goto yystate27 + } yystate117: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'o': -goto yystate118 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'n' || c >= 'p' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'o': + goto yystate118 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'n' || c >= 'p' && c <= 'z': + goto yystate27 + } yystate118: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'r': -goto yystate55 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'q' || c >= 's' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'r': + goto yystate55 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'q' || c >= 's' && c <= 'z': + goto yystate27 + } yystate119: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'f': -goto yystate57 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'e' || c >= 'g' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'f': + goto yystate57 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'e' || c >= 'g' && c <= 'z': + goto yystate27 + } yystate120: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'e': -goto yystate121 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'e': + goto yystate121 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z': + goto yystate27 + } yystate121: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'e': -goto yystate122 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'e': + goto yystate122 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z': + goto yystate27 + } yystate122: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'p': -goto yystate123 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'o' || c >= 'q' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'p': + goto yystate123 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'o' || c >= 'q' && c <= 'z': + goto yystate27 + } yystate123: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'i': -goto yystate124 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'h' || c >= 'j' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'i': + goto yystate124 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'h' || c >= 'j' && c <= 'z': + goto yystate27 + } yystate124: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'n': -goto yystate125 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'm' || c >= 'o' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'n': + goto yystate125 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'm' || c >= 'o' && c <= 'z': + goto yystate27 + } yystate125: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'g': -goto yystate126 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'f' || c >= 'h' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'g': + goto yystate126 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'f' || c >= 'h' && c <= 'z': + goto yystate27 + } yystate126: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == '_': -goto yystate127 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == '_': + goto yystate127 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z': + goto yystate27 + } yystate127: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'e': -goto yystate128 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'e': + goto yystate128 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z': + goto yystate27 + } yystate128: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'x': -goto yystate129 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'w' || c == 'y' || c == 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'x': + goto yystate129 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'w' || c == 'y' || c == 'z': + goto yystate27 + } yystate129: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 't': -goto yystate130 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 's' || c >= 'u' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 't': + goto yystate130 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 's' || c >= 'u' && c <= 'z': + goto yystate27 + } yystate130: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'r': -goto yystate131 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'q' || c >= 's' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'r': + goto yystate131 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'q' || c >= 's' && c <= 'z': + goto yystate27 + } yystate131: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'a': -goto yystate70 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'b' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'a': + goto yystate70 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'b' && c <= 'z': + goto yystate27 + } yystate132: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'a': -goto yystate133 -case c == 'i': -goto yystate134 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'b' && c <= 'h' || c >= 'j' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'a': + goto yystate133 + case c == 'i': + goto yystate134 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'b' && c <= 'h' || c >= 'j' && c <= 'z': + goto yystate27 + } yystate133: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'x': -goto yystate101 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'w' || c == 'y' || c == 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'x': + goto yystate101 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'w' || c == 'y' || c == 'z': + goto yystate27 + } yystate134: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'n': -goto yystate101 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'm' || c >= 'o' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'n': + goto yystate101 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'm' || c >= 'o' && c <= 'z': + goto yystate27 + } yystate135: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'r': -goto yystate33 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'q' || c >= 's' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'r': + goto yystate33 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'q' || c >= 's' && c <= 'z': + goto yystate27 + } yystate136: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'e': -goto yystate137 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'e': + goto yystate137 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z': + goto yystate27 + } yystate137: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'r': -goto yystate138 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'q' || c >= 's' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'r': + goto yystate138 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'q' || c >= 's' && c <= 'z': + goto yystate27 + } yystate138: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'm': -goto yystate139 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'l' || c >= 'n' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'm': + goto yystate139 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'l' || c >= 'n' && c <= 'z': + goto yystate27 + } yystate139: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'a': -goto yystate140 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'b' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'a': + goto yystate140 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'b' && c <= 'z': + goto yystate27 + } yystate140: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'n': -goto yystate141 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'm' || c >= 'o' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'n': + goto yystate141 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'm' || c >= 'o' && c <= 'z': + goto yystate27 + } yystate141: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'e': -goto yystate142 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'e': + goto yystate142 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'd' || c >= 'f' && c <= 'z': + goto yystate27 + } yystate142: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'n': -goto yystate143 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'm' || c >= 'o' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'n': + goto yystate143 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'm' || c >= 'o' && c <= 'z': + goto yystate27 + } yystate143: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 't': -goto yystate83 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 's' || c >= 'u' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 't': + goto yystate83 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 's' || c >= 'u' && c <= 'z': + goto yystate27 + } yystate144: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'u': -goto yystate145 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 't' || c >= 'v' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'u': + goto yystate145 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 't' || c >= 'v' && c <= 'z': + goto yystate27 + } yystate145: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'm': -goto yystate146 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'l' || c >= 'n' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'm': + goto yystate146 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'l' || c >= 'n' && c <= 'z': + goto yystate27 + } yystate146: -c = lexer.getChar() -switch { -default: -goto yyrule15 -case c == ':': -goto yystate23 -case c == 'm': -goto yystate147 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'l' || c >= 'n' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule15 + case c == ':': + goto yystate23 + case c == 'm': + goto yystate147 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'l' || c >= 'n' && c <= 'z': + goto yystate27 + } yystate147: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'a': -goto yystate148 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'b' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'a': + goto yystate148 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'b' && c <= 'z': + goto yystate27 + } yystate148: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'r': -goto yystate149 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'q' || c >= 's' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'r': + goto yystate149 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'q' || c >= 's' && c <= 'z': + goto yystate27 + } yystate149: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'y': -goto yystate90 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'x' || c == 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'y': + goto yystate90 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'x' || c == 'z': + goto yystate27 + } yystate150: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'i': -goto yystate151 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'h' || c >= 'j' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'i': + goto yystate151 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'h' || c >= 'j' && c <= 'z': + goto yystate27 + } yystate151: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 't': -goto yystate152 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 's' || c >= 'u' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 't': + goto yystate152 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 's' || c >= 'u' && c <= 'z': + goto yystate27 + } yystate152: -c = lexer.getChar() -switch { -default: -goto yyrule21 -case c == ':': -goto yystate23 -case c == 'h': -goto yystate94 -case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'g' || c >= 'i' && c <= 'z': -goto yystate27 -} + c = lexer.getChar() + switch { + default: + goto yyrule21 + case c == ':': + goto yystate23 + case c == 'h': + goto yystate94 + case c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'g' || c >= 'i' && c <= 'z': + goto yystate27 + } -goto yystate153 // silence unused label error + goto yystate153 // silence unused label error yystate153: -c = lexer.getChar() + c = lexer.getChar() yystart153: -switch { -default: -goto yyabort -case c == '*': -goto yystate155 -case c >= '\x01' && c <= ')' || c >= '+' && c <= 'ÿ': -goto yystate154 -} + switch { + default: + goto yyabort + case c == '*': + goto yystate155 + case c >= '\x01' && c <= ')' || c >= '+' && c <= 'ÿ': + goto yystate154 + } yystate154: -c = lexer.getChar() -goto yyrule3 + c = lexer.getChar() + goto yyrule3 yystate155: -c = lexer.getChar() -switch { -default: -goto yyrule3 -case c == '/': -goto yystate156 -} + c = lexer.getChar() + switch { + default: + goto yyrule3 + case c == '/': + goto yystate156 + } yystate156: -c = lexer.getChar() -goto yyrule2 + c = lexer.getChar() + goto yyrule2 yyrule1: // "/*" -{ - currentState = S_COMMENTS -goto yystate0 -} + { + currentState = S_COMMENTS + goto yystate0 + } yyrule2: // "*/" -{ - currentState = S_INITIAL -goto yystate0 -} + { + currentState = S_INITIAL + goto yystate0 + } yyrule3: // .|\n -{ - /* ignore chars within multi-line comments */ -goto yystate0 -} + { + /* ignore chars within multi-line comments */ + goto yystate0 + } yyrule4: // \/\/[^\r\n]*\n -{ - /* gobble up one-line comments */ -goto yystate0 -} + { + /* gobble up one-line comments */ + goto yystate0 + } yyrule5: // ALERT|alert -{ - return ALERT -} + { + return ALERT + } yyrule6: // IF|if -{ - return IF -} + { + return IF + } yyrule7: // FOR|for -{ - return FOR -} + { + return FOR + } yyrule8: // WITH|with -{ - return WITH -} + { + return WITH + } yyrule9: // SUMMARY|summary -{ - return SUMMARY -} + { + return SUMMARY + } yyrule10: // DESCRIPTION|description -{ - return DESCRIPTION -} + { + return DESCRIPTION + } yyrule11: // PERMANENT|permanent -{ - return PERMANENT -} + { + return PERMANENT + } yyrule12: // BY|by -{ - return GROUP_OP -} + { + return GROUP_OP + } yyrule13: // KEEPING_EXTRA|keeping_extra -{ -return KEEPING_EXTRA -} + { + return KEEPING_EXTRA + } yyrule14: // AVG|SUM|MAX|MIN|COUNT -{ - lval.str = lexer.token(); return AGGR_OP -goto yystate0 -} + { + lval.str = lexer.token() + return AGGR_OP + goto yystate0 + } yyrule15: // avg|sum|max|min|count -{ - lval.str = strings.ToUpper(lexer.token()); return AGGR_OP -goto yystate0 -} + { + lval.str = strings.ToUpper(lexer.token()) + return AGGR_OP + goto yystate0 + } yyrule16: // \<|>|AND|OR|and|or -{ - lval.str = strings.ToUpper(lexer.token()); return CMP_OP -goto yystate0 -} + { + lval.str = strings.ToUpper(lexer.token()) + return CMP_OP + goto yystate0 + } yyrule17: // ==|!=|>=|<=|=~|!~ -{ - lval.str = lexer.token(); return CMP_OP -goto yystate0 -} + { + lval.str = lexer.token() + return CMP_OP + goto yystate0 + } yyrule18: // [+\-] -{ - lval.str = lexer.token(); return ADDITIVE_OP -goto yystate0 -} + { + lval.str = lexer.token() + return ADDITIVE_OP + goto yystate0 + } yyrule19: // [*/%] -{ - lval.str = lexer.token(); return MULT_OP -goto yystate0 -} + { + lval.str = lexer.token() + return MULT_OP + goto yystate0 + } yyrule20: // {D}+{U} -{ - lval.str = lexer.token(); return DURATION -goto yystate0 -} + { + lval.str = lexer.token() + return DURATION + goto yystate0 + } yyrule21: // {L}({L}|{D})* -{ - lval.str = lexer.token(); return IDENTIFIER -goto yystate0 -} + { + lval.str = lexer.token() + return IDENTIFIER + goto yystate0 + } yyrule22: // {M}({M}|{D})* -{ - lval.str = lexer.token(); return METRICNAME -goto yystate0 -} + { + lval.str = lexer.token() + return METRICNAME + goto yystate0 + } yyrule23: // \-?{D}+(\.{D}*)? -{ - num, err := strconv.ParseFloat(lexer.token(), 64); - if (err != nil && err.(*strconv.NumError).Err == strconv.ErrSyntax) { - panic("Invalid float") - } - lval.num = clientmodel.SampleValue(num) - return NUMBER -} + { + num, err := strconv.ParseFloat(lexer.token(), 64) + if err != nil && err.(*strconv.NumError).Err == strconv.ErrSyntax { + panic("Invalid float") + } + lval.num = clientmodel.SampleValue(num) + return NUMBER + } yyrule24: // \"(\\.|[^\\"])*\" -{ - lval.str = lexer.token()[1:len(lexer.token()) - 1]; return STRING -goto yystate0 -} + { + lval.str = lexer.token()[1 : len(lexer.token())-1] + return STRING + goto yystate0 + } yyrule25: // \'(\\.|[^\\'])*\' -{ - lval.str = lexer.token()[1:len(lexer.token()) - 1]; return STRING -goto yystate0 -} + { + lval.str = lexer.token()[1 : len(lexer.token())-1] + return STRING + goto yystate0 + } yyrule26: // [{}\[\]()=,] -{ - return int(lexer.buf[0]) -} + { + return int(lexer.buf[0]) + } yyrule27: // [\t\n\r ] -{ - /* gobble up any whitespace */ -goto yystate0 -} -panic("unreachable") + { + /* gobble up any whitespace */ + goto yystate0 + } + panic("unreachable") -goto yyabort // silence unused label error + goto yyabort // silence unused label error yyabort: // no lexem recognized - lexer.empty = true - return int(c) + lexer.empty = true + return int(c) } diff --git a/rules/parser.y.go b/rules/parser.y.go index 655c0cfb0..e70ab4b15 100644 --- a/rules/parser.y.go +++ b/rules/parser.y.go @@ -67,7 +67,7 @@ var yyToknames = []string{ "WITH", "SUMMARY", "DESCRIPTION", - " =", + "'='", } var yyStatenames = []string{} diff --git a/rules/rules_test.go b/rules/rules_test.go index 028da4006..fd45fa146 100644 --- a/rules/rules_test.go +++ b/rules/rules_test.go @@ -658,7 +658,7 @@ func TestExpressions(t *testing.T) { t.Errorf("%d. Test should fail, but didn't", i) } failed := false - resultStr := ast.EvalToString(testExpr, testEvalTime, ast.TEXT, storage, stats.NewTimerGroup()) + resultStr := ast.EvalToString(testExpr, testEvalTime, ast.Text, storage, stats.NewTimerGroup()) resultLines := strings.Split(resultStr, "\n") if len(exprTest.output) != len(resultLines) { diff --git a/web/api/query.go b/web/api/query.go index d8dd9cf0e..2fe1da415 100644 --- a/web/api/query.go +++ b/web/api/query.go @@ -54,7 +54,7 @@ func (serv MetricsService) Query(w http.ResponseWriter, r *http.Request) { format = ast.JSON w.Header().Set("Content-Type", "application/json") } else { - format = ast.TEXT + format = ast.Text w.Header().Set("Content-Type", "text/plain") } @@ -94,7 +94,7 @@ func (serv MetricsService) QueryRange(w http.ResponseWriter, r *http.Request) { fmt.Fprint(w, ast.ErrorToJSON(err)) return } - if exprNode.Type() != ast.VECTOR { + if exprNode.Type() != ast.VectorType { fmt.Fprint(w, ast.ErrorToJSON(errors.New("expression does not evaluate to vector type"))) return }