maride/php-parser
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
72cd222aeb
php-parser/internal/scanner/scanner.go

24159 lines
400 KiB
Go
Raw Normal View History

refactor php7
2020-05-12 21:16:36 +00:00
// line internal/scanner/scanner.rl:1
split scanner and parser
2018-01-24 16:42:23 +00:00
package scanner
split scanner and lexer
2017-12-01 13:36:46 +00:00
import (
"fmt"
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
"strconv"
"strings"
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
all: renamed github.com/z7zmey/php-parser with github.com/VKCOM/php-parser
2021-07-30 18:01:34 +00:00
"github.com/VKCOM/php-parser/pkg/token"
split scanner and lexer
2017-12-01 13:36:46 +00:00
)
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
// line internal/scanner/scanner.go:15
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
const lexer_start int = 113
const lexer_first_final int = 113
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
const lexer_error int = 0
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
const lexer_en_main int = 113
const lexer_en_html int = 116
const lexer_en_php int = 123
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
const lexer_en_property int = 467
const lexer_en_nowdoc int = 473
const lexer_en_heredoc int = 477
const lexer_en_backqote int = 484
const lexer_en_template_string int = 490
const lexer_en_heredoc_end int = 496
const lexer_en_string_var int = 498
const lexer_en_string_var_index int = 503
const lexer_en_string_var_name int = 513
const lexer_en_halt_compiller_open_parenthesis int = 515
const lexer_en_halt_compiller_close_parenthesis int = 519
const lexer_en_halt_compiller_close_semicolon int = 523
const lexer_en_halt_compiller_end int = 527
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
// line internal/scanner/scanner.rl:17
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
[refactoring] move errors from scanner to parser
2020-05-18 17:07:17 +00:00
func initLexer(lex *Lexer) {
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
// line internal/scanner/scanner.go:43
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
lex.cs = lexer_start
lex.top = 0
lex.ts = 0
lex.te = 0
lex.act = 0
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
// line internal/scanner/scanner.rl:21
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
split scanner and lexer
2017-12-01 13:36:46 +00:00
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
func (lex *Lexer) Lex() *token.Token {
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
eof := lex.pe
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
var tok token.ID
tkn := lex.tokenPool.Get()
split scanner and lexer
2017-12-01 13:36:46 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lblStart := 0
lblEnd := 0
split scanner and lexer
2017-12-01 13:36:46 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_, _ = lblStart, lblEnd
split scanner and lexer
2017-12-01 13:36:46 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.go:67
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
var _widec int16
if (lex.p) == (lex.pe) {
goto _test_eof
}
goto _resume
_again:
switch lex.cs {
case 113:
goto st113
case 114:
goto st114
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 1:
goto st1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 115:
goto st115
case 116:
goto st116
case 117:
goto st117
case 118:
goto st118
case 119:
goto st119
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 120:
goto st120
case 121:
goto st121
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 2:
goto st2
case 3:
goto st3
case 4:
goto st4
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 122:
goto st122
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 5:
goto st5
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 123:
goto st123
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
case 124:
goto st124
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 125:
goto st125
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 6:
goto st6
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 126:
goto st126
case 127:
goto st127
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 128:
goto st128
case 129:
goto st129
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 7:
goto st7
case 8:
goto st8
case 9:
goto st9
case 10:
goto st10
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 130:
goto st130
case 131:
goto st131
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 132:
goto st132
case 133:
goto st133
case 134:
goto st134
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 135:
goto st135
case 136:
goto st136
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 11:
goto st11
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 12:
goto st12
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 137:
goto st137
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
goto st13
case 14:
goto st14
case 15:
goto st15
case 16:
goto st16
case 17:
goto st17
case 18:
goto st18
case 19:
goto st19
case 20:
goto st20
case 21:
goto st21
case 22:
goto st22
case 23:
goto st23
case 24:
goto st24
case 25:
goto st25
case 26:
goto st26
case 27:
goto st27
case 28:
goto st28
case 29:
goto st29
case 30:
goto st30
case 31:
goto st31
case 32:
goto st32
case 33:
goto st33
case 34:
goto st34
case 35:
goto st35
case 36:
goto st36
case 37:
goto st37
case 38:
goto st38
case 39:
goto st39
case 40:
goto st40
case 41:
goto st41
case 42:
goto st42
case 43:
goto st43
case 44:
goto st44
case 45:
goto st45
case 46:
goto st46
case 47:
goto st47
case 48:
goto st48
case 49:
goto st49
case 50:
goto st50
case 51:
goto st51
case 52:
goto st52
case 53:
goto st53
case 54:
goto st54
case 55:
goto st55
case 56:
goto st56
case 57:
goto st57
case 58:
goto st58
case 59:
goto st59
case 60:
goto st60
case 61:
goto st61
case 62:
goto st62
case 63:
goto st63
case 64:
goto st64
case 65:
goto st65
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 66:
goto st66
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 138:
goto st138
case 139:
goto st139
case 140:
goto st140
case 141:
goto st141
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 142:
goto st142
case 67:
goto st67
case 143:
goto st143
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 68:
goto st68
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
case 69:
goto st69
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 144:
goto st144
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 70:
goto st70
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 145:
goto st145
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 71:
goto st71
case 72:
goto st72
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 73:
goto st73
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 146:
goto st146
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 147:
goto st147
case 148:
goto st148
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 74:
goto st74
case 75:
goto st75
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 149:
goto st149
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 76:
goto st76
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 150:
goto st150
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 151:
goto st151
case 152:
goto st152
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 77:
goto st77
case 78:
goto st78
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 79:
goto st79
case 80:
goto st80
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 153:
goto st153
case 154:
goto st154
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 81:
goto st81
case 155:
goto st155
case 156:
goto st156
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 82:
goto st82
case 83:
goto st83
case 84:
goto st84
case 85:
goto st85
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 157:
goto st157
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 86:
goto st86
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 87:
goto st87
case 88:
goto st88
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 89:
goto st89
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 158:
goto st158
case 159:
goto st159
case 160:
goto st160
case 161:
goto st161
case 162:
goto st162
case 163:
goto st163
case 164:
goto st164
case 165:
goto st165
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 90:
goto st90
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 166:
goto st166
case 167:
goto st167
case 168:
goto st168
case 169:
goto st169
case 170:
goto st170
case 171:
goto st171
case 172:
goto st172
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 173:
goto st173
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 174:
goto st174
case 175:
goto st175
case 176:
goto st176
case 177:
goto st177
case 178:
goto st178
case 179:
goto st179
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 91:
goto st91
case 92:
goto st92
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 180:
goto st180
case 181:
goto st181
case 182:
goto st182
case 183:
goto st183
case 184:
goto st184
case 185:
goto st185
case 186:
goto st186
case 187:
goto st187
case 188:
goto st188
case 189:
goto st189
case 190:
goto st190
case 191:
goto st191
case 192:
goto st192
case 193:
goto st193
case 194:
goto st194
case 195:
goto st195
case 196:
goto st196
case 197:
goto st197
case 198:
goto st198
case 199:
goto st199
case 200:
goto st200
case 201:
goto st201
case 202:
goto st202
case 203:
goto st203
case 204:
goto st204
case 205:
goto st205
case 206:
goto st206
case 207:
goto st207
case 208:
goto st208
case 209:
goto st209
case 210:
goto st210
case 211:
goto st211
case 212:
goto st212
case 213:
goto st213
case 214:
goto st214
case 215:
goto st215
case 216:
goto st216
case 217:
goto st217
case 218:
goto st218
case 219:
goto st219
case 220:
goto st220
case 221:
goto st221
case 222:
goto st222
case 223:
goto st223
case 224:
goto st224
case 225:
goto st225
case 226:
goto st226
case 227:
goto st227
case 228:
goto st228
case 229:
goto st229
case 230:
goto st230
case 231:
goto st231
case 232:
goto st232
case 233:
goto st233
case 234:
goto st234
case 235:
goto st235
case 236:
goto st236
case 237:
goto st237
case 238:
goto st238
case 239:
goto st239
case 240:
goto st240
case 241:
goto st241
case 242:
goto st242
case 243:
goto st243
case 244:
goto st244
case 245:
goto st245
case 246:
goto st246
case 247:
goto st247
case 248:
goto st248
case 249:
goto st249
case 250:
goto st250
case 251:
goto st251
case 252:
goto st252
case 253:
goto st253
case 254:
goto st254
case 255:
goto st255
case 256:
goto st256
case 257:
goto st257
case 258:
goto st258
case 259:
goto st259
case 260:
goto st260
case 261:
goto st261
case 262:
goto st262
case 263:
goto st263
case 264:
goto st264
case 265:
goto st265
case 266:
goto st266
case 267:
goto st267
case 268:
goto st268
case 269:
goto st269
case 270:
goto st270
case 271:
goto st271
case 272:
goto st272
case 273:
goto st273
case 274:
goto st274
case 275:
goto st275
case 276:
goto st276
case 277:
goto st277
case 278:
goto st278
case 279:
goto st279
case 280:
goto st280
case 281:
goto st281
case 282:
goto st282
case 283:
goto st283
case 284:
goto st284
case 285:
goto st285
case 286:
goto st286
case 287:
goto st287
case 288:
goto st288
case 289:
goto st289
case 290:
goto st290
case 291:
goto st291
case 292:
goto st292
case 293:
goto st293
case 294:
goto st294
case 295:
goto st295
case 296:
goto st296
case 297:
goto st297
case 298:
goto st298
case 299:
goto st299
case 300:
goto st300
case 301:
goto st301
case 302:
goto st302
case 303:
goto st303
case 304:
goto st304
case 305:
goto st305
case 306:
goto st306
case 307:
goto st307
case 308:
goto st308
case 309:
goto st309
case 310:
goto st310
case 311:
goto st311
case 312:
goto st312
case 313:
goto st313
case 314:
goto st314
case 315:
goto st315
case 316:
goto st316
case 317:
goto st317
case 318:
goto st318
case 319:
goto st319
case 320:
goto st320
case 321:
goto st321
case 322:
goto st322
case 323:
goto st323
case 324:
goto st324
case 325:
goto st325
case 326:
goto st326
case 327:
goto st327
case 328:
goto st328
case 329:
goto st329
case 330:
goto st330
case 331:
goto st331
case 332:
goto st332
case 333:
goto st333
case 334:
goto st334
case 335:
goto st335
case 336:
goto st336
case 337:
goto st337
case 338:
goto st338
case 339:
goto st339
case 340:
goto st340
case 341:
goto st341
case 342:
goto st342
case 343:
goto st343
case 344:
goto st344
case 345:
goto st345
case 346:
goto st346
case 347:
goto st347
case 348:
goto st348
case 349:
goto st349
case 350:
goto st350
case 351:
goto st351
case 352:
goto st352
case 353:
goto st353
case 354:
goto st354
case 355:
goto st355
case 356:
goto st356
case 357:
goto st357
case 358:
goto st358
case 359:
goto st359
case 360:
goto st360
case 361:
goto st361
case 362:
goto st362
case 363:
goto st363
case 364:
goto st364
case 365:
goto st365
case 366:
goto st366
case 367:
goto st367
case 368:
goto st368
case 369:
goto st369
case 370:
goto st370
case 371:
goto st371
case 372:
goto st372
case 373:
goto st373
case 374:
goto st374
case 375:
goto st375
case 376:
goto st376
case 377:
goto st377
case 378:
goto st378
case 379:
goto st379
case 380:
goto st380
case 381:
goto st381
case 382:
goto st382
case 383:
goto st383
case 384:
goto st384
case 385:
goto st385
case 386:
goto st386
case 387:
goto st387
case 388:
goto st388
case 389:
goto st389
case 390:
goto st390
case 391:
goto st391
case 392:
goto st392
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 393:
goto st393
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 394:
goto st394
case 395:
goto st395
case 396:
goto st396
case 397:
goto st397
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 398:
goto st398
case 399:
goto st399
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 93:
goto st93
case 94:
goto st94
case 95:
goto st95
case 96:
goto st96
case 97:
goto st97
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 98:
goto st98
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 400:
goto st400
case 401:
goto st401
case 402:
goto st402
case 403:
goto st403
case 404:
goto st404
case 405:
goto st405
case 406:
goto st406
case 407:
goto st407
case 408:
goto st408
case 409:
goto st409
case 410:
goto st410
case 411:
goto st411
case 412:
goto st412
case 413:
goto st413
case 414:
goto st414
case 415:
goto st415
case 416:
goto st416
case 417:
goto st417
case 418:
goto st418
case 419:
goto st419
case 420:
goto st420
case 421:
goto st421
case 422:
goto st422
case 423:
goto st423
case 424:
goto st424
case 425:
goto st425
case 426:
goto st426
case 427:
goto st427
case 428:
goto st428
case 429:
goto st429
case 430:
goto st430
case 431:
goto st431
case 432:
goto st432
case 433:
goto st433
case 434:
goto st434
case 435:
goto st435
case 436:
goto st436
case 437:
goto st437
case 438:
goto st438
case 439:
goto st439
case 440:
goto st440
case 441:
goto st441
case 442:
goto st442
case 443:
goto st443
case 444:
goto st444
case 445:
goto st445
case 446:
goto st446
case 447:
goto st447
case 448:
goto st448
case 449:
goto st449
case 450:
goto st450
case 451:
goto st451
case 452:
goto st452
case 453:
goto st453
case 454:
goto st454
case 455:
goto st455
case 456:
goto st456
case 457:
goto st457
case 458:
goto st458
case 459:
goto st459
case 460:
goto st460
case 461:
goto st461
case 462:
goto st462
case 463:
goto st463
case 464:
goto st464
case 465:
goto st465
case 466:
goto st466
case 467:
goto st467
case 468:
goto st468
case 469:
goto st469
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 99:
goto st99
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 470:
goto st470
case 471:
goto st471
case 472:
goto st472
case 473:
goto st473
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 0:
goto st0
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 474:
goto st474
case 475:
goto st475
case 476:
goto st476
case 477:
goto st477
case 478:
goto st478
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 100:
goto st100
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 479:
goto st479
case 480:
goto st480
case 481:
goto st481
case 482:
goto st482
case 483:
goto st483
case 484:
goto st484
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 101:
goto st101
case 102:
goto st102
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 485:
goto st485
case 486:
goto st486
case 487:
goto st487
case 488:
goto st488
case 489:
goto st489
case 490:
goto st490
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 103:
goto st103
case 104:
goto st104
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 491:
goto st491
case 492:
goto st492
case 493:
goto st493
case 494:
goto st494
case 495:
goto st495
case 496:
goto st496
case 497:
goto st497
case 498:
goto st498
case 499:
goto st499
case 500:
goto st500
case 501:
goto st501
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 105:
goto st105
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 502:
goto st502
case 503:
goto st503
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 504:
goto st504
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 505:
goto st505
case 506:
goto st506
case 507:
goto st507
case 508:
goto st508
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 509:
goto st509
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 106:
goto st106
case 107:
goto st107
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 510:
goto st510
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 108:
goto st108
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 511:
goto st511
case 512:
goto st512
case 513:
goto st513
case 514:
goto st514
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 109:
goto st109
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 515:
goto st515
case 516:
goto st516
case 517:
goto st517
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 110:
goto st110
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 518:
goto st518
case 519:
goto st519
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 520:
goto st520
case 521:
goto st521
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 111:
goto st111
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 522:
goto st522
case 523:
goto st523
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 524:
goto st524
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 525:
goto st525
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 112:
goto st112
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 526:
goto st526
case 527:
goto st527
case 528:
goto st528
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 529:
goto st529
case 530:
goto st530
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
split scanner and lexer
2017-12-01 13:36:46 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof
}
_resume:
switch lex.cs {
case 113:
goto st_case_113
case 114:
goto st_case_114
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 1:
goto st_case_1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 115:
goto st_case_115
case 116:
goto st_case_116
case 117:
goto st_case_117
case 118:
goto st_case_118
case 119:
goto st_case_119
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 120:
goto st_case_120
case 121:
goto st_case_121
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 2:
goto st_case_2
case 3:
goto st_case_3
case 4:
goto st_case_4
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 122:
goto st_case_122
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 5:
goto st_case_5
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 123:
goto st_case_123
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
case 124:
goto st_case_124
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 125:
goto st_case_125
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 6:
goto st_case_6
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 126:
goto st_case_126
case 127:
goto st_case_127
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 128:
goto st_case_128
case 129:
goto st_case_129
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 7:
goto st_case_7
case 8:
goto st_case_8
case 9:
goto st_case_9
case 10:
goto st_case_10
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 130:
goto st_case_130
case 131:
goto st_case_131
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 132:
goto st_case_132
case 133:
goto st_case_133
case 134:
goto st_case_134
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 135:
goto st_case_135
case 136:
goto st_case_136
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 11:
goto st_case_11
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 12:
goto st_case_12
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 137:
goto st_case_137
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
goto st_case_13
case 14:
goto st_case_14
case 15:
goto st_case_15
case 16:
goto st_case_16
case 17:
goto st_case_17
case 18:
goto st_case_18
case 19:
goto st_case_19
case 20:
goto st_case_20
case 21:
goto st_case_21
case 22:
goto st_case_22
case 23:
goto st_case_23
case 24:
goto st_case_24
case 25:
goto st_case_25
case 26:
goto st_case_26
case 27:
goto st_case_27
case 28:
goto st_case_28
case 29:
goto st_case_29
case 30:
goto st_case_30
case 31:
goto st_case_31
case 32:
goto st_case_32
case 33:
goto st_case_33
case 34:
goto st_case_34
case 35:
goto st_case_35
case 36:
goto st_case_36
case 37:
goto st_case_37
case 38:
goto st_case_38
case 39:
goto st_case_39
case 40:
goto st_case_40
case 41:
goto st_case_41
case 42:
goto st_case_42
case 43:
goto st_case_43
case 44:
goto st_case_44
case 45:
goto st_case_45
case 46:
goto st_case_46
case 47:
goto st_case_47
case 48:
goto st_case_48
case 49:
goto st_case_49
case 50:
goto st_case_50
case 51:
goto st_case_51
case 52:
goto st_case_52
case 53:
goto st_case_53
case 54:
goto st_case_54
case 55:
goto st_case_55
case 56:
goto st_case_56
case 57:
goto st_case_57
case 58:
goto st_case_58
case 59:
goto st_case_59
case 60:
goto st_case_60
case 61:
goto st_case_61
case 62:
goto st_case_62
case 63:
goto st_case_63
case 64:
goto st_case_64
case 65:
goto st_case_65
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 66:
goto st_case_66
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 138:
goto st_case_138
case 139:
goto st_case_139
case 140:
goto st_case_140
case 141:
goto st_case_141
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 142:
goto st_case_142
case 67:
goto st_case_67
case 143:
goto st_case_143
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 68:
goto st_case_68
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
case 69:
goto st_case_69
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 144:
goto st_case_144
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 70:
goto st_case_70
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 145:
goto st_case_145
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 71:
goto st_case_71
case 72:
goto st_case_72
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 73:
goto st_case_73
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 146:
goto st_case_146
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 147:
goto st_case_147
case 148:
goto st_case_148
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 74:
goto st_case_74
case 75:
goto st_case_75
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 149:
goto st_case_149
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 76:
goto st_case_76
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 150:
goto st_case_150
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 151:
goto st_case_151
case 152:
goto st_case_152
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 77:
goto st_case_77
case 78:
goto st_case_78
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 79:
goto st_case_79
case 80:
goto st_case_80
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 153:
goto st_case_153
case 154:
goto st_case_154
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 81:
goto st_case_81
case 155:
goto st_case_155
case 156:
goto st_case_156
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 82:
goto st_case_82
case 83:
goto st_case_83
case 84:
goto st_case_84
case 85:
goto st_case_85
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 157:
goto st_case_157
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 86:
goto st_case_86
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 87:
goto st_case_87
case 88:
goto st_case_88
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 89:
goto st_case_89
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 158:
goto st_case_158
case 159:
goto st_case_159
case 160:
goto st_case_160
case 161:
goto st_case_161
case 162:
goto st_case_162
case 163:
goto st_case_163
case 164:
goto st_case_164
case 165:
goto st_case_165
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 90:
goto st_case_90
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 166:
goto st_case_166
case 167:
goto st_case_167
case 168:
goto st_case_168
case 169:
goto st_case_169
case 170:
goto st_case_170
case 171:
goto st_case_171
case 172:
goto st_case_172
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 173:
goto st_case_173
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 174:
goto st_case_174
case 175:
goto st_case_175
case 176:
goto st_case_176
case 177:
goto st_case_177
case 178:
goto st_case_178
case 179:
goto st_case_179
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 91:
goto st_case_91
case 92:
goto st_case_92
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 180:
goto st_case_180
case 181:
goto st_case_181
case 182:
goto st_case_182
case 183:
goto st_case_183
case 184:
goto st_case_184
case 185:
goto st_case_185
case 186:
goto st_case_186
case 187:
goto st_case_187
case 188:
goto st_case_188
case 189:
goto st_case_189
case 190:
goto st_case_190
case 191:
goto st_case_191
case 192:
goto st_case_192
case 193:
goto st_case_193
case 194:
goto st_case_194
case 195:
goto st_case_195
case 196:
goto st_case_196
case 197:
goto st_case_197
case 198:
goto st_case_198
case 199:
goto st_case_199
case 200:
goto st_case_200
case 201:
goto st_case_201
case 202:
goto st_case_202
case 203:
goto st_case_203
case 204:
goto st_case_204
case 205:
goto st_case_205
case 206:
goto st_case_206
case 207:
goto st_case_207
case 208:
goto st_case_208
case 209:
goto st_case_209
case 210:
goto st_case_210
case 211:
goto st_case_211
case 212:
goto st_case_212
case 213:
goto st_case_213
case 214:
goto st_case_214
case 215:
goto st_case_215
case 216:
goto st_case_216
case 217:
goto st_case_217
case 218:
goto st_case_218
case 219:
goto st_case_219
case 220:
goto st_case_220
case 221:
goto st_case_221
case 222:
goto st_case_222
case 223:
goto st_case_223
case 224:
goto st_case_224
case 225:
goto st_case_225
case 226:
goto st_case_226
case 227:
goto st_case_227
case 228:
goto st_case_228
case 229:
goto st_case_229
case 230:
goto st_case_230
case 231:
goto st_case_231
case 232:
goto st_case_232
case 233:
goto st_case_233
case 234:
goto st_case_234
case 235:
goto st_case_235
case 236:
goto st_case_236
case 237:
goto st_case_237
case 238:
goto st_case_238
case 239:
goto st_case_239
case 240:
goto st_case_240
case 241:
goto st_case_241
case 242:
goto st_case_242
case 243:
goto st_case_243
case 244:
goto st_case_244
case 245:
goto st_case_245
case 246:
goto st_case_246
case 247:
goto st_case_247
case 248:
goto st_case_248
case 249:
goto st_case_249
case 250:
goto st_case_250
case 251:
goto st_case_251
case 252:
goto st_case_252
case 253:
goto st_case_253
case 254:
goto st_case_254
case 255:
goto st_case_255
case 256:
goto st_case_256
case 257:
goto st_case_257
case 258:
goto st_case_258
case 259:
goto st_case_259
case 260:
goto st_case_260
case 261:
goto st_case_261
case 262:
goto st_case_262
case 263:
goto st_case_263
case 264:
goto st_case_264
case 265:
goto st_case_265
case 266:
goto st_case_266
case 267:
goto st_case_267
case 268:
goto st_case_268
case 269:
goto st_case_269
case 270:
goto st_case_270
case 271:
goto st_case_271
case 272:
goto st_case_272
case 273:
goto st_case_273
case 274:
goto st_case_274
case 275:
goto st_case_275
case 276:
goto st_case_276
case 277:
goto st_case_277
case 278:
goto st_case_278
case 279:
goto st_case_279
case 280:
goto st_case_280
case 281:
goto st_case_281
case 282:
goto st_case_282
case 283:
goto st_case_283
case 284:
goto st_case_284
case 285:
goto st_case_285
case 286:
goto st_case_286
case 287:
goto st_case_287
case 288:
goto st_case_288
case 289:
goto st_case_289
case 290:
goto st_case_290
case 291:
goto st_case_291
case 292:
goto st_case_292
case 293:
goto st_case_293
case 294:
goto st_case_294
case 295:
goto st_case_295
case 296:
goto st_case_296
case 297:
goto st_case_297
case 298:
goto st_case_298
case 299:
goto st_case_299
case 300:
goto st_case_300
case 301:
goto st_case_301
case 302:
goto st_case_302
case 303:
goto st_case_303
case 304:
goto st_case_304
case 305:
goto st_case_305
case 306:
goto st_case_306
case 307:
goto st_case_307
case 308:
goto st_case_308
case 309:
goto st_case_309
case 310:
goto st_case_310
case 311:
goto st_case_311
case 312:
goto st_case_312
case 313:
goto st_case_313
case 314:
goto st_case_314
case 315:
goto st_case_315
case 316:
goto st_case_316
case 317:
goto st_case_317
case 318:
goto st_case_318
case 319:
goto st_case_319
case 320:
goto st_case_320
case 321:
goto st_case_321
case 322:
goto st_case_322
case 323:
goto st_case_323
case 324:
goto st_case_324
case 325:
goto st_case_325
case 326:
goto st_case_326
case 327:
goto st_case_327
case 328:
goto st_case_328
case 329:
goto st_case_329
case 330:
goto st_case_330
case 331:
goto st_case_331
case 332:
goto st_case_332
case 333:
goto st_case_333
case 334:
goto st_case_334
case 335:
goto st_case_335
case 336:
goto st_case_336
case 337:
goto st_case_337
case 338:
goto st_case_338
case 339:
goto st_case_339
case 340:
goto st_case_340
case 341:
goto st_case_341
case 342:
goto st_case_342
case 343:
goto st_case_343
case 344:
goto st_case_344
case 345:
goto st_case_345
case 346:
goto st_case_346
case 347:
goto st_case_347
case 348:
goto st_case_348
case 349:
goto st_case_349
case 350:
goto st_case_350
case 351:
goto st_case_351
case 352:
goto st_case_352
case 353:
goto st_case_353
case 354:
goto st_case_354
case 355:
goto st_case_355
case 356:
goto st_case_356
case 357:
goto st_case_357
case 358:
goto st_case_358
case 359:
goto st_case_359
case 360:
goto st_case_360
case 361:
goto st_case_361
case 362:
goto st_case_362
case 363:
goto st_case_363
case 364:
goto st_case_364
case 365:
goto st_case_365
case 366:
goto st_case_366
case 367:
goto st_case_367
case 368:
goto st_case_368
case 369:
goto st_case_369
case 370:
goto st_case_370
case 371:
goto st_case_371
case 372:
goto st_case_372
case 373:
goto st_case_373
case 374:
goto st_case_374
case 375:
goto st_case_375
case 376:
goto st_case_376
case 377:
goto st_case_377
case 378:
goto st_case_378
case 379:
goto st_case_379
case 380:
goto st_case_380
case 381:
goto st_case_381
case 382:
goto st_case_382
case 383:
goto st_case_383
case 384:
goto st_case_384
case 385:
goto st_case_385
case 386:
goto st_case_386
case 387:
goto st_case_387
case 388:
goto st_case_388
case 389:
goto st_case_389
case 390:
goto st_case_390
case 391:
goto st_case_391
case 392:
goto st_case_392
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 393:
goto st_case_393
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 394:
goto st_case_394
case 395:
goto st_case_395
case 396:
goto st_case_396
case 397:
goto st_case_397
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 398:
goto st_case_398
case 399:
goto st_case_399
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 93:
goto st_case_93
case 94:
goto st_case_94
case 95:
goto st_case_95
case 96:
goto st_case_96
case 97:
goto st_case_97
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 98:
goto st_case_98
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 400:
goto st_case_400
case 401:
goto st_case_401
case 402:
goto st_case_402
case 403:
goto st_case_403
case 404:
goto st_case_404
case 405:
goto st_case_405
case 406:
goto st_case_406
case 407:
goto st_case_407
case 408:
goto st_case_408
case 409:
goto st_case_409
case 410:
goto st_case_410
case 411:
goto st_case_411
case 412:
goto st_case_412
case 413:
goto st_case_413
case 414:
goto st_case_414
case 415:
goto st_case_415
case 416:
goto st_case_416
case 417:
goto st_case_417
case 418:
goto st_case_418
case 419:
goto st_case_419
case 420:
goto st_case_420
case 421:
goto st_case_421
case 422:
goto st_case_422
case 423:
goto st_case_423
case 424:
goto st_case_424
case 425:
goto st_case_425
case 426:
goto st_case_426
case 427:
goto st_case_427
case 428:
goto st_case_428
case 429:
goto st_case_429
case 430:
goto st_case_430
case 431:
goto st_case_431
case 432:
goto st_case_432
case 433:
goto st_case_433
case 434:
goto st_case_434
case 435:
goto st_case_435
case 436:
goto st_case_436
case 437:
goto st_case_437
case 438:
goto st_case_438
case 439:
goto st_case_439
case 440:
goto st_case_440
case 441:
goto st_case_441
case 442:
goto st_case_442
case 443:
goto st_case_443
case 444:
goto st_case_444
case 445:
goto st_case_445
case 446:
goto st_case_446
case 447:
goto st_case_447
case 448:
goto st_case_448
case 449:
goto st_case_449
case 450:
goto st_case_450
case 451:
goto st_case_451
case 452:
goto st_case_452
case 453:
goto st_case_453
case 454:
goto st_case_454
case 455:
goto st_case_455
case 456:
goto st_case_456
case 457:
goto st_case_457
case 458:
goto st_case_458
case 459:
goto st_case_459
case 460:
goto st_case_460
case 461:
goto st_case_461
case 462:
goto st_case_462
case 463:
goto st_case_463
case 464:
goto st_case_464
case 465:
goto st_case_465
case 466:
goto st_case_466
case 467:
goto st_case_467
case 468:
goto st_case_468
case 469:
goto st_case_469
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 99:
goto st_case_99
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 470:
goto st_case_470
case 471:
goto st_case_471
case 472:
goto st_case_472
case 473:
goto st_case_473
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 0:
goto st_case_0
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 474:
goto st_case_474
case 475:
goto st_case_475
case 476:
goto st_case_476
case 477:
goto st_case_477
case 478:
goto st_case_478
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 100:
goto st_case_100
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 479:
goto st_case_479
case 480:
goto st_case_480
case 481:
goto st_case_481
case 482:
goto st_case_482
case 483:
goto st_case_483
case 484:
goto st_case_484
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 101:
goto st_case_101
case 102:
goto st_case_102
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 485:
goto st_case_485
case 486:
goto st_case_486
case 487:
goto st_case_487
case 488:
goto st_case_488
case 489:
goto st_case_489
case 490:
goto st_case_490
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 103:
goto st_case_103
case 104:
goto st_case_104
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 491:
goto st_case_491
case 492:
goto st_case_492
case 493:
goto st_case_493
case 494:
goto st_case_494
case 495:
goto st_case_495
case 496:
goto st_case_496
case 497:
goto st_case_497
case 498:
goto st_case_498
case 499:
goto st_case_499
case 500:
goto st_case_500
case 501:
goto st_case_501
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 105:
goto st_case_105
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 502:
goto st_case_502
case 503:
goto st_case_503
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 504:
goto st_case_504
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 505:
goto st_case_505
case 506:
goto st_case_506
case 507:
goto st_case_507
case 508:
goto st_case_508
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 509:
goto st_case_509
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 106:
goto st_case_106
case 107:
goto st_case_107
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 510:
goto st_case_510
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 108:
goto st_case_108
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 511:
goto st_case_511
case 512:
goto st_case_512
case 513:
goto st_case_513
case 514:
goto st_case_514
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 109:
goto st_case_109
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 515:
goto st_case_515
case 516:
goto st_case_516
case 517:
goto st_case_517
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 110:
goto st_case_110
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 518:
goto st_case_518
case 519:
goto st_case_519
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 520:
goto st_case_520
case 521:
goto st_case_521
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 111:
goto st_case_111
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 522:
goto st_case_522
case 523:
goto st_case_523
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 524:
goto st_case_524
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 525:
goto st_case_525
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 112:
goto st_case_112
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 526:
goto st_case_526
case 527:
goto st_case_527
case 528:
goto st_case_528
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 529:
goto st_case_529
case 530:
goto st_case_530
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
goto st_out
tr0:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 113
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:130
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
(lex.p) = (lex.te) - 1
{
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 116
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.ungetCnt(1)
}
goto _again
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr169:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 113
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:130
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.te = (lex.p) + 1
{
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 116
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.ungetCnt(1)
}
goto _again
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr171:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 113
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:130
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.te = (lex.p)
(lex.p)--
{
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 116
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.ungetCnt(1)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
goto _again
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr172:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:127
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_COMMENT, lex.ts, lex.te)
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st113
st113:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.ts = 0
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof113
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_113:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.ts = (lex.p)
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
// line internal/scanner/scanner.go:2259
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
if lex.data[(lex.p)] == 35 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr170
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr169
tr170:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.te = (lex.p) + 1
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st114
st114:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof114
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_114:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
// line internal/scanner/scanner.go:2274
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
if lex.data[(lex.p)] == 33 {
goto st1
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr171
tr3:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
goto st1
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st1:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof1
}
st_case_1:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
// line internal/scanner/scanner.go:2296
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
switch lex.data[(lex.p)] {
case 10:
goto tr2
case 13:
goto tr3
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
goto st1
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr2:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
goto st115
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st115:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof115
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_115:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
// line internal/scanner/scanner.go:2321
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr172
tr4:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 116
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:143
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
(lex.p) = (lex.te) - 1
{
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_OPEN_TAG, lex.ts, lex.te)
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
goto _again
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr7:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 116
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:147
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
lex.ungetCnt(lex.te - lex.ts - 5)
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_OPEN_TAG, lex.ts, lex.ts+5)
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
goto _again
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr177:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:137
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
lex.ungetStr("<")
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_INLINE_HTML
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 116
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st116
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr179:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:137
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
lex.ungetStr("<")
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_INLINE_HTML
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 116
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st116
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr185:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 116
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:143
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_OPEN_TAG, lex.ts, lex.te)
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
goto _again
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr186:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 116
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:152
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ECHO
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
goto _again
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr188:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 116
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:147
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
lex.ungetCnt(lex.te - lex.ts - 5)
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_OPEN_TAG, lex.ts, lex.ts+5)
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
goto _again
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st116:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = 0
#67: skip unexpected character in input
2018-11-05 14:56:27 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof116
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_116:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = (lex.p)
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
// line internal/scanner/scanner.go:2411
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr174
case 13:
goto tr175
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 60:
goto st120
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st117
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr175:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
goto st117
tr180:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto st117
tr182:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st117
st117:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof117
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_117:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
// line internal/scanner/scanner.go:2456
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr174
case 13:
goto tr175
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 60:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st119
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st117
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr174:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
goto st118
tr181:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st118
st118:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof118
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_118:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
// line internal/scanner/scanner.go:2497
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr181
case 13:
goto tr182
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 60:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr183
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr180
tr183:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st119
st119:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof119
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_119:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
// line internal/scanner/scanner.go:2516
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr174
case 13:
goto tr175
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 60:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st119
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 63:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr177
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st117
st120:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof120
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_120:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr174
case 13:
goto tr175
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 60:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st119
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 63:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr184
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st117
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr184:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st121
st121:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof121
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_121:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
// line internal/scanner/scanner.go:2554
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 61:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr186
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 80:
goto st2
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 112:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st2
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr185
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st2:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof2
}
st_case_2:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 72:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st3
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 104:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st3
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr4
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st3:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof3
}
st_case_3:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
switch lex.data[(lex.p)] {
case 80:
goto st4
case 112:
goto st4
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr4
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st4:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof4
}
st_case_4:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 9:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr7
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr8
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr9
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 32:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr7
}
goto tr4
tr8:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto st122
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st122:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof122
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_122:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
// line internal/scanner/scanner.go:2621
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr188
tr9:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
goto st5
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st5:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof5
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_5:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
// line internal/scanner/scanner.go:2640
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if lex.data[(lex.p)] == 10 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr8
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr4
tr10:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:161
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
(lex.p) = (lex.te) - 1
{
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr12:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.act {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 10:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DNUMBER
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 11:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
{
(lex.p) = (lex.te) - 1
s := strings.Replace(string(lex.data[lex.ts+2:lex.te]), "_", "", -1)
_, err := strconv.ParseInt(s, 2, 0)
if err == nil {
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_LNUMBER
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
{
(lex.p)++
goto _out
}
}
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DNUMBER
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 12:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
base := 10
if lex.data[lex.ts] == '0' {
base = 8
}
s := strings.Replace(string(lex.data[lex.ts:lex.te]), "_", "", -1)
_, err := strconv.ParseInt(s, base, 0)
if err == nil {
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_LNUMBER
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
{
(lex.p)++
goto _out
}
}
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DNUMBER
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 13:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
{
(lex.p) = (lex.te) - 1
s := strings.Replace(string(lex.data[lex.ts+2:lex.te]), "_", "", -1)
_, err := strconv.ParseInt(s, 16, 0)
if err == nil {
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_LNUMBER
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DNUMBER
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 14:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ABSTRACT
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 15:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ARRAY
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 16:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_AS
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 17:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_BREAK
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 18:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_CALLABLE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 19:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_CASE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 20:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_CATCH
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 21:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_CLASS
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 22:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_CLONE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 23:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_CONST
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 24:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_CONTINUE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 25:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DECLARE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 26:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DEFAULT
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 27:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DO
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 28:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ECHO
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 30:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ELSEIF
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 31:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_EMPTY
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 32:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ENDDECLARE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 34:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ENDFOREACH
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 35:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ENDIF
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 36:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ENDSWITCH
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 37:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ENDWHILE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 38:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_EVAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 39:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_EXIT
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 40:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_EXTENDS
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 42:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_FINALLY
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 44:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_FOREACH
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 45:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_FUNCTION
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 46:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_FN
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 47:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_GLOBAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 48:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_GOTO
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 49:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_IF
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 50:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ISSET
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 51:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_IMPLEMENTS
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 52:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_INSTANCEOF
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 53:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_INSTEADOF
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 54:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_INTERFACE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 55:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_LIST
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 56:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_NAMESPACE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 57:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_PRIVATE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 58:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_PUBLIC
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 59:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_PRINT
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 60:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_PROTECTED
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 61:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_RETURN
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 62:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_STATIC
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 63:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_SWITCH
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 64:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_THROW
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 65:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_TRAIT
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 66:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_TRY
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 67:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_UNSET
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 68:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_USE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 69:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_VAR
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 70:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_WHILE
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 74:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_INCLUDE_ONCE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 76:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_REQUIRE_ONCE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 77:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_CLASS_C
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 78:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DIR
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 79:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_FILE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 80:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_FUNC_C
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 81:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_LINE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 82:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_NS_C
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 83:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_METHOD_C
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 84:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_TRAIT_C
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 85:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_HALT_COMPILER
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 515
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 86:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_NEW
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 87:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_LOGICAL_AND
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 88:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_LOGICAL_OR
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 89:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_LOGICAL_XOR
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 118:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_SL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 135:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_STRING
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 140:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int('"'))
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 490
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
}
split scanner and lexer
2017-12-01 13:36:46 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _again
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr15:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:349
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_CONSTANT_ENCAPSED_STRING
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr19:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:372
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
(lex.p) = (lex.te) - 1
{
c := lex.data[lex.p]
[refactoring] move errors from scanner to parser
2020-05-18 17:07:17 +00:00
lex.error(fmt.Sprintf("WARNING: Unexpected character in input: '%c' (ASCII=%d)", c, c))
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr23:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:336
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
(lex.p) = (lex.te) - 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int(lex.data[lex.ts]))
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr38:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:311
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ARRAY_CAST
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr45:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:316
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_STRING_CAST
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr49:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:312
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_BOOL_CAST
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr57:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:313
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DOUBLE_CAST
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr64:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_INT_CAST
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr73:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:315
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_OBJECT_CAST
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr84:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:317
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_UNSET_CAST
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr85:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:279
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ELLIPSIS
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr88:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:165
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
(lex.p) = (lex.te) - 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DNUMBER
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr98:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:323
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
isDocComment := false
if lex.te-lex.ts > 4 && string(lex.data[lex.ts:lex.ts+3]) == "/**" {
isDocComment = true
}
split scanner and lexer
2017-12-01 13:36:46 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if isDocComment {
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_DOC_COMMENT, lex.ts, lex.te)
refactor php7
2020-05-12 21:16:36 +00:00
} else {
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_COMMENT, lex.ts, lex.te)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr99:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:176
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
(lex.p) = (lex.te) - 1
{
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
base := 10
if lex.data[lex.ts] == '0' {
base = 8
}
s := strings.Replace(string(lex.data[lex.ts:lex.te]), "_", "", -1)
_, err := strconv.ParseInt(s, base, 0)
if err == nil {
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_LNUMBER
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DNUMBER
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr112:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:163
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
(lex.p) = (lex.te) - 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int(';'))
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 116
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
goto _again
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr128:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:162
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
(lex.p) = (lex.te) - 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int(';'))
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 116
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
goto _again
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr130:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:345
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
(lex.p) = (lex.te) - 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_STRING
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr132:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:260
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
(lex.p) = (lex.te) - 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_YIELD
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr143:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:259
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_YIELD_FROM
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr189:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:372
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
c := lex.data[lex.p]
[refactoring] move errors from scanner to parser
2020-05-18 17:07:17 +00:00
lex.error(fmt.Sprintf("WARNING: Unexpected character in input: '%c' (ASCII=%d)", c, c))
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr200:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:336
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int(lex.data[lex.ts]))
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr234:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:278
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_NS_SEPARATOR
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr237:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:369
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int('`'))
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 484
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
goto _again
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr238:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:342
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int('{'))
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.call(123, 123)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr240:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:343
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int('}'))
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ret(1)
goto _out
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr241:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:161
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr243:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:161
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr247:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:372
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
c := lex.data[lex.p]
[refactoring] move errors from scanner to parser
2020-05-18 17:07:17 +00:00
lex.error(fmt.Sprintf("WARNING: Unexpected character in input: '%c' (ASCII=%d)", c, c))
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr248:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:336
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int(lex.data[lex.ts]))
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr250:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:297
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_IS_NOT_EQUAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr251:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:298
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_IS_NOT_IDENTICAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr252:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:370
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int('"'))
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 490
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
goto _again
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr253:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:319
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
lex.ungetStr("?>")
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_COMMENT, lex.ts, lex.te)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr256:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:319
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
lex.ungetStr("?>")
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_COMMENT, lex.ts, lex.te)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr261:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:344
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_VARIABLE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr262:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:292
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_MOD_EQUAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr263:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:281
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_BOOLEAN_AND
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr264:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:283
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_AND_EQUAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr266:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:286
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_MUL_EQUAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr267:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:305
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_POW
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr268:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:287
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_POW_EQUAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr269:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:294
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_INC
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr270:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:289
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_PLUS_EQUAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr271:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:293
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DEC
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr272:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:290
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_MINUS_EQUAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr273:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:347
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_OBJECT_OPERATOR
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 467
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
goto _again
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr275:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:285
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_CONCAT_EQUAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr276:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:165
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DNUMBER
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr279:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:288
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DIV_EQUAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr280:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:176
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
base := 10
if lex.data[lex.ts] == '0' {
base = 8
}
s := strings.Replace(string(lex.data[lex.ts:lex.te]), "_", "", -1)
_, err := strconv.ParseInt(s, base, 0)
if err == nil {
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_LNUMBER
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DNUMBER
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr285:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:166
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
s := strings.Replace(string(lex.data[lex.ts+2:lex.te]), "_", "", -1)
_, err := strconv.ParseInt(s, 2, 0)
split scanner and lexer
2017-12-01 13:36:46 +00:00
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
if err == nil {
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_LNUMBER
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DNUMBER
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr286:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:191
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
s := strings.Replace(string(lex.data[lex.ts+2:lex.te]), "_", "", -1)
_, err := strconv.ParseInt(s, 16, 0)
split scanner and lexer
2017-12-01 13:36:46 +00:00
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
if err == nil {
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_LNUMBER
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DNUMBER
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr287:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:280
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_PAAMAYIM_NEKUDOTAYIM
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr288:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:163
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int(';'))
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 116
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
goto _again
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr290:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:163
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int(';'))
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 116
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
goto _again
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr293:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:297
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_IS_NOT_EQUAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr294:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:306
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_SL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr295:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:301
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_SL_EQUAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr296:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:355
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
lex.heredocLabel = lex.data[lblStart:lblEnd]
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_START_HEREDOC
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if lex.isHeredocEnd(lex.p + 1) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 496
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
} else if lex.data[lblStart-1] == '\'' {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 473
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
} else {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 477
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
{
(lex.p)++
goto _out
}
}
goto _again
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr297:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:304
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_IS_SMALLER_OR_EQUAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr298:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:296
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_SPACESHIP
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr300:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:295
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DOUBLE_ARROW
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr301:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:299
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_IS_EQUAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr302:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:300
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_IS_IDENTICAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr303:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:303
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_IS_GREATER_OR_EQUAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr305:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:307
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_SR
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr306:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:302
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.te = (lex.p) + 1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_SR_EQUAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr309:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:162
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int(';'))
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 116
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
goto _again
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr311:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:162
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int(';'))
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 116
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
goto _again
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr312:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:308
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_COALESCE
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr313:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:309
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_COALESCE_EQUAL
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr314:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:345
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_STRING
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr394:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:217
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ELSE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr414:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:221
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ENDFOR
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr443:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:229
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_FINAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr447:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:231
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_FOR
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr479:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:261
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_INCLUDE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr547:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:263
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_REQUIRE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr593:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:260
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_YIELD
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr594:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:291
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_XOR_EQUAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr668:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:284
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_OR_EQUAL
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr669:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:282
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_BOOLEAN_OR
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
st123:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = 0
split scanner and lexer
2017-12-01 13:36:46 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_123:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = (lex.p)
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
// line internal/scanner/scanner.go:3488
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr11
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr191
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 32:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr190
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 33:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st127
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 34:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr193
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 35:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st130
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 36:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st132
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 37:
goto st134
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 38:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st135
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 39:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr198
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 40:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr199
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 42:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st138
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 43:
goto st140
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 45:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st141
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 46:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr204
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 47:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr205
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 48:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr206
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 58:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st151
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 59:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr208
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 60:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st155
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 61:
goto st159
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 62:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st161
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 63:
goto st163
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 64:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr200
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 65:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st167
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 66:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr214
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 67:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st183
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 68:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st212
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 69:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st223
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 70:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st265
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 71:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st276
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 73:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st283
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 76:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st322
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 78:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st325
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 79:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st334
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 80:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st335
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 82:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st352
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 83:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st366
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 84:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st375
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 85:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st382
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 86:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st387
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 87:
goto st389
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 88:
goto st393
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 89:
goto st395
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 92:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr234
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 94:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st400
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 95:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st401
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr237
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 97:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st167
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 98:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr214
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 99:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st183
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 100:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st212
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 101:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st223
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 102:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st265
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 103:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st276
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 105:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st283
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 108:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st322
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 110:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st325
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 111:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st334
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 112:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st335
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 114:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st352
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 115:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st366
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 116:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st375
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 117:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st382
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 118:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st387
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 119:
goto st389
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 120:
goto st393
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 121:
goto st395
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 123:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr238
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 124:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st466
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 125:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr240
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 126:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr200
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 127:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr189
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 14:
switch {
case lex.data[(lex.p)] > 8:
if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr190
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr189
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 31:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 49:
if 41 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 44 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr200
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case lex.data[(lex.p)] > 57:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 91 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 93 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr200
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr100
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr189
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
tr190:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st124
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr244:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st124
st124:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof124
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_124:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
// line internal/scanner/scanner.go:3681
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr11
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr242
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 32:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr190
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr190
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr241
tr11:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st125
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr245:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st125
st125:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof125
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_125:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
// line internal/scanner/scanner.go:3731
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr245
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr246
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 32:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr244
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr244
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr243
tr242:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
goto st6
tr246:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st6
st6:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof6
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_6:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
// line internal/scanner/scanner.go:3775
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if lex.data[(lex.p)] == 10 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr11
}
goto tr10
tr191:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto st126
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st126:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof126
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_126:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
// line internal/scanner/scanner.go:3797
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if lex.data[(lex.p)] == 10 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr11
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr247
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st127:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof127
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_127:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if lex.data[(lex.p)] == 61 {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st128
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st128:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof128
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_128:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if lex.data[(lex.p)] == 61 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr251
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr250
tr193:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:370
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 140
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st129
st129:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof129
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_129:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
// line internal/scanner/scanner.go:3832
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr14
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto tr14
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 34:
goto tr15
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 36:
goto st8
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 92:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st9
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 123:
goto st10
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st7
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr14:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st7
st7:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof7
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_7:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
// line internal/scanner/scanner.go:3865
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr14
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto tr14
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 34:
goto tr15
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 36:
goto st8
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 92:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st9
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 123:
goto st10
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st7
st8:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof8
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_8:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr14
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
case 13:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto tr14
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 34:
goto tr15
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
case 36:
goto st8
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 92:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st9
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
case 96:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st7
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
case lex.data[(lex.p)] < 91:
if lex.data[(lex.p)] <= 64 {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st7
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
case lex.data[(lex.p)] > 94:
if 124 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st7
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
}
default:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st7
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st9:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof9
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_9:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr14
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr14
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st7
st10:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof10
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_10:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr14
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto tr14
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 34:
goto tr15
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 36:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
[#101] fix constant string "{\""
2020-01-08 07:31:40 +00:00
case 92:
goto st9
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st7
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr255:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
goto st130
tr257:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto st130
tr259:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st130
st130:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof130
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_130:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:3978
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_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
}
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
switch _widec {
case 522:
goto tr254
case 525:
goto tr255
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 512 <= _widec && _widec <= 767 {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st130
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr253
tr254:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
goto st131
tr258:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st131
st131:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof131
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_131:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:4058
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_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
}
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
switch _widec {
case 522:
goto tr258
case 525:
goto tr259
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 512 <= _widec && _widec <= 767 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr257
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr256
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st132:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof132
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_132:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if lex.data[(lex.p)] == 96 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 91:
if lex.data[(lex.p)] <= 64 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st133
st133:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof133
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_133:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if lex.data[(lex.p)] == 96 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr261
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr261
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr261
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr261
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr261
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st133
st134:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof134
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_134:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if lex.data[(lex.p)] == 61 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr262
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st135:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof135
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_135:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 38:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr263
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 61:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr264
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
tr198:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st136
st136:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof136
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_136:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:4185
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr21
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr21
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 39:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr15
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 92:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st12
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st11
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr21:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st11
st11:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof11
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_11:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:4214
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr21
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr21
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 39:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr15
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 92:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st12
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st11
st12:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof12
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_12:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr21
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr21
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st11
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr199:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st137
st137:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof137
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_137:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:4248
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 9:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st13
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 32:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st13
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 65:
goto st14
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 66:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st19
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 68:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st31
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 70:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st37
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 73:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st41
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 79:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st48
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 82:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st54
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 83:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st57
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 85:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st62
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 97:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st14
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 98:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st19
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 100:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st31
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 102:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st37
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 105:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st41
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 111:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st48
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 114:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st54
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 115:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st57
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 117:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st62
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st13
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st13:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof13
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_13:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 9:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st13
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 32:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st13
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 65:
goto st14
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 66:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st19
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 68:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st31
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 70:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st37
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 73:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st41
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 79:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st48
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 82:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st54
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 83:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st57
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 85:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st62
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 97:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st14
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 98:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st19
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 100:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st31
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 102:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st37
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 105:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st41
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 111:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st48
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 114:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st54
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 115:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st57
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 117:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st62
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st13
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st14:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof14
}
st_case_14:
switch lex.data[(lex.p)] {
case 82:
goto st15
case 114:
goto st15
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st15:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof15
}
st_case_15:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 82:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st16
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 114:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st16
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st16:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof16
}
st_case_16:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 65:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st17
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 97:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st17
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st17:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof17
}
st_case_17:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 89:
goto st18
case 121:
goto st18
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st18:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof18
}
st_case_18:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 9:
goto st18
case 32:
goto st18
case 41:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr38
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
goto st18
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st19:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof19
}
st_case_19:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 73:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st20
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 79:
goto st25
case 105:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st20
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 111:
goto st25
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st20:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof20
}
st_case_20:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 78:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st21
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 110:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st21
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st21:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof21
}
st_case_21:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 65:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st22
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 97:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st22
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st22:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof22
}
st_case_22:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 82:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st23
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 114:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st23
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st23:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof23
}
st_case_23:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 89:
goto st24
case 121:
goto st24
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st24:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof24
}
st_case_24:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 9:
goto st24
case 32:
goto st24
case 41:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr45
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
goto st24
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st25:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof25
}
st_case_25:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 79:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st26
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 111:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st26
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st26:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof26
}
st_case_26:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 76:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st27
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 108:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st27
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st27:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof27
}
st_case_27:
switch lex.data[(lex.p)] {
case 9:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st28
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 32:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st28
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 41:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr49
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 69:
goto st29
case 101:
goto st29
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st28
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st28:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof28
}
st_case_28:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 9:
goto st28
case 32:
goto st28
case 41:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr49
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
goto st28
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st29:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof29
}
st_case_29:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 65:
goto st30
case 97:
goto st30
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st30:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof30
}
st_case_30:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 78:
goto st28
case 110:
goto st28
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st31:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof31
}
st_case_31:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 79:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st32
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 111:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st32
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st32:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof32
}
st_case_32:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 85:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st33
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 117:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st33
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st33:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof33
}
st_case_33:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 66:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st34
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 98:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st34
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st34:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof34
}
st_case_34:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 76:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st35
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 108:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st35
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st35:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof35
}
st_case_35:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 69:
goto st36
case 101:
goto st36
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st36:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof36
}
st_case_36:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 9:
goto st36
case 32:
goto st36
case 41:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr57
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
goto st36
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st37:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof37
}
st_case_37:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 76:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st38
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 108:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st38
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st38:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof38
}
st_case_38:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 79:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st39
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 111:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st39
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st39:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof39
}
st_case_39:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 65:
goto st40
case 97:
goto st40
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st40:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof40
}
st_case_40:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 84:
goto st36
case 116:
goto st36
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st41:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof41
}
st_case_41:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 78:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st42
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 110:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st42
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st42:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof42
}
st_case_42:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 84:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st43
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 116:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st43
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st43:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof43
}
st_case_43:
switch lex.data[(lex.p)] {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
case 9:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st44
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
case 32:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st44
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
case 41:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr64
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 69:
goto st45
case 101:
goto st45
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
}
if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st44
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st44:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof44
}
st_case_44:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 9:
goto st44
case 32:
goto st44
case 41:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr64
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
goto st44
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st45:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof45
}
st_case_45:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 71:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st46
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 103:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st46
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st46:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof46
}
st_case_46:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 69:
goto st47
case 101:
goto st47
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st47:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof47
}
st_case_47:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 82:
goto st44
case 114:
goto st44
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st48:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof48
}
st_case_48:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 66:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st49
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 98:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st49
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st49:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof49
}
st_case_49:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 74:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st50
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 106:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st50
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st50:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof50
}
st_case_50:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 69:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st51
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 101:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st51
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st51:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof51
}
st_case_51:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 67:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st52
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 99:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st52
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st52:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof52
}
st_case_52:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 84:
goto st53
case 116:
goto st53
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st53:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof53
}
st_case_53:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 9:
goto st53
case 32:
goto st53
case 41:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr73
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
goto st53
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st54:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof54
}
st_case_54:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 69:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st55
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 101:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st55
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st55:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof55
}
st_case_55:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 65:
goto st56
case 97:
goto st56
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st56:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof56
}
st_case_56:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 76:
goto st36
case 108:
goto st36
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st57:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof57
}
st_case_57:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 84:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st58
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 116:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st58
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st58:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof58
}
st_case_58:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 82:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st59
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 114:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st59
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st59:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof59
}
st_case_59:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 73:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st60
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 105:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st60
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st60:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof60
}
st_case_60:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 78:
goto st61
case 110:
goto st61
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st61:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof61
}
st_case_61:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 71:
goto st24
case 103:
goto st24
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st62:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof62
}
st_case_62:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 78:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st63
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 110:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st63
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st63:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof63
}
st_case_63:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 83:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st64
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 115:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st64
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st64:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof64
}
st_case_64:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 69:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st65
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 101:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st65
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st65:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof65
}
st_case_65:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
switch lex.data[(lex.p)] {
case 84:
goto st66
case 116:
goto st66
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st66:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof66
}
st_case_66:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 9:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st66
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 32:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st66
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 41:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr84
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st66
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st138:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof138
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_138:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 42:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st139
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 61:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr266
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st139:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof139
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_139:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if lex.data[(lex.p)] == 61 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr268
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr267
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st140:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof140
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_140:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 43:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr269
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 61:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr270
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st141:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof141
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_141:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 45:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr271
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 61:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr272
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 62:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr273
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
tr204:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st142
st142:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof142
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_142:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5096
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 46:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st67
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 61:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr275
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr89
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st67:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof67
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_67:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if lex.data[(lex.p)] == 46 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr85
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
tr89:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:165
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 10
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st143
st143:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof143
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_143:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5128
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 69:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st68
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 95:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st70
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 101:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st68
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr89
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr276
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st68:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof68
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_68:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 43:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st69
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 45:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st69
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr87
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st69:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof69
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_69:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr87
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
tr87:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:165
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 10
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st144
st144:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof144
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_144:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5177
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
if lex.data[(lex.p)] == 95 {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st69
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr87
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr276
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st70:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof70
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_70:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr89
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr88
tr205:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
lex.te = (lex.p) + 1
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st145
st145:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof145
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_145:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5204
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 42:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st71
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 47:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st130
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 61:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr279
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
tr92:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
goto st71
tr94:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto st71
tr96:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st71
st71:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof71
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_71:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5249
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr91
case 13:
goto tr92
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 42:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st73
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st71
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr91:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
goto st72
tr95:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st72
st72:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof72
}
st_case_72:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5290
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr95
case 13:
goto tr96
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 42:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr97
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr94
tr97:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st73
st73:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof73
}
st_case_73:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5309
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr91
case 13:
goto tr92
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 42:
goto st73
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 47:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr98
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st71
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr206:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:176
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 12
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st146
st146:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof146
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_146:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5333
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 46:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr281
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 69:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st68
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 95:
goto st74
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 98:
goto st75
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 101:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st68
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 120:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st76
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr100
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr280
tr281:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:165
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 10
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st147
st147:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof147
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_147:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5364
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
switch lex.data[(lex.p)] {
case 69:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st68
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 101:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st68
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr89
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr276
tr100:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:176
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 12
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st148
st148:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof148
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_148:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5387
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 46:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr281
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 69:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st68
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 95:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st74
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 101:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st68
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr100
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr280
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st74:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof74
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_74:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr100
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr99
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st75:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof75
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_75:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 49 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr101
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
tr101:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:166
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 11
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st149
st149:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof149
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_149:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5432
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
if lex.data[(lex.p)] == 95 {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st75
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 49 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr101
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr285
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st76:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof76
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_76:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch {
case lex.data[(lex.p)] < 65:
if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr102
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
case lex.data[(lex.p)] > 70:
if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr102
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr102
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
tr102:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:191
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 13
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st150
st150:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof150
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_150:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5470
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
if lex.data[(lex.p)] == 95 {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st76
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
case lex.data[(lex.p)] < 65:
if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr102
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
case lex.data[(lex.p)] > 70:
if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr102
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr102
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr286
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st151:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof151
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_151:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if lex.data[(lex.p)] == 58 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr287
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
tr208:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st152
st152:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof152
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_152:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5506
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr104
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr105
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 32:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st77
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 63:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st80
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st77
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
tr107:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st77
st77:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof77
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_77:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5530
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr104
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr105
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 32:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st77
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 63:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st80
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st77
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
tr104:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
goto st78
tr108:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st78
st78:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof78
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_78:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5576
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr108
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr109
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 32:
goto tr107
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 63:
goto tr110
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr107
}
goto tr23
tr105:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto st79
tr109:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st79
st79:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof79
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_79:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5622
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
if lex.data[(lex.p)] == 10 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr104
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
tr110:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st80
st80:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof80
}
st_case_80:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5636
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if lex.data[(lex.p)] == 62 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr111
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
tr111:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st153
st153:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof153
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_153:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5651
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr113
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr289
}
goto tr288
tr113:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto st154
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st154:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof154
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_154:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5676
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr290
tr289:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
goto st81
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st81:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof81
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_81:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5695
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if lex.data[(lex.p)] == 10 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr113
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr112
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st155:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof155
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_155:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch lex.data[(lex.p)] {
case 60:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr291
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 61:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st158
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 62:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr293
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
tr291:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:306
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 118
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st156
st156:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof156
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_156:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5726
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch lex.data[(lex.p)] {
case 60:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st82
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 61:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr295
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr294
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st82:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof82
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_82:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch lex.data[(lex.p)] {
case 9:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st82
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 32:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st82
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 34:
goto st83
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 39:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st87
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
switch {
case lex.data[(lex.p)] < 91:
if lex.data[(lex.p)] <= 64 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr117
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st83:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof83
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_83:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if lex.data[(lex.p)] == 96 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
switch {
case lex.data[(lex.p)] < 91:
if lex.data[(lex.p)] <= 64 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr118
tr118:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:35
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lblStart = lex.p
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st84
st84:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof84
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_84:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5794
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch lex.data[(lex.p)] {
case 34:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr119
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st84
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr119:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:36
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lblEnd = lex.p
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st85
st85:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof85
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_85:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5828
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr121
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr122
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
tr121:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
goto st157
tr125:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:36
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lblEnd = lex.p
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st157
st157:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof157
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_157:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5867
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr296
tr122:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
goto st86
tr126:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:36
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lblEnd = lex.p
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st86
st86:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof86
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_86:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5900
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if lex.data[(lex.p)] == 10 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr121
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st87:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof87
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_87:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if lex.data[(lex.p)] == 96 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
switch {
case lex.data[(lex.p)] < 91:
if lex.data[(lex.p)] <= 64 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr123
tr123:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:35
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lblStart = lex.p
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st88
st88:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof88
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_88:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5935
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch lex.data[(lex.p)] {
case 39:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr119
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st88
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr117:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:35
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lblStart = lex.p
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st89
st89:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof89
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_89:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:5969
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr125
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr126
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st89
st158:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof158
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_158:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
if lex.data[(lex.p)] == 62 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr298
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr297
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st159:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof159
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_159:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch lex.data[(lex.p)] {
case 61:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st160
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 62:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr300
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st160:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof160
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_160:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if lex.data[(lex.p)] == 61 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr302
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr301
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st161:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof161
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_161:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 61:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr303
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 62:
goto st162
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st162:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof162
}
st_case_162:
if lex.data[(lex.p)] == 61 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr306
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr305
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st163:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof163
}
st_case_163:
switch lex.data[(lex.p)] {
case 62:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr307
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 63:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st166
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
tr307:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st164
st164:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof164
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_164:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:6069
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr129
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr310
}
goto tr309
tr129:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
goto st165
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st165:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof165
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_165:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:6094
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr311
tr310:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
goto st90
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st90:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof90
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_90:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:6113
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if lex.data[(lex.p)] == 10 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr129
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr128
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st166:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof166
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_166:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
if lex.data[(lex.p)] == 61 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr313
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr312
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st167:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof167
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_167:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch lex.data[(lex.p)] {
case 66:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st169
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 78:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st175
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 82:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st176
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 83:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr318
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 98:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st169
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 110:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st175
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 114:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st176
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 115:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr318
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
tr220:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:345
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 135
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr318:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:204
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 16
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr324:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:202
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 14
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr325:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:275
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 87
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr328:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:203
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 15
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr333:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:205
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.act = 17
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr345:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:206
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.act = 18
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr346:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:207
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 19
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr348:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:208
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 20
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr355:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:233
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 45
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr359:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:209
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.act = 21
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr361:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:210
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.act = 22
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr365:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:211
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 23
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr369:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:212
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 24
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr372:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:215
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 27
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr378:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:213
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 25
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr382:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:214
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.act = 26
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr383:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:227
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 39
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr391:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:216
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 28
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr396:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:218
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.act = 30
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr399:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:219
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 31
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr411:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 32
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr418:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:222
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.act = 34
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr419:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:223
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.act = 35
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr424:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:224
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.act = 36
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr428:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:225
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 37
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr430:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:226
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 38
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr436:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:228
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.act = 40
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr438:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:234
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 46
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr445:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:230
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 42
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr451:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:232
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 44
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr457:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:235
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
lex.act = 47
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr459:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:236
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 48
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr460:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:237
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 49
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr471:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:239
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 51
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr484:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:262
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 74
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr492:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:240
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
lex.act = 52
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr496:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:241
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 53
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr502:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:242
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 54
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr505:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:238
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 50
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr508:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:243
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 55
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr517:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:244
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 56
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr518:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:274
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 86
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr519:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:276
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 88
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr526:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:247
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 59
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr529:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:245
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 57
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr535:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:248
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 60
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr539:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:246
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 58
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr552:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:264
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 76
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr555:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:249
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.act = 61
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr561:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:250
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.act = 62
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr565:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:251
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
lex.act = 63
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr570:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:252
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 64
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr572:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:254
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.act = 66
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr574:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:253
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 65
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr579:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:255
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.act = 67
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr580:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:256
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
lex.act = 68
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr582:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:257
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 69
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr586:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:258
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 70
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr588:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:277
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 89
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr609:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:265
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.act = 77
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr613:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:266
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.act = 78
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr619:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:267
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 79
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr627:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:268
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 80
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr639:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:273
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 85
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr644:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:269
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
lex.act = 81
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr651:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:271
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 83
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr661:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:270
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
lex.act = 82
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr667:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:272
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 84
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st168
st168:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof168
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_168:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:6658
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
if lex.data[(lex.p)] == 96 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st169:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof169
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_169:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 83:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st170
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 115:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st170
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st170:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof170
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_170:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 84:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st171
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 116:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st171
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st171:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof171
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_171:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 82:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st172
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 114:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st172
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st172:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof172
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_172:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 65:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st173
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 97:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st173
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st173:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof173
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_173:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 67:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st174
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 99:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st174
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st174:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof174
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_174:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 84:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr324
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 116:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr324
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st175:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof175
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_175:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 68:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr325
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 100:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr325
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st176:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof176
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_176:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 82:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st177
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 114:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st177
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st177:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof177
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_177:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 65:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st178
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 97:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st178
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st178:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof178
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_178:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 89:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr328
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 121:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr328
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
tr214:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:345
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 135
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st179
st179:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof179
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_179:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:7002
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 34:
goto st7
case 60:
goto st91
case 82:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st180
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 114:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st180
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st91:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof91
}
st_case_91:
if lex.data[(lex.p)] == 60 {
goto st92
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr130
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st92:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof92
}
st_case_92:
if lex.data[(lex.p)] == 60 {
goto st82
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr130
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st180:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof180
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_180:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 69:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st181
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 101:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st181
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st181:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof181
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_181:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 65:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st182
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 97:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st182
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st182:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof182
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_182:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 75:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr333
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 107:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr333
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st183:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof183
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_183:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 65:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st184
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 70:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st193
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 76:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st200
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 79:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st205
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 97:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st184
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 102:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st193
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 108:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st200
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 111:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st205
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st184:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof184
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_184:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 76:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st185
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 83:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st190
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 84:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st191
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 108:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st185
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 115:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st190
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 116:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st191
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st185:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof185
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_185:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 76:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st186
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 108:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st186
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st186:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof186
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_186:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 65:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st187
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 97:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st187
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st187:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof187
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_187:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 66:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st188
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 98:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st188
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st188:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof188
}
st_case_188:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 76:
goto st189
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 108:
goto st189
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st189:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof189
}
st_case_189:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr345
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr345
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st190:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof190
}
st_case_190:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr346
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr346
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st191:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof191
}
st_case_191:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 67:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st192
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 99:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st192
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st192:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof192
}
st_case_192:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 72:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr348
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 104:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr348
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st193:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof193
}
st_case_193:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 85:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st194
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 117:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st194
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st194:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof194
}
st_case_194:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 78:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st195
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 110:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st195
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st195:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof195
}
st_case_195:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 67:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st196
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 99:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st196
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st196:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof196
}
st_case_196:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 84:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st197
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 116:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st197
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st197:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof197
}
st_case_197:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 73:
goto st198
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 105:
goto st198
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st198:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof198
}
st_case_198:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 79:
goto st199
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 111:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st199
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st199:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof199
}
st_case_199:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 78:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr355
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 110:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr355
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st200:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof200
}
st_case_200:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 65:
goto st201
case 79:
goto st203
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 97:
goto st201
case 111:
goto st203
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st201:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof201
}
st_case_201:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 83:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st202
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 115:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st202
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st202:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof202
}
st_case_202:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 83:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr359
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 115:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr359
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st203:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof203
}
st_case_203:
switch lex.data[(lex.p)] {
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 78:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st204
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 110:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st204
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st204:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof204
}
st_case_204:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr361
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr361
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st205:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof205
}
st_case_205:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 78:
goto st206
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 110:
goto st206
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st206:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof206
}
st_case_206:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 83:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st207
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 84:
goto st208
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 115:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st207
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 116:
goto st208
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st207:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof207
}
st_case_207:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 84:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr365
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 116:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr365
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st208:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof208
}
st_case_208:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 73:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st209
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 105:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st209
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st209:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof209
}
st_case_209:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 78:
goto st210
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 110:
goto st210
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st210:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof210
}
st_case_210:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 85:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st211
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 117:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st211
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st211:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof211
}
st_case_211:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr369
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr369
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st212:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof212
}
st_case_212:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st213
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 73:
goto st222
case 79:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr372
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st213
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 105:
goto st222
case 111:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr372
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st213:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof213
}
st_case_213:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 67:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st214
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 70:
goto st218
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 99:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st214
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 102:
goto st218
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st214:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof214
}
st_case_214:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 76:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st215
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 108:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st215
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st215:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof215
}
st_case_215:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 65:
goto st216
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 97:
goto st216
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st216:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof216
}
st_case_216:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 82:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st217
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 114:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st217
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st217:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof217
}
st_case_217:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr378
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr378
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st218:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof218
}
st_case_218:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 65:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st219
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 97:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st219
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st219:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof219
}
st_case_219:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 85:
goto st220
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 117:
goto st220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st220:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof220
}
st_case_220:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 76:
goto st221
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 108:
goto st221
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st221:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof221
}
st_case_221:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 84:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr382
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 116:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr382
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st222:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof222
}
st_case_222:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr383
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr383
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st223:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof223
}
st_case_223:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 67:
goto st224
case 76:
goto st226
case 77:
goto st230
case 78:
goto st233
case 86:
goto st257
case 88:
goto st259
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 99:
goto st224
case 108:
goto st226
case 109:
goto st230
case 110:
goto st233
case 118:
goto st257
case 120:
goto st259
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st224:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof224
}
st_case_224:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 72:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st225
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 104:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st225
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st225:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof225
}
st_case_225:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 79:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr391
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 111:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr391
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st226:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof226
}
st_case_226:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 83:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st227
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 115:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st227
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st227:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof227
}
st_case_227:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
goto st228
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
goto st228
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st228:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof228
}
st_case_228:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 73:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st229
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr394
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 105:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st229
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr394
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr394
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr394
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr394
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st229:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof229
}
st_case_229:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 70:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr396
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 102:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr396
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st230:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof230
}
st_case_230:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 80:
goto st231
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 112:
goto st231
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st231:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof231
}
st_case_231:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 84:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st232
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 116:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st232
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st232:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof232
}
st_case_232:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 89:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr399
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 121:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr399
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st233:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof233
}
st_case_233:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 68:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st234
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 100:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st234
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st234:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof234
}
st_case_234:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 68:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st235
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 70:
goto st241
case 73:
goto st247
case 83:
goto st248
case 87:
goto st253
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 100:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st235
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 102:
goto st241
case 105:
goto st247
case 115:
goto st248
case 119:
goto st253
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st235:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof235
}
st_case_235:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st236
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st236
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st236:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof236
}
st_case_236:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 67:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st237
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 99:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st237
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st237:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof237
}
st_case_237:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 76:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st238
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 108:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st238
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st238:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof238
}
st_case_238:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 65:
goto st239
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 97:
goto st239
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st239:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof239
}
st_case_239:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 82:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st240
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 114:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st240
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st240:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof240
}
st_case_240:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr411
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr411
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st241:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof241
}
st_case_241:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 79:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st242
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 111:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st242
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st242:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof242
}
st_case_242:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 82:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st243
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 114:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st243
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st243:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof243
}
st_case_243:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st244
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr414
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st244
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr414
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr414
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr414
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr414
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st244:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof244
}
st_case_244:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 65:
goto st245
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 97:
goto st245
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st245:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof245
}
st_case_245:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 67:
goto st246
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 99:
goto st246
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st246:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof246
}
st_case_246:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 72:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr418
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 104:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr418
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st247:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof247
}
st_case_247:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 70:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr419
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 102:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr419
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st248:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof248
}
st_case_248:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 87:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st249
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 119:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st249
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st249:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof249
}
st_case_249:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 73:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st250
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 105:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st250
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st250:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof250
}
st_case_250:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 84:
goto st251
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 116:
goto st251
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st251:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof251
}
st_case_251:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 67:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st252
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 99:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st252
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st252:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof252
}
st_case_252:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 72:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr424
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 104:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr424
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st253:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof253
}
st_case_253:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 72:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st254
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 104:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st254
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st254:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof254
}
st_case_254:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 73:
goto st255
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 105:
goto st255
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st255:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof255
}
st_case_255:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 76:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st256
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 108:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st256
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st256:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof256
}
st_case_256:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr428
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr428
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st257:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof257
}
st_case_257:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 65:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st258
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 97:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st258
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st258:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof258
}
st_case_258:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 76:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr430
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 108:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr430
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st259:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof259
}
st_case_259:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 73:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st260
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 84:
goto st261
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 105:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st260
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 116:
goto st261
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st260:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof260
}
st_case_260:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 84:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr383
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 116:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr383
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st261:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof261
}
st_case_261:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st262
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st262
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st262:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof262
}
st_case_262:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 78:
goto st263
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 110:
goto st263
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st263:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof263
}
st_case_263:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 68:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st264
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 100:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st264
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st264:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof264
}
st_case_264:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 83:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr436
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 115:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr436
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st265:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof265
}
st_case_265:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 73:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st266
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 78:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr438
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 79:
goto st271
case 85:
goto st194
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 105:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st266
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 110:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr438
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 111:
goto st271
case 117:
goto st194
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st266:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof266
}
st_case_266:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 78:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st267
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 110:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st267
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st267:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof267
}
st_case_267:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 65:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st268
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 97:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st268
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st268:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof268
}
st_case_268:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 76:
goto st269
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 108:
goto st269
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st269:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof269
}
st_case_269:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 76:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st270
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr443
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 108:
goto st270
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr443
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr443
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr443
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr443
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st270:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof270
}
st_case_270:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 89:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr445
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 121:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr445
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st271:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof271
}
st_case_271:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 82:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st272
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 114:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st272
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st272:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof272
}
st_case_272:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st273
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr447
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st273
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr447
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr447
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr447
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr447
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st273:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof273
}
st_case_273:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 65:
goto st274
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 97:
goto st274
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st274:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof274
}
st_case_274:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 67:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st275
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 99:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st275
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st275:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof275
}
st_case_275:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 72:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr451
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 104:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr451
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st276:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof276
}
st_case_276:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 76:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st277
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 79:
goto st281
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 108:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st277
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 111:
goto st281
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st277:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof277
}
st_case_277:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 79:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st278
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 111:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st278
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st278:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof278
}
st_case_278:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 66:
goto st279
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 98:
goto st279
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st279:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof279
}
st_case_279:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 65:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st280
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 97:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st280
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st280:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof280
}
st_case_280:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 76:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr457
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 108:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr457
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st281:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof281
}
st_case_281:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 84:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st282
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 116:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st282
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st282:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof282
}
st_case_282:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 79:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr459
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 111:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr459
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st283:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof283
}
st_case_283:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 70:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr460
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 77:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st284
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 78:
goto st292
case 83:
goto st319
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 102:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr460
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 109:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st284
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 110:
goto st292
case 115:
goto st319
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st284:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof284
}
st_case_284:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 80:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st285
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 112:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st285
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st285:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof285
}
st_case_285:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 76:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st286
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 108:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st286
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st286:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof286
}
st_case_286:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 69:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st287
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 101:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st287
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st287:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof287
}
st_case_287:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 77:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st288
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 109:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st288
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st288:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof288
}
st_case_288:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st289
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st289
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st289:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof289
}
st_case_289:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 78:
goto st290
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 110:
goto st290
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st290:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof290
}
st_case_290:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 84:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st291
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 116:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st291
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st291:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof291
}
st_case_291:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 83:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr471
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 115:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr471
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st292:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof292
}
st_case_292:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 67:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st293
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 83:
goto st302
case 84:
goto st313
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 99:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st293
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 115:
goto st302
case 116:
goto st313
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st293:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof293
}
st_case_293:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 76:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st294
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 108:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st294
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st294:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof294
}
st_case_294:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 85:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st295
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 117:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st295
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st295:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof295
}
st_case_295:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
switch lex.data[(lex.p)] {
case 68:
goto st296
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 100:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st296
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st296:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof296
}
st_case_296:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st297
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st297
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st297:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof297
}
st_case_297:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
if lex.data[(lex.p)] == 95 {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st298
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr479
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case lex.data[(lex.p)] > 96:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr479
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr479
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr479
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st298:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof298
}
st_case_298:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 79:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st299
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 111:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st299
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st299:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof299
}
st_case_299:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 78:
goto st300
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 110:
goto st300
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st300:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof300
}
st_case_300:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 67:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st301
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 99:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st301
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st301:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof301
}
st_case_301:
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 69:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr484
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 101:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr484
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st302:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof302
}
st_case_302:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 84:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st303
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 116:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st303
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st303:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof303
}
st_case_303:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 65:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st304
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
goto st309
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 97:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st304
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
goto st309
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st304:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof304
}
st_case_304:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 78:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st305
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 110:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st305
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st305:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof305
}
st_case_305:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 67:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st306
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 99:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st306
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st306:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof306
}
st_case_306:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
goto st307
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
goto st307
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st307:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof307
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_307:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 79:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st308
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 111:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st308
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st308:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof308
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_308:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 70:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr492
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 102:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr492
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st309:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof309
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_309:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 65:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st310
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 97:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st310
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st310:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof310
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_310:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 68:
goto st311
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 100:
goto st311
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st311:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof311
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_311:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 79:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st312
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 111:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st312
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st312:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof312
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_312:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 70:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr496
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 102:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr496
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st313:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof313
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_313:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st314:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_314:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 82:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st315
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 114:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st315
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st315:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof315
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_315:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 70:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st316
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 102:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st316
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st316:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof316
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_316:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 65:
goto st317
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 97:
goto st317
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st317:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof317
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_317:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 67:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st318
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 99:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st318
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st318:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof318
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_318:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 69:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr502
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 101:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr502
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st319:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof319
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_319:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 83:
goto st320
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 115:
goto st320
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st320:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof320
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_320:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st321
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st321
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st321:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof321
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_321:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 84:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr505
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 116:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr505
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st322:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof322
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_322:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 73:
goto st323
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 105:
goto st323
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st323:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof323
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_323:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 83:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st324
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 115:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st324
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st324:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof324
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_324:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 84:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr508
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 116:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr508
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st325:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof325
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_325:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 65:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st326
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
goto st333
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 97:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st326
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
goto st333
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st326:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof326
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_326:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 77:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st327
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 109:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st327
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st327:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof327
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_327:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st328
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st328
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st328:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof328
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_328:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 83:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st329
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 115:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st329
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st329:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof329
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_329:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 80:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st330
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 112:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st330
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st330:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof330
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_330:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 65:
goto st331
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 97:
goto st331
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st331:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof331
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_331:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 67:
goto st332
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 99:
goto st332
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st332:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof332
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_332:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr517
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr517
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st333:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof333
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_333:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 87:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr518
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 119:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr518
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st334:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof334
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_334:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 82:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr519
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 114:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr519
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st335:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof335
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_335:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 82:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st336
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 85:
goto st348
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 114:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st336
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 117:
goto st348
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st336:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof336
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_336:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 73:
goto st337
case 79:
goto st342
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 105:
goto st337
case 111:
goto st342
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st337:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof337
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_337:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 78:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st338
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 86:
goto st339
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 110:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st338
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 118:
goto st339
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st338:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof338
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_338:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 84:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr526
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 116:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr526
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st339:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof339
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_339:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 65:
goto st340
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 97:
goto st340
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st340:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof340
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_340:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 84:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st341
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 116:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st341
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st341:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof341
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_341:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 69:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr529
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 101:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr529
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st342:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof342
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_342:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 84:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st343
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 116:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st343
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st343:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof343
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_343:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st344
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st344
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st344:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof344
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_344:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 67:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st345
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 99:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st345
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st345:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof345
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_345:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 84:
goto st346
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 116:
goto st346
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st346:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof346
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_346:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st347
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st347
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st347:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof347
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_347:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 68:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr535
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 100:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr535
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st348:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof348
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_348:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 66:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st349
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 98:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st349
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st349:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof349
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_349:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 76:
goto st350
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 108:
goto st350
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st350:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof350
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_350:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 73:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st351
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 105:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st351
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st351:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof351
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_351:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 67:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr539
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 99:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr539
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st352:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof352
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_352:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st353
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st353
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st353:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof353
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_353:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 81:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st354
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 84:
goto st363
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 113:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st354
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 116:
goto st363
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st354:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof354
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_354:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 85:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st355
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 117:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st355
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st355:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof355
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_355:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 73:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st356
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 105:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st356
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st356:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof356
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_356:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
switch lex.data[(lex.p)] {
case 82:
goto st357
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 114:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st357
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st357:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof357
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_357:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st358
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st358
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st358:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof358
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_358:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
if lex.data[(lex.p)] == 95 {
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st359
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr547
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case lex.data[(lex.p)] > 96:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr547
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr547
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr547
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st359:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof359
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_359:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 79:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st360
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 111:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st360
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st360:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof360
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_360:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 78:
goto st361
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 110:
goto st361
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st361:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof361
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_361:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 67:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st362
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 99:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st362
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st362:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof362
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_362:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr552
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr552
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st363:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof363
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_363:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 85:
goto st364
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 117:
goto st364
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st364:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof364
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_364:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 82:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st365
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 114:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st365
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st365:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof365
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_365:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 78:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr555
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 110:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr555
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st366:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof366
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_366:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 84:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st367
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 87:
goto st371
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 116:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st367
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 119:
goto st371
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st367:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof367
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_367:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 65:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st368
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 97:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st368
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st368:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof368
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_368:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 84:
goto st369
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 116:
goto st369
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st369:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof369
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_369:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 73:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st370
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 105:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st370
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st370:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof370
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_370:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 67:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr561
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 99:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr561
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st371:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof371
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_371:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 73:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st372
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 105:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st372
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st372:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof372
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_372:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 84:
goto st373
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 116:
goto st373
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st373:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof373
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_373:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 67:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st374
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 99:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto st374
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st374:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof374
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_374:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 72:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr565
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 104:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr565
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st375:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof375
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_375:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 72:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st376
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 82:
goto st379
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 104:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st376
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 114:
goto st379
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st376:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof376
}
st_case_376:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 82:
goto st377
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 114:
goto st377
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st377:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof377
}
st_case_377:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 79:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st378
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 111:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st378
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st378:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof378
}
st_case_378:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 87:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr570
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 119:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr570
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st379:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof379
}
st_case_379:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 65:
goto st380
case 89:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr572
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 97:
goto st380
case 121:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr572
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st380:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof380
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_380:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 73:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st381
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 105:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st381
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st381:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof381
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_381:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 84:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr574
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 116:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr574
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st382:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof382
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_382:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 78:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st383
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 83:
goto st386
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 110:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st383
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 115:
goto st386
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st383:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof383
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_383:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 83:
goto st384
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 115:
goto st384
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st384:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof384
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_384:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 69:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st385
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 101:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st385
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st385:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof385
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_385:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 84:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr579
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 116:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr579
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st386:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof386
}
st_case_386:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr580
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr580
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st387:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof387
}
st_case_387:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 65:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st388
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 97:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st388
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st388:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof388
}
st_case_388:
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 82:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr582
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 114:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr582
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st389:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof389
}
st_case_389:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 72:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st390
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 104:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st390
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st390:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof390
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_390:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 73:
goto st391
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 105:
goto st391
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st391:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof391
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_391:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 76:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st392
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 108:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st392
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st392:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof392
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_392:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr586
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr586
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st393:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof393
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_393:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 79:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st394
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 111:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st394
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st394:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof394
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_394:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 82:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr588
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 114:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr588
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st395:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof395
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_395:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 73:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st396
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 105:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st396
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st396:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof396
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_396:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 69:
goto st397
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
goto st397
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st397:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof397
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_397:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 76:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st398
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 108:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st398
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
case lex.data[(lex.p)] > 64:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st398:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof398
}
st_case_398:
switch lex.data[(lex.p)] {
case 68:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr592
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 100:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr592
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
tr592:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
// line NONE:1
lex.te = (lex.p) + 1
goto st399
st399:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof399
}
st_case_399:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:13996
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr134
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr135
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 32:
goto st93
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr593
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
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 st93
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr593
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 47:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 91:
if 58 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 64 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr593
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr593
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr593
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr593
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
tr137:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st93
st93:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof93
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_93:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:14043
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr134
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr135
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 32:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st93
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 70:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st96
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 102:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st96
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st93
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr132
tr134:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
goto st94
tr138:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st94
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st94:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
goto _test_eof94
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
st_case_94:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:14091
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr138
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr139
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 32:
goto tr137
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 70:
goto tr140
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 102:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr140
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr137
}
goto tr132
tr135:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
goto st95
tr139:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st95
st95:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof95
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_95:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:14139
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
if lex.data[(lex.p)] == 10 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr134
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr132
tr140:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st96
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st96:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof96
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_96:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:14153
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
switch lex.data[(lex.p)] {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 82:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st97
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 114:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st97
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr132
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st97:
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof97
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_97:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 79:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st98
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 111:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st98
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr132
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st98:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof98
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_98:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch lex.data[(lex.p)] {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 77:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr143
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 109:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr143
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr132
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st400:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof400
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_400:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
if lex.data[(lex.p)] == 61 {
goto tr594
}
goto tr248
st401:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof401
}
st_case_401:
if lex.data[(lex.p)] == 95 {
goto st402
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 96:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st402:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof402
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_402:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 67:
goto st403
case 68:
goto st409
case 70:
goto st413
case 72:
goto st426
case 76:
goto st438
case 77:
goto st443
case 78:
goto st450
case 84:
goto st460
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 99:
goto st403
case 100:
goto st409
case 102:
goto st413
case 104:
goto st426
case 108:
goto st438
case 109:
goto st443
case 110:
goto st450
case 116:
goto st460
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st403:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof403
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_403:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 76:
goto st404
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 108:
goto st404
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st404:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof404
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_404:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
switch lex.data[(lex.p)] {
case 65:
goto st405
case 96:
goto tr314
case 97:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st405
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st405:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof405
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_405:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 83:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st406
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 115:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st406
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st406:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof406
}
st_case_406:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 83:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st407
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 115:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st407
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st407:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof407
}
st_case_407:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
if lex.data[(lex.p)] == 95 {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st408
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 96:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st408:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof408
}
st_case_408:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
if lex.data[(lex.p)] == 95 {
goto tr609
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 96:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st409:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof409
}
st_case_409:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 73:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st410
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 105:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st410
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st410:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof410
}
st_case_410:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
switch lex.data[(lex.p)] {
case 82:
goto st411
case 96:
goto tr314
case 114:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st411
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st411:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof411
}
st_case_411:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
if lex.data[(lex.p)] == 95 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st412
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case lex.data[(lex.p)] > 96:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st412:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof412
}
st_case_412:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
if lex.data[(lex.p)] == 95 {
goto tr613
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 96:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st413:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof413
}
st_case_413:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 73:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st414
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 85:
goto st418
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 105:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st414
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 117:
goto st418
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st414:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof414
}
st_case_414:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
switch lex.data[(lex.p)] {
case 76:
goto st415
case 96:
goto tr314
case 108:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st415
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st415:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof415
}
st_case_415:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
switch lex.data[(lex.p)] {
case 69:
goto st416
case 96:
goto tr314
case 101:
goto st416
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st416:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof416
}
st_case_416:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
if lex.data[(lex.p)] == 95 {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st417
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 96:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st417:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof417
}
st_case_417:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
if lex.data[(lex.p)] == 95 {
goto tr619
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 96:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st418:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof418
}
st_case_418:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 78:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st419
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 110:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st419
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st419:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof419
}
st_case_419:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
switch lex.data[(lex.p)] {
case 67:
goto st420
case 96:
goto tr314
case 99:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st420
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st420:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof420
}
st_case_420:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
switch lex.data[(lex.p)] {
case 84:
goto st421
case 96:
goto tr314
case 116:
goto st421
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st421:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof421
}
st_case_421:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 73:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st422
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 105:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st422
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st422:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof422
}
st_case_422:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 79:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st423
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 111:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st423
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st423:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof423
}
st_case_423:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 78:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st424
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 110:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st424
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st424:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof424
}
st_case_424:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
if lex.data[(lex.p)] == 95 {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto st425
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 96:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st425:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof425
}
st_case_425:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
if lex.data[(lex.p)] == 95 {
goto tr627
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 96:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st426:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof426
}
st_case_426:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 65:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st427
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 97:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st427
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st427:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof427
}
st_case_427:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
switch lex.data[(lex.p)] {
case 76:
goto st428
case 96:
goto tr314
case 108:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st428
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st428:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof428
}
st_case_428:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
switch lex.data[(lex.p)] {
case 84:
goto st429
case 96:
goto tr314
case 116:
goto st429
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st429:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof429
}
st_case_429:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
if lex.data[(lex.p)] == 95 {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st430
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 96:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st430:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof430
}
st_case_430:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 67:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st431
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 99:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st431
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st431:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof431
}
st_case_431:
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 79:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st432
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 111:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st432
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st432:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof432
}
st_case_432:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
switch lex.data[(lex.p)] {
case 77:
goto st433
case 96:
goto tr314
case 109:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto st433
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st433:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof433
}
st_case_433:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 80:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st434
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 112:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
goto st434
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st434:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof434
}
st_case_434:
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 73:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st435
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 105:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st435
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st435:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof435
}
st_case_435:
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 76:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st436
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 108:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st436
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st436:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof436
}
st_case_436:
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 69:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st437
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 101:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st437
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st437:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof437
}
st_case_437:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 82:
goto tr639
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 114:
goto tr639
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st438:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof438
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_438:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 73:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st439
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 105:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st439
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st439:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof439
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_439:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 78:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st440
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 110:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st440
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st440:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof440
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_440:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 69:
goto st441
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 101:
goto st441
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st441:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof441
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_441:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
if lex.data[(lex.p)] == 95 {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st442
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 96:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st442:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof442
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_442:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
if lex.data[(lex.p)] == 95 {
goto tr644
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 96:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st443:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof443
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_443:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
switch lex.data[(lex.p)] {
case 69:
goto st444
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 101:
goto st444
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st444:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof444
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_444:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
switch lex.data[(lex.p)] {
case 84:
goto st445
case 96:
goto tr314
case 116:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st445
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st445:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof445
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_445:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
switch lex.data[(lex.p)] {
case 72:
goto st446
case 96:
goto tr314
case 104:
goto st446
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st446:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof446
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_446:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 79:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st447
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 111:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st447
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st447:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof447
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
st_case_447:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 68:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st448
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 100:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto st448
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st448:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof448
}
st_case_448:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
if lex.data[(lex.p)] == 95 {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st449
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 96:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st449:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof449
}
st_case_449:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
if lex.data[(lex.p)] == 95 {
goto tr651
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 96:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st450:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof450
}
st_case_450:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 65:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st451
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 97:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st451
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case lex.data[(lex.p)] > 94:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st451:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof451
}
st_case_451:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
switch lex.data[(lex.p)] {
case 77:
goto st452
case 96:
goto tr314
case 109:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st452
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st452:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof452
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_452:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
switch lex.data[(lex.p)] {
case 69:
goto st453
case 96:
goto tr314
case 101:
goto st453
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st453:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof453
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_453:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 83:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st454
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 115:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st454
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st454:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof454
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_454:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 80:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st455
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 112:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st455
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st455:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof455
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_455:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 65:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st456
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 97:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st456
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st456:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof456
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_456:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 67:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st457
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 99:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st457
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st457:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof457
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_457:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 69:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st458
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 101:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st458
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st458:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof458
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_458:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
if lex.data[(lex.p)] == 95 {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st459
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 96:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st459:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof459
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_459:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
if lex.data[(lex.p)] == 95 {
goto tr661
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 96:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st460:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof460
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_460:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 82:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st461
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 114:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st461
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st461:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof461
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_461:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
switch lex.data[(lex.p)] {
case 65:
goto st462
case 96:
goto tr314
case 97:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st462
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st462:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof462
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_462:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
switch lex.data[(lex.p)] {
case 73:
goto st463
case 96:
goto tr314
case 105:
goto st463
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 94:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st463:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof463
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_463:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 84:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st464
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 116:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st464
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st464:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof464
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_464:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
if lex.data[(lex.p)] == 95 {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st465
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 96:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st465:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof465
}
st_case_465:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
if lex.data[(lex.p)] == 95 {
goto tr667
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
switch {
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
case lex.data[(lex.p)] > 64:
switch {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case lex.data[(lex.p)] > 96:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
case lex.data[(lex.p)] >= 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr220
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st466:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof466
}
st_case_466:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 61:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr668
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 124:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr669
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
tr144:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:379
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
(lex.p) = (lex.te) - 1
{
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st467
tr670:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:382
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
lex.ungetCnt(1)
{
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st467
tr675:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:379
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st467
tr677:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:379
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st467
tr681:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:382
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
lex.ungetCnt(1)
{
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st467
tr682:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:380
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_OBJECT_OPERATOR
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 467
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st467
tr683:
lex.cs = 467
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:381
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_STRING
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st467:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = 0
split scanner and lexer
2017-12-01 13:36:46 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof467
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_467:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = (lex.p)
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:16216
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr145
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr672
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 32:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr671
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 45:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st471
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr670
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 14:
switch {
case lex.data[(lex.p)] > 8:
if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr671
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
default:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr670
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr670
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr670
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr670
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st472
tr671:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st468
tr678:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st468
st468:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof468
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_468:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:16269
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr145
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr676
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 32:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr671
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr671
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr675
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr145:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st469
tr679:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st469
st469:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof469
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_469:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:16319
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr679
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr680
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 32:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr678
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr678
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr677
tr676:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto st99
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr680:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st99
st99:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof99
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_99:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:16363
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if lex.data[(lex.p)] == 10 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr145
}
goto tr144
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr672:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st470
st470:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof470
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_470:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:16385
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
if lex.data[(lex.p)] == 10 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr145
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr681
st471:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof471
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_471:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
if lex.data[(lex.p)] == 62 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr682
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr681
st472:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof472
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_472:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if lex.data[(lex.p)] == 96 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr683
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr683
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr683
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr683
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr683
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st472
tr687:
lex.cs = 473
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.act {
case 0:
{
{
goto st0
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 146:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ENCAPSED_AND_WHITESPACE
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 496
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
}
split scanner and lexer
2017-12-01 13:36:46 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr688:
lex.cs = 473
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:386
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ENCAPSED_AND_WHITESPACE
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 496
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
{
(lex.p)++
goto _out
}
}
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr692:
lex.cs = 473
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:386
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ENCAPSED_AND_WHITESPACE
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 496
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st473:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = 0
split scanner and lexer
2017-12-01 13:36:46 +00:00
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.act = 0
split scanner and lexer
2017-12-01 13:36:46 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof473
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_473:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = (lex.p)
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:16482
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_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
}
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
switch _widec {
case 1034:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr685
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 1037:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr686
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 1024 <= _widec && _widec <= 1279 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr684
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
goto st0
st_case_0:
st0:
lex.cs = 0
goto _out
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr684:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:386
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 146
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st474
tr689:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:386
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 146
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st474
st474:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof474
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_474:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:16556
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_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
}
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
switch _widec {
case 1034:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr685
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 1037:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr686
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 1024 <= _widec && _widec <= 1279 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr684
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr687
tr685:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st475
tr690:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st475
st475:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof475
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_475:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:16636
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_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
}
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
switch _widec {
case 1034:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr690
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 1037:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr691
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 1024 <= _widec && _widec <= 1279 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr689
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr688
tr686:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st476
tr691:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st476
st476:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof476
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_476:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:16716
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
_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
}
}
switch _widec {
case 1034:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr685
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 1037:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr686
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if 1024 <= _widec && _widec <= 1279 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr684
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr692
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr146:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:395
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
lex.ungetCnt(1)
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_CURLY_OPEN
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.call(477, 123)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st477
tr700:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:397
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
lex.ungetCnt(1)
{
lex.growCallStack()
{
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.stack[lex.top] = 477
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.top++
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st498
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
}
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st477
tr701:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:396
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DOLLAR_OPEN_CURLY_BRACES
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.call(477, 513)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st477
tr702:
lex.cs = 477
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.act {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 147:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
lex.ungetCnt(1)
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_CURLY_OPEN
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.call(477, 123)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 148:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DOLLAR_OPEN_CURLY_BRACES
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.call(477, 513)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 150:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
split scanner and lexer
2017-12-01 13:36:46 +00:00
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ENCAPSED_AND_WHITESPACE
split scanner and lexer
2017-12-01 13:36:46 +00:00
[#82] Lexer: handle PHP 7.3 heredoc
2019-12-26 13:41:06 +00:00
if len(lex.data) > lex.p+1 && lex.data[lex.p+1] != '$' && lex.data[lex.p+1] != '{' {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 496
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
{
(lex.p)++
goto _out
}
}
}
split scanner and lexer
2017-12-01 13:36:46 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr703:
lex.cs = 477
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:398
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ENCAPSED_AND_WHITESPACE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
[#82] Lexer: handle PHP 7.3 heredoc
2019-12-26 13:41:06 +00:00
if len(lex.data) > lex.p+1 && lex.data[lex.p+1] != '$' && lex.data[lex.p+1] != '{' {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 496
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
{
(lex.p)++
goto _out
}
}
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr707:
lex.cs = 477
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:398
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ENCAPSED_AND_WHITESPACE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
[#82] Lexer: handle PHP 7.3 heredoc
2019-12-26 13:41:06 +00:00
if len(lex.data) > lex.p+1 && lex.data[lex.p+1] != '$' && lex.data[lex.p+1] != '{' {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 496
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
{
(lex.p)++
goto _out
}
}
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st477:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = 0
split scanner and lexer
2017-12-01 13:36:46 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof477
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_477:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = (lex.p)
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:16848
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_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:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st478
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 1403:
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto st100
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 1546:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr696
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 1549:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr697
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 1572:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st482
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 1659:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st483
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 1536 <= _widec && _widec <= 1791 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr695
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
goto st0
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st478:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof478
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_478:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if lex.data[(lex.p)] == 123 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr701
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr700
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st100:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof100
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_100:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if lex.data[(lex.p)] == 36 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr146
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
goto st0
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr695:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:398
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 150
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st479
tr704:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:398
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 150
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st479
tr708:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:396
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 148
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st479
tr709:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:395
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 147
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st479
st479:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof479
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_479:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:16958
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_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
}
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
switch _widec {
case 1546:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr696
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 1549:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr697
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 1536 <= _widec && _widec <= 1791 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr695
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr702
tr696:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st480
tr705:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st480
st480:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof480
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_480:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:17038
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_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
}
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
switch _widec {
case 1546:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr705
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 1549:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr706
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 1536 <= _widec && _widec <= 1791 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr704
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr703
tr697:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st481
tr706:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st481
st481:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof481
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_481:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:17118
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
_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 1546:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr696
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 1549:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr697
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if 1536 <= _widec && _widec <= 1791 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr695
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr707
st482:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof482
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_482:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_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:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr701
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 1546:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr696
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 1549:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr697
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 1659:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr708
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 1536 <= _widec && _widec <= 1791 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr695
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr700
st483:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof483
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_483:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_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:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr146
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 1546:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr696
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 1549:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr697
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 1572:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr709
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 1536 <= _widec && _widec <= 1791 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr695
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr707
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr148:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:412
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.te = (lex.p) + 1
{
lex.ungetCnt(2)
{
lex.growCallStack()
{
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.stack[lex.top] = 484
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.top++
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st498
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
}
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st484
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr149:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:411
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DOLLAR_OPEN_CURLY_BRACES
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.call(484, 513)
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _out
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st484
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr150:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:410
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
lex.ungetCnt(1)
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_CURLY_OPEN
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.call(484, 123)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st484
tr711:
lex.cs = 484
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:413
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int('`'))
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr719:
lex.cs = 484
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.act {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 151:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
lex.ungetCnt(1)
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_CURLY_OPEN
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.call(484, 123)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 152:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DOLLAR_OPEN_CURLY_BRACES
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.call(484, 513)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 153:
{
(lex.p) = (lex.te) - 1
lex.ungetCnt(2)
{
lex.growCallStack()
{
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.stack[lex.top] = 484
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.top++
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st498
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 154:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int('`'))
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 155:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ENCAPSED_AND_WHITESPACE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
}
split scanner and lexer
2017-12-01 13:36:46 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr720:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:414
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ENCAPSED_AND_WHITESPACE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 484
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st484
tr724:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:414
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ENCAPSED_AND_WHITESPACE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 484
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st484
st484:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = 0
split scanner and lexer
2017-12-01 13:36:46 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof484
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_484:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = (lex.p)
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:17361
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_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:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st101
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 1888:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr711
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 1915:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st102
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 2058:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr714
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 2061:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr715
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 2084:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st488
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 2144:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr717
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 2171:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st489
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 2048 <= _widec && _widec <= 2303 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr713
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
goto st0
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st101:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof101
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
st_case_101:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
switch lex.data[(lex.p)] {
case 96:
goto st0
case 123:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr149
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
switch {
case lex.data[(lex.p)] < 91:
if lex.data[(lex.p)] <= 64 {
goto st0
}
case lex.data[(lex.p)] > 94:
if 124 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
goto st0
}
default:
goto st0
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr148
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st102:
if (lex.p)++; (lex.p) == (lex.pe) {
goto _test_eof102
}
st_case_102:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if lex.data[(lex.p)] == 36 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr150
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
goto st0
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr713:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:414
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 155
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st485
tr717:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:413
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 154
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st485
tr721:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:414
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 155
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st485
tr725:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
// line NONE:1
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:412
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.act = 153
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st485
tr726:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:411
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 152
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st485
tr727:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:410
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 151
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st485
st485:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof485
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_485:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:17504
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_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
}
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
switch _widec {
case 2058:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr714
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 2061:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr715
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 2048 <= _widec && _widec <= 2303 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr713
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr719
tr714:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st486
tr722:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st486
st486:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof486
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_486:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:17584
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_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
}
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
switch _widec {
case 2058:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr722
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 2061:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr723
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 2048 <= _widec && _widec <= 2303 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr721
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr720
tr715:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st487
tr723:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st487
st487:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof487
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_487:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:17664
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_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 2058:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr714
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 2061:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr715
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if 2048 <= _widec && _widec <= 2303 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr713
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr724
st488:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof488
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_488:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
_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 1887:
goto tr148
case 1915:
goto tr149
case 2058:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr714
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 2061:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr715
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 2143:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr725
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 2171:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr726
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
switch {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case _widec < 2113:
switch {
case _widec < 1889:
if 1857 <= _widec && _widec <= 1882 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr148
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
case _widec > 1914:
switch {
case _widec > 2047:
if 2048 <= _widec && _widec <= 2112 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr713
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
case _widec >= 1920:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr148
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr148
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
case _widec > 2138:
switch {
case _widec < 2145:
if 2139 <= _widec && _widec <= 2144 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr713
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
case _widec > 2170:
switch {
case _widec > 2175:
if 2176 <= _widec && _widec <= 2303 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr725
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
case _widec >= 2172:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr713
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
default:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr725
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
default:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr725
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr724
st489:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof489
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_489:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_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:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr150
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 2058:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr714
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 2061:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr715
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 2084:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr727
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 2048 <= _widec && _widec <= 2303 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr713
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr724
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr151:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:424
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.te = (lex.p) + 1
{
lex.ungetCnt(2)
{
lex.growCallStack()
{
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.stack[lex.top] = 490
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.top++
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st498
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
}
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st490
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr152:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:423
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DOLLAR_OPEN_CURLY_BRACES
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.call(490, 513)
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _out
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st490
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr153:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:422
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
lex.ungetCnt(1)
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_CURLY_OPEN
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.call(490, 123)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st490
tr728:
lex.cs = 490
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:425
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int('"'))
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr737:
lex.cs = 490
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.act {
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 156:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
lex.ungetCnt(1)
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_CURLY_OPEN
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.call(490, 123)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 157:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_DOLLAR_OPEN_CURLY_BRACES
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.call(490, 513)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 158:
{
(lex.p) = (lex.te) - 1
lex.ungetCnt(2)
{
lex.growCallStack()
{
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.stack[lex.top] = 490
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.top++
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st498
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
}
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 159:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int('"'))
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 160:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ENCAPSED_AND_WHITESPACE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
}
#56: now, `__halt_compiler();` terminates parsing process
2018-07-24 18:49:26 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr738:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:426
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ENCAPSED_AND_WHITESPACE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 490
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st490
tr742:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:426
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ENCAPSED_AND_WHITESPACE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 490
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st490
st490:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = 0
split scanner and lexer
2017-12-01 13:36:46 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof490
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_490:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = (lex.p)
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:17948
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_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
}
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
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
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
}
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
default:
_widec = 2304 + (int16(lex.data[(lex.p)]) - 0)
if lex.isNotStringEnd('"') && lex.isNotStringVar() {
_widec += 256
}
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch _widec {
case 2338:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr728
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 2340:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st103
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 2427:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st104
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 2570:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr732
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 2573:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr733
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 2594:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr734
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 2596:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st494
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 2683:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st495
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 2560 <= _widec && _widec <= 2815 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr731
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
goto st0
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st103:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof103
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_103:
switch lex.data[(lex.p)] {
case 96:
goto st0
case 123:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr152
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
switch {
case lex.data[(lex.p)] < 91:
if lex.data[(lex.p)] <= 64 {
goto st0
}
case lex.data[(lex.p)] > 94:
if 124 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
goto st0
}
default:
goto st0
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr151
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st104:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof104
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_104:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if lex.data[(lex.p)] == 36 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr153
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
goto st0
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr731:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:426
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 160
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st491
tr734:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:425
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 159
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st491
tr739:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:426
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 160
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st491
tr743:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
// line NONE:1
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:424
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.act = 158
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st491
tr744:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:423
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 157
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st491
tr745:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:422
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 156
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st491
st491:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof491
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_491:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:18091
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_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
}
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
switch _widec {
case 2570:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr732
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 2573:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr733
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 2560 <= _widec && _widec <= 2815 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr731
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr737
tr732:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st492
tr740:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st492
st492:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof492
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_492:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:18171
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_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
}
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
switch _widec {
case 2570:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr740
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 2573:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr741
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 2560 <= _widec && _widec <= 2815 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr739
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr738
tr733:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st493
tr741:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st493
st493:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof493
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_493:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:18251
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_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 2570:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr732
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 2573:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr733
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if 2560 <= _widec && _widec <= 2815 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr731
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr742
st494:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof494
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_494:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_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 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 2399:
goto tr151
case 2427:
goto tr152
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 2570:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr732
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 2573:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr733
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 2655:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr743
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 2683:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr744
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
switch {
case _widec < 2625:
switch {
case _widec < 2401:
if 2369 <= _widec && _widec <= 2394 {
goto tr151
}
case _widec > 2426:
switch {
case _widec > 2559:
if 2560 <= _widec && _widec <= 2624 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr731
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
case _widec >= 2432:
goto tr151
}
default:
goto tr151
}
case _widec > 2650:
switch {
case _widec < 2657:
if 2651 <= _widec && _widec <= 2656 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr731
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
case _widec > 2682:
switch {
case _widec > 2687:
if 2688 <= _widec && _widec <= 2815 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr743
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
case _widec >= 2684:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr731
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
default:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr743
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
default:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr743
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr742
st495:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof495
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_495:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
_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 2340:
goto tr153
case 2570:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr732
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 2573:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr733
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 2596:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr745
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 2560 <= _widec && _widec <= 2815 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr731
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr742
tr747:
lex.cs = 496
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:434
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_END_HEREDOC
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st496:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = 0
split scanner and lexer
2017-12-01 13:36:46 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof496
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_496:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = (lex.p)
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:18478
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if lex.data[(lex.p)] == 96 {
goto st0
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 91:
if lex.data[(lex.p)] <= 64 {
goto st0
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
goto st0
}
default:
goto st0
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st497
st497:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof497
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_497:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if lex.data[(lex.p)] == 96 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr747
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr747
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr747
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr747
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr747
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st497
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr154:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:453
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
(lex.p) = (lex.te) - 1
{
lex.ungetCnt(1)
{
lex.top--
lex.cs = lex.stack[lex.top]
goto _again
fix lexer bugs: single quoted string with backslash and hnum, bnum out of range
2017-12-06 10:35:05 +00:00
}
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st498
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr155:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:450
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
lex.ungetCnt(1)
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_OBJECT_OPERATOR
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 498
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st498
tr748:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:453
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
lex.ungetCnt(1)
{
lex.top--
lex.cs = lex.stack[lex.top]
goto _again
}
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st498
tr752:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:452
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int('['))
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.call(498, 503)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st498
tr753:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:453
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
lex.ungetCnt(1)
{
lex.top--
lex.cs = lex.stack[lex.top]
goto _again
fix lexer bugs: single quoted string with backslash and hnum, bnum out of range
2017-12-06 10:35:05 +00:00
}
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st498
tr755:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:449
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_VARIABLE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 498
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st498
tr757:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:451
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_STRING
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 498
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st498
st498:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = 0
issue #2 - fix single line comment fix handling end of file add handling php close tag
2018-03-30 14:15:26 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof498
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_498:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = (lex.p)
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:18570
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 36:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st499
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 45:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr750
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr752
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 96:
goto tr748
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 92:
if lex.data[(lex.p)] <= 64 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr748
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr748
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
default:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr748
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st502
st499:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof499
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_499:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if lex.data[(lex.p)] == 96 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr753
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 91:
if lex.data[(lex.p)] <= 64 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr753
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr753
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
default:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr753
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st500
st500:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof500
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_500:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if lex.data[(lex.p)] == 96 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr755
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr755
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr755
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr755
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr755
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st500
tr750:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st501
st501:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof501
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_501:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:18651
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if lex.data[(lex.p)] == 62 {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st105
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr753
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st105:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof105
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_105:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if lex.data[(lex.p)] == 96 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr154
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 91:
if lex.data[(lex.p)] <= 64 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr154
issue #2 - fix single line comment fix handling end of file add handling php close tag
2018-03-30 14:15:26 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr154
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr154
issue #2 - fix single line comment fix handling end of file add handling php close tag
2018-03-30 14:15:26 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr155
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st502:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof502
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_502:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if lex.data[(lex.p)] == 96 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr757
handle php doc comments
2018-01-02 11:53:55 +00:00
}
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr757
handle php doc comments
2018-01-02 11:53:55 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr757
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr757
handle php doc comments
2018-01-02 11:53:55 +00:00
}
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
default:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr757
handle php doc comments
2018-01-02 11:53:55 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st502
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr156:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:457
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
(lex.p) = (lex.te) - 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_NUM_STRING
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 503
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
handle php doc comments
2018-01-02 11:53:55 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st503
tr758:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:463
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
c := lex.data[lex.p]
[refactoring] move errors from scanner to parser
2020-05-18 17:07:17 +00:00
lex.error(fmt.Sprintf("WARNING: Unexpected character in input: '%c' (ASCII=%d)", c, c))
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st503
tr759:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:460
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ENCAPSED_AND_WHITESPACE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ret(2)
goto _out
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st503
tr762:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:461
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int(lex.data[lex.ts]))
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 503
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st503
tr766:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:462
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int(']'))
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ret(2)
goto _out
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st503
tr767:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:460
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_ENCAPSED_AND_WHITESPACE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ret(2)
goto _out
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st503
tr768:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:463
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
c := lex.data[lex.p]
[refactoring] move errors from scanner to parser
2020-05-18 17:07:17 +00:00
lex.error(fmt.Sprintf("WARNING: Unexpected character in input: '%c' (ASCII=%d)", c, c))
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st503
tr769:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:461
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int(lex.data[lex.ts]))
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 503
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st503
tr771:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:458
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_VARIABLE
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 503
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st503
tr772:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:457
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_NUM_STRING
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 503
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st503
tr776:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:459
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_STRING
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 503
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _out
}
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st503
st503:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = 0
split scanner and lexer
2017-12-01 13:36:46 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof503
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_503:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = (lex.p)
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:18783
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr760
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 13:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr761
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 32:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr759
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 33:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr762
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 35:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr759
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 36:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st506
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 39:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr759
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 48:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr764
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 92:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr759
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 93:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr766
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr758
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 124:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr762
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 126:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr762
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 37:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 9:
if lex.data[(lex.p)] <= 8 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr758
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case lex.data[(lex.p)] > 12:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if 14 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 34 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr758
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
default:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr759
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 47:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if 49 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr157
fix bugs: multibyte chars, null pointer in a list
2018-01-10 12:35:08 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr758
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr762
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
default:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr762
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
default:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr762
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st512
tr760:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st504
st504:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof504
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_504:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:18865
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr767
tr761:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st505
st505:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof505
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_505:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:18884
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
if lex.data[(lex.p)] == 10 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr760
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr768
st506:
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof506
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_506:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if lex.data[(lex.p)] == 96 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr769
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 91:
if lex.data[(lex.p)] <= 64 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr769
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr769
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
default:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr769
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st507
st507:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof507
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_507:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if lex.data[(lex.p)] == 96 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr771
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr771
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr771
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr771
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr771
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st507
tr764:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st508
st508:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof508
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_508:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:18946
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 95:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st106
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 98:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st107
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 120:
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st108
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr157
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr772
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr157:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
lex.te = (lex.p) + 1
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st509
st509:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof509
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_509:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:18969
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
if lex.data[(lex.p)] == 95 {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st106
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr157
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr772
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st106:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof106
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_106:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr157
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr156
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st107:
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof107
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_107:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 49 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr158
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr156
tr158:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
lex.te = (lex.p) + 1
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st510
st510:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof510
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_510:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19005
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
if lex.data[(lex.p)] == 95 {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st107
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 49 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr158
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr772
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st108:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof108
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_108:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch {
case lex.data[(lex.p)] < 65:
if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr159
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
case lex.data[(lex.p)] > 70:
if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr159
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr159
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr156
tr159:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
lex.te = (lex.p) + 1
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st511
st511:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof511
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_511:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19041
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
if lex.data[(lex.p)] == 95 {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st108
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
case lex.data[(lex.p)] < 65:
if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr159
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
case lex.data[(lex.p)] > 70:
if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr159
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr159
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr772
st512:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof512
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_512:
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if lex.data[(lex.p)] == 96 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr776
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr776
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr776
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 91:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr776
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr776
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st512
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr160:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 513
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:471
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
(lex.p) = (lex.te) - 1
{
lex.ungetCnt(1)
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
goto _again
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr162:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 513
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:470
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
lex.ungetCnt(1)
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.T_STRING_VARNAME
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr777:
lex.cs = 513
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:471
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
lex.ungetCnt(1)
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr779:
lex.cs = 513
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:471
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
lex.ungetCnt(1)
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st513:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = 0
split scanner and lexer
2017-12-01 13:36:46 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof513
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_513:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = (lex.p)
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19120
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
if lex.data[(lex.p)] == 96 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr777
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 91:
if lex.data[(lex.p)] <= 64 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr777
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr777
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
default:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr777
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr778
tr778:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st514
st514:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof514
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_514:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19147
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr162
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr779
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 125:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr162
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr779
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr779
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 92:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr779
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
default:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr779
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st109
st109:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof109
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_109:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr162
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr160
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 125:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr162
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
switch {
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] < 58:
if lex.data[(lex.p)] <= 47 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr160
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case lex.data[(lex.p)] > 64:
switch {
case lex.data[(lex.p)] > 94:
if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr160
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
}
case lex.data[(lex.p)] >= 92:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr160
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
default:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr160
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st109
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr163:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:475
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
(lex.p) = (lex.te) - 1
{
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st515
tr780:
lex.cs = 515
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:477
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
lex.ungetCnt(1)
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr783:
lex.cs = 515
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:476
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int('('))
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 519
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr784:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:475
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st515
tr786:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:475
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st515
tr790:
lex.cs = 515
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:477
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
lex.ungetCnt(1)
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st515:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = 0
split scanner and lexer
2017-12-01 13:36:46 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof515
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_515:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = (lex.p)
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19254
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr164
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr782
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 32:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr781
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 40:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr783
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr781
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr780
tr781:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st516
tr787:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st516
st516:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof516
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_516:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19286
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr164
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr785
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 32:
goto tr781
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr781
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr784
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr164:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st517
tr788:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st517
st517:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof517
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_517:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19336
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr788
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr789
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 32:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr787
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr787
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr786
tr785:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
goto st110
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr789:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st110
st110:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof110
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_110:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19380
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if lex.data[(lex.p)] == 10 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr164
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr163
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr782:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st518
st518:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof518
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_518:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19402
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if lex.data[(lex.p)] == 10 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr164
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr790
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr165:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:481
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
(lex.p) = (lex.te) - 1
{
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st519
tr791:
lex.cs = 519
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:483
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
lex.ungetCnt(1)
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr794:
lex.cs = 519
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:482
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int(')'))
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 523
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr795:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:481
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st519
tr797:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:481
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st519
tr801:
lex.cs = 519
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:483
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
lex.ungetCnt(1)
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st519:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = 0
split scanner and lexer
2017-12-01 13:36:46 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof519
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_519:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = (lex.p)
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19456
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr166
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr793
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 32:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr792
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 41:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr794
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr792
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr791
tr792:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st520
tr798:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st520
st520:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof520
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_520:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19488
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr166
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr796
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 32:
goto tr792
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr792
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr795
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr166:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st521
tr799:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st521
st521:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof521
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_521:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19538
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr799
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr800
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 32:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr798
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr798
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr797
tr796:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
goto st111
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr800:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st111
st111:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof111
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_111:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19582
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if lex.data[(lex.p)] == 10 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr166
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr165
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr793:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st522
st522:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof522
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_522:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19604
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if lex.data[(lex.p)] == 10 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr166
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr801
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr167:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:487
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
(lex.p) = (lex.te) - 1
{
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st523
tr802:
lex.cs = 523
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:489
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
lex.ungetCnt(1)
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr805:
lex.cs = 523
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:488
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
{
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
lex.setTokenPosition(tkn)
tok = token.ID(int(';'))
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
lex.cs = 527
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p)++
goto _out
}
}
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr806:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:487
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st523
tr808:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:487
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st523
tr812:
lex.cs = 523
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:489
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
lex.ungetCnt(1)
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
lex.cs = 123
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
goto _again
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st523:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = 0
split scanner and lexer
2017-12-01 13:36:46 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof523
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_523:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = (lex.p)
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19658
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr168
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr804
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 32:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr803
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 59:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr805
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr803
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr802
tr803:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st524
tr809:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st524
st524:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof524
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_524:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19690
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr168
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr807
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 32:
goto tr803
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr803
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr806
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
tr168:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st525
tr810:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st525
st525:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof525
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_525:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19740
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.data[(lex.p)] {
case 10:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr810
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr811
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 32:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr809
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr809
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr808
tr807:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
goto st112
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr811:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto st112
st112:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
goto _test_eof112
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
st_case_112:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19784
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if lex.data[(lex.p)] == 10 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr168
}
goto tr167
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
tr804:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st526
st526:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof526
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_526:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19806
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if lex.data[(lex.p)] == 10 {
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr168
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr812
tr816:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
switch lex.act {
case 0:
{
{
goto st0
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
}
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 186:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
{
(lex.p) = (lex.te) - 1
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_HALT_COMPILER, lex.ts, lex.te)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st527
tr817:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:493
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_HALT_COMPILER, lex.ts, lex.te)
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st527
tr821:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:493
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
lex.te = (lex.p)
(lex.p)--
{
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
lex.addFreeFloatingToken(tkn, token.T_HALT_COMPILER, lex.ts, lex.te)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st527
st527:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = 0
split scanner and lexer
2017-12-01 13:36:46 +00:00
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.act = 0
split scanner and lexer
2017-12-01 13:36:46 +00:00
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof527
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_527:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.ts = (lex.p)
split scanner and lexer
2017-12-01 13:36:46 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19850
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
switch lex.data[(lex.p)] {
case 10:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr814
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 13:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr815
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr813
tr813:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:493
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 186
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st528
tr818:
[refactoring] scanner DefaultConfig
2020-05-18 18:40:49 +00:00
// line NONE:1
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
lex.te = (lex.p) + 1
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:493
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
lex.act = 186
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st528
st528:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof528
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_528:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19879
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
switch lex.data[(lex.p)] {
case 10:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr814
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 13:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr815
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr813
tr814:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st529
tr819:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st529
st529:
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof529
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_529:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19918
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
switch lex.data[(lex.p)] {
case 10:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr819
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 13:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr820
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr818
tr815:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st530
tr820:
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:54
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
[refactoring] update Token structure
2020-12-07 23:23:48 +00:00
// line internal/scanner/scanner.rl:38
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if lex.data[lex.p] == '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' {
Merge branch 'master' into refactoring
2020-07-29 20:23:44 +00:00
lex.newLines.Append(lex.p + 1)
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto st530
st530:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
if (lex.p)++; (lex.p) == (lex.pe) {
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto _test_eof530
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
st_case_530:
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.go:19957
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
switch lex.data[(lex.p)] {
case 10:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr814
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 13:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr815
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
}
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr813
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
st_out:
_test_eof113:
lex.cs = 113
goto _test_eof
_test_eof114:
lex.cs = 114
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof1:
lex.cs = 1
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof115:
lex.cs = 115
goto _test_eof
_test_eof116:
lex.cs = 116
goto _test_eof
_test_eof117:
lex.cs = 117
goto _test_eof
_test_eof118:
lex.cs = 118
goto _test_eof
_test_eof119:
lex.cs = 119
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof120:
lex.cs = 120
goto _test_eof
_test_eof121:
lex.cs = 121
goto _test_eof
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
_test_eof2:
lex.cs = 2
goto _test_eof
_test_eof3:
lex.cs = 3
goto _test_eof
_test_eof4:
lex.cs = 4
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof122:
lex.cs = 122
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _test_eof
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
_test_eof5:
lex.cs = 5
goto _test_eof
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
_test_eof123:
lex.cs = 123
goto _test_eof
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
_test_eof124:
lex.cs = 124
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _test_eof
_test_eof125:
lex.cs = 125
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof6:
lex.cs = 6
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof126:
lex.cs = 126
goto _test_eof
_test_eof127:
lex.cs = 127
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof128:
lex.cs = 128
goto _test_eof
_test_eof129:
lex.cs = 129
goto _test_eof
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
_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
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
_test_eof130:
lex.cs = 130
goto _test_eof
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
_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
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof135:
lex.cs = 135
goto _test_eof
_test_eof136:
lex.cs = 136
goto _test_eof
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
_test_eof11:
lex.cs = 11
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _test_eof
_test_eof12:
lex.cs = 12
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof137:
lex.cs = 137
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof13:
lex.cs = 13
goto _test_eof
_test_eof14:
lex.cs = 14
goto _test_eof
_test_eof15:
lex.cs = 15
goto _test_eof
_test_eof16:
lex.cs = 16
goto _test_eof
_test_eof17:
lex.cs = 17
goto _test_eof
_test_eof18:
lex.cs = 18
goto _test_eof
_test_eof19:
lex.cs = 19
goto _test_eof
_test_eof20:
lex.cs = 20
goto _test_eof
_test_eof21:
lex.cs = 21
goto _test_eof
_test_eof22:
lex.cs = 22
goto _test_eof
_test_eof23:
lex.cs = 23
goto _test_eof
_test_eof24:
lex.cs = 24
goto _test_eof
_test_eof25:
lex.cs = 25
goto _test_eof
_test_eof26:
lex.cs = 26
goto _test_eof
_test_eof27:
lex.cs = 27
goto _test_eof
_test_eof28:
lex.cs = 28
goto _test_eof
_test_eof29:
lex.cs = 29
goto _test_eof
_test_eof30:
lex.cs = 30
goto _test_eof
_test_eof31:
lex.cs = 31
goto _test_eof
_test_eof32:
lex.cs = 32
goto _test_eof
_test_eof33:
lex.cs = 33
goto _test_eof
_test_eof34:
lex.cs = 34
goto _test_eof
_test_eof35:
lex.cs = 35
goto _test_eof
_test_eof36:
lex.cs = 36
goto _test_eof
_test_eof37:
lex.cs = 37
goto _test_eof
_test_eof38:
lex.cs = 38
goto _test_eof
_test_eof39:
lex.cs = 39
goto _test_eof
_test_eof40:
lex.cs = 40
goto _test_eof
_test_eof41:
lex.cs = 41
goto _test_eof
_test_eof42:
lex.cs = 42
goto _test_eof
_test_eof43:
lex.cs = 43
goto _test_eof
_test_eof44:
lex.cs = 44
goto _test_eof
_test_eof45:
lex.cs = 45
goto _test_eof
_test_eof46:
lex.cs = 46
goto _test_eof
_test_eof47:
lex.cs = 47
goto _test_eof
_test_eof48:
lex.cs = 48
goto _test_eof
_test_eof49:
lex.cs = 49
goto _test_eof
_test_eof50:
lex.cs = 50
goto _test_eof
_test_eof51:
lex.cs = 51
goto _test_eof
_test_eof52:
lex.cs = 52
goto _test_eof
_test_eof53:
lex.cs = 53
goto _test_eof
_test_eof54:
lex.cs = 54
goto _test_eof
_test_eof55:
lex.cs = 55
goto _test_eof
_test_eof56:
lex.cs = 56
goto _test_eof
_test_eof57:
lex.cs = 57
goto _test_eof
_test_eof58:
lex.cs = 58
goto _test_eof
_test_eof59:
lex.cs = 59
goto _test_eof
_test_eof60:
lex.cs = 60
goto _test_eof
_test_eof61:
lex.cs = 61
goto _test_eof
_test_eof62:
lex.cs = 62
goto _test_eof
_test_eof63:
lex.cs = 63
goto _test_eof
_test_eof64:
lex.cs = 64
goto _test_eof
_test_eof65:
lex.cs = 65
goto _test_eof
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
_test_eof66:
lex.cs = 66
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
_test_eof138:
lex.cs = 138
goto _test_eof
_test_eof139:
lex.cs = 139
goto _test_eof
_test_eof140:
lex.cs = 140
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof141:
lex.cs = 141
goto _test_eof
_test_eof142:
lex.cs = 142
goto _test_eof
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
_test_eof67:
lex.cs = 67
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof143:
lex.cs = 143
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
_test_eof68:
lex.cs = 68
goto _test_eof
_test_eof69:
lex.cs = 69
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof144:
lex.cs = 144
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof70:
lex.cs = 70
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof145:
lex.cs = 145
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof71:
lex.cs = 71
goto _test_eof
_test_eof72:
lex.cs = 72
goto _test_eof
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
_test_eof73:
lex.cs = 73
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof146:
lex.cs = 146
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof147:
lex.cs = 147
goto _test_eof
_test_eof148:
lex.cs = 148
goto _test_eof
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
_test_eof74:
lex.cs = 74
goto _test_eof
_test_eof75:
lex.cs = 75
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof149:
lex.cs = 149
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
_test_eof76:
lex.cs = 76
goto _test_eof
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
_test_eof150:
lex.cs = 150
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof151:
lex.cs = 151
goto _test_eof
_test_eof152:
lex.cs = 152
goto _test_eof
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
_test_eof77:
lex.cs = 77
goto _test_eof
_test_eof78:
lex.cs = 78
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof79:
lex.cs = 79
goto _test_eof
_test_eof80:
lex.cs = 80
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof153:
lex.cs = 153
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof154:
lex.cs = 154
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof81:
lex.cs = 81
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof155:
lex.cs = 155
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof156:
lex.cs = 156
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof82:
lex.cs = 82
goto _test_eof
_test_eof83:
lex.cs = 83
goto _test_eof
_test_eof84:
lex.cs = 84
goto _test_eof
_test_eof85:
lex.cs = 85
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof157:
lex.cs = 157
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof86:
lex.cs = 86
goto _test_eof
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
_test_eof87:
lex.cs = 87
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _test_eof
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
_test_eof88:
lex.cs = 88
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _test_eof
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
_test_eof89:
lex.cs = 89
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof158:
lex.cs = 158
goto _test_eof
_test_eof159:
lex.cs = 159
goto _test_eof
_test_eof160:
lex.cs = 160
goto _test_eof
_test_eof161:
lex.cs = 161
goto _test_eof
_test_eof162:
lex.cs = 162
goto _test_eof
_test_eof163:
lex.cs = 163
goto _test_eof
_test_eof164:
lex.cs = 164
goto _test_eof
_test_eof165:
lex.cs = 165
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof90:
lex.cs = 90
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof166:
lex.cs = 166
goto _test_eof
_test_eof167:
lex.cs = 167
goto _test_eof
_test_eof168:
lex.cs = 168
goto _test_eof
_test_eof169:
lex.cs = 169
goto _test_eof
_test_eof170:
lex.cs = 170
goto _test_eof
_test_eof171:
lex.cs = 171
goto _test_eof
_test_eof172:
lex.cs = 172
goto _test_eof
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
_test_eof173:
lex.cs = 173
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof174:
lex.cs = 174
goto _test_eof
_test_eof175:
lex.cs = 175
goto _test_eof
_test_eof176:
lex.cs = 176
goto _test_eof
_test_eof177:
lex.cs = 177
goto _test_eof
_test_eof178:
lex.cs = 178
goto _test_eof
_test_eof179:
lex.cs = 179
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof91:
lex.cs = 91
goto _test_eof
_test_eof92:
lex.cs = 92
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof180:
lex.cs = 180
goto _test_eof
_test_eof181:
lex.cs = 181
goto _test_eof
_test_eof182:
lex.cs = 182
goto _test_eof
_test_eof183:
lex.cs = 183
goto _test_eof
_test_eof184:
lex.cs = 184
goto _test_eof
_test_eof185:
lex.cs = 185
goto _test_eof
_test_eof186:
lex.cs = 186
goto _test_eof
_test_eof187:
lex.cs = 187
goto _test_eof
_test_eof188:
lex.cs = 188
goto _test_eof
_test_eof189:
lex.cs = 189
goto _test_eof
_test_eof190:
lex.cs = 190
goto _test_eof
_test_eof191:
lex.cs = 191
goto _test_eof
_test_eof192:
lex.cs = 192
goto _test_eof
_test_eof193:
lex.cs = 193
goto _test_eof
_test_eof194:
lex.cs = 194
goto _test_eof
_test_eof195:
lex.cs = 195
goto _test_eof
_test_eof196:
lex.cs = 196
goto _test_eof
_test_eof197:
lex.cs = 197
goto _test_eof
_test_eof198:
lex.cs = 198
goto _test_eof
_test_eof199:
lex.cs = 199
goto _test_eof
_test_eof200:
lex.cs = 200
goto _test_eof
_test_eof201:
lex.cs = 201
goto _test_eof
_test_eof202:
lex.cs = 202
goto _test_eof
_test_eof203:
lex.cs = 203
goto _test_eof
_test_eof204:
lex.cs = 204
goto _test_eof
_test_eof205:
lex.cs = 205
goto _test_eof
_test_eof206:
lex.cs = 206
goto _test_eof
_test_eof207:
lex.cs = 207
goto _test_eof
_test_eof208:
lex.cs = 208
goto _test_eof
_test_eof209:
lex.cs = 209
goto _test_eof
_test_eof210:
lex.cs = 210
goto _test_eof
_test_eof211:
lex.cs = 211
goto _test_eof
_test_eof212:
lex.cs = 212
goto _test_eof
_test_eof213:
lex.cs = 213
goto _test_eof
_test_eof214:
lex.cs = 214
goto _test_eof
_test_eof215:
lex.cs = 215
goto _test_eof
_test_eof216:
lex.cs = 216
goto _test_eof
_test_eof217:
lex.cs = 217
goto _test_eof
_test_eof218:
lex.cs = 218
goto _test_eof
_test_eof219:
lex.cs = 219
goto _test_eof
_test_eof220:
lex.cs = 220
goto _test_eof
_test_eof221:
lex.cs = 221
goto _test_eof
_test_eof222:
lex.cs = 222
goto _test_eof
_test_eof223:
lex.cs = 223
goto _test_eof
_test_eof224:
lex.cs = 224
goto _test_eof
_test_eof225:
lex.cs = 225
goto _test_eof
_test_eof226:
lex.cs = 226
goto _test_eof
_test_eof227:
lex.cs = 227
goto _test_eof
_test_eof228:
lex.cs = 228
goto _test_eof
_test_eof229:
lex.cs = 229
goto _test_eof
_test_eof230:
lex.cs = 230
goto _test_eof
_test_eof231:
lex.cs = 231
goto _test_eof
_test_eof232:
lex.cs = 232
goto _test_eof
_test_eof233:
lex.cs = 233
goto _test_eof
_test_eof234:
lex.cs = 234
goto _test_eof
_test_eof235:
lex.cs = 235
goto _test_eof
_test_eof236:
lex.cs = 236
goto _test_eof
_test_eof237:
lex.cs = 237
goto _test_eof
_test_eof238:
lex.cs = 238
goto _test_eof
_test_eof239:
lex.cs = 239
goto _test_eof
_test_eof240:
lex.cs = 240
goto _test_eof
_test_eof241:
lex.cs = 241
goto _test_eof
_test_eof242:
lex.cs = 242
goto _test_eof
_test_eof243:
lex.cs = 243
goto _test_eof
_test_eof244:
lex.cs = 244
goto _test_eof
_test_eof245:
lex.cs = 245
goto _test_eof
_test_eof246:
lex.cs = 246
goto _test_eof
_test_eof247:
lex.cs = 247
goto _test_eof
_test_eof248:
lex.cs = 248
goto _test_eof
_test_eof249:
lex.cs = 249
goto _test_eof
_test_eof250:
lex.cs = 250
goto _test_eof
_test_eof251:
lex.cs = 251
goto _test_eof
_test_eof252:
lex.cs = 252
goto _test_eof
_test_eof253:
lex.cs = 253
goto _test_eof
_test_eof254:
lex.cs = 254
goto _test_eof
_test_eof255:
lex.cs = 255
goto _test_eof
_test_eof256:
lex.cs = 256
goto _test_eof
_test_eof257:
lex.cs = 257
goto _test_eof
_test_eof258:
lex.cs = 258
goto _test_eof
_test_eof259:
lex.cs = 259
goto _test_eof
_test_eof260:
lex.cs = 260
goto _test_eof
_test_eof261:
lex.cs = 261
goto _test_eof
_test_eof262:
lex.cs = 262
goto _test_eof
_test_eof263:
lex.cs = 263
goto _test_eof
_test_eof264:
lex.cs = 264
goto _test_eof
_test_eof265:
lex.cs = 265
goto _test_eof
_test_eof266:
lex.cs = 266
goto _test_eof
_test_eof267:
lex.cs = 267
goto _test_eof
_test_eof268:
lex.cs = 268
goto _test_eof
_test_eof269:
lex.cs = 269
goto _test_eof
_test_eof270:
lex.cs = 270
goto _test_eof
_test_eof271:
lex.cs = 271
goto _test_eof
_test_eof272:
lex.cs = 272
goto _test_eof
_test_eof273:
lex.cs = 273
goto _test_eof
_test_eof274:
lex.cs = 274
goto _test_eof
_test_eof275:
lex.cs = 275
goto _test_eof
_test_eof276:
lex.cs = 276
goto _test_eof
_test_eof277:
lex.cs = 277
goto _test_eof
_test_eof278:
lex.cs = 278
goto _test_eof
_test_eof279:
lex.cs = 279
goto _test_eof
_test_eof280:
lex.cs = 280
goto _test_eof
_test_eof281:
lex.cs = 281
goto _test_eof
_test_eof282:
lex.cs = 282
goto _test_eof
_test_eof283:
lex.cs = 283
goto _test_eof
_test_eof284:
lex.cs = 284
goto _test_eof
_test_eof285:
lex.cs = 285
goto _test_eof
_test_eof286:
lex.cs = 286
goto _test_eof
_test_eof287:
lex.cs = 287
goto _test_eof
_test_eof288:
lex.cs = 288
goto _test_eof
_test_eof289:
lex.cs = 289
goto _test_eof
_test_eof290:
lex.cs = 290
goto _test_eof
_test_eof291:
lex.cs = 291
goto _test_eof
_test_eof292:
lex.cs = 292
goto _test_eof
_test_eof293:
lex.cs = 293
goto _test_eof
_test_eof294:
lex.cs = 294
goto _test_eof
_test_eof295:
lex.cs = 295
goto _test_eof
_test_eof296:
lex.cs = 296
goto _test_eof
_test_eof297:
lex.cs = 297
goto _test_eof
_test_eof298:
lex.cs = 298
goto _test_eof
_test_eof299:
lex.cs = 299
goto _test_eof
_test_eof300:
lex.cs = 300
goto _test_eof
_test_eof301:
lex.cs = 301
goto _test_eof
_test_eof302:
lex.cs = 302
goto _test_eof
_test_eof303:
lex.cs = 303
goto _test_eof
_test_eof304:
lex.cs = 304
goto _test_eof
_test_eof305:
lex.cs = 305
goto _test_eof
_test_eof306:
lex.cs = 306
goto _test_eof
_test_eof307:
lex.cs = 307
goto _test_eof
_test_eof308:
lex.cs = 308
goto _test_eof
_test_eof309:
lex.cs = 309
goto _test_eof
_test_eof310:
lex.cs = 310
goto _test_eof
_test_eof311:
lex.cs = 311
goto _test_eof
_test_eof312:
lex.cs = 312
goto _test_eof
_test_eof313:
lex.cs = 313
goto _test_eof
_test_eof314:
lex.cs = 314
goto _test_eof
_test_eof315:
lex.cs = 315
goto _test_eof
_test_eof316:
lex.cs = 316
goto _test_eof
_test_eof317:
lex.cs = 317
goto _test_eof
_test_eof318:
lex.cs = 318
goto _test_eof
_test_eof319:
lex.cs = 319
goto _test_eof
_test_eof320:
lex.cs = 320
goto _test_eof
_test_eof321:
lex.cs = 321
goto _test_eof
_test_eof322:
lex.cs = 322
goto _test_eof
_test_eof323:
lex.cs = 323
goto _test_eof
_test_eof324:
lex.cs = 324
goto _test_eof
_test_eof325:
lex.cs = 325
goto _test_eof
_test_eof326:
lex.cs = 326
goto _test_eof
_test_eof327:
lex.cs = 327
goto _test_eof
_test_eof328:
lex.cs = 328
goto _test_eof
_test_eof329:
lex.cs = 329
goto _test_eof
_test_eof330:
lex.cs = 330
goto _test_eof
_test_eof331:
lex.cs = 331
goto _test_eof
_test_eof332:
lex.cs = 332
goto _test_eof
_test_eof333:
lex.cs = 333
goto _test_eof
_test_eof334:
lex.cs = 334
goto _test_eof
_test_eof335:
lex.cs = 335
goto _test_eof
_test_eof336:
lex.cs = 336
goto _test_eof
_test_eof337:
lex.cs = 337
goto _test_eof
_test_eof338:
lex.cs = 338
goto _test_eof
_test_eof339:
lex.cs = 339
goto _test_eof
_test_eof340:
lex.cs = 340
goto _test_eof
_test_eof341:
lex.cs = 341
goto _test_eof
_test_eof342:
lex.cs = 342
goto _test_eof
_test_eof343:
lex.cs = 343
goto _test_eof
_test_eof344:
lex.cs = 344
goto _test_eof
_test_eof345:
lex.cs = 345
goto _test_eof
_test_eof346:
lex.cs = 346
goto _test_eof
_test_eof347:
lex.cs = 347
goto _test_eof
_test_eof348:
lex.cs = 348
goto _test_eof
_test_eof349:
lex.cs = 349
goto _test_eof
_test_eof350:
lex.cs = 350
goto _test_eof
_test_eof351:
lex.cs = 351
goto _test_eof
_test_eof352:
lex.cs = 352
goto _test_eof
_test_eof353:
lex.cs = 353
goto _test_eof
_test_eof354:
lex.cs = 354
goto _test_eof
_test_eof355:
lex.cs = 355
goto _test_eof
_test_eof356:
lex.cs = 356
goto _test_eof
_test_eof357:
lex.cs = 357
goto _test_eof
_test_eof358:
lex.cs = 358
goto _test_eof
_test_eof359:
lex.cs = 359
goto _test_eof
_test_eof360:
lex.cs = 360
goto _test_eof
_test_eof361:
lex.cs = 361
goto _test_eof
_test_eof362:
lex.cs = 362
goto _test_eof
_test_eof363:
lex.cs = 363
goto _test_eof
_test_eof364:
lex.cs = 364
goto _test_eof
_test_eof365:
lex.cs = 365
goto _test_eof
_test_eof366:
lex.cs = 366
goto _test_eof
_test_eof367:
lex.cs = 367
goto _test_eof
_test_eof368:
lex.cs = 368
goto _test_eof
_test_eof369:
lex.cs = 369
goto _test_eof
_test_eof370:
lex.cs = 370
goto _test_eof
_test_eof371:
lex.cs = 371
goto _test_eof
_test_eof372:
lex.cs = 372
goto _test_eof
_test_eof373:
lex.cs = 373
goto _test_eof
_test_eof374:
lex.cs = 374
goto _test_eof
_test_eof375:
lex.cs = 375
goto _test_eof
_test_eof376:
lex.cs = 376
goto _test_eof
_test_eof377:
lex.cs = 377
goto _test_eof
_test_eof378:
lex.cs = 378
goto _test_eof
_test_eof379:
lex.cs = 379
goto _test_eof
_test_eof380:
lex.cs = 380
goto _test_eof
_test_eof381:
lex.cs = 381
goto _test_eof
_test_eof382:
lex.cs = 382
goto _test_eof
_test_eof383:
lex.cs = 383
goto _test_eof
_test_eof384:
lex.cs = 384
goto _test_eof
_test_eof385:
lex.cs = 385
goto _test_eof
_test_eof386:
lex.cs = 386
goto _test_eof
_test_eof387:
lex.cs = 387
goto _test_eof
_test_eof388:
lex.cs = 388
goto _test_eof
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
_test_eof389:
lex.cs = 389
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _test_eof
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
_test_eof390:
lex.cs = 390
goto _test_eof
_test_eof391:
lex.cs = 391
goto _test_eof
_test_eof392:
lex.cs = 392
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _test_eof
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
_test_eof393:
lex.cs = 393
goto _test_eof
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
_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
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof398:
lex.cs = 398
goto _test_eof
_test_eof399:
lex.cs = 399
goto _test_eof
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
_test_eof93:
lex.cs = 93
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _test_eof
_test_eof94:
lex.cs = 94
goto _test_eof
_test_eof95:
lex.cs = 95
goto _test_eof
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
_test_eof96:
lex.cs = 96
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _test_eof
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
_test_eof97:
lex.cs = 97
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _test_eof
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
_test_eof98:
lex.cs = 98
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _test_eof
_test_eof400:
lex.cs = 400
goto _test_eof
_test_eof401:
lex.cs = 401
goto _test_eof
_test_eof402:
lex.cs = 402
goto _test_eof
_test_eof403:
lex.cs = 403
goto _test_eof
_test_eof404:
lex.cs = 404
goto _test_eof
_test_eof405:
lex.cs = 405
goto _test_eof
_test_eof406:
lex.cs = 406
goto _test_eof
_test_eof407:
lex.cs = 407
goto _test_eof
_test_eof408:
lex.cs = 408
goto _test_eof
_test_eof409:
lex.cs = 409
goto _test_eof
_test_eof410:
lex.cs = 410
goto _test_eof
_test_eof411:
lex.cs = 411
goto _test_eof
_test_eof412:
lex.cs = 412
goto _test_eof
_test_eof413:
lex.cs = 413
goto _test_eof
_test_eof414:
lex.cs = 414
goto _test_eof
_test_eof415:
lex.cs = 415
goto _test_eof
_test_eof416:
lex.cs = 416
goto _test_eof
_test_eof417:
lex.cs = 417
goto _test_eof
_test_eof418:
lex.cs = 418
goto _test_eof
_test_eof419:
lex.cs = 419
goto _test_eof
_test_eof420:
lex.cs = 420
goto _test_eof
_test_eof421:
lex.cs = 421
goto _test_eof
_test_eof422:
lex.cs = 422
goto _test_eof
_test_eof423:
lex.cs = 423
goto _test_eof
_test_eof424:
lex.cs = 424
goto _test_eof
_test_eof425:
lex.cs = 425
goto _test_eof
_test_eof426:
lex.cs = 426
goto _test_eof
_test_eof427:
lex.cs = 427
goto _test_eof
_test_eof428:
lex.cs = 428
goto _test_eof
_test_eof429:
lex.cs = 429
goto _test_eof
_test_eof430:
lex.cs = 430
goto _test_eof
_test_eof431:
lex.cs = 431
goto _test_eof
_test_eof432:
lex.cs = 432
goto _test_eof
_test_eof433:
lex.cs = 433
goto _test_eof
_test_eof434:
lex.cs = 434
goto _test_eof
_test_eof435:
lex.cs = 435
goto _test_eof
_test_eof436:
lex.cs = 436
goto _test_eof
_test_eof437:
lex.cs = 437
goto _test_eof
_test_eof438:
lex.cs = 438
goto _test_eof
_test_eof439:
lex.cs = 439
goto _test_eof
_test_eof440:
lex.cs = 440
goto _test_eof
_test_eof441:
lex.cs = 441
goto _test_eof
_test_eof442:
lex.cs = 442
goto _test_eof
_test_eof443:
lex.cs = 443
goto _test_eof
_test_eof444:
lex.cs = 444
goto _test_eof
_test_eof445:
lex.cs = 445
goto _test_eof
_test_eof446:
lex.cs = 446
goto _test_eof
_test_eof447:
lex.cs = 447
goto _test_eof
_test_eof448:
lex.cs = 448
goto _test_eof
_test_eof449:
lex.cs = 449
goto _test_eof
_test_eof450:
lex.cs = 450
goto _test_eof
_test_eof451:
lex.cs = 451
goto _test_eof
_test_eof452:
lex.cs = 452
goto _test_eof
_test_eof453:
lex.cs = 453
goto _test_eof
_test_eof454:
lex.cs = 454
goto _test_eof
_test_eof455:
lex.cs = 455
goto _test_eof
_test_eof456:
lex.cs = 456
goto _test_eof
_test_eof457:
lex.cs = 457
goto _test_eof
_test_eof458:
lex.cs = 458
goto _test_eof
_test_eof459:
lex.cs = 459
goto _test_eof
_test_eof460:
lex.cs = 460
goto _test_eof
_test_eof461:
lex.cs = 461
goto _test_eof
_test_eof462:
lex.cs = 462
goto _test_eof
_test_eof463:
lex.cs = 463
goto _test_eof
_test_eof464:
lex.cs = 464
goto _test_eof
_test_eof465:
lex.cs = 465
goto _test_eof
_test_eof466:
lex.cs = 466
goto _test_eof
_test_eof467:
lex.cs = 467
goto _test_eof
_test_eof468:
lex.cs = 468
goto _test_eof
_test_eof469:
lex.cs = 469
goto _test_eof
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
_test_eof99:
lex.cs = 99
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof470:
lex.cs = 470
goto _test_eof
_test_eof471:
lex.cs = 471
goto _test_eof
_test_eof472:
lex.cs = 472
goto _test_eof
_test_eof473:
lex.cs = 473
goto _test_eof
_test_eof474:
lex.cs = 474
goto _test_eof
_test_eof475:
lex.cs = 475
goto _test_eof
_test_eof476:
lex.cs = 476
goto _test_eof
_test_eof477:
lex.cs = 477
goto _test_eof
_test_eof478:
lex.cs = 478
goto _test_eof
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
_test_eof100:
lex.cs = 100
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof479:
lex.cs = 479
goto _test_eof
_test_eof480:
lex.cs = 480
goto _test_eof
_test_eof481:
lex.cs = 481
goto _test_eof
_test_eof482:
lex.cs = 482
goto _test_eof
_test_eof483:
lex.cs = 483
goto _test_eof
_test_eof484:
lex.cs = 484
goto _test_eof
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
_test_eof101:
lex.cs = 101
goto _test_eof
_test_eof102:
lex.cs = 102
goto _test_eof
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
_test_eof485:
lex.cs = 485
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof486:
lex.cs = 486
goto _test_eof
_test_eof487:
lex.cs = 487
goto _test_eof
_test_eof488:
lex.cs = 488
goto _test_eof
_test_eof489:
lex.cs = 489
goto _test_eof
_test_eof490:
lex.cs = 490
goto _test_eof
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
_test_eof103:
lex.cs = 103
goto _test_eof
_test_eof104:
lex.cs = 104
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof491:
lex.cs = 491
goto _test_eof
_test_eof492:
lex.cs = 492
goto _test_eof
_test_eof493:
lex.cs = 493
goto _test_eof
_test_eof494:
lex.cs = 494
goto _test_eof
_test_eof495:
lex.cs = 495
goto _test_eof
_test_eof496:
lex.cs = 496
goto _test_eof
_test_eof497:
lex.cs = 497
goto _test_eof
_test_eof498:
lex.cs = 498
goto _test_eof
_test_eof499:
lex.cs = 499
goto _test_eof
_test_eof500:
lex.cs = 500
goto _test_eof
_test_eof501:
lex.cs = 501
goto _test_eof
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
_test_eof105:
lex.cs = 105
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof502:
lex.cs = 502
goto _test_eof
_test_eof503:
lex.cs = 503
goto _test_eof
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
_test_eof504:
lex.cs = 504
goto _test_eof
_test_eof505:
lex.cs = 505
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
goto _test_eof
_test_eof506:
lex.cs = 506
goto _test_eof
_test_eof507:
lex.cs = 507
goto _test_eof
_test_eof508:
lex.cs = 508
goto _test_eof
_test_eof509:
lex.cs = 509
goto _test_eof
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
_test_eof106:
lex.cs = 106
goto _test_eof
_test_eof107:
lex.cs = 107
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof510:
lex.cs = 510
goto _test_eof
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
_test_eof108:
lex.cs = 108
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof511:
lex.cs = 511
goto _test_eof
_test_eof512:
lex.cs = 512
goto _test_eof
_test_eof513:
lex.cs = 513
goto _test_eof
_test_eof514:
lex.cs = 514
goto _test_eof
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
_test_eof109:
lex.cs = 109
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof515:
lex.cs = 515
goto _test_eof
_test_eof516:
lex.cs = 516
goto _test_eof
_test_eof517:
lex.cs = 517
goto _test_eof
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
_test_eof110:
lex.cs = 110
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof518:
lex.cs = 518
goto _test_eof
_test_eof519:
lex.cs = 519
goto _test_eof
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
_test_eof520:
lex.cs = 520
goto _test_eof
_test_eof521:
lex.cs = 521
goto _test_eof
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
_test_eof111:
lex.cs = 111
goto _test_eof
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
_test_eof522:
lex.cs = 522
goto _test_eof
_test_eof523:
lex.cs = 523
goto _test_eof
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
_test_eof524:
lex.cs = 524
goto _test_eof
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
_test_eof525:
lex.cs = 525
goto _test_eof
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
_test_eof112:
lex.cs = 112
goto _test_eof
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
_test_eof526:
lex.cs = 526
goto _test_eof
_test_eof527:
lex.cs = 527
goto _test_eof
_test_eof528:
lex.cs = 528
goto _test_eof
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
_test_eof529:
lex.cs = 529
goto _test_eof
_test_eof530:
lex.cs = 530
goto _test_eof
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_test_eof:
{
}
if (lex.p) == eof {
switch lex.cs {
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 114:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr171
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 1:
goto tr0
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 115:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr172
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 117:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr177
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
case 118:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr179
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
case 119:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr177
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 120:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr177
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 121:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr185
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 2:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr4
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 3:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr4
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 4:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr4
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 122:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr188
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 5:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr4
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
case 124:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr241
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 125:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr243
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 6:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr10
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 126:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr247
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 127:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 128:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr250
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 129:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr252
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 7:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 8:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 9:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 10:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 130:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr253
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 131:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr256
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 132:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 133:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr261
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 134:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 135:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 136:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr247
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 11:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr19
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 12:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr19
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 137:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 13:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 14:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 15:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 16:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 17:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 18:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 19:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 20:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 21:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 22:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 23:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 24:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 25:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 26:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 27:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 28:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 29:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 30:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 31:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 32:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 33:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 34:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 35:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 36:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 37:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 38:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 39:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 40:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 41:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 42:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 43:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 44:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 45:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 46:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 47:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 48:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 49:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 50:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 51:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 52:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 53:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 54:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 55:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 56:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 57:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 58:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 59:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 60:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 61:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 62:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 63:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 64:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 65:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 66:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 138:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 139:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr267
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 140:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 141:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 142:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 67:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 143:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr276
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 68:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
case 69:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 144:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr276
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 70:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr88
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 145:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 71:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 72:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 73:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 146:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr280
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 147:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr276
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 148:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr280
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 74:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr99
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 75:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 149:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr285
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 76:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 150:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr286
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 151:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 152:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 77:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
[#93] fix scanning constant strings
2019-06-07 06:33:35 +00:00
case 78:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 79:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 80:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr23
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 153:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr288
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 154:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr290
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 81:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr112
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 155:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 156:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr294
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 82:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 83:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 84:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 85:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 157:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr296
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 86:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 87:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 88:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 89:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 158:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr297
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 159:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 160:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr301
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 161:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 162:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr305
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 163:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr248
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 164:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr309
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 165:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr311
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 90:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr128
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 166:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr312
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 167:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 168:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr12
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 169:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 170:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 171:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 172:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 173:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 174:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 175:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 176:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 177:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 178:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 179:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 91:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr130
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 92:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr130
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 180:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 181:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 182:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 183:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 184:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 185:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 186:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 187:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 188:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 189:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 190:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 191:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 192:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 193:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 194:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 195:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 196:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 197:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 198:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 199:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 200:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 201:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 202:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 203:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 204:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 205:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 206:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 207:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 208:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 209:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 210:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 211:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 212:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 213:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 214:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 215:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 216:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 217:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 218:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 219:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 220:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 221:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 222:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 223:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 224:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 225:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 226:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 227:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 228:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr394
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 229:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 230:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 231:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 232:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 233:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 234:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 235:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 236:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 237:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 238:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 239:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 240:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 241:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 242:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 243:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr414
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 244:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 245:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 246:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 247:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 248:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 249:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 250:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 251:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 252:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 253:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 254:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 255:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 256:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 257:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 258:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 259:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 260:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 261:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 262:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 263:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 264:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 265:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 266:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 267:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 268:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 269:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr443
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 270:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 271:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 272:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr447
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 273:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 274:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 275:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 276:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 277:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 278:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 279:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 280:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 281:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 282:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 283:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 284:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 285:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 286:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 287:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 288:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 289:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 290:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 291:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 292:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 293:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 294:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 295:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 296:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 297:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr479
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 298:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 299:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 300:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 301:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 302:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 303:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 304:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 305:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 306:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 307:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 308:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 309:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 310:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 311:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 312:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 313:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 314:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 315:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 316:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 317:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 318:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 319:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 320:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 321:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 322:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 323:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 324:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 325:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 326:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 327:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 328:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 329:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 330:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 331:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 332:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 333:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 334:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 335:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 336:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 337:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 338:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 339:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 340:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 341:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 342:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 343:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 344:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 345:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 346:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 347:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 348:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 349:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 350:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 351:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 352:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 353:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 354:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 355:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 356:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 357:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 358:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr547
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 359:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 360:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 361:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 362:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 363:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 364:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 365:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 366:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 367:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 368:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 369:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 370:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 371:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 372:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 373:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 374:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 375:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 376:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 377:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 378:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 379:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 380:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 381:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 382:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 383:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 384:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 385:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 386:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 387:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 388:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 389:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 390:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 391:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 392:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 393:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 394:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 395:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 396:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 397:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 398:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 399:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr593
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 93:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr132
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 94:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr132
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 95:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr132
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 96:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr132
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 97:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr132
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 98:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr132
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 400:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr248
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 401:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 402:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 403:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 404:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 405:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 406:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 407:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 408:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 409:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 410:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 411:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 412:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 413:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 414:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 415:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 416:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 417:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 418:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 419:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 420:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 421:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 422:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 423:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 424:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 425:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 426:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 427:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 428:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 429:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 430:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 431:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 432:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 433:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 434:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 435:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 436:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 437:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 438:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 439:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 440:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 441:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 442:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 443:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 444:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 445:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 446:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 447:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 448:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 449:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 450:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 451:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 452:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 453:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 454:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 455:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 456:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 457:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 458:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 459:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 460:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 461:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 462:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 463:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 464:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 465:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr314
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 466:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr248
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 468:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr675
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 469:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr677
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 99:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr144
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 470:
goto tr681
case 471:
goto tr681
case 472:
goto tr683
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 474:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr687
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 475:
goto tr688
case 476:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr692
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 478:
goto tr700
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 479:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr702
case 480:
goto tr703
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 481:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr707
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 482:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr700
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 483:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr707
case 485:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr719
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 486:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr720
case 487:
goto tr724
[#82] PHP 7.4: numeric literal separator
2019-12-26 21:54:44 +00:00
case 488:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr724
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 489:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr724
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 491:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr737
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 492:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr738
case 493:
goto tr742
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
case 494:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr742
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 495:
goto tr742
case 497:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr747
case 499:
goto tr753
Fix #91 Add support for \x80-\xff. Change \x7f-\xff to \x80-\xff.
2019-06-03 14:22:05 +00:00
case 500:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr755
case 501:
goto tr753
case 105:
goto tr154
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 502:
goto tr757
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 504:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr767
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 505:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr768
case 506:
goto tr769
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 507:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr771
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 508:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr772
[#107] fix infinite loop when $ appear between variable and the end of a template string
2020-06-14 20:37:44 +00:00
case 509:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr772
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 106:
goto tr156
case 107:
goto tr156
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 510:
goto tr772
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 108:
goto tr156
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 511:
goto tr772
case 512:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr776
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 514:
goto tr779
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 109:
goto tr160
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 516:
goto tr784
case 517:
goto tr786
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 110:
goto tr163
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 518:
goto tr790
case 520:
goto tr795
[#82] Arrow function and assign coalesce
2019-12-28 20:26:54 +00:00
case 521:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr797
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 111:
goto tr165
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 522:
goto tr801
case 524:
goto tr806
[#82] add support of shebang
2019-12-29 22:20:20 +00:00
case 525:
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
goto tr808
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
case 112:
goto tr167
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 526:
goto tr812
case 528:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr816
[refactoring] update dumper
2020-12-11 11:28:16 +00:00
case 529:
goto tr817
case 530:
[#105] fix counting newlines in strings
2020-07-26 16:56:32 +00:00
goto tr821
fixed bug when heredoc starts by `\`; removing `\n` from a heredoc value end
2018-07-14 15:00:48 +00:00
}
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
#80 implement Ragel based lexer
2019-03-10 21:37:01 +00:00
_out:
{
}
#67: skip unexpected character in input
2018-11-05 14:56:27 +00:00
}
split scanner and lexer
2017-12-01 13:36:46 +00:00
refactoring: fix scanning double dollar in template string
2020-12-28 19:43:55 +00:00
// line internal/scanner/scanner.rl:497
[refactoring] update ast structure of "Echo" node
2020-09-10 20:11:08 +00:00
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
tkn.Value = lex.data[lex.ts:lex.te]
tkn.ID = token.ID(tok)
scanner refactoring
2019-12-21 12:44:25 +00:00
[refactoring] remove scanner token
2020-08-17 17:31:04 +00:00
return tkn
split scanner and lexer
2017-12-01 13:36:46 +00:00
}
Reference in New Issue Copy Permalink