From 31052588b1d344e72729551ce0285aebb9786834 Mon Sep 17 00:00:00 2001 From: z7zmey Date: Mon, 30 Dec 2019 00:20:20 +0200 Subject: [PATCH] [#82] add support of shebang --- printer/printer_parsed_php5_test.go | 12 + printer/printer_parsed_php7_test.go | 12 + scanner/scanner.go | 17655 +++++++++++++------------- scanner/scanner.rl | 14 +- scanner/scanner_test.go | 45 + 5 files changed, 8968 insertions(+), 8770 deletions(-) diff --git a/printer/printer_parsed_php5_test.go b/printer/printer_parsed_php5_test.go index 40cac5c..660987a 100644 --- a/printer/printer_parsed_php5_test.go +++ b/printer/printer_parsed_php5_test.go @@ -1077,6 +1077,18 @@ func TestParseAndPrintPhp5InlineHtml(t *testing.T) { } } +func TestParseAndPrintPhp5Shebang(t *testing.T) { + src := `#!/usr/bin/env php + testtest") lex.addFreeFloating(freefloating.CommentType, lex.ts, lex.te) } - goto st117 - tr239: + goto st121 + tr246: //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) -//line scanner/scanner.rl:319 +//line scanner/scanner.rl:329 lex.te = (lex.p) (lex.p)-- { lex.ungetStr("?>") lex.addFreeFloating(freefloating.CommentType, lex.ts, lex.te) } - goto st117 - tr243: -//line scanner/scanner.rl:345 + goto st121 + tr250: +//line scanner/scanner.rl:355 lex.te = (lex.p) (lex.p)-- { @@ -3708,65 +3809,65 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_VARIABLE { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr244: -//line scanner/scanner.rl:292 + goto st121 + tr251: +//line scanner/scanner.rl:302 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_MOD_EQUAL { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr245: -//line scanner/scanner.rl:281 + goto st121 + tr252: +//line scanner/scanner.rl:291 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_BOOLEAN_AND { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr246: -//line scanner/scanner.rl:283 + goto st121 + tr253: +//line scanner/scanner.rl:293 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_AND_EQUAL { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr248: -//line scanner/scanner.rl:286 + goto st121 + tr255: +//line scanner/scanner.rl:296 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_MUL_EQUAL { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr249: -//line scanner/scanner.rl:305 + goto st121 + tr256: +//line scanner/scanner.rl:315 lex.te = (lex.p) (lex.p)-- { @@ -3774,105 +3875,105 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_POW { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr250: -//line scanner/scanner.rl:287 + goto st121 + tr257: +//line scanner/scanner.rl:297 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_POW_EQUAL { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr251: -//line scanner/scanner.rl:294 + goto st121 + tr258: +//line scanner/scanner.rl:304 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_INC { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr252: -//line scanner/scanner.rl:289 + goto st121 + tr259: +//line scanner/scanner.rl:299 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_PLUS_EQUAL { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr253: -//line scanner/scanner.rl:293 + goto st121 + tr260: +//line scanner/scanner.rl:303 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_DEC { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr254: -//line scanner/scanner.rl:290 + goto st121 + tr261: +//line scanner/scanner.rl:300 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_MINUS_EQUAL { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr255: - lex.cs = 117 -//line scanner/scanner.rl:348 + goto st121 + tr262: + lex.cs = 121 +//line scanner/scanner.rl:358 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_OBJECT_OPERATOR - lex.cs = 464 + lex.cs = 468 { (lex.p)++ goto _out } } goto _again - tr257: -//line scanner/scanner.rl:285 + tr264: +//line scanner/scanner.rl:295 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_CONCAT_EQUAL { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr258: -//line scanner/scanner.rl:165 + goto st121 + tr265: +//line scanner/scanner.rl:175 lex.te = (lex.p) (lex.p)-- { @@ -3880,26 +3981,26 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_DNUMBER { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr261: -//line scanner/scanner.rl:288 + goto st121 + tr268: +//line scanner/scanner.rl:298 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_DIV_EQUAL { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr262: -//line scanner/scanner.rl:176 + goto st121 + tr269: +//line scanner/scanner.rl:186 lex.te = (lex.p) (lex.p)-- { @@ -3916,7 +4017,7 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_LNUMBER { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } @@ -3925,13 +4026,13 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_DNUMBER { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr267: -//line scanner/scanner.rl:166 + goto st121 + tr274: +//line scanner/scanner.rl:176 lex.te = (lex.p) (lex.p)-- { @@ -3943,7 +4044,7 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_LNUMBER { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } @@ -3952,13 +4053,13 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_DNUMBER { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr268: -//line scanner/scanner.rl:191 + goto st121 + tr275: +//line scanner/scanner.rl:201 lex.te = (lex.p) (lex.p)-- { @@ -3970,7 +4071,7 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_LNUMBER { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } @@ -3979,71 +4080,71 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_DNUMBER { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr269: -//line scanner/scanner.rl:280 + goto st121 + tr276: +//line scanner/scanner.rl:290 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_PAAMAYIM_NEKUDOTAYIM { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr270: - lex.cs = 117 -//line scanner/scanner.rl:163 + goto st121 + tr277: + lex.cs = 121 +//line scanner/scanner.rl:173 lex.te = (lex.p) (lex.p)-- { lex.setTokenPosition(token) tok = TokenID(int(';')) - lex.cs = 110 + lex.cs = 114 { (lex.p)++ goto _out } } goto _again - tr272: - lex.cs = 117 + tr279: + lex.cs = 121 //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) -//line scanner/scanner.rl:163 +//line scanner/scanner.rl:173 lex.te = (lex.p) (lex.p)-- { lex.setTokenPosition(token) tok = TokenID(int(';')) - lex.cs = 110 + lex.cs = 114 { (lex.p)++ goto _out } } goto _again - tr275: -//line scanner/scanner.rl:297 + tr282: +//line scanner/scanner.rl:307 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_IS_NOT_EQUAL { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr276: -//line scanner/scanner.rl:306 + goto st121 + tr283: +//line scanner/scanner.rl:316 lex.te = (lex.p) (lex.p)-- { @@ -4051,29 +4152,29 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_SL { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr277: -//line scanner/scanner.rl:301 + goto st121 + tr284: +//line scanner/scanner.rl:311 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_SL_EQUAL { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr278: - lex.cs = 117 + goto st121 + tr285: + lex.cs = 121 //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) -//line scanner/scanner.rl:356 +//line scanner/scanner.rl:366 lex.te = (lex.p) (lex.p)-- { @@ -4082,11 +4183,11 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_START_HEREDOC if lex.isHeredocEnd(lex.p + 1) { - lex.cs = 491 + lex.cs = 495 } else if lex.data[lblStart-1] == '\'' { - lex.cs = 470 + lex.cs = 474 } else { - lex.cs = 473 + lex.cs = 477 } { (lex.p)++ @@ -4094,8 +4195,8 @@ func (lex *Lexer) Lex(lval Lval) int { } } goto _again - tr279: -//line scanner/scanner.rl:304 + tr286: +//line scanner/scanner.rl:314 lex.te = (lex.p) (lex.p)-- { @@ -4103,39 +4204,39 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_IS_SMALLER_OR_EQUAL { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr280: -//line scanner/scanner.rl:296 + goto st121 + tr287: +//line scanner/scanner.rl:306 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_SPACESHIP { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr282: -//line scanner/scanner.rl:295 + goto st121 + tr289: +//line scanner/scanner.rl:305 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_DOUBLE_ARROW { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr283: -//line scanner/scanner.rl:299 + goto st121 + tr290: +//line scanner/scanner.rl:309 lex.te = (lex.p) (lex.p)-- { @@ -4143,39 +4244,39 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_IS_EQUAL { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr284: -//line scanner/scanner.rl:300 + goto st121 + tr291: +//line scanner/scanner.rl:310 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_IS_IDENTICAL { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr285: -//line scanner/scanner.rl:303 + goto st121 + tr292: +//line scanner/scanner.rl:313 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_IS_GREATER_OR_EQUAL { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr287: -//line scanner/scanner.rl:307 + goto st121 + tr294: +//line scanner/scanner.rl:317 lex.te = (lex.p) (lex.p)-- { @@ -4183,58 +4284,58 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_SR { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr288: -//line scanner/scanner.rl:302 + goto st121 + tr295: +//line scanner/scanner.rl:312 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_SR_EQUAL { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr291: - lex.cs = 117 -//line scanner/scanner.rl:162 + goto st121 + tr298: + lex.cs = 121 +//line scanner/scanner.rl:172 lex.te = (lex.p) (lex.p)-- { lex.setTokenPosition(token) tok = TokenID(int(';')) - lex.cs = 110 + lex.cs = 114 { (lex.p)++ goto _out } } goto _again - tr293: - lex.cs = 117 + tr300: + lex.cs = 121 //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) -//line scanner/scanner.rl:162 +//line scanner/scanner.rl:172 lex.te = (lex.p) (lex.p)-- { lex.setTokenPosition(token) tok = TokenID(int(';')) - lex.cs = 110 + lex.cs = 114 { (lex.p)++ goto _out } } goto _again - tr294: -//line scanner/scanner.rl:308 + tr301: +//line scanner/scanner.rl:318 lex.te = (lex.p) (lex.p)-- { @@ -4242,26 +4343,26 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_COALESCE { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr295: -//line scanner/scanner.rl:309 + goto st121 + tr302: +//line scanner/scanner.rl:319 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_COALESCE_EQUAL { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr296: -//line scanner/scanner.rl:346 + goto st121 + tr303: +//line scanner/scanner.rl:356 lex.te = (lex.p) (lex.p)-- { @@ -4269,13 +4370,13 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_STRING { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr376: -//line scanner/scanner.rl:217 + goto st121 + tr383: +//line scanner/scanner.rl:227 lex.te = (lex.p) (lex.p)-- { @@ -4283,13 +4384,13 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_ELSE { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr396: -//line scanner/scanner.rl:221 + goto st121 + tr403: +//line scanner/scanner.rl:231 lex.te = (lex.p) (lex.p)-- { @@ -4297,13 +4398,13 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_ENDFOR { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr425: -//line scanner/scanner.rl:229 + goto st121 + tr432: +//line scanner/scanner.rl:239 lex.te = (lex.p) (lex.p)-- { @@ -4311,13 +4412,13 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_FINAL { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr429: -//line scanner/scanner.rl:231 + goto st121 + tr436: +//line scanner/scanner.rl:241 lex.te = (lex.p) (lex.p)-- { @@ -4325,13 +4426,13 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_FOR { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr461: -//line scanner/scanner.rl:261 + goto st121 + tr468: +//line scanner/scanner.rl:271 lex.te = (lex.p) (lex.p)-- { @@ -4339,13 +4440,13 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_INCLUDE { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr529: -//line scanner/scanner.rl:263 + goto st121 + tr536: +//line scanner/scanner.rl:273 lex.te = (lex.p) (lex.p)-- { @@ -4353,13 +4454,13 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_REQUIRE { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr575: -//line scanner/scanner.rl:260 + goto st121 + tr582: +//line scanner/scanner.rl:270 lex.te = (lex.p) (lex.p)-- { @@ -4367,565 +4468,327 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_YIELD { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr580: -//line scanner/scanner.rl:291 + goto st121 + tr587: +//line scanner/scanner.rl:301 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_XOR_EQUAL { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr654: -//line scanner/scanner.rl:284 + goto st121 + tr661: +//line scanner/scanner.rl:294 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_OR_EQUAL { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - tr655: -//line scanner/scanner.rl:282 + goto st121 + tr662: +//line scanner/scanner.rl:292 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_BOOLEAN_OR { (lex.p)++ - lex.cs = 117 + lex.cs = 121 goto _out } } - goto st117 - st117: + goto st121 + st121: //line NONE:1 lex.ts = 0 if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof117 + goto _test_eof121 } - st_case_117: + st_case_121: //line NONE:1 lex.ts = (lex.p) -//line scanner/scanner.go:3286 +//line scanner/scanner.go:3387 switch lex.data[(lex.p)] { case 10: - goto tr7 + goto tr10 case 13: - goto st120 - case 32: - goto tr174 - case 33: - goto st121 - case 34: - goto tr177 - case 35: goto st124 - case 36: - goto st126 - case 37: + case 32: + goto tr181 + case 33: + goto st125 + case 34: + goto tr184 + case 35: goto st128 - case 38: - goto st129 - case 39: - goto tr182 - case 40: - goto tr183 - case 42: + case 36: + goto st130 + case 37: goto st132 - case 43: - goto st134 - case 45: - goto st135 - case 46: - goto tr188 - case 47: + case 38: + goto st133 + case 39: goto tr189 - case 48: + case 40: goto tr190 + case 42: + goto st136 + case 43: + goto st138 + case 45: + goto st139 + case 46: + goto tr195 + case 47: + goto tr196 + case 48: + goto tr197 case 58: - goto st145 - case 59: - goto tr192 - case 60: goto st149 - case 61: + case 59: + goto tr199 + case 60: goto st153 - case 62: - goto st155 - case 63: + case 61: goto st157 + case 62: + goto st159 + case 63: + goto st161 case 64: - goto tr184 + goto tr191 case 65: - goto st161 + goto st165 case 66: - goto tr198 + goto tr205 case 67: - goto st177 + goto st181 case 68: - goto st206 + goto st210 case 69: - goto st217 + goto st221 case 70: - goto st259 + goto st263 case 71: - goto st270 + goto st274 case 73: - goto st277 + goto st281 case 76: - goto st316 + goto st320 case 78: - goto st319 + goto st323 case 79: - goto st328 + goto st332 case 80: - goto st329 + goto st333 case 82: - goto st346 + goto st350 case 83: - goto st360 + goto st364 case 84: - goto st369 + goto st373 case 85: - goto st376 + goto st380 case 86: - goto st381 + goto st385 case 87: - goto st383 + goto st387 case 88: - goto st387 + goto st391 case 89: - goto st389 + goto st393 case 92: - goto tr218 + goto tr225 case 94: - goto st397 + goto st401 case 95: - goto st398 + goto st402 case 96: - goto tr221 + goto tr228 case 97: - goto st161 + goto st165 case 98: - goto tr198 + goto tr205 case 99: - goto st177 + goto st181 case 100: - goto st206 + goto st210 case 101: - goto st217 + goto st221 case 102: - goto st259 + goto st263 case 103: - goto st270 + goto st274 case 105: - goto st277 + goto st281 case 108: - goto st316 + goto st320 case 110: - goto st319 + goto st323 case 111: - goto st328 + goto st332 case 112: - goto st329 + goto st333 case 114: - goto st346 + goto st350 case 115: - goto st360 + goto st364 case 116: - goto st369 + goto st373 case 117: - goto st376 + goto st380 case 118: - goto st381 + goto st385 case 119: - goto st383 - case 120: goto st387 + case 120: + goto st391 case 121: - goto st389 + goto st393 case 123: - goto tr222 + goto tr229 case 124: - goto st463 + goto st467 case 125: - goto tr224 + goto tr231 case 126: - goto tr184 + goto tr191 case 127: - goto tr173 + goto tr180 } switch { case lex.data[(lex.p)] < 14: switch { case lex.data[(lex.p)] > 8: if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto tr174 + goto tr181 } default: - goto tr173 + goto tr180 } case lex.data[(lex.p)] > 31: switch { case lex.data[(lex.p)] < 49: if 41 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 44 { - goto tr184 + goto tr191 } case lex.data[(lex.p)] > 57: if 91 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 93 { - goto tr184 + goto tr191 } default: - goto tr94 + goto tr97 } default: - goto tr173 + goto tr180 } - goto tr204 - tr174: + goto tr211 + tr181: //line NONE:1 lex.te = (lex.p) + 1 - goto st118 - tr228: + goto st122 + tr235: //line NONE:1 lex.te = (lex.p) + 1 //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) - goto st118 - st118: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof118 - } - st_case_118: -//line scanner/scanner.go:3479 - switch lex.data[(lex.p)] { - case 10: - goto tr7 - case 13: - goto st5 - case 32: - goto tr174 - } - if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto tr174 - } - goto tr225 - tr7: -//line NONE:1 - lex.te = (lex.p) + 1 - - goto st119 - tr229: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) - goto st119 - st119: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof119 - } - st_case_119: -//line scanner/scanner.go:3509 - switch lex.data[(lex.p)] { - case 10: - goto tr229 - case 13: - goto tr230 - case 32: - goto tr228 - } - if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto tr228 - } - goto tr227 - tr230: -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) - goto st5 - st5: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof5 - } - st_case_5: -//line scanner/scanner.go:3531 - if lex.data[(lex.p)] == 10 { - goto tr7 - } - goto tr6 - st120: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof120 - } - st_case_120: - if lex.data[(lex.p)] == 10 { - goto tr7 - } - goto tr231 - st121: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof121 - } - st_case_121: - if lex.data[(lex.p)] == 61 { - goto st122 - } - goto tr232 + goto st122 st122: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof122 } st_case_122: - if lex.data[(lex.p)] == 61 { - goto tr235 +//line scanner/scanner.go:3580 + switch lex.data[(lex.p)] { + case 10: + goto tr10 + case 13: + goto st6 + case 32: + goto tr181 } - goto tr234 - tr177: + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr181 + } + goto tr232 + tr10: //line NONE:1 lex.te = (lex.p) + 1 -//line scanner/scanner.rl:371 - lex.act = 138 + goto st123 + tr236: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) goto st123 st123: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof123 } st_case_123: -//line scanner/scanner.go:3575 +//line scanner/scanner.go:3610 switch lex.data[(lex.p)] { case 10: - goto tr10 + goto tr236 case 13: - goto tr10 - case 34: - goto tr11 - case 36: - goto st7 - case 92: - goto st8 - case 123: - goto st9 + goto tr237 + case 32: + goto tr235 } - goto st6 - tr10: -//line scanner/scanner.rl:50 - - if lex.data[lex.p] == '\n' { - lex.NewLines.Append(lex.p) + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr235 } - - if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { - lex.NewLines.Append(lex.p) - } - + goto tr234 + tr237: +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) goto st6 st6: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof6 } st_case_6: -//line scanner/scanner.go:3608 - switch lex.data[(lex.p)] { - case 10: - goto tr10 - case 13: - goto tr10 - case 34: - goto tr11 - case 36: - goto st7 - case 92: - goto st8 - case 123: - goto st9 - } - goto st6 - st7: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof7 - } - st_case_7: - switch lex.data[(lex.p)] { - case 10: - goto tr10 - case 13: - goto tr10 - case 34: - goto tr11 - case 92: - goto st8 - case 96: - goto st6 - } - switch { - case lex.data[(lex.p)] < 91: - if lex.data[(lex.p)] <= 64 { - goto st6 - } - case lex.data[(lex.p)] > 94: - if 124 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto st6 - } - default: - goto st6 - } - goto tr8 - st8: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof8 - } - st_case_8: - switch lex.data[(lex.p)] { - case 10: - goto tr10 - case 13: +//line scanner/scanner.go:3632 + if lex.data[(lex.p)] == 10 { goto tr10 } - goto st6 - st9: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof9 - } - st_case_9: - switch lex.data[(lex.p)] { - case 10: - goto tr10 - case 13: - goto tr10 - case 34: - goto tr11 - case 36: - goto tr8 - } - goto st6 - tr240: -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) - goto st124 + goto tr9 st124: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof124 } st_case_124: -//line scanner/scanner.go:3691 - _widec = int16(lex.data[(lex.p)]) - switch { - case lex.data[(lex.p)] < 11: - switch { - case lex.data[(lex.p)] > 9: - if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { - _widec = 256 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotPhpCloseToken() && lex.isNotNewLine() { - _widec += 256 - } - } - default: - _widec = 256 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotPhpCloseToken() && lex.isNotNewLine() { - _widec += 256 - } - } - case lex.data[(lex.p)] > 12: - switch { - case lex.data[(lex.p)] > 13: - if 14 <= lex.data[(lex.p)] { - _widec = 256 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotPhpCloseToken() && lex.isNotNewLine() { - _widec += 256 - } - } - case lex.data[(lex.p)] >= 13: - _widec = 256 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotPhpCloseToken() && lex.isNotNewLine() { - _widec += 256 - } - } - default: - _widec = 256 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotPhpCloseToken() && lex.isNotNewLine() { - _widec += 256 - } + if lex.data[(lex.p)] == 10 { + goto tr10 } - if _widec == 522 { - goto st125 - } - if 512 <= _widec && _widec <= 767 { - goto st124 - } - goto tr237 - tr241: -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) - goto st125 + goto tr238 st125: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof125 } st_case_125: -//line scanner/scanner.go:3746 - _widec = int16(lex.data[(lex.p)]) - switch { - case lex.data[(lex.p)] < 11: - switch { - case lex.data[(lex.p)] > 9: - if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { - _widec = 256 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotPhpCloseToken() && lex.isNotNewLine() { - _widec += 256 - } - } - default: - _widec = 256 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotPhpCloseToken() && lex.isNotNewLine() { - _widec += 256 - } - } - case lex.data[(lex.p)] > 12: - switch { - case lex.data[(lex.p)] > 13: - if 14 <= lex.data[(lex.p)] { - _widec = 256 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotPhpCloseToken() && lex.isNotNewLine() { - _widec += 256 - } - } - case lex.data[(lex.p)] >= 13: - _widec = 256 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotPhpCloseToken() && lex.isNotNewLine() { - _widec += 256 - } - } - default: - _widec = 256 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotPhpCloseToken() && lex.isNotNewLine() { - _widec += 256 - } - } - if _widec == 522 { - goto tr241 - } - if 512 <= _widec && _widec <= 767 { - goto tr240 + if lex.data[(lex.p)] == 61 { + goto st126 } goto tr239 st126: @@ -4933,92 +4796,39 @@ func (lex *Lexer) Lex(lval Lval) int { goto _test_eof126 } st_case_126: - if lex.data[(lex.p)] == 96 { - goto tr232 - } - switch { - case lex.data[(lex.p)] < 91: - if lex.data[(lex.p)] <= 64 { - goto tr232 - } - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr232 - } - default: - goto tr232 + if lex.data[(lex.p)] == 61 { + goto tr242 } + goto tr241 + tr184: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:381 + lex.act = 140 goto st127 st127: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof127 } st_case_127: - if lex.data[(lex.p)] == 96 { - goto tr243 - } - switch { - case lex.data[(lex.p)] < 58: - if lex.data[(lex.p)] <= 47 { - goto tr243 - } - case lex.data[(lex.p)] > 64: - switch { - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr243 - } - case lex.data[(lex.p)] >= 91: - goto tr243 - } - default: - goto tr243 - } - goto st127 - st128: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof128 - } - st_case_128: - if lex.data[(lex.p)] == 61 { - goto tr244 - } - goto tr232 - st129: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof129 - } - st_case_129: - switch lex.data[(lex.p)] { - case 38: - goto tr245 - case 61: - goto tr246 - } - goto tr232 - tr182: -//line NONE:1 - lex.te = (lex.p) + 1 - - goto st130 - st130: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof130 - } - st_case_130: -//line scanner/scanner.go:3870 +//line scanner/scanner.go:3676 switch lex.data[(lex.p)] { case 10: - goto tr17 + goto tr13 case 13: - goto tr17 - case 39: - goto tr11 + goto tr13 + case 34: + goto tr14 + case 36: + goto st8 case 92: - goto st11 + goto st9 + case 123: + goto st10 } - goto st10 - tr17: + goto st7 + tr13: //line scanner/scanner.rl:50 if lex.data[lex.p] == '\n' { @@ -5029,156 +4839,435 @@ func (lex *Lexer) Lex(lval Lval) int { lex.NewLines.Append(lex.p) } - goto st10 + goto st7 + st7: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof7 + } + st_case_7: +//line scanner/scanner.go:3709 + switch lex.data[(lex.p)] { + case 10: + goto tr13 + case 13: + goto tr13 + case 34: + goto tr14 + case 36: + goto st8 + case 92: + goto st9 + case 123: + goto st10 + } + goto st7 + st8: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof8 + } + st_case_8: + switch lex.data[(lex.p)] { + case 10: + goto tr13 + case 13: + goto tr13 + case 34: + goto tr14 + case 92: + goto st9 + case 96: + goto st7 + } + switch { + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto st7 + } + case lex.data[(lex.p)] > 94: + if 124 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto st7 + } + default: + goto st7 + } + goto tr11 + st9: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof9 + } + st_case_9: + switch lex.data[(lex.p)] { + case 10: + goto tr13 + case 13: + goto tr13 + } + goto st7 st10: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof10 } st_case_10: -//line scanner/scanner.go:3899 switch lex.data[(lex.p)] { case 10: - goto tr17 + goto tr13 case 13: - goto tr17 - case 39: + goto tr13 + case 34: + goto tr14 + case 36: goto tr11 - case 92: - goto st11 } - goto st10 - st11: + goto st7 + tr247: +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) + goto st128 + st128: if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof11 + goto _test_eof128 } - st_case_11: - switch lex.data[(lex.p)] { - case 10: - goto tr17 - case 13: - goto tr17 + st_case_128: +//line scanner/scanner.go:3792 + _widec = int16(lex.data[(lex.p)]) + switch { + case lex.data[(lex.p)] < 11: + switch { + case lex.data[(lex.p)] > 9: + if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { + _widec = 256 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotPhpCloseToken() && lex.isNotNewLine() { + _widec += 256 + } + } + default: + _widec = 256 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotPhpCloseToken() && lex.isNotNewLine() { + _widec += 256 + } + } + case lex.data[(lex.p)] > 12: + switch { + case lex.data[(lex.p)] > 13: + if 14 <= lex.data[(lex.p)] { + _widec = 256 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotPhpCloseToken() && lex.isNotNewLine() { + _widec += 256 + } + } + case lex.data[(lex.p)] >= 13: + _widec = 256 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotPhpCloseToken() && lex.isNotNewLine() { + _widec += 256 + } + } + default: + _widec = 256 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotPhpCloseToken() && lex.isNotNewLine() { + _widec += 256 + } + } + if _widec == 522 { + goto st129 + } + if 512 <= _widec && _widec <= 767 { + goto st128 + } + goto tr244 + tr248: +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) + goto st129 + st129: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof129 + } + st_case_129: +//line scanner/scanner.go:3847 + _widec = int16(lex.data[(lex.p)]) + switch { + case lex.data[(lex.p)] < 11: + switch { + case lex.data[(lex.p)] > 9: + if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { + _widec = 256 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotPhpCloseToken() && lex.isNotNewLine() { + _widec += 256 + } + } + default: + _widec = 256 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotPhpCloseToken() && lex.isNotNewLine() { + _widec += 256 + } + } + case lex.data[(lex.p)] > 12: + switch { + case lex.data[(lex.p)] > 13: + if 14 <= lex.data[(lex.p)] { + _widec = 256 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotPhpCloseToken() && lex.isNotNewLine() { + _widec += 256 + } + } + case lex.data[(lex.p)] >= 13: + _widec = 256 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotPhpCloseToken() && lex.isNotNewLine() { + _widec += 256 + } + } + default: + _widec = 256 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotPhpCloseToken() && lex.isNotNewLine() { + _widec += 256 + } + } + if _widec == 522 { + goto tr248 + } + if 512 <= _widec && _widec <= 767 { + goto tr247 + } + goto tr246 + st130: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof130 + } + st_case_130: + if lex.data[(lex.p)] == 96 { + goto tr239 + } + switch { + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto tr239 + } + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr239 + } + default: + goto tr239 } - goto st10 - tr183: -//line NONE:1 - lex.te = (lex.p) + 1 - goto st131 st131: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof131 } st_case_131: -//line scanner/scanner.go:3933 + if lex.data[(lex.p)] == 96 { + goto tr250 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr250 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr250 + } + case lex.data[(lex.p)] >= 91: + goto tr250 + } + default: + goto tr250 + } + goto st131 + st132: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof132 + } + st_case_132: + if lex.data[(lex.p)] == 61 { + goto tr251 + } + goto tr239 + st133: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof133 + } + st_case_133: switch lex.data[(lex.p)] { - case 9: - goto st12 - case 32: - goto st12 - case 65: - goto st13 - case 66: - goto st18 - case 68: - goto st30 - case 70: - goto st36 - case 73: - goto st40 - case 79: - goto st47 - case 82: - goto st53 - case 83: - goto st56 - case 85: - goto st61 - case 97: - goto st13 - case 98: - goto st18 - case 100: - goto st30 - case 102: - goto st36 - case 105: - goto st40 - case 111: - goto st47 - case 114: - goto st53 - case 115: - goto st56 - case 117: - goto st61 + case 38: + goto tr252 + case 61: + goto tr253 } - if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr239 + tr189: +//line NONE:1 + lex.te = (lex.p) + 1 + + goto st134 + st134: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof134 + } + st_case_134: +//line scanner/scanner.go:3971 + switch lex.data[(lex.p)] { + case 10: + goto tr20 + case 13: + goto tr20 + case 39: + goto tr14 + case 92: goto st12 } - goto tr232 + goto st11 + tr20: +//line scanner/scanner.rl:50 + + if lex.data[lex.p] == '\n' { + lex.NewLines.Append(lex.p) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.NewLines.Append(lex.p) + } + + goto st11 + st11: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof11 + } + st_case_11: +//line scanner/scanner.go:4000 + switch lex.data[(lex.p)] { + case 10: + goto tr20 + case 13: + goto tr20 + case 39: + goto tr14 + case 92: + goto st12 + } + goto st11 st12: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof12 } st_case_12: + switch lex.data[(lex.p)] { + case 10: + goto tr20 + case 13: + goto tr20 + } + goto st11 + tr190: +//line NONE:1 + lex.te = (lex.p) + 1 + + goto st135 + st135: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof135 + } + st_case_135: +//line scanner/scanner.go:4034 switch lex.data[(lex.p)] { case 9: - goto st12 + goto st13 case 32: - goto st12 + goto st13 case 65: - goto st13 + goto st14 case 66: - goto st18 + goto st19 case 68: - goto st30 + goto st31 case 70: - goto st36 + goto st37 case 73: - goto st40 + goto st41 case 79: - goto st47 + goto st48 case 82: - goto st53 + goto st54 case 83: - goto st56 + goto st57 case 85: - goto st61 + goto st62 case 97: - goto st13 + goto st14 case 98: - goto st18 + goto st19 case 100: - goto st30 + goto st31 case 102: - goto st36 + goto st37 case 105: - goto st40 + goto st41 case 111: - goto st47 + goto st48 case 114: - goto st53 + goto st54 case 115: - goto st56 + goto st57 case 117: - goto st61 + goto st62 } if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto st12 + goto st13 } - goto tr19 + goto tr239 st13: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof13 } st_case_13: switch lex.data[(lex.p)] { + case 9: + goto st13 + case 32: + goto st13 + case 65: + goto st14 + case 66: + goto st19 + case 68: + goto st31 + case 70: + goto st37 + case 73: + goto st41 + case 79: + goto st48 case 82: + goto st54 + case 83: + goto st57 + case 85: + goto st62 + case 97: goto st14 + case 98: + goto st19 + case 100: + goto st31 + case 102: + goto st37 + case 105: + goto st41 + case 111: + goto st48 case 114: - goto st14 + goto st54 + case 115: + goto st57 + case 117: + goto st62 } - goto tr19 + if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st13 + } + goto tr22 st14: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof14 @@ -5190,174 +5279,165 @@ func (lex *Lexer) Lex(lval Lval) int { case 114: goto st15 } - goto tr19 + goto tr22 st15: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof15 } st_case_15: switch lex.data[(lex.p)] { - case 65: + case 82: goto st16 - case 97: + case 114: goto st16 } - goto tr19 + goto tr22 st16: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof16 } st_case_16: switch lex.data[(lex.p)] { - case 89: + case 65: goto st17 - case 121: + case 97: goto st17 } - goto tr19 + goto tr22 st17: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof17 } st_case_17: switch lex.data[(lex.p)] { - case 9: - goto st17 - case 32: - goto st17 - case 41: - goto tr34 + case 89: + goto st18 + case 121: + goto st18 } - if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto st17 - } - goto tr19 + goto tr22 st18: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof18 } st_case_18: switch lex.data[(lex.p)] { - case 73: - goto st19 - case 79: - goto st24 - case 105: - goto st19 - case 111: - goto st24 + case 9: + goto st18 + case 32: + goto st18 + case 41: + goto tr37 } - goto tr19 + if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st18 + } + goto tr22 st19: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof19 } st_case_19: switch lex.data[(lex.p)] { - case 78: + case 73: goto st20 - case 110: + case 79: + goto st25 + case 105: goto st20 + case 111: + goto st25 } - goto tr19 + goto tr22 st20: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof20 } st_case_20: switch lex.data[(lex.p)] { - case 65: + case 78: goto st21 - case 97: + case 110: goto st21 } - goto tr19 + goto tr22 st21: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof21 } st_case_21: switch lex.data[(lex.p)] { - case 82: + case 65: goto st22 - case 114: + case 97: goto st22 } - goto tr19 + goto tr22 st22: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof22 } st_case_22: switch lex.data[(lex.p)] { - case 89: + case 82: goto st23 - case 121: + case 114: goto st23 } - goto tr19 + goto tr22 st23: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof23 } st_case_23: switch lex.data[(lex.p)] { - case 9: - goto st23 - case 32: - goto st23 - case 41: - goto tr41 + case 89: + goto st24 + case 121: + goto st24 } - if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto st23 - } - goto tr19 + goto tr22 st24: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof24 } st_case_24: switch lex.data[(lex.p)] { - case 79: - goto st25 - case 111: - goto st25 + case 9: + goto st24 + case 32: + goto st24 + case 41: + goto tr44 } - goto tr19 + if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st24 + } + goto tr22 st25: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof25 } st_case_25: switch lex.data[(lex.p)] { - case 76: + case 79: goto st26 - case 108: + case 111: goto st26 } - goto tr19 + goto tr22 st26: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof26 } st_case_26: switch lex.data[(lex.p)] { - case 9: + case 76: goto st27 - case 32: - goto st27 - case 41: - goto tr45 - case 69: - goto st28 - case 101: - goto st28 - } - if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + case 108: goto st27 } - goto tr19 + goto tr22 st27: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof27 @@ -5365,210 +5445,210 @@ func (lex *Lexer) Lex(lval Lval) int { st_case_27: switch lex.data[(lex.p)] { case 9: - goto st27 + goto st28 case 32: - goto st27 + goto st28 case 41: - goto tr45 + goto tr48 + case 69: + goto st29 + case 101: + goto st29 } if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto st27 + goto st28 } - goto tr19 + goto tr22 st28: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof28 } st_case_28: switch lex.data[(lex.p)] { - case 65: - goto st29 - case 97: - goto st29 + case 9: + goto st28 + case 32: + goto st28 + case 41: + goto tr48 } - goto tr19 + if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st28 + } + goto tr22 st29: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof29 } st_case_29: switch lex.data[(lex.p)] { - case 78: - goto st27 - case 110: - goto st27 + case 65: + goto st30 + case 97: + goto st30 } - goto tr19 + goto tr22 st30: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof30 } st_case_30: switch lex.data[(lex.p)] { - case 79: - goto st31 - case 111: - goto st31 + case 78: + goto st28 + case 110: + goto st28 } - goto tr19 + goto tr22 st31: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof31 } st_case_31: switch lex.data[(lex.p)] { - case 85: + case 79: goto st32 - case 117: + case 111: goto st32 } - goto tr19 + goto tr22 st32: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof32 } st_case_32: switch lex.data[(lex.p)] { - case 66: + case 85: goto st33 - case 98: + case 117: goto st33 } - goto tr19 + goto tr22 st33: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof33 } st_case_33: switch lex.data[(lex.p)] { - case 76: + case 66: goto st34 - case 108: + case 98: goto st34 } - goto tr19 + goto tr22 st34: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof34 } st_case_34: switch lex.data[(lex.p)] { - case 69: + case 76: goto st35 - case 101: + case 108: goto st35 } - goto tr19 + goto tr22 st35: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof35 } st_case_35: switch lex.data[(lex.p)] { - case 9: - goto st35 - case 32: - goto st35 - case 41: - goto tr53 + case 69: + goto st36 + case 101: + goto st36 } - if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto st35 - } - goto tr19 + goto tr22 st36: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof36 } st_case_36: switch lex.data[(lex.p)] { - case 76: - goto st37 - case 108: - goto st37 + case 9: + goto st36 + case 32: + goto st36 + case 41: + goto tr56 } - goto tr19 + if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st36 + } + goto tr22 st37: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof37 } st_case_37: switch lex.data[(lex.p)] { - case 79: + case 76: goto st38 - case 111: + case 108: goto st38 } - goto tr19 + goto tr22 st38: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof38 } st_case_38: switch lex.data[(lex.p)] { - case 65: + case 79: goto st39 - case 97: + case 111: goto st39 } - goto tr19 + goto tr22 st39: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof39 } st_case_39: switch lex.data[(lex.p)] { - case 84: - goto st35 - case 116: - goto st35 + case 65: + goto st40 + case 97: + goto st40 } - goto tr19 + goto tr22 st40: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof40 } st_case_40: switch lex.data[(lex.p)] { - case 78: - goto st41 - case 110: - goto st41 + case 84: + goto st36 + case 116: + goto st36 } - goto tr19 + goto tr22 st41: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof41 } st_case_41: switch lex.data[(lex.p)] { - case 84: + case 78: goto st42 - case 116: + case 110: goto st42 } - goto tr19 + goto tr22 st42: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof42 } st_case_42: switch lex.data[(lex.p)] { - case 9: + case 84: goto st43 - case 32: - goto st43 - case 41: - goto tr60 - case 69: - goto st44 - case 101: - goto st44 - } - if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + case 116: goto st43 } - goto tr19 + goto tr22 st43: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof43 @@ -5576,483 +5656,487 @@ func (lex *Lexer) Lex(lval Lval) int { st_case_43: switch lex.data[(lex.p)] { case 9: - goto st43 + goto st44 case 32: - goto st43 + goto st44 case 41: - goto tr60 + goto tr63 + case 69: + goto st45 + case 101: + goto st45 } if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto st43 + goto st44 } - goto tr19 + goto tr22 st44: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof44 } st_case_44: switch lex.data[(lex.p)] { - case 71: - goto st45 - case 103: - goto st45 + case 9: + goto st44 + case 32: + goto st44 + case 41: + goto tr63 } - goto tr19 + if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st44 + } + goto tr22 st45: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof45 } st_case_45: switch lex.data[(lex.p)] { - case 69: + case 71: goto st46 - case 101: + case 103: goto st46 } - goto tr19 + goto tr22 st46: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof46 } st_case_46: switch lex.data[(lex.p)] { - case 82: - goto st43 - case 114: - goto st43 + case 69: + goto st47 + case 101: + goto st47 } - goto tr19 + goto tr22 st47: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof47 } st_case_47: switch lex.data[(lex.p)] { - case 66: - goto st48 - case 98: - goto st48 + case 82: + goto st44 + case 114: + goto st44 } - goto tr19 + goto tr22 st48: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof48 } st_case_48: switch lex.data[(lex.p)] { - case 74: + case 66: goto st49 - case 106: + case 98: goto st49 } - goto tr19 + goto tr22 st49: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof49 } st_case_49: switch lex.data[(lex.p)] { - case 69: + case 74: goto st50 - case 101: + case 106: goto st50 } - goto tr19 + goto tr22 st50: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof50 } st_case_50: switch lex.data[(lex.p)] { - case 67: + case 69: goto st51 - case 99: + case 101: goto st51 } - goto tr19 + goto tr22 st51: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof51 } st_case_51: switch lex.data[(lex.p)] { - case 84: + case 67: goto st52 - case 116: + case 99: goto st52 } - goto tr19 + goto tr22 st52: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof52 } st_case_52: switch lex.data[(lex.p)] { - case 9: - goto st52 - case 32: - goto st52 - case 41: - goto tr69 + case 84: + goto st53 + case 116: + goto st53 } - if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto st52 - } - goto tr19 + goto tr22 st53: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof53 } st_case_53: switch lex.data[(lex.p)] { - case 69: - goto st54 - case 101: - goto st54 + case 9: + goto st53 + case 32: + goto st53 + case 41: + goto tr72 } - goto tr19 + if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st53 + } + goto tr22 st54: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof54 } st_case_54: switch lex.data[(lex.p)] { - case 65: + case 69: goto st55 - case 97: + case 101: goto st55 } - goto tr19 + goto tr22 st55: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof55 } st_case_55: switch lex.data[(lex.p)] { - case 76: - goto st35 - case 108: - goto st35 + case 65: + goto st56 + case 97: + goto st56 } - goto tr19 + goto tr22 st56: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof56 } st_case_56: switch lex.data[(lex.p)] { - case 84: - goto st57 - case 116: - goto st57 + case 76: + goto st36 + case 108: + goto st36 } - goto tr19 + goto tr22 st57: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof57 } st_case_57: switch lex.data[(lex.p)] { - case 82: + case 84: goto st58 - case 114: + case 116: goto st58 } - goto tr19 + goto tr22 st58: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof58 } st_case_58: switch lex.data[(lex.p)] { - case 73: + case 82: goto st59 - case 105: + case 114: goto st59 } - goto tr19 + goto tr22 st59: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof59 } st_case_59: switch lex.data[(lex.p)] { - case 78: + case 73: goto st60 - case 110: + case 105: goto st60 } - goto tr19 + goto tr22 st60: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof60 } st_case_60: switch lex.data[(lex.p)] { - case 71: - goto st23 - case 103: - goto st23 + case 78: + goto st61 + case 110: + goto st61 } - goto tr19 + goto tr22 st61: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof61 } st_case_61: switch lex.data[(lex.p)] { - case 78: - goto st62 - case 110: - goto st62 + case 71: + goto st24 + case 103: + goto st24 } - goto tr19 + goto tr22 st62: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof62 } st_case_62: switch lex.data[(lex.p)] { - case 83: + case 78: goto st63 - case 115: + case 110: goto st63 } - goto tr19 + goto tr22 st63: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof63 } st_case_63: switch lex.data[(lex.p)] { - case 69: + case 83: goto st64 - case 101: + case 115: goto st64 } - goto tr19 + goto tr22 st64: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof64 } st_case_64: switch lex.data[(lex.p)] { - case 84: + case 69: goto st65 - case 116: + case 101: goto st65 } - goto tr19 + goto tr22 st65: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof65 } st_case_65: switch lex.data[(lex.p)] { - case 9: - goto st65 - case 32: - goto st65 - case 41: - goto tr80 - } - if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto st65 - } - goto tr19 - st132: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof132 - } - st_case_132: - switch lex.data[(lex.p)] { - case 42: - goto st133 - case 61: - goto tr248 - } - goto tr232 - st133: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof133 - } - st_case_133: - if lex.data[(lex.p)] == 61 { - goto tr250 - } - goto tr249 - st134: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof134 - } - st_case_134: - switch lex.data[(lex.p)] { - case 43: - goto tr251 - case 61: - goto tr252 - } - goto tr232 - st135: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof135 - } - st_case_135: - switch lex.data[(lex.p)] { - case 45: - goto tr253 - case 61: - goto tr254 - case 62: - goto tr255 - } - goto tr232 - tr188: -//line NONE:1 - lex.te = (lex.p) + 1 - - goto st136 - st136: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof136 - } - st_case_136: -//line scanner/scanner.go:4781 - switch lex.data[(lex.p)] { - case 46: + case 84: + goto st66 + case 116: goto st66 - case 61: - goto tr257 } - if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { - goto tr85 - } - goto tr232 + goto tr22 st66: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof66 } st_case_66: - if lex.data[(lex.p)] == 46 { - goto tr81 + switch lex.data[(lex.p)] { + case 9: + goto st66 + case 32: + goto st66 + case 41: + goto tr83 } - goto tr19 - tr85: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:165 - lex.act = 8 - goto st137 + if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st66 + } + goto tr22 + st136: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof136 + } + st_case_136: + switch lex.data[(lex.p)] { + case 42: + goto st137 + case 61: + goto tr255 + } + goto tr239 st137: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof137 } st_case_137: -//line scanner/scanner.go:4813 - switch lex.data[(lex.p)] { - case 69: - goto st67 - case 95: - goto st69 - case 101: - goto st67 + if lex.data[(lex.p)] == 61 { + goto tr257 } - if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { - goto tr85 - } - goto tr258 - st67: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof67 - } - st_case_67: - switch lex.data[(lex.p)] { - case 43: - goto st68 - case 45: - goto st68 - } - if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { - goto tr83 - } - goto tr8 - st68: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof68 - } - st_case_68: - if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { - goto tr83 - } - goto tr8 - tr83: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:165 - lex.act = 8 - goto st138 + goto tr256 st138: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof138 } st_case_138: -//line scanner/scanner.go:4862 - if lex.data[(lex.p)] == 95 { + switch lex.data[(lex.p)] { + case 43: + goto tr258 + case 61: + goto tr259 + } + goto tr239 + st139: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof139 + } + st_case_139: + switch lex.data[(lex.p)] { + case 45: + goto tr260 + case 61: + goto tr261 + case 62: + goto tr262 + } + goto tr239 + tr195: +//line NONE:1 + lex.te = (lex.p) + 1 + + goto st140 + st140: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof140 + } + st_case_140: +//line scanner/scanner.go:4882 + switch lex.data[(lex.p)] { + case 46: + goto st67 + case 61: + goto tr264 + } + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr88 + } + goto tr239 + st67: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof67 + } + st_case_67: + if lex.data[(lex.p)] == 46 { + goto tr84 + } + goto tr22 + tr88: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:175 + lex.act = 10 + goto st141 + st141: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof141 + } + st_case_141: +//line scanner/scanner.go:4914 + switch lex.data[(lex.p)] { + case 69: + goto st68 + case 95: + goto st70 + case 101: goto st68 } if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { - goto tr83 + goto tr88 } - goto tr258 + goto tr265 + st68: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof68 + } + st_case_68: + switch lex.data[(lex.p)] { + case 43: + goto st69 + case 45: + goto st69 + } + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr86 + } + goto tr11 st69: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof69 } st_case_69: if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { - goto tr85 + goto tr86 } - goto tr84 - tr189: + goto tr11 + tr86: //line NONE:1 lex.te = (lex.p) + 1 - goto st139 - st139: +//line scanner/scanner.rl:175 + lex.act = 10 + goto st142 + st142: if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof139 + goto _test_eof142 } - st_case_139: -//line scanner/scanner.go:4889 - switch lex.data[(lex.p)] { - case 42: - goto st70 - case 47: - goto st124 - case 61: - goto tr261 + st_case_142: +//line scanner/scanner.go:4963 + if lex.data[(lex.p)] == 95 { + goto st69 } - goto tr232 - tr89: -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) - goto st70 + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr86 + } + goto tr265 st70: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof70 } st_case_70: -//line scanner/scanner.go:4908 - switch lex.data[(lex.p)] { - case 10: - goto st71 - case 42: - goto st72 + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr88 } - goto st70 - tr90: + goto tr87 + tr196: +//line NONE:1 + lex.te = (lex.p) + 1 + + goto st143 + st143: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof143 + } + st_case_143: +//line scanner/scanner.go:4990 + switch lex.data[(lex.p)] { + case 42: + goto st71 + case 47: + goto st128 + case 61: + goto tr268 + } + goto tr239 + tr92: //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) goto st71 @@ -6061,15 +6145,15 @@ func (lex *Lexer) Lex(lval Lval) int { goto _test_eof71 } st_case_71: -//line scanner/scanner.go:4925 +//line scanner/scanner.go:5009 switch lex.data[(lex.p)] { case 10: - goto tr90 + goto st72 case 42: - goto tr91 + goto st73 } - goto tr89 - tr91: + goto st71 + tr93: //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) goto st72 @@ -6078,241 +6162,234 @@ func (lex *Lexer) Lex(lval Lval) int { goto _test_eof72 } st_case_72: -//line scanner/scanner.go:4942 +//line scanner/scanner.go:5026 switch lex.data[(lex.p)] { case 10: - goto st71 + goto tr93 case 42: - goto st72 - case 47: - goto tr92 - } - goto st70 - tr190: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:176 - lex.act = 10 - goto st140 - st140: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof140 - } - st_case_140: -//line scanner/scanner.go:4964 - switch lex.data[(lex.p)] { - case 46: - goto tr263 - case 69: - goto st67 - case 95: - goto st73 - case 98: - goto st74 - case 101: - goto st67 - case 120: - goto st75 - } - if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { goto tr94 } - goto tr262 - tr263: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:165 - lex.act = 8 - goto st141 - st141: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof141 - } - st_case_141: -//line scanner/scanner.go:4995 - switch lex.data[(lex.p)] { - case 69: - goto st67 - case 101: - goto st67 - } - if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { - goto tr85 - } - goto tr258 + goto tr92 tr94: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:176 - lex.act = 10 - goto st142 - st142: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof142 - } - st_case_142: -//line scanner/scanner.go:5018 - switch lex.data[(lex.p)] { - case 46: - goto tr263 - case 69: - goto st67 - case 95: - goto st73 - case 101: - goto st67 - } - if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { - goto tr94 - } - goto tr262 +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) + goto st73 st73: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof73 } st_case_73: - if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { - goto tr94 - } - goto tr93 - st74: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof74 - } - st_case_74: - if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 49 { +//line scanner/scanner.go:5043 + switch lex.data[(lex.p)] { + case 10: + goto st72 + case 42: + goto st73 + case 47: goto tr95 } - goto tr8 - tr95: + goto st71 + tr197: //line NONE:1 lex.te = (lex.p) + 1 -//line scanner/scanner.rl:166 - lex.act = 9 - goto st143 - st143: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof143 - } - st_case_143: -//line scanner/scanner.go:5063 - if lex.data[(lex.p)] == 95 { - goto st74 - } - if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 49 { - goto tr95 - } - goto tr267 - st75: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof75 - } - st_case_75: - switch { - case lex.data[(lex.p)] < 65: - if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { - goto tr96 - } - case lex.data[(lex.p)] > 70: - if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { - goto tr96 - } - default: - goto tr96 - } - goto tr8 - tr96: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:191 - lex.act = 11 +//line scanner/scanner.rl:186 + lex.act = 12 goto st144 st144: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof144 } st_case_144: -//line scanner/scanner.go:5101 - if lex.data[(lex.p)] == 95 { +//line scanner/scanner.go:5065 + switch lex.data[(lex.p)] { + case 46: + goto tr270 + case 69: + goto st68 + case 95: + goto st74 + case 98: goto st75 + case 101: + goto st68 + case 120: + goto st76 } - switch { - case lex.data[(lex.p)] < 65: - if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { - goto tr96 - } - case lex.data[(lex.p)] > 70: - if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { - goto tr96 - } - default: - goto tr96 + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr97 } - goto tr268 + goto tr269 + tr270: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:175 + lex.act = 10 + goto st145 st145: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof145 } st_case_145: - if lex.data[(lex.p)] == 58 { - goto tr269 +//line scanner/scanner.go:5096 + switch lex.data[(lex.p)] { + case 69: + goto st68 + case 101: + goto st68 } - goto tr232 - tr192: + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr88 + } + goto tr265 + tr97: //line NONE:1 lex.te = (lex.p) + 1 +//line scanner/scanner.rl:186 + lex.act = 12 goto st146 st146: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof146 } st_case_146: -//line scanner/scanner.go:5137 +//line scanner/scanner.go:5119 switch lex.data[(lex.p)] { - case 10: - goto st77 - case 13: - goto st78 - case 32: - goto st76 - case 63: - goto st79 + case 46: + goto tr270 + case 69: + goto st68 + case 95: + goto st74 + case 101: + goto st68 } - if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto st76 + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr97 } - goto tr232 - tr101: -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) - goto st76 + goto tr269 + st74: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof74 + } + st_case_74: + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr97 + } + goto tr96 + st75: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof75 + } + st_case_75: + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 49 { + goto tr98 + } + goto tr11 + tr98: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:176 + lex.act = 11 + goto st147 + st147: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof147 + } + st_case_147: +//line scanner/scanner.go:5164 + if lex.data[(lex.p)] == 95 { + goto st75 + } + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 49 { + goto tr98 + } + goto tr274 st76: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof76 } st_case_76: -//line scanner/scanner.go:5161 + switch { + case lex.data[(lex.p)] < 65: + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr99 + } + case lex.data[(lex.p)] > 70: + if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { + goto tr99 + } + default: + goto tr99 + } + goto tr11 + tr99: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:201 + lex.act = 13 + goto st148 + st148: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof148 + } + st_case_148: +//line scanner/scanner.go:5202 + if lex.data[(lex.p)] == 95 { + goto st76 + } + switch { + case lex.data[(lex.p)] < 65: + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr99 + } + case lex.data[(lex.p)] > 70: + if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { + goto tr99 + } + default: + goto tr99 + } + goto tr275 + st149: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof149 + } + st_case_149: + if lex.data[(lex.p)] == 58 { + goto tr276 + } + goto tr239 + tr199: +//line NONE:1 + lex.te = (lex.p) + 1 + + goto st150 + st150: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof150 + } + st_case_150: +//line scanner/scanner.go:5238 switch lex.data[(lex.p)] { case 10: - goto st77 - case 13: goto st78 - case 32: - goto st76 - case 63: + case 13: goto st79 + case 32: + goto st77 + case 63: + goto st80 } if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto st76 + goto st77 } - goto tr19 - tr102: + goto tr239 + tr104: //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) goto st77 @@ -6321,22 +6398,22 @@ func (lex *Lexer) Lex(lval Lval) int { goto _test_eof77 } st_case_77: -//line scanner/scanner.go:5185 +//line scanner/scanner.go:5262 switch lex.data[(lex.p)] { case 10: - goto tr102 + goto st78 case 13: - goto tr103 + goto st79 case 32: - goto tr101 + goto st77 case 63: - goto tr104 + goto st80 } if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto tr101 + goto st77 } - goto tr19 - tr103: + goto tr22 + tr105: //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) goto st78 @@ -6345,12 +6422,22 @@ func (lex *Lexer) Lex(lval Lval) int { goto _test_eof78 } st_case_78: -//line scanner/scanner.go:5209 - if lex.data[(lex.p)] == 10 { - goto st77 +//line scanner/scanner.go:5286 + switch lex.data[(lex.p)] { + case 10: + goto tr105 + case 13: + goto tr106 + case 32: + goto tr104 + case 63: + goto tr107 } - goto tr19 - tr104: + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr104 + } + goto tr22 + tr106: //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) goto st79 @@ -6359,192 +6446,178 @@ func (lex *Lexer) Lex(lval Lval) int { goto _test_eof79 } st_case_79: -//line scanner/scanner.go:5223 - if lex.data[(lex.p)] == 62 { - goto tr105 +//line scanner/scanner.go:5310 + if lex.data[(lex.p)] == 10 { + goto st78 } - goto tr19 - tr105: -//line NONE:1 - lex.te = (lex.p) + 1 - - goto st147 - st147: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof147 - } - st_case_147: -//line scanner/scanner.go:5238 - switch lex.data[(lex.p)] { - case 10: - goto st148 - case 13: - goto st80 - } - goto tr270 - st148: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof148 - } - st_case_148: - goto tr272 + goto tr22 + tr107: +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) + goto st80 st80: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof80 } st_case_80: - if lex.data[(lex.p)] == 10 { - goto st148 +//line scanner/scanner.go:5324 + if lex.data[(lex.p)] == 62 { + goto tr108 } - goto tr106 - st149: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof149 - } - st_case_149: - switch lex.data[(lex.p)] { - case 60: - goto tr273 - case 61: - goto st152 - case 62: - goto tr275 - } - goto tr232 - tr273: + goto tr22 + tr108: //line NONE:1 lex.te = (lex.p) + 1 -//line scanner/scanner.rl:306 - lex.act = 116 - goto st150 - st150: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof150 - } - st_case_150: -//line scanner/scanner.go:5287 - switch lex.data[(lex.p)] { - case 60: - goto st81 - case 61: - goto tr277 - } - goto tr276 - st81: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof81 - } - st_case_81: - switch lex.data[(lex.p)] { - case 9: - goto st81 - case 32: - goto st81 - case 34: - goto st82 - case 39: - goto st86 - case 96: - goto tr8 - } - switch { - case lex.data[(lex.p)] < 91: - if lex.data[(lex.p)] <= 64 { - goto tr8 - } - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr8 - } - default: - goto tr8 - } - goto tr111 - st82: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof82 - } - st_case_82: - if lex.data[(lex.p)] == 96 { - goto tr8 - } - switch { - case lex.data[(lex.p)] < 91: - if lex.data[(lex.p)] <= 64 { - goto tr8 - } - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr8 - } - default: - goto tr8 - } - goto tr112 - tr112: -//line scanner/scanner.rl:47 - lblStart = lex.p - goto st83 - st83: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof83 - } - st_case_83: -//line scanner/scanner.go:5355 - switch lex.data[(lex.p)] { - case 34: - goto tr113 - case 96: - goto tr8 - } - switch { - case lex.data[(lex.p)] < 58: - if lex.data[(lex.p)] <= 47 { - goto tr8 - } - case lex.data[(lex.p)] > 64: - switch { - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr8 - } - case lex.data[(lex.p)] >= 91: - goto tr8 - } - default: - goto tr8 - } - goto st83 - tr113: -//line scanner/scanner.rl:48 - lblEnd = lex.p - goto st84 - st84: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof84 - } - st_case_84: -//line scanner/scanner.go:5389 - switch lex.data[(lex.p)] { - case 10: - goto st151 - case 13: - goto st85 - } - goto tr8 - tr119: -//line scanner/scanner.rl:48 - lblEnd = lex.p goto st151 st151: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof151 } st_case_151: -//line scanner/scanner.go:5406 - goto tr278 - tr120: +//line scanner/scanner.go:5339 + switch lex.data[(lex.p)] { + case 10: + goto st152 + case 13: + goto st81 + } + goto tr277 + st152: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof152 + } + st_case_152: + goto tr279 + st81: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof81 + } + st_case_81: + if lex.data[(lex.p)] == 10 { + goto st152 + } + goto tr109 + st153: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof153 + } + st_case_153: + switch lex.data[(lex.p)] { + case 60: + goto tr280 + case 61: + goto st156 + case 62: + goto tr282 + } + goto tr239 + tr280: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:316 + lex.act = 118 + goto st154 + st154: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof154 + } + st_case_154: +//line scanner/scanner.go:5388 + switch lex.data[(lex.p)] { + case 60: + goto st82 + case 61: + goto tr284 + } + goto tr283 + st82: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof82 + } + st_case_82: + switch lex.data[(lex.p)] { + case 9: + goto st82 + case 32: + goto st82 + case 34: + goto st83 + case 39: + goto st87 + case 96: + goto tr11 + } + switch { + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto tr11 + } + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr11 + } + default: + goto tr11 + } + goto tr114 + st83: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof83 + } + st_case_83: + if lex.data[(lex.p)] == 96 { + goto tr11 + } + switch { + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto tr11 + } + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr11 + } + default: + goto tr11 + } + goto tr115 + tr115: +//line scanner/scanner.rl:47 + lblStart = lex.p + goto st84 + st84: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof84 + } + st_case_84: +//line scanner/scanner.go:5456 + switch lex.data[(lex.p)] { + case 34: + goto tr116 + case 96: + goto tr11 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr11 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr11 + } + case lex.data[(lex.p)] >= 91: + goto tr11 + } + default: + goto tr11 + } + goto st84 + tr116: //line scanner/scanner.rl:48 lblEnd = lex.p goto st85 @@ -6553,67 +6626,61 @@ func (lex *Lexer) Lex(lval Lval) int { goto _test_eof85 } st_case_85: -//line scanner/scanner.go:5417 - if lex.data[(lex.p)] == 10 { - goto st151 +//line scanner/scanner.go:5490 + switch lex.data[(lex.p)] { + case 10: + goto st155 + case 13: + goto st86 } - goto tr8 + goto tr11 + tr122: +//line scanner/scanner.rl:48 + lblEnd = lex.p + goto st155 + st155: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof155 + } + st_case_155: +//line scanner/scanner.go:5507 + goto tr285 + tr123: +//line scanner/scanner.rl:48 + lblEnd = lex.p + goto st86 st86: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof86 } st_case_86: - if lex.data[(lex.p)] == 96 { - goto tr8 +//line scanner/scanner.go:5518 + if lex.data[(lex.p)] == 10 { + goto st155 } - switch { - case lex.data[(lex.p)] < 91: - if lex.data[(lex.p)] <= 64 { - goto tr8 - } - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr8 - } - default: - goto tr8 - } - goto tr117 - tr117: -//line scanner/scanner.rl:47 - lblStart = lex.p - goto st87 + goto tr11 st87: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof87 } st_case_87: -//line scanner/scanner.go:5452 - switch lex.data[(lex.p)] { - case 39: - goto tr113 - case 96: - goto tr8 + if lex.data[(lex.p)] == 96 { + goto tr11 } switch { - case lex.data[(lex.p)] < 58: - if lex.data[(lex.p)] <= 47 { - goto tr8 + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto tr11 } - case lex.data[(lex.p)] > 64: - switch { - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr8 - } - case lex.data[(lex.p)] >= 91: - goto tr8 + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr11 } default: - goto tr8 + goto tr11 } - goto st87 - tr111: + goto tr120 + tr120: //line scanner/scanner.rl:47 lblStart = lex.p goto st88 @@ -6622,129 +6689,109 @@ func (lex *Lexer) Lex(lval Lval) int { goto _test_eof88 } st_case_88: -//line scanner/scanner.go:5486 +//line scanner/scanner.go:5553 switch lex.data[(lex.p)] { - case 10: - goto tr119 - case 13: - goto tr120 + case 39: + goto tr116 case 96: - goto tr8 + goto tr11 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr8 + goto tr11 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr8 + goto tr11 } case lex.data[(lex.p)] >= 91: - goto tr8 + goto tr11 } default: - goto tr8 + goto tr11 } goto st88 - st152: + tr114: +//line scanner/scanner.rl:47 + lblStart = lex.p + goto st89 + st89: if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof152 + goto _test_eof89 } - st_case_152: - if lex.data[(lex.p)] == 62 { - goto tr280 - } - goto tr279 - st153: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof153 - } - st_case_153: + st_case_89: +//line scanner/scanner.go:5587 switch lex.data[(lex.p)] { - case 61: - goto st154 - case 62: - goto tr282 + case 10: + goto tr122 + case 13: + goto tr123 + case 96: + goto tr11 } - goto tr232 - st154: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof154 + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr11 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr11 + } + case lex.data[(lex.p)] >= 91: + goto tr11 + } + default: + goto tr11 } - st_case_154: - if lex.data[(lex.p)] == 61 { - goto tr284 - } - goto tr283 - st155: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof155 - } - st_case_155: - switch lex.data[(lex.p)] { - case 61: - goto tr285 - case 62: - goto st156 - } - goto tr232 + goto st89 st156: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof156 } st_case_156: - if lex.data[(lex.p)] == 61 { - goto tr288 + if lex.data[(lex.p)] == 62 { + goto tr287 } - goto tr287 + goto tr286 st157: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof157 } st_case_157: switch lex.data[(lex.p)] { + case 61: + goto st158 case 62: goto tr289 - case 63: - goto st160 } - goto tr232 - tr289: -//line NONE:1 - lex.te = (lex.p) + 1 - - goto st158 + goto tr239 st158: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof158 } st_case_158: -//line scanner/scanner.go:5586 - switch lex.data[(lex.p)] { - case 10: - goto st159 - case 13: - goto st89 + if lex.data[(lex.p)] == 61 { + goto tr291 } - goto tr291 + goto tr290 st159: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof159 } st_case_159: - goto tr293 - st89: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof89 + switch lex.data[(lex.p)] { + case 61: + goto tr292 + case 62: + goto st160 } - st_case_89: - if lex.data[(lex.p)] == 10 { - goto st159 - } - goto tr122 + goto tr239 st160: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof160 @@ -6760,715 +6807,645 @@ func (lex *Lexer) Lex(lval Lval) int { } st_case_161: switch lex.data[(lex.p)] { - case 66: - goto st163 - case 78: - goto st169 - case 82: - goto st170 - case 83: - goto tr300 - case 96: + case 62: goto tr296 - case 98: - goto st163 - case 110: - goto st169 - case 114: - goto st170 - case 115: - goto tr300 + case 63: + goto st164 } - switch { - case lex.data[(lex.p)] < 58: - if lex.data[(lex.p)] <= 47 { - goto tr296 - } - case lex.data[(lex.p)] > 64: - switch { - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 - } - case lex.data[(lex.p)] >= 91: - goto tr296 - } - default: - goto tr296 - } - goto tr204 - tr204: + goto tr239 + tr296: //line NONE:1 lex.te = (lex.p) + 1 -//line scanner/scanner.rl:346 - lex.act = 133 - goto st162 - tr300: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:204 - lex.act = 14 - goto st162 - tr306: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:202 - lex.act = 12 - goto st162 - tr307: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:275 - lex.act = 85 - goto st162 - tr310: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:203 - lex.act = 13 - goto st162 - tr315: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:205 - lex.act = 15 - goto st162 - tr327: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:206 - lex.act = 16 - goto st162 - tr328: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:207 - lex.act = 17 - goto st162 - tr330: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:208 - lex.act = 18 - goto st162 - tr337: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:233 - lex.act = 43 - goto st162 - tr341: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:209 - lex.act = 19 - goto st162 - tr343: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:210 - lex.act = 20 - goto st162 - tr347: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:211 - lex.act = 21 - goto st162 - tr351: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:212 - lex.act = 22 - goto st162 - tr354: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:215 - lex.act = 25 - goto st162 - tr360: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:213 - lex.act = 23 - goto st162 - tr364: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:214 - lex.act = 24 - goto st162 - tr365: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:227 - lex.act = 37 - goto st162 - tr373: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:216 - lex.act = 26 - goto st162 - tr378: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:218 - lex.act = 28 - goto st162 - tr381: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:219 - lex.act = 29 - goto st162 - tr393: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:220 - lex.act = 30 - goto st162 - tr400: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:222 - lex.act = 32 - goto st162 - tr401: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:223 - lex.act = 33 - goto st162 - tr406: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:224 - lex.act = 34 - goto st162 - tr410: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:225 - lex.act = 35 - goto st162 - tr412: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:226 - lex.act = 36 - goto st162 - tr418: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:228 - lex.act = 38 - goto st162 - tr420: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:234 - lex.act = 44 - goto st162 - tr427: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:230 - lex.act = 40 - goto st162 - tr433: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:232 - lex.act = 42 - goto st162 - tr439: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:235 - lex.act = 45 - goto st162 - tr441: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:236 - lex.act = 46 - goto st162 - tr442: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:237 - lex.act = 47 - goto st162 - tr453: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:239 - lex.act = 49 - goto st162 - tr466: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:262 - lex.act = 72 - goto st162 - tr474: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:240 - lex.act = 50 - goto st162 - tr478: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:241 - lex.act = 51 - goto st162 - tr484: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:242 - lex.act = 52 - goto st162 - tr487: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:238 - lex.act = 48 - goto st162 - tr490: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:243 - lex.act = 53 - goto st162 - tr499: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:244 - lex.act = 54 - goto st162 - tr500: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:274 - lex.act = 84 - goto st162 - tr501: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:276 - lex.act = 86 - goto st162 - tr508: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:247 - lex.act = 57 - goto st162 - tr511: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:245 - lex.act = 55 - goto st162 - tr517: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:248 - lex.act = 58 - goto st162 - tr521: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:246 - lex.act = 56 - goto st162 - tr534: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:264 - lex.act = 74 - goto st162 - tr537: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:249 - lex.act = 59 - goto st162 - tr543: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:250 - lex.act = 60 - goto st162 - tr547: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:251 - lex.act = 61 - goto st162 - tr552: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:252 - lex.act = 62 - goto st162 - tr554: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:254 - lex.act = 64 - goto st162 - tr556: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:253 - lex.act = 63 - goto st162 - tr561: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:255 - lex.act = 65 - goto st162 - tr562: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:256 - lex.act = 66 - goto st162 - tr564: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:257 - lex.act = 67 - goto st162 - tr568: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:258 - lex.act = 68 - goto st162 - tr570: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:277 - lex.act = 87 - goto st162 - tr579: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:259 - lex.act = 69 - goto st162 - tr595: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:265 - lex.act = 75 - goto st162 - tr599: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:266 - lex.act = 76 - goto st162 - tr605: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:267 - lex.act = 77 - goto st162 - tr613: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:268 - lex.act = 78 - goto st162 - tr625: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:273 - lex.act = 83 - goto st162 - tr630: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:269 - lex.act = 79 - goto st162 - tr637: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:271 - lex.act = 81 - goto st162 - tr647: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:270 - lex.act = 80 - goto st162 - tr653: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:272 - lex.act = 82 goto st162 st162: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof162 } st_case_162: -//line scanner/scanner.go:6156 - if lex.data[(lex.p)] == 96 { - goto tr8 +//line scanner/scanner.go:5687 + switch lex.data[(lex.p)] { + case 10: + goto st163 + case 13: + goto st90 } - switch { - case lex.data[(lex.p)] < 58: - if lex.data[(lex.p)] <= 47 { - goto tr8 - } - case lex.data[(lex.p)] > 64: - switch { - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr8 - } - case lex.data[(lex.p)] >= 91: - goto tr8 - } - default: - goto tr8 - } - goto tr204 + goto tr298 st163: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof163 } st_case_163: - switch lex.data[(lex.p)] { - case 83: - goto st164 - case 96: - goto tr296 - case 115: - goto st164 + goto tr300 + st90: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof90 } - switch { - case lex.data[(lex.p)] < 58: - if lex.data[(lex.p)] <= 47 { - goto tr296 - } - case lex.data[(lex.p)] > 64: - switch { - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 - } - case lex.data[(lex.p)] >= 91: - goto tr296 - } - default: - goto tr296 + st_case_90: + if lex.data[(lex.p)] == 10 { + goto st163 } - goto tr204 + goto tr125 st164: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof164 } st_case_164: - switch lex.data[(lex.p)] { - case 84: - goto st165 - case 96: - goto tr296 - case 116: - goto st165 + if lex.data[(lex.p)] == 61 { + goto tr302 } - switch { - case lex.data[(lex.p)] < 58: - if lex.data[(lex.p)] <= 47 { - goto tr296 - } - case lex.data[(lex.p)] > 64: - switch { - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 - } - case lex.data[(lex.p)] >= 91: - goto tr296 - } - default: - goto tr296 - } - goto tr204 + goto tr301 st165: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof165 } st_case_165: switch lex.data[(lex.p)] { + case 66: + goto st167 + case 78: + goto st173 case 82: - goto st166 + goto st174 + case 83: + goto tr307 case 96: - goto tr296 + goto tr303 + case 98: + goto st167 + case 110: + goto st173 case 114: - goto st166 + goto st174 + case 115: + goto tr307 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 + tr211: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:356 + lex.act = 135 + goto st166 + tr307: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:214 + lex.act = 16 + goto st166 + tr313: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:212 + lex.act = 14 + goto st166 + tr314: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:285 + lex.act = 87 + goto st166 + tr317: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:213 + lex.act = 15 + goto st166 + tr322: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:215 + lex.act = 17 + goto st166 + tr334: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:216 + lex.act = 18 + goto st166 + tr335: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:217 + lex.act = 19 + goto st166 + tr337: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:218 + lex.act = 20 + goto st166 + tr344: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:243 + lex.act = 45 + goto st166 + tr348: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:219 + lex.act = 21 + goto st166 + tr350: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:220 + lex.act = 22 + goto st166 + tr354: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:221 + lex.act = 23 + goto st166 + tr358: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:222 + lex.act = 24 + goto st166 + tr361: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:225 + lex.act = 27 + goto st166 + tr367: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:223 + lex.act = 25 + goto st166 + tr371: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:224 + lex.act = 26 + goto st166 + tr372: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:237 + lex.act = 39 + goto st166 + tr380: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:226 + lex.act = 28 + goto st166 + tr385: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:228 + lex.act = 30 + goto st166 + tr388: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:229 + lex.act = 31 + goto st166 + tr400: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:230 + lex.act = 32 + goto st166 + tr407: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:232 + lex.act = 34 + goto st166 + tr408: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:233 + lex.act = 35 + goto st166 + tr413: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:234 + lex.act = 36 + goto st166 + tr417: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:235 + lex.act = 37 + goto st166 + tr419: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:236 + lex.act = 38 + goto st166 + tr425: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:238 + lex.act = 40 + goto st166 + tr427: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:244 + lex.act = 46 + goto st166 + tr434: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:240 + lex.act = 42 + goto st166 + tr440: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:242 + lex.act = 44 + goto st166 + tr446: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:245 + lex.act = 47 + goto st166 + tr448: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:246 + lex.act = 48 + goto st166 + tr449: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:247 + lex.act = 49 + goto st166 + tr460: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:249 + lex.act = 51 + goto st166 + tr473: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:272 + lex.act = 74 + goto st166 + tr481: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:250 + lex.act = 52 + goto st166 + tr485: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:251 + lex.act = 53 + goto st166 + tr491: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:252 + lex.act = 54 + goto st166 + tr494: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:248 + lex.act = 50 + goto st166 + tr497: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:253 + lex.act = 55 + goto st166 + tr506: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:254 + lex.act = 56 + goto st166 + tr507: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:284 + lex.act = 86 + goto st166 + tr508: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:286 + lex.act = 88 + goto st166 + tr515: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:257 + lex.act = 59 + goto st166 + tr518: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:255 + lex.act = 57 + goto st166 + tr524: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:258 + lex.act = 60 + goto st166 + tr528: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:256 + lex.act = 58 + goto st166 + tr541: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:274 + lex.act = 76 + goto st166 + tr544: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:259 + lex.act = 61 + goto st166 + tr550: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:260 + lex.act = 62 + goto st166 + tr554: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:261 + lex.act = 63 + goto st166 + tr559: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:262 + lex.act = 64 + goto st166 + tr561: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:264 + lex.act = 66 + goto st166 + tr563: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:263 + lex.act = 65 + goto st166 + tr568: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:265 + lex.act = 67 + goto st166 + tr569: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:266 + lex.act = 68 + goto st166 + tr571: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:267 + lex.act = 69 + goto st166 + tr575: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:268 + lex.act = 70 + goto st166 + tr577: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:287 + lex.act = 89 + goto st166 + tr586: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:269 + lex.act = 71 + goto st166 + tr602: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:275 + lex.act = 77 + goto st166 + tr606: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:276 + lex.act = 78 + goto st166 + tr612: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:277 + lex.act = 79 + goto st166 + tr620: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:278 + lex.act = 80 + goto st166 + tr632: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:283 + lex.act = 85 + goto st166 + tr637: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:279 + lex.act = 81 + goto st166 + tr644: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:281 + lex.act = 83 + goto st166 + tr654: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:280 + lex.act = 82 + goto st166 + tr660: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:282 + lex.act = 84 + goto st166 st166: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof166 } st_case_166: - switch lex.data[(lex.p)] { - case 65: - goto st167 - case 96: - goto tr296 - case 97: - goto st167 +//line scanner/scanner.go:6257 + if lex.data[(lex.p)] == 96 { + goto tr11 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr11 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr11 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr11 } default: - goto tr296 + goto tr11 } - goto tr204 + goto tr211 st167: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof167 } st_case_167: switch lex.data[(lex.p)] { - case 67: + case 83: goto st168 case 96: - goto tr296 - case 99: + goto tr303 + case 115: goto st168 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st168: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof168 @@ -7476,246 +7453,216 @@ func (lex *Lexer) Lex(lval Lval) int { st_case_168: switch lex.data[(lex.p)] { case 84: - goto tr306 + goto st169 case 96: - goto tr296 + goto tr303 case 116: - goto tr306 + goto st169 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st169: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof169 } st_case_169: switch lex.data[(lex.p)] { - case 68: - goto tr307 + case 82: + goto st170 case 96: - goto tr296 - case 100: - goto tr307 + goto tr303 + case 114: + goto st170 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st170: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof170 } st_case_170: switch lex.data[(lex.p)] { - case 82: + case 65: goto st171 case 96: - goto tr296 - case 114: + goto tr303 + case 97: goto st171 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st171: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof171 } st_case_171: switch lex.data[(lex.p)] { - case 65: + case 67: goto st172 case 96: - goto tr296 - case 97: + goto tr303 + case 99: goto st172 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st172: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof172 } st_case_172: switch lex.data[(lex.p)] { - case 89: - goto tr310 + case 84: + goto tr313 case 96: - goto tr296 - case 121: - goto tr310 + goto tr303 + case 116: + goto tr313 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 - tr198: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:346 - lex.act = 133 - goto st173 + goto tr211 st173: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof173 } st_case_173: -//line scanner/scanner.go:6500 switch lex.data[(lex.p)] { - case 34: - goto st6 - case 60: - goto st90 - case 82: - goto st174 + case 68: + goto tr314 case 96: - goto tr296 - case 114: - goto st174 + goto tr303 + case 100: + goto tr314 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 - st90: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof90 - } - st_case_90: - if lex.data[(lex.p)] == 60 { - goto st91 - } - goto tr124 - st91: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof91 - } - st_case_91: - if lex.data[(lex.p)] == 60 { - goto st81 - } - goto tr124 + goto tr211 st174: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof174 } st_case_174: switch lex.data[(lex.p)] { - case 69: + case 82: goto st175 case 96: - goto tr296 - case 101: + goto tr303 + case 114: goto st175 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st175: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof175 @@ -7725,234 +7672,256 @@ func (lex *Lexer) Lex(lval Lval) int { case 65: goto st176 case 96: - goto tr296 + goto tr303 case 97: goto st176 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st176: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof176 } st_case_176: switch lex.data[(lex.p)] { - case 75: - goto tr315 + case 89: + goto tr317 case 96: - goto tr296 - case 107: - goto tr315 + goto tr303 + case 121: + goto tr317 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 + tr205: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:356 + lex.act = 135 + goto st177 st177: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof177 } st_case_177: +//line scanner/scanner.go:6601 switch lex.data[(lex.p)] { - case 65: + case 34: + goto st7 + case 60: + goto st91 + case 82: goto st178 - case 70: - goto st187 - case 76: - goto st194 - case 79: - goto st199 case 96: - goto tr296 - case 97: + goto tr303 + case 114: goto st178 - case 102: - goto st187 - case 108: - goto st194 - case 111: - goto st199 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 + st91: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof91 + } + st_case_91: + if lex.data[(lex.p)] == 60 { + goto st92 + } + goto tr127 + st92: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof92 + } + st_case_92: + if lex.data[(lex.p)] == 60 { + goto st82 + } + goto tr127 st178: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof178 } st_case_178: switch lex.data[(lex.p)] { - case 76: + case 69: goto st179 - case 83: - goto st184 - case 84: - goto st185 case 96: - goto tr296 - case 108: + goto tr303 + case 101: goto st179 - case 115: - goto st184 - case 116: - goto st185 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st179: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof179 } st_case_179: switch lex.data[(lex.p)] { - case 76: + case 65: goto st180 case 96: - goto tr296 - case 108: + goto tr303 + case 97: goto st180 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st180: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof180 } st_case_180: switch lex.data[(lex.p)] { - case 65: - goto st181 + case 75: + goto tr322 case 96: - goto tr296 - case 97: - goto st181 + goto tr303 + case 107: + goto tr322 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st181: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof181 } st_case_181: switch lex.data[(lex.p)] { - case 66: + case 65: goto st182 + case 70: + goto st191 + case 76: + goto st198 + case 79: + goto st203 case 96: - goto tr296 - case 98: + goto tr303 + case 97: goto st182 + case 102: + goto st191 + case 108: + goto st198 + case 111: + goto st203 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st182: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof182 @@ -7961,215 +7930,223 @@ func (lex *Lexer) Lex(lval Lval) int { switch lex.data[(lex.p)] { case 76: goto st183 + case 83: + goto st188 + case 84: + goto st189 case 96: - goto tr296 + goto tr303 case 108: goto st183 + case 115: + goto st188 + case 116: + goto st189 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st183: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof183 } st_case_183: switch lex.data[(lex.p)] { - case 69: - goto tr327 + case 76: + goto st184 case 96: - goto tr296 - case 101: - goto tr327 + goto tr303 + case 108: + goto st184 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st184: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof184 } st_case_184: switch lex.data[(lex.p)] { - case 69: - goto tr328 + case 65: + goto st185 case 96: - goto tr296 - case 101: - goto tr328 + goto tr303 + case 97: + goto st185 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st185: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof185 } st_case_185: switch lex.data[(lex.p)] { - case 67: + case 66: goto st186 case 96: - goto tr296 - case 99: + goto tr303 + case 98: goto st186 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st186: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof186 } st_case_186: switch lex.data[(lex.p)] { - case 72: - goto tr330 + case 76: + goto st187 case 96: - goto tr296 - case 104: - goto tr330 + goto tr303 + case 108: + goto st187 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st187: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof187 } st_case_187: switch lex.data[(lex.p)] { - case 85: - goto st188 + case 69: + goto tr334 case 96: - goto tr296 - case 117: - goto st188 + goto tr303 + case 101: + goto tr334 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st188: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof188 } st_case_188: switch lex.data[(lex.p)] { - case 78: - goto st189 + case 69: + goto tr335 case 96: - goto tr296 - case 110: - goto st189 + goto tr303 + case 101: + goto tr335 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st189: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof189 @@ -8179,249 +8156,245 @@ func (lex *Lexer) Lex(lval Lval) int { case 67: goto st190 case 96: - goto tr296 + goto tr303 case 99: goto st190 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st190: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof190 } st_case_190: switch lex.data[(lex.p)] { - case 84: - goto st191 + case 72: + goto tr337 case 96: - goto tr296 - case 116: - goto st191 + goto tr303 + case 104: + goto tr337 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st191: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof191 } st_case_191: switch lex.data[(lex.p)] { - case 73: + case 85: goto st192 case 96: - goto tr296 - case 105: + goto tr303 + case 117: goto st192 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st192: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof192 } st_case_192: switch lex.data[(lex.p)] { - case 79: + case 78: goto st193 case 96: - goto tr296 - case 111: + goto tr303 + case 110: goto st193 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st193: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof193 } st_case_193: switch lex.data[(lex.p)] { - case 78: - goto tr337 + case 67: + goto st194 case 96: - goto tr296 - case 110: - goto tr337 + goto tr303 + case 99: + goto st194 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st194: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof194 } st_case_194: switch lex.data[(lex.p)] { - case 65: + case 84: goto st195 - case 79: - goto st197 case 96: - goto tr296 - case 97: + goto tr303 + case 116: goto st195 - case 111: - goto st197 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st195: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof195 } st_case_195: switch lex.data[(lex.p)] { - case 83: + case 73: goto st196 case 96: - goto tr296 - case 115: + goto tr303 + case 105: goto st196 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st196: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof196 } st_case_196: switch lex.data[(lex.p)] { - case 83: - goto tr341 + case 79: + goto st197 case 96: - goto tr296 - case 115: - goto tr341 + goto tr303 + case 111: + goto st197 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st197: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof197 @@ -8429,92 +8402,96 @@ func (lex *Lexer) Lex(lval Lval) int { st_case_197: switch lex.data[(lex.p)] { case 78: - goto st198 + goto tr344 case 96: - goto tr296 + goto tr303 case 110: - goto st198 + goto tr344 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st198: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof198 } st_case_198: switch lex.data[(lex.p)] { - case 69: - goto tr343 + case 65: + goto st199 + case 79: + goto st201 case 96: - goto tr296 - case 101: - goto tr343 + goto tr303 + case 97: + goto st199 + case 111: + goto st201 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st199: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof199 } st_case_199: switch lex.data[(lex.p)] { - case 78: + case 83: goto st200 case 96: - goto tr296 - case 110: + goto tr303 + case 115: goto st200 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st200: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof200 @@ -8522,96 +8499,92 @@ func (lex *Lexer) Lex(lval Lval) int { st_case_200: switch lex.data[(lex.p)] { case 83: - goto st201 - case 84: - goto st202 + goto tr348 case 96: - goto tr296 + goto tr303 case 115: - goto st201 - case 116: - goto st202 + goto tr348 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st201: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof201 } st_case_201: switch lex.data[(lex.p)] { - case 84: - goto tr347 + case 78: + goto st202 case 96: - goto tr296 - case 116: - goto tr347 + goto tr303 + case 110: + goto st202 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st202: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof202 } st_case_202: switch lex.data[(lex.p)] { - case 73: - goto st203 + case 69: + goto tr350 case 96: - goto tr296 - case 105: - goto st203 + goto tr303 + case 101: + goto tr350 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st203: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof203 @@ -8621,1828 +8594,1820 @@ func (lex *Lexer) Lex(lval Lval) int { case 78: goto st204 case 96: - goto tr296 + goto tr303 case 110: goto st204 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st204: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof204 } st_case_204: switch lex.data[(lex.p)] { - case 85: + case 83: goto st205 + case 84: + goto st206 case 96: - goto tr296 - case 117: + goto tr303 + case 115: goto st205 + case 116: + goto st206 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st205: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof205 } st_case_205: switch lex.data[(lex.p)] { - case 69: - goto tr351 + case 84: + goto tr354 case 96: - goto tr296 - case 101: - goto tr351 + goto tr303 + case 116: + goto tr354 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st206: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof206 } st_case_206: switch lex.data[(lex.p)] { - case 69: - goto st207 case 73: - goto st216 - case 79: - goto tr354 - case 96: - goto tr296 - case 101: goto st207 + case 96: + goto tr303 case 105: - goto st216 - case 111: - goto tr354 + goto st207 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st207: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof207 } st_case_207: switch lex.data[(lex.p)] { - case 67: + case 78: goto st208 - case 70: - goto st212 case 96: - goto tr296 - case 99: + goto tr303 + case 110: goto st208 - case 102: - goto st212 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st208: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof208 } st_case_208: switch lex.data[(lex.p)] { - case 76: + case 85: goto st209 case 96: - goto tr296 - case 108: + goto tr303 + case 117: goto st209 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st209: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof209 } st_case_209: switch lex.data[(lex.p)] { - case 65: - goto st210 + case 69: + goto tr358 case 96: - goto tr296 - case 97: - goto st210 + goto tr303 + case 101: + goto tr358 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st210: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof210 } st_case_210: switch lex.data[(lex.p)] { - case 82: + case 69: goto st211 + case 73: + goto st220 + case 79: + goto tr361 case 96: - goto tr296 - case 114: + goto tr303 + case 101: goto st211 + case 105: + goto st220 + case 111: + goto tr361 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st211: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof211 } st_case_211: switch lex.data[(lex.p)] { - case 69: - goto tr360 + case 67: + goto st212 + case 70: + goto st216 case 96: - goto tr296 - case 101: - goto tr360 + goto tr303 + case 99: + goto st212 + case 102: + goto st216 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st212: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof212 } st_case_212: switch lex.data[(lex.p)] { - case 65: + case 76: goto st213 case 96: - goto tr296 - case 97: + goto tr303 + case 108: goto st213 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st213: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof213 } st_case_213: switch lex.data[(lex.p)] { - case 85: + case 65: goto st214 case 96: - goto tr296 - case 117: + goto tr303 + case 97: goto st214 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st214: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof214 } st_case_214: switch lex.data[(lex.p)] { - case 76: + case 82: goto st215 case 96: - goto tr296 - case 108: + goto tr303 + case 114: goto st215 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st215: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof215 } st_case_215: switch lex.data[(lex.p)] { - case 84: - goto tr364 + case 69: + goto tr367 case 96: - goto tr296 - case 116: - goto tr364 + goto tr303 + case 101: + goto tr367 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st216: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof216 } st_case_216: switch lex.data[(lex.p)] { - case 69: - goto tr365 + case 65: + goto st217 case 96: - goto tr296 - case 101: - goto tr365 + goto tr303 + case 97: + goto st217 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st217: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof217 } st_case_217: switch lex.data[(lex.p)] { - case 67: + case 85: goto st218 - case 76: - goto st220 - case 77: - goto st224 - case 78: - goto st227 - case 86: - goto st251 - case 88: - goto st253 case 96: - goto tr296 - case 99: + goto tr303 + case 117: goto st218 - case 108: - goto st220 - case 109: - goto st224 - case 110: - goto st227 - case 118: - goto st251 - case 120: - goto st253 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st218: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof218 } st_case_218: switch lex.data[(lex.p)] { - case 72: + case 76: goto st219 case 96: - goto tr296 - case 104: + goto tr303 + case 108: goto st219 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st219: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof219 } st_case_219: switch lex.data[(lex.p)] { - case 79: - goto tr373 + case 84: + goto tr371 case 96: - goto tr296 - case 111: - goto tr373 + goto tr303 + case 116: + goto tr371 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st220: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof220 } st_case_220: switch lex.data[(lex.p)] { - case 83: - goto st221 + case 69: + goto tr372 case 96: - goto tr296 - case 115: - goto st221 + goto tr303 + case 101: + goto tr372 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st221: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof221 } st_case_221: switch lex.data[(lex.p)] { - case 69: + case 67: goto st222 + case 76: + goto st224 + case 77: + goto st228 + case 78: + goto st231 + case 86: + goto st255 + case 88: + goto st257 case 96: - goto tr296 - case 101: + goto tr303 + case 99: goto st222 + case 108: + goto st224 + case 109: + goto st228 + case 110: + goto st231 + case 118: + goto st255 + case 120: + goto st257 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st222: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof222 } st_case_222: switch lex.data[(lex.p)] { - case 73: + case 72: goto st223 case 96: - goto tr376 - case 105: + goto tr303 + case 104: goto st223 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr376 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr376 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr376 + goto tr303 } default: - goto tr376 + goto tr303 } - goto tr204 + goto tr211 st223: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof223 } st_case_223: switch lex.data[(lex.p)] { - case 70: - goto tr378 + case 79: + goto tr380 case 96: - goto tr296 - case 102: - goto tr378 + goto tr303 + case 111: + goto tr380 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st224: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof224 } st_case_224: switch lex.data[(lex.p)] { - case 80: + case 83: goto st225 case 96: - goto tr296 - case 112: + goto tr303 + case 115: goto st225 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st225: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof225 } st_case_225: switch lex.data[(lex.p)] { - case 84: + case 69: goto st226 case 96: - goto tr296 - case 116: + goto tr303 + case 101: goto st226 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st226: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof226 } st_case_226: switch lex.data[(lex.p)] { - case 89: - goto tr381 + case 73: + goto st227 case 96: - goto tr296 - case 121: - goto tr381 + goto tr383 + case 105: + goto st227 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr383 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr383 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr383 } default: - goto tr296 + goto tr383 } - goto tr204 + goto tr211 st227: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof227 } st_case_227: switch lex.data[(lex.p)] { - case 68: - goto st228 + case 70: + goto tr385 case 96: - goto tr296 - case 100: - goto st228 + goto tr303 + case 102: + goto tr385 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st228: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof228 } st_case_228: switch lex.data[(lex.p)] { - case 68: + case 80: goto st229 - case 70: - goto st235 - case 73: - goto st241 - case 83: - goto st242 - case 87: - goto st247 case 96: - goto tr296 - case 100: + goto tr303 + case 112: goto st229 - case 102: - goto st235 - case 105: - goto st241 - case 115: - goto st242 - case 119: - goto st247 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st229: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof229 } st_case_229: switch lex.data[(lex.p)] { - case 69: + case 84: goto st230 case 96: - goto tr296 - case 101: + goto tr303 + case 116: goto st230 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st230: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof230 } st_case_230: switch lex.data[(lex.p)] { - case 67: - goto st231 + case 89: + goto tr388 case 96: - goto tr296 - case 99: - goto st231 + goto tr303 + case 121: + goto tr388 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st231: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof231 } st_case_231: switch lex.data[(lex.p)] { - case 76: + case 68: goto st232 case 96: - goto tr296 - case 108: + goto tr303 + case 100: goto st232 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st232: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof232 } st_case_232: switch lex.data[(lex.p)] { - case 65: + case 68: goto st233 + case 70: + goto st239 + case 73: + goto st245 + case 83: + goto st246 + case 87: + goto st251 case 96: - goto tr296 - case 97: + goto tr303 + case 100: goto st233 + case 102: + goto st239 + case 105: + goto st245 + case 115: + goto st246 + case 119: + goto st251 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st233: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof233 } st_case_233: switch lex.data[(lex.p)] { - case 82: + case 69: goto st234 case 96: - goto tr296 - case 114: + goto tr303 + case 101: goto st234 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st234: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof234 } st_case_234: switch lex.data[(lex.p)] { - case 69: - goto tr393 + case 67: + goto st235 case 96: - goto tr296 - case 101: - goto tr393 + goto tr303 + case 99: + goto st235 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st235: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof235 } st_case_235: switch lex.data[(lex.p)] { - case 79: + case 76: goto st236 case 96: - goto tr296 - case 111: + goto tr303 + case 108: goto st236 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st236: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof236 } st_case_236: switch lex.data[(lex.p)] { - case 82: + case 65: goto st237 case 96: - goto tr296 - case 114: + goto tr303 + case 97: goto st237 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st237: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof237 } st_case_237: switch lex.data[(lex.p)] { - case 69: + case 82: goto st238 case 96: - goto tr396 - case 101: + goto tr303 + case 114: goto st238 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr396 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr396 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr396 + goto tr303 } default: - goto tr396 + goto tr303 } - goto tr204 + goto tr211 st238: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof238 } st_case_238: switch lex.data[(lex.p)] { - case 65: - goto st239 + case 69: + goto tr400 case 96: - goto tr296 - case 97: - goto st239 + goto tr303 + case 101: + goto tr400 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st239: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof239 } st_case_239: switch lex.data[(lex.p)] { - case 67: + case 79: goto st240 case 96: - goto tr296 - case 99: + goto tr303 + case 111: goto st240 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st240: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof240 } st_case_240: switch lex.data[(lex.p)] { - case 72: - goto tr400 + case 82: + goto st241 case 96: - goto tr296 - case 104: - goto tr400 + goto tr303 + case 114: + goto st241 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st241: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof241 } st_case_241: switch lex.data[(lex.p)] { - case 70: - goto tr401 + case 69: + goto st242 case 96: - goto tr296 - case 102: - goto tr401 + goto tr403 + case 101: + goto st242 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr403 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr403 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr403 } default: - goto tr296 + goto tr403 } - goto tr204 + goto tr211 st242: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof242 } st_case_242: switch lex.data[(lex.p)] { - case 87: + case 65: goto st243 case 96: - goto tr296 - case 119: + goto tr303 + case 97: goto st243 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st243: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof243 } st_case_243: switch lex.data[(lex.p)] { - case 73: + case 67: goto st244 case 96: - goto tr296 - case 105: + goto tr303 + case 99: goto st244 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st244: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof244 } st_case_244: switch lex.data[(lex.p)] { - case 84: - goto st245 + case 72: + goto tr407 case 96: - goto tr296 - case 116: - goto st245 + goto tr303 + case 104: + goto tr407 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st245: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof245 } st_case_245: switch lex.data[(lex.p)] { - case 67: - goto st246 + case 70: + goto tr408 case 96: - goto tr296 - case 99: - goto st246 + goto tr303 + case 102: + goto tr408 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st246: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof246 } st_case_246: switch lex.data[(lex.p)] { - case 72: - goto tr406 + case 87: + goto st247 case 96: - goto tr296 - case 104: - goto tr406 + goto tr303 + case 119: + goto st247 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st247: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof247 } st_case_247: switch lex.data[(lex.p)] { - case 72: + case 73: goto st248 case 96: - goto tr296 - case 104: + goto tr303 + case 105: goto st248 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st248: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof248 } st_case_248: switch lex.data[(lex.p)] { - case 73: + case 84: goto st249 case 96: - goto tr296 - case 105: + goto tr303 + case 116: goto st249 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st249: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof249 } st_case_249: switch lex.data[(lex.p)] { - case 76: + case 67: goto st250 case 96: - goto tr296 - case 108: + goto tr303 + case 99: goto st250 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st250: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof250 } st_case_250: switch lex.data[(lex.p)] { - case 69: - goto tr410 + case 72: + goto tr413 case 96: - goto tr296 - case 101: - goto tr410 + goto tr303 + case 104: + goto tr413 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st251: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof251 } st_case_251: switch lex.data[(lex.p)] { - case 65: + case 72: goto st252 case 96: - goto tr296 - case 97: + goto tr303 + case 104: goto st252 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st252: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof252 } st_case_252: switch lex.data[(lex.p)] { - case 76: - goto tr412 + case 73: + goto st253 case 96: - goto tr296 - case 108: - goto tr412 + goto tr303 + case 105: + goto st253 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st253: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof253 } st_case_253: switch lex.data[(lex.p)] { - case 73: + case 76: goto st254 - case 84: - goto st255 case 96: - goto tr296 - case 105: + goto tr303 + case 108: goto st254 - case 116: - goto st255 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st254: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof254 } st_case_254: switch lex.data[(lex.p)] { - case 84: - goto tr365 + case 69: + goto tr417 case 96: - goto tr296 - case 116: - goto tr365 + goto tr303 + case 101: + goto tr417 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st255: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof255 } st_case_255: switch lex.data[(lex.p)] { - case 69: + case 65: goto st256 case 96: - goto tr296 - case 101: + goto tr303 + case 97: goto st256 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st256: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof256 } st_case_256: switch lex.data[(lex.p)] { - case 78: - goto st257 + case 76: + goto tr419 case 96: - goto tr296 - case 110: - goto st257 + goto tr303 + case 108: + goto tr419 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st257: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof257 } st_case_257: switch lex.data[(lex.p)] { - case 68: + case 73: goto st258 + case 84: + goto st259 case 96: - goto tr296 - case 100: + goto tr303 + case 105: goto st258 + case 116: + goto st259 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st258: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof258 } st_case_258: switch lex.data[(lex.p)] { - case 83: - goto tr418 + case 84: + goto tr372 case 96: - goto tr296 - case 115: - goto tr418 + goto tr303 + case 116: + goto tr372 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st259: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof259 } st_case_259: switch lex.data[(lex.p)] { - case 73: + case 69: goto st260 - case 78: - goto tr420 - case 79: - goto st265 - case 85: - goto st188 case 96: - goto tr296 - case 105: + goto tr303 + case 101: goto st260 - case 110: - goto tr420 - case 111: - goto st265 - case 117: - goto st188 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st260: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof260 @@ -10452,435 +10417,443 @@ func (lex *Lexer) Lex(lval Lval) int { case 78: goto st261 case 96: - goto tr296 + goto tr303 case 110: goto st261 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st261: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof261 } st_case_261: switch lex.data[(lex.p)] { - case 65: + case 68: goto st262 case 96: - goto tr296 - case 97: + goto tr303 + case 100: goto st262 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st262: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof262 } st_case_262: switch lex.data[(lex.p)] { - case 76: - goto st263 + case 83: + goto tr425 case 96: - goto tr296 - case 108: - goto st263 + goto tr303 + case 115: + goto tr425 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st263: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof263 } st_case_263: switch lex.data[(lex.p)] { - case 76: + case 73: goto st264 + case 78: + goto tr427 + case 79: + goto st269 + case 85: + goto st192 case 96: - goto tr425 - case 108: + goto tr303 + case 105: goto st264 + case 110: + goto tr427 + case 111: + goto st269 + case 117: + goto st192 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr425 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr425 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr425 + goto tr303 } default: - goto tr425 + goto tr303 } - goto tr204 + goto tr211 st264: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof264 } st_case_264: switch lex.data[(lex.p)] { - case 89: - goto tr427 + case 78: + goto st265 case 96: - goto tr296 - case 121: - goto tr427 + goto tr303 + case 110: + goto st265 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st265: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof265 } st_case_265: switch lex.data[(lex.p)] { - case 82: + case 65: goto st266 case 96: - goto tr296 - case 114: + goto tr303 + case 97: goto st266 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st266: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof266 } st_case_266: switch lex.data[(lex.p)] { - case 69: + case 76: goto st267 case 96: - goto tr429 - case 101: + goto tr303 + case 108: goto st267 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr429 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr429 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr429 + goto tr303 } default: - goto tr429 + goto tr303 } - goto tr204 + goto tr211 st267: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof267 } st_case_267: switch lex.data[(lex.p)] { - case 65: + case 76: goto st268 case 96: - goto tr296 - case 97: + goto tr432 + case 108: goto st268 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr432 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr432 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr432 } default: - goto tr296 + goto tr432 } - goto tr204 + goto tr211 st268: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof268 } st_case_268: switch lex.data[(lex.p)] { - case 67: - goto st269 + case 89: + goto tr434 case 96: - goto tr296 - case 99: - goto st269 + goto tr303 + case 121: + goto tr434 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st269: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof269 } st_case_269: switch lex.data[(lex.p)] { - case 72: - goto tr433 + case 82: + goto st270 case 96: - goto tr296 - case 104: - goto tr433 + goto tr303 + case 114: + goto st270 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st270: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof270 } st_case_270: switch lex.data[(lex.p)] { - case 76: + case 69: goto st271 - case 79: - goto st275 case 96: - goto tr296 - case 108: + goto tr436 + case 101: goto st271 - case 111: - goto st275 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr436 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr436 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr436 } default: - goto tr296 + goto tr436 } - goto tr204 + goto tr211 st271: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof271 } st_case_271: switch lex.data[(lex.p)] { - case 79: + case 65: goto st272 case 96: - goto tr296 - case 111: + goto tr303 + case 97: goto st272 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st272: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof272 } st_case_272: switch lex.data[(lex.p)] { - case 66: + case 67: goto st273 case 96: - goto tr296 - case 98: + goto tr303 + case 99: goto st273 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st273: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof273 } st_case_273: switch lex.data[(lex.p)] { - case 65: - goto st274 + case 72: + goto tr440 case 96: - goto tr296 - case 97: - goto st274 + goto tr303 + case 104: + goto tr440 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st274: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof274 @@ -10888,979 +10861,983 @@ func (lex *Lexer) Lex(lval Lval) int { st_case_274: switch lex.data[(lex.p)] { case 76: - goto tr439 + goto st275 + case 79: + goto st279 case 96: - goto tr296 + goto tr303 case 108: - goto tr439 + goto st275 + case 111: + goto st279 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st275: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof275 } st_case_275: switch lex.data[(lex.p)] { - case 84: + case 79: goto st276 case 96: - goto tr296 - case 116: + goto tr303 + case 111: goto st276 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st276: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof276 } st_case_276: switch lex.data[(lex.p)] { - case 79: - goto tr441 + case 66: + goto st277 case 96: - goto tr296 - case 111: - goto tr441 + goto tr303 + case 98: + goto st277 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st277: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof277 } st_case_277: switch lex.data[(lex.p)] { - case 70: - goto tr442 - case 77: + case 65: goto st278 - case 78: - goto st286 - case 83: - goto st313 case 96: - goto tr296 - case 102: - goto tr442 - case 109: + goto tr303 + case 97: goto st278 - case 110: - goto st286 - case 115: - goto st313 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st278: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof278 } st_case_278: switch lex.data[(lex.p)] { - case 80: - goto st279 + case 76: + goto tr446 case 96: - goto tr296 - case 112: - goto st279 + goto tr303 + case 108: + goto tr446 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st279: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof279 } st_case_279: switch lex.data[(lex.p)] { - case 76: + case 84: goto st280 case 96: - goto tr296 - case 108: + goto tr303 + case 116: goto st280 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st280: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof280 } st_case_280: switch lex.data[(lex.p)] { - case 69: - goto st281 + case 79: + goto tr448 case 96: - goto tr296 - case 101: - goto st281 + goto tr303 + case 111: + goto tr448 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st281: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof281 } st_case_281: switch lex.data[(lex.p)] { + case 70: + goto tr449 case 77: goto st282 + case 78: + goto st290 + case 83: + goto st317 case 96: - goto tr296 + goto tr303 + case 102: + goto tr449 case 109: goto st282 + case 110: + goto st290 + case 115: + goto st317 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st282: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof282 } st_case_282: switch lex.data[(lex.p)] { - case 69: + case 80: goto st283 case 96: - goto tr296 - case 101: + goto tr303 + case 112: goto st283 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st283: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof283 } st_case_283: switch lex.data[(lex.p)] { - case 78: + case 76: goto st284 case 96: - goto tr296 - case 110: + goto tr303 + case 108: goto st284 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st284: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof284 } st_case_284: switch lex.data[(lex.p)] { - case 84: + case 69: goto st285 case 96: - goto tr296 - case 116: + goto tr303 + case 101: goto st285 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st285: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof285 } st_case_285: switch lex.data[(lex.p)] { - case 83: - goto tr453 + case 77: + goto st286 case 96: - goto tr296 - case 115: - goto tr453 + goto tr303 + case 109: + goto st286 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st286: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof286 } st_case_286: switch lex.data[(lex.p)] { - case 67: + case 69: goto st287 - case 83: - goto st296 - case 84: - goto st307 case 96: - goto tr296 - case 99: + goto tr303 + case 101: goto st287 - case 115: - goto st296 - case 116: - goto st307 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st287: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof287 } st_case_287: switch lex.data[(lex.p)] { - case 76: + case 78: goto st288 case 96: - goto tr296 - case 108: + goto tr303 + case 110: goto st288 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st288: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof288 } st_case_288: switch lex.data[(lex.p)] { - case 85: + case 84: goto st289 case 96: - goto tr296 - case 117: + goto tr303 + case 116: goto st289 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st289: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof289 } st_case_289: switch lex.data[(lex.p)] { - case 68: - goto st290 + case 83: + goto tr460 case 96: - goto tr296 - case 100: - goto st290 + goto tr303 + case 115: + goto tr460 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st290: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof290 } st_case_290: switch lex.data[(lex.p)] { - case 69: + case 67: goto st291 + case 83: + goto st300 + case 84: + goto st311 case 96: - goto tr296 - case 101: + goto tr303 + case 99: goto st291 + case 115: + goto st300 + case 116: + goto st311 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st291: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof291 } st_case_291: - if lex.data[(lex.p)] == 95 { + switch lex.data[(lex.p)] { + case 76: + goto st292 + case 96: + goto tr303 + case 108: goto st292 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr461 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 96: + case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr461 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr461 + goto tr303 } default: - goto tr461 + goto tr303 } - goto tr204 + goto tr211 st292: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof292 } st_case_292: switch lex.data[(lex.p)] { - case 79: + case 85: goto st293 case 96: - goto tr296 - case 111: + goto tr303 + case 117: goto st293 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st293: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof293 } st_case_293: switch lex.data[(lex.p)] { - case 78: + case 68: goto st294 case 96: - goto tr296 - case 110: + goto tr303 + case 100: goto st294 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st294: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof294 } st_case_294: switch lex.data[(lex.p)] { - case 67: + case 69: goto st295 case 96: - goto tr296 - case 99: + goto tr303 + case 101: goto st295 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st295: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof295 } st_case_295: - switch lex.data[(lex.p)] { - case 69: - goto tr466 - case 96: - goto tr296 - case 101: - goto tr466 + if lex.data[(lex.p)] == 95 { + goto st296 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr468 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 94: + case lex.data[(lex.p)] > 96: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr468 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr468 } default: - goto tr296 + goto tr468 } - goto tr204 + goto tr211 st296: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof296 } st_case_296: switch lex.data[(lex.p)] { - case 84: + case 79: goto st297 case 96: - goto tr296 - case 116: + goto tr303 + case 111: goto st297 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st297: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof297 } st_case_297: switch lex.data[(lex.p)] { - case 65: + case 78: goto st298 - case 69: - goto st303 case 96: - goto tr296 - case 97: + goto tr303 + case 110: goto st298 - case 101: - goto st303 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st298: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof298 } st_case_298: switch lex.data[(lex.p)] { - case 78: + case 67: goto st299 case 96: - goto tr296 - case 110: + goto tr303 + case 99: goto st299 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st299: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof299 } st_case_299: switch lex.data[(lex.p)] { - case 67: - goto st300 + case 69: + goto tr473 case 96: - goto tr296 - case 99: - goto st300 + goto tr303 + case 101: + goto tr473 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st300: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof300 } st_case_300: switch lex.data[(lex.p)] { - case 69: + case 84: goto st301 case 96: - goto tr296 - case 101: + goto tr303 + case 116: goto st301 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st301: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof301 } st_case_301: switch lex.data[(lex.p)] { - case 79: + case 65: goto st302 + case 69: + goto st307 case 96: - goto tr296 - case 111: + goto tr303 + case 97: goto st302 + case 101: + goto st307 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st302: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof302 } st_case_302: switch lex.data[(lex.p)] { - case 70: - goto tr474 + case 78: + goto st303 case 96: - goto tr296 - case 102: - goto tr474 + goto tr303 + case 110: + goto st303 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st303: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof303 } st_case_303: switch lex.data[(lex.p)] { - case 65: + case 67: goto st304 case 96: - goto tr296 - case 97: + goto tr303 + case 99: goto st304 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st304: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof304 } st_case_304: switch lex.data[(lex.p)] { - case 68: + case 69: goto st305 case 96: - goto tr296 - case 100: + goto tr303 + case 101: goto st305 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st305: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof305 @@ -11870,28 +11847,28 @@ func (lex *Lexer) Lex(lval Lval) int { case 79: goto st306 case 96: - goto tr296 + goto tr303 case 111: goto st306 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st306: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof306 @@ -11899,340 +11876,340 @@ func (lex *Lexer) Lex(lval Lval) int { st_case_306: switch lex.data[(lex.p)] { case 70: - goto tr478 + goto tr481 case 96: - goto tr296 + goto tr303 case 102: - goto tr478 + goto tr481 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st307: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof307 } st_case_307: switch lex.data[(lex.p)] { - case 69: + case 65: goto st308 case 96: - goto tr296 - case 101: + goto tr303 + case 97: goto st308 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st308: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof308 } st_case_308: switch lex.data[(lex.p)] { - case 82: + case 68: goto st309 case 96: - goto tr296 - case 114: + goto tr303 + case 100: goto st309 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st309: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof309 } st_case_309: switch lex.data[(lex.p)] { - case 70: + case 79: goto st310 case 96: - goto tr296 - case 102: + goto tr303 + case 111: goto st310 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st310: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof310 } st_case_310: switch lex.data[(lex.p)] { - case 65: - goto st311 + case 70: + goto tr485 case 96: - goto tr296 - case 97: - goto st311 + goto tr303 + case 102: + goto tr485 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st311: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof311 } st_case_311: switch lex.data[(lex.p)] { - case 67: + case 69: goto st312 case 96: - goto tr296 - case 99: + goto tr303 + case 101: goto st312 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st312: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof312 } st_case_312: switch lex.data[(lex.p)] { - case 69: - goto tr484 + case 82: + goto st313 case 96: - goto tr296 - case 101: - goto tr484 + goto tr303 + case 114: + goto st313 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st313: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof313 } st_case_313: switch lex.data[(lex.p)] { - case 83: + case 70: goto st314 case 96: - goto tr296 - case 115: + goto tr303 + case 102: goto st314 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st314: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof314 } st_case_314: switch lex.data[(lex.p)] { - case 69: + case 65: goto st315 case 96: - goto tr296 - case 101: + goto tr303 + case 97: goto st315 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st315: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof315 } st_case_315: switch lex.data[(lex.p)] { - case 84: - goto tr487 + case 67: + goto st316 case 96: - goto tr296 - case 116: - goto tr487 + goto tr303 + case 99: + goto st316 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st316: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof316 } st_case_316: switch lex.data[(lex.p)] { - case 73: - goto st317 + case 69: + goto tr491 case 96: - goto tr296 - case 105: - goto st317 + goto tr303 + case 101: + goto tr491 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st317: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof317 @@ -12242,602 +12219,602 @@ func (lex *Lexer) Lex(lval Lval) int { case 83: goto st318 case 96: - goto tr296 + goto tr303 case 115: goto st318 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st318: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof318 } st_case_318: switch lex.data[(lex.p)] { - case 84: - goto tr490 + case 69: + goto st319 case 96: - goto tr296 - case 116: - goto tr490 + goto tr303 + case 101: + goto st319 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st319: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof319 } st_case_319: switch lex.data[(lex.p)] { - case 65: - goto st320 - case 69: - goto st327 + case 84: + goto tr494 case 96: - goto tr296 - case 97: - goto st320 - case 101: - goto st327 + goto tr303 + case 116: + goto tr494 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st320: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof320 } st_case_320: switch lex.data[(lex.p)] { - case 77: + case 73: goto st321 case 96: - goto tr296 - case 109: + goto tr303 + case 105: goto st321 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st321: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof321 } st_case_321: switch lex.data[(lex.p)] { - case 69: + case 83: goto st322 case 96: - goto tr296 - case 101: + goto tr303 + case 115: goto st322 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st322: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof322 } st_case_322: switch lex.data[(lex.p)] { - case 83: - goto st323 + case 84: + goto tr497 case 96: - goto tr296 - case 115: - goto st323 + goto tr303 + case 116: + goto tr497 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st323: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof323 } st_case_323: switch lex.data[(lex.p)] { - case 80: + case 65: goto st324 + case 69: + goto st331 case 96: - goto tr296 - case 112: + goto tr303 + case 97: goto st324 + case 101: + goto st331 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st324: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof324 } st_case_324: switch lex.data[(lex.p)] { - case 65: + case 77: goto st325 case 96: - goto tr296 - case 97: + goto tr303 + case 109: goto st325 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st325: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof325 } st_case_325: switch lex.data[(lex.p)] { - case 67: + case 69: goto st326 case 96: - goto tr296 - case 99: + goto tr303 + case 101: goto st326 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st326: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof326 } st_case_326: switch lex.data[(lex.p)] { - case 69: - goto tr499 + case 83: + goto st327 case 96: - goto tr296 - case 101: - goto tr499 + goto tr303 + case 115: + goto st327 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st327: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof327 } st_case_327: switch lex.data[(lex.p)] { - case 87: - goto tr500 + case 80: + goto st328 case 96: - goto tr296 - case 119: - goto tr500 + goto tr303 + case 112: + goto st328 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st328: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof328 } st_case_328: switch lex.data[(lex.p)] { - case 82: - goto tr501 + case 65: + goto st329 case 96: - goto tr296 - case 114: - goto tr501 + goto tr303 + case 97: + goto st329 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st329: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof329 } st_case_329: switch lex.data[(lex.p)] { - case 82: + case 67: goto st330 - case 85: - goto st342 case 96: - goto tr296 - case 114: + goto tr303 + case 99: goto st330 - case 117: - goto st342 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st330: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof330 } st_case_330: switch lex.data[(lex.p)] { - case 73: - goto st331 - case 79: - goto st336 + case 69: + goto tr506 case 96: - goto tr296 - case 105: - goto st331 - case 111: - goto st336 + goto tr303 + case 101: + goto tr506 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st331: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof331 } st_case_331: switch lex.data[(lex.p)] { - case 78: - goto st332 - case 86: - goto st333 + case 87: + goto tr507 case 96: - goto tr296 - case 110: - goto st332 - case 118: - goto st333 + goto tr303 + case 119: + goto tr507 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st332: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof332 } st_case_332: switch lex.data[(lex.p)] { - case 84: + case 82: goto tr508 case 96: - goto tr296 - case 116: + goto tr303 + case 114: goto tr508 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st333: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof333 } st_case_333: switch lex.data[(lex.p)] { - case 65: + case 82: goto st334 + case 85: + goto st346 case 96: - goto tr296 - case 97: + goto tr303 + case 114: goto st334 + case 117: + goto st346 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st334: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof334 } st_case_334: switch lex.data[(lex.p)] { - case 84: + case 73: goto st335 + case 79: + goto st340 case 96: - goto tr296 - case 116: + goto tr303 + case 105: goto st335 + case 111: + goto st340 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st335: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof335 } st_case_335: switch lex.data[(lex.p)] { - case 69: - goto tr511 + case 78: + goto st336 + case 86: + goto st337 case 96: - goto tr296 - case 101: - goto tr511 + goto tr303 + case 110: + goto st336 + case 118: + goto st337 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st336: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof336 @@ -12845,932 +12822,932 @@ func (lex *Lexer) Lex(lval Lval) int { st_case_336: switch lex.data[(lex.p)] { case 84: - goto st337 + goto tr515 case 96: - goto tr296 + goto tr303 case 116: - goto st337 + goto tr515 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st337: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof337 } st_case_337: switch lex.data[(lex.p)] { - case 69: + case 65: goto st338 case 96: - goto tr296 - case 101: + goto tr303 + case 97: goto st338 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st338: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof338 } st_case_338: switch lex.data[(lex.p)] { - case 67: + case 84: goto st339 case 96: - goto tr296 - case 99: + goto tr303 + case 116: goto st339 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st339: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof339 } st_case_339: switch lex.data[(lex.p)] { - case 84: - goto st340 + case 69: + goto tr518 case 96: - goto tr296 - case 116: - goto st340 + goto tr303 + case 101: + goto tr518 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st340: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof340 } st_case_340: switch lex.data[(lex.p)] { - case 69: + case 84: goto st341 case 96: - goto tr296 - case 101: + goto tr303 + case 116: goto st341 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st341: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof341 } st_case_341: switch lex.data[(lex.p)] { - case 68: - goto tr517 + case 69: + goto st342 case 96: - goto tr296 - case 100: - goto tr517 + goto tr303 + case 101: + goto st342 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st342: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof342 } st_case_342: switch lex.data[(lex.p)] { - case 66: + case 67: goto st343 case 96: - goto tr296 - case 98: + goto tr303 + case 99: goto st343 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st343: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof343 } st_case_343: switch lex.data[(lex.p)] { - case 76: + case 84: goto st344 case 96: - goto tr296 - case 108: + goto tr303 + case 116: goto st344 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st344: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof344 } st_case_344: switch lex.data[(lex.p)] { - case 73: + case 69: goto st345 case 96: - goto tr296 - case 105: + goto tr303 + case 101: goto st345 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st345: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof345 } st_case_345: switch lex.data[(lex.p)] { - case 67: - goto tr521 + case 68: + goto tr524 case 96: - goto tr296 - case 99: - goto tr521 + goto tr303 + case 100: + goto tr524 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st346: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof346 } st_case_346: switch lex.data[(lex.p)] { - case 69: + case 66: goto st347 case 96: - goto tr296 - case 101: + goto tr303 + case 98: goto st347 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st347: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof347 } st_case_347: switch lex.data[(lex.p)] { - case 81: + case 76: goto st348 - case 84: - goto st357 case 96: - goto tr296 - case 113: + goto tr303 + case 108: goto st348 - case 116: - goto st357 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st348: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof348 } st_case_348: switch lex.data[(lex.p)] { - case 85: + case 73: goto st349 case 96: - goto tr296 - case 117: + goto tr303 + case 105: goto st349 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st349: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof349 } st_case_349: switch lex.data[(lex.p)] { - case 73: - goto st350 + case 67: + goto tr528 case 96: - goto tr296 - case 105: - goto st350 + goto tr303 + case 99: + goto tr528 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st350: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof350 } st_case_350: switch lex.data[(lex.p)] { - case 82: + case 69: goto st351 case 96: - goto tr296 - case 114: + goto tr303 + case 101: goto st351 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st351: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof351 } st_case_351: switch lex.data[(lex.p)] { - case 69: + case 81: goto st352 + case 84: + goto st361 case 96: - goto tr296 - case 101: + goto tr303 + case 113: goto st352 + case 116: + goto st361 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st352: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof352 } st_case_352: - if lex.data[(lex.p)] == 95 { + switch lex.data[(lex.p)] { + case 85: + goto st353 + case 96: + goto tr303 + case 117: goto st353 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr529 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 96: + case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr529 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr529 + goto tr303 } default: - goto tr529 + goto tr303 } - goto tr204 + goto tr211 st353: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof353 } st_case_353: switch lex.data[(lex.p)] { - case 79: + case 73: goto st354 case 96: - goto tr296 - case 111: + goto tr303 + case 105: goto st354 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st354: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof354 } st_case_354: switch lex.data[(lex.p)] { - case 78: + case 82: goto st355 case 96: - goto tr296 - case 110: + goto tr303 + case 114: goto st355 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st355: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof355 } st_case_355: switch lex.data[(lex.p)] { - case 67: + case 69: goto st356 case 96: - goto tr296 - case 99: + goto tr303 + case 101: goto st356 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st356: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof356 } st_case_356: - switch lex.data[(lex.p)] { - case 69: - goto tr534 - case 96: - goto tr296 - case 101: - goto tr534 + if lex.data[(lex.p)] == 95 { + goto st357 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr536 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 94: + case lex.data[(lex.p)] > 96: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr536 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr536 } default: - goto tr296 + goto tr536 } - goto tr204 + goto tr211 st357: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof357 } st_case_357: switch lex.data[(lex.p)] { - case 85: + case 79: goto st358 case 96: - goto tr296 - case 117: + goto tr303 + case 111: goto st358 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st358: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof358 } st_case_358: switch lex.data[(lex.p)] { - case 82: + case 78: goto st359 case 96: - goto tr296 - case 114: + goto tr303 + case 110: goto st359 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st359: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof359 } st_case_359: switch lex.data[(lex.p)] { - case 78: - goto tr537 + case 67: + goto st360 case 96: - goto tr296 - case 110: - goto tr537 + goto tr303 + case 99: + goto st360 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st360: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof360 } st_case_360: switch lex.data[(lex.p)] { - case 84: - goto st361 - case 87: - goto st365 + case 69: + goto tr541 case 96: - goto tr296 - case 116: - goto st361 - case 119: - goto st365 + goto tr303 + case 101: + goto tr541 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st361: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof361 } st_case_361: switch lex.data[(lex.p)] { - case 65: + case 85: goto st362 case 96: - goto tr296 - case 97: + goto tr303 + case 117: goto st362 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st362: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof362 } st_case_362: switch lex.data[(lex.p)] { - case 84: + case 82: goto st363 case 96: - goto tr296 - case 116: + goto tr303 + case 114: goto st363 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st363: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof363 } st_case_363: switch lex.data[(lex.p)] { - case 73: - goto st364 + case 78: + goto tr544 case 96: - goto tr296 - case 105: - goto st364 + goto tr303 + case 110: + goto tr544 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st364: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof364 } st_case_364: switch lex.data[(lex.p)] { - case 67: - goto tr543 + case 84: + goto st365 + case 87: + goto st369 case 96: - goto tr296 - case 99: - goto tr543 + goto tr303 + case 116: + goto st365 + case 119: + goto st369 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st365: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof365 } st_case_365: switch lex.data[(lex.p)] { - case 73: + case 65: goto st366 case 96: - goto tr296 - case 105: + goto tr303 + case 97: goto st366 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st366: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof366 @@ -13780,412 +13757,408 @@ func (lex *Lexer) Lex(lval Lval) int { case 84: goto st367 case 96: - goto tr296 + goto tr303 case 116: goto st367 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st367: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof367 } st_case_367: switch lex.data[(lex.p)] { - case 67: + case 73: goto st368 case 96: - goto tr296 - case 99: + goto tr303 + case 105: goto st368 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st368: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof368 } st_case_368: switch lex.data[(lex.p)] { - case 72: - goto tr547 + case 67: + goto tr550 case 96: - goto tr296 - case 104: - goto tr547 + goto tr303 + case 99: + goto tr550 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st369: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof369 } st_case_369: switch lex.data[(lex.p)] { - case 72: + case 73: goto st370 - case 82: - goto st373 case 96: - goto tr296 - case 104: + goto tr303 + case 105: goto st370 - case 114: - goto st373 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st370: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof370 } st_case_370: switch lex.data[(lex.p)] { - case 82: + case 84: goto st371 case 96: - goto tr296 - case 114: + goto tr303 + case 116: goto st371 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st371: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof371 } st_case_371: switch lex.data[(lex.p)] { - case 79: + case 67: goto st372 case 96: - goto tr296 - case 111: + goto tr303 + case 99: goto st372 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st372: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof372 } st_case_372: switch lex.data[(lex.p)] { - case 87: - goto tr552 + case 72: + goto tr554 case 96: - goto tr296 - case 119: - goto tr552 + goto tr303 + case 104: + goto tr554 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st373: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof373 } st_case_373: switch lex.data[(lex.p)] { - case 65: + case 72: goto st374 - case 89: - goto tr554 + case 82: + goto st377 case 96: - goto tr296 - case 97: + goto tr303 + case 104: goto st374 - case 121: - goto tr554 + case 114: + goto st377 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st374: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof374 } st_case_374: switch lex.data[(lex.p)] { - case 73: + case 82: goto st375 case 96: - goto tr296 - case 105: + goto tr303 + case 114: goto st375 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st375: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof375 } st_case_375: switch lex.data[(lex.p)] { - case 84: - goto tr556 + case 79: + goto st376 case 96: - goto tr296 - case 116: - goto tr556 + goto tr303 + case 111: + goto st376 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st376: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof376 } st_case_376: switch lex.data[(lex.p)] { - case 78: - goto st377 - case 83: - goto st380 + case 87: + goto tr559 case 96: - goto tr296 - case 110: - goto st377 - case 115: - goto st380 + goto tr303 + case 119: + goto tr559 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st377: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof377 } st_case_377: switch lex.data[(lex.p)] { - case 83: + case 65: goto st378 + case 89: + goto tr561 case 96: - goto tr296 - case 115: + goto tr303 + case 97: goto st378 + case 121: + goto tr561 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st378: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof378 } st_case_378: switch lex.data[(lex.p)] { - case 69: + case 73: goto st379 case 96: - goto tr296 - case 101: + goto tr303 + case 105: goto st379 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st379: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof379 @@ -14193,340 +14166,344 @@ func (lex *Lexer) Lex(lval Lval) int { st_case_379: switch lex.data[(lex.p)] { case 84: - goto tr561 + goto tr563 case 96: - goto tr296 + goto tr303 case 116: - goto tr561 + goto tr563 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st380: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof380 } st_case_380: switch lex.data[(lex.p)] { - case 69: - goto tr562 + case 78: + goto st381 + case 83: + goto st384 case 96: - goto tr296 - case 101: - goto tr562 + goto tr303 + case 110: + goto st381 + case 115: + goto st384 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st381: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof381 } st_case_381: switch lex.data[(lex.p)] { - case 65: + case 83: goto st382 case 96: - goto tr296 - case 97: + goto tr303 + case 115: goto st382 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st382: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof382 } st_case_382: switch lex.data[(lex.p)] { - case 82: - goto tr564 + case 69: + goto st383 case 96: - goto tr296 - case 114: - goto tr564 + goto tr303 + case 101: + goto st383 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st383: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof383 } st_case_383: switch lex.data[(lex.p)] { - case 72: - goto st384 + case 84: + goto tr568 case 96: - goto tr296 - case 104: - goto st384 + goto tr303 + case 116: + goto tr568 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st384: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof384 } st_case_384: switch lex.data[(lex.p)] { - case 73: - goto st385 + case 69: + goto tr569 case 96: - goto tr296 - case 105: - goto st385 + goto tr303 + case 101: + goto tr569 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st385: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof385 } st_case_385: switch lex.data[(lex.p)] { - case 76: + case 65: goto st386 case 96: - goto tr296 - case 108: + goto tr303 + case 97: goto st386 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st386: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof386 } st_case_386: switch lex.data[(lex.p)] { - case 69: - goto tr568 + case 82: + goto tr571 case 96: - goto tr296 - case 101: - goto tr568 + goto tr303 + case 114: + goto tr571 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st387: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof387 } st_case_387: switch lex.data[(lex.p)] { - case 79: + case 72: goto st388 case 96: - goto tr296 - case 111: + goto tr303 + case 104: goto st388 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st388: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof388 } st_case_388: switch lex.data[(lex.p)] { - case 82: - goto tr570 + case 73: + goto st389 case 96: - goto tr296 - case 114: - goto tr570 + goto tr303 + case 105: + goto st389 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st389: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof389 } st_case_389: switch lex.data[(lex.p)] { - case 73: + case 76: goto st390 case 96: - goto tr296 - case 105: + goto tr303 + case 108: goto st390 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st390: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof390 @@ -14534,171 +14511,269 @@ func (lex *Lexer) Lex(lval Lval) int { st_case_390: switch lex.data[(lex.p)] { case 69: - goto st391 + goto tr575 case 96: - goto tr296 + goto tr303 case 101: - goto st391 + goto tr575 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st391: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof391 } st_case_391: switch lex.data[(lex.p)] { - case 76: + case 79: goto st392 case 96: - goto tr296 - case 108: + goto tr303 + case 111: goto st392 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st392: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof392 } st_case_392: switch lex.data[(lex.p)] { - case 68: - goto tr574 + case 82: + goto tr577 case 96: - goto tr296 - case 100: - goto tr574 + goto tr303 + case 114: + goto tr577 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 - tr574: -//line NONE:1 - lex.te = (lex.p) + 1 - - goto st393 + goto tr211 st393: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof393 } st_case_393: -//line scanner/scanner.go:13494 switch lex.data[(lex.p)] { - case 10: - goto st93 - case 13: - goto st94 - case 32: - goto st92 - case 70: + case 73: goto st394 case 96: - goto tr575 - case 102: + goto tr303 + case 105: goto st394 } switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr303 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr303 + } + case lex.data[(lex.p)] >= 91: + goto tr303 + } + default: + goto tr303 + } + goto tr211 + st394: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof394 + } + st_case_394: + switch lex.data[(lex.p)] { + case 69: + goto st395 + case 96: + goto tr303 + case 101: + goto st395 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr303 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr303 + } + case lex.data[(lex.p)] >= 91: + goto tr303 + } + default: + goto tr303 + } + goto tr211 + st395: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof395 + } + st_case_395: + switch lex.data[(lex.p)] { + case 76: + goto st396 + case 96: + goto tr303 + case 108: + goto st396 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr303 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr303 + } + case lex.data[(lex.p)] >= 91: + goto tr303 + } + default: + goto tr303 + } + goto tr211 + st396: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof396 + } + st_case_396: + switch lex.data[(lex.p)] { + case 68: + goto tr581 + case 96: + goto tr303 + case 100: + goto tr581 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr303 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr303 + } + case lex.data[(lex.p)] >= 91: + goto tr303 + } + default: + goto tr303 + } + goto tr211 + tr581: +//line NONE:1 + lex.te = (lex.p) + 1 + + goto st397 + st397: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof397 + } + st_case_397: +//line scanner/scanner.go:13595 + switch lex.data[(lex.p)] { + case 10: + goto st94 + case 13: + goto st95 + case 32: + goto st93 + case 70: + goto st398 + case 96: + goto tr582 + case 102: + goto st398 + } + switch { case lex.data[(lex.p)] < 14: switch { case lex.data[(lex.p)] > 8: if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto st92 + goto st93 } default: - goto tr575 + goto tr582 } case lex.data[(lex.p)] > 47: switch { case lex.data[(lex.p)] < 91: if 58 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 64 { - goto tr575 + goto tr582 } case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr575 + goto tr582 } default: - goto tr575 + goto tr582 } default: - goto tr575 + goto tr582 } - goto tr204 - tr131: -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) - goto st92 - st92: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof92 - } - st_case_92: -//line scanner/scanner.go:13545 - switch lex.data[(lex.p)] { - case 10: - goto st93 - case 13: - goto st94 - case 32: - goto st92 - case 70: - goto st95 - case 102: - goto st95 - } - if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto st92 - } - goto tr126 - tr132: + goto tr211 + tr134: //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) goto st93 @@ -14707,24 +14782,24 @@ func (lex *Lexer) Lex(lval Lval) int { goto _test_eof93 } st_case_93: -//line scanner/scanner.go:13571 +//line scanner/scanner.go:13646 switch lex.data[(lex.p)] { case 10: - goto tr132 + goto st94 case 13: - goto tr133 + goto st95 case 32: - goto tr131 + goto st93 case 70: - goto tr134 + goto st96 case 102: - goto tr134 + goto st96 } if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto tr131 + goto st93 } - goto tr126 - tr133: + goto tr129 + tr135: //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) goto st94 @@ -14733,12 +14808,24 @@ func (lex *Lexer) Lex(lval Lval) int { goto _test_eof94 } st_case_94: -//line scanner/scanner.go:13597 - if lex.data[(lex.p)] == 10 { - goto st93 +//line scanner/scanner.go:13672 + switch lex.data[(lex.p)] { + case 10: + goto tr135 + case 13: + goto tr136 + case 32: + goto tr134 + case 70: + goto tr137 + case 102: + goto tr137 } - goto tr126 - tr134: + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr134 + } + goto tr129 + tr136: //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) goto st95 @@ -14747,463 +14834,363 @@ func (lex *Lexer) Lex(lval Lval) int { goto _test_eof95 } st_case_95: -//line scanner/scanner.go:13611 - switch lex.data[(lex.p)] { - case 82: - goto st96 - case 114: - goto st96 +//line scanner/scanner.go:13698 + if lex.data[(lex.p)] == 10 { + goto st94 } - goto tr126 + goto tr129 + tr137: +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) + goto st96 st96: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof96 } st_case_96: +//line scanner/scanner.go:13712 switch lex.data[(lex.p)] { - case 79: + case 82: goto st97 - case 111: + case 114: goto st97 } - goto tr126 + goto tr129 st97: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof97 } st_case_97: - switch lex.data[(lex.p)] { - case 77: - goto tr137 - case 109: - goto tr137 - } - goto tr126 - st394: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof394 - } - st_case_394: - switch lex.data[(lex.p)] { - case 82: - goto st395 - case 96: - goto tr296 - case 114: - goto st395 - } - switch { - case lex.data[(lex.p)] < 58: - if lex.data[(lex.p)] <= 47 { - goto tr296 - } - case lex.data[(lex.p)] > 64: - switch { - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 - } - case lex.data[(lex.p)] >= 91: - goto tr296 - } - default: - goto tr296 - } - goto tr204 - st395: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof395 - } - st_case_395: switch lex.data[(lex.p)] { case 79: - goto st396 - case 96: - goto tr296 + goto st98 case 111: - goto st396 + goto st98 } - switch { - case lex.data[(lex.p)] < 58: - if lex.data[(lex.p)] <= 47 { - goto tr296 - } - case lex.data[(lex.p)] > 64: - switch { - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 - } - case lex.data[(lex.p)] >= 91: - goto tr296 - } - default: - goto tr296 - } - goto tr204 - st396: + goto tr129 + st98: if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof396 + goto _test_eof98 } - st_case_396: + st_case_98: switch lex.data[(lex.p)] { case 77: - goto tr579 - case 96: - goto tr296 + goto tr140 case 109: - goto tr579 + goto tr140 } - switch { - case lex.data[(lex.p)] < 58: - if lex.data[(lex.p)] <= 47 { - goto tr296 - } - case lex.data[(lex.p)] > 64: - switch { - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 - } - case lex.data[(lex.p)] >= 91: - goto tr296 - } - default: - goto tr296 - } - goto tr204 - st397: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof397 - } - st_case_397: - if lex.data[(lex.p)] == 61 { - goto tr580 - } - goto tr232 + goto tr129 st398: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof398 } st_case_398: - if lex.data[(lex.p)] == 95 { + switch lex.data[(lex.p)] { + case 82: + goto st399 + case 96: + goto tr303 + case 114: goto st399 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 96: + case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st399: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof399 } st_case_399: switch lex.data[(lex.p)] { - case 67: + case 79: goto st400 - case 68: - goto st406 - case 70: - goto st410 - case 72: - goto st423 - case 76: - goto st435 - case 77: - goto st440 - case 78: - goto st447 - case 84: - goto st457 case 96: - goto tr296 - case 99: + goto tr303 + case 111: goto st400 - case 100: - goto st406 - case 102: - goto st410 - case 104: - goto st423 - case 108: - goto st435 - case 109: - goto st440 - case 110: - goto st447 - case 116: - goto st457 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st400: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof400 } st_case_400: switch lex.data[(lex.p)] { - case 76: - goto st401 + case 77: + goto tr586 case 96: - goto tr296 - case 108: - goto st401 + goto tr303 + case 109: + goto tr586 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st401: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof401 } st_case_401: - switch lex.data[(lex.p)] { - case 65: - goto st402 - case 96: - goto tr296 - case 97: - goto st402 + if lex.data[(lex.p)] == 61 { + goto tr587 } - switch { - case lex.data[(lex.p)] < 58: - if lex.data[(lex.p)] <= 47 { - goto tr296 - } - case lex.data[(lex.p)] > 64: - switch { - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 - } - case lex.data[(lex.p)] >= 91: - goto tr296 - } - default: - goto tr296 - } - goto tr204 + goto tr239 st402: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof402 } st_case_402: - switch lex.data[(lex.p)] { - case 83: - goto st403 - case 96: - goto tr296 - case 115: + if lex.data[(lex.p)] == 95 { goto st403 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 94: + case lex.data[(lex.p)] > 96: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st403: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof403 } st_case_403: switch lex.data[(lex.p)] { - case 83: + case 67: goto st404 + case 68: + goto st410 + case 70: + goto st414 + case 72: + goto st427 + case 76: + goto st439 + case 77: + goto st444 + case 78: + goto st451 + case 84: + goto st461 case 96: - goto tr296 - case 115: + goto tr303 + case 99: goto st404 + case 100: + goto st410 + case 102: + goto st414 + case 104: + goto st427 + case 108: + goto st439 + case 109: + goto st444 + case 110: + goto st451 + case 116: + goto st461 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st404: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof404 } st_case_404: - if lex.data[(lex.p)] == 95 { + switch lex.data[(lex.p)] { + case 76: + goto st405 + case 96: + goto tr303 + case 108: goto st405 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 96: + case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st405: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof405 } st_case_405: - if lex.data[(lex.p)] == 95 { - goto tr595 + switch lex.data[(lex.p)] { + case 65: + goto st406 + case 96: + goto tr303 + case 97: + goto st406 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 96: + case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st406: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof406 } st_case_406: switch lex.data[(lex.p)] { - case 73: + case 83: goto st407 case 96: - goto tr296 - case 105: + goto tr303 + case 115: goto st407 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st407: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof407 } st_case_407: switch lex.data[(lex.p)] { - case 82: + case 83: goto st408 case 96: - goto tr296 - case 114: + goto tr303 + case 115: goto st408 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st408: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof408 @@ -15215,47 +15202,47 @@ func (lex *Lexer) Lex(lval Lval) int { switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 96: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st409: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof409 } st_case_409: if lex.data[(lex.p)] == 95 { - goto tr599 + goto tr602 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 96: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st410: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof410 @@ -15264,752 +15251,742 @@ func (lex *Lexer) Lex(lval Lval) int { switch lex.data[(lex.p)] { case 73: goto st411 - case 85: - goto st415 case 96: - goto tr296 + goto tr303 case 105: goto st411 - case 117: - goto st415 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st411: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof411 } st_case_411: switch lex.data[(lex.p)] { - case 76: + case 82: goto st412 case 96: - goto tr296 - case 108: + goto tr303 + case 114: goto st412 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st412: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof412 } st_case_412: - switch lex.data[(lex.p)] { - case 69: - goto st413 - case 96: - goto tr296 - case 101: + if lex.data[(lex.p)] == 95 { goto st413 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 94: + case lex.data[(lex.p)] > 96: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st413: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof413 } st_case_413: if lex.data[(lex.p)] == 95 { - goto st414 + goto tr606 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 96: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st414: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof414 } st_case_414: - if lex.data[(lex.p)] == 95 { - goto tr605 + switch lex.data[(lex.p)] { + case 73: + goto st415 + case 85: + goto st419 + case 96: + goto tr303 + case 105: + goto st415 + case 117: + goto st419 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 96: + case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st415: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof415 } st_case_415: switch lex.data[(lex.p)] { - case 78: + case 76: goto st416 case 96: - goto tr296 - case 110: + goto tr303 + case 108: goto st416 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st416: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof416 } st_case_416: switch lex.data[(lex.p)] { - case 67: + case 69: goto st417 case 96: - goto tr296 - case 99: + goto tr303 + case 101: goto st417 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st417: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof417 } st_case_417: - switch lex.data[(lex.p)] { - case 84: - goto st418 - case 96: - goto tr296 - case 116: + if lex.data[(lex.p)] == 95 { goto st418 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 94: + case lex.data[(lex.p)] > 96: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st418: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof418 } st_case_418: - switch lex.data[(lex.p)] { - case 73: - goto st419 - case 96: - goto tr296 - case 105: - goto st419 + if lex.data[(lex.p)] == 95 { + goto tr612 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 94: + case lex.data[(lex.p)] > 96: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st419: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof419 } st_case_419: switch lex.data[(lex.p)] { - case 79: + case 78: goto st420 case 96: - goto tr296 - case 111: + goto tr303 + case 110: goto st420 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st420: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof420 } st_case_420: switch lex.data[(lex.p)] { - case 78: + case 67: goto st421 case 96: - goto tr296 - case 110: + goto tr303 + case 99: goto st421 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st421: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof421 } st_case_421: - if lex.data[(lex.p)] == 95 { + switch lex.data[(lex.p)] { + case 84: + goto st422 + case 96: + goto tr303 + case 116: goto st422 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 96: + case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st422: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof422 } st_case_422: - if lex.data[(lex.p)] == 95 { - goto tr613 + switch lex.data[(lex.p)] { + case 73: + goto st423 + case 96: + goto tr303 + case 105: + goto st423 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 96: + case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st423: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof423 } st_case_423: switch lex.data[(lex.p)] { - case 65: + case 79: goto st424 case 96: - goto tr296 - case 97: + goto tr303 + case 111: goto st424 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st424: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof424 } st_case_424: switch lex.data[(lex.p)] { - case 76: + case 78: goto st425 case 96: - goto tr296 - case 108: + goto tr303 + case 110: goto st425 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st425: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof425 } st_case_425: - switch lex.data[(lex.p)] { - case 84: - goto st426 - case 96: - goto tr296 - case 116: + if lex.data[(lex.p)] == 95 { goto st426 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 94: + case lex.data[(lex.p)] > 96: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st426: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof426 } st_case_426: if lex.data[(lex.p)] == 95 { - goto st427 + goto tr620 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 96: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st427: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof427 } st_case_427: switch lex.data[(lex.p)] { - case 67: + case 65: goto st428 case 96: - goto tr296 - case 99: + goto tr303 + case 97: goto st428 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st428: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof428 } st_case_428: switch lex.data[(lex.p)] { - case 79: + case 76: goto st429 case 96: - goto tr296 - case 111: + goto tr303 + case 108: goto st429 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st429: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof429 } st_case_429: switch lex.data[(lex.p)] { - case 77: + case 84: goto st430 case 96: - goto tr296 - case 109: + goto tr303 + case 116: goto st430 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st430: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof430 } st_case_430: - switch lex.data[(lex.p)] { - case 80: - goto st431 - case 96: - goto tr296 - case 112: + if lex.data[(lex.p)] == 95 { goto st431 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 94: + case lex.data[(lex.p)] > 96: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st431: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof431 } st_case_431: switch lex.data[(lex.p)] { - case 73: + case 67: goto st432 case 96: - goto tr296 - case 105: + goto tr303 + case 99: goto st432 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st432: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof432 } st_case_432: switch lex.data[(lex.p)] { - case 76: + case 79: goto st433 case 96: - goto tr296 - case 108: + goto tr303 + case 111: goto st433 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st433: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof433 } st_case_433: switch lex.data[(lex.p)] { - case 69: + case 77: goto st434 case 96: - goto tr296 - case 101: + goto tr303 + case 109: goto st434 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st434: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof434 } st_case_434: switch lex.data[(lex.p)] { - case 82: - goto tr625 + case 80: + goto st435 case 96: - goto tr296 - case 114: - goto tr625 + goto tr303 + case 112: + goto st435 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st435: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof435 @@ -16019,59 +15996,59 @@ func (lex *Lexer) Lex(lval Lval) int { case 73: goto st436 case 96: - goto tr296 + goto tr303 case 105: goto st436 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st436: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof436 } st_case_436: switch lex.data[(lex.p)] { - case 78: + case 76: goto st437 case 96: - goto tr296 - case 110: + goto tr303 + case 108: goto st437 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st437: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof437 @@ -16081,1016 +16058,1140 @@ func (lex *Lexer) Lex(lval Lval) int { case 69: goto st438 case 96: - goto tr296 + goto tr303 case 101: goto st438 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st438: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof438 } st_case_438: - if lex.data[(lex.p)] == 95 { - goto st439 + switch lex.data[(lex.p)] { + case 82: + goto tr632 + case 96: + goto tr303 + case 114: + goto tr632 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 96: + case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st439: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof439 } st_case_439: - if lex.data[(lex.p)] == 95 { - goto tr630 + switch lex.data[(lex.p)] { + case 73: + goto st440 + case 96: + goto tr303 + case 105: + goto st440 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 96: + case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st440: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof440 } st_case_440: switch lex.data[(lex.p)] { - case 69: + case 78: goto st441 case 96: - goto tr296 - case 101: + goto tr303 + case 110: goto st441 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st441: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof441 } st_case_441: switch lex.data[(lex.p)] { - case 84: + case 69: goto st442 case 96: - goto tr296 - case 116: + goto tr303 + case 101: goto st442 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st442: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof442 } st_case_442: - switch lex.data[(lex.p)] { - case 72: - goto st443 - case 96: - goto tr296 - case 104: - goto st443 - } - switch { - case lex.data[(lex.p)] < 58: - if lex.data[(lex.p)] <= 47 { - goto tr296 - } - case lex.data[(lex.p)] > 64: - switch { - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 - } - case lex.data[(lex.p)] >= 91: - goto tr296 - } - default: - goto tr296 - } - goto tr204 - st443: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof443 - } - st_case_443: - switch lex.data[(lex.p)] { - case 79: - goto st444 - case 96: - goto tr296 - case 111: - goto st444 - } - switch { - case lex.data[(lex.p)] < 58: - if lex.data[(lex.p)] <= 47 { - goto tr296 - } - case lex.data[(lex.p)] > 64: - switch { - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 - } - case lex.data[(lex.p)] >= 91: - goto tr296 - } - default: - goto tr296 - } - goto tr204 - st444: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof444 - } - st_case_444: - switch lex.data[(lex.p)] { - case 68: - goto st445 - case 96: - goto tr296 - case 100: - goto st445 - } - switch { - case lex.data[(lex.p)] < 58: - if lex.data[(lex.p)] <= 47 { - goto tr296 - } - case lex.data[(lex.p)] > 64: - switch { - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 - } - case lex.data[(lex.p)] >= 91: - goto tr296 - } - default: - goto tr296 - } - goto tr204 - st445: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof445 - } - st_case_445: if lex.data[(lex.p)] == 95 { - goto st446 + goto st443 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 96: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 - st446: + goto tr211 + st443: if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof446 + goto _test_eof443 } - st_case_446: + st_case_443: if lex.data[(lex.p)] == 95 { goto tr637 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 96: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 + st444: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof444 + } + st_case_444: + switch lex.data[(lex.p)] { + case 69: + goto st445 + case 96: + goto tr303 + case 101: + goto st445 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr303 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr303 + } + case lex.data[(lex.p)] >= 91: + goto tr303 + } + default: + goto tr303 + } + goto tr211 + st445: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof445 + } + st_case_445: + switch lex.data[(lex.p)] { + case 84: + goto st446 + case 96: + goto tr303 + case 116: + goto st446 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr303 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr303 + } + case lex.data[(lex.p)] >= 91: + goto tr303 + } + default: + goto tr303 + } + goto tr211 + st446: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof446 + } + st_case_446: + switch lex.data[(lex.p)] { + case 72: + goto st447 + case 96: + goto tr303 + case 104: + goto st447 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr303 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr303 + } + case lex.data[(lex.p)] >= 91: + goto tr303 + } + default: + goto tr303 + } + goto tr211 st447: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof447 } st_case_447: switch lex.data[(lex.p)] { - case 65: + case 79: goto st448 case 96: - goto tr296 - case 97: + goto tr303 + case 111: goto st448 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st448: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof448 } st_case_448: switch lex.data[(lex.p)] { - case 77: + case 68: goto st449 case 96: - goto tr296 - case 109: + goto tr303 + case 100: goto st449 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st449: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof449 } st_case_449: - switch lex.data[(lex.p)] { - case 69: - goto st450 - case 96: - goto tr296 - case 101: + if lex.data[(lex.p)] == 95 { goto st450 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 94: + case lex.data[(lex.p)] > 96: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st450: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof450 } st_case_450: - switch lex.data[(lex.p)] { - case 83: - goto st451 - case 96: - goto tr296 - case 115: - goto st451 + if lex.data[(lex.p)] == 95 { + goto tr644 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 94: + case lex.data[(lex.p)] > 96: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st451: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof451 } st_case_451: switch lex.data[(lex.p)] { - case 80: + case 65: goto st452 case 96: - goto tr296 - case 112: + goto tr303 + case 97: goto st452 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st452: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof452 } st_case_452: switch lex.data[(lex.p)] { - case 65: + case 77: goto st453 case 96: - goto tr296 - case 97: + goto tr303 + case 109: goto st453 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st453: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof453 } st_case_453: switch lex.data[(lex.p)] { - case 67: + case 69: goto st454 case 96: - goto tr296 - case 99: + goto tr303 + case 101: goto st454 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st454: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof454 } st_case_454: switch lex.data[(lex.p)] { - case 69: + case 83: goto st455 case 96: - goto tr296 - case 101: + goto tr303 + case 115: goto st455 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st455: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof455 } st_case_455: - if lex.data[(lex.p)] == 95 { + switch lex.data[(lex.p)] { + case 80: + goto st456 + case 96: + goto tr303 + case 112: goto st456 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 96: + case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st456: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof456 } st_case_456: - if lex.data[(lex.p)] == 95 { - goto tr647 + switch lex.data[(lex.p)] { + case 65: + goto st457 + case 96: + goto tr303 + case 97: + goto st457 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 96: + case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st457: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof457 } st_case_457: switch lex.data[(lex.p)] { - case 82: + case 67: goto st458 case 96: - goto tr296 - case 114: + goto tr303 + case 99: goto st458 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st458: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof458 } st_case_458: switch lex.data[(lex.p)] { - case 65: + case 69: goto st459 case 96: - goto tr296 - case 97: + goto tr303 + case 101: goto st459 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st459: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof459 } st_case_459: - switch lex.data[(lex.p)] { - case 73: - goto st460 - case 96: - goto tr296 - case 105: + if lex.data[(lex.p)] == 95 { goto st460 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 94: + case lex.data[(lex.p)] > 96: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st460: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof460 } st_case_460: - switch lex.data[(lex.p)] { - case 84: - goto st461 - case 96: - goto tr296 - case 116: - goto st461 + if lex.data[(lex.p)] == 95 { + goto tr654 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 94: + case lex.data[(lex.p)] > 96: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st461: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof461 } st_case_461: - if lex.data[(lex.p)] == 95 { + switch lex.data[(lex.p)] { + case 82: + goto st462 + case 96: + goto tr303 + case 114: goto st462 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 96: + case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st462: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof462 } st_case_462: - if lex.data[(lex.p)] == 95 { - goto tr653 + switch lex.data[(lex.p)] { + case 65: + goto st463 + case 96: + goto tr303 + case 97: + goto st463 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] > 64: switch { - case lex.data[(lex.p)] > 96: + case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr296 + goto tr303 } case lex.data[(lex.p)] >= 91: - goto tr296 + goto tr303 } default: - goto tr296 + goto tr303 } - goto tr204 + goto tr211 st463: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof463 } st_case_463: switch lex.data[(lex.p)] { - case 61: - goto tr654 - case 124: - goto tr655 + case 73: + goto st464 + case 96: + goto tr303 + case 105: + goto st464 } - goto tr232 - tr138: -//line scanner/scanner.rl:380 + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr303 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr303 + } + case lex.data[(lex.p)] >= 91: + goto tr303 + } + default: + goto tr303 + } + goto tr211 + st464: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof464 + } + st_case_464: + switch lex.data[(lex.p)] { + case 84: + goto st465 + case 96: + goto tr303 + case 116: + goto st465 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr303 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr303 + } + case lex.data[(lex.p)] >= 91: + goto tr303 + } + default: + goto tr303 + } + goto tr211 + st465: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof465 + } + st_case_465: + if lex.data[(lex.p)] == 95 { + goto st466 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr303 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr303 + } + case lex.data[(lex.p)] >= 91: + goto tr303 + } + default: + goto tr303 + } + goto tr211 + st466: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof466 + } + st_case_466: + if lex.data[(lex.p)] == 95 { + goto tr660 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr303 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr303 + } + case lex.data[(lex.p)] >= 91: + goto tr303 + } + default: + goto tr303 + } + goto tr211 + st467: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof467 + } + st_case_467: + switch lex.data[(lex.p)] { + case 61: + goto tr661 + case 124: + goto tr662 + } + goto tr239 + tr141: +//line scanner/scanner.rl:390 (lex.p) = (lex.te) - 1 { lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te) } - goto st464 - tr656: -//line scanner/scanner.rl:383 + goto st468 + tr663: +//line scanner/scanner.rl:393 lex.te = (lex.p) + 1 { lex.ungetCnt(1) { - goto st117 + goto st121 } } - goto st464 - tr661: -//line scanner/scanner.rl:380 + goto st468 + tr668: +//line scanner/scanner.rl:390 lex.te = (lex.p) (lex.p)-- { lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te) } - goto st464 - tr663: + goto st468 + tr670: //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) -//line scanner/scanner.rl:380 +//line scanner/scanner.rl:390 lex.te = (lex.p) (lex.p)-- { lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te) } - goto st464 - tr667: -//line scanner/scanner.rl:383 + goto st468 + tr674: +//line scanner/scanner.rl:393 lex.te = (lex.p) (lex.p)-- { lex.ungetCnt(1) { - goto st117 + goto st121 } } - goto st464 - tr668: -//line scanner/scanner.rl:381 + goto st468 + tr675: +//line scanner/scanner.rl:391 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_OBJECT_OPERATOR { (lex.p)++ - lex.cs = 464 + lex.cs = 468 goto _out } } - goto st464 - tr669: - lex.cs = 464 -//line scanner/scanner.rl:382 + goto st468 + tr676: + lex.cs = 468 +//line scanner/scanner.rl:392 lex.te = (lex.p) (lex.p)-- { lex.setTokenPosition(token) tok = T_STRING - lex.cs = 117 + lex.cs = 121 { (lex.p)++ goto _out } } goto _again - st464: + st468: //line NONE:1 lex.ts = 0 if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof464 + goto _test_eof468 } - st_case_464: + st_case_468: //line NONE:1 lex.ts = (lex.p) -//line scanner/scanner.go:15767 +//line scanner/scanner.go:15868 switch lex.data[(lex.p)] { case 10: - goto tr139 + goto tr142 case 13: - goto st467 + goto st471 case 32: - goto tr657 + goto tr664 case 45: - goto st468 + goto st472 case 96: - goto tr656 + goto tr663 } switch { case lex.data[(lex.p)] < 14: switch { case lex.data[(lex.p)] > 8: if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto tr657 + goto tr664 } default: - goto tr656 + goto tr663 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr656 + goto tr663 } case lex.data[(lex.p)] >= 91: - goto tr656 + goto tr663 } default: - goto tr656 + goto tr663 } - goto st469 - tr657: -//line NONE:1 - lex.te = (lex.p) + 1 - - goto st465 + goto st473 tr664: //line NONE:1 lex.te = (lex.p) + 1 -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) - goto st465 - st465: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof465 - } - st_case_465: -//line scanner/scanner.go:15820 - switch lex.data[(lex.p)] { - case 10: - goto tr139 - case 13: - goto st98 - case 32: - goto tr657 - } - if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto tr657 - } - goto tr661 - tr139: -//line NONE:1 - lex.te = (lex.p) + 1 - - goto st466 - tr665: + goto st469 + tr671: //line NONE:1 lex.te = (lex.p) + 1 //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) - goto st466 - st466: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof466 - } - st_case_466: -//line scanner/scanner.go:15850 - switch lex.data[(lex.p)] { - case 10: - goto tr665 - case 13: - goto tr666 - case 32: - goto tr664 - } - if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto tr664 - } - goto tr663 - tr666: -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) - goto st98 - st98: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof98 - } - st_case_98: -//line scanner/scanner.go:15872 - if lex.data[(lex.p)] == 10 { - goto tr139 - } - goto tr138 - st467: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof467 - } - st_case_467: - if lex.data[(lex.p)] == 10 { - goto tr139 - } - goto tr667 - st468: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof468 - } - st_case_468: - if lex.data[(lex.p)] == 62 { - goto tr668 - } - goto tr667 + goto st469 st469: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof469 } st_case_469: +//line scanner/scanner.go:15921 + switch lex.data[(lex.p)] { + case 10: + goto tr142 + case 13: + goto st99 + case 32: + goto tr664 + } + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr664 + } + goto tr668 + tr142: +//line NONE:1 + lex.te = (lex.p) + 1 + + goto st470 + tr672: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) + goto st470 + st470: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof470 + } + st_case_470: +//line scanner/scanner.go:15951 + switch lex.data[(lex.p)] { + case 10: + goto tr672 + case 13: + goto tr673 + case 32: + goto tr671 + } + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr671 + } + goto tr670 + tr673: +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) + goto st99 + st99: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof99 + } + st_case_99: +//line scanner/scanner.go:15973 + if lex.data[(lex.p)] == 10 { + goto tr142 + } + goto tr141 + st471: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof471 + } + st_case_471: + if lex.data[(lex.p)] == 10 { + goto tr142 + } + goto tr674 + st472: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof472 + } + st_case_472: + if lex.data[(lex.p)] == 62 { + goto tr675 + } + goto tr674 + st473: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof473 + } + st_case_473: if lex.data[(lex.p)] == 96 { - goto tr669 + goto tr676 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr669 + goto tr676 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr669 + goto tr676 } case lex.data[(lex.p)] >= 91: - goto tr669 + goto tr676 } default: - goto tr669 + goto tr676 } - goto st469 - tr672: - lex.cs = 470 + goto st473 + tr679: + lex.cs = 474 //line NONE:1 switch lex.act { case 0: @@ -17099,13 +17200,13 @@ func (lex *Lexer) Lex(lval Lval) int { goto st0 } } - case 144: + case 146: { (lex.p) = (lex.te) - 1 lex.setTokenPosition(token) tok = T_ENCAPSED_AND_WHITESPACE - lex.cs = 491 + lex.cs = 495 { (lex.p)++ goto _out @@ -17114,24 +17215,24 @@ func (lex *Lexer) Lex(lval Lval) int { } goto _again - tr673: - lex.cs = 470 + tr680: + lex.cs = 474 //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) -//line scanner/scanner.rl:387 +//line scanner/scanner.rl:397 lex.te = (lex.p) (lex.p)-- { lex.setTokenPosition(token) tok = T_ENCAPSED_AND_WHITESPACE - lex.cs = 491 + lex.cs = 495 { (lex.p)++ goto _out } } goto _again - st470: + st474: //line NONE:1 lex.ts = 0 @@ -17139,13 +17240,13 @@ func (lex *Lexer) Lex(lval Lval) int { lex.act = 0 if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof470 + goto _test_eof474 } - st_case_470: + st_case_474: //line NONE:1 lex.ts = (lex.p) -//line scanner/scanner.go:15966 +//line scanner/scanner.go:16067 _widec = int16(lex.data[(lex.p)]) switch { case lex.data[(lex.p)] < 11: @@ -17185,386 +17286,52 @@ func (lex *Lexer) Lex(lval Lval) int { } } if _widec == 1034 { - goto st472 + goto st476 } if 1024 <= _widec && _widec <= 1279 { - goto tr670 + goto tr677 } goto st0 st_case_0: st0: lex.cs = 0 goto _out - tr670: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:387 - lex.act = 144 - goto st471 - tr674: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) -//line scanner/scanner.rl:387 - lex.act = 144 - goto st471 - st471: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof471 - } - st_case_471: -//line scanner/scanner.go:16037 - _widec = int16(lex.data[(lex.p)]) - switch { - case lex.data[(lex.p)] < 11: - switch { - case lex.data[(lex.p)] > 9: - if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { - _widec = 768 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) { - _widec += 256 - } - } - default: - _widec = 768 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) { - _widec += 256 - } - } - case lex.data[(lex.p)] > 12: - switch { - case lex.data[(lex.p)] > 13: - if 14 <= lex.data[(lex.p)] { - _widec = 768 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) { - _widec += 256 - } - } - case lex.data[(lex.p)] >= 13: - _widec = 768 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) { - _widec += 256 - } - } - default: - _widec = 768 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) { - _widec += 256 - } - } - if _widec == 1034 { - goto st472 - } - if 1024 <= _widec && _widec <= 1279 { - goto tr670 - } - goto tr672 - tr675: -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) - goto st472 - st472: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof472 - } - st_case_472: -//line scanner/scanner.go:16092 - _widec = int16(lex.data[(lex.p)]) - switch { - case lex.data[(lex.p)] < 11: - switch { - case lex.data[(lex.p)] > 9: - if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { - _widec = 768 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) { - _widec += 256 - } - } - default: - _widec = 768 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) { - _widec += 256 - } - } - case lex.data[(lex.p)] > 12: - switch { - case lex.data[(lex.p)] > 13: - if 14 <= lex.data[(lex.p)] { - _widec = 768 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) { - _widec += 256 - } - } - case lex.data[(lex.p)] >= 13: - _widec = 768 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) { - _widec += 256 - } - } - default: - _widec = 768 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) { - _widec += 256 - } - } - if _widec == 1034 { - goto tr675 - } - if 1024 <= _widec && _widec <= 1279 { - goto tr674 - } - goto tr673 - tr140: -//line scanner/scanner.rl:396 - lex.te = (lex.p) + 1 - { - lex.ungetCnt(1) - lex.setTokenPosition(token) - tok = T_CURLY_OPEN - lex.call(473, 117) - goto _out - } - goto st473 - tr682: -//line scanner/scanner.rl:398 - lex.te = (lex.p) - (lex.p)-- - { - lex.ungetCnt(1) - { - lex.growCallStack() - { - lex.stack[lex.top] = 473 - lex.top++ - goto st493 - } - } - } - goto st473 - tr683: -//line scanner/scanner.rl:397 - lex.te = (lex.p) + 1 - { - lex.setTokenPosition(token) - tok = T_DOLLAR_OPEN_CURLY_BRACES - lex.call(473, 508) - goto _out - } - goto st473 - tr684: - lex.cs = 473 -//line NONE:1 - switch lex.act { - case 145: - { - (lex.p) = (lex.te) - 1 - lex.ungetCnt(1) - lex.setTokenPosition(token) - tok = T_CURLY_OPEN - lex.call(473, 117) - goto _out - } - case 146: - { - (lex.p) = (lex.te) - 1 - lex.setTokenPosition(token) - tok = T_DOLLAR_OPEN_CURLY_BRACES - lex.call(473, 508) - goto _out - } - case 148: - { - (lex.p) = (lex.te) - 1 - - lex.setTokenPosition(token) - tok = T_ENCAPSED_AND_WHITESPACE - - if len(lex.data) > lex.p+1 && lex.data[lex.p+1] != '$' && lex.data[lex.p+1] != '{' { - lex.cs = 491 - } - { - (lex.p)++ - goto _out - } - } - } - - goto _again - tr685: - lex.cs = 473 -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) -//line scanner/scanner.rl:399 - lex.te = (lex.p) - (lex.p)-- - { - lex.setTokenPosition(token) - tok = T_ENCAPSED_AND_WHITESPACE - - if len(lex.data) > lex.p+1 && lex.data[lex.p+1] != '$' && lex.data[lex.p+1] != '{' { - lex.cs = 491 - } - { - (lex.p)++ - goto _out - } - } - goto _again - tr689: - lex.cs = 473 -//line scanner/scanner.rl:399 - lex.te = (lex.p) - (lex.p)-- - { - lex.setTokenPosition(token) - tok = T_ENCAPSED_AND_WHITESPACE - - if len(lex.data) > lex.p+1 && lex.data[lex.p+1] != '$' && lex.data[lex.p+1] != '{' { - lex.cs = 491 - } - { - (lex.p)++ - goto _out - } - } - goto _again - st473: -//line NONE:1 - lex.ts = 0 - - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof473 - } - st_case_473: -//line NONE:1 - lex.ts = (lex.p) - -//line scanner/scanner.go:16221 - _widec = int16(lex.data[(lex.p)]) - switch { - case lex.data[(lex.p)] < 11: - switch { - case lex.data[(lex.p)] > 9: - if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { - _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { - _widec += 256 - } - } - default: - _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { - _widec += 256 - } - } - case lex.data[(lex.p)] > 12: - switch { - case lex.data[(lex.p)] > 13: - if 14 <= lex.data[(lex.p)] { - _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { - _widec += 256 - } - } - case lex.data[(lex.p)] >= 13: - _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { - _widec += 256 - } - } - default: - _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { - _widec += 256 - } - } - switch _widec { - case 1316: - goto st474 - case 1403: - goto st99 - case 1546: - goto st476 - case 1572: - goto st477 - case 1659: - goto st478 - } - if 1536 <= _widec && _widec <= 1791 { - goto tr678 - } - goto st0 - st474: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof474 - } - st_case_474: - if lex.data[(lex.p)] == 123 { - goto tr683 - } - goto tr682 - st99: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof99 - } - st_case_99: - if lex.data[(lex.p)] == 36 { - goto tr140 - } - goto st0 - tr678: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:399 - lex.act = 148 - goto st475 - tr686: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) -//line scanner/scanner.rl:399 - lex.act = 148 - goto st475 - tr688: + tr677: //line NONE:1 lex.te = (lex.p) + 1 //line scanner/scanner.rl:397 lex.act = 146 goto st475 - tr690: + tr681: //line NONE:1 lex.te = (lex.p) + 1 -//line scanner/scanner.rl:396 - lex.act = 145 +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) +//line scanner/scanner.rl:397 + lex.act = 146 goto st475 st475: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof475 } st_case_475: -//line scanner/scanner.go:16329 +//line scanner/scanner.go:16138 _widec = int16(lex.data[(lex.p)]) switch { case lex.data[(lex.p)] < 11: switch { case lex.data[(lex.p)] > 9: if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { - _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec = 768 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) { _widec += 256 } } default: - _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec = 768 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) { _widec += 256 } } @@ -17572,31 +17339,31 @@ func (lex *Lexer) Lex(lval Lval) int { switch { case lex.data[(lex.p)] > 13: if 14 <= lex.data[(lex.p)] { - _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec = 768 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) { _widec += 256 } } case lex.data[(lex.p)] >= 13: - _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec = 768 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) { _widec += 256 } } default: - _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec = 768 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) { _widec += 256 } } - if _widec == 1546 { + if _widec == 1034 { goto st476 } - if 1536 <= _widec && _widec <= 1791 { - goto tr678 + if 1024 <= _widec && _widec <= 1279 { + goto tr677 } - goto tr684 - tr687: + goto tr679 + tr682: //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) goto st476 @@ -17605,21 +17372,21 @@ func (lex *Lexer) Lex(lval Lval) int { goto _test_eof476 } st_case_476: -//line scanner/scanner.go:16384 +//line scanner/scanner.go:16193 _widec = int16(lex.data[(lex.p)]) switch { case lex.data[(lex.p)] < 11: switch { case lex.data[(lex.p)] > 9: if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { - _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec = 768 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) { _widec += 256 } } default: - _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec = 768 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) { _widec += 256 } } @@ -17627,90 +17394,156 @@ func (lex *Lexer) Lex(lval Lval) int { switch { case lex.data[(lex.p)] > 13: if 14 <= lex.data[(lex.p)] { - _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec = 768 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) { _widec += 256 } } case lex.data[(lex.p)] >= 13: - _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec = 768 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) { _widec += 256 } } default: - _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec = 768 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) { _widec += 256 } } - if _widec == 1546 { - goto tr687 + if _widec == 1034 { + goto tr682 } - if 1536 <= _widec && _widec <= 1791 { - goto tr686 + if 1024 <= _widec && _widec <= 1279 { + goto tr681 } - goto tr685 + goto tr680 + tr143: +//line scanner/scanner.rl:406 + lex.te = (lex.p) + 1 + { + lex.ungetCnt(1) + lex.setTokenPosition(token) + tok = T_CURLY_OPEN + lex.call(477, 121) + goto _out + } + goto st477 + tr689: +//line scanner/scanner.rl:408 + lex.te = (lex.p) + (lex.p)-- + { + lex.ungetCnt(1) + { + lex.growCallStack() + { + lex.stack[lex.top] = 477 + lex.top++ + goto st497 + } + } + } + goto st477 + tr690: +//line scanner/scanner.rl:407 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(token) + tok = T_DOLLAR_OPEN_CURLY_BRACES + lex.call(477, 512) + goto _out + } + goto st477 + tr691: + lex.cs = 477 +//line NONE:1 + switch lex.act { + case 147: + { + (lex.p) = (lex.te) - 1 + lex.ungetCnt(1) + lex.setTokenPosition(token) + tok = T_CURLY_OPEN + lex.call(477, 121) + goto _out + } + case 148: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(token) + tok = T_DOLLAR_OPEN_CURLY_BRACES + lex.call(477, 512) + goto _out + } + case 150: + { + (lex.p) = (lex.te) - 1 + + lex.setTokenPosition(token) + tok = T_ENCAPSED_AND_WHITESPACE + + if len(lex.data) > lex.p+1 && lex.data[lex.p+1] != '$' && lex.data[lex.p+1] != '{' { + lex.cs = 495 + } + { + (lex.p)++ + goto _out + } + } + } + + goto _again + tr692: + lex.cs = 477 +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) +//line scanner/scanner.rl:409 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(token) + tok = T_ENCAPSED_AND_WHITESPACE + + if len(lex.data) > lex.p+1 && lex.data[lex.p+1] != '$' && lex.data[lex.p+1] != '{' { + lex.cs = 495 + } + { + (lex.p)++ + goto _out + } + } + goto _again + tr696: + lex.cs = 477 +//line scanner/scanner.rl:409 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(token) + tok = T_ENCAPSED_AND_WHITESPACE + + if len(lex.data) > lex.p+1 && lex.data[lex.p+1] != '$' && lex.data[lex.p+1] != '{' { + lex.cs = 495 + } + { + (lex.p)++ + goto _out + } + } + goto _again st477: +//line NONE:1 + lex.ts = 0 + if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof477 } st_case_477: - _widec = int16(lex.data[(lex.p)]) - switch { - case lex.data[(lex.p)] < 11: - switch { - case lex.data[(lex.p)] > 9: - if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { - _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { - _widec += 256 - } - } - default: - _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { - _widec += 256 - } - } - case lex.data[(lex.p)] > 12: - switch { - case lex.data[(lex.p)] > 13: - if 14 <= lex.data[(lex.p)] { - _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { - _widec += 256 - } - } - case lex.data[(lex.p)] >= 13: - _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { - _widec += 256 - } - } - default: - _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { - _widec += 256 - } - } - switch _widec { - case 1403: - goto tr683 - case 1546: - goto st476 - case 1659: - goto tr688 - } - if 1536 <= _widec && _widec <= 1791 { - goto tr678 - } - goto tr682 - st478: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof478 - } - st_case_478: +//line NONE:1 + lex.ts = (lex.p) + +//line scanner/scanner.go:16322 _widec = int16(lex.data[(lex.p)]) switch { case lex.data[(lex.p)] < 11: @@ -17751,288 +17584,193 @@ func (lex *Lexer) Lex(lval Lval) int { } switch _widec { case 1316: - goto tr140 + goto st478 + case 1403: + goto st100 case 1546: - goto st476 + goto st480 case 1572: - goto tr690 + goto st481 + case 1659: + goto st482 } if 1536 <= _widec && _widec <= 1791 { - goto tr678 - } - goto tr689 - tr142: -//line scanner/scanner.rl:411 - lex.te = (lex.p) + 1 - { - lex.ungetCnt(1) - lex.setTokenPosition(token) - tok = T_CURLY_OPEN - lex.call(479, 117) - goto _out - } - goto st479 - tr692: - lex.cs = 479 -//line scanner/scanner.rl:414 - lex.te = (lex.p) + 1 - { - lex.setTokenPosition(token) - tok = TokenID(int('`')) - lex.cs = 117 - { - (lex.p)++ - goto _out - } - } - goto _again - tr699: -//line scanner/scanner.rl:413 - lex.te = (lex.p) - (lex.p)-- - { - lex.ungetCnt(1) - { - lex.growCallStack() - { - lex.stack[lex.top] = 479 - lex.top++ - goto st493 - } - } - } - goto st479 - tr700: -//line scanner/scanner.rl:412 - lex.te = (lex.p) + 1 - { - lex.setTokenPosition(token) - tok = T_DOLLAR_OPEN_CURLY_BRACES - lex.call(479, 508) - goto _out - } - goto st479 - tr701: - lex.cs = 479 -//line NONE:1 - switch lex.act { - case 149: - { - (lex.p) = (lex.te) - 1 - lex.ungetCnt(1) - lex.setTokenPosition(token) - tok = T_CURLY_OPEN - lex.call(479, 117) - goto _out - } - case 150: - { - (lex.p) = (lex.te) - 1 - lex.setTokenPosition(token) - tok = T_DOLLAR_OPEN_CURLY_BRACES - lex.call(479, 508) - goto _out - } - case 152: - { - (lex.p) = (lex.te) - 1 - lex.setTokenPosition(token) - tok = TokenID(int('`')) - lex.cs = 117 - { - (lex.p)++ - goto _out - } - } - case 153: - { - (lex.p) = (lex.te) - 1 - - lex.setTokenPosition(token) - tok = T_ENCAPSED_AND_WHITESPACE - { - (lex.p)++ - goto _out - } - } - } - - goto _again - tr702: -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) -//line scanner/scanner.rl:415 - lex.te = (lex.p) - (lex.p)-- - { - lex.setTokenPosition(token) - tok = T_ENCAPSED_AND_WHITESPACE - { - (lex.p)++ - lex.cs = 479 - goto _out - } - } - goto st479 - tr706: -//line scanner/scanner.rl:415 - lex.te = (lex.p) - (lex.p)-- - { - lex.setTokenPosition(token) - tok = T_ENCAPSED_AND_WHITESPACE - { - (lex.p)++ - lex.cs = 479 - goto _out - } - } - goto st479 - st479: -//line NONE:1 - lex.ts = 0 - - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof479 - } - st_case_479: -//line NONE:1 - lex.ts = (lex.p) - -//line scanner/scanner.go:16618 - _widec = int16(lex.data[(lex.p)]) - switch { - case lex.data[(lex.p)] < 11: - switch { - case lex.data[(lex.p)] > 9: - if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { - _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('`') && lex.isNotStringVar() { - _widec += 256 - } - } - default: - _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('`') && lex.isNotStringVar() { - _widec += 256 - } - } - case lex.data[(lex.p)] > 12: - switch { - case lex.data[(lex.p)] > 13: - if 14 <= lex.data[(lex.p)] { - _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('`') && lex.isNotStringVar() { - _widec += 256 - } - } - case lex.data[(lex.p)] >= 13: - _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('`') && lex.isNotStringVar() { - _widec += 256 - } - } - default: - _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('`') && lex.isNotStringVar() { - _widec += 256 - } - } - switch _widec { - case 1828: - goto st480 - case 1888: - goto tr692 - case 1915: - goto st100 - case 2058: - goto st482 - case 2084: - goto st483 - case 2144: - goto tr697 - case 2171: - goto st484 - } - if 2048 <= _widec && _widec <= 2303 { - goto tr694 + goto tr685 } goto st0 - st480: + st478: if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof480 + goto _test_eof478 } - st_case_480: + st_case_478: if lex.data[(lex.p)] == 123 { - goto tr700 + goto tr690 } - goto tr699 + goto tr689 st100: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof100 } st_case_100: if lex.data[(lex.p)] == 36 { - goto tr142 + goto tr143 } goto st0 - tr694: + tr685: //line NONE:1 lex.te = (lex.p) + 1 -//line scanner/scanner.rl:415 - lex.act = 153 - goto st481 - tr697: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:414 - lex.act = 152 - goto st481 - tr703: +//line scanner/scanner.rl:409 + lex.act = 150 + goto st479 + tr693: //line NONE:1 lex.te = (lex.p) + 1 //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) -//line scanner/scanner.rl:415 - lex.act = 153 - goto st481 - tr705: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:412 +//line scanner/scanner.rl:409 lex.act = 150 - goto st481 - tr707: + goto st479 + tr695: //line NONE:1 lex.te = (lex.p) + 1 -//line scanner/scanner.rl:411 - lex.act = 149 - goto st481 +//line scanner/scanner.rl:407 + lex.act = 148 + goto st479 + tr697: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:406 + lex.act = 147 + goto st479 + st479: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof479 + } + st_case_479: +//line scanner/scanner.go:16430 + _widec = int16(lex.data[(lex.p)]) + switch { + case lex.data[(lex.p)] < 11: + switch { + case lex.data[(lex.p)] > 9: + if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] > 12: + switch { + case lex.data[(lex.p)] > 13: + if 14 <= lex.data[(lex.p)] { + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] >= 13: + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + if _widec == 1546 { + goto st480 + } + if 1536 <= _widec && _widec <= 1791 { + goto tr685 + } + goto tr691 + tr694: +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) + goto st480 + st480: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof480 + } + st_case_480: +//line scanner/scanner.go:16485 + _widec = int16(lex.data[(lex.p)]) + switch { + case lex.data[(lex.p)] < 11: + switch { + case lex.data[(lex.p)] > 9: + if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] > 12: + switch { + case lex.data[(lex.p)] > 13: + if 14 <= lex.data[(lex.p)] { + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] >= 13: + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + if _widec == 1546 { + goto tr694 + } + if 1536 <= _widec && _widec <= 1791 { + goto tr693 + } + goto tr692 st481: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof481 } st_case_481: -//line scanner/scanner.go:16737 _widec = int16(lex.data[(lex.p)]) switch { case lex.data[(lex.p)] < 11: switch { case lex.data[(lex.p)] > 9: if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { - _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { _widec += 256 } } default: - _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { _widec += 256 } } @@ -18040,54 +17778,54 @@ func (lex *Lexer) Lex(lval Lval) int { switch { case lex.data[(lex.p)] > 13: if 14 <= lex.data[(lex.p)] { - _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { _widec += 256 } } case lex.data[(lex.p)] >= 13: - _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { _widec += 256 } } default: - _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { _widec += 256 } } - if _widec == 2058 { - goto st482 + switch _widec { + case 1403: + goto tr690 + case 1546: + goto st480 + case 1659: + goto tr695 } - if 2048 <= _widec && _widec <= 2303 { - goto tr694 + if 1536 <= _widec && _widec <= 1791 { + goto tr685 } - goto tr701 - tr704: -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) - goto st482 + goto tr689 st482: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof482 } st_case_482: -//line scanner/scanner.go:16792 _widec = int16(lex.data[(lex.p)]) switch { case lex.data[(lex.p)] < 11: switch { case lex.data[(lex.p)] > 9: if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { - _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { _widec += 256 } } default: - _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { _widec += 256 } } @@ -18095,90 +17833,174 @@ func (lex *Lexer) Lex(lval Lval) int { switch { case lex.data[(lex.p)] > 13: if 14 <= lex.data[(lex.p)] { - _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { _widec += 256 } } case lex.data[(lex.p)] >= 13: - _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { _widec += 256 } } default: - _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('`') && lex.isNotStringVar() { - _widec += 256 - } - } - if _widec == 2058 { - goto tr704 - } - if 2048 <= _widec && _widec <= 2303 { - goto tr703 - } - goto tr702 - st483: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof483 - } - st_case_483: - _widec = int16(lex.data[(lex.p)]) - switch { - case lex.data[(lex.p)] < 11: - switch { - case lex.data[(lex.p)] > 9: - if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { - _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('`') && lex.isNotStringVar() { - _widec += 256 - } - } - default: - _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('`') && lex.isNotStringVar() { - _widec += 256 - } - } - case lex.data[(lex.p)] > 12: - switch { - case lex.data[(lex.p)] > 13: - if 14 <= lex.data[(lex.p)] { - _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('`') && lex.isNotStringVar() { - _widec += 256 - } - } - case lex.data[(lex.p)] >= 13: - _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('`') && lex.isNotStringVar() { - _widec += 256 - } - } - default: - _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { _widec += 256 } } switch _widec { - case 1915: - goto tr700 - case 2058: - goto st482 - case 2171: - goto tr705 + case 1316: + goto tr143 + case 1546: + goto st480 + case 1572: + goto tr697 } - if 2048 <= _widec && _widec <= 2303 { - goto tr694 + if 1536 <= _widec && _widec <= 1791 { + goto tr685 } - goto tr699 - st484: + goto tr696 + tr145: +//line scanner/scanner.rl:421 + lex.te = (lex.p) + 1 + { + lex.ungetCnt(1) + lex.setTokenPosition(token) + tok = T_CURLY_OPEN + lex.call(483, 121) + goto _out + } + goto st483 + tr699: + lex.cs = 483 +//line scanner/scanner.rl:424 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(token) + tok = TokenID(int('`')) + lex.cs = 121 + { + (lex.p)++ + goto _out + } + } + goto _again + tr706: +//line scanner/scanner.rl:423 + lex.te = (lex.p) + (lex.p)-- + { + lex.ungetCnt(1) + { + lex.growCallStack() + { + lex.stack[lex.top] = 483 + lex.top++ + goto st497 + } + } + } + goto st483 + tr707: +//line scanner/scanner.rl:422 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(token) + tok = T_DOLLAR_OPEN_CURLY_BRACES + lex.call(483, 512) + goto _out + } + goto st483 + tr708: + lex.cs = 483 +//line NONE:1 + switch lex.act { + case 151: + { + (lex.p) = (lex.te) - 1 + lex.ungetCnt(1) + lex.setTokenPosition(token) + tok = T_CURLY_OPEN + lex.call(483, 121) + goto _out + } + case 152: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(token) + tok = T_DOLLAR_OPEN_CURLY_BRACES + lex.call(483, 512) + goto _out + } + case 154: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(token) + tok = TokenID(int('`')) + lex.cs = 121 + { + (lex.p)++ + goto _out + } + } + case 155: + { + (lex.p) = (lex.te) - 1 + + lex.setTokenPosition(token) + tok = T_ENCAPSED_AND_WHITESPACE + { + (lex.p)++ + goto _out + } + } + } + + goto _again + tr709: +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) +//line scanner/scanner.rl:425 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(token) + tok = T_ENCAPSED_AND_WHITESPACE + { + (lex.p)++ + lex.cs = 483 + goto _out + } + } + goto st483 + tr713: +//line scanner/scanner.rl:425 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(token) + tok = T_ENCAPSED_AND_WHITESPACE + { + (lex.p)++ + lex.cs = 483 + goto _out + } + } + goto st483 + st483: +//line NONE:1 + lex.ts = 0 + if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof484 + goto _test_eof483 } - st_case_484: + st_case_483: +//line NONE:1 + lex.ts = (lex.p) + +//line scanner/scanner.go:16719 _widec = int16(lex.data[(lex.p)]) switch { case lex.data[(lex.p)] < 11: @@ -18219,43 +18041,322 @@ func (lex *Lexer) Lex(lval Lval) int { } switch _widec { case 1828: - goto tr142 + goto st484 + case 1888: + goto tr699 + case 1915: + goto st101 case 2058: - goto st482 + goto st486 case 2084: - goto tr707 + goto st487 + case 2144: + goto tr704 + case 2171: + goto st488 } if 2048 <= _widec && _widec <= 2303 { - goto tr694 + goto tr701 + } + goto st0 + st484: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof484 + } + st_case_484: + if lex.data[(lex.p)] == 123 { + goto tr707 } goto tr706 - tr143: -//line scanner/scanner.rl:423 + st101: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof101 + } + st_case_101: + if lex.data[(lex.p)] == 36 { + goto tr145 + } + goto st0 + tr701: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:425 + lex.act = 155 + goto st485 + tr704: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:424 + lex.act = 154 + goto st485 + tr710: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) +//line scanner/scanner.rl:425 + lex.act = 155 + goto st485 + tr712: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:422 + lex.act = 152 + goto st485 + tr714: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:421 + lex.act = 151 + goto st485 + st485: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof485 + } + st_case_485: +//line scanner/scanner.go:16838 + _widec = int16(lex.data[(lex.p)]) + switch { + case lex.data[(lex.p)] < 11: + switch { + case lex.data[(lex.p)] > 9: + if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] > 12: + switch { + case lex.data[(lex.p)] > 13: + if 14 <= lex.data[(lex.p)] { + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] >= 13: + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + if _widec == 2058 { + goto st486 + } + if 2048 <= _widec && _widec <= 2303 { + goto tr701 + } + goto tr708 + tr711: +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) + goto st486 + st486: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof486 + } + st_case_486: +//line scanner/scanner.go:16893 + _widec = int16(lex.data[(lex.p)]) + switch { + case lex.data[(lex.p)] < 11: + switch { + case lex.data[(lex.p)] > 9: + if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] > 12: + switch { + case lex.data[(lex.p)] > 13: + if 14 <= lex.data[(lex.p)] { + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] >= 13: + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + if _widec == 2058 { + goto tr711 + } + if 2048 <= _widec && _widec <= 2303 { + goto tr710 + } + goto tr709 + st487: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof487 + } + st_case_487: + _widec = int16(lex.data[(lex.p)]) + switch { + case lex.data[(lex.p)] < 11: + switch { + case lex.data[(lex.p)] > 9: + if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] > 12: + switch { + case lex.data[(lex.p)] > 13: + if 14 <= lex.data[(lex.p)] { + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] >= 13: + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + switch _widec { + case 1915: + goto tr707 + case 2058: + goto st486 + case 2171: + goto tr712 + } + if 2048 <= _widec && _widec <= 2303 { + goto tr701 + } + goto tr706 + st488: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof488 + } + st_case_488: + _widec = int16(lex.data[(lex.p)]) + switch { + case lex.data[(lex.p)] < 11: + switch { + case lex.data[(lex.p)] > 9: + if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] > 12: + switch { + case lex.data[(lex.p)] > 13: + if 14 <= lex.data[(lex.p)] { + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] >= 13: + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + switch _widec { + case 1828: + goto tr145 + case 2058: + goto st486 + case 2084: + goto tr714 + } + if 2048 <= _widec && _widec <= 2303 { + goto tr701 + } + goto tr713 + tr146: +//line scanner/scanner.rl:433 lex.te = (lex.p) + 1 { lex.ungetCnt(1) lex.setTokenPosition(token) tok = T_CURLY_OPEN - lex.call(485, 117) + lex.call(489, 121) goto _out } - goto st485 - tr708: - lex.cs = 485 -//line scanner/scanner.rl:426 + goto st489 + tr715: + lex.cs = 489 +//line scanner/scanner.rl:436 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = TokenID(int('"')) - lex.cs = 117 + lex.cs = 121 { (lex.p)++ goto _out } } goto _again - tr716: -//line scanner/scanner.rl:425 + tr723: +//line scanner/scanner.rl:435 lex.te = (lex.p) (lex.p)-- { @@ -18263,56 +18364,56 @@ func (lex *Lexer) Lex(lval Lval) int { { lex.growCallStack() { - lex.stack[lex.top] = 485 + lex.stack[lex.top] = 489 lex.top++ - goto st493 + goto st497 } } } - goto st485 - tr717: -//line scanner/scanner.rl:424 + goto st489 + tr724: +//line scanner/scanner.rl:434 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = T_DOLLAR_OPEN_CURLY_BRACES - lex.call(485, 508) + lex.call(489, 512) goto _out } - goto st485 - tr718: - lex.cs = 485 + goto st489 + tr725: + lex.cs = 489 //line NONE:1 switch lex.act { - case 154: + case 156: { (lex.p) = (lex.te) - 1 lex.ungetCnt(1) lex.setTokenPosition(token) tok = T_CURLY_OPEN - lex.call(485, 117) - goto _out - } - case 155: - { - (lex.p) = (lex.te) - 1 - lex.setTokenPosition(token) - tok = T_DOLLAR_OPEN_CURLY_BRACES - lex.call(485, 508) + lex.call(489, 121) goto _out } case 157: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(token) + tok = T_DOLLAR_OPEN_CURLY_BRACES + lex.call(489, 512) + goto _out + } + case 159: { (lex.p) = (lex.te) - 1 lex.setTokenPosition(token) tok = TokenID(int('"')) - lex.cs = 117 + lex.cs = 121 { (lex.p)++ goto _out } } - case 158: + case 160: { (lex.p) = (lex.te) - 1 @@ -18326,10 +18427,10 @@ func (lex *Lexer) Lex(lval Lval) int { } goto _again - tr719: + tr726: //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) -//line scanner/scanner.rl:427 +//line scanner/scanner.rl:437 lex.te = (lex.p) (lex.p)-- { @@ -18337,13 +18438,13 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_ENCAPSED_AND_WHITESPACE { (lex.p)++ - lex.cs = 485 + lex.cs = 489 goto _out } } - goto st485 - tr723: -//line scanner/scanner.rl:427 + goto st489 + tr730: +//line scanner/scanner.rl:437 lex.te = (lex.p) (lex.p)-- { @@ -18351,23 +18452,23 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_ENCAPSED_AND_WHITESPACE { (lex.p)++ - lex.cs = 485 + lex.cs = 489 goto _out } } - goto st485 - st485: + goto st489 + st489: //line NONE:1 lex.ts = 0 if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof485 + goto _test_eof489 } - st_case_485: + st_case_489: //line NONE:1 lex.ts = (lex.p) -//line scanner/scanner.go:17026 +//line scanner/scanner.go:17127 _widec = int16(lex.data[(lex.p)]) switch { case lex.data[(lex.p)] < 11: @@ -18408,245 +18509,245 @@ func (lex *Lexer) Lex(lval Lval) int { } switch _widec { case 2338: - goto tr708 + goto tr715 case 2340: - goto st486 - case 2427: - goto st101 - case 2570: - goto st488 - case 2594: - goto tr713 - case 2596: - goto st489 - case 2683: goto st490 - } - if 2560 <= _widec && _widec <= 2815 { - goto tr711 - } - goto st0 - st486: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof486 - } - st_case_486: - if lex.data[(lex.p)] == 123 { - goto tr717 - } - goto tr716 - st101: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof101 - } - st_case_101: - if lex.data[(lex.p)] == 36 { - goto tr143 - } - goto st0 - tr711: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:427 - lex.act = 158 - goto st487 - tr713: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:426 - lex.act = 157 - goto st487 - tr720: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) -//line scanner/scanner.rl:427 - lex.act = 158 - goto st487 - tr722: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:424 - lex.act = 155 - goto st487 - tr724: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:423 - lex.act = 154 - goto st487 - st487: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof487 - } - st_case_487: -//line scanner/scanner.go:17145 - _widec = int16(lex.data[(lex.p)]) - switch { - case lex.data[(lex.p)] < 11: - switch { - case lex.data[(lex.p)] > 9: - if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { - _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('"') && lex.isNotStringVar() { - _widec += 256 - } - } - default: - _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('"') && lex.isNotStringVar() { - _widec += 256 - } - } - case lex.data[(lex.p)] > 12: - switch { - case lex.data[(lex.p)] > 13: - if 14 <= lex.data[(lex.p)] { - _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('"') && lex.isNotStringVar() { - _widec += 256 - } - } - case lex.data[(lex.p)] >= 13: - _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('"') && lex.isNotStringVar() { - _widec += 256 - } - } - default: - _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('"') && lex.isNotStringVar() { - _widec += 256 - } - } - if _widec == 2570 { - goto st488 - } - if 2560 <= _widec && _widec <= 2815 { - goto tr711 - } - goto tr718 - tr721: -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) - goto st488 - st488: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof488 - } - st_case_488: -//line scanner/scanner.go:17200 - _widec = int16(lex.data[(lex.p)]) - switch { - case lex.data[(lex.p)] < 11: - switch { - case lex.data[(lex.p)] > 9: - if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { - _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('"') && lex.isNotStringVar() { - _widec += 256 - } - } - default: - _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('"') && lex.isNotStringVar() { - _widec += 256 - } - } - case lex.data[(lex.p)] > 12: - switch { - case lex.data[(lex.p)] > 13: - if 14 <= lex.data[(lex.p)] { - _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('"') && lex.isNotStringVar() { - _widec += 256 - } - } - case lex.data[(lex.p)] >= 13: - _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('"') && lex.isNotStringVar() { - _widec += 256 - } - } - default: - _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('"') && lex.isNotStringVar() { - _widec += 256 - } - } - if _widec == 2570 { - goto tr721 - } - if 2560 <= _widec && _widec <= 2815 { - goto tr720 - } - goto tr719 - st489: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof489 - } - st_case_489: - _widec = int16(lex.data[(lex.p)]) - switch { - case lex.data[(lex.p)] < 11: - switch { - case lex.data[(lex.p)] > 9: - if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { - _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('"') && lex.isNotStringVar() { - _widec += 256 - } - } - default: - _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('"') && lex.isNotStringVar() { - _widec += 256 - } - } - case lex.data[(lex.p)] > 12: - switch { - case lex.data[(lex.p)] > 13: - if 14 <= lex.data[(lex.p)] { - _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('"') && lex.isNotStringVar() { - _widec += 256 - } - } - case lex.data[(lex.p)] >= 13: - _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('"') && lex.isNotStringVar() { - _widec += 256 - } - } - default: - _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) - if lex.isNotStringEnd('"') && lex.isNotStringVar() { - _widec += 256 - } - } - switch _widec { case 2427: - goto tr717 + goto st102 case 2570: - goto st488 + goto st492 + case 2594: + goto tr720 + case 2596: + goto st493 case 2683: - goto tr722 + goto st494 } if 2560 <= _widec && _widec <= 2815 { - goto tr711 + goto tr718 } - goto tr716 + goto st0 st490: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof490 } st_case_490: + if lex.data[(lex.p)] == 123 { + goto tr724 + } + goto tr723 + st102: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof102 + } + st_case_102: + if lex.data[(lex.p)] == 36 { + goto tr146 + } + goto st0 + tr718: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:437 + lex.act = 160 + goto st491 + tr720: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:436 + lex.act = 159 + goto st491 + tr727: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) +//line scanner/scanner.rl:437 + lex.act = 160 + goto st491 + tr729: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:434 + lex.act = 157 + goto st491 + tr731: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:433 + lex.act = 156 + goto st491 + st491: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof491 + } + st_case_491: +//line scanner/scanner.go:17246 + _widec = int16(lex.data[(lex.p)]) + switch { + case lex.data[(lex.p)] < 11: + switch { + case lex.data[(lex.p)] > 9: + if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { + _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('"') && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('"') && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] > 12: + switch { + case lex.data[(lex.p)] > 13: + if 14 <= lex.data[(lex.p)] { + _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('"') && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] >= 13: + _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('"') && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('"') && lex.isNotStringVar() { + _widec += 256 + } + } + if _widec == 2570 { + goto st492 + } + if 2560 <= _widec && _widec <= 2815 { + goto tr718 + } + goto tr725 + tr728: +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) + goto st492 + st492: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof492 + } + st_case_492: +//line scanner/scanner.go:17301 + _widec = int16(lex.data[(lex.p)]) + switch { + case lex.data[(lex.p)] < 11: + switch { + case lex.data[(lex.p)] > 9: + if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { + _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('"') && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('"') && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] > 12: + switch { + case lex.data[(lex.p)] > 13: + if 14 <= lex.data[(lex.p)] { + _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('"') && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] >= 13: + _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('"') && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('"') && lex.isNotStringVar() { + _widec += 256 + } + } + if _widec == 2570 { + goto tr728 + } + if 2560 <= _widec && _widec <= 2815 { + goto tr727 + } + goto tr726 + st493: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof493 + } + st_case_493: + _widec = int16(lex.data[(lex.p)]) + switch { + case lex.data[(lex.p)] < 11: + switch { + case lex.data[(lex.p)] > 9: + if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { + _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('"') && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('"') && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] > 12: + switch { + case lex.data[(lex.p)] > 13: + if 14 <= lex.data[(lex.p)] { + _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('"') && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] >= 13: + _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('"') && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 2304 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('"') && lex.isNotStringVar() { + _widec += 256 + } + } + switch _widec { + case 2427: + goto tr724 + case 2570: + goto st492 + case 2683: + goto tr729 + } + if 2560 <= _widec && _widec <= 2815 { + goto tr718 + } + goto tr723 + st494: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof494 + } + st_case_494: _widec = int16(lex.data[(lex.p)]) switch { case lex.data[(lex.p)] < 11: @@ -18687,43 +18788,43 @@ func (lex *Lexer) Lex(lval Lval) int { } switch _widec { case 2340: - goto tr143 + goto tr146 case 2570: - goto st488 + goto st492 case 2596: - goto tr724 + goto tr731 } if 2560 <= _widec && _widec <= 2815 { - goto tr711 + goto tr718 } - goto tr723 - tr726: - lex.cs = 491 -//line scanner/scanner.rl:435 + goto tr730 + tr733: + lex.cs = 495 +//line scanner/scanner.rl:445 lex.te = (lex.p) (lex.p)-- { lex.setTokenPosition(token) tok = T_END_HEREDOC - lex.cs = 117 + lex.cs = 121 { (lex.p)++ goto _out } } goto _again - st491: + st495: //line NONE:1 lex.ts = 0 if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof491 + goto _test_eof495 } - st_case_491: + st_case_495: //line NONE:1 lex.ts = (lex.p) -//line scanner/scanner.go:17379 +//line scanner/scanner.go:17480 if lex.data[(lex.p)] == 96 { goto st0 } @@ -18739,35 +18840,35 @@ func (lex *Lexer) Lex(lval Lval) int { default: goto st0 } - goto st492 - st492: + goto st496 + st496: if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof492 + goto _test_eof496 } - st_case_492: + st_case_496: if lex.data[(lex.p)] == 96 { - goto tr726 + goto tr733 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr726 + goto tr733 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr726 + goto tr733 } case lex.data[(lex.p)] >= 91: - goto tr726 + goto tr733 } default: - goto tr726 + goto tr733 } - goto st492 - tr144: -//line scanner/scanner.rl:454 + goto st496 + tr147: +//line scanner/scanner.rl:464 (lex.p) = (lex.te) - 1 { lex.ungetCnt(1) @@ -18777,9 +18878,9 @@ func (lex *Lexer) Lex(lval Lval) int { goto _again } } - goto st493 - tr145: -//line scanner/scanner.rl:451 + goto st497 + tr148: +//line scanner/scanner.rl:461 lex.te = (lex.p) + 1 { lex.ungetCnt(1) @@ -18787,13 +18888,13 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_OBJECT_OPERATOR { (lex.p)++ - lex.cs = 493 + lex.cs = 497 goto _out } } - goto st493 - tr727: -//line scanner/scanner.rl:454 + goto st497 + tr734: +//line scanner/scanner.rl:464 lex.te = (lex.p) + 1 { lex.ungetCnt(1) @@ -18803,19 +18904,19 @@ func (lex *Lexer) Lex(lval Lval) int { goto _again } } - goto st493 - tr731: -//line scanner/scanner.rl:453 + goto st497 + tr738: +//line scanner/scanner.rl:463 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = TokenID(int('[')) - lex.call(493, 498) + lex.call(497, 502) goto _out } - goto st493 - tr732: -//line scanner/scanner.rl:454 + goto st497 + tr739: +//line scanner/scanner.rl:464 lex.te = (lex.p) (lex.p)-- { @@ -18826,9 +18927,9 @@ func (lex *Lexer) Lex(lval Lval) int { goto _again } } - goto st493 - tr734: -//line scanner/scanner.rl:450 + goto st497 + tr741: +//line scanner/scanner.rl:460 lex.te = (lex.p) (lex.p)-- { @@ -18836,13 +18937,13 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_VARIABLE { (lex.p)++ - lex.cs = 493 + lex.cs = 497 goto _out } } - goto st493 - tr736: -//line scanner/scanner.rl:452 + goto st497 + tr743: +//line scanner/scanner.rl:462 lex.te = (lex.p) (lex.p)-- { @@ -18850,178 +18951,178 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_STRING { (lex.p)++ - lex.cs = 493 + lex.cs = 497 goto _out } } - goto st493 - st493: + goto st497 + st497: //line NONE:1 lex.ts = 0 if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof493 + goto _test_eof497 } - st_case_493: + st_case_497: //line NONE:1 lex.ts = (lex.p) -//line scanner/scanner.go:17471 +//line scanner/scanner.go:17572 switch lex.data[(lex.p)] { case 36: - goto st494 + goto st498 case 45: - goto tr729 + goto tr736 case 91: - goto tr731 + goto tr738 case 96: - goto tr727 + goto tr734 } switch { case lex.data[(lex.p)] < 92: if lex.data[(lex.p)] <= 64 { - goto tr727 + goto tr734 } case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr727 + goto tr734 } default: - goto tr727 + goto tr734 } - goto st497 - st494: + goto st501 + st498: if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof494 + goto _test_eof498 } - st_case_494: + st_case_498: if lex.data[(lex.p)] == 96 { - goto tr732 + goto tr739 } switch { case lex.data[(lex.p)] < 91: if lex.data[(lex.p)] <= 64 { - goto tr732 + goto tr739 } case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr732 + goto tr739 } default: - goto tr732 + goto tr739 } - goto st495 - st495: + goto st499 + st499: if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof495 + goto _test_eof499 } - st_case_495: + st_case_499: if lex.data[(lex.p)] == 96 { - goto tr734 + goto tr741 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr734 + goto tr741 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr734 + goto tr741 } case lex.data[(lex.p)] >= 91: - goto tr734 + goto tr741 } default: - goto tr734 + goto tr741 } - goto st495 - tr729: + goto st499 + tr736: //line NONE:1 lex.te = (lex.p) + 1 - goto st496 - st496: + goto st500 + st500: if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof496 + goto _test_eof500 } - st_case_496: -//line scanner/scanner.go:17552 + st_case_500: +//line scanner/scanner.go:17653 if lex.data[(lex.p)] == 62 { - goto st102 + goto st103 } - goto tr732 - st102: + goto tr739 + st103: if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof102 + goto _test_eof103 } - st_case_102: + st_case_103: if lex.data[(lex.p)] == 96 { - goto tr144 + goto tr147 } switch { case lex.data[(lex.p)] < 91: if lex.data[(lex.p)] <= 64 { - goto tr144 + goto tr147 } case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr144 + goto tr147 } default: - goto tr144 + goto tr147 } - goto tr145 - st497: + goto tr148 + st501: if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof497 + goto _test_eof501 } - st_case_497: + st_case_501: if lex.data[(lex.p)] == 96 { - goto tr736 + goto tr743 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr736 + goto tr743 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr736 + goto tr743 } case lex.data[(lex.p)] >= 91: - goto tr736 + goto tr743 } default: - goto tr736 + goto tr743 } - goto st497 - tr146: -//line scanner/scanner.rl:458 + goto st501 + tr149: +//line scanner/scanner.rl:468 (lex.p) = (lex.te) - 1 { lex.setTokenPosition(token) tok = T_NUM_STRING { (lex.p)++ - lex.cs = 498 + lex.cs = 502 goto _out } } - goto st498 - tr737: -//line scanner/scanner.rl:464 + goto st502 + tr744: +//line scanner/scanner.rl:474 lex.te = (lex.p) + 1 { c := lex.data[lex.p] lex.Error(fmt.Sprintf("WARNING: Unexpected character in input: '%c' (ASCII=%d)", c, c)) } - goto st498 - tr738: -//line scanner/scanner.rl:461 + goto st502 + tr745: +//line scanner/scanner.rl:471 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) @@ -19029,22 +19130,22 @@ func (lex *Lexer) Lex(lval Lval) int { lex.ret(2) goto _out } - goto st498 - tr741: -//line scanner/scanner.rl:462 + goto st502 + tr748: +//line scanner/scanner.rl:472 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) tok = TokenID(int(lex.data[lex.ts])) { (lex.p)++ - lex.cs = 498 + lex.cs = 502 goto _out } } - goto st498 - tr745: -//line scanner/scanner.rl:463 + goto st502 + tr752: +//line scanner/scanner.rl:473 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) @@ -19052,11 +19153,11 @@ func (lex *Lexer) Lex(lval Lval) int { lex.ret(2) goto _out } - goto st498 - tr746: + goto st502 + tr753: //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) -//line scanner/scanner.rl:461 +//line scanner/scanner.rl:471 lex.te = (lex.p) (lex.p)-- { @@ -19065,18 +19166,18 @@ func (lex *Lexer) Lex(lval Lval) int { lex.ret(2) goto _out } - goto st498 - tr747: -//line scanner/scanner.rl:464 + goto st502 + tr754: +//line scanner/scanner.rl:474 lex.te = (lex.p) (lex.p)-- { c := lex.data[lex.p] lex.Error(fmt.Sprintf("WARNING: Unexpected character in input: '%c' (ASCII=%d)", c, c)) } - goto st498 - tr748: -//line scanner/scanner.rl:462 + goto st502 + tr755: +//line scanner/scanner.rl:472 lex.te = (lex.p) (lex.p)-- { @@ -19084,13 +19185,13 @@ func (lex *Lexer) Lex(lval Lval) int { tok = TokenID(int(lex.data[lex.ts])) { (lex.p)++ - lex.cs = 498 + lex.cs = 502 goto _out } } - goto st498 - tr750: -//line scanner/scanner.rl:459 + goto st502 + tr757: +//line scanner/scanner.rl:469 lex.te = (lex.p) (lex.p)-- { @@ -19098,13 +19199,13 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_VARIABLE { (lex.p)++ - lex.cs = 498 + lex.cs = 502 goto _out } } - goto st498 - tr751: -//line scanner/scanner.rl:458 + goto st502 + tr758: +//line scanner/scanner.rl:468 lex.te = (lex.p) (lex.p)-- { @@ -19112,13 +19213,13 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_NUM_STRING { (lex.p)++ - lex.cs = 498 + lex.cs = 502 goto _out } } - goto st498 - tr755: -//line scanner/scanner.rl:460 + goto st502 + tr762: +//line scanner/scanner.rl:470 lex.te = (lex.p) (lex.p)-- { @@ -19126,369 +19227,209 @@ func (lex *Lexer) Lex(lval Lval) int { tok = T_STRING { (lex.p)++ - lex.cs = 498 + lex.cs = 502 goto _out } } - goto st498 - st498: + goto st502 + st502: //line NONE:1 lex.ts = 0 if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof498 + goto _test_eof502 } - st_case_498: + st_case_502: //line NONE:1 lex.ts = (lex.p) -//line scanner/scanner.go:17684 +//line scanner/scanner.go:17785 switch lex.data[(lex.p)] { case 10: - goto st499 + goto st503 case 13: - goto st500 + goto st504 case 32: - goto tr738 - case 33: - goto tr741 - case 35: - goto tr738 - case 36: - goto st501 - case 39: - goto tr738 - case 48: - goto tr743 - case 92: - goto tr738 - case 93: goto tr745 + case 33: + goto tr748 + case 35: + goto tr745 + case 36: + goto st505 + case 39: + goto tr745 + case 48: + goto tr750 + case 92: + goto tr745 + case 93: + goto tr752 case 96: - goto tr737 + goto tr744 case 124: - goto tr741 + goto tr748 case 126: - goto tr741 + goto tr748 } switch { case lex.data[(lex.p)] < 37: switch { case lex.data[(lex.p)] < 9: if lex.data[(lex.p)] <= 8 { - goto tr737 + goto tr744 } case lex.data[(lex.p)] > 12: if 14 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 34 { - goto tr737 + goto tr744 } default: - goto tr738 + goto tr745 } case lex.data[(lex.p)] > 47: switch { case lex.data[(lex.p)] < 58: if 49 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { - goto tr147 + goto tr150 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr737 + goto tr744 } case lex.data[(lex.p)] >= 91: - goto tr741 + goto tr748 } default: - goto tr741 - } - default: - goto tr741 - } - goto st507 - st499: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof499 - } - st_case_499: - goto tr746 - st500: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof500 - } - st_case_500: - if lex.data[(lex.p)] == 10 { - goto st499 - } - goto tr747 - st501: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof501 - } - st_case_501: - if lex.data[(lex.p)] == 96 { - goto tr748 - } - switch { - case lex.data[(lex.p)] < 91: - if lex.data[(lex.p)] <= 64 { - goto tr748 - } - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { goto tr748 } default: goto tr748 } - goto st502 - st502: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof502 - } - st_case_502: - if lex.data[(lex.p)] == 96 { - goto tr750 - } - switch { - case lex.data[(lex.p)] < 58: - if lex.data[(lex.p)] <= 47 { - goto tr750 - } - case lex.data[(lex.p)] > 64: - switch { - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr750 - } - case lex.data[(lex.p)] >= 91: - goto tr750 - } - default: - goto tr750 - } - goto st502 - tr743: -//line NONE:1 - lex.te = (lex.p) + 1 - - goto st503 + goto st511 st503: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof503 } st_case_503: -//line scanner/scanner.go:17821 - switch lex.data[(lex.p)] { - case 95: - goto st103 - case 98: - goto st104 - case 120: - goto st105 - } - if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { - goto tr147 - } - goto tr751 - tr147: -//line NONE:1 - lex.te = (lex.p) + 1 - - goto st504 + goto tr753 st504: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof504 } st_case_504: -//line scanner/scanner.go:17844 - if lex.data[(lex.p)] == 95 { - goto st103 + if lex.data[(lex.p)] == 10 { + goto st503 } - if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { - goto tr147 - } - goto tr751 - st103: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof103 - } - st_case_103: - if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { - goto tr147 - } - goto tr146 - st104: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof104 - } - st_case_104: - if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 49 { - goto tr148 - } - goto tr146 - tr148: -//line NONE:1 - lex.te = (lex.p) + 1 - - goto st505 + goto tr754 st505: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof505 } st_case_505: -//line scanner/scanner.go:17880 - if lex.data[(lex.p)] == 95 { - goto st104 + if lex.data[(lex.p)] == 96 { + goto tr755 } - if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 49 { - goto tr148 - } - goto tr751 - st105: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof105 - } - st_case_105: switch { - case lex.data[(lex.p)] < 65: - if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { - goto tr149 + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto tr755 } - case lex.data[(lex.p)] > 70: - if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { - goto tr149 + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr755 } default: - goto tr149 + goto tr755 } - goto tr146 - tr149: -//line NONE:1 - lex.te = (lex.p) + 1 - goto st506 st506: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof506 } st_case_506: -//line scanner/scanner.go:17916 - if lex.data[(lex.p)] == 95 { - goto st105 - } - switch { - case lex.data[(lex.p)] < 65: - if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { - goto tr149 - } - case lex.data[(lex.p)] > 70: - if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { - goto tr149 - } - default: - goto tr149 - } - goto tr751 - st507: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof507 - } - st_case_507: if lex.data[(lex.p)] == 96 { - goto tr755 + goto tr757 } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr755 + goto tr757 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr755 + goto tr757 } case lex.data[(lex.p)] >= 91: - goto tr755 + goto tr757 } default: - goto tr755 + goto tr757 } - goto st507 - tr150: - lex.cs = 508 -//line scanner/scanner.rl:472 - (lex.p) = (lex.te) - 1 - { - lex.ungetCnt(1) - lex.cs = 117 - } - goto _again - tr152: - lex.cs = 508 -//line scanner/scanner.rl:471 - lex.te = (lex.p) + 1 - { - lex.ungetCnt(1) - lex.setTokenPosition(token) - tok = T_STRING_VARNAME - lex.cs = 117 - { - (lex.p)++ - goto _out - } - } - goto _again - tr756: - lex.cs = 508 -//line scanner/scanner.rl:472 - lex.te = (lex.p) + 1 - { - lex.ungetCnt(1) - lex.cs = 117 - } - goto _again - tr758: - lex.cs = 508 -//line scanner/scanner.rl:472 - lex.te = (lex.p) - (lex.p)-- - { - lex.ungetCnt(1) - lex.cs = 117 - } - goto _again - st508: + goto st506 + tr750: //line NONE:1 - lex.ts = 0 + lex.te = (lex.p) + 1 + goto st507 + st507: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof507 + } + st_case_507: +//line scanner/scanner.go:17922 + switch lex.data[(lex.p)] { + case 95: + goto st104 + case 98: + goto st105 + case 120: + goto st106 + } + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr150 + } + goto tr758 + tr150: +//line NONE:1 + lex.te = (lex.p) + 1 + + goto st508 + st508: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof508 } st_case_508: -//line NONE:1 - lex.ts = (lex.p) - -//line scanner/scanner.go:17995 - if lex.data[(lex.p)] == 96 { - goto tr756 +//line scanner/scanner.go:17945 + if lex.data[(lex.p)] == 95 { + goto st104 } - switch { - case lex.data[(lex.p)] < 91: - if lex.data[(lex.p)] <= 64 { - goto tr756 - } - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr756 - } - default: - goto tr756 + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr150 } - goto tr757 - tr757: + goto tr758 + st104: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof104 + } + st_case_104: + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr150 + } + goto tr149 + st105: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof105 + } + st_case_105: + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 49 { + goto tr151 + } + goto tr149 + tr151: //line NONE:1 lex.te = (lex.p) + 1 @@ -19498,88 +19439,103 @@ func (lex *Lexer) Lex(lval Lval) int { goto _test_eof509 } st_case_509: -//line scanner/scanner.go:18022 - switch lex.data[(lex.p)] { - case 91: - goto tr152 - case 96: - goto tr758 - case 125: - goto tr152 +//line scanner/scanner.go:17981 + if lex.data[(lex.p)] == 95 { + goto st105 } - switch { - case lex.data[(lex.p)] < 58: - if lex.data[(lex.p)] <= 47 { - goto tr758 - } - case lex.data[(lex.p)] > 64: - switch { - case lex.data[(lex.p)] > 94: - if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr758 - } - case lex.data[(lex.p)] >= 92: - goto tr758 - } - default: - goto tr758 + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 49 { + goto tr151 } - goto st106 + goto tr758 st106: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof106 } st_case_106: - switch lex.data[(lex.p)] { - case 91: + switch { + case lex.data[(lex.p)] < 65: + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr152 + } + case lex.data[(lex.p)] > 70: + if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { + goto tr152 + } + default: goto tr152 - case 96: - goto tr150 - case 125: + } + goto tr149 + tr152: +//line NONE:1 + lex.te = (lex.p) + 1 + + goto st510 + st510: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof510 + } + st_case_510: +//line scanner/scanner.go:18017 + if lex.data[(lex.p)] == 95 { + goto st106 + } + switch { + case lex.data[(lex.p)] < 65: + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr152 + } + case lex.data[(lex.p)] > 70: + if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { + goto tr152 + } + default: goto tr152 } + goto tr758 + st511: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof511 + } + st_case_511: + if lex.data[(lex.p)] == 96 { + goto tr762 + } switch { case lex.data[(lex.p)] < 58: if lex.data[(lex.p)] <= 47 { - goto tr150 + goto tr762 } case lex.data[(lex.p)] > 64: switch { case lex.data[(lex.p)] > 94: if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { - goto tr150 + goto tr762 } - case lex.data[(lex.p)] >= 92: - goto tr150 + case lex.data[(lex.p)] >= 91: + goto tr762 } default: - goto tr150 + goto tr762 } - goto st106 + goto st511 tr153: -//line scanner/scanner.rl:476 + lex.cs = 512 +//line scanner/scanner.rl:482 (lex.p) = (lex.te) - 1 { - lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te) + lex.ungetCnt(1) + lex.cs = 121 } - goto st510 - tr759: - lex.cs = 510 -//line scanner/scanner.rl:478 + goto _again + tr155: + lex.cs = 512 +//line scanner/scanner.rl:481 lex.te = (lex.p) + 1 { lex.ungetCnt(1) - lex.cs = 117 - } - goto _again - tr762: - lex.cs = 510 -//line scanner/scanner.rl:477 - lex.te = (lex.p) + 1 - { lex.setTokenPosition(token) - tok = TokenID(int('(')) - lex.cs = 514 + tok = T_STRING_VARNAME + lex.cs = 121 { (lex.p)++ goto _out @@ -19587,165 +19543,143 @@ func (lex *Lexer) Lex(lval Lval) int { } goto _again tr763: -//line scanner/scanner.rl:476 - lex.te = (lex.p) - (lex.p)-- + lex.cs = 512 +//line scanner/scanner.rl:482 + lex.te = (lex.p) + 1 { - lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te) + lex.ungetCnt(1) + lex.cs = 121 } - goto st510 + goto _again tr765: -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) -//line scanner/scanner.rl:476 - lex.te = (lex.p) - (lex.p)-- - { - lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te) - } - goto st510 - tr769: - lex.cs = 510 -//line scanner/scanner.rl:478 + lex.cs = 512 +//line scanner/scanner.rl:482 lex.te = (lex.p) (lex.p)-- { lex.ungetCnt(1) - lex.cs = 117 + lex.cs = 121 } goto _again - st510: + st512: //line NONE:1 lex.ts = 0 - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof510 - } - st_case_510: -//line NONE:1 - lex.ts = (lex.p) - -//line scanner/scanner.go:18129 - switch lex.data[(lex.p)] { - case 10: - goto tr154 - case 13: - goto st513 - case 32: - goto tr760 - case 40: - goto tr762 - } - if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto tr760 - } - goto tr759 - tr760: -//line NONE:1 - lex.te = (lex.p) + 1 - - goto st511 - tr766: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) - goto st511 - st511: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof511 - } - st_case_511: -//line scanner/scanner.go:18161 - switch lex.data[(lex.p)] { - case 10: - goto tr154 - case 13: - goto st107 - case 32: - goto tr760 - } - if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto tr760 - } - goto tr763 - tr154: -//line NONE:1 - lex.te = (lex.p) + 1 - - goto st512 - tr767: -//line NONE:1 - lex.te = (lex.p) + 1 - -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) - goto st512 - st512: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof512 } st_case_512: -//line scanner/scanner.go:18191 +//line NONE:1 + lex.ts = (lex.p) + +//line scanner/scanner.go:18096 + if lex.data[(lex.p)] == 96 { + goto tr763 + } + switch { + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto tr763 + } + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr763 + } + default: + goto tr763 + } + goto tr764 + tr764: +//line NONE:1 + lex.te = (lex.p) + 1 + + goto st513 + st513: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof513 + } + st_case_513: +//line scanner/scanner.go:18123 switch lex.data[(lex.p)] { - case 10: - goto tr767 - case 13: - goto tr768 - case 32: - goto tr766 + case 91: + goto tr155 + case 96: + goto tr765 + case 125: + goto tr155 } - if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto tr766 + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr765 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr765 + } + case lex.data[(lex.p)] >= 92: + goto tr765 + } + default: + goto tr765 } - goto tr765 - tr768: -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) goto st107 st107: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof107 } st_case_107: -//line scanner/scanner.go:18213 - if lex.data[(lex.p)] == 10 { - goto tr154 + switch lex.data[(lex.p)] { + case 91: + goto tr155 + case 96: + goto tr153 + case 125: + goto tr155 } - goto tr153 - st513: - if (lex.p)++; (lex.p) == (lex.pe) { - goto _test_eof513 + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr153 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr153 + } + case lex.data[(lex.p)] >= 92: + goto tr153 + } + default: + goto tr153 } - st_case_513: - if lex.data[(lex.p)] == 10 { - goto tr154 - } - goto tr769 - tr155: -//line scanner/scanner.rl:482 + goto st107 + tr156: +//line scanner/scanner.rl:486 (lex.p) = (lex.te) - 1 { lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te) } goto st514 - tr770: + tr766: lex.cs = 514 -//line scanner/scanner.rl:484 +//line scanner/scanner.rl:488 lex.te = (lex.p) + 1 { lex.ungetCnt(1) - lex.cs = 117 + lex.cs = 121 } goto _again - tr773: + tr769: lex.cs = 514 -//line scanner/scanner.rl:483 +//line scanner/scanner.rl:487 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) - tok = TokenID(int(')')) + tok = TokenID(int('(')) lex.cs = 518 { (lex.p)++ @@ -19753,8 +19687,18 @@ func (lex *Lexer) Lex(lval Lval) int { } } goto _again - tr774: -//line scanner/scanner.rl:482 + tr770: +//line scanner/scanner.rl:486 + lex.te = (lex.p) + (lex.p)-- + { + lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te) + } + goto st514 + tr772: +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) +//line scanner/scanner.rl:486 lex.te = (lex.p) (lex.p)-- { @@ -19762,23 +19706,13 @@ func (lex *Lexer) Lex(lval Lval) int { } goto st514 tr776: -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) -//line scanner/scanner.rl:482 - lex.te = (lex.p) - (lex.p)-- - { - lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te) - } - goto st514 - tr780: lex.cs = 514 -//line scanner/scanner.rl:484 +//line scanner/scanner.rl:488 lex.te = (lex.p) (lex.p)-- { lex.ungetCnt(1) - lex.cs = 117 + lex.cs = 121 } goto _again st514: @@ -19792,27 +19726,27 @@ func (lex *Lexer) Lex(lval Lval) int { //line NONE:1 lex.ts = (lex.p) -//line scanner/scanner.go:18276 +//line scanner/scanner.go:18230 switch lex.data[(lex.p)] { case 10: - goto tr156 + goto tr157 case 13: goto st517 case 32: - goto tr771 - case 41: - goto tr773 + goto tr767 + case 40: + goto tr769 } if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto tr771 + goto tr767 } - goto tr770 - tr771: + goto tr766 + tr767: //line NONE:1 lex.te = (lex.p) + 1 goto st515 - tr777: + tr773: //line NONE:1 lex.te = (lex.p) + 1 @@ -19824,25 +19758,25 @@ func (lex *Lexer) Lex(lval Lval) int { goto _test_eof515 } st_case_515: -//line scanner/scanner.go:18308 +//line scanner/scanner.go:18262 switch lex.data[(lex.p)] { case 10: - goto tr156 + goto tr157 case 13: goto st108 case 32: - goto tr771 + goto tr767 } if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto tr771 + goto tr767 } - goto tr774 - tr156: + goto tr770 + tr157: //line NONE:1 lex.te = (lex.p) + 1 goto st516 - tr778: + tr774: //line NONE:1 lex.te = (lex.p) + 1 @@ -19854,20 +19788,20 @@ func (lex *Lexer) Lex(lval Lval) int { goto _test_eof516 } st_case_516: -//line scanner/scanner.go:18338 +//line scanner/scanner.go:18292 switch lex.data[(lex.p)] { case 10: - goto tr778 + goto tr774 case 13: - goto tr779 + goto tr775 case 32: - goto tr777 + goto tr773 } if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto tr777 + goto tr773 } - goto tr776 - tr779: + goto tr772 + tr775: //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) goto st108 @@ -19876,43 +19810,43 @@ func (lex *Lexer) Lex(lval Lval) int { goto _test_eof108 } st_case_108: -//line scanner/scanner.go:18360 +//line scanner/scanner.go:18314 if lex.data[(lex.p)] == 10 { - goto tr156 + goto tr157 } - goto tr155 + goto tr156 st517: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof517 } st_case_517: if lex.data[(lex.p)] == 10 { - goto tr156 + goto tr157 } - goto tr780 - tr157: -//line scanner/scanner.rl:488 + goto tr776 + tr158: +//line scanner/scanner.rl:492 (lex.p) = (lex.te) - 1 { lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te) } goto st518 - tr781: + tr777: lex.cs = 518 -//line scanner/scanner.rl:490 +//line scanner/scanner.rl:494 lex.te = (lex.p) + 1 { lex.ungetCnt(1) - lex.cs = 117 + lex.cs = 121 } goto _again - tr784: + tr780: lex.cs = 518 -//line scanner/scanner.rl:489 +//line scanner/scanner.rl:493 lex.te = (lex.p) + 1 { lex.setTokenPosition(token) - tok = TokenID(int(';')) + tok = TokenID(int(')')) lex.cs = 522 { (lex.p)++ @@ -19920,8 +19854,18 @@ func (lex *Lexer) Lex(lval Lval) int { } } goto _again - tr785: -//line scanner/scanner.rl:488 + tr781: +//line scanner/scanner.rl:492 + lex.te = (lex.p) + (lex.p)-- + { + lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te) + } + goto st518 + tr783: +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) +//line scanner/scanner.rl:492 lex.te = (lex.p) (lex.p)-- { @@ -19929,23 +19873,13 @@ func (lex *Lexer) Lex(lval Lval) int { } goto st518 tr787: -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) -//line scanner/scanner.rl:488 - lex.te = (lex.p) - (lex.p)-- - { - lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te) - } - goto st518 - tr791: lex.cs = 518 -//line scanner/scanner.rl:490 +//line scanner/scanner.rl:494 lex.te = (lex.p) (lex.p)-- { lex.ungetCnt(1) - lex.cs = 117 + lex.cs = 121 } goto _again st518: @@ -19959,27 +19893,27 @@ func (lex *Lexer) Lex(lval Lval) int { //line NONE:1 lex.ts = (lex.p) -//line scanner/scanner.go:18423 +//line scanner/scanner.go:18377 switch lex.data[(lex.p)] { case 10: - goto tr158 + goto tr159 case 13: goto st521 case 32: - goto tr782 - case 59: - goto tr784 + goto tr778 + case 41: + goto tr780 } if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto tr782 + goto tr778 } - goto tr781 - tr782: + goto tr777 + tr778: //line NONE:1 lex.te = (lex.p) + 1 goto st519 - tr788: + tr784: //line NONE:1 lex.te = (lex.p) + 1 @@ -19991,25 +19925,25 @@ func (lex *Lexer) Lex(lval Lval) int { goto _test_eof519 } st_case_519: -//line scanner/scanner.go:18455 +//line scanner/scanner.go:18409 switch lex.data[(lex.p)] { case 10: - goto tr158 + goto tr159 case 13: goto st109 case 32: - goto tr782 + goto tr778 } if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto tr782 + goto tr778 } - goto tr785 - tr158: + goto tr781 + tr159: //line NONE:1 lex.te = (lex.p) + 1 goto st520 - tr789: + tr785: //line NONE:1 lex.te = (lex.p) + 1 @@ -20021,20 +19955,20 @@ func (lex *Lexer) Lex(lval Lval) int { goto _test_eof520 } st_case_520: -//line scanner/scanner.go:18485 +//line scanner/scanner.go:18439 switch lex.data[(lex.p)] { case 10: - goto tr789 + goto tr785 case 13: - goto tr790 + goto tr786 case 32: - goto tr788 + goto tr784 } if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { - goto tr788 + goto tr784 } - goto tr787 - tr790: + goto tr783 + tr786: //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) goto st109 @@ -20043,54 +19977,82 @@ func (lex *Lexer) Lex(lval Lval) int { goto _test_eof109 } st_case_109: -//line scanner/scanner.go:18507 +//line scanner/scanner.go:18461 if lex.data[(lex.p)] == 10 { - goto tr158 + goto tr159 } - goto tr157 + goto tr158 st521: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof521 } st_case_521: if lex.data[(lex.p)] == 10 { - goto tr158 + goto tr159 } - goto tr791 - tr794: -//line NONE:1 - switch lex.act { - case 0: - { - { - goto st0 - } - } - case 184: - { - (lex.p) = (lex.te) - 1 - lex.addFreeFloating(freefloating.TokenType, lex.ts, lex.te) - } + goto tr787 + tr160: +//line scanner/scanner.rl:498 + (lex.p) = (lex.te) - 1 + { + lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te) } - goto st522 - tr795: -//line scanner/scanner.rl:66 - lex.NewLines.Append(lex.p) -//line scanner/scanner.rl:494 + tr788: + lex.cs = 522 +//line scanner/scanner.rl:500 + lex.te = (lex.p) + 1 + { + lex.ungetCnt(1) + lex.cs = 121 + } + goto _again + tr791: + lex.cs = 522 +//line scanner/scanner.rl:499 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(token) + tok = TokenID(int(';')) + lex.cs = 526 + { + (lex.p)++ + goto _out + } + } + goto _again + tr792: +//line scanner/scanner.rl:498 lex.te = (lex.p) (lex.p)-- { - lex.addFreeFloating(freefloating.TokenType, lex.ts, lex.te) + lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te) } goto st522 + tr794: +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) +//line scanner/scanner.rl:498 + lex.te = (lex.p) + (lex.p)-- + { + lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te) + } + goto st522 + tr798: + lex.cs = 522 +//line scanner/scanner.rl:500 + lex.te = (lex.p) + (lex.p)-- + { + lex.ungetCnt(1) + lex.cs = 121 + } + goto _again st522: //line NONE:1 lex.ts = 0 -//line NONE:1 - lex.act = 0 - if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof522 } @@ -20098,38 +20060,60 @@ func (lex *Lexer) Lex(lval Lval) int { //line NONE:1 lex.ts = (lex.p) -//line scanner/scanner.go:18554 - if lex.data[(lex.p)] == 10 { - goto st524 +//line scanner/scanner.go:18524 + switch lex.data[(lex.p)] { + case 10: + goto tr161 + case 13: + goto st525 + case 32: + goto tr789 + case 59: + goto tr791 } - goto tr792 - tr792: + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr789 + } + goto tr788 + tr789: //line NONE:1 lex.te = (lex.p) + 1 -//line scanner/scanner.rl:494 - lex.act = 184 goto st523 - tr796: + tr795: //line NONE:1 lex.te = (lex.p) + 1 //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) -//line scanner/scanner.rl:494 - lex.act = 184 goto st523 st523: if (lex.p)++; (lex.p) == (lex.pe) { goto _test_eof523 } st_case_523: -//line scanner/scanner.go:18580 - if lex.data[(lex.p)] == 10 { - goto st524 +//line scanner/scanner.go:18556 + switch lex.data[(lex.p)] { + case 10: + goto tr161 + case 13: + goto st110 + case 32: + goto tr789 + } + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr789 } goto tr792 - tr797: + tr161: +//line NONE:1 + lex.te = (lex.p) + 1 + + goto st524 + tr796: +//line NONE:1 + lex.te = (lex.p) + 1 + //line scanner/scanner.rl:66 lex.NewLines.Append(lex.p) goto st524 @@ -20138,21 +20122,138 @@ func (lex *Lexer) Lex(lval Lval) int { goto _test_eof524 } st_case_524: -//line scanner/scanner.go:18594 - if lex.data[(lex.p)] == 10 { +//line scanner/scanner.go:18586 + switch lex.data[(lex.p)] { + case 10: + goto tr796 + case 13: goto tr797 + case 32: + goto tr795 } - goto tr796 + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr795 + } + goto tr794 + tr797: +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) + goto st110 + st110: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof110 + } + st_case_110: +//line scanner/scanner.go:18608 + if lex.data[(lex.p)] == 10 { + goto tr161 + } + goto tr160 + st525: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof525 + } + st_case_525: + if lex.data[(lex.p)] == 10 { + goto tr161 + } + goto tr798 + tr801: +//line NONE:1 + switch lex.act { + case 0: + { + { + goto st0 + } + } + case 186: + { + (lex.p) = (lex.te) - 1 + lex.addFreeFloating(freefloating.TokenType, lex.ts, lex.te) + } + } + + goto st526 + tr802: +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) +//line scanner/scanner.rl:504 + lex.te = (lex.p) + (lex.p)-- + { + lex.addFreeFloating(freefloating.TokenType, lex.ts, lex.te) + } + goto st526 + st526: +//line NONE:1 + lex.ts = 0 + +//line NONE:1 + lex.act = 0 + + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof526 + } + st_case_526: +//line NONE:1 + lex.ts = (lex.p) + +//line scanner/scanner.go:18655 + if lex.data[(lex.p)] == 10 { + goto st528 + } + goto tr799 + tr799: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:504 + lex.act = 186 + goto st527 + tr803: +//line NONE:1 + lex.te = (lex.p) + 1 + +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) +//line scanner/scanner.rl:504 + lex.act = 186 + goto st527 + st527: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof527 + } + st_case_527: +//line scanner/scanner.go:18681 + if lex.data[(lex.p)] == 10 { + goto st528 + } + goto tr799 + tr804: +//line scanner/scanner.rl:66 + lex.NewLines.Append(lex.p) + goto st528 + st528: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof528 + } + st_case_528: +//line scanner/scanner.go:18695 + if lex.data[(lex.p)] == 10 { + goto tr804 + } + goto tr803 st_out: - _test_eof110: - lex.cs = 110 - goto _test_eof _test_eof111: lex.cs = 111 goto _test_eof _test_eof112: lex.cs = 112 goto _test_eof + _test_eof1: + lex.cs = 1 + goto _test_eof _test_eof113: lex.cs = 113 goto _test_eof @@ -20162,21 +20263,9 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof115: lex.cs = 115 goto _test_eof - _test_eof1: - lex.cs = 1 - goto _test_eof - _test_eof2: - lex.cs = 2 - goto _test_eof - _test_eof3: - lex.cs = 3 - goto _test_eof _test_eof116: lex.cs = 116 goto _test_eof - _test_eof4: - lex.cs = 4 - goto _test_eof _test_eof117: lex.cs = 117 goto _test_eof @@ -20186,12 +20275,21 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof119: lex.cs = 119 goto _test_eof - _test_eof5: - lex.cs = 5 + _test_eof2: + lex.cs = 2 + goto _test_eof + _test_eof3: + lex.cs = 3 + goto _test_eof + _test_eof4: + lex.cs = 4 goto _test_eof _test_eof120: lex.cs = 120 goto _test_eof + _test_eof5: + lex.cs = 5 + goto _test_eof _test_eof121: lex.cs = 121 goto _test_eof @@ -20204,15 +20302,6 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof6: lex.cs = 6 goto _test_eof - _test_eof7: - lex.cs = 7 - goto _test_eof - _test_eof8: - lex.cs = 8 - goto _test_eof - _test_eof9: - lex.cs = 9 - goto _test_eof _test_eof124: lex.cs = 124 goto _test_eof @@ -20225,6 +20314,18 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof127: lex.cs = 127 goto _test_eof + _test_eof7: + lex.cs = 7 + goto _test_eof + _test_eof8: + lex.cs = 8 + goto _test_eof + _test_eof9: + lex.cs = 9 + goto _test_eof + _test_eof10: + lex.cs = 10 + goto _test_eof _test_eof128: lex.cs = 128 goto _test_eof @@ -20234,18 +20335,27 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof130: lex.cs = 130 goto _test_eof - _test_eof10: - lex.cs = 10 + _test_eof131: + lex.cs = 131 + goto _test_eof + _test_eof132: + lex.cs = 132 + goto _test_eof + _test_eof133: + lex.cs = 133 + goto _test_eof + _test_eof134: + lex.cs = 134 goto _test_eof _test_eof11: lex.cs = 11 goto _test_eof - _test_eof131: - lex.cs = 131 - goto _test_eof _test_eof12: lex.cs = 12 goto _test_eof + _test_eof135: + lex.cs = 135 + goto _test_eof _test_eof13: lex.cs = 13 goto _test_eof @@ -20405,72 +20515,54 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof65: lex.cs = 65 goto _test_eof - _test_eof132: - lex.cs = 132 - goto _test_eof - _test_eof133: - lex.cs = 133 - goto _test_eof - _test_eof134: - lex.cs = 134 - goto _test_eof - _test_eof135: - lex.cs = 135 + _test_eof66: + lex.cs = 66 goto _test_eof _test_eof136: lex.cs = 136 goto _test_eof - _test_eof66: - lex.cs = 66 - goto _test_eof _test_eof137: lex.cs = 137 goto _test_eof - _test_eof67: - lex.cs = 67 - goto _test_eof - _test_eof68: - lex.cs = 68 - goto _test_eof _test_eof138: lex.cs = 138 goto _test_eof - _test_eof69: - lex.cs = 69 - goto _test_eof _test_eof139: lex.cs = 139 goto _test_eof + _test_eof140: + lex.cs = 140 + goto _test_eof + _test_eof67: + lex.cs = 67 + goto _test_eof + _test_eof141: + lex.cs = 141 + goto _test_eof + _test_eof68: + lex.cs = 68 + goto _test_eof + _test_eof69: + lex.cs = 69 + goto _test_eof + _test_eof142: + lex.cs = 142 + goto _test_eof _test_eof70: lex.cs = 70 goto _test_eof + _test_eof143: + lex.cs = 143 + goto _test_eof _test_eof71: lex.cs = 71 goto _test_eof _test_eof72: lex.cs = 72 goto _test_eof - _test_eof140: - lex.cs = 140 - goto _test_eof - _test_eof141: - lex.cs = 141 - goto _test_eof - _test_eof142: - lex.cs = 142 - goto _test_eof _test_eof73: lex.cs = 73 goto _test_eof - _test_eof74: - lex.cs = 74 - goto _test_eof - _test_eof143: - lex.cs = 143 - goto _test_eof - _test_eof75: - lex.cs = 75 - goto _test_eof _test_eof144: lex.cs = 144 goto _test_eof @@ -20480,9 +20572,27 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof146: lex.cs = 146 goto _test_eof + _test_eof74: + lex.cs = 74 + goto _test_eof + _test_eof75: + lex.cs = 75 + goto _test_eof + _test_eof147: + lex.cs = 147 + goto _test_eof _test_eof76: lex.cs = 76 goto _test_eof + _test_eof148: + lex.cs = 148 + goto _test_eof + _test_eof149: + lex.cs = 149 + goto _test_eof + _test_eof150: + lex.cs = 150 + goto _test_eof _test_eof77: lex.cs = 77 goto _test_eof @@ -20492,24 +20602,24 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof79: lex.cs = 79 goto _test_eof - _test_eof147: - lex.cs = 147 - goto _test_eof - _test_eof148: - lex.cs = 148 - goto _test_eof _test_eof80: lex.cs = 80 goto _test_eof - _test_eof149: - lex.cs = 149 + _test_eof151: + lex.cs = 151 goto _test_eof - _test_eof150: - lex.cs = 150 + _test_eof152: + lex.cs = 152 goto _test_eof _test_eof81: lex.cs = 81 goto _test_eof + _test_eof153: + lex.cs = 153 + goto _test_eof + _test_eof154: + lex.cs = 154 + goto _test_eof _test_eof82: lex.cs = 82 goto _test_eof @@ -20519,12 +20629,12 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof84: lex.cs = 84 goto _test_eof - _test_eof151: - lex.cs = 151 - goto _test_eof _test_eof85: lex.cs = 85 goto _test_eof + _test_eof155: + lex.cs = 155 + goto _test_eof _test_eof86: lex.cs = 86 goto _test_eof @@ -20534,17 +20644,8 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof88: lex.cs = 88 goto _test_eof - _test_eof152: - lex.cs = 152 - goto _test_eof - _test_eof153: - lex.cs = 153 - goto _test_eof - _test_eof154: - lex.cs = 154 - goto _test_eof - _test_eof155: - lex.cs = 155 + _test_eof89: + lex.cs = 89 goto _test_eof _test_eof156: lex.cs = 156 @@ -20558,9 +20659,6 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof159: lex.cs = 159 goto _test_eof - _test_eof89: - lex.cs = 89 - goto _test_eof _test_eof160: lex.cs = 160 goto _test_eof @@ -20573,6 +20671,9 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof163: lex.cs = 163 goto _test_eof + _test_eof90: + lex.cs = 90 + goto _test_eof _test_eof164: lex.cs = 164 goto _test_eof @@ -20603,12 +20704,6 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof173: lex.cs = 173 goto _test_eof - _test_eof90: - lex.cs = 90 - goto _test_eof - _test_eof91: - lex.cs = 91 - goto _test_eof _test_eof174: lex.cs = 174 goto _test_eof @@ -20621,6 +20716,12 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof177: lex.cs = 177 goto _test_eof + _test_eof91: + lex.cs = 91 + goto _test_eof + _test_eof92: + lex.cs = 92 + goto _test_eof _test_eof178: lex.cs = 178 goto _test_eof @@ -21269,8 +21370,17 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof393: lex.cs = 393 goto _test_eof - _test_eof92: - lex.cs = 92 + _test_eof394: + lex.cs = 394 + goto _test_eof + _test_eof395: + lex.cs = 395 + goto _test_eof + _test_eof396: + lex.cs = 396 + goto _test_eof + _test_eof397: + lex.cs = 397 goto _test_eof _test_eof93: lex.cs = 93 @@ -21287,17 +21397,8 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof97: lex.cs = 97 goto _test_eof - _test_eof394: - lex.cs = 394 - goto _test_eof - _test_eof395: - lex.cs = 395 - goto _test_eof - _test_eof396: - lex.cs = 396 - goto _test_eof - _test_eof397: - lex.cs = 397 + _test_eof98: + lex.cs = 98 goto _test_eof _test_eof398: lex.cs = 398 @@ -21506,9 +21607,6 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof466: lex.cs = 466 goto _test_eof - _test_eof98: - lex.cs = 98 - goto _test_eof _test_eof467: lex.cs = 467 goto _test_eof @@ -21521,6 +21619,9 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof470: lex.cs = 470 goto _test_eof + _test_eof99: + lex.cs = 99 + goto _test_eof _test_eof471: lex.cs = 471 goto _test_eof @@ -21533,9 +21634,6 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof474: lex.cs = 474 goto _test_eof - _test_eof99: - lex.cs = 99 - goto _test_eof _test_eof475: lex.cs = 475 goto _test_eof @@ -21548,15 +21646,15 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof478: lex.cs = 478 goto _test_eof + _test_eof100: + lex.cs = 100 + goto _test_eof _test_eof479: lex.cs = 479 goto _test_eof _test_eof480: lex.cs = 480 goto _test_eof - _test_eof100: - lex.cs = 100 - goto _test_eof _test_eof481: lex.cs = 481 goto _test_eof @@ -21569,15 +21667,15 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof484: lex.cs = 484 goto _test_eof + _test_eof101: + lex.cs = 101 + goto _test_eof _test_eof485: lex.cs = 485 goto _test_eof _test_eof486: lex.cs = 486 goto _test_eof - _test_eof101: - lex.cs = 101 - goto _test_eof _test_eof487: lex.cs = 487 goto _test_eof @@ -21590,6 +21688,9 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof490: lex.cs = 490 goto _test_eof + _test_eof102: + lex.cs = 102 + goto _test_eof _test_eof491: lex.cs = 491 goto _test_eof @@ -21608,9 +21709,6 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof496: lex.cs = 496 goto _test_eof - _test_eof102: - lex.cs = 102 - goto _test_eof _test_eof497: lex.cs = 497 goto _test_eof @@ -21623,6 +21721,9 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof500: lex.cs = 500 goto _test_eof + _test_eof103: + lex.cs = 103 + goto _test_eof _test_eof501: lex.cs = 501 goto _test_eof @@ -21635,18 +21736,9 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof504: lex.cs = 504 goto _test_eof - _test_eof103: - lex.cs = 103 - goto _test_eof - _test_eof104: - lex.cs = 104 - goto _test_eof _test_eof505: lex.cs = 505 goto _test_eof - _test_eof105: - lex.cs = 105 - goto _test_eof _test_eof506: lex.cs = 506 goto _test_eof @@ -21656,6 +21748,12 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof508: lex.cs = 508 goto _test_eof + _test_eof104: + lex.cs = 104 + goto _test_eof + _test_eof105: + lex.cs = 105 + goto _test_eof _test_eof509: lex.cs = 509 goto _test_eof @@ -21671,12 +21769,12 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof512: lex.cs = 512 goto _test_eof - _test_eof107: - lex.cs = 107 - goto _test_eof _test_eof513: lex.cs = 513 goto _test_eof + _test_eof107: + lex.cs = 107 + goto _test_eof _test_eof514: lex.cs = 514 goto _test_eof @@ -21716,1024 +21814,1045 @@ func (lex *Lexer) Lex(lval Lval) int { _test_eof524: lex.cs = 524 goto _test_eof + _test_eof110: + lex.cs = 110 + goto _test_eof + _test_eof525: + lex.cs = 525 + goto _test_eof + _test_eof526: + lex.cs = 526 + goto _test_eof + _test_eof527: + lex.cs = 527 + goto _test_eof + _test_eof528: + lex.cs = 528 + goto _test_eof _test_eof: { } if (lex.p) == eof { switch lex.cs { - case 111: - goto tr162 case 112: goto tr164 - case 113: - goto tr162 - case 114: - goto tr162 - case 115: - goto tr169 case 1: goto tr0 - case 2: - goto tr0 - case 3: - goto tr0 + case 113: + goto tr165 + case 115: + goto tr169 case 116: - goto tr172 - case 4: - goto tr0 + goto tr171 + case 117: + goto tr169 case 118: - goto tr225 + goto tr169 case 119: - goto tr227 - case 5: - goto tr6 + goto tr176 + case 2: + goto tr3 + case 3: + goto tr3 + case 4: + goto tr3 case 120: - goto tr231 - case 121: - goto tr232 + goto tr179 + case 5: + goto tr3 case 122: - goto tr234 + goto tr232 case 123: - goto tr236 + goto tr234 case 6: - goto tr8 - case 7: - goto tr8 - case 8: - goto tr8 - case 9: - goto tr8 + goto tr9 case 124: - goto tr237 + goto tr238 case 125: goto tr239 case 126: - goto tr232 + goto tr241 case 127: goto tr243 - case 128: - goto tr232 - case 129: - goto tr232 - case 130: - goto tr231 + case 7: + goto tr11 + case 8: + goto tr11 + case 9: + goto tr11 case 10: - goto tr15 - case 11: - goto tr15 + goto tr11 + case 128: + goto tr244 + case 129: + goto tr246 + case 130: + goto tr239 case 131: - goto tr232 - case 12: - goto tr19 - case 13: - goto tr19 - case 14: - goto tr19 - case 15: - goto tr19 - case 16: - goto tr19 - case 17: - goto tr19 - case 18: - goto tr19 - case 19: - goto tr19 - case 20: - goto tr19 - case 21: - goto tr19 - case 22: - goto tr19 - case 23: - goto tr19 - case 24: - goto tr19 - case 25: - goto tr19 - case 26: - goto tr19 - case 27: - goto tr19 - case 28: - goto tr19 - case 29: - goto tr19 - case 30: - goto tr19 - case 31: - goto tr19 - case 32: - goto tr19 - case 33: - goto tr19 - case 34: - goto tr19 - case 35: - goto tr19 - case 36: - goto tr19 - case 37: - goto tr19 - case 38: - goto tr19 - case 39: - goto tr19 - case 40: - goto tr19 - case 41: - goto tr19 - case 42: - goto tr19 - case 43: - goto tr19 - case 44: - goto tr19 - case 45: - goto tr19 - case 46: - goto tr19 - case 47: - goto tr19 - case 48: - goto tr19 - case 49: - goto tr19 - case 50: - goto tr19 - case 51: - goto tr19 - case 52: - goto tr19 - case 53: - goto tr19 - case 54: - goto tr19 - case 55: - goto tr19 - case 56: - goto tr19 - case 57: - goto tr19 - case 58: - goto tr19 - case 59: - goto tr19 - case 60: - goto tr19 - case 61: - goto tr19 - case 62: - goto tr19 - case 63: - goto tr19 - case 64: - goto tr19 - case 65: - goto tr19 + goto tr250 case 132: - goto tr232 + goto tr239 case 133: - goto tr249 + goto tr239 case 134: - goto tr232 + goto tr238 + case 11: + goto tr18 + case 12: + goto tr18 case 135: - goto tr232 - case 136: - goto tr232 + goto tr239 + case 13: + goto tr22 + case 14: + goto tr22 + case 15: + goto tr22 + case 16: + goto tr22 + case 17: + goto tr22 + case 18: + goto tr22 + case 19: + goto tr22 + case 20: + goto tr22 + case 21: + goto tr22 + case 22: + goto tr22 + case 23: + goto tr22 + case 24: + goto tr22 + case 25: + goto tr22 + case 26: + goto tr22 + case 27: + goto tr22 + case 28: + goto tr22 + case 29: + goto tr22 + case 30: + goto tr22 + case 31: + goto tr22 + case 32: + goto tr22 + case 33: + goto tr22 + case 34: + goto tr22 + case 35: + goto tr22 + case 36: + goto tr22 + case 37: + goto tr22 + case 38: + goto tr22 + case 39: + goto tr22 + case 40: + goto tr22 + case 41: + goto tr22 + case 42: + goto tr22 + case 43: + goto tr22 + case 44: + goto tr22 + case 45: + goto tr22 + case 46: + goto tr22 + case 47: + goto tr22 + case 48: + goto tr22 + case 49: + goto tr22 + case 50: + goto tr22 + case 51: + goto tr22 + case 52: + goto tr22 + case 53: + goto tr22 + case 54: + goto tr22 + case 55: + goto tr22 + case 56: + goto tr22 + case 57: + goto tr22 + case 58: + goto tr22 + case 59: + goto tr22 + case 60: + goto tr22 + case 61: + goto tr22 + case 62: + goto tr22 + case 63: + goto tr22 + case 64: + goto tr22 + case 65: + goto tr22 case 66: - goto tr19 + goto tr22 + case 136: + goto tr239 case 137: - goto tr258 - case 67: - goto tr8 - case 68: - goto tr8 + goto tr256 case 138: - goto tr258 - case 69: - goto tr84 + goto tr239 case 139: - goto tr232 - case 70: - goto tr19 - case 71: - goto tr19 - case 72: - goto tr19 + goto tr239 case 140: - goto tr262 + goto tr239 + case 67: + goto tr22 case 141: - goto tr258 + goto tr265 + case 68: + goto tr11 + case 69: + goto tr11 case 142: - goto tr262 - case 73: - goto tr93 - case 74: - goto tr8 + goto tr265 + case 70: + goto tr87 case 143: - goto tr267 - case 75: - goto tr8 + goto tr239 + case 71: + goto tr22 + case 72: + goto tr22 + case 73: + goto tr22 case 144: - goto tr268 + goto tr269 case 145: - goto tr232 + goto tr265 case 146: - goto tr232 - case 76: - goto tr19 - case 77: - goto tr19 - case 78: - goto tr19 - case 79: - goto tr19 + goto tr269 + case 74: + goto tr96 + case 75: + goto tr11 case 147: - goto tr270 + goto tr274 + case 76: + goto tr11 case 148: - goto tr272 - case 80: - goto tr106 + goto tr275 case 149: - goto tr232 + goto tr239 case 150: - goto tr276 - case 81: - goto tr8 - case 82: - goto tr8 - case 83: - goto tr8 - case 84: - goto tr8 + goto tr239 + case 77: + goto tr22 + case 78: + goto tr22 + case 79: + goto tr22 + case 80: + goto tr22 case 151: - goto tr278 - case 85: - goto tr8 - case 86: - goto tr8 - case 87: - goto tr8 - case 88: - goto tr8 + goto tr277 case 152: goto tr279 + case 81: + goto tr109 case 153: - goto tr232 + goto tr239 case 154: goto tr283 + case 82: + goto tr11 + case 83: + goto tr11 + case 84: + goto tr11 + case 85: + goto tr11 case 155: - goto tr232 - case 156: - goto tr287 - case 157: - goto tr232 - case 158: - goto tr291 - case 159: - goto tr293 + goto tr285 + case 86: + goto tr11 + case 87: + goto tr11 + case 88: + goto tr11 case 89: - goto tr122 + goto tr11 + case 156: + goto tr286 + case 157: + goto tr239 + case 158: + goto tr290 + case 159: + goto tr239 case 160: goto tr294 case 161: - goto tr296 + goto tr239 case 162: - goto tr8 + goto tr298 case 163: - goto tr296 - case 164: - goto tr296 - case 165: - goto tr296 - case 166: - goto tr296 - case 167: - goto tr296 - case 168: - goto tr296 - case 169: - goto tr296 - case 170: - goto tr296 - case 171: - goto tr296 - case 172: - goto tr296 - case 173: - goto tr296 + goto tr300 case 90: - goto tr124 - case 91: - goto tr124 + goto tr125 + case 164: + goto tr301 + case 165: + goto tr303 + case 166: + goto tr11 + case 167: + goto tr303 + case 168: + goto tr303 + case 169: + goto tr303 + case 170: + goto tr303 + case 171: + goto tr303 + case 172: + goto tr303 + case 173: + goto tr303 case 174: - goto tr296 + goto tr303 case 175: - goto tr296 + goto tr303 case 176: - goto tr296 + goto tr303 case 177: - goto tr296 - case 178: - goto tr296 - case 179: - goto tr296 - case 180: - goto tr296 - case 181: - goto tr296 - case 182: - goto tr296 - case 183: - goto tr296 - case 184: - goto tr296 - case 185: - goto tr296 - case 186: - goto tr296 - case 187: - goto tr296 - case 188: - goto tr296 - case 189: - goto tr296 - case 190: - goto tr296 - case 191: - goto tr296 - case 192: - goto tr296 - case 193: - goto tr296 - case 194: - goto tr296 - case 195: - goto tr296 - case 196: - goto tr296 - case 197: - goto tr296 - case 198: - goto tr296 - case 199: - goto tr296 - case 200: - goto tr296 - case 201: - goto tr296 - case 202: - goto tr296 - case 203: - goto tr296 - case 204: - goto tr296 - case 205: - goto tr296 - case 206: - goto tr296 - case 207: - goto tr296 - case 208: - goto tr296 - case 209: - goto tr296 - case 210: - goto tr296 - case 211: - goto tr296 - case 212: - goto tr296 - case 213: - goto tr296 - case 214: - goto tr296 - case 215: - goto tr296 - case 216: - goto tr296 - case 217: - goto tr296 - case 218: - goto tr296 - case 219: - goto tr296 - case 220: - goto tr296 - case 221: - goto tr296 - case 222: - goto tr376 - case 223: - goto tr296 - case 224: - goto tr296 - case 225: - goto tr296 - case 226: - goto tr296 - case 227: - goto tr296 - case 228: - goto tr296 - case 229: - goto tr296 - case 230: - goto tr296 - case 231: - goto tr296 - case 232: - goto tr296 - case 233: - goto tr296 - case 234: - goto tr296 - case 235: - goto tr296 - case 236: - goto tr296 - case 237: - goto tr396 - case 238: - goto tr296 - case 239: - goto tr296 - case 240: - goto tr296 - case 241: - goto tr296 - case 242: - goto tr296 - case 243: - goto tr296 - case 244: - goto tr296 - case 245: - goto tr296 - case 246: - goto tr296 - case 247: - goto tr296 - case 248: - goto tr296 - case 249: - goto tr296 - case 250: - goto tr296 - case 251: - goto tr296 - case 252: - goto tr296 - case 253: - goto tr296 - case 254: - goto tr296 - case 255: - goto tr296 - case 256: - goto tr296 - case 257: - goto tr296 - case 258: - goto tr296 - case 259: - goto tr296 - case 260: - goto tr296 - case 261: - goto tr296 - case 262: - goto tr296 - case 263: - goto tr425 - case 264: - goto tr296 - case 265: - goto tr296 - case 266: - goto tr429 - case 267: - goto tr296 - case 268: - goto tr296 - case 269: - goto tr296 - case 270: - goto tr296 - case 271: - goto tr296 - case 272: - goto tr296 - case 273: - goto tr296 - case 274: - goto tr296 - case 275: - goto tr296 - case 276: - goto tr296 - case 277: - goto tr296 - case 278: - goto tr296 - case 279: - goto tr296 - case 280: - goto tr296 - case 281: - goto tr296 - case 282: - goto tr296 - case 283: - goto tr296 - case 284: - goto tr296 - case 285: - goto tr296 - case 286: - goto tr296 - case 287: - goto tr296 - case 288: - goto tr296 - case 289: - goto tr296 - case 290: - goto tr296 - case 291: - goto tr461 - case 292: - goto tr296 - case 293: - goto tr296 - case 294: - goto tr296 - case 295: - goto tr296 - case 296: - goto tr296 - case 297: - goto tr296 - case 298: - goto tr296 - case 299: - goto tr296 - case 300: - goto tr296 - case 301: - goto tr296 - case 302: - goto tr296 - case 303: - goto tr296 - case 304: - goto tr296 - case 305: - goto tr296 - case 306: - goto tr296 - case 307: - goto tr296 - case 308: - goto tr296 - case 309: - goto tr296 - case 310: - goto tr296 - case 311: - goto tr296 - case 312: - goto tr296 - case 313: - goto tr296 - case 314: - goto tr296 - case 315: - goto tr296 - case 316: - goto tr296 - case 317: - goto tr296 - case 318: - goto tr296 - case 319: - goto tr296 - case 320: - goto tr296 - case 321: - goto tr296 - case 322: - goto tr296 - case 323: - goto tr296 - case 324: - goto tr296 - case 325: - goto tr296 - case 326: - goto tr296 - case 327: - goto tr296 - case 328: - goto tr296 - case 329: - goto tr296 - case 330: - goto tr296 - case 331: - goto tr296 - case 332: - goto tr296 - case 333: - goto tr296 - case 334: - goto tr296 - case 335: - goto tr296 - case 336: - goto tr296 - case 337: - goto tr296 - case 338: - goto tr296 - case 339: - goto tr296 - case 340: - goto tr296 - case 341: - goto tr296 - case 342: - goto tr296 - case 343: - goto tr296 - case 344: - goto tr296 - case 345: - goto tr296 - case 346: - goto tr296 - case 347: - goto tr296 - case 348: - goto tr296 - case 349: - goto tr296 - case 350: - goto tr296 - case 351: - goto tr296 - case 352: - goto tr529 - case 353: - goto tr296 - case 354: - goto tr296 - case 355: - goto tr296 - case 356: - goto tr296 - case 357: - goto tr296 - case 358: - goto tr296 - case 359: - goto tr296 - case 360: - goto tr296 - case 361: - goto tr296 - case 362: - goto tr296 - case 363: - goto tr296 - case 364: - goto tr296 - case 365: - goto tr296 - case 366: - goto tr296 - case 367: - goto tr296 - case 368: - goto tr296 - case 369: - goto tr296 - case 370: - goto tr296 - case 371: - goto tr296 - case 372: - goto tr296 - case 373: - goto tr296 - case 374: - goto tr296 - case 375: - goto tr296 - case 376: - goto tr296 - case 377: - goto tr296 - case 378: - goto tr296 - case 379: - goto tr296 - case 380: - goto tr296 - case 381: - goto tr296 - case 382: - goto tr296 - case 383: - goto tr296 - case 384: - goto tr296 - case 385: - goto tr296 - case 386: - goto tr296 - case 387: - goto tr296 - case 388: - goto tr296 - case 389: - goto tr296 - case 390: - goto tr296 - case 391: - goto tr296 - case 392: - goto tr296 - case 393: - goto tr575 + goto tr303 + case 91: + goto tr127 case 92: - goto tr126 - case 93: - goto tr126 - case 94: - goto tr126 - case 95: - goto tr126 - case 96: - goto tr126 - case 97: - goto tr126 + goto tr127 + case 178: + goto tr303 + case 179: + goto tr303 + case 180: + goto tr303 + case 181: + goto tr303 + case 182: + goto tr303 + case 183: + goto tr303 + case 184: + goto tr303 + case 185: + goto tr303 + case 186: + goto tr303 + case 187: + goto tr303 + case 188: + goto tr303 + case 189: + goto tr303 + case 190: + goto tr303 + case 191: + goto tr303 + case 192: + goto tr303 + case 193: + goto tr303 + case 194: + goto tr303 + case 195: + goto tr303 + case 196: + goto tr303 + case 197: + goto tr303 + case 198: + goto tr303 + case 199: + goto tr303 + case 200: + goto tr303 + case 201: + goto tr303 + case 202: + goto tr303 + case 203: + goto tr303 + case 204: + goto tr303 + case 205: + goto tr303 + case 206: + goto tr303 + case 207: + goto tr303 + case 208: + goto tr303 + case 209: + goto tr303 + case 210: + goto tr303 + case 211: + goto tr303 + case 212: + goto tr303 + case 213: + goto tr303 + case 214: + goto tr303 + case 215: + goto tr303 + case 216: + goto tr303 + case 217: + goto tr303 + case 218: + goto tr303 + case 219: + goto tr303 + case 220: + goto tr303 + case 221: + goto tr303 + case 222: + goto tr303 + case 223: + goto tr303 + case 224: + goto tr303 + case 225: + goto tr303 + case 226: + goto tr383 + case 227: + goto tr303 + case 228: + goto tr303 + case 229: + goto tr303 + case 230: + goto tr303 + case 231: + goto tr303 + case 232: + goto tr303 + case 233: + goto tr303 + case 234: + goto tr303 + case 235: + goto tr303 + case 236: + goto tr303 + case 237: + goto tr303 + case 238: + goto tr303 + case 239: + goto tr303 + case 240: + goto tr303 + case 241: + goto tr403 + case 242: + goto tr303 + case 243: + goto tr303 + case 244: + goto tr303 + case 245: + goto tr303 + case 246: + goto tr303 + case 247: + goto tr303 + case 248: + goto tr303 + case 249: + goto tr303 + case 250: + goto tr303 + case 251: + goto tr303 + case 252: + goto tr303 + case 253: + goto tr303 + case 254: + goto tr303 + case 255: + goto tr303 + case 256: + goto tr303 + case 257: + goto tr303 + case 258: + goto tr303 + case 259: + goto tr303 + case 260: + goto tr303 + case 261: + goto tr303 + case 262: + goto tr303 + case 263: + goto tr303 + case 264: + goto tr303 + case 265: + goto tr303 + case 266: + goto tr303 + case 267: + goto tr432 + case 268: + goto tr303 + case 269: + goto tr303 + case 270: + goto tr436 + case 271: + goto tr303 + case 272: + goto tr303 + case 273: + goto tr303 + case 274: + goto tr303 + case 275: + goto tr303 + case 276: + goto tr303 + case 277: + goto tr303 + case 278: + goto tr303 + case 279: + goto tr303 + case 280: + goto tr303 + case 281: + goto tr303 + case 282: + goto tr303 + case 283: + goto tr303 + case 284: + goto tr303 + case 285: + goto tr303 + case 286: + goto tr303 + case 287: + goto tr303 + case 288: + goto tr303 + case 289: + goto tr303 + case 290: + goto tr303 + case 291: + goto tr303 + case 292: + goto tr303 + case 293: + goto tr303 + case 294: + goto tr303 + case 295: + goto tr468 + case 296: + goto tr303 + case 297: + goto tr303 + case 298: + goto tr303 + case 299: + goto tr303 + case 300: + goto tr303 + case 301: + goto tr303 + case 302: + goto tr303 + case 303: + goto tr303 + case 304: + goto tr303 + case 305: + goto tr303 + case 306: + goto tr303 + case 307: + goto tr303 + case 308: + goto tr303 + case 309: + goto tr303 + case 310: + goto tr303 + case 311: + goto tr303 + case 312: + goto tr303 + case 313: + goto tr303 + case 314: + goto tr303 + case 315: + goto tr303 + case 316: + goto tr303 + case 317: + goto tr303 + case 318: + goto tr303 + case 319: + goto tr303 + case 320: + goto tr303 + case 321: + goto tr303 + case 322: + goto tr303 + case 323: + goto tr303 + case 324: + goto tr303 + case 325: + goto tr303 + case 326: + goto tr303 + case 327: + goto tr303 + case 328: + goto tr303 + case 329: + goto tr303 + case 330: + goto tr303 + case 331: + goto tr303 + case 332: + goto tr303 + case 333: + goto tr303 + case 334: + goto tr303 + case 335: + goto tr303 + case 336: + goto tr303 + case 337: + goto tr303 + case 338: + goto tr303 + case 339: + goto tr303 + case 340: + goto tr303 + case 341: + goto tr303 + case 342: + goto tr303 + case 343: + goto tr303 + case 344: + goto tr303 + case 345: + goto tr303 + case 346: + goto tr303 + case 347: + goto tr303 + case 348: + goto tr303 + case 349: + goto tr303 + case 350: + goto tr303 + case 351: + goto tr303 + case 352: + goto tr303 + case 353: + goto tr303 + case 354: + goto tr303 + case 355: + goto tr303 + case 356: + goto tr536 + case 357: + goto tr303 + case 358: + goto tr303 + case 359: + goto tr303 + case 360: + goto tr303 + case 361: + goto tr303 + case 362: + goto tr303 + case 363: + goto tr303 + case 364: + goto tr303 + case 365: + goto tr303 + case 366: + goto tr303 + case 367: + goto tr303 + case 368: + goto tr303 + case 369: + goto tr303 + case 370: + goto tr303 + case 371: + goto tr303 + case 372: + goto tr303 + case 373: + goto tr303 + case 374: + goto tr303 + case 375: + goto tr303 + case 376: + goto tr303 + case 377: + goto tr303 + case 378: + goto tr303 + case 379: + goto tr303 + case 380: + goto tr303 + case 381: + goto tr303 + case 382: + goto tr303 + case 383: + goto tr303 + case 384: + goto tr303 + case 385: + goto tr303 + case 386: + goto tr303 + case 387: + goto tr303 + case 388: + goto tr303 + case 389: + goto tr303 + case 390: + goto tr303 + case 391: + goto tr303 + case 392: + goto tr303 + case 393: + goto tr303 case 394: - goto tr296 + goto tr303 case 395: - goto tr296 + goto tr303 case 396: - goto tr296 + goto tr303 case 397: - goto tr232 - case 398: - goto tr296 - case 399: - goto tr296 - case 400: - goto tr296 - case 401: - goto tr296 - case 402: - goto tr296 - case 403: - goto tr296 - case 404: - goto tr296 - case 405: - goto tr296 - case 406: - goto tr296 - case 407: - goto tr296 - case 408: - goto tr296 - case 409: - goto tr296 - case 410: - goto tr296 - case 411: - goto tr296 - case 412: - goto tr296 - case 413: - goto tr296 - case 414: - goto tr296 - case 415: - goto tr296 - case 416: - goto tr296 - case 417: - goto tr296 - case 418: - goto tr296 - case 419: - goto tr296 - case 420: - goto tr296 - case 421: - goto tr296 - case 422: - goto tr296 - case 423: - goto tr296 - case 424: - goto tr296 - case 425: - goto tr296 - case 426: - goto tr296 - case 427: - goto tr296 - case 428: - goto tr296 - case 429: - goto tr296 - case 430: - goto tr296 - case 431: - goto tr296 - case 432: - goto tr296 - case 433: - goto tr296 - case 434: - goto tr296 - case 435: - goto tr296 - case 436: - goto tr296 - case 437: - goto tr296 - case 438: - goto tr296 - case 439: - goto tr296 - case 440: - goto tr296 - case 441: - goto tr296 - case 442: - goto tr296 - case 443: - goto tr296 - case 444: - goto tr296 - case 445: - goto tr296 - case 446: - goto tr296 - case 447: - goto tr296 - case 448: - goto tr296 - case 449: - goto tr296 - case 450: - goto tr296 - case 451: - goto tr296 - case 452: - goto tr296 - case 453: - goto tr296 - case 454: - goto tr296 - case 455: - goto tr296 - case 456: - goto tr296 - case 457: - goto tr296 - case 458: - goto tr296 - case 459: - goto tr296 - case 460: - goto tr296 - case 461: - goto tr296 - case 462: - goto tr296 - case 463: - goto tr232 - case 465: - goto tr661 - case 466: - goto tr663 + goto tr582 + case 93: + goto tr129 + case 94: + goto tr129 + case 95: + goto tr129 + case 96: + goto tr129 + case 97: + goto tr129 case 98: - goto tr138 + goto tr129 + case 398: + goto tr303 + case 399: + goto tr303 + case 400: + goto tr303 + case 401: + goto tr239 + case 402: + goto tr303 + case 403: + goto tr303 + case 404: + goto tr303 + case 405: + goto tr303 + case 406: + goto tr303 + case 407: + goto tr303 + case 408: + goto tr303 + case 409: + goto tr303 + case 410: + goto tr303 + case 411: + goto tr303 + case 412: + goto tr303 + case 413: + goto tr303 + case 414: + goto tr303 + case 415: + goto tr303 + case 416: + goto tr303 + case 417: + goto tr303 + case 418: + goto tr303 + case 419: + goto tr303 + case 420: + goto tr303 + case 421: + goto tr303 + case 422: + goto tr303 + case 423: + goto tr303 + case 424: + goto tr303 + case 425: + goto tr303 + case 426: + goto tr303 + case 427: + goto tr303 + case 428: + goto tr303 + case 429: + goto tr303 + case 430: + goto tr303 + case 431: + goto tr303 + case 432: + goto tr303 + case 433: + goto tr303 + case 434: + goto tr303 + case 435: + goto tr303 + case 436: + goto tr303 + case 437: + goto tr303 + case 438: + goto tr303 + case 439: + goto tr303 + case 440: + goto tr303 + case 441: + goto tr303 + case 442: + goto tr303 + case 443: + goto tr303 + case 444: + goto tr303 + case 445: + goto tr303 + case 446: + goto tr303 + case 447: + goto tr303 + case 448: + goto tr303 + case 449: + goto tr303 + case 450: + goto tr303 + case 451: + goto tr303 + case 452: + goto tr303 + case 453: + goto tr303 + case 454: + goto tr303 + case 455: + goto tr303 + case 456: + goto tr303 + case 457: + goto tr303 + case 458: + goto tr303 + case 459: + goto tr303 + case 460: + goto tr303 + case 461: + goto tr303 + case 462: + goto tr303 + case 463: + goto tr303 + case 464: + goto tr303 + case 465: + goto tr303 + case 466: + goto tr303 case 467: - goto tr667 - case 468: - goto tr667 + goto tr239 case 469: - goto tr669 + goto tr668 + case 470: + goto tr670 + case 99: + goto tr141 case 471: - goto tr672 + goto tr674 case 472: - goto tr673 - case 474: - goto tr682 + goto tr674 + case 473: + goto tr676 case 475: - goto tr684 + goto tr679 case 476: - goto tr685 - case 477: - goto tr682 + goto tr680 case 478: goto tr689 + case 479: + goto tr691 case 480: - goto tr699 + goto tr692 case 481: - goto tr701 + goto tr689 case 482: - goto tr702 - case 483: - goto tr699 + goto tr696 case 484: goto tr706 + case 485: + goto tr708 case 486: - goto tr716 + goto tr709 case 487: - goto tr718 + goto tr706 case 488: - goto tr719 - case 489: - goto tr716 + goto tr713 case 490: goto tr723 + case 491: + goto tr725 case 492: goto tr726 + case 493: + goto tr723 case 494: - goto tr732 - case 495: - goto tr734 + goto tr730 case 496: - goto tr732 - case 102: - goto tr144 - case 497: - goto tr736 + goto tr733 + case 498: + goto tr739 case 499: - goto tr746 + goto tr741 case 500: - goto tr747 - case 501: - goto tr748 - case 502: - goto tr750 - case 503: - goto tr751 - case 504: - goto tr751 + goto tr739 case 103: - goto tr146 - case 104: - goto tr146 + goto tr147 + case 501: + goto tr743 + case 503: + goto tr753 + case 504: + goto tr754 case 505: - goto tr751 - case 105: - goto tr146 - case 506: - goto tr751 - case 507: goto tr755 + case 506: + goto tr757 + case 507: + goto tr758 + case 508: + goto tr758 + case 104: + goto tr149 + case 105: + goto tr149 case 509: goto tr758 case 106: - goto tr150 + goto tr149 + case 510: + goto tr758 case 511: - goto tr763 - case 512: + goto tr762 + case 513: goto tr765 case 107: goto tr153 - case 513: - goto tr769 case 515: - goto tr774 + goto tr770 case 516: - goto tr776 + goto tr772 case 108: - goto tr155 + goto tr156 case 517: - goto tr780 + goto tr776 case 519: - goto tr785 + goto tr781 case 520: - goto tr787 + goto tr783 case 109: - goto tr157 + goto tr158 case 521: - goto tr791 + goto tr787 case 523: - goto tr794 + goto tr792 case 524: - goto tr795 + goto tr794 + case 110: + goto tr160 + case 525: + goto tr798 + case 527: + goto tr801 + case 528: + goto tr802 } } @@ -22742,7 +22861,7 @@ func (lex *Lexer) Lex(lval Lval) int { } } -//line scanner/scanner.rl:498 +//line scanner/scanner.rl:508 token.FreeFloating = lex.FreeFloating token.Value = string(lex.data[lex.ts:lex.te]) diff --git a/scanner/scanner.rl b/scanner/scanner.rl index 67738aa..a331c8a 100644 --- a/scanner/scanner.rl +++ b/scanner/scanner.rl @@ -134,6 +134,16 @@ func (lex *Lexer) Lex(lval Lval) int { ); main := |* + "#!" any* :>> newline => { + lex.addFreeFloating(freefloating.CommentType, lex.ts, lex.te) + }; + any => { + fnext html; + lex.ungetCnt(1) + }; + *|; + + html := |* any_line+ -- ' { lex.ungetStr("<") lex.setTokenPosition(token) @@ -159,8 +169,8 @@ func (lex *Lexer) Lex(lval Lval) int { php := |* whitespace_line* => {lex.addFreeFloating(freefloating.WhiteSpaceType, lex.ts, lex.te)}; - '?>' newline? => {lex.setTokenPosition(token); tok = TokenID(int(';')); fnext main; fbreak;}; - ';' whitespace_line* '?>' newline? => {lex.setTokenPosition(token); tok = TokenID(int(';')); fnext main; fbreak;}; + '?>' newline? => {lex.setTokenPosition(token); tok = TokenID(int(';')); fnext html; fbreak;}; + ';' whitespace_line* '?>' newline? => {lex.setTokenPosition(token); tok = TokenID(int(';')); fnext html; fbreak;}; (dnum | exponent_dnum) => {lex.setTokenPosition(token); tok = T_DNUMBER; fbreak;}; bnum => { diff --git a/scanner/scanner_test.go b/scanner/scanner_test.go index df1b075..7d49a4a 100644 --- a/scanner/scanner_test.go +++ b/scanner/scanner_test.go @@ -377,6 +377,51 @@ func TestTokens(t *testing.T) { assert.DeepEqual(t, expected, actual) } +func TestShebang(t *testing.T) { + src := `#!/usr/bin/env php +