diff --git a/Makefile b/Makefile index 5309a04..856785c 100644 --- a/Makefile +++ b/Makefile @@ -19,12 +19,15 @@ bench: go test -benchmem -bench=. ./internal/php5 go test -benchmem -bench=. ./internal/php7 -compile: ./internal/php5/php5.go ./internal/php7/php7.go ./internal/scanner/scanner.go - sed -i '' -e 's/yyErrorVerbose = false/yyErrorVerbose = true/g' ./internal/php7/php7.go - sed -i '' -e 's/yyErrorVerbose = false/yyErrorVerbose = true/g' ./internal/php5/php5.go - sed -i '' -e 's/\/\/line/\/\/ line/g' ./internal/php5/php5.go - sed -i '' -e 's/\/\/line/\/\/ line/g' ./internal/php7/php7.go - sed -i '' -e 's/\/\/line/\/\/ line/g' ./internal/scanner/scanner.go +compile: ./internal/php5/php5.go ./internal/php7/php7.go ./internal/php8/php8.go ./internal/php8/scanner.go ./internal/scanner/scanner.go + sed -i -e 's/yyErrorVerbose = false/yyErrorVerbose = true/g' ./internal/php5/php5.go + sed -i -e 's/yyErrorVerbose = false/yyErrorVerbose = true/g' ./internal/php7/php7.go + sed -i -e 's/yyErrorVerbose = false/yyErrorVerbose = true/g' ./internal/php8/php8.go + sed -i -e 's/\/\/line/\/\/ line/g' ./internal/php5/php5.go + sed -i -e 's/\/\/line/\/\/ line/g' ./internal/php7/php7.go + sed -i -e 's/\/\/line/\/\/ line/g' ./internal/php8/php8.go + sed -i -e 's/\/\/line/\/\/ line/g' ./internal/scanner/scanner.go + sed -i -e 's/\/\/line/\/\/ line/g' ./internal/php8/scanner.go rm -f y.output ./internal/scanner/scanner.go: ./internal/scanner/scanner.rl @@ -36,6 +39,12 @@ compile: ./internal/php5/php5.go ./internal/php7/php7.go ./internal/scanner/scan ./internal/php7/php7.go: ./internal/php7/php7.y goyacc -o $@ $< +./internal/php8/php8.go: ./internal/php8/php8.y + goyacc -o $@ $< + +./internal/php8/scanner.go: ./internal/php8/scanner.rl + ragel -Z -G2 -o $@ $< + cpu_pprof: go test -cpuprofile cpu.pprof -bench=. -benchtime=20s ./internal/php7 go tool pprof ./php7.test cpu.pprof diff --git a/README.md b/README.md index 132d86d..ee040f5 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,5 @@ +> This is a fork of the [z7zmey](https://github.com/z7zmey) [parser](https://github.com/z7zmey/php-parser) that adds PHP 8 support. + PHP Parser written in Go ======================== @@ -6,29 +8,25 @@ PHP Parser written in Go [![GoDoc](https://godoc.org/github.com/z7zmey/php-parser?status.svg)](https://godoc.org/github.com/z7zmey/php-parser) [![Build Status](https://travis-ci.org/z7zmey/php-parser.svg?branch=master)](https://travis-ci.org/z7zmey/php-parser) [![Go Report Card](https://goreportcard.com/badge/github.com/z7zmey/php-parser)](https://goreportcard.com/report/github.com/z7zmey/php-parser) -[![Maintainability](https://api.codeclimate.com/v1/badges/950783b2e739db26e0ed/maintainability)](https://codeclimate.com/github/z7zmey/php-parser/maintainability) -[![Test Coverage](https://api.codeclimate.com/v1/badges/950783b2e739db26e0ed/test_coverage)](https://codeclimate.com/github/z7zmey/php-parser/test_coverage) This project uses [goyacc](https://godoc.org/golang.org/x/tools/cmd/goyacc) and [ragel](https://www.colm.net/open-source/ragel/) tools to create PHP parser. It parses source code into [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree). It can be used to write static analysis, refactoring, metrics, code style formatting tools. -#### Try it online: [demo](https://php-parser.com) - -Features: +Features --------- -- Fully support PHP 5 and PHP 7 syntax +- Fully support PHP 5, PHP 7 and PHP 8.0 syntax - Abstract syntax tree (AST) representation - Traversing AST -- Resolving namespaced names +- Resolving namespace names - Parsing syntax-invalid PHP files - Saving and printing free-floating comments and whitespaces Who Uses -------- -[VKCOM/noverify](https://github.com/VKCOM/noverify) - NoVerify is a pretty fast linter for PHP - -[quasilyte/phpgrep](https://github.com/quasilyte/phpgrep) - phpgrep is a tool for syntax-aware PHP code search +- [VKCOM/noverify](https://github.com/VKCOM/noverify) — pretty fast linter for PHP +- [VKCOM/nocolor](https://github.com/VKCOM/nocolor) — architecture validation tool for PHP based on the [*concept of colored functions*](https://github.com/VKCOM/nocolor/blob/master/docs/introducing_colors.md) +- [quasilyte/phpgrep](https://github.com/quasilyte/phpgrep) — tool for syntax-aware PHP code search Usage example ------- @@ -48,7 +46,7 @@ import ( ) func main() { - src := []byte(` ... ``` -| flag | type | description | -| ------- | ------ | --------------------------------- | -| -p | bool | print filepath | -| -e | bool | print errors | -| -d | bool | dump in golang format | -| -r | bool | resolve names | -| -prof | string | start profiler: [cpu, mem, trace] | -| -phpver | string | php version (default: 7.4) | +| flag | type | description | +| ---------- | -------- | ----------------------------------- | +| `--p` | `bool` | Print file paths | +| `--e` | `bool` | Print errors | +| `--d` | `bool` | Dump AST in Golang format | +| `--r` | `bool` | Resolve names | +| `--prof` | `string` | Start profiler: `[cpu, mem, trace]` | +| `--phpver` | `string` | PHP version (default: 8.0) | Namespace resolver ------------------ @@ -113,4 +105,4 @@ Namespace resolver Namespace resolver is a visitor that resolves nodes fully qualified name and saves into `map[node.Node]string` structure - For `Class`, `Interface`, `Trait`, `Function`, `Constant` nodes it saves name with current namespace. -- For `Name`, `Relative`, `FullyQualified` nodes it resolves `use` aliases and saves a fully qualified name. +- For `Name`, `Relative`, `FullyQualified` nodes it resolves `use` aliases and saves a fully qualified name. \ No newline at end of file diff --git a/internal/php5/php5.go b/internal/php5/php5.go index e6fa0e1..b793bd6 100644 Binary files a/internal/php5/php5.go and b/internal/php5/php5.go differ diff --git a/internal/php7/php7.go b/internal/php7/php7.go index c7a41b4..499cb1e 100644 Binary files a/internal/php7/php7.go and b/internal/php7/php7.go differ diff --git a/internal/php8/builder.go b/internal/php8/builder.go new file mode 100644 index 0000000..6b855c3 --- /dev/null +++ b/internal/php8/builder.go @@ -0,0 +1,1431 @@ +package php8 + +import ( + "bytes" + + "github.com/z7zmey/php-parser/internal/position" + "github.com/z7zmey/php-parser/pkg/ast" + position2 "github.com/z7zmey/php-parser/pkg/position" + "github.com/z7zmey/php-parser/pkg/token" +) + +// Builder is responsible for creating nodes inside grammar rules. +// Creating nodes directly in grammar rules is inconvenient, since +// there is no autocompletion and you cannot put breakpoints inside. +type Builder struct { + Pos *position.Builder + Parser *Parser +} + +// NewBuilder creates a new Builder. +func NewBuilder(pos *position.Builder, parser *Parser) *Builder { + return &Builder{ + Pos: pos, + Parser: parser, + } +} + +// NewEmptySeparatedList creates a new empty list. +// Used for places where a delimited list is used. +func (b *Builder) NewEmptySeparatedList() *ParserSeparatedList { + return &ParserSeparatedList{} +} + +// NewSeparatedList creates a new single-element list. +// Used for places where a delimited list is used. +func (b *Builder) NewSeparatedList(node ast.Vertex) *ParserSeparatedList { + return &ParserSeparatedList{Items: []ast.Vertex{node}} +} + +// NewSeparatedListWithTwoElements creates a new two-element list. +// Used for places where a delimited list is used. +func (b *Builder) NewSeparatedListWithTwoElements(node1 ast.Vertex, tkn *token.Token, node2 ast.Vertex) *ParserSeparatedList { + return &ParserSeparatedList{ + Items: []ast.Vertex{node1, node2}, + SeparatorTkns: []*token.Token{tkn}, + } +} + +func (b *Builder) NewNonEmptySeparatedList(nodes []ast.Vertex, tkns []*token.Token) *ParserSeparatedList { + return &ParserSeparatedList{ + Items: nodes, + SeparatorTkns: tkns, + } +} + +// AppendToSeparatedList inserts a new node and/or token into the list. +func (b *Builder) AppendToSeparatedList(list ast.Vertex, tkn *token.Token, node ast.Vertex) *ParserSeparatedList { + sepList := list.(*ParserSeparatedList) + if node != nil { + sepList.Items = append(sepList.Items, node) + } + if tkn != nil { + sepList.SeparatorTkns = append(sepList.SeparatorTkns, tkn) + } + + return sepList +} + +func (b *Builder) SeparatedListItems(list ast.Vertex) (items []ast.Vertex, sepTkns []*token.Token) { + if list == nil { + return nil, nil + } + + paramsList, ok := list.(*ParserSeparatedList) + if !ok { + return nil, nil + } + + return paramsList.Items, paramsList.SeparatorTkns +} + +// namespace\Foo +func (b *Builder) parseNameRelativeToken(t *token.Token) *ast.NameRelative { + n := &ast.NameRelative{ + Position: b.Pos.NewTokenPosition(t), + } + s := t.Position.StartPos + v := t.Value + + // namespace token + + p1 := b.Parser.Lexer.positionPool.Get() + p1.StartLine = t.Position.StartLine + p1.EndLine = t.Position.EndLine + p1.StartPos = s + p1.EndPos = s + 9 + + n.NsTkn = &token.Token{ + ID: token.T_NAMESPACE, + Value: v[:9], + Position: p1, + FreeFloating: t.FreeFloating, + } + + s = s + 9 + v = v[9:] + + // ns separator token + + p1 = b.Parser.Lexer.positionPool.Get() + p1.StartLine = t.Position.StartLine + p1.EndLine = t.Position.EndLine + p1.StartPos = s + p1.EndPos = s + 1 + + n.NsSeparatorTkn = &token.Token{ + ID: token.T_NS_SEPARATOR, + Value: v[:1], + Position: p1, + } + + s = s + 1 + v = v[1:] + + // parts + + for { + i := bytes.Index(v, []byte("\\")) + if i < 0 { + break + } + + p1 = b.Parser.Lexer.positionPool.Get() + p1.StartLine = t.Position.StartLine + p1.EndLine = t.Position.EndLine + p1.StartPos = s + p1.EndPos = s + i + + p2 := b.Parser.Lexer.positionPool.Get() + *p2 = *p1 + + n.Parts = append(n.Parts, &ast.NamePart{ + Position: p1, + StringTkn: &token.Token{ + ID: token.T_STRING, + Value: v[:i], + Position: p2, + }, + Value: v[:i], + }) + t.FreeFloating = nil + s = s + i + v = v[i:] + + p1 = b.Parser.Lexer.positionPool.Get() + p1.StartLine = t.Position.StartLine + p1.EndLine = t.Position.EndLine + p1.StartPos = s + p1.EndPos = s + 1 + + n.SeparatorTkns = append(n.SeparatorTkns, &token.Token{ + ID: token.T_NS_SEPARATOR, + Value: v[:1], + Position: p1, + }) + s = s + 1 + v = v[1:] + } + + // last part + + p1 = b.Parser.Lexer.positionPool.Get() + p1.StartLine = t.Position.StartLine + p1.EndLine = t.Position.EndLine + p1.StartPos = s + p1.EndPos = s + len(v) + p2 := b.Parser.Lexer.positionPool.Get() + *p2 = *p1 + + n.Parts = append(n.Parts, &ast.NamePart{ + Position: p1, + StringTkn: &token.Token{ + ID: token.T_STRING, + Value: v, + Position: p2, + }, + Value: v, + }) + + return n +} + +// \Foo\Boo +func (b *Builder) parseNameFullyQualifiedToken(t *token.Token) *ast.NameFullyQualified { + n := &ast.NameFullyQualified{ + Position: b.Pos.NewTokenPosition(t), + } + s := t.Position.StartPos + v := t.Value + + // ns separator token + + p1 := b.Parser.Lexer.positionPool.Get() + p1.StartLine = t.Position.StartLine + p1.EndLine = t.Position.EndLine + p1.StartPos = s + p1.EndPos = s + 1 + + n.NsSeparatorTkn = &token.Token{ + ID: token.T_NS_SEPARATOR, + Value: v[:1], + Position: p1, + FreeFloating: t.FreeFloating, + } + + s = s + 1 + v = v[1:] + + // parts + + for { + i := bytes.Index(v, []byte("\\")) + if i < 0 { + break + } + + p1 = b.Parser.Lexer.positionPool.Get() + p1.StartLine = t.Position.StartLine + p1.EndLine = t.Position.EndLine + p1.StartPos = s + p1.EndPos = s + i + + p2 := b.Parser.Lexer.positionPool.Get() + *p2 = *p1 + + n.Parts = append(n.Parts, &ast.NamePart{ + Position: p1, + StringTkn: &token.Token{ + ID: token.T_STRING, + Value: v[:i], + Position: p2, + }, + Value: v[:i], + }) + t.FreeFloating = nil + s = s + i + v = v[i:] + + p1 = b.Parser.Lexer.positionPool.Get() + p1.StartLine = t.Position.StartLine + p1.EndLine = t.Position.EndLine + p1.StartPos = s + p1.EndPos = s + 1 + + n.SeparatorTkns = append(n.SeparatorTkns, &token.Token{ + ID: token.T_NS_SEPARATOR, + Value: v[:1], + Position: p1, + }) + s = s + 1 + v = v[1:] + } + + // last part + + p1 = b.Parser.Lexer.positionPool.Get() + p1.StartLine = t.Position.StartLine + p1.EndLine = t.Position.EndLine + p1.StartPos = s + p1.EndPos = s + len(v) + p2 := b.Parser.Lexer.positionPool.Get() + *p2 = *p1 + + n.Parts = append(n.Parts, &ast.NamePart{ + Position: p1, + StringTkn: &token.Token{ + ID: token.T_STRING, + Value: v, + Position: p2, + }, + Value: v, + }) + + return n +} + +// Foo\Boo +func (b *Builder) parseNameToken(t *token.Token) *ast.NameRelative { + n := &ast.NameRelative{ + Position: b.Pos.NewTokenPosition(t), + } + s := t.Position.StartPos + v := t.Value + + if bytes.HasPrefix(bytes.ToLower(v), []byte("namespace")) { + p1 := b.Parser.Lexer.positionPool.Get() + p1.StartLine = t.Position.StartLine + p1.EndLine = t.Position.EndLine + p1.StartPos = s + p1.EndPos = s + 9 + + n.NsTkn = &token.Token{ + ID: token.T_NAMESPACE, + Value: v[:9], + Position: p1, + } + + s = s + 9 + v = v[9:] + } + + if bytes.HasPrefix(bytes.ToLower(v), []byte("\\")) { + p1 := b.Parser.Lexer.positionPool.Get() + p1.StartLine = t.Position.StartLine + p1.EndLine = t.Position.EndLine + p1.StartPos = s + p1.EndPos = s + 1 + + n.NsSeparatorTkn = &token.Token{ + ID: token.T_NS_SEPARATOR, + Value: v[:1], + Position: p1, + } + + s = s + 1 + v = v[1:] + } + + for { + i := bytes.Index(v, []byte("\\")) + if i < 0 { + break + } + + p1 := b.Parser.Lexer.positionPool.Get() + p1.StartLine = t.Position.StartLine + p1.EndLine = t.Position.EndLine + p1.StartPos = s + p1.EndPos = s + i + + p2 := b.Parser.Lexer.positionPool.Get() + *p2 = *p1 + + n.Parts = append(n.Parts, &ast.NamePart{ + Position: p1, + StringTkn: &token.Token{ + ID: token.T_STRING, + Value: v[:i], + Position: p2, + FreeFloating: t.FreeFloating, + }, + Value: v[:i], + }) + t.FreeFloating = nil + s = s + i + v = v[i:] + + p1 = b.Parser.Lexer.positionPool.Get() + p1.StartLine = t.Position.StartLine + p1.EndLine = t.Position.EndLine + p1.StartPos = s + p1.EndPos = s + 1 + + n.SeparatorTkns = append(n.SeparatorTkns, &token.Token{ + ID: token.T_NS_SEPARATOR, + Value: v[:1], + Position: p1, + }) + s = s + 1 + v = v[1:] + } + + p1 := b.Parser.Lexer.positionPool.Get() + p1.StartLine = t.Position.StartLine + p1.EndLine = t.Position.EndLine + p1.StartPos = s + p1.EndPos = s + len(v) + p2 := b.Parser.Lexer.positionPool.Get() + *p2 = *p1 + + n.Parts = append(n.Parts, &ast.NamePart{ + Position: p1, + StringTkn: &token.Token{ + ID: token.T_STRING, + Value: v, + Position: p2, + FreeFloating: t.FreeFloating, + }, + Value: v, + }) + + return n +} + +func (b *Builder) NewScalarMagicConstant( + MagicConstantTkn *token.Token, +) *ast.ScalarMagicConstant { + return &ast.ScalarMagicConstant{ + Position: b.Pos.NewTokenPosition(MagicConstantTkn), + MagicConstTkn: MagicConstantTkn, + Value: MagicConstantTkn.Value, + } +} + +func (b *Builder) NewBracket( + OpenParenthesisTkn *token.Token, + Expr ast.Vertex, + CloseParenthesisTkn *token.Token, +) *ast.ExprBrackets { + return &ast.ExprBrackets{ + Position: b.Pos.NewTokensPosition(OpenParenthesisTkn, CloseParenthesisTkn), + OpenParenthesisTkn: OpenParenthesisTkn, + Expr: Expr, + CloseParenthesisTkn: CloseParenthesisTkn, + } +} + +func (b *Builder) NewExpressionStmt( + Expr ast.Vertex, + SemiColonTkn *token.Token, +) ast.Vertex { + if throwExpr, ok := Expr.(*ast.ExprThrow); ok { + // For backwards-compatibility reasons, convert throw in statement position into + // StmtThrow rather than StmtExpression(ExprThrow). + return &ast.StmtThrow{ + Position: b.Pos.NewTokensPosition(throwExpr.ThrowTkn, SemiColonTkn), + ThrowTkn: throwExpr.ThrowTkn, + Expr: throwExpr.Expr, + SemiColonTkn: SemiColonTkn, + } + } + + return &ast.StmtExpression{ + Position: b.Pos.NewNodeTokenPosition(Expr, SemiColonTkn), + Expr: Expr, + SemiColonTkn: SemiColonTkn, + } +} + +func (b *Builder) NewIdentifier( + IdentifierTkn *token.Token, +) ast.Vertex { + if IdentifierTkn == nil { + return nil + } + + return &ast.Identifier{ + Position: b.Pos.NewTokenPosition(IdentifierTkn), + IdentifierTkn: IdentifierTkn, + Value: IdentifierTkn.Value, + } +} + +func (b *Builder) NewName( + NameTkn *token.Token, +) *ast.Name { + return &ast.Name{ + Position: b.Pos.NewTokenPosition(NameTkn), + Parts: []ast.Vertex{ + &ast.NamePart{ + Position: b.Pos.NewTokenPosition(NameTkn), + StringTkn: NameTkn, + Value: NameTkn.Value, + }, + }, + } +} + +func (b *Builder) NewNameQualified( + NameTkn *token.Token, +) *ast.Name { + name := b.parseNameToken(NameTkn) + + return &ast.Name{ + Position: b.Pos.NewTokenPosition(NameTkn), + Parts: name.Parts, + SeparatorTkns: name.SeparatorTkns, + } +} + +func (b *Builder) NewNameFullyQualified( + NameTkn *token.Token, +) *ast.NameFullyQualified { + return b.parseNameFullyQualifiedToken(NameTkn) +} + +func (b *Builder) NewNameRelative( + NameTkn *token.Token, +) *ast.NameRelative { + return b.parseNameRelativeToken(NameTkn) +} + +func (b *Builder) NewNamePart( + NameTkn *token.Token, +) *ast.NamePart { + return &ast.NamePart{ + Position: b.Pos.NewTokenPosition(NameTkn), + StringTkn: NameTkn, + Value: NameTkn.Value, + } +} + +func (b *Builder) NewConstFetch( + Name ast.Vertex, +) *ast.ExprConstFetch { + return &ast.ExprConstFetch{ + Position: b.Pos.NewNodePosition(Name), + Const: Name, + } +} + +func (b *Builder) NewMethodCall( + Expr ast.Vertex, + ObjectOperatorTkn *token.Token, + PropertyName ast.Vertex, + ArgList ast.Vertex, +) *ast.ExprMethodCall { + argumentList := ArgList.(*ArgumentList) + methodCall := &ast.ExprMethodCall{ + Position: b.Pos.NewNodesPosition(Expr, ArgList), + Var: Expr, + ObjectOperatorTkn: ObjectOperatorTkn, + Method: PropertyName, + OpenParenthesisTkn: argumentList.OpenParenthesisTkn, + Args: argumentList.Arguments, + SeparatorTkns: argumentList.SeparatorTkns, + CloseParenthesisTkn: argumentList.CloseParenthesisTkn, + } + + if brackets, ok := PropertyName.(*ParserBrackets); ok { + methodCall.OpenCurlyBracketTkn = brackets.OpenBracketTkn + methodCall.Method = brackets.Child + methodCall.CloseCurlyBracketTkn = brackets.CloseBracketTkn + } + + return methodCall +} + +func (b *Builder) NewNullsafeMethodCall( + Expr ast.Vertex, + ObjectOperatorTkn *token.Token, + PropertyName ast.Vertex, + ArgList ast.Vertex, +) *ast.ExprNullsafeMethodCall { + argumentList := ArgList.(*ArgumentList) + methodCall := &ast.ExprNullsafeMethodCall{ + Position: b.Pos.NewNodesPosition(Expr, ArgList), + Var: Expr, + ObjectOperatorTkn: ObjectOperatorTkn, + Method: PropertyName, + OpenParenthesisTkn: argumentList.OpenParenthesisTkn, + Args: argumentList.Arguments, + SeparatorTkns: argumentList.SeparatorTkns, + CloseParenthesisTkn: argumentList.CloseParenthesisTkn, + } + + if brackets, ok := PropertyName.(*ParserBrackets); ok { + methodCall.OpenCurlyBracketTkn = brackets.OpenBracketTkn + methodCall.Method = brackets.Child + methodCall.CloseCurlyBracketTkn = brackets.CloseBracketTkn + } + + return methodCall +} + +func (b *Builder) NewPropertyFetch( + Expr ast.Vertex, + ObjectOperatorTkn *token.Token, + PropertyName ast.Vertex, +) *ast.ExprPropertyFetch { + propertyFetch := &ast.ExprPropertyFetch{ + Position: b.Pos.NewNodesPosition(Expr, PropertyName), + Var: Expr, + ObjectOperatorTkn: ObjectOperatorTkn, + Prop: PropertyName, + } + + if brackets, ok := PropertyName.(*ParserBrackets); ok { + propertyFetch.OpenCurlyBracketTkn = brackets.OpenBracketTkn + propertyFetch.Prop = brackets.Child + propertyFetch.CloseCurlyBracketTkn = brackets.CloseBracketTkn + } + + return propertyFetch +} + +func (b *Builder) NewPropertyFetchFromTokens( + VariableTkn *token.Token, + ObjectOperatorTkn *token.Token, + StringTkn *token.Token, +) *ast.ExprPropertyFetch { + return &ast.ExprPropertyFetch{ + Position: b.Pos.NewTokensPosition(VariableTkn, StringTkn), + Var: &ast.ExprVariable{ + Position: b.Pos.NewTokenPosition(VariableTkn), + Name: &ast.Identifier{ + Position: b.Pos.NewTokenPosition(VariableTkn), + IdentifierTkn: VariableTkn, + Value: VariableTkn.Value, + }, + }, + ObjectOperatorTkn: ObjectOperatorTkn, + Prop: &ast.Identifier{ + Position: b.Pos.NewTokenPosition(StringTkn), + IdentifierTkn: StringTkn, + Value: StringTkn.Value, + }, + } +} + +func (b *Builder) NewNullsafePropertyFetch( + Expr ast.Vertex, + ObjectOperatorTkn *token.Token, + PropertyName ast.Vertex, +) *ast.ExprNullsafePropertyFetch { + propertyFetch := &ast.ExprNullsafePropertyFetch{ + Position: b.Pos.NewNodesPosition(Expr, PropertyName), + Var: Expr, + ObjectOperatorTkn: ObjectOperatorTkn, + Prop: PropertyName, + } + + if brackets, ok := PropertyName.(*ParserBrackets); ok { + propertyFetch.OpenCurlyBracketTkn = brackets.OpenBracketTkn + propertyFetch.Prop = brackets.Child + propertyFetch.CloseCurlyBracketTkn = brackets.CloseBracketTkn + } + + return propertyFetch +} + +func (b *Builder) NewNullsafePropertyFetchFromTokens( + VariableTkn *token.Token, + ObjectOperatorTkn *token.Token, + StringTkn *token.Token, +) *ast.ExprNullsafePropertyFetch { + return &ast.ExprNullsafePropertyFetch{ + Position: b.Pos.NewTokensPosition(VariableTkn, StringTkn), + Var: &ast.ExprVariable{ + Position: b.Pos.NewTokenPosition(VariableTkn), + Name: &ast.Identifier{ + Position: b.Pos.NewTokenPosition(VariableTkn), + IdentifierTkn: VariableTkn, + Value: VariableTkn.Value, + }, + }, + ObjectOperatorTkn: ObjectOperatorTkn, + Prop: &ast.Identifier{ + Position: b.Pos.NewTokenPosition(StringTkn), + IdentifierTkn: StringTkn, + Value: StringTkn.Value, + }, + } +} + +func (b *Builder) NewArgument( + Expr ast.Vertex, +) *ast.Argument { + return &ast.Argument{ + Position: b.Pos.NewNodePosition(Expr), + Expr: Expr, + } +} + +func (b *Builder) NewVariadicArgument( + VariadicTkn *token.Token, + Expr ast.Vertex, +) *ast.Argument { + return &ast.Argument{ + Position: b.Pos.NewTokenNodePosition(VariadicTkn, Expr), + VariadicTkn: VariadicTkn, + Expr: Expr, + } +} + +func (b *Builder) NewNamedArgument( + Name *token.Token, + ColonTkn *token.Token, + Expr ast.Vertex, +) *ast.Argument { + return &ast.Argument{ + Position: b.Pos.NewTokenNodePosition(Name, Expr), + Name: &ast.Identifier{ + Position: Name.Position, + IdentifierTkn: Name, + Value: Name.Value, + }, + ColonTkn: ColonTkn, + Expr: Expr, + } +} + +func (b *Builder) NewMatch( + MatchTkn *token.Token, + OpenParenthesisTkn *token.Token, + Expr ast.Vertex, + CloseParenthesisTkn *token.Token, + OpenCurlyBracketTkn *token.Token, + Cases ast.Vertex, + CloseCurlyBracketTkn *token.Token, +) *ast.ExprMatch { + var arms []ast.Vertex + var sepTkns []*token.Token + if Cases != nil { + cases := Cases.(*ParserSeparatedList) + arms = cases.Items + sepTkns = cases.SeparatorTkns + } + + return &ast.ExprMatch{ + Position: b.Pos.NewTokensPosition(MatchTkn, CloseCurlyBracketTkn), + MatchTkn: MatchTkn, + OpenParenthesisTkn: OpenParenthesisTkn, + Expr: Expr, + CloseParenthesisTkn: CloseParenthesisTkn, + OpenCurlyBracketTkn: OpenCurlyBracketTkn, + Arms: arms, + SeparatorTkns: sepTkns, + CloseCurlyBracketTkn: CloseCurlyBracketTkn, + } +} + +func (b *Builder) NewMatchArm( + DefaultTkn *token.Token, + DefaultCommaTkn *token.Token, + Exprs ast.Vertex, + DoubleArrowTkn *token.Token, + ReturnExpr ast.Vertex, +) *ast.MatchArm { + // Default branch. + if Exprs == nil { + return &ast.MatchArm{ + Position: b.Pos.NewTokenNodePosition(DefaultTkn, ReturnExpr), + DefaultTkn: DefaultTkn, + DefaultCommaTkn: DefaultCommaTkn, + DoubleArrowTkn: DoubleArrowTkn, + ReturnExpr: ReturnExpr, + } + } + list := Exprs.(*ParserSeparatedList) + return &ast.MatchArm{ + Position: b.Pos.NewNodeListNodePosition(list.Items, ReturnExpr), + DefaultTkn: nil, + Exprs: list.Items, + SeparatorTkns: list.SeparatorTkns, + DoubleArrowTkn: DoubleArrowTkn, + ReturnExpr: ReturnExpr, + } +} + +func (b *Builder) NewNameType( + IdentifierTkn *token.Token, +) *ast.Identifier { + return &ast.Identifier{ + Position: b.Pos.NewTokenPosition(IdentifierTkn), + IdentifierTkn: IdentifierTkn, + Value: IdentifierTkn.Value, + } +} + +func (b *Builder) NewNullableType( + QuestionTkn *token.Token, + Expr ast.Vertex, +) *ast.Nullable { + return &ast.Nullable{ + Position: b.Pos.NewTokenNodePosition(QuestionTkn, Expr), + QuestionTkn: QuestionTkn, + Expr: Expr, + } +} + +func (b *Builder) NewUnionType( + Types ast.Vertex, +) *ast.Union { + var types []ast.Vertex + var sepTkns []*token.Token + if Types != nil { + cases := Types.(*ParserSeparatedList) + types = cases.Items + sepTkns = cases.SeparatorTkns + } + + return &ast.Union{ + Position: b.Pos.NewNodeListPosition(types), + Types: types, + SeparatorTkns: sepTkns, + } +} + +func (b *Builder) NewReturnType( + ColonTkn *token.Token, + Type ast.Vertex, +) *ReturnType { + return &ReturnType{ + ColonTkn: ColonTkn, + Type: Type, + } +} + +func (b *Builder) NewTry( + TryTkn *token.Token, + OpenCurlyBracketTkn *token.Token, + Stmts []ast.Vertex, + CloseCurlyBracketTkn *token.Token, + Catches ast.Vertex, + Finally ast.Vertex, +) *ast.StmtTry { + var catches []ast.Vertex + if Catches != nil { + catchList := Catches.(*ParserSeparatedList) + catches = catchList.Items + } + + var pos *position2.Position + + if Finally != nil { + pos = b.Pos.NewTokenNodePosition(TryTkn, Finally) + } else { + pos = b.Pos.NewTokenNodeListPosition(TryTkn, catches) + } + + return &ast.StmtTry{ + Position: pos, + TryTkn: TryTkn, + OpenCurlyBracketTkn: OpenCurlyBracketTkn, + Stmts: Stmts, + CloseCurlyBracketTkn: CloseCurlyBracketTkn, + Catches: catches, + Finally: Finally, + } +} + +func (b *Builder) NewCatch( + CatchTkn *token.Token, + OpenParenthesisTkn *token.Token, + CatchNameList ast.Vertex, + Variable *token.Token, + CloseParenthesisTkn *token.Token, + OpenCurlyBracketTkn *token.Token, + Stmts []ast.Vertex, + CloseCurlyBracketTkn *token.Token, +) *ast.StmtCatch { + var types []ast.Vertex + var sepTkns []*token.Token + if CatchNameList != nil { + catchList := CatchNameList.(*ParserSeparatedList) + types = catchList.Items + sepTkns = catchList.SeparatorTkns + } + + var variable ast.Vertex + + if Variable != nil { + variable = &ast.ExprVariable{ + Position: b.Pos.NewTokenPosition(Variable), + Name: &ast.Identifier{ + Position: b.Pos.NewTokenPosition(Variable), + IdentifierTkn: Variable, + Value: Variable.Value, + }, + } + } + + return &ast.StmtCatch{ + Position: b.Pos.NewTokensPosition(CatchTkn, CloseCurlyBracketTkn), + CatchTkn: CatchTkn, + OpenParenthesisTkn: OpenParenthesisTkn, + Types: types, + SeparatorTkns: sepTkns, + Var: variable, + CloseParenthesisTkn: CloseParenthesisTkn, + OpenCurlyBracketTkn: OpenCurlyBracketTkn, + Stmts: Stmts, + CloseCurlyBracketTkn: CloseCurlyBracketTkn, + } +} + +func (b *Builder) NewThrowStmt( + ThrowTkn *token.Token, + Expr ast.Vertex, +) *ast.StmtThrow { + return &ast.StmtThrow{ + Position: b.Pos.NewTokenNodePosition(ThrowTkn, Expr), + ThrowTkn: ThrowTkn, + Expr: Expr, + } +} + +func (b *Builder) NewThrowExpr( + ThrowTkn *token.Token, + Expr ast.Vertex, +) *ast.ExprThrow { + return &ast.ExprThrow{ + Position: b.Pos.NewTokenNodePosition(ThrowTkn, Expr), + ThrowTkn: ThrowTkn, + Expr: Expr, + } +} + +func (b *Builder) NewParameter( + AttrGroups []ast.Vertex, + Visibility ast.Vertex, + Type ast.Vertex, + AmpersandTkn *token.Token, + VariadicTkn *token.Token, + VarTkn *token.Token, + EqualTkn *token.Token, + DefaultValue ast.Vertex, + WithDefault bool, +) *ast.Parameter { + var pos *position2.Position + + if WithDefault { + if AttrGroups != nil { + pos = b.Pos.NewNodeListNodePosition(AttrGroups, DefaultValue) + } else if Visibility != nil { + pos = b.Pos.NewNodesPosition(Visibility, DefaultValue) + } else if Type != nil { + pos = b.Pos.NewNodesPosition(Type, DefaultValue) + } else if AmpersandTkn != nil { + pos = b.Pos.NewTokenNodePosition(AmpersandTkn, DefaultValue) + } else if VariadicTkn != nil { + pos = b.Pos.NewTokenNodePosition(VariadicTkn, DefaultValue) + } else { + pos = b.Pos.NewTokenNodePosition(VarTkn, DefaultValue) + } + } else { + if AttrGroups != nil { + pos = b.Pos.NewNodeListTokenPosition(AttrGroups, VarTkn) + } else if Visibility != nil { + pos = b.Pos.NewNodeTokenPosition(Visibility, VarTkn) + } else if Type != nil { + pos = b.Pos.NewNodeTokenPosition(Type, VarTkn) + } else if AmpersandTkn != nil { + pos = b.Pos.NewTokensPosition(AmpersandTkn, VarTkn) + } else if VariadicTkn != nil { + pos = b.Pos.NewTokensPosition(VariadicTkn, VarTkn) + } else { + pos = b.Pos.NewTokenPosition(VarTkn) + } + } + + return &ast.Parameter{ + Position: pos, + AttrGroups: AttrGroups, + Visibility: Visibility, + Type: Type, + AmpersandTkn: AmpersandTkn, + VariadicTkn: VariadicTkn, + Var: &ast.ExprVariable{ + Position: b.Pos.NewTokenPosition(VarTkn), + Name: &ast.Identifier{ + Position: b.Pos.NewTokenPosition(VarTkn), + IdentifierTkn: VarTkn, + Value: VarTkn.Value, + }, + }, + EqualTkn: EqualTkn, + DefaultValue: DefaultValue, + } +} + +func (b *Builder) NewAttribute( + Name ast.Vertex, + ArgList ast.Vertex, +) *ast.Attribute { + if ArgList == nil { + return &ast.Attribute{ + Position: b.Pos.NewNodePosition(Name), + Name: Name, + } + } + + argList := ArgList.(*ArgumentList) + return &ast.Attribute{ + Position: b.Pos.NewNodeTokenPosition(Name, argList.CloseParenthesisTkn), + Name: Name, + OpenParenthesisTkn: argList.OpenParenthesisTkn, + Args: argList.Arguments, + SeparatorTkns: argList.SeparatorTkns, + CloseParenthesisTkn: argList.CloseParenthesisTkn, + } +} + +func (b *Builder) NewAttributeGroup( + OpenAttributeTkn *token.Token, + AttrsList ast.Vertex, + OptionalCommaTkn *token.Token, + CloseAttributeTkn *token.Token, +) *ast.AttributeGroup { + attrList := AttrsList.(*ParserSeparatedList) + if OptionalCommaTkn != nil { + attrList.SeparatorTkns = append(attrList.SeparatorTkns, OptionalCommaTkn) + } + return &ast.AttributeGroup{ + Position: b.Pos.NewTokensPosition(OpenAttributeTkn, CloseAttributeTkn), + OpenAttributeTkn: OpenAttributeTkn, + Attrs: attrList.Items, + SeparatorTkns: attrList.SeparatorTkns, + CloseAttributeTkn: CloseAttributeTkn, + } +} + +func (b *Builder) NewClass( + AttrGroups []ast.Vertex, + Modifiers []ast.Vertex, + ClassTkn *token.Token, + Name *token.Token, + + ExtendsFrom ast.Vertex, + ImplementsList ast.Vertex, + + OpenCurlyBracketTkn *token.Token, + Stmts []ast.Vertex, + CloseCurlyBracketTkn *token.Token, +) *ast.StmtClass { + var pos *position2.Position + if AttrGroups != nil { + pos = b.Pos.NewNodeListTokenPosition(AttrGroups, CloseCurlyBracketTkn) + } else if Modifiers != nil { + pos = b.Pos.NewNodeListTokenPosition(Modifiers, CloseCurlyBracketTkn) + } else { + pos = b.Pos.NewTokensPosition(ClassTkn, CloseCurlyBracketTkn) + } + + var name ast.Vertex + + if Name != nil { + name = &ast.Identifier{ + Position: b.Pos.NewTokenPosition(Name), + IdentifierTkn: Name, + Value: Name.Value, + } + } + + class := &ast.StmtClass{ + Position: pos, + AttrGroups: AttrGroups, + Modifiers: Modifiers, + ClassTkn: ClassTkn, + Name: name, + OpenCurlyBracketTkn: OpenCurlyBracketTkn, + Stmts: Stmts, + CloseCurlyBracketTkn: CloseCurlyBracketTkn, + } + + if ExtendsFrom != nil { + class.ExtendsTkn = ExtendsFrom.(*ast.StmtClass).ExtendsTkn + class.Extends = ExtendsFrom.(*ast.StmtClass).Extends + } + + if ImplementsList != nil { + class.ImplementsTkn = ImplementsList.(*ast.StmtClass).ImplementsTkn + class.Implements = ImplementsList.(*ast.StmtClass).Implements + class.ImplementsSeparatorTkns = ImplementsList.(*ast.StmtClass).ImplementsSeparatorTkns + } + + return class +} + +func (b *Builder) NewAnonClass( + AttrGroups []ast.Vertex, + ClassTkn *token.Token, + + ArgList ast.Vertex, + + ExtendsFrom ast.Vertex, + ImplementsList ast.Vertex, + + OpenCurlyBracketTkn *token.Token, + Stmts []ast.Vertex, + CloseCurlyBracketTkn *token.Token, +) *ast.StmtClass { + class := b.NewClass( + AttrGroups, + nil, // Modifiers + ClassTkn, + nil, // Name + ExtendsFrom, + ImplementsList, + OpenCurlyBracketTkn, + Stmts, + CloseCurlyBracketTkn, + ) + + if ArgList == nil { + return class + } + + argList := ArgList.(*ArgumentList) + + class.OpenParenthesisTkn = argList.OpenParenthesisTkn + class.Args = argList.Arguments + class.SeparatorTkns = argList.SeparatorTkns + class.CloseParenthesisTkn = argList.CloseParenthesisTkn + + return class +} + +func (b *Builder) NewTrait( + AttrGroups []ast.Vertex, + TraitTkn *token.Token, + Name *token.Token, + OpenCurlyBracketTkn *token.Token, + Stmts []ast.Vertex, + CloseCurlyBracketTkn *token.Token, +) *ast.StmtTrait { + return &ast.StmtTrait{ + Position: b.Pos.NewOptionalListTokensPosition(AttrGroups, TraitTkn, CloseCurlyBracketTkn), + AttrGroups: AttrGroups, + TraitTkn: TraitTkn, + Name: &ast.Identifier{ + Position: b.Pos.NewTokenPosition(Name), + IdentifierTkn: Name, + Value: Name.Value, + }, + OpenCurlyBracketTkn: OpenCurlyBracketTkn, + Stmts: Stmts, + CloseCurlyBracketTkn: CloseCurlyBracketTkn, + } +} + +func (b *Builder) NewInterface( + AttrGroups []ast.Vertex, + InterfaceTkn *token.Token, + Name *token.Token, + ExtendsFrom ast.Vertex, + OpenCurlyBracketTkn *token.Token, + Stmts []ast.Vertex, + CloseCurlyBracketTkn *token.Token, +) *ast.StmtInterface { + iface := &ast.StmtInterface{ + Position: b.Pos.NewOptionalListTokensPosition(AttrGroups, InterfaceTkn, CloseCurlyBracketTkn), + AttrGroups: AttrGroups, + InterfaceTkn: InterfaceTkn, + Name: &ast.Identifier{ + Position: b.Pos.NewTokenPosition(Name), + IdentifierTkn: Name, + Value: Name.Value, + }, + OpenCurlyBracketTkn: OpenCurlyBracketTkn, + Stmts: Stmts, + CloseCurlyBracketTkn: CloseCurlyBracketTkn, + } + + if ExtendsFrom != nil { + iface.ExtendsTkn = ExtendsFrom.(*ast.StmtInterface).ExtendsTkn + iface.Extends = ExtendsFrom.(*ast.StmtInterface).Extends + iface.ExtendsSeparatorTkns = ExtendsFrom.(*ast.StmtInterface).ExtendsSeparatorTkns + } + + return iface +} + +func (b *Builder) NewFunction( + AttrGroups []ast.Vertex, + FunctionTkn *token.Token, + AmpersandTkn *token.Token, + Name *token.Token, + OpenParenthesisTkn *token.Token, + Params ast.Vertex, + CloseParenthesisTkn *token.Token, + RetType ast.Vertex, + OpenCurlyBracketTkn *token.Token, + Stmts []ast.Vertex, + CloseCurlyBracketTkn *token.Token, +) *ast.StmtFunction { + var params []ast.Vertex + var sepTkns []*token.Token + if Params != nil { + paramsList := Params.(*ParserSeparatedList) + params = paramsList.Items + sepTkns = paramsList.SeparatorTkns + } + + returnType := RetType.(*ReturnType) + + return &ast.StmtFunction{ + Position: b.Pos.NewOptionalListTokensPosition(AttrGroups, FunctionTkn, CloseCurlyBracketTkn), + AttrGroups: AttrGroups, + FunctionTkn: FunctionTkn, + AmpersandTkn: AmpersandTkn, + Name: &ast.Identifier{ + Position: b.Pos.NewTokenPosition(Name), + IdentifierTkn: Name, + Value: Name.Value, + }, + OpenParenthesisTkn: OpenParenthesisTkn, + Params: params, + SeparatorTkns: sepTkns, + CloseParenthesisTkn: CloseParenthesisTkn, + ColonTkn: returnType.ColonTkn, + ReturnType: returnType.Type, + OpenCurlyBracketTkn: OpenCurlyBracketTkn, + Stmts: Stmts, + CloseCurlyBracketTkn: CloseCurlyBracketTkn, + } +} + +func (b *Builder) NewPropertyList( + AttrGroups []ast.Vertex, + Modifiers []ast.Vertex, + Type ast.Vertex, + PropsList ast.Vertex, + SemiColonTkn *token.Token, +) *ast.StmtPropertyList { + props, sepTkns := b.SeparatedListItems(PropsList) + + var pos *position2.Position + + if AttrGroups != nil { + pos = b.Pos.NewNodeListTokenPosition(AttrGroups, SemiColonTkn) + } else { + pos = b.Pos.NewNodeListTokenPosition(Modifiers, SemiColonTkn) + } + + return &ast.StmtPropertyList{ + Position: pos, + AttrGroups: AttrGroups, + Modifiers: Modifiers, + Type: Type, + Props: props, + SeparatorTkns: sepTkns, + SemiColonTkn: SemiColonTkn, + } +} + +func (b *Builder) NewClassConstList( + AttrGroups []ast.Vertex, + Modifiers []ast.Vertex, + ConstTkn *token.Token, + ConstList ast.Vertex, + SemiColonTkn *token.Token, +) *ast.StmtClassConstList { + consts, sepTkns := b.SeparatedListItems(ConstList) + + var pos *position2.Position + + if AttrGroups != nil { + pos = b.Pos.NewNodeListTokenPosition(AttrGroups, SemiColonTkn) + } else { + pos = b.Pos.NewOptionalListTokensPosition(Modifiers, ConstTkn, SemiColonTkn) + } + + return &ast.StmtClassConstList{ + Position: pos, + AttrGroups: AttrGroups, + Modifiers: Modifiers, + ConstTkn: ConstTkn, + Consts: consts, + SeparatorTkns: sepTkns, + SemiColonTkn: SemiColonTkn, + } +} + +func (b *Builder) NewClassMethod( + AttrGroups []ast.Vertex, + Modifiers []ast.Vertex, + FunctionTkn *token.Token, + AmpersandTkn *token.Token, + Name *token.Token, + + OpenParenthesisTkn *token.Token, + Params ast.Vertex, + CloseParenthesisTkn *token.Token, + + RetType ast.Vertex, + + Stmt ast.Vertex, +) *ast.StmtClassMethod { + params, sepTkns := b.SeparatedListItems(Params) + returnType := RetType.(*ReturnType) + + var pos *position2.Position + + if AttrGroups != nil { + pos = b.Pos.NewNodeListNodePosition(AttrGroups, Stmt) + } else if Modifiers != nil { + pos = b.Pos.NewNodeListNodePosition(Modifiers, Stmt) + } else { + pos = b.Pos.NewTokenNodePosition(FunctionTkn, Stmt) + } + + return &ast.StmtClassMethod{ + Position: pos, + AttrGroups: AttrGroups, + Modifiers: Modifiers, + FunctionTkn: FunctionTkn, + AmpersandTkn: AmpersandTkn, + Name: &ast.Identifier{ + Position: b.Pos.NewTokenPosition(Name), + IdentifierTkn: Name, + Value: Name.Value, + }, + OpenParenthesisTkn: OpenParenthesisTkn, + Params: params, + SeparatorTkns: sepTkns, + CloseParenthesisTkn: CloseParenthesisTkn, + ColonTkn: returnType.ColonTkn, + ReturnType: returnType.Type, + Stmt: Stmt, + } +} + +func (b *Builder) NewNamespace( + NsTkn *token.Token, + Name ast.Vertex, + OpenCurlyBracketTkn *token.Token, + Stmts []ast.Vertex, + CloseCurlyBracketTkn *token.Token, + SemiColonTkn *token.Token, +) *ast.StmtNamespace { + var pos *position2.Position + + if SemiColonTkn != nil { + pos = b.Pos.NewTokensPosition(NsTkn, SemiColonTkn) + } else { + pos = b.Pos.NewTokensPosition(NsTkn, CloseCurlyBracketTkn) + } + + return &ast.StmtNamespace{ + Position: pos, + NsTkn: NsTkn, + Name: Name, + OpenCurlyBracketTkn: OpenCurlyBracketTkn, + Stmts: Stmts, + CloseCurlyBracketTkn: CloseCurlyBracketTkn, + SemiColonTkn: SemiColonTkn, + } +} + +func (b *Builder) NewUseList( + UseTkn *token.Token, + Type *token.Token, + UsesList ast.Vertex, + SemiColonTkn *token.Token, +) *ast.StmtUseList { + uses, sepTkns := b.SeparatedListItems(UsesList) + + return &ast.StmtUseList{ + Position: b.Pos.NewTokensPosition(UseTkn, SemiColonTkn), + UseTkn: UseTkn, + Type: b.NewIdentifier(Type), + Uses: uses, + SeparatorTkns: sepTkns, + SemiColonTkn: SemiColonTkn, + } +} + +func (b *Builder) NewGroupUseList( + UseTkn *token.Token, + Type *token.Token, + + Prefix ast.Vertex, + + NsSeparatorTkn *token.Token, + + OpenCurlyBracketTkn *token.Token, + + UsesList ast.Vertex, + + CloseCurlyBracketTkn *token.Token, + SemiColonTkn *token.Token, +) *ast.StmtGroupUseList { + uses, sepTkns := b.SeparatedListItems(UsesList) + + groupUse := &ast.StmtGroupUseList{ + Position: b.Pos.NewTokensPosition(UseTkn, SemiColonTkn), + UseTkn: UseTkn, + Type: b.NewIdentifier(Type), + Prefix: Prefix, + NsSeparatorTkn: NsSeparatorTkn, + OpenCurlyBracketTkn: OpenCurlyBracketTkn, + Uses: uses, + SeparatorTkns: sepTkns, + CloseCurlyBracketTkn: CloseCurlyBracketTkn, + SemiColonTkn: SemiColonTkn, + } + + if n, ok := Prefix.(*ast.NameFullyQualified); ok { + groupUse.LeadingNsSeparatorTkn = n.NsSeparatorTkn + + prefix := &ast.Name{ + Position: n.Position, + Parts: n.Parts, + SeparatorTkns: n.SeparatorTkns, + } + prefix.Position.StartPos++ + + groupUse.Prefix = prefix + } + + return groupUse +} + +func (b *Builder) NewUse( + Type ast.Vertex, + + UseName ast.Vertex, + + AsTkn *token.Token, + Alias *token.Token, +) *ast.StmtUse { + use := &ast.StmtUse{ + Type: Type, + Use: UseName, + AsTkn: AsTkn, + Alias: b.NewIdentifier(Alias), + } + + if Alias != nil { + use.Position = b.Pos.NewNodeTokenPosition(UseName, Alias) + } else { + use.Position = b.Pos.NewNodePosition(UseName) + } + + if n, ok := UseName.(*ast.NameFullyQualified); ok { + use.NsSeparatorTkn = n.NsSeparatorTkn + + name := &ast.Name{ + Position: n.Position, + Parts: n.Parts, + SeparatorTkns: n.SeparatorTkns, + } + name.Position.StartPos++ + + use.Use = name + } + + return use +} diff --git a/internal/php8/lexer.go b/internal/php8/lexer.go new file mode 100644 index 0000000..f8a8b16 --- /dev/null +++ b/internal/php8/lexer.go @@ -0,0 +1,251 @@ +package php8 + +import ( + "bytes" + "strings" + + "github.com/z7zmey/php-parser/pkg/conf" + "github.com/z7zmey/php-parser/pkg/errors" + "github.com/z7zmey/php-parser/pkg/position" + "github.com/z7zmey/php-parser/pkg/token" + "github.com/z7zmey/php-parser/pkg/version" +) + +type Lexer struct { + data []byte + phpVersion *version.Version + errHandlerFunc func(*errors.Error) + + p, pe, cs int + ts, te, act int + stack []int + top int + + heredocLabel []byte + tokenPool *token.Pool + positionPool *position.Pool + newLines NewLines +} + +func NewLexer(data []byte, config conf.Config) *Lexer { + lex := &Lexer{ + data: data, + phpVersion: config.Version, + errHandlerFunc: config.ErrorHandlerFunc, + + pe: len(data), + stack: make([]int, 0), + + tokenPool: token.NewPool(position.DefaultBlockSize), + positionPool: position.NewPool(token.DefaultBlockSize), + newLines: NewLines{make([]int, 0, 128)}, + } + + initLexer(lex) + + return lex +} + +func (lex *Lexer) setTokenPosition(token *token.Token) { + pos := lex.positionPool.Get() + + pos.StartLine = lex.newLines.GetLine(lex.ts) + pos.EndLine = lex.newLines.GetLine(lex.te - 1) + pos.StartPos = lex.ts + pos.EndPos = lex.te + + token.Position = pos +} + +func (lex *Lexer) addFreeFloatingToken(t *token.Token, id token.ID, ps, pe int) { + skippedTkn := lex.tokenPool.Get() + skippedTkn.ID = id + skippedTkn.Value = lex.data[ps:pe] + + lex.setTokenPosition(skippedTkn) + + if t.FreeFloating == nil { + t.FreeFloating = make([]*token.Token, 0, 2) + } + + t.FreeFloating = append(t.FreeFloating, skippedTkn) +} + +func (lex *Lexer) isNotStringVar() bool { + p := lex.p + if lex.data[p-1] == '\\' && lex.data[p-2] != '\\' { + return true + } + + if len(lex.data) < p+1 { + return true + } + + if lex.data[p] == '$' && (lex.data[p+1] == '{' || isValidVarNameStart(lex.data[p+1])) { + return false + } + + if lex.data[p] == '{' && lex.data[p+1] == '$' { + return false + } + + return true +} + +func (lex *Lexer) isNotStringEnd(s byte) bool { + p := lex.p + if lex.data[p-1] == '\\' && lex.data[p-2] != '\\' { + return true + } + + return !(lex.data[p] == s) +} + +func (lex *Lexer) isHeredocEnd(p int) bool { + o, err := version.New("7.3") + if err != nil { + panic(err) + } + + if lex.phpVersion.GreaterOrEqual(o) { + return lex.isHeredocEndSince73(p) + } + + return lex.isHeredocEndBefore73(p) +} + +func (lex *Lexer) isHeredocEndBefore73(p int) bool { + if lex.data[p-1] != '\r' && lex.data[p-1] != '\n' { + return false + } + + l := len(lex.heredocLabel) + if len(lex.data) < p+l { + return false + } + + if len(lex.data) > p+l && lex.data[p+l] != ';' && lex.data[p+l] != '\r' && lex.data[p+l] != '\n' { + return false + } + + if len(lex.data) > p+l+1 && lex.data[p+l] == ';' && lex.data[p+l+1] != '\r' && lex.data[p+l+1] != '\n' { + return false + } + + return bytes.Equal(lex.heredocLabel, lex.data[p:p+l]) +} + +func (lex *Lexer) isHeredocEndSince73(p int) bool { + if lex.data[p-1] != '\r' && lex.data[p-1] != '\n' { + return false + } + + if p == len(lex.data) { + return false + } + + for lex.data[p] == ' ' || lex.data[p] == '\t' { + p++ + } + + l := len(lex.heredocLabel) + if len(lex.data) < p+l { + return false + } + + if len(lex.data) > p+l && isValidVarName(lex.data[p+l]) { + return false + } + + a := string(lex.heredocLabel) + b := string(lex.data[p : p+l]) + + _, _ = a, b + + if bytes.Equal(lex.heredocLabel, lex.data[p:p+l]) { + lex.p = p + return true + } + + return false +} + +func (lex *Lexer) isNotHeredocEnd(p int) bool { + return !lex.isHeredocEnd(p) +} + +func (lex *Lexer) growCallStack() { + if lex.top == len(lex.stack) { + lex.stack = append(lex.stack, 0) + } +} + +func (lex *Lexer) isNotPhpCloseToken() bool { + if lex.p+1 == len(lex.data) { + return true + } + + return lex.data[lex.p] != '?' || lex.data[lex.p+1] != '>' +} + +func (lex *Lexer) isNotNewLine() bool { + if lex.data[lex.p] == '\n' && lex.data[lex.p-1] == '\r' { + return true + } + + return lex.data[lex.p-1] != '\n' && lex.data[lex.p-1] != '\r' +} + +func (lex *Lexer) call(state int, fnext int) { + lex.growCallStack() + + lex.stack[lex.top] = state + lex.top++ + + lex.p++ + lex.cs = fnext +} + +func (lex *Lexer) ret(n int) { + lex.top = lex.top - n + if lex.top < 0 { + lex.top = 0 + } + lex.cs = lex.stack[lex.top] + lex.p++ +} + +func (lex *Lexer) ungetStr(s string) { + tokenStr := string(lex.data[lex.ts:lex.te]) + if strings.HasSuffix(tokenStr, s) { + lex.ungetCnt(len(s)) + } +} + +func (lex *Lexer) ungetCnt(n int) { + lex.p = lex.p - n + lex.te = lex.te - n +} + +func (lex *Lexer) error(msg string) { + if lex.errHandlerFunc == nil { + return + } + + pos := position.NewPosition( + lex.newLines.GetLine(lex.ts), + lex.newLines.GetLine(lex.te-1), + lex.ts, + lex.te, + ) + + lex.errHandlerFunc(errors.NewError(msg, pos)) +} + +func isValidVarNameStart(r byte) bool { + return (r >= 'A' && r <= 'Z') || (r >= 'a' && r <= 'z') || r == '_' || r >= 0x80 +} + +func isValidVarName(r byte) bool { + return (r >= 'A' && r <= 'Z') || (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') || r == '_' || r >= 0x80 +} diff --git a/internal/php8/newline.go b/internal/php8/newline.go new file mode 100644 index 0000000..111501d --- /dev/null +++ b/internal/php8/newline.go @@ -0,0 +1,25 @@ +package php8 + +type NewLines struct { + data []int +} + +func (nl *NewLines) Append(p int) { + if len(nl.data) == 0 || nl.data[len(nl.data)-1] < p { + nl.data = append(nl.data, p) + } +} + +func (nl *NewLines) GetLine(p int) int { + line := len(nl.data) + 1 + + for i := len(nl.data) - 1; i >= 0; i-- { + if p < nl.data[i] { + line = i + 1 + } else { + break + } + } + + return line +} diff --git a/internal/php8/node.go b/internal/php8/node.go new file mode 100644 index 0000000..bc4b44c --- /dev/null +++ b/internal/php8/node.go @@ -0,0 +1,99 @@ +package php8 + +import ( + "github.com/z7zmey/php-parser/pkg/ast" + "github.com/z7zmey/php-parser/pkg/position" + "github.com/z7zmey/php-parser/pkg/token" +) + +type ParserBrackets struct { + Position *position.Position + OpenBracketTkn *token.Token + Child ast.Vertex + CloseBracketTkn *token.Token +} + +func (n *ParserBrackets) Accept(v ast.Visitor) { + // do nothing +} + +func (n *ParserBrackets) GetPosition() *position.Position { + return n.Position +} + +type ParserSeparatedList struct { + Position *position.Position + Items []ast.Vertex + SeparatorTkns []*token.Token +} + +func (n *ParserSeparatedList) Accept(v ast.Visitor) { + // do nothing +} + +func (n *ParserSeparatedList) GetPosition() *position.Position { + return n.Position +} + +// TraitAdaptationList node +type TraitAdaptationList struct { + Position *position.Position + OpenCurlyBracketTkn *token.Token + Adaptations []ast.Vertex + CloseCurlyBracketTkn *token.Token +} + +func (n *TraitAdaptationList) Accept(v ast.Visitor) { + // do nothing +} + +func (n *TraitAdaptationList) GetPosition() *position.Position { + return n.Position +} + +// ArgumentList node +type ArgumentList struct { + Position *position.Position + OpenParenthesisTkn *token.Token + Arguments []ast.Vertex + SeparatorTkns []*token.Token + CloseParenthesisTkn *token.Token +} + +func (n *ArgumentList) Accept(v ast.Visitor) { + // do nothing +} + +func (n *ArgumentList) GetPosition() *position.Position { + return n.Position +} + +type ReturnType struct { + Position *position.Position + ColonTkn *token.Token + Type ast.Vertex +} + +func (n *ReturnType) Accept(v ast.Visitor) { + // do nothing +} + +func (n *ReturnType) GetPosition() *position.Position { + return n.Position +} + +// TraitMethodRef node +type TraitMethodRef struct { + Position *position.Position + Trait ast.Vertex + DoubleColonTkn *token.Token + Method ast.Vertex +} + +func (n *TraitMethodRef) Accept(v ast.Visitor) { + // do nothing +} + +func (n *TraitMethodRef) GetPosition() *position.Position { + return n.Position +} diff --git a/internal/php8/parser.go b/internal/php8/parser.go new file mode 100644 index 0000000..4ff6d8d --- /dev/null +++ b/internal/php8/parser.go @@ -0,0 +1,66 @@ +package php8 + +import ( + "github.com/z7zmey/php-parser/internal/position" + "github.com/z7zmey/php-parser/pkg/ast" + "github.com/z7zmey/php-parser/pkg/conf" + "github.com/z7zmey/php-parser/pkg/errors" + "github.com/z7zmey/php-parser/pkg/token" +) + +// Parser structure +type Parser struct { + Lexer *Lexer + currentToken *token.Token + rootNode ast.Vertex + errHandlerFunc func(*errors.Error) + builder *Builder +} + +// NewParser creates and returns new Parser +func NewParser(lexer *Lexer, config conf.Config) *Parser { + p := &Parser{ + Lexer: lexer, + errHandlerFunc: config.ErrorHandlerFunc, + } + p.builder = NewBuilder(position.NewBuilder(), p) + return p +} + +func (p *Parser) Lex(lval *yySymType) int { + t := p.Lexer.Lex() + + p.currentToken = t + lval.token = t + + return int(t.ID) +} + +func (p *Parser) Error(msg string) { + if p.errHandlerFunc == nil { + return + } + + p.errHandlerFunc(errors.NewError(msg, p.currentToken.Position)) +} + +// Parse the php7 Parser entrypoint +func (p *Parser) Parse() int { + p.rootNode = nil + + return yyParse(p) +} + +// GetRootNode returns root node +func (p *Parser) GetRootNode() ast.Vertex { + return p.rootNode +} + +// helpers + +func lastNode(nn []ast.Vertex) ast.Vertex { + if len(nn) == 0 { + return nil + } + return nn[len(nn)-1] +} diff --git a/internal/php8/parser_php8_test.go b/internal/php8/parser_php8_test.go new file mode 100644 index 0000000..ee6d1ce --- /dev/null +++ b/internal/php8/parser_php8_test.go @@ -0,0 +1,4896 @@ +package php8_test + +import ( + "testing" + + "github.com/z7zmey/php-parser/internal/tester" + "github.com/z7zmey/php-parser/pkg/ast" + "github.com/z7zmey/php-parser/pkg/conf" + "github.com/z7zmey/php-parser/pkg/errors" + "github.com/z7zmey/php-parser/pkg/parser" + "github.com/z7zmey/php-parser/pkg/position" + "github.com/z7zmey/php-parser/pkg/token" + "github.com/z7zmey/php-parser/pkg/version" + "gotest.tools/assert" +) + +func TestNullsafeExprMethodCall(t *testing.T) { + suite := tester.NewParserTestSuite(t) + suite.UsePHP8() + suite.Code = `foo();` + + suite.Expected = &ast.Root{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 14, + }, + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 14, + }, + Expr: &ast.ExprNullsafeMethodCall{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 13, + }, + Var: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 5, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 5, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 5, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 5, + EndPos: 8, + }, + }, + Method: &ast.Identifier{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 8, + EndPos: 11, + }, + IdentifierTkn: &token.Token{ + ID: token.T_STRING, + Value: []byte("foo"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 8, + EndPos: 11, + }, + }, + Value: []byte("foo"), + }, + OpenParenthesisTkn: &token.Token{ + ID: token.ID(40), + Value: []byte("("), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 11, + EndPos: 12, + }, + }, + CloseParenthesisTkn: &token.Token{ + ID: token.ID(41), + Value: []byte(")"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 12, + EndPos: 13, + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 13, + EndPos: 14, + }, + }, + }, + }, + EndTkn: &token.Token{}, + } + + suite.Run() +} + +func TestNullsafePropertyFetch(t *testing.T) { + suite := tester.NewParserTestSuite(t) + suite.UsePHP8() + suite.Code = `foo;` + + suite.Expected = &ast.Root{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 6, + EndPos: 15, + }, + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 6, + EndPos: 15, + }, + Expr: &ast.ExprNullsafePropertyFetch{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 6, + EndPos: 14, + }, + Var: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 6, + EndPos: 8, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 6, + EndPos: 8, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 6, + EndPos: 8, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 8, + EndPos: 11, + }, + }, + Prop: &ast.Identifier{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 11, + EndPos: 14, + }, + IdentifierTkn: &token.Token{ + ID: token.T_STRING, + Value: []byte("foo"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 11, + EndPos: 14, + }, + }, + Value: []byte("foo"), + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 14, + EndPos: 15, + }, + }, + }, + }, + EndTkn: &token.Token{}, + } + + suite.Run() +} + +func TestNullsafePropertyFetchInEncapsed(t *testing.T) { + suite := tester.NewParserTestSuite(t) + suite.UsePHP8() + suite.Code = `foo";` + + suite.Expected = &ast.Root{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 6, + EndPos: 17, + }, + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 6, + EndPos: 17, + }, + Expr: &ast.ScalarEncapsed{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 6, + EndPos: 16, + }, + OpenQuoteTkn: &token.Token{ + ID: token.ID(34), + Value: []byte("\""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 6, + EndPos: 7, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 9, + EndPos: 12, + }, + }, + Prop: &ast.Identifier{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 12, + EndPos: 15, + }, + IdentifierTkn: &token.Token{ + ID: token.T_STRING, + Value: []byte("foo"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 12, + EndPos: 15, + }, + }, + Value: []byte("foo"), + }, + }, + }, + CloseQuoteTkn: &token.Token{ + ID: token.ID(34), + Value: []byte("\""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 15, + EndPos: 16, + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 16, + EndPos: 17, + }, + }, + }, + }, + EndTkn: &token.Token{}, + } + + suite.Run() +} + +func TestNullsafePropertyFetchForDereferencable(t *testing.T) { + suite := tester.NewParserTestSuite(t) + suite.UsePHP8() + suite.Code = `foo;` + + suite.Expected = &ast.Root{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 6, + EndPos: 18, + }, + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 6, + EndPos: 18, + }, + Expr: &ast.ExprNullsafePropertyFetch{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 6, + EndPos: 17, + }, + Var: &ast.ExprBrackets{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 6, + EndPos: 11, + }, + OpenParenthesisTkn: &token.Token{ + ID: token.ID(40), + Value: []byte("("), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 6, + EndPos: 7, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 11, + EndPos: 14, + }, + }, + Prop: &ast.Identifier{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 14, + EndPos: 17, + }, + IdentifierTkn: &token.Token{ + ID: token.T_STRING, + Value: []byte("foo"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 14, + EndPos: 17, + }, + }, + Value: []byte("foo"), + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 17, + EndPos: 18, + }, + }, + }, + }, + EndTkn: &token.Token{}, + } + + suite.Run() +} + +func TestExprCast(t *testing.T) { + suite := tester.NewParserTestSuite(t) + suite.UsePHP8() + suite.Code = `bar(some: $a, $b, ...$c); +foo::bar($a, b: $b, ...$c); +$foo::bar($b, c: $a, ...$b); +new foo(a: $a, $c, ...$b); +/** anonymous class */ +new class (name: $a, $b, ...$c) {}; +` + + config := conf.Config{ + Version: &version.Version{Major: 8, Minor: 0}, + } + + root, err := parser.Parse([]byte(suite.Code), config) + if err != nil { + t.Fatalf("Error parse: %v", err) + } + + stmts := root.(*ast.Root).Stmts + + for _, stmt := range stmts { + stmtExpr, ok := stmt.(*ast.StmtExpression) + if !ok { + continue + } + + switch n := stmtExpr.Expr.(type) { + case *ast.ExprFunctionCall: + assert.Assert(t, len(n.Args) == 3) + case *ast.ExprMethodCall: + assert.Assert(t, len(n.Args) == 3) + case *ast.ExprStaticCall: + assert.Assert(t, len(n.Args) == 3) + case *ast.ExprNew: + if class, ok := n.Class.(*ast.StmtClass); ok { + assert.Assert(t, len(class.Args) == 3) + continue + } + + assert.Assert(t, len(n.Args) == 3) + } + } +} + +func TestCurlyBracesAccessParserError(t *testing.T) { + suite := tester.NewParserErrorTestSuite(t) + suite.UsePHP8() + suite.Code = ` 100 +}; +` + + suite.Expected = &ast.Root{ + Position: &position.Position{ + StartLine: 2, + EndLine: 4, + StartPos: 6, + EndPos: 33, + }, + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 2, + EndLine: 4, + StartPos: 6, + EndPos: 33, + }, + Expr: &ast.ExprMatch{ + Position: &position.Position{ + StartLine: 2, + EndLine: 4, + StartPos: 6, + EndPos: 32, + }, + MatchTkn: &token.Token{ + ID: token.T_MATCH, + Value: []byte("match"), + Position: &position.Position{ + StartLine: 2, + EndLine: 2, + StartPos: 6, + EndPos: 11, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 3, + EndLine: 3, + StartPos: 24, + EndPos: 26, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 3, + EndLine: 3, + StartPos: 23, + EndPos: 24, + }, + }, + }, + }, + ReturnExpr: &ast.ScalarLnumber{ + Position: &position.Position{ + StartLine: 3, + EndLine: 3, + StartPos: 27, + EndPos: 30, + }, + NumberTkn: &token.Token{ + ID: token.T_LNUMBER, + Value: []byte("100"), + Position: &position.Position{ + StartLine: 3, + EndLine: 3, + StartPos: 27, + EndPos: 30, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 3, + EndLine: 3, + StartPos: 26, + EndPos: 27, + }, + }, + }, + }, + Value: []byte("100"), + }, + }, + }, + CloseCurlyBracketTkn: &token.Token{ + ID: token.ID(125), + Value: []byte("}"), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 31, + EndPos: 32, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n"), + Position: &position.Position{ + StartLine: 3, + EndLine: 3, + StartPos: 30, + EndPos: 31, + }, + }, + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 32, + EndPos: 33, + }, + }, + }, + }, + EndTkn: &token.Token{ + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n"), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 33, + EndPos: 34, + }, + }, + }, + }, + } + + suite.Run() +} + +func TestMatchExprWithList(t *testing.T) { + suite := tester.NewParserTestSuite(t) + suite.UsePHP8() + suite.Code = ` 100 +}; +` + + suite.Expected = &ast.Root{ + Position: &position.Position{ + StartLine: 2, + EndLine: 4, + StartPos: 6, + EndPos: 37, + }, + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 2, + EndLine: 4, + StartPos: 6, + EndPos: 37, + }, + Expr: &ast.ExprMatch{ + Position: &position.Position{ + StartLine: 2, + EndLine: 4, + StartPos: 6, + EndPos: 36, + }, + MatchTkn: &token.Token{ + ID: token.T_MATCH, + Value: []byte("match"), + Position: &position.Position{ + StartLine: 2, + EndLine: 2, + StartPos: 6, + EndPos: 11, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 3, + EndLine: 3, + StartPos: 28, + EndPos: 30, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 3, + EndLine: 3, + StartPos: 27, + EndPos: 28, + }, + }, + }, + }, + ReturnExpr: &ast.ScalarLnumber{ + Position: &position.Position{ + StartLine: 3, + EndLine: 3, + StartPos: 31, + EndPos: 34, + }, + NumberTkn: &token.Token{ + ID: token.T_LNUMBER, + Value: []byte("100"), + Position: &position.Position{ + StartLine: 3, + EndLine: 3, + StartPos: 31, + EndPos: 34, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 3, + EndLine: 3, + StartPos: 30, + EndPos: 31, + }, + }, + }, + }, + Value: []byte("100"), + }, + }, + }, + CloseCurlyBracketTkn: &token.Token{ + ID: token.ID(125), + Value: []byte("}"), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 35, + EndPos: 36, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n"), + Position: &position.Position{ + StartLine: 3, + EndLine: 3, + StartPos: 34, + EndPos: 35, + }, + }, + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 36, + EndPos: 37, + }, + }, + }, + }, + EndTkn: &token.Token{ + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n"), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 37, + EndPos: 38, + }, + }, + }, + }, + } + + suite.Run() +} + +func TestMatchExprWithDefault(t *testing.T) { + suite := tester.NewParserTestSuite(t) + suite.UsePHP8() + suite.Code = ` 100, + default => 101, +}; +` + + suite.Expected = &ast.Root{ + Position: &position.Position{ + StartLine: 2, + EndLine: 5, + StartPos: 6, + EndPos: 52, + }, + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 2, + EndLine: 5, + StartPos: 6, + EndPos: 52, + }, + Expr: &ast.ExprMatch{ + Position: &position.Position{ + StartLine: 2, + EndLine: 5, + StartPos: 6, + EndPos: 51, + }, + MatchTkn: &token.Token{ + ID: token.T_MATCH, + Value: []byte("match"), + Position: &position.Position{ + StartLine: 2, + EndLine: 2, + StartPos: 6, + EndPos: 11, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 3, + EndLine: 3, + StartPos: 24, + EndPos: 26, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 3, + EndLine: 3, + StartPos: 23, + EndPos: 24, + }, + }, + }, + }, + ReturnExpr: &ast.ScalarLnumber{ + Position: &position.Position{ + StartLine: 3, + EndLine: 3, + StartPos: 27, + EndPos: 30, + }, + NumberTkn: &token.Token{ + ID: token.T_LNUMBER, + Value: []byte("100"), + Position: &position.Position{ + StartLine: 3, + EndLine: 3, + StartPos: 27, + EndPos: 30, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 3, + EndLine: 3, + StartPos: 26, + EndPos: 27, + }, + }, + }, + }, + Value: []byte("100"), + }, + }, + &ast.MatchArm{ + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 34, + EndPos: 48, + }, + DefaultTkn: &token.Token{ + ID: token.T_DEFAULT, + Value: []byte("default"), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 34, + EndPos: 41, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n "), + Position: &position.Position{ + StartLine: 3, + EndLine: 4, + StartPos: 31, + EndPos: 34, + }, + }, + }, + }, + DoubleArrowTkn: &token.Token{ + ID: token.T_DOUBLE_ARROW, + Value: []byte("=>"), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 42, + EndPos: 44, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 41, + EndPos: 42, + }, + }, + }, + }, + ReturnExpr: &ast.ScalarLnumber{ + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 45, + EndPos: 48, + }, + NumberTkn: &token.Token{ + ID: token.T_LNUMBER, + Value: []byte("101"), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 45, + EndPos: 48, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 44, + EndPos: 45, + }, + }, + }, + }, + Value: []byte("101"), + }, + }, + }, + SeparatorTkns: []*token.Token{ + { + ID: token.ID(44), + Value: []byte(","), + Position: &position.Position{ + StartLine: 3, + EndLine: 3, + StartPos: 30, + EndPos: 31, + }, + }, + { + ID: token.ID(44), + Value: []byte(","), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 48, + EndPos: 49, + }, + }, + }, + CloseCurlyBracketTkn: &token.Token{ + ID: token.ID(125), + Value: []byte("}"), + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 50, + EndPos: 51, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n"), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 49, + EndPos: 50, + }, + }, + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 51, + EndPos: 52, + }, + }, + }, + }, + EndTkn: &token.Token{ + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n"), + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 52, + EndPos: 53, + }, + }, + }, + }, + } + + suite.Run() +} + +func TestStaticTypeParserError(t *testing.T) { + suite := tester.NewParserErrorTestSuite(t) + suite.UsePHP8() + suite.Code = `createNotFoundException();` + + suite.Expected = `&ast.Root{ + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Expr: &ast.ExprAssignCoalesce{ + Var: &ast.ExprVariable{ + Name: &ast.Identifier{ + Val: []byte("$a"), + }, + }, + Expr: &ast.ExprThrow{ + Expr: &ast.ExprMethodCall{ + Var: &ast.ExprVariable{ + Name: &ast.Identifier{ + Val: []byte("$this"), + }, + }, + Method: &ast.Identifier{ + Val: []byte("createNotFoundException"), + }, + }, + }, + }, + }, + }, +},` + + suite.Run() +} + +func TestArrowFunctionPrecedenceWithOr(t *testing.T) { + suite := tester.NewParserDumpTestSuite(t) + suite.UsePHP8() + suite.Code = ` $a and $b;` + + suite.Expected = `&ast.Root{ + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Expr: &ast.ExprArrowFunction{ + Params: []ast.Vertex{ + &ast.Parameter{ + Var: &ast.ExprVariable{ + Name: &ast.Identifier{ + Val: []byte("$a"), + }, + }, + }, + &ast.Parameter{ + Var: &ast.ExprVariable{ + Name: &ast.Identifier{ + Val: []byte("$b"), + }, + }, + }, + }, + Expr: &ast.ExprBinaryLogicalAnd{ + Left: &ast.ExprVariable{ + Name: &ast.Identifier{ + Val: []byte("$a"), + }, + }, + Right: &ast.ExprVariable{ + Name: &ast.Identifier{ + Val: []byte("$b"), + }, + }, + }, + }, + }, + }, +},` + + suite.Run() +} + +func TestArrowFunctionPrecedenceWithAnd(t *testing.T) { + suite := tester.NewParserDumpTestSuite(t) + suite.UsePHP8() + suite.Code = ` $a && $b;` + + suite.Expected = `&ast.Root{ + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Expr: &ast.ExprArrowFunction{ + Params: []ast.Vertex{ + &ast.Parameter{ + Var: &ast.ExprVariable{ + Name: &ast.Identifier{ + Val: []byte("$a"), + }, + }, + }, + &ast.Parameter{ + Var: &ast.ExprVariable{ + Name: &ast.Identifier{ + Val: []byte("$b"), + }, + }, + }, + }, + Expr: &ast.ExprBinaryBooleanAnd{ + Left: &ast.ExprVariable{ + Name: &ast.Identifier{ + Val: []byte("$a"), + }, + }, + Right: &ast.ExprVariable{ + Name: &ast.Identifier{ + Val: []byte("$b"), + }, + }, + }, + }, + }, + }, +},` + + suite.Run() +} + +func TestConcatPrecedenceWithPlus(t *testing.T) { + suite := tester.NewParserDumpTestSuite(t) + suite.UsePHP8() + suite.Code = `length(); +"foo$bar"[0]; +"foo$bar"->length(); +` + + suite.Expected = `&ast.Root{ + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Expr: &ast.ExprMethodCall{ + Var: &ast.ScalarString{ + Val: []byte("\"string\""), + }, + Method: &ast.Identifier{ + Val: []byte("length"), + }, + }, + }, + &ast.StmtExpression{ + Expr: &ast.ExprArrayDimFetch{ + Var: &ast.ScalarEncapsed{ + Parts: []ast.Vertex{ + &ast.ScalarEncapsedStringPart{ + Val: []byte("foo"), + }, + &ast.ExprVariable{ + Name: &ast.Identifier{ + Val: []byte("$bar"), + }, + }, + }, + }, + Dim: &ast.ScalarLnumber{ + Val: []byte("0"), + }, + }, + }, + &ast.StmtExpression{ + Expr: &ast.ExprMethodCall{ + Var: &ast.ScalarEncapsed{ + Parts: []ast.Vertex{ + &ast.ScalarEncapsedStringPart{ + Val: []byte("foo"), + }, + &ast.ExprVariable{ + Name: &ast.Identifier{ + Val: []byte("$bar"), + }, + }, + }, + }, + Method: &ast.Identifier{ + Val: []byte("length"), + }, + }, + }, + }, +},` + + suite.Run() +} + +func TestConstantDerefencable(t *testing.T) { + suite := tester.NewParserDumpTestSuite(t) + suite.UsePHP8() + suite.Code = `length; +A->length(); +A[0]; +A[0][1][2]; + +A::B[0]; +A::B[0][1][2]; +A::B->length; +A::B->length(); +A::B::C; +A::B::$c; +A::B::c(); +` + + suite.Expected = `&ast.Root{ + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Expr: &ast.ExprPropertyFetch{ + Var: &ast.ExprConstFetch{ + Const: &ast.Name{ + Parts: []ast.Vertex{ + &ast.NamePart{ + Val: []byte("A"), + }, + }, + }, + }, + Prop: &ast.Identifier{ + Val: []byte("length"), + }, + }, + }, + &ast.StmtExpression{ + Expr: &ast.ExprMethodCall{ + Var: &ast.ExprConstFetch{ + Const: &ast.Name{ + Parts: []ast.Vertex{ + &ast.NamePart{ + Val: []byte("A"), + }, + }, + }, + }, + Method: &ast.Identifier{ + Val: []byte("length"), + }, + }, + }, + &ast.StmtExpression{ + Expr: &ast.ExprArrayDimFetch{ + Var: &ast.ExprConstFetch{ + Const: &ast.Name{ + Parts: []ast.Vertex{ + &ast.NamePart{ + Val: []byte("A"), + }, + }, + }, + }, + Dim: &ast.ScalarLnumber{ + Val: []byte("0"), + }, + }, + }, + &ast.StmtExpression{ + Expr: &ast.ExprArrayDimFetch{ + Var: &ast.ExprArrayDimFetch{ + Var: &ast.ExprArrayDimFetch{ + Var: &ast.ExprConstFetch{ + Const: &ast.Name{ + Parts: []ast.Vertex{ + &ast.NamePart{ + Val: []byte("A"), + }, + }, + }, + }, + Dim: &ast.ScalarLnumber{ + Val: []byte("0"), + }, + }, + Dim: &ast.ScalarLnumber{ + Val: []byte("1"), + }, + }, + Dim: &ast.ScalarLnumber{ + Val: []byte("2"), + }, + }, + }, + &ast.StmtExpression{ + Expr: &ast.ExprArrayDimFetch{ + Var: &ast.ExprClassConstFetch{ + Class: &ast.Name{ + Parts: []ast.Vertex{ + &ast.NamePart{ + Val: []byte("A"), + }, + }, + }, + Const: &ast.Identifier{ + Val: []byte("B"), + }, + }, + Dim: &ast.ScalarLnumber{ + Val: []byte("0"), + }, + }, + }, + &ast.StmtExpression{ + Expr: &ast.ExprArrayDimFetch{ + Var: &ast.ExprArrayDimFetch{ + Var: &ast.ExprArrayDimFetch{ + Var: &ast.ExprClassConstFetch{ + Class: &ast.Name{ + Parts: []ast.Vertex{ + &ast.NamePart{ + Val: []byte("A"), + }, + }, + }, + Const: &ast.Identifier{ + Val: []byte("B"), + }, + }, + Dim: &ast.ScalarLnumber{ + Val: []byte("0"), + }, + }, + Dim: &ast.ScalarLnumber{ + Val: []byte("1"), + }, + }, + Dim: &ast.ScalarLnumber{ + Val: []byte("2"), + }, + }, + }, + &ast.StmtExpression{ + Expr: &ast.ExprPropertyFetch{ + Var: &ast.ExprClassConstFetch{ + Class: &ast.Name{ + Parts: []ast.Vertex{ + &ast.NamePart{ + Val: []byte("A"), + }, + }, + }, + Const: &ast.Identifier{ + Val: []byte("B"), + }, + }, + Prop: &ast.Identifier{ + Val: []byte("length"), + }, + }, + }, + &ast.StmtExpression{ + Expr: &ast.ExprMethodCall{ + Var: &ast.ExprClassConstFetch{ + Class: &ast.Name{ + Parts: []ast.Vertex{ + &ast.NamePart{ + Val: []byte("A"), + }, + }, + }, + Const: &ast.Identifier{ + Val: []byte("B"), + }, + }, + Method: &ast.Identifier{ + Val: []byte("length"), + }, + }, + }, + &ast.StmtExpression{ + Expr: &ast.ExprClassConstFetch{ + Class: &ast.ExprClassConstFetch{ + Class: &ast.Name{ + Parts: []ast.Vertex{ + &ast.NamePart{ + Val: []byte("A"), + }, + }, + }, + Const: &ast.Identifier{ + Val: []byte("B"), + }, + }, + Const: &ast.Identifier{ + Val: []byte("C"), + }, + }, + }, + &ast.StmtExpression{ + Expr: &ast.ExprStaticPropertyFetch{ + Class: &ast.ExprClassConstFetch{ + Class: &ast.Name{ + Parts: []ast.Vertex{ + &ast.NamePart{ + Val: []byte("A"), + }, + }, + }, + Const: &ast.Identifier{ + Val: []byte("B"), + }, + }, + Prop: &ast.ExprVariable{ + Name: &ast.Identifier{ + Val: []byte("$c"), + }, + }, + }, + }, + &ast.StmtExpression{ + Expr: &ast.ExprStaticCall{ + Class: &ast.ExprClassConstFetch{ + Class: &ast.Name{ + Parts: []ast.Vertex{ + &ast.NamePart{ + Val: []byte("A"), + }, + }, + }, + Const: &ast.Identifier{ + Val: []byte("B"), + }, + }, + Call: &ast.Identifier{ + Val: []byte("c"), + }, + }, + }, + }, +},` + + suite.Run() +} diff --git a/internal/php8/parser_test.go b/internal/php8/parser_test.go new file mode 100644 index 0000000..a4a50c7 --- /dev/null +++ b/internal/php8/parser_test.go @@ -0,0 +1,56137 @@ +package php8_test + +import ( + "testing" + + "github.com/z7zmey/php-parser/internal/php8" + "gotest.tools/assert" + + "github.com/z7zmey/php-parser/pkg/ast" + "github.com/z7zmey/php-parser/pkg/conf" + "github.com/z7zmey/php-parser/pkg/errors" + "github.com/z7zmey/php-parser/pkg/position" + "github.com/z7zmey/php-parser/pkg/token" + "github.com/z7zmey/php-parser/pkg/version" +) + +func TestIdentifier(t *testing.T) { + src := `bar($a, ...$b); + foo::bar($a, ...$b); + $foo::bar($a, ...$b); + new foo($a, ...$b); + /** anonymous class */ + new class ($a, ...$b) {};` + + expected := &ast.Root{ + Position: &position.Position{ + StartLine: 2, + EndLine: 9, + StartPos: 5, + EndPos: 185, + }, + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 2, + EndLine: 2, + StartPos: 5, + EndPos: 20, + }, + Expr: &ast.ExprFunctionCall{ + Position: &position.Position{ + StartLine: 2, + EndLine: 2, + StartPos: 5, + EndPos: 19, + }, + Function: &ast.Name{ + Position: &position.Position{ + StartLine: 2, + EndLine: 2, + StartPos: 5, + EndPos: 8, + }, + Parts: []ast.Vertex{ + &ast.NamePart{ + Position: &position.Position{ + StartLine: 2, + EndLine: 2, + StartPos: 5, + EndPos: 8, + }, + StringTkn: &token.Token{ + ID: token.T_STRING, + Value: []byte("foo"), + Position: &position.Position{ + StartLine: 2, + EndLine: 2, + StartPos: 5, + EndPos: 8, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 46, + EndPos: 48, + }, + }, + Method: &ast.Identifier{ + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 48, + EndPos: 51, + }, + IdentifierTkn: &token.Token{ + ID: token.T_STRING, + Value: []byte("bar"), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 48, + EndPos: 51, + }, + }, + Value: []byte("bar"), + }, + OpenParenthesisTkn: &token.Token{ + ID: token.ID(40), + Value: []byte("("), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 51, + EndPos: 52, + }, + }, + Args: []ast.Vertex{ + &ast.Argument{ + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 52, + EndPos: 54, + }, + Expr: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 52, + EndPos: 54, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 52, + EndPos: 54, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 52, + EndPos: 54, + }, + }, + Value: []byte("$a"), + }, + }, + }, + &ast.Argument{ + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 56, + EndPos: 61, + }, + VariadicTkn: &token.Token{ + ID: token.T_ELLIPSIS, + Value: []byte("..."), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 56, + EndPos: 59, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 55, + EndPos: 56, + }, + }, + }, + }, + Expr: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 59, + EndPos: 61, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 59, + EndPos: 61, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 59, + EndPos: 61, + }, + }, + Value: []byte("$b"), + }, + }, + }, + }, + SeparatorTkns: []*token.Token{ + { + ID: token.ID(44), + Value: []byte(","), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 54, + EndPos: 55, + }, + }, + }, + CloseParenthesisTkn: &token.Token{ + ID: token.ID(41), + Value: []byte(")"), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 61, + EndPos: 62, + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 4, + EndLine: 4, + StartPos: 62, + EndPos: 63, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 66, + EndPos: 86, + }, + Expr: &ast.ExprStaticCall{ + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 66, + EndPos: 85, + }, + Class: &ast.Name{ + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 66, + EndPos: 69, + }, + Parts: []ast.Vertex{ + &ast.NamePart{ + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 66, + EndPos: 69, + }, + StringTkn: &token.Token{ + ID: token.T_STRING, + Value: []byte("foo"), + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 66, + EndPos: 69, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 4, + EndLine: 5, + StartPos: 63, + EndPos: 66, + }, + }, + }, + }, + Value: []byte("foo"), + }, + }, + }, + DoubleColonTkn: &token.Token{ + ID: token.T_PAAMAYIM_NEKUDOTAYIM, + Value: []byte("::"), + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 69, + EndPos: 71, + }, + }, + Call: &ast.Identifier{ + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 71, + EndPos: 74, + }, + IdentifierTkn: &token.Token{ + ID: token.T_STRING, + Value: []byte("bar"), + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 71, + EndPos: 74, + }, + }, + Value: []byte("bar"), + }, + OpenParenthesisTkn: &token.Token{ + ID: token.ID(40), + Value: []byte("("), + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 74, + EndPos: 75, + }, + }, + Args: []ast.Vertex{ + &ast.Argument{ + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 75, + EndPos: 77, + }, + Expr: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 75, + EndPos: 77, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 75, + EndPos: 77, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 75, + EndPos: 77, + }, + }, + Value: []byte("$a"), + }, + }, + }, + &ast.Argument{ + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 79, + EndPos: 84, + }, + VariadicTkn: &token.Token{ + ID: token.T_ELLIPSIS, + Value: []byte("..."), + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 79, + EndPos: 82, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 78, + EndPos: 79, + }, + }, + }, + }, + Expr: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 82, + EndPos: 84, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 82, + EndPos: 84, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 82, + EndPos: 84, + }, + }, + Value: []byte("$b"), + }, + }, + }, + }, + SeparatorTkns: []*token.Token{ + { + ID: token.ID(44), + Value: []byte(","), + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 77, + EndPos: 78, + }, + }, + }, + CloseParenthesisTkn: &token.Token{ + ID: token.ID(41), + Value: []byte(")"), + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 84, + EndPos: 85, + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 5, + EndLine: 5, + StartPos: 85, + EndPos: 86, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 89, + EndPos: 110, + }, + Expr: &ast.ExprStaticCall{ + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 89, + EndPos: 109, + }, + Class: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 89, + EndPos: 93, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 89, + EndPos: 93, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$foo"), + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 89, + EndPos: 93, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 5, + EndLine: 6, + StartPos: 86, + EndPos: 89, + }, + }, + }, + }, + Value: []byte("$foo"), + }, + }, + DoubleColonTkn: &token.Token{ + ID: token.T_PAAMAYIM_NEKUDOTAYIM, + Value: []byte("::"), + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 93, + EndPos: 95, + }, + }, + Call: &ast.Identifier{ + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 95, + EndPos: 98, + }, + IdentifierTkn: &token.Token{ + ID: token.T_STRING, + Value: []byte("bar"), + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 95, + EndPos: 98, + }, + }, + Value: []byte("bar"), + }, + OpenParenthesisTkn: &token.Token{ + ID: token.ID(40), + Value: []byte("("), + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 98, + EndPos: 99, + }, + }, + Args: []ast.Vertex{ + &ast.Argument{ + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 99, + EndPos: 101, + }, + Expr: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 99, + EndPos: 101, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 99, + EndPos: 101, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 99, + EndPos: 101, + }, + }, + Value: []byte("$a"), + }, + }, + }, + &ast.Argument{ + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 103, + EndPos: 108, + }, + VariadicTkn: &token.Token{ + ID: token.T_ELLIPSIS, + Value: []byte("..."), + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 103, + EndPos: 106, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 102, + EndPos: 103, + }, + }, + }, + }, + Expr: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 106, + EndPos: 108, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 106, + EndPos: 108, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 106, + EndPos: 108, + }, + }, + Value: []byte("$b"), + }, + }, + }, + }, + SeparatorTkns: []*token.Token{ + { + ID: token.ID(44), + Value: []byte(","), + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 101, + EndPos: 102, + }, + }, + }, + CloseParenthesisTkn: &token.Token{ + ID: token.ID(41), + Value: []byte(")"), + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 108, + EndPos: 109, + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 6, + EndLine: 6, + StartPos: 109, + EndPos: 110, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 7, + EndLine: 7, + StartPos: 113, + EndPos: 132, + }, + Expr: &ast.ExprNew{ + Position: &position.Position{ + StartLine: 7, + EndLine: 7, + StartPos: 113, + EndPos: 131, + }, + NewTkn: &token.Token{ + ID: token.T_NEW, + Value: []byte("new"), + Position: &position.Position{ + StartLine: 7, + EndLine: 7, + StartPos: 113, + EndPos: 116, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 6, + EndLine: 7, + StartPos: 110, + EndPos: 113, + }, + }, + }, + }, + Class: &ast.Name{ + Position: &position.Position{ + StartLine: 7, + EndLine: 7, + StartPos: 117, + EndPos: 120, + }, + Parts: []ast.Vertex{ + &ast.NamePart{ + Position: &position.Position{ + StartLine: 7, + EndLine: 7, + StartPos: 117, + EndPos: 120, + }, + StringTkn: &token.Token{ + ID: token.T_STRING, + Value: []byte("foo"), + Position: &position.Position{ + StartLine: 7, + EndLine: 7, + StartPos: 117, + EndPos: 120, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 7, + EndLine: 7, + StartPos: 116, + EndPos: 117, + }, + }, + }, + }, + Value: []byte("foo"), + }, + }, + }, + OpenParenthesisTkn: &token.Token{ + ID: token.ID(40), + Value: []byte("("), + Position: &position.Position{ + StartLine: 7, + EndLine: 7, + StartPos: 120, + EndPos: 121, + }, + }, + Args: []ast.Vertex{ + &ast.Argument{ + Position: &position.Position{ + StartLine: 7, + EndLine: 7, + StartPos: 121, + EndPos: 123, + }, + Expr: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 7, + EndLine: 7, + StartPos: 121, + EndPos: 123, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 7, + EndLine: 7, + StartPos: 121, + EndPos: 123, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 7, + EndLine: 7, + StartPos: 121, + EndPos: 123, + }, + }, + Value: []byte("$a"), + }, + }, + }, + &ast.Argument{ + Position: &position.Position{ + StartLine: 7, + EndLine: 7, + StartPos: 125, + EndPos: 130, + }, + VariadicTkn: &token.Token{ + ID: token.T_ELLIPSIS, + Value: []byte("..."), + Position: &position.Position{ + StartLine: 7, + EndLine: 7, + StartPos: 125, + EndPos: 128, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 7, + EndLine: 7, + StartPos: 124, + EndPos: 125, + }, + }, + }, + }, + Expr: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 7, + EndLine: 7, + StartPos: 128, + EndPos: 130, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 7, + EndLine: 7, + StartPos: 128, + EndPos: 130, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 7, + EndLine: 7, + StartPos: 128, + EndPos: 130, + }, + }, + Value: []byte("$b"), + }, + }, + }, + }, + SeparatorTkns: []*token.Token{ + { + ID: token.ID(44), + Value: []byte(","), + Position: &position.Position{ + StartLine: 7, + EndLine: 7, + StartPos: 123, + EndPos: 124, + }, + }, + }, + CloseParenthesisTkn: &token.Token{ + ID: token.ID(41), + Value: []byte(")"), + Position: &position.Position{ + StartLine: 7, + EndLine: 7, + StartPos: 130, + EndPos: 131, + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 7, + EndLine: 7, + StartPos: 131, + EndPos: 132, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 160, + EndPos: 185, + }, + Expr: &ast.ExprNew{ + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 160, + EndPos: 184, + }, + NewTkn: &token.Token{ + ID: token.T_NEW, + Value: []byte("new"), + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 160, + EndPos: 163, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 7, + EndLine: 8, + StartPos: 132, + EndPos: 135, + }, + }, + { + ID: token.T_DOC_COMMENT, + Value: []byte("/** anonymous class */"), + Position: &position.Position{ + StartLine: 8, + EndLine: 8, + StartPos: 135, + EndPos: 157, + }, + }, + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 8, + EndLine: 9, + StartPos: 157, + EndPos: 160, + }, + }, + }, + }, + Class: &ast.StmtClass{ + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 164, + EndPos: 184, + }, + ClassTkn: &token.Token{ + ID: token.T_CLASS, + Value: []byte("class"), + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 164, + EndPos: 169, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 163, + EndPos: 164, + }, + }, + }, + }, + OpenParenthesisTkn: &token.Token{ + ID: token.ID(40), + Value: []byte("("), + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 170, + EndPos: 171, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 169, + EndPos: 170, + }, + }, + }, + }, + Args: []ast.Vertex{ + &ast.Argument{ + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 171, + EndPos: 173, + }, + Expr: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 171, + EndPos: 173, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 171, + EndPos: 173, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 171, + EndPos: 173, + }, + }, + Value: []byte("$a"), + }, + }, + }, + &ast.Argument{ + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 175, + EndPos: 180, + }, + VariadicTkn: &token.Token{ + ID: token.T_ELLIPSIS, + Value: []byte("..."), + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 175, + EndPos: 178, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 174, + EndPos: 175, + }, + }, + }, + }, + Expr: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 178, + EndPos: 180, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 178, + EndPos: 180, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 178, + EndPos: 180, + }, + }, + Value: []byte("$b"), + }, + }, + }, + }, + SeparatorTkns: []*token.Token{ + { + ID: token.ID(44), + Value: []byte(","), + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 173, + EndPos: 174, + }, + }, + }, + CloseParenthesisTkn: &token.Token{ + ID: token.ID(41), + Value: []byte(")"), + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 180, + EndPos: 181, + }, + }, + OpenCurlyBracketTkn: &token.Token{ + ID: token.ID(123), + Value: []byte("{"), + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 182, + EndPos: 183, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 181, + EndPos: 182, + }, + }, + }, + }, + Stmts: []ast.Vertex{}, + CloseCurlyBracketTkn: &token.Token{ + ID: token.ID(125), + Value: []byte("}"), + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 183, + EndPos: 184, + }, + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 9, + EndLine: 9, + StartPos: 184, + EndPos: 185, + }, + }, + }, + }, + EndTkn: &token.Token{}, + } + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := php8.NewLexer([]byte(src), config) + php8parser := php8.NewParser(lexer, config) + php8parser.Parse() + actual := php8parser.GetRootNode() + assert.DeepEqual(t, expected, actual) +} + +func TestPhp8ParameterNode(t *testing.T) { + src := `bar()";` + + expected := &ast.Root{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 22, + }, + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 22, + }, + Expr: &ast.ScalarEncapsed{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 21, + }, + OpenQuoteTkn: &token.Token{ + ID: token.ID(34), + Value: []byte("\""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 4, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 13, + EndPos: 15, + }, + }, + Prop: &ast.Identifier{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 15, + EndPos: 18, + }, + IdentifierTkn: &token.Token{ + ID: token.T_STRING, + Value: []byte("bar"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 15, + EndPos: 18, + }, + }, + Value: []byte("bar"), + }, + }, + &ast.ScalarEncapsedStringPart{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 18, + EndPos: 20, + }, + EncapsedStrTkn: &token.Token{ + ID: token.T_ENCAPSED_AND_WHITESPACE, + Value: []byte("()"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 18, + EndPos: 20, + }, + }, + Value: []byte("()"), + }, + }, + CloseQuoteTkn: &token.Token{ + ID: token.ID(34), + Value: []byte("\""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 20, + EndPos: 21, + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 21, + EndPos: 22, + }, + }, + }, + }, + EndTkn: &token.Token{}, + } + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := php8.NewLexer([]byte(src), config) + php8parser := php8.NewParser(lexer, config) + php8parser.Parse() + actual := php8parser.GetRootNode() + assert.DeepEqual(t, expected, actual) +} + +func TestScalarEncapsed_DollarOpenCurlyBraces(t *testing.T) { + src := `bar()}";` + + expected := &ast.Root{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 24, + }, + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 24, + }, + Expr: &ast.ScalarEncapsed{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 23, + }, + OpenQuoteTkn: &token.Token{ + ID: token.ID(34), + Value: []byte("\""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 4, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 14, + EndPos: 16, + }, + }, + Method: &ast.Identifier{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 16, + EndPos: 19, + }, + IdentifierTkn: &token.Token{ + ID: token.T_STRING, + Value: []byte("bar"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 16, + EndPos: 19, + }, + }, + Value: []byte("bar"), + }, + OpenParenthesisTkn: &token.Token{ + ID: token.ID(40), + Value: []byte("("), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 19, + EndPos: 20, + }, + }, + CloseParenthesisTkn: &token.Token{ + ID: token.ID(41), + Value: []byte(")"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 20, + EndPos: 21, + }, + }, + }, + CloseCurlyBracketTkn: &token.Token{ + ID: token.ID(125), + Value: []byte("}"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 21, + EndPos: 22, + }, + }, + }, + }, + CloseQuoteTkn: &token.Token{ + ID: token.ID(34), + Value: []byte("\""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 22, + EndPos: 23, + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 23, + EndPos: 24, + }, + }, + }, + }, + EndTkn: &token.Token{}, + } + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := php8.NewLexer([]byte(src), config) + php8parser := php8.NewParser(lexer, config) + php8parser.Parse() + actual := php8parser.GetRootNode() + assert.DeepEqual(t, expected, actual) +} + +func TestScalarHeredoc_HeredocSimpleLabel(t *testing.T) { + src := ` $v) {}` + + expected := &ast.Root{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 30, + }, + Stmts: []ast.Vertex{ + &ast.StmtForeach{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 30, + }, + ForeachTkn: &token.Token{ + ID: token.T_FOREACH, + Value: []byte("foreach"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 10, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 21, + EndPos: 23, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 20, + EndPos: 21, + }, + }, + }, + }, + Var: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 24, + EndPos: 26, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 24, + EndPos: 26, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$v"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 24, + EndPos: 26, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 23, + EndPos: 24, + }, + }, + }, + }, + Value: []byte("$v"), + }, + }, + CloseParenthesisTkn: &token.Token{ + ID: token.ID(41), + Value: []byte(")"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 26, + EndPos: 27, + }, + }, + Stmt: &ast.StmtStmtList{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 28, + EndPos: 30, + }, + OpenCurlyBracketTkn: &token.Token{ + ID: token.ID(123), + Value: []byte("{"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 28, + EndPos: 29, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 27, + EndPos: 28, + }, + }, + }, + }, + Stmts: []ast.Vertex{}, + CloseCurlyBracketTkn: &token.Token{ + ID: token.ID(125), + Value: []byte("}"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 29, + EndPos: 30, + }, + }, + }, + }, + }, + EndTkn: &token.Token{}, + } + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := php8.NewLexer([]byte(src), config) + php8parser := php8.NewParser(lexer, config) + php8parser.Parse() + actual := php8parser.GetRootNode() + assert.DeepEqual(t, expected, actual) +} + +func TestStmtForeach_ExprWithKey(t *testing.T) { + src := ` $v) {}` + + expected := &ast.Root{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 30, + }, + Stmts: []ast.Vertex{ + &ast.StmtForeach{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 30, + }, + ForeachTkn: &token.Token{ + ID: token.T_FOREACH, + Value: []byte("foreach"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 10, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 21, + EndPos: 23, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 20, + EndPos: 21, + }, + }, + }, + }, + Var: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 24, + EndPos: 26, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 24, + EndPos: 26, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$v"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 24, + EndPos: 26, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 23, + EndPos: 24, + }, + }, + }, + }, + Value: []byte("$v"), + }, + }, + CloseParenthesisTkn: &token.Token{ + ID: token.ID(41), + Value: []byte(")"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 26, + EndPos: 27, + }, + }, + Stmt: &ast.StmtStmtList{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 28, + EndPos: 30, + }, + OpenCurlyBracketTkn: &token.Token{ + ID: token.ID(123), + Value: []byte("{"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 28, + EndPos: 29, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 27, + EndPos: 28, + }, + }, + }, + }, + Stmts: []ast.Vertex{}, + CloseCurlyBracketTkn: &token.Token{ + ID: token.ID(125), + Value: []byte("}"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 29, + EndPos: 30, + }, + }, + }, + }, + }, + EndTkn: &token.Token{}, + } + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := php8.NewLexer([]byte(src), config) + php8parser := php8.NewParser(lexer, config) + php8parser.Parse() + actual := php8parser.GetRootNode() + assert.DeepEqual(t, expected, actual) +} + +func TestStmtForeach_WithRef(t *testing.T) { + src := ` &$v) {}` + + expected := &ast.Root{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 31, + }, + Stmts: []ast.Vertex{ + &ast.StmtForeach{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 31, + }, + ForeachTkn: &token.Token{ + ID: token.T_FOREACH, + Value: []byte("foreach"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 10, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 21, + EndPos: 23, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 20, + EndPos: 21, + }, + }, + }, + }, + AmpersandTkn: &token.Token{ + ID: token.ID(38), + Value: []byte("&"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 24, + EndPos: 25, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 23, + EndPos: 24, + }, + }, + }, + }, + Var: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 25, + EndPos: 27, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 25, + EndPos: 27, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$v"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 25, + EndPos: 27, + }, + }, + Value: []byte("$v"), + }, + }, + CloseParenthesisTkn: &token.Token{ + ID: token.ID(41), + Value: []byte(")"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 27, + EndPos: 28, + }, + }, + Stmt: &ast.StmtStmtList{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 29, + EndPos: 31, + }, + OpenCurlyBracketTkn: &token.Token{ + ID: token.ID(123), + Value: []byte("{"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 29, + EndPos: 30, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 28, + EndPos: 29, + }, + }, + }, + }, + Stmts: []ast.Vertex{}, + CloseCurlyBracketTkn: &token.Token{ + ID: token.ID(125), + Value: []byte("}"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 30, + EndPos: 31, + }, + }, + }, + }, + }, + EndTkn: &token.Token{}, + } + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := php8.NewLexer([]byte(src), config) + php8parser := php8.NewParser(lexer, config) + php8parser.Parse() + actual := php8parser.GetRootNode() + assert.DeepEqual(t, expected, actual) +} + +func TestStmtForeach_WithList(t *testing.T) { + src := ` list($v)) {}` + + expected := &ast.Root{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 36, + }, + Stmts: []ast.Vertex{ + &ast.StmtForeach{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 36, + }, + ForeachTkn: &token.Token{ + ID: token.T_FOREACH, + Value: []byte("foreach"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 10, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 21, + EndPos: 23, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 20, + EndPos: 21, + }, + }, + }, + }, + Var: &ast.ExprList{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 24, + EndPos: 32, + }, + ListTkn: &token.Token{ + ID: token.T_LIST, + Value: []byte("list"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 24, + EndPos: 28, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 23, + EndPos: 24, + }, + }, + }, + }, + OpenBracketTkn: &token.Token{ + ID: token.ID(40), + Value: []byte("("), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 28, + EndPos: 29, + }, + }, + Items: []ast.Vertex{ + &ast.ExprArrayItem{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 29, + EndPos: 31, + }, + Val: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 29, + EndPos: 31, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 29, + EndPos: 31, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$v"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 29, + EndPos: 31, + }, + }, + Value: []byte("$v"), + }, + }, + }, + }, + CloseBracketTkn: &token.Token{ + ID: token.ID(41), + Value: []byte(")"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 31, + EndPos: 32, + }, + }, + }, + CloseParenthesisTkn: &token.Token{ + ID: token.ID(41), + Value: []byte(")"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 32, + EndPos: 33, + }, + }, + Stmt: &ast.StmtStmtList{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 34, + EndPos: 36, + }, + OpenCurlyBracketTkn: &token.Token{ + ID: token.ID(123), + Value: []byte("{"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 34, + EndPos: 35, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 33, + EndPos: 34, + }, + }, + }, + }, + Stmts: []ast.Vertex{}, + CloseCurlyBracketTkn: &token.Token{ + ID: token.ID(125), + Value: []byte("}"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 35, + EndPos: 36, + }, + }, + }, + }, + }, + EndTkn: &token.Token{}, + } + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := php8.NewLexer([]byte(src), config) + php8parser := php8.NewParser(lexer, config) + php8parser.Parse() + actual := php8parser.GetRootNode() + assert.DeepEqual(t, expected, actual) +} + +func TestStmtFunction(t *testing.T) { + src := `
` + + expected := &ast.Root{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 17, + }, + Stmts: []ast.Vertex{ + &ast.StmtNop{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 5, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte("?>"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 5, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 5, + EndPos: 17, + }, + }, + Value: []byte("
"), + }, + }, + EndTkn: &token.Token{}, + } + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := php8.NewLexer([]byte(src), config) + php8parser := php8.NewParser(lexer, config) + php8parser.Parse() + actual := php8parser.GetRootNode() + assert.DeepEqual(t, expected, actual) +} + +func TestStmtInterface(t *testing.T) { + src := `1, &$b,);` + + expected := &ast.Root{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 21, + }, + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 21, + }, + Expr: &ast.ExprArray{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 20, + }, + ArrayTkn: &token.Token{ + ID: token.T_ARRAY, + Value: []byte("array"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 8, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 10, + EndPos: 12, + }, + }, + Val: &ast.ScalarLnumber{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 12, + EndPos: 13, + }, + NumberTkn: &token.Token{ + ID: token.T_LNUMBER, + Value: []byte("1"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 12, + EndPos: 13, + }, + }, + Value: []byte("1"), + }, + }, + &ast.ExprArrayItem{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 15, + EndPos: 18, + }, + AmpersandTkn: &token.Token{ + ID: token.ID(38), + Value: []byte("&"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 15, + EndPos: 16, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 14, + EndPos: 15, + }, + }, + }, + }, + Val: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 16, + EndPos: 18, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 16, + EndPos: 18, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 16, + EndPos: 18, + }, + }, + Value: []byte("$b"), + }, + }, + }, + &ast.ExprArrayItem{}, + }, + SeparatorTkns: []*token.Token{ + { + ID: token.ID(44), + Value: []byte(","), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 13, + EndPos: 14, + }, + }, + { + ID: token.ID(44), + Value: []byte(","), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 18, + EndPos: 19, + }, + }, + }, + CloseBracketTkn: &token.Token{ + ID: token.ID(41), + Value: []byte(")"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 19, + EndPos: 20, + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 20, + EndPos: 21, + }, + }, + }, + }, + EndTkn: &token.Token{}, + } + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := php8.NewLexer([]byte(src), config) + php8parser := php8.NewParser(lexer, config) + php8parser.Parse() + actual := php8parser.GetRootNode() + assert.DeepEqual(t, expected, actual) +} + +func TestExprArray_ItemUnpack(t *testing.T) { + src := ` $a;` + + expected := &ast.Root{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 14, + }, + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 14, + }, + Expr: &ast.ExprArrowFunction{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 13, + }, + FnTkn: &token.Token{ + ID: token.T_FN, + Value: []byte("fn"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 5, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 8, + EndPos: 10, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 7, + EndPos: 8, + }, + }, + }, + }, + Expr: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 11, + EndPos: 13, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 11, + EndPos: 13, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 11, + EndPos: 13, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 10, + EndPos: 11, + }, + }, + }, + }, + Value: []byte("$a"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 13, + EndPos: 14, + }, + }, + }, + }, + EndTkn: &token.Token{}, + } + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := php8.NewLexer([]byte(src), config) + php8parser := php8.NewParser(lexer, config) + php8parser.Parse() + actual := php8parser.GetRootNode() + assert.DeepEqual(t, expected, actual) +} + +func TestExprArrowFunction_ReturnType(t *testing.T) { + src := ` $a;` + + expected := &ast.Root{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 23, + }, + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 23, + }, + Expr: &ast.ExprArrowFunction{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 22, + }, + FnTkn: &token.Token{ + ID: token.T_FN, + Value: []byte("fn"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 5, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 17, + EndPos: 19, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 16, + EndPos: 17, + }, + }, + }, + }, + Expr: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 20, + EndPos: 22, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 20, + EndPos: 22, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 20, + EndPos: 22, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 19, + EndPos: 20, + }, + }, + }, + }, + Value: []byte("$a"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 22, + EndPos: 23, + }, + }, + }, + }, + EndTkn: &token.Token{}, + } + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := php8.NewLexer([]byte(src), config) + php8parser := php8.NewParser(lexer, config) + php8parser.Parse() + actual := php8parser.GetRootNode() + assert.DeepEqual(t, expected, actual) +} + +func TestExprBitwiseNot(t *testing.T) { + src := `foo();` + + expected := &ast.Root{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 13, + }, + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 13, + }, + Expr: &ast.ExprMethodCall{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 12, + }, + Var: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 5, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 5, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 5, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 5, + EndPos: 7, + }, + }, + Method: &ast.Identifier{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 7, + EndPos: 10, + }, + IdentifierTkn: &token.Token{ + ID: token.T_STRING, + Value: []byte("foo"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 7, + EndPos: 10, + }, + }, + Value: []byte("foo"), + }, + OpenParenthesisTkn: &token.Token{ + ID: token.ID(40), + Value: []byte("("), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 10, + EndPos: 11, + }, + }, + CloseParenthesisTkn: &token.Token{ + ID: token.ID(41), + Value: []byte(")"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 11, + EndPos: 12, + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 12, + EndPos: 13, + }, + }, + }, + }, + EndTkn: &token.Token{}, + } + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := php8.NewLexer([]byte(src), config) + php8parser := php8.NewParser(lexer, config) + php8parser.Parse() + actual := php8parser.GetRootNode() + assert.DeepEqual(t, expected, actual) +} + +func TestExprNew(t *testing.T) { + src := `foo;` + + expected := &ast.Root{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 11, + }, + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 11, + }, + Expr: &ast.ExprPropertyFetch{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 10, + }, + Var: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 5, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 5, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 5, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 5, + EndPos: 7, + }, + }, + Prop: &ast.Identifier{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 7, + EndPos: 10, + }, + IdentifierTkn: &token.Token{ + ID: token.T_STRING, + Value: []byte("foo"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 7, + EndPos: 10, + }, + }, + Value: []byte("foo"), + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 10, + EndPos: 11, + }, + }, + }, + }, + EndTkn: &token.Token{}, + } + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := php8.NewLexer([]byte(src), config) + php8parser := php8.NewParser(lexer, config) + php8parser.Parse() + actual := php8parser.GetRootNode() + assert.DeepEqual(t, expected, actual) +} + +func TestExprShellExec(t *testing.T) { + src := "1, &$b,];` + + expected := &ast.Root{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 16, + }, + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 16, + }, + Expr: &ast.ExprArray{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 15, + }, + OpenBracketTkn: &token.Token{ + ID: token.ID(91), + Value: []byte("["), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 4, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 5, + EndPos: 7, + }, + }, + Val: &ast.ScalarLnumber{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 7, + EndPos: 8, + }, + NumberTkn: &token.Token{ + ID: token.T_LNUMBER, + Value: []byte("1"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 7, + EndPos: 8, + }, + }, + Value: []byte("1"), + }, + }, + &ast.ExprArrayItem{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 10, + EndPos: 13, + }, + AmpersandTkn: &token.Token{ + ID: token.ID(38), + Value: []byte("&"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 10, + EndPos: 11, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 9, + EndPos: 10, + }, + }, + }, + }, + Val: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 11, + EndPos: 13, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 11, + EndPos: 13, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 11, + EndPos: 13, + }, + }, + Value: []byte("$b"), + }, + }, + }, + &ast.ExprArrayItem{}, + }, + SeparatorTkns: []*token.Token{ + { + ID: token.ID(44), + Value: []byte(","), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 8, + EndPos: 9, + }, + }, + { + ID: token.ID(44), + Value: []byte(","), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 13, + EndPos: 14, + }, + }, + }, + CloseBracketTkn: &token.Token{ + ID: token.ID(93), + Value: []byte("]"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 14, + EndPos: 15, + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 15, + EndPos: 16, + }, + }, + }, + }, + EndTkn: &token.Token{}, + } + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := php8.NewLexer([]byte(src), config) + php8parser := php8.NewParser(lexer, config) + php8parser.Parse() + actual := php8parser.GetRootNode() + assert.DeepEqual(t, expected, actual) +} + +func TestExprShortList(t *testing.T) { + src := ` $b;` + + expected := &ast.Root{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 18, + }, + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 18, + }, + Expr: &ast.ExprYield{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 17, + }, + YieldTkn: &token.Token{ + ID: token.T_YIELD, + Value: []byte("yield"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 8, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 12, + EndPos: 14, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 11, + EndPos: 12, + }, + }, + }, + }, + Val: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 15, + EndPos: 17, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 15, + EndPos: 17, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 15, + EndPos: 17, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 14, + EndPos: 15, + }, + }, + }, + }, + Value: []byte("$b"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 17, + EndPos: 18, + }, + }, + }, + }, + EndTkn: &token.Token{}, + } + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := php8.NewLexer([]byte(src), config) + php8parser := php8.NewParser(lexer, config) + php8parser.Parse() + actual := php8parser.GetRootNode() + assert.DeepEqual(t, expected, actual) +} + +func TestExprYield_Expr(t *testing.T) { + src := ` 1;` + + expected := &ast.Root{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 17, + }, + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 17, + }, + Expr: &ast.ExprYield{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 16, + }, + YieldTkn: &token.Token{ + ID: token.T_YIELD, + Value: []byte("yield"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 3, + EndPos: 8, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(""), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 12, + EndPos: 14, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 11, + EndPos: 12, + }, + }, + }, + }, + Val: &ast.ScalarLnumber{ + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 15, + EndPos: 16, + }, + NumberTkn: &token.Token{ + ID: token.T_LNUMBER, + Value: []byte("1"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 15, + EndPos: 16, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 14, + EndPos: 15, + }, + }, + }, + }, + Value: []byte("1"), + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 1, + EndLine: 1, + StartPos: 16, + EndPos: 17, + }, + }, + }, + }, + EndTkn: &token.Token{}, + } + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := php8.NewLexer([]byte(src), config) + php8parser := php8.NewParser(lexer, config) + php8parser.Parse() + actual := php8parser.GetRootNode() + assert.DeepEqual(t, expected, actual) +} + +func TestExprYieldFrom(t *testing.T) { + src := `>= $b; + $a ??= $b;` + + expected := &ast.Root{ + Position: &position.Position{ + StartLine: 2, + EndLine: 18, + StartPos: 5, + EndPos: 223, + }, + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 2, + EndLine: 2, + StartPos: 5, + EndPos: 13, + }, + Expr: &ast.ExprAssign{ + Position: &position.Position{ + StartLine: 2, + EndLine: 2, + StartPos: 5, + EndPos: 12, + }, + Var: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 2, + EndLine: 2, + StartPos: 5, + EndPos: 7, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 2, + EndLine: 2, + StartPos: 5, + EndPos: 7, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 2, + EndLine: 2, + StartPos: 5, + EndPos: 7, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(">="), + Position: &position.Position{ + StartLine: 17, + EndLine: 17, + StartPos: 203, + EndPos: 206, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 17, + EndLine: 17, + StartPos: 202, + EndPos: 203, + }, + }, + }, + }, + Expr: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 17, + EndLine: 17, + StartPos: 207, + EndPos: 209, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 17, + EndLine: 17, + StartPos: 207, + EndPos: 209, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 17, + EndLine: 17, + StartPos: 207, + EndPos: 209, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 17, + EndLine: 17, + StartPos: 206, + EndPos: 207, + }, + }, + }, + }, + Value: []byte("$b"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 17, + EndLine: 17, + StartPos: 209, + EndPos: 210, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 213, + EndPos: 223, + }, + Expr: &ast.ExprAssignCoalesce{ + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 213, + EndPos: 222, + }, + Var: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 213, + EndPos: 215, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 213, + EndPos: 215, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 213, + EndPos: 215, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 17, + EndLine: 18, + StartPos: 210, + EndPos: 213, + }, + }, + }, + }, + Value: []byte("$a"), + }, + }, + EqualTkn: &token.Token{ + ID: token.T_COALESCE_EQUAL, + Value: []byte("??="), + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 216, + EndPos: 219, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 215, + EndPos: 216, + }, + }, + }, + }, + Expr: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 220, + EndPos: 222, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 220, + EndPos: 222, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 220, + EndPos: 222, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 219, + EndPos: 220, + }, + }, + }, + }, + Value: []byte("$b"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 222, + EndPos: 223, + }, + }, + }, + }, + EndTkn: &token.Token{}, + } + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := php8.NewLexer([]byte(src), config) + php8parser := php8.NewParser(lexer, config) + php8parser.Parse() + actual := php8parser.GetRootNode() + assert.DeepEqual(t, expected, actual) +} + +// expr binary + +func TestExprBinary_BitwiseAnd(t *testing.T) { + src := `= $b; + $a > $b; + $a === $b; + $a and $b; + $a or $b; + $a xor $b; + $a - $b; + $a % $b; + $a * $b; + $a != $b; + $a !== $b; + $a + $b; + $a ** $b; + $a << $b; + $a >> $b; + $a <= $b; + $a < $b; + $a <=> $b;` + + expected := &ast.Root{ + Position: &position.Position{ + StartLine: 2, + EndLine: 28, + StartPos: 5, + EndPos: 320, + }, + Stmts: []ast.Vertex{ + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 2, + EndLine: 2, + StartPos: 5, + EndPos: 13, + }, + Expr: &ast.ExprBinaryBitwiseAnd{ + Position: &position.Position{ + StartLine: 2, + EndLine: 2, + StartPos: 5, + EndPos: 12, + }, + Left: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 2, + EndLine: 2, + StartPos: 5, + EndPos: 7, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 2, + EndLine: 2, + StartPos: 5, + EndPos: 7, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 2, + EndLine: 2, + StartPos: 5, + EndPos: 7, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte("="), + Position: &position.Position{ + StartLine: 11, + EndLine: 11, + StartPos: 111, + EndPos: 113, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 11, + EndLine: 11, + StartPos: 110, + EndPos: 111, + }, + }, + }, + }, + Right: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 11, + EndLine: 11, + StartPos: 114, + EndPos: 116, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 11, + EndLine: 11, + StartPos: 114, + EndPos: 116, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 11, + EndLine: 11, + StartPos: 114, + EndPos: 116, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 11, + EndLine: 11, + StartPos: 113, + EndPos: 114, + }, + }, + }, + }, + Value: []byte("$b"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 11, + EndLine: 11, + StartPos: 116, + EndPos: 117, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 12, + EndLine: 12, + StartPos: 120, + EndPos: 128, + }, + Expr: &ast.ExprBinaryGreater{ + Position: &position.Position{ + StartLine: 12, + EndLine: 12, + StartPos: 120, + EndPos: 127, + }, + Left: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 12, + EndLine: 12, + StartPos: 120, + EndPos: 122, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 12, + EndLine: 12, + StartPos: 120, + EndPos: 122, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 12, + EndLine: 12, + StartPos: 120, + EndPos: 122, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 11, + EndLine: 12, + StartPos: 117, + EndPos: 120, + }, + }, + }, + }, + Value: []byte("$a"), + }, + }, + OpTkn: &token.Token{ + ID: token.ID(62), + Value: []byte(">"), + Position: &position.Position{ + StartLine: 12, + EndLine: 12, + StartPos: 123, + EndPos: 124, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 12, + EndLine: 12, + StartPos: 122, + EndPos: 123, + }, + }, + }, + }, + Right: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 12, + EndLine: 12, + StartPos: 125, + EndPos: 127, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 12, + EndLine: 12, + StartPos: 125, + EndPos: 127, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 12, + EndLine: 12, + StartPos: 125, + EndPos: 127, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 12, + EndLine: 12, + StartPos: 124, + EndPos: 125, + }, + }, + }, + }, + Value: []byte("$b"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 12, + EndLine: 12, + StartPos: 127, + EndPos: 128, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 13, + EndLine: 13, + StartPos: 131, + EndPos: 141, + }, + Expr: &ast.ExprBinaryIdentical{ + Position: &position.Position{ + StartLine: 13, + EndLine: 13, + StartPos: 131, + EndPos: 140, + }, + Left: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 13, + EndLine: 13, + StartPos: 131, + EndPos: 133, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 13, + EndLine: 13, + StartPos: 131, + EndPos: 133, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 13, + EndLine: 13, + StartPos: 131, + EndPos: 133, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 12, + EndLine: 13, + StartPos: 128, + EndPos: 131, + }, + }, + }, + }, + Value: []byte("$a"), + }, + }, + OpTkn: &token.Token{ + ID: token.T_IS_IDENTICAL, + Value: []byte("==="), + Position: &position.Position{ + StartLine: 13, + EndLine: 13, + StartPos: 134, + EndPos: 137, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 13, + EndLine: 13, + StartPos: 133, + EndPos: 134, + }, + }, + }, + }, + Right: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 13, + EndLine: 13, + StartPos: 138, + EndPos: 140, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 13, + EndLine: 13, + StartPos: 138, + EndPos: 140, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 13, + EndLine: 13, + StartPos: 138, + EndPos: 140, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 13, + EndLine: 13, + StartPos: 137, + EndPos: 138, + }, + }, + }, + }, + Value: []byte("$b"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 13, + EndLine: 13, + StartPos: 140, + EndPos: 141, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 14, + EndLine: 14, + StartPos: 144, + EndPos: 154, + }, + Expr: &ast.ExprBinaryLogicalAnd{ + Position: &position.Position{ + StartLine: 14, + EndLine: 14, + StartPos: 144, + EndPos: 153, + }, + Left: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 14, + EndLine: 14, + StartPos: 144, + EndPos: 146, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 14, + EndLine: 14, + StartPos: 144, + EndPos: 146, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 14, + EndLine: 14, + StartPos: 144, + EndPos: 146, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 13, + EndLine: 14, + StartPos: 141, + EndPos: 144, + }, + }, + }, + }, + Value: []byte("$a"), + }, + }, + OpTkn: &token.Token{ + ID: token.T_LOGICAL_AND, + Value: []byte("and"), + Position: &position.Position{ + StartLine: 14, + EndLine: 14, + StartPos: 147, + EndPos: 150, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 14, + EndLine: 14, + StartPos: 146, + EndPos: 147, + }, + }, + }, + }, + Right: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 14, + EndLine: 14, + StartPos: 151, + EndPos: 153, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 14, + EndLine: 14, + StartPos: 151, + EndPos: 153, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 14, + EndLine: 14, + StartPos: 151, + EndPos: 153, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 14, + EndLine: 14, + StartPos: 150, + EndPos: 151, + }, + }, + }, + }, + Value: []byte("$b"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 14, + EndLine: 14, + StartPos: 153, + EndPos: 154, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 15, + EndLine: 15, + StartPos: 157, + EndPos: 166, + }, + Expr: &ast.ExprBinaryLogicalOr{ + Position: &position.Position{ + StartLine: 15, + EndLine: 15, + StartPos: 157, + EndPos: 165, + }, + Left: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 15, + EndLine: 15, + StartPos: 157, + EndPos: 159, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 15, + EndLine: 15, + StartPos: 157, + EndPos: 159, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 15, + EndLine: 15, + StartPos: 157, + EndPos: 159, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 14, + EndLine: 15, + StartPos: 154, + EndPos: 157, + }, + }, + }, + }, + Value: []byte("$a"), + }, + }, + OpTkn: &token.Token{ + ID: token.T_LOGICAL_OR, + Value: []byte("or"), + Position: &position.Position{ + StartLine: 15, + EndLine: 15, + StartPos: 160, + EndPos: 162, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 15, + EndLine: 15, + StartPos: 159, + EndPos: 160, + }, + }, + }, + }, + Right: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 15, + EndLine: 15, + StartPos: 163, + EndPos: 165, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 15, + EndLine: 15, + StartPos: 163, + EndPos: 165, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 15, + EndLine: 15, + StartPos: 163, + EndPos: 165, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 15, + EndLine: 15, + StartPos: 162, + EndPos: 163, + }, + }, + }, + }, + Value: []byte("$b"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 15, + EndLine: 15, + StartPos: 165, + EndPos: 166, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 16, + EndLine: 16, + StartPos: 169, + EndPos: 179, + }, + Expr: &ast.ExprBinaryLogicalXor{ + Position: &position.Position{ + StartLine: 16, + EndLine: 16, + StartPos: 169, + EndPos: 178, + }, + Left: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 16, + EndLine: 16, + StartPos: 169, + EndPos: 171, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 16, + EndLine: 16, + StartPos: 169, + EndPos: 171, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 16, + EndLine: 16, + StartPos: 169, + EndPos: 171, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 15, + EndLine: 16, + StartPos: 166, + EndPos: 169, + }, + }, + }, + }, + Value: []byte("$a"), + }, + }, + OpTkn: &token.Token{ + ID: token.T_LOGICAL_XOR, + Value: []byte("xor"), + Position: &position.Position{ + StartLine: 16, + EndLine: 16, + StartPos: 172, + EndPos: 175, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 16, + EndLine: 16, + StartPos: 171, + EndPos: 172, + }, + }, + }, + }, + Right: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 16, + EndLine: 16, + StartPos: 176, + EndPos: 178, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 16, + EndLine: 16, + StartPos: 176, + EndPos: 178, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 16, + EndLine: 16, + StartPos: 176, + EndPos: 178, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 16, + EndLine: 16, + StartPos: 175, + EndPos: 176, + }, + }, + }, + }, + Value: []byte("$b"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 16, + EndLine: 16, + StartPos: 178, + EndPos: 179, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 17, + EndLine: 17, + StartPos: 182, + EndPos: 190, + }, + Expr: &ast.ExprBinaryMinus{ + Position: &position.Position{ + StartLine: 17, + EndLine: 17, + StartPos: 182, + EndPos: 189, + }, + Left: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 17, + EndLine: 17, + StartPos: 182, + EndPos: 184, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 17, + EndLine: 17, + StartPos: 182, + EndPos: 184, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 17, + EndLine: 17, + StartPos: 182, + EndPos: 184, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 16, + EndLine: 17, + StartPos: 179, + EndPos: 182, + }, + }, + }, + }, + Value: []byte("$a"), + }, + }, + OpTkn: &token.Token{ + ID: token.ID(45), + Value: []byte("-"), + Position: &position.Position{ + StartLine: 17, + EndLine: 17, + StartPos: 185, + EndPos: 186, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 17, + EndLine: 17, + StartPos: 184, + EndPos: 185, + }, + }, + }, + }, + Right: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 17, + EndLine: 17, + StartPos: 187, + EndPos: 189, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 17, + EndLine: 17, + StartPos: 187, + EndPos: 189, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 17, + EndLine: 17, + StartPos: 187, + EndPos: 189, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 17, + EndLine: 17, + StartPos: 186, + EndPos: 187, + }, + }, + }, + }, + Value: []byte("$b"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 17, + EndLine: 17, + StartPos: 189, + EndPos: 190, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 193, + EndPos: 201, + }, + Expr: &ast.ExprBinaryMod{ + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 193, + EndPos: 200, + }, + Left: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 193, + EndPos: 195, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 193, + EndPos: 195, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 193, + EndPos: 195, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 17, + EndLine: 18, + StartPos: 190, + EndPos: 193, + }, + }, + }, + }, + Value: []byte("$a"), + }, + }, + OpTkn: &token.Token{ + ID: token.ID(37), + Value: []byte("%"), + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 196, + EndPos: 197, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 195, + EndPos: 196, + }, + }, + }, + }, + Right: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 198, + EndPos: 200, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 198, + EndPos: 200, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 198, + EndPos: 200, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 197, + EndPos: 198, + }, + }, + }, + }, + Value: []byte("$b"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 18, + EndLine: 18, + StartPos: 200, + EndPos: 201, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 19, + EndLine: 19, + StartPos: 204, + EndPos: 212, + }, + Expr: &ast.ExprBinaryMul{ + Position: &position.Position{ + StartLine: 19, + EndLine: 19, + StartPos: 204, + EndPos: 211, + }, + Left: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 19, + EndLine: 19, + StartPos: 204, + EndPos: 206, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 19, + EndLine: 19, + StartPos: 204, + EndPos: 206, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 19, + EndLine: 19, + StartPos: 204, + EndPos: 206, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 18, + EndLine: 19, + StartPos: 201, + EndPos: 204, + }, + }, + }, + }, + Value: []byte("$a"), + }, + }, + OpTkn: &token.Token{ + ID: token.ID(42), + Value: []byte("*"), + Position: &position.Position{ + StartLine: 19, + EndLine: 19, + StartPos: 207, + EndPos: 208, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 19, + EndLine: 19, + StartPos: 206, + EndPos: 207, + }, + }, + }, + }, + Right: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 19, + EndLine: 19, + StartPos: 209, + EndPos: 211, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 19, + EndLine: 19, + StartPos: 209, + EndPos: 211, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 19, + EndLine: 19, + StartPos: 209, + EndPos: 211, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 19, + EndLine: 19, + StartPos: 208, + EndPos: 209, + }, + }, + }, + }, + Value: []byte("$b"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 19, + EndLine: 19, + StartPos: 211, + EndPos: 212, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 20, + EndLine: 20, + StartPos: 215, + EndPos: 224, + }, + Expr: &ast.ExprBinaryNotEqual{ + Position: &position.Position{ + StartLine: 20, + EndLine: 20, + StartPos: 215, + EndPos: 223, + }, + Left: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 20, + EndLine: 20, + StartPos: 215, + EndPos: 217, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 20, + EndLine: 20, + StartPos: 215, + EndPos: 217, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 20, + EndLine: 20, + StartPos: 215, + EndPos: 217, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 19, + EndLine: 20, + StartPos: 212, + EndPos: 215, + }, + }, + }, + }, + Value: []byte("$a"), + }, + }, + OpTkn: &token.Token{ + ID: token.T_IS_NOT_EQUAL, + Value: []byte("!="), + Position: &position.Position{ + StartLine: 20, + EndLine: 20, + StartPos: 218, + EndPos: 220, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 20, + EndLine: 20, + StartPos: 217, + EndPos: 218, + }, + }, + }, + }, + Right: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 20, + EndLine: 20, + StartPos: 221, + EndPos: 223, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 20, + EndLine: 20, + StartPos: 221, + EndPos: 223, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 20, + EndLine: 20, + StartPos: 221, + EndPos: 223, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 20, + EndLine: 20, + StartPos: 220, + EndPos: 221, + }, + }, + }, + }, + Value: []byte("$b"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 20, + EndLine: 20, + StartPos: 223, + EndPos: 224, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 21, + EndLine: 21, + StartPos: 227, + EndPos: 237, + }, + Expr: &ast.ExprBinaryNotIdentical{ + Position: &position.Position{ + StartLine: 21, + EndLine: 21, + StartPos: 227, + EndPos: 236, + }, + Left: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 21, + EndLine: 21, + StartPos: 227, + EndPos: 229, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 21, + EndLine: 21, + StartPos: 227, + EndPos: 229, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 21, + EndLine: 21, + StartPos: 227, + EndPos: 229, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 20, + EndLine: 21, + StartPos: 224, + EndPos: 227, + }, + }, + }, + }, + Value: []byte("$a"), + }, + }, + OpTkn: &token.Token{ + ID: token.T_IS_NOT_IDENTICAL, + Value: []byte("!=="), + Position: &position.Position{ + StartLine: 21, + EndLine: 21, + StartPos: 230, + EndPos: 233, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 21, + EndLine: 21, + StartPos: 229, + EndPos: 230, + }, + }, + }, + }, + Right: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 21, + EndLine: 21, + StartPos: 234, + EndPos: 236, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 21, + EndLine: 21, + StartPos: 234, + EndPos: 236, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 21, + EndLine: 21, + StartPos: 234, + EndPos: 236, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 21, + EndLine: 21, + StartPos: 233, + EndPos: 234, + }, + }, + }, + }, + Value: []byte("$b"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 21, + EndLine: 21, + StartPos: 236, + EndPos: 237, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 22, + EndLine: 22, + StartPos: 240, + EndPos: 248, + }, + Expr: &ast.ExprBinaryPlus{ + Position: &position.Position{ + StartLine: 22, + EndLine: 22, + StartPos: 240, + EndPos: 247, + }, + Left: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 22, + EndLine: 22, + StartPos: 240, + EndPos: 242, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 22, + EndLine: 22, + StartPos: 240, + EndPos: 242, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 22, + EndLine: 22, + StartPos: 240, + EndPos: 242, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 21, + EndLine: 22, + StartPos: 237, + EndPos: 240, + }, + }, + }, + }, + Value: []byte("$a"), + }, + }, + OpTkn: &token.Token{ + ID: token.ID(43), + Value: []byte("+"), + Position: &position.Position{ + StartLine: 22, + EndLine: 22, + StartPos: 243, + EndPos: 244, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 22, + EndLine: 22, + StartPos: 242, + EndPos: 243, + }, + }, + }, + }, + Right: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 22, + EndLine: 22, + StartPos: 245, + EndPos: 247, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 22, + EndLine: 22, + StartPos: 245, + EndPos: 247, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 22, + EndLine: 22, + StartPos: 245, + EndPos: 247, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 22, + EndLine: 22, + StartPos: 244, + EndPos: 245, + }, + }, + }, + }, + Value: []byte("$b"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 22, + EndLine: 22, + StartPos: 247, + EndPos: 248, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 23, + EndLine: 23, + StartPos: 251, + EndPos: 260, + }, + Expr: &ast.ExprBinaryPow{ + Position: &position.Position{ + StartLine: 23, + EndLine: 23, + StartPos: 251, + EndPos: 259, + }, + Left: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 23, + EndLine: 23, + StartPos: 251, + EndPos: 253, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 23, + EndLine: 23, + StartPos: 251, + EndPos: 253, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 23, + EndLine: 23, + StartPos: 251, + EndPos: 253, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 22, + EndLine: 23, + StartPos: 248, + EndPos: 251, + }, + }, + }, + }, + Value: []byte("$a"), + }, + }, + OpTkn: &token.Token{ + ID: token.T_POW, + Value: []byte("**"), + Position: &position.Position{ + StartLine: 23, + EndLine: 23, + StartPos: 254, + EndPos: 256, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 23, + EndLine: 23, + StartPos: 253, + EndPos: 254, + }, + }, + }, + }, + Right: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 23, + EndLine: 23, + StartPos: 257, + EndPos: 259, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 23, + EndLine: 23, + StartPos: 257, + EndPos: 259, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 23, + EndLine: 23, + StartPos: 257, + EndPos: 259, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 23, + EndLine: 23, + StartPos: 256, + EndPos: 257, + }, + }, + }, + }, + Value: []byte("$b"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 23, + EndLine: 23, + StartPos: 259, + EndPos: 260, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 24, + EndLine: 24, + StartPos: 263, + EndPos: 272, + }, + Expr: &ast.ExprBinaryShiftLeft{ + Position: &position.Position{ + StartLine: 24, + EndLine: 24, + StartPos: 263, + EndPos: 271, + }, + Left: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 24, + EndLine: 24, + StartPos: 263, + EndPos: 265, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 24, + EndLine: 24, + StartPos: 263, + EndPos: 265, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 24, + EndLine: 24, + StartPos: 263, + EndPos: 265, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 23, + EndLine: 24, + StartPos: 260, + EndPos: 263, + }, + }, + }, + }, + Value: []byte("$a"), + }, + }, + OpTkn: &token.Token{ + ID: token.T_SL, + Value: []byte("<<"), + Position: &position.Position{ + StartLine: 24, + EndLine: 24, + StartPos: 266, + EndPos: 268, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 24, + EndLine: 24, + StartPos: 265, + EndPos: 266, + }, + }, + }, + }, + Right: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 24, + EndLine: 24, + StartPos: 269, + EndPos: 271, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 24, + EndLine: 24, + StartPos: 269, + EndPos: 271, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 24, + EndLine: 24, + StartPos: 269, + EndPos: 271, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 24, + EndLine: 24, + StartPos: 268, + EndPos: 269, + }, + }, + }, + }, + Value: []byte("$b"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 24, + EndLine: 24, + StartPos: 271, + EndPos: 272, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 25, + EndLine: 25, + StartPos: 275, + EndPos: 284, + }, + Expr: &ast.ExprBinaryShiftRight{ + Position: &position.Position{ + StartLine: 25, + EndLine: 25, + StartPos: 275, + EndPos: 283, + }, + Left: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 25, + EndLine: 25, + StartPos: 275, + EndPos: 277, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 25, + EndLine: 25, + StartPos: 275, + EndPos: 277, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 25, + EndLine: 25, + StartPos: 275, + EndPos: 277, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 24, + EndLine: 25, + StartPos: 272, + EndPos: 275, + }, + }, + }, + }, + Value: []byte("$a"), + }, + }, + OpTkn: &token.Token{ + ID: token.T_SR, + Value: []byte(">>"), + Position: &position.Position{ + StartLine: 25, + EndLine: 25, + StartPos: 278, + EndPos: 280, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 25, + EndLine: 25, + StartPos: 277, + EndPos: 278, + }, + }, + }, + }, + Right: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 25, + EndLine: 25, + StartPos: 281, + EndPos: 283, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 25, + EndLine: 25, + StartPos: 281, + EndPos: 283, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 25, + EndLine: 25, + StartPos: 281, + EndPos: 283, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 25, + EndLine: 25, + StartPos: 280, + EndPos: 281, + }, + }, + }, + }, + Value: []byte("$b"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 25, + EndLine: 25, + StartPos: 283, + EndPos: 284, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 26, + EndLine: 26, + StartPos: 287, + EndPos: 296, + }, + Expr: &ast.ExprBinarySmallerOrEqual{ + Position: &position.Position{ + StartLine: 26, + EndLine: 26, + StartPos: 287, + EndPos: 295, + }, + Left: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 26, + EndLine: 26, + StartPos: 287, + EndPos: 289, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 26, + EndLine: 26, + StartPos: 287, + EndPos: 289, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 26, + EndLine: 26, + StartPos: 287, + EndPos: 289, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 25, + EndLine: 26, + StartPos: 284, + EndPos: 287, + }, + }, + }, + }, + Value: []byte("$a"), + }, + }, + OpTkn: &token.Token{ + ID: token.T_IS_SMALLER_OR_EQUAL, + Value: []byte("<="), + Position: &position.Position{ + StartLine: 26, + EndLine: 26, + StartPos: 290, + EndPos: 292, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 26, + EndLine: 26, + StartPos: 289, + EndPos: 290, + }, + }, + }, + }, + Right: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 26, + EndLine: 26, + StartPos: 293, + EndPos: 295, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 26, + EndLine: 26, + StartPos: 293, + EndPos: 295, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 26, + EndLine: 26, + StartPos: 293, + EndPos: 295, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 26, + EndLine: 26, + StartPos: 292, + EndPos: 293, + }, + }, + }, + }, + Value: []byte("$b"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 26, + EndLine: 26, + StartPos: 295, + EndPos: 296, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 27, + EndLine: 27, + StartPos: 299, + EndPos: 307, + }, + Expr: &ast.ExprBinarySmaller{ + Position: &position.Position{ + StartLine: 27, + EndLine: 27, + StartPos: 299, + EndPos: 306, + }, + Left: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 27, + EndLine: 27, + StartPos: 299, + EndPos: 301, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 27, + EndLine: 27, + StartPos: 299, + EndPos: 301, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 27, + EndLine: 27, + StartPos: 299, + EndPos: 301, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 26, + EndLine: 27, + StartPos: 296, + EndPos: 299, + }, + }, + }, + }, + Value: []byte("$a"), + }, + }, + OpTkn: &token.Token{ + ID: token.ID(60), + Value: []byte("<"), + Position: &position.Position{ + StartLine: 27, + EndLine: 27, + StartPos: 302, + EndPos: 303, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 27, + EndLine: 27, + StartPos: 301, + EndPos: 302, + }, + }, + }, + }, + Right: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 27, + EndLine: 27, + StartPos: 304, + EndPos: 306, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 27, + EndLine: 27, + StartPos: 304, + EndPos: 306, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 27, + EndLine: 27, + StartPos: 304, + EndPos: 306, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 27, + EndLine: 27, + StartPos: 303, + EndPos: 304, + }, + }, + }, + }, + Value: []byte("$b"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 27, + EndLine: 27, + StartPos: 306, + EndPos: 307, + }, + }, + }, + &ast.StmtExpression{ + Position: &position.Position{ + StartLine: 28, + EndLine: 28, + StartPos: 310, + EndPos: 320, + }, + Expr: &ast.ExprBinarySpaceship{ + Position: &position.Position{ + StartLine: 28, + EndLine: 28, + StartPos: 310, + EndPos: 319, + }, + Left: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 28, + EndLine: 28, + StartPos: 310, + EndPos: 312, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 28, + EndLine: 28, + StartPos: 310, + EndPos: 312, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$a"), + Position: &position.Position{ + StartLine: 28, + EndLine: 28, + StartPos: 310, + EndPos: 312, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte("\n\t\t"), + Position: &position.Position{ + StartLine: 27, + EndLine: 28, + StartPos: 307, + EndPos: 310, + }, + }, + }, + }, + Value: []byte("$a"), + }, + }, + OpTkn: &token.Token{ + ID: token.T_SPACESHIP, + Value: []byte("<=>"), + Position: &position.Position{ + StartLine: 28, + EndLine: 28, + StartPos: 313, + EndPos: 316, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 28, + EndLine: 28, + StartPos: 312, + EndPos: 313, + }, + }, + }, + }, + Right: &ast.ExprVariable{ + Position: &position.Position{ + StartLine: 28, + EndLine: 28, + StartPos: 317, + EndPos: 319, + }, + Name: &ast.Identifier{ + Position: &position.Position{ + StartLine: 28, + EndLine: 28, + StartPos: 317, + EndPos: 319, + }, + IdentifierTkn: &token.Token{ + ID: token.T_VARIABLE, + Value: []byte("$b"), + Position: &position.Position{ + StartLine: 28, + EndLine: 28, + StartPos: 317, + EndPos: 319, + }, + FreeFloating: []*token.Token{ + { + ID: token.T_WHITESPACE, + Value: []byte(" "), + Position: &position.Position{ + StartLine: 28, + EndLine: 28, + StartPos: 316, + EndPos: 317, + }, + }, + }, + }, + Value: []byte("$b"), + }, + }, + }, + SemiColonTkn: &token.Token{ + ID: token.ID(59), + Value: []byte(";"), + Position: &position.Position{ + StartLine: 28, + EndLine: 28, + StartPos: 319, + EndPos: 320, + }, + }, + }, + }, + EndTkn: &token.Token{}, + } + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := php8.NewLexer([]byte(src), config) + php8parser := php8.NewParser(lexer, config) + php8parser.Parse() + actual := php8parser.GetRootNode() + assert.DeepEqual(t, expected, actual) +} + +// expr cast + +func TestStrings(t *testing.T) { + src := `'", + "'.'", +} +var yyStatenames = [...]string{} + +const yyEofCode = 1 +const yyErrCode = 2 +const yyInitialStackSize = 16 + +// line internal/php8/php8.y:3423 + +// line yacctab:1 +var yyExca = [...]int{ + -1, 1, + 1, -1, + -2, 0, + -1, 2, + 1, 1, + 53, 107, + 54, 107, + 55, 107, + 100, 107, + 101, 107, + -2, 0, + -1, 42, + 58, 479, + 79, 479, + 142, 479, + 150, 479, + 156, 479, + -2, 475, + -1, 46, + 154, 485, + -2, 494, + -1, 82, + 79, 440, + -2, 483, + -1, 83, + 58, 484, + 142, 484, + 150, 484, + 156, 484, + -2, 464, + -1, 96, + 58, 481, + 79, 481, + 142, 481, + 150, 481, + 154, 487, + 156, 481, + -2, 462, + -1, 97, + 58, 482, + 79, 482, + 142, 482, + 150, 482, + 156, 482, + -2, 463, + -1, 101, + 79, 442, + -2, 466, + -1, 215, + 53, 107, + 54, 107, + 55, 107, + 100, 107, + 101, 107, + -2, 0, + -1, 322, + 58, 479, + 79, 479, + 142, 479, + 150, 479, + 156, 479, + -2, 362, + -1, 325, + 154, 487, + -2, 481, + -1, 329, + 58, 479, + 79, 479, + 142, 479, + 150, 479, + 156, 479, + -2, 364, + -1, 392, + 53, 107, + 54, 107, + 55, 107, + 100, 107, + 101, 107, + -2, 0, + -1, 445, + 116, 0, + 136, 0, + 137, 0, + 138, 0, + 139, 0, + -2, 386, + -1, 446, + 116, 0, + 136, 0, + 137, 0, + 138, 0, + 139, 0, + -2, 387, + -1, 447, + 116, 0, + 136, 0, + 137, 0, + 138, 0, + 139, 0, + -2, 388, + -1, 448, + 116, 0, + 136, 0, + 137, 0, + 138, 0, + 139, 0, + -2, 389, + -1, 449, + 140, 0, + 141, 0, + 173, 0, + 174, 0, + -2, 390, + -1, 450, + 140, 0, + 141, 0, + 173, 0, + 174, 0, + -2, 391, + -1, 451, + 140, 0, + 141, 0, + 173, 0, + 174, 0, + -2, 392, + -1, 452, + 140, 0, + 141, 0, + 173, 0, + 174, 0, + -2, 393, + -1, 453, + 116, 0, + 136, 0, + 137, 0, + 138, 0, + 139, 0, + -2, 394, + -1, 460, + 155, 184, + 166, 184, + -2, 479, + -1, 463, + 53, 107, + 54, 107, + 55, 107, + 100, 107, + 101, 107, + -2, 0, + -1, 504, + 155, 523, + 157, 523, + 166, 523, + -2, 479, + -1, 509, + 58, 480, + 79, 480, + 142, 480, + 150, 480, + 154, 486, + 156, 480, + -2, 396, + -1, 527, + 154, 511, + -2, 501, + -1, 530, + 154, 78, + -2, 80, + -1, 531, + 154, 79, + -2, 81, + -1, 557, + 153, 80, + -2, 96, + -1, 561, + 153, 13, + -2, 446, + -1, 563, + 153, 46, + -2, 415, + -1, 565, + 153, 72, + -2, 441, + -1, 566, + 153, 11, + -2, 107, + -1, 575, + 154, 427, + -2, 42, + -1, 577, + 153, 61, + -2, 474, + -1, 578, + 153, 62, + -2, 470, + -1, 579, + 153, 63, + -2, 472, + -1, 580, + 153, 64, + -2, 471, + -1, 581, + 153, 65, + -2, 467, + -1, 582, + 153, 66, + -2, 468, + -1, 583, + 153, 67, + -2, 469, + -1, 584, + 153, 68, + -2, 473, + -1, 585, + 154, 427, + -2, 69, + -1, 588, + 155, 236, + -2, 107, + -1, 590, + 53, 107, + 54, 107, + 55, 107, + 100, 107, + 101, 107, + -2, 0, + -1, 617, + 155, 236, + -2, 107, + -1, 618, + 155, 236, + -2, 107, + -1, 626, + 53, 107, + 54, 107, + 55, 107, + 100, 107, + 101, 107, + -2, 0, + -1, 641, + 154, 486, + -2, 480, + -1, 706, + 155, 206, + -2, 479, + -1, 716, + 155, 236, + -2, 107, + -1, 731, + 155, 522, + 157, 522, + 166, 522, + -2, 479, + -1, 749, + 155, 83, + -2, 107, + -1, 763, + 53, 107, + 54, 107, + 55, 107, + 100, 107, + 101, 107, + -2, 0, + -1, 773, + 155, 207, + -2, 479, + -1, 776, + 53, 107, + 54, 107, + 55, 107, + 100, 107, + 101, 107, + -2, 0, + -1, 796, + 53, 107, + 54, 107, + 55, 107, + 94, 231, + 95, 231, + 96, 231, + 100, 107, + 101, 107, + -2, 0, + -1, 838, + 155, 206, + -2, 479, + -1, 840, + 155, 209, + -2, 454, + -1, 852, + 37, 306, + 39, 306, + -2, 303, + -1, 864, + 53, 107, + 54, 107, + 55, 107, + 94, 232, + 95, 232, + 96, 232, + 100, 107, + 101, 107, + -2, 0, + -1, 899, + 53, 107, + 54, 107, + 55, 107, + 100, 107, + 101, 107, + -2, 0, + -1, 903, + 53, 107, + 54, 107, + 55, 107, + 100, 107, + 101, 107, + -2, 0, + -1, 935, + 31, 222, + 32, 222, + 33, 222, + 53, 107, + 54, 107, + 55, 107, + 100, 107, + 101, 107, + 151, 222, + -2, 0, + -1, 943, + 53, 107, + 54, 107, + 55, 107, + 100, 107, + 101, 107, + -2, 0, + -1, 970, + 79, 96, + -2, 78, + -1, 977, + 53, 107, + 54, 107, + 55, 107, + 100, 107, + 101, 107, + -2, 0, + -1, 978, + 31, 221, + 32, 221, + 33, 221, + 53, 107, + 54, 107, + 55, 107, + 100, 107, + 101, 107, + 151, 221, + -2, 0, + -1, 983, + 53, 107, + 54, 107, + 55, 107, + 100, 107, + 101, 107, + -2, 0, + -1, 988, + 53, 107, + 54, 107, + 55, 107, + 100, 107, + 101, 107, + -2, 0, + -1, 1014, + 155, 236, + -2, 107, + -1, 1022, + 53, 107, + 54, 107, + 55, 107, + 100, 107, + 101, 107, + -2, 0, + -1, 1033, + 53, 107, + 54, 107, + 55, 107, + 100, 107, + 101, 107, + -2, 0, +} + +const yyPrivate = 57344 + +const yyLast = 9249 + +var yyAct = [...]int{ + + 29, 39, 947, 808, 854, 963, 466, 215, 679, 721, + 126, 956, 878, 953, 834, 893, 811, 957, 803, 218, + 719, 688, 38, 223, 223, 223, 705, 687, 237, 681, + 881, 784, 959, 553, 544, 313, 766, 414, 459, 717, + 532, 495, 315, 357, 124, 233, 101, 213, 96, 236, + 103, 317, 321, 388, 97, 330, 331, 332, 333, 334, + 283, 205, 229, 335, 336, 337, 338, 339, 340, 341, + 409, 344, 99, 9, 352, 353, 354, 355, 556, 2, + 523, 408, 77, 204, 8, 212, 366, 222, 361, 372, + 373, 274, 375, 376, 407, 406, 533, 7, 6, 234, + 44, 325, 325, 98, 368, 265, 1004, 326, 326, 232, + 690, 226, 227, 995, 348, 992, 116, 202, 729, 635, + 917, 425, 916, 208, 401, 359, 496, 993, 116, 358, + 989, 359, 926, 924, 887, 363, 792, 615, 885, 276, + 594, 994, 278, 426, 990, 349, 265, 251, 400, 423, + 421, 399, 393, 116, 394, 405, 792, 427, 5, 986, + 875, 873, 870, 424, 422, 400, 394, 821, 349, 759, + 749, 264, 675, 670, 116, 217, 613, 604, 522, 502, + 645, 116, 116, 646, 250, 252, 253, 349, 251, 254, + 255, 256, 257, 258, 259, 261, 263, 275, 382, 384, + 884, 840, 392, 738, 734, 657, 642, 652, 629, 501, + 868, 1014, 653, 1028, 245, 249, 248, 411, 984, 980, + 901, 416, 417, 900, 246, 250, 252, 253, 260, 262, + 247, 891, 865, 847, 782, 38, 781, 771, 747, 744, + 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, + 448, 449, 450, 451, 452, 453, 497, 455, 457, 742, + 461, 941, 733, 413, 703, 692, 678, 643, 634, 463, + 389, 100, 908, 843, 516, 895, 894, 396, 774, 732, + 716, 380, 477, 479, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 100, 232, 492, 223, + 494, 537, 359, 317, 208, 385, 363, 325, 265, 276, + 505, 395, 278, 326, 809, 507, 310, 100, 949, 317, + 647, 467, 539, 700, 374, 371, 701, 1003, 370, 369, + 343, 312, 383, 471, 223, 618, 617, 602, 500, 600, + 588, 518, 506, 499, 454, 474, 462, 472, 307, 270, + 251, 254, 255, 269, 508, 268, 540, 325, 517, 221, + 542, 545, 546, 326, 220, 547, 83, 216, 528, 120, + 42, 550, 515, 1032, 554, 1031, 317, 249, 248, 829, + 830, 794, 677, 531, 476, 538, 493, 250, 252, 253, + 325, 273, 599, 536, 829, 830, 326, 790, 1021, 535, + 311, 391, 38, 390, 225, 1000, 558, 999, 309, 349, + 349, 586, 979, 225, 308, 116, 608, 936, 237, 323, + 323, 510, 902, 322, 329, 790, 897, 890, 888, 526, + 265, 826, 822, 473, 795, 770, 769, 265, 598, 767, + 349, 765, 349, 762, 603, 524, 592, 611, 589, 349, + 349, 512, 513, 9, 475, 816, 817, 464, 420, 276, + 607, 590, 419, 624, 8, 625, 418, 609, 593, 627, + 866, 819, 251, 38, 626, 606, 757, 7, 6, 251, + 254, 255, 512, 654, 513, 225, 790, 234, 632, 210, + 1006, 513, 512, 317, 637, 208, 78, 317, 896, 249, + 248, 950, 327, 971, 944, 790, 249, 248, 906, 250, + 252, 253, 655, 828, 867, 848, 250, 252, 253, 225, + 659, 247, 842, 741, 78, 720, 223, 662, 225, 612, + 511, 951, 640, 684, 621, 636, 816, 817, 5, 119, + 117, 118, 596, 271, 210, 78, 676, 78, 119, 117, + 118, 321, 814, 352, 353, 355, 656, 365, 366, 359, + 265, 372, 373, 358, 375, 376, 210, 251, 100, 663, + 664, 206, 667, 207, 882, 928, 368, 347, 648, 534, + 682, 360, 631, 116, 923, 78, 633, 921, 514, 753, + 752, 751, 862, 696, 416, 698, 691, 871, 368, 772, + 38, 702, 251, 359, 78, 219, 115, 363, 327, 682, + 682, 787, 658, 661, 669, 785, 714, 715, 210, 413, + 119, 117, 118, 674, 846, 211, 730, 368, 368, 284, + 285, 697, 718, 879, 623, 323, 38, 1001, 232, 460, + 280, 281, 704, 541, 736, 206, 116, 207, 350, 351, + 468, 9, 325, 325, 119, 117, 118, 1002, 326, 326, + 722, 545, 8, 119, 117, 118, 554, 398, 746, 277, + 115, 219, 115, 379, 761, 7, 6, 325, 286, 287, + 211, 209, 398, 326, 398, 323, 284, 285, 225, 504, + 780, 779, 386, 763, 412, 743, 756, 740, 558, 745, + 317, 760, 211, 209, 288, 290, 289, 913, 682, 912, + 776, 789, 78, 735, 689, 783, 116, 116, 323, 587, + 797, 595, 520, 317, 824, 796, 368, 203, 768, 368, + 650, 791, 807, 649, 620, 775, 5, 116, 397, 816, + 817, 682, 514, 619, 116, 1, 325, 694, 225, 514, + 116, 748, 326, 79, 211, 786, 416, 758, 798, 368, + 214, 711, 800, 597, 225, 317, 898, 829, 830, 810, + 470, 813, 469, 38, 726, 844, 78, 823, 78, 230, + 548, 350, 351, 789, 116, 849, 38, 818, 465, 837, + 861, 279, 864, 827, 831, 272, 833, 282, 852, 116, + 839, 368, 350, 351, 377, 876, 38, 850, 549, 350, + 351, 325, 832, 829, 830, 816, 817, 326, 851, 962, + 892, 345, 722, 119, 117, 118, 820, 722, 356, 863, + 750, 116, 778, 889, 899, 886, 387, 327, 367, 907, + 903, 909, 713, 802, 801, 60, 818, 914, 806, 350, + 351, 818, 804, 882, 381, 845, 622, 911, 458, 910, + 693, 807, 920, 378, 350, 351, 922, 931, 1030, 793, + 699, 813, 915, 869, 38, 815, 872, 874, 918, 919, + 905, 116, 925, 119, 117, 118, 346, 818, 812, 880, + 877, 935, 365, 316, 41, 121, 350, 351, 934, 119, + 117, 118, 789, 100, 943, 938, 929, 685, 930, 38, + 789, 686, 972, 38, 973, 754, 818, 835, 755, 13, + 368, 40, 818, 955, 818, 969, 543, 974, 368, 975, + 946, 977, 978, 858, 859, 860, 857, 856, 855, 945, + 17, 952, 983, 552, 16, 38, 350, 351, 988, 904, + 235, 991, 644, 38, 968, 364, 47, 960, 998, 46, + 102, 818, 48, 818, 82, 525, 80, 942, 996, 71, + 969, 948, 342, 314, 954, 61, 81, 362, 981, 1008, + 323, 323, 59, 1011, 460, 706, 1013, 38, 38, 967, + 976, 966, 965, 38, 1010, 1020, 1012, 1018, 38, 968, + 964, 1015, 788, 1017, 1022, 323, 682, 853, 1023, 731, + 1024, 1019, 987, 1025, 231, 228, 43, 985, 777, 367, + 710, 680, 1029, 415, 368, 402, 1026, 3, 940, 927, + 1033, 883, 38, 0, 0, 0, 0, 932, 722, 241, + 243, 242, 265, 38, 0, 0, 835, 0, 0, 948, + 0, 0, 0, 954, 0, 0, 0, 0, 858, 859, + 860, 857, 856, 855, 498, 498, 267, 264, 0, 0, + 0, 0, 0, 0, 323, 0, 0, 0, 773, 0, + 0, 0, 239, 240, 251, 254, 255, 256, 257, 258, + 259, 261, 263, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 895, 894, 0, 0, 0, 0, 266, + 245, 249, 248, 0, 527, 0, 0, 0, 244, 0, + 246, 250, 252, 253, 260, 262, 247, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 323, + 0, 0, 0, 838, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 570, 571, 561, 145, 93, + 94, 557, 0, 116, 0, 0, 230, 0, 0, 113, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 179, 180, 181, 182, 183, 171, 172, 575, 585, + 174, 175, 160, 161, 162, 564, 164, 165, 166, 167, + 168, 568, 569, 0, 191, 189, 190, 186, 187, 0, + 0, 559, 576, 185, 577, 578, 580, 579, 581, 582, + 0, 0, 0, 0, 0, 0, 95, 0, 0, 0, + 0, 188, 584, 583, 0, 555, 572, 573, 574, 138, + 139, 140, 141, 566, 560, 146, 147, 148, 562, 563, + 565, 128, 129, 130, 131, 132, 52, 53, 75, 62, + 63, 64, 65, 66, 67, 68, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 660, 0, + 0, 498, 498, 665, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 567, 78, 119, 117, 118, 114, + 72, 0, 0, 0, 0, 58, 551, 50, 0, 0, + 367, 55, 54, 56, 57, 70, 100, 570, 571, 561, + 145, 93, 94, 557, 0, 116, 0, 0, 0, 0, + 0, 113, 149, 150, 151, 152, 153, 154, 155, 156, + 157, 158, 159, 179, 180, 181, 182, 183, 171, 172, + 575, 585, 174, 175, 160, 161, 162, 564, 164, 165, + 166, 167, 168, 568, 569, 0, 191, 189, 190, 186, + 187, 0, 0, 559, 576, 185, 577, 578, 580, 579, + 581, 582, 0, 0, 0, 0, 0, 0, 95, 0, + 0, 0, 0, 188, 584, 583, 0, 555, 572, 573, + 574, 138, 139, 140, 141, 566, 560, 146, 147, 148, + 562, 563, 565, 128, 129, 130, 131, 132, 52, 53, + 75, 62, 63, 64, 65, 66, 67, 68, 0, 305, + 306, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 292, 293, 294, 295, 296, 297, 298, 299, + 300, 301, 302, 303, 304, 0, 567, 78, 119, 117, + 118, 114, 72, 0, 0, 0, 0, 58, 0, 50, + 0, 0, 0, 55, 54, 56, 57, 70, 100, 4, + 0, 88, 89, 69, 45, 93, 94, 36, 0, 116, + 0, 28, 291, 0, 0, 113, 27, 19, 18, 0, + 20, 0, 31, 0, 32, 0, 0, 21, 0, 0, + 0, 22, 23, 35, 37, 115, 14, 24, 34, 0, + 0, 76, 12, 265, 25, 0, 30, 86, 87, 10, + 0, 0, 0, 0, 0, 0, 0, 49, 112, 0, + 111, 107, 108, 109, 104, 105, 0, 0, 0, 0, + 0, 0, 95, 0, 0, 0, 0, 11, 110, 106, + 0, 0, 90, 91, 92, 251, 254, 255, 0, 84, + 51, 0, 261, 263, 73, 74, 26, 0, 0, 0, + 0, 0, 52, 53, 75, 62, 63, 64, 65, 66, + 67, 68, 249, 248, 0, 0, 0, 0, 0, 0, + 0, 0, 250, 252, 253, 260, 262, 247, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 85, 78, 119, 117, 118, 114, 72, 15, 683, 33, + 0, 58, 0, 50, 0, 0, 0, 55, 54, 56, + 57, 70, 100, 4, 0, 88, 89, 69, 45, 93, + 94, 36, 0, 116, 0, 28, 0, 0, 0, 113, + 27, 19, 18, 0, 20, 0, 31, 0, 32, 0, + 0, 21, 0, 0, 0, 22, 23, 35, 37, 115, + 14, 24, 34, 0, 0, 76, 12, 0, 25, 0, + 30, 86, 87, 10, 0, 0, 0, 0, 0, 0, + 0, 49, 112, 0, 111, 107, 108, 109, 104, 105, + 0, 0, 0, 0, 0, 0, 95, 0, 0, 0, + 0, 11, 110, 106, 0, 0, 90, 91, 92, 0, + 0, 0, 0, 84, 51, 0, 0, 0, 73, 74, + 26, 0, 0, 0, 0, 0, 52, 53, 75, 62, + 63, 64, 65, 66, 67, 68, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 85, 78, 119, 117, 118, 114, + 72, 15, 591, 33, 0, 58, 0, 50, 0, 0, + 0, 55, 54, 56, 57, 70, 100, 4, 0, 88, + 89, 69, 45, 93, 94, 36, 0, 116, 0, 28, + 0, 0, 0, 113, 27, 19, 18, 0, 20, 0, + 31, 0, 32, 0, 0, 21, 0, 0, 0, 22, + 23, 35, 37, 115, 14, 24, 34, 0, 0, 76, + 12, 0, 25, 0, 30, 86, 87, 10, 0, 0, + 0, 0, 0, 0, 0, 49, 112, 0, 111, 107, + 108, 109, 104, 105, 0, 0, 0, 0, 0, 0, + 95, 0, 0, 0, 0, 11, 110, 106, 0, 0, + 90, 91, 92, 0, 0, 0, 0, 84, 51, 0, + 0, 0, 73, 74, 26, 0, 0, 0, 0, 0, + 52, 53, 75, 62, 63, 64, 65, 66, 67, 68, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 85, 78, + 119, 117, 118, 114, 72, 15, 0, 33, 0, 58, + 0, 50, 0, 0, 0, 55, 54, 56, 57, 70, + 100, 133, 134, 144, 145, 0, 0, 530, 0, 116, + 0, 0, 0, 0, 0, 0, 149, 150, 151, 152, + 153, 154, 155, 156, 157, 158, 159, 179, 180, 181, + 182, 183, 171, 172, 173, 200, 174, 175, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 0, + 191, 189, 190, 186, 187, 0, 0, 178, 184, 185, + 192, 193, 195, 194, 196, 197, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 188, 199, 198, + 0, 0, 135, 136, 137, 138, 139, 140, 141, 142, + 143, 146, 147, 148, 176, 177, 127, 128, 129, 130, + 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, + 404, 0, 88, 89, 69, 45, 93, 94, 36, 0, + 116, 0, 28, 0, 0, 0, 113, 27, 19, 18, + 0, 20, 0, 31, 0, 32, 0, 0, 21, 0, + 201, 0, 22, 23, 35, 37, 115, 529, 24, 34, + 0, 0, 76, 0, 0, 25, 0, 30, 86, 87, + 410, 0, 100, 0, 0, 0, 0, 0, 49, 112, + 0, 111, 107, 108, 109, 104, 105, 0, 0, 0, + 0, 0, 0, 95, 0, 0, 0, 0, 0, 110, + 106, 0, 0, 90, 91, 92, 0, 0, 0, 0, + 84, 51, 0, 0, 0, 73, 74, 26, 0, 0, + 0, 0, 0, 52, 53, 75, 62, 63, 64, 65, + 66, 67, 68, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 85, 78, 119, 117, 118, 114, 72, 15, 1034, + 33, 0, 58, 0, 50, 0, 0, 0, 55, 54, + 56, 57, 70, 100, 404, 0, 88, 89, 69, 45, + 93, 94, 36, 0, 116, 0, 28, 0, 0, 0, + 113, 27, 19, 18, 0, 20, 0, 31, 0, 32, + 0, 0, 21, 0, 0, 0, 22, 23, 35, 37, + 115, 0, 24, 34, 0, 0, 76, 0, 0, 25, + 0, 30, 86, 87, 410, 0, 0, 0, 0, 0, + 0, 0, 49, 112, 0, 111, 107, 108, 109, 104, + 105, 0, 0, 0, 0, 0, 0, 95, 0, 0, + 0, 0, 0, 110, 106, 0, 0, 90, 91, 92, + 0, 0, 0, 0, 84, 51, 0, 0, 0, 73, + 74, 26, 0, 0, 0, 0, 0, 52, 53, 75, + 62, 63, 64, 65, 66, 67, 68, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 85, 78, 119, 117, 118, + 114, 72, 15, 1027, 33, 0, 58, 0, 50, 0, + 0, 0, 55, 54, 56, 57, 70, 100, 404, 0, + 88, 89, 69, 45, 93, 94, 36, 0, 116, 0, + 28, 0, 0, 0, 113, 27, 19, 18, 0, 20, + 0, 31, 0, 32, 0, 0, 21, 0, 0, 0, + 22, 23, 35, 37, 115, 0, 24, 34, 0, 0, + 76, 0, 0, 25, 0, 30, 86, 87, 410, 0, + 0, 0, 0, 0, 0, 0, 49, 112, 0, 111, + 107, 108, 109, 104, 105, 0, 0, 0, 0, 0, + 0, 95, 0, 0, 0, 0, 0, 110, 106, 0, + 0, 90, 91, 92, 0, 0, 0, 0, 84, 51, + 0, 0, 0, 73, 74, 26, 0, 0, 0, 0, + 0, 52, 53, 75, 62, 63, 64, 65, 66, 67, + 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 85, + 78, 119, 117, 118, 114, 72, 15, 1009, 33, 0, + 58, 0, 50, 0, 0, 0, 55, 54, 56, 57, + 70, 100, 404, 0, 88, 89, 69, 45, 93, 94, + 36, 0, 116, 0, 28, 0, 0, 0, 113, 27, + 19, 18, 0, 20, 0, 31, 0, 32, 0, 0, + 21, 0, 0, 0, 22, 23, 35, 37, 115, 0, + 24, 34, 0, 0, 76, 0, 0, 25, 0, 30, + 86, 87, 410, 0, 0, 0, 0, 0, 0, 0, + 49, 112, 0, 111, 107, 108, 109, 104, 105, 0, + 0, 0, 0, 0, 0, 95, 0, 0, 0, 0, + 0, 110, 106, 0, 0, 90, 91, 92, 0, 0, + 0, 0, 84, 51, 0, 0, 0, 73, 74, 26, + 0, 0, 0, 0, 0, 52, 53, 75, 62, 63, + 64, 65, 66, 67, 68, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 85, 78, 119, 117, 118, 114, 72, + 15, 1007, 33, 0, 58, 0, 50, 0, 0, 0, + 55, 54, 56, 57, 70, 100, 404, 0, 88, 89, + 69, 45, 93, 94, 36, 0, 116, 0, 28, 0, + 0, 0, 113, 27, 19, 18, 0, 20, 1005, 31, + 0, 32, 0, 0, 21, 0, 0, 0, 22, 23, + 35, 37, 115, 0, 24, 34, 0, 0, 76, 0, + 0, 25, 0, 30, 86, 87, 410, 0, 0, 0, + 0, 0, 0, 0, 49, 112, 0, 111, 107, 108, + 109, 104, 105, 0, 0, 0, 0, 0, 0, 95, + 0, 0, 0, 0, 0, 110, 106, 0, 0, 90, + 91, 92, 0, 0, 0, 0, 84, 51, 0, 0, + 0, 73, 74, 26, 0, 0, 0, 0, 0, 52, + 53, 75, 62, 63, 64, 65, 66, 67, 68, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 85, 78, 119, + 117, 118, 114, 72, 15, 0, 33, 0, 58, 0, + 50, 0, 0, 0, 55, 54, 56, 57, 70, 100, + 404, 0, 88, 89, 69, 45, 93, 94, 36, 0, + 116, 0, 28, 0, 0, 0, 113, 27, 19, 18, + 0, 20, 0, 31, 0, 32, 0, 0, 21, 0, + 0, 0, 22, 23, 35, 37, 115, 0, 24, 34, + 0, 0, 76, 0, 0, 25, 0, 30, 86, 87, + 410, 0, 0, 0, 0, 0, 0, 0, 49, 112, + 0, 111, 107, 108, 109, 104, 105, 0, 0, 0, + 0, 0, 0, 95, 0, 0, 0, 0, 0, 110, + 106, 0, 0, 90, 91, 92, 0, 0, 0, 0, + 84, 51, 0, 0, 0, 73, 74, 26, 0, 0, + 0, 0, 0, 52, 53, 75, 62, 63, 64, 65, + 66, 67, 68, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 85, 78, 119, 117, 118, 114, 72, 15, 982, + 33, 0, 58, 0, 50, 0, 0, 0, 55, 54, + 56, 57, 70, 100, 404, 0, 88, 89, 69, 45, + 93, 94, 36, 0, 116, 0, 28, 0, 0, 0, + 113, 27, 19, 18, 0, 20, 0, 31, 0, 32, + 0, 0, 21, 0, 0, 0, 22, 23, 35, 37, + 115, 0, 24, 34, 0, 0, 76, 0, 0, 25, + 0, 30, 86, 87, 410, 0, 0, 0, 0, 0, + 0, 0, 49, 112, 0, 111, 107, 108, 109, 104, + 105, 0, 0, 0, 0, 0, 0, 95, 0, 0, + 0, 0, 0, 110, 106, 0, 0, 90, 91, 92, + 0, 0, 0, 0, 84, 51, 0, 0, 0, 73, + 74, 26, 0, 0, 0, 0, 0, 52, 53, 75, + 62, 63, 64, 65, 66, 67, 68, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 85, 78, 119, 117, 118, + 114, 72, 15, 939, 33, 0, 58, 0, 50, 0, + 0, 0, 55, 54, 56, 57, 70, 100, 404, 0, + 88, 89, 69, 45, 93, 94, 36, 0, 116, 0, + 28, 0, 0, 0, 113, 27, 19, 18, 0, 20, + 0, 31, 937, 32, 0, 0, 21, 0, 0, 0, + 22, 23, 35, 37, 115, 0, 24, 34, 0, 0, + 76, 0, 0, 25, 0, 30, 86, 87, 410, 0, + 0, 0, 0, 0, 0, 0, 49, 112, 0, 111, + 107, 108, 109, 104, 105, 0, 0, 0, 0, 0, + 0, 95, 0, 0, 0, 0, 0, 110, 106, 0, + 0, 90, 91, 92, 0, 0, 0, 0, 84, 51, + 0, 0, 0, 73, 74, 26, 0, 0, 0, 0, + 0, 52, 53, 75, 62, 63, 64, 65, 66, 67, + 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 85, + 78, 119, 117, 118, 114, 72, 15, 0, 33, 0, + 58, 0, 50, 0, 0, 0, 55, 54, 56, 57, + 70, 100, 404, 0, 88, 89, 69, 45, 93, 94, + 36, 0, 116, 0, 28, 0, 0, 0, 113, 27, + 19, 18, 0, 20, 0, 31, 0, 32, 841, 0, + 21, 0, 0, 0, 22, 23, 35, 37, 115, 0, + 24, 34, 0, 0, 76, 0, 0, 25, 0, 30, + 86, 87, 410, 0, 0, 0, 0, 0, 0, 0, + 49, 112, 0, 111, 107, 108, 109, 104, 105, 0, + 0, 0, 0, 0, 0, 95, 0, 0, 0, 0, + 0, 110, 106, 0, 0, 90, 91, 92, 0, 0, + 0, 0, 84, 51, 0, 0, 0, 73, 74, 26, + 0, 0, 0, 0, 0, 52, 53, 75, 62, 63, + 64, 65, 66, 67, 68, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 85, 78, 119, 117, 118, 114, 72, + 15, 0, 33, 0, 58, 0, 50, 0, 0, 0, + 55, 54, 56, 57, 70, 100, 404, 0, 88, 89, + 69, 45, 93, 94, 36, 0, 116, 0, 28, 0, + 0, 0, 113, 27, 19, 18, 825, 20, 0, 31, + 0, 32, 0, 0, 21, 0, 0, 0, 22, 23, + 35, 37, 115, 0, 24, 34, 0, 0, 76, 0, + 0, 25, 0, 30, 86, 87, 410, 0, 0, 0, + 0, 0, 0, 0, 49, 112, 0, 111, 107, 108, + 109, 104, 105, 0, 0, 0, 0, 0, 0, 95, + 0, 0, 0, 0, 0, 110, 106, 0, 0, 90, + 91, 92, 0, 0, 0, 0, 84, 51, 0, 0, + 0, 73, 74, 26, 0, 0, 0, 0, 0, 52, + 53, 75, 62, 63, 64, 65, 66, 67, 68, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 85, 78, 119, + 117, 118, 114, 72, 15, 0, 33, 0, 58, 0, + 50, 0, 0, 0, 55, 54, 56, 57, 70, 100, + 404, 0, 88, 89, 69, 45, 93, 94, 36, 0, + 116, 0, 28, 0, 0, 0, 113, 27, 19, 18, + 0, 20, 0, 31, 0, 32, 0, 0, 21, 0, + 0, 0, 22, 23, 35, 37, 115, 0, 24, 34, + 0, 0, 76, 0, 0, 25, 0, 30, 86, 87, + 410, 0, 0, 0, 0, 0, 0, 0, 49, 112, + 0, 111, 107, 108, 109, 104, 105, 0, 0, 0, + 0, 0, 0, 95, 0, 0, 0, 0, 0, 110, + 106, 0, 0, 90, 91, 92, 0, 0, 0, 0, + 84, 51, 0, 0, 725, 73, 74, 26, 0, 0, + 0, 0, 0, 52, 53, 75, 62, 63, 64, 65, + 66, 67, 68, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 85, 78, 119, 117, 118, 114, 72, 15, 0, + 33, 0, 58, 0, 50, 0, 0, 0, 55, 54, + 56, 57, 70, 100, 404, 0, 88, 89, 69, 45, + 93, 94, 36, 0, 116, 0, 28, 0, 0, 0, + 113, 27, 19, 18, 0, 20, 0, 31, 0, 32, + 0, 0, 21, 0, 0, 0, 22, 23, 35, 37, + 115, 0, 24, 34, 0, 0, 76, 0, 0, 25, + 0, 30, 86, 87, 410, 0, 0, 0, 0, 0, + 0, 0, 49, 112, 0, 111, 107, 108, 109, 104, + 105, 0, 0, 0, 0, 0, 0, 95, 0, 0, + 0, 0, 0, 110, 106, 0, 0, 90, 91, 92, + 0, 0, 0, 0, 84, 51, 0, 0, 0, 73, + 74, 26, 0, 0, 0, 0, 0, 52, 53, 75, + 62, 63, 64, 65, 66, 67, 68, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 85, 78, 119, 117, 118, + 114, 72, 15, 616, 33, 0, 58, 0, 50, 0, + 0, 0, 55, 54, 56, 57, 70, 100, 404, 0, + 88, 89, 69, 45, 93, 94, 36, 0, 116, 0, + 28, 0, 0, 0, 113, 27, 19, 18, 0, 20, + 0, 31, 0, 32, 0, 0, 21, 0, 0, 0, + 22, 23, 35, 37, 115, 0, 24, 34, 0, 0, + 76, 0, 0, 25, 0, 30, 86, 87, 410, 0, + 0, 0, 0, 0, 0, 0, 49, 112, 0, 111, + 107, 108, 109, 104, 105, 0, 0, 0, 0, 0, + 0, 95, 0, 0, 0, 0, 0, 110, 106, 0, + 0, 90, 91, 92, 0, 0, 0, 0, 84, 51, + 0, 0, 0, 73, 74, 26, 0, 0, 0, 0, + 0, 52, 53, 75, 62, 63, 64, 65, 66, 67, + 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 85, + 78, 119, 117, 118, 114, 72, 15, 403, 33, 0, + 58, 0, 50, 0, 0, 0, 55, 54, 56, 57, + 70, 100, 404, 0, 88, 89, 69, 45, 93, 94, + 36, 0, 116, 0, 28, 0, 0, 0, 113, 27, + 19, 18, 0, 20, 0, 31, 0, 32, 0, 0, + 21, 0, 0, 0, 22, 23, 35, 37, 115, 0, + 24, 34, 0, 0, 76, 0, 0, 25, 0, 30, + 86, 87, 410, 0, 0, 0, 0, 0, 0, 0, + 49, 112, 0, 111, 107, 108, 109, 104, 105, 0, + 0, 0, 0, 0, 0, 95, 0, 0, 0, 0, + 0, 110, 106, 0, 0, 90, 91, 92, 0, 0, + 0, 0, 84, 51, 0, 0, 0, 73, 74, 26, + 0, 0, 0, 0, 0, 52, 53, 75, 62, 63, + 64, 65, 66, 67, 68, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 85, 78, 119, 117, 118, 114, 72, + 15, 0, 33, 0, 58, 0, 50, 0, 0, 0, + 55, 54, 56, 57, 70, 100, 88, 89, 69, 45, + 93, 94, 36, 0, 116, 0, 28, 0, 0, 0, + 113, 27, 19, 18, 0, 20, 0, 31, 0, 32, + 0, 0, 21, 0, 0, 0, 22, 23, 35, 219, + 115, 0, 24, 34, 0, 0, 76, 0, 0, 25, + 0, 30, 86, 87, 0, 0, 0, 0, 0, 0, + 0, 0, 49, 112, 0, 111, 107, 108, 109, 104, + 105, 0, 0, 0, 0, 0, 0, 95, 0, 0, + 0, 0, 0, 110, 106, 0, 0, 90, 91, 92, + 0, 0, 0, 0, 84, 51, 0, 0, 0, 73, + 74, 26, 0, 0, 0, 0, 0, 52, 53, 75, + 62, 63, 64, 65, 66, 67, 68, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 85, 78, 119, 117, 118, + 114, 72, 15, 0, 33, 836, 58, 0, 50, 0, + 0, 0, 55, 54, 56, 57, 70, 100, 88, 89, + 69, 45, 93, 94, 36, 0, 116, 0, 28, 0, + 0, 0, 113, 27, 19, 18, 0, 20, 0, 31, + 0, 32, 0, 0, 21, 0, 0, 0, 22, 23, + 35, 219, 115, 0, 24, 34, 0, 0, 76, 0, + 0, 25, 0, 30, 86, 87, 0, 0, 0, 0, + 0, 0, 0, 0, 49, 112, 0, 111, 107, 108, + 109, 104, 105, 0, 0, 0, 0, 0, 0, 95, + 0, 0, 0, 0, 0, 110, 106, 0, 0, 90, + 91, 92, 0, 0, 0, 0, 84, 51, 0, 0, + 0, 73, 74, 26, 0, 0, 0, 0, 0, 52, + 53, 75, 62, 63, 64, 65, 66, 67, 68, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 85, 78, 119, + 117, 118, 114, 72, 15, 0, 33, 933, 58, 0, + 50, 0, 0, 0, 55, 54, 56, 57, 70, 100, + 88, 89, 69, 45, 93, 94, 36, 0, 116, 0, + 28, 0, 0, 0, 113, 27, 19, 18, 0, 20, + 0, 31, 0, 32, 0, 0, 21, 0, 0, 0, + 22, 23, 35, 219, 115, 0, 24, 34, 0, 0, + 76, 0, 0, 25, 0, 30, 86, 87, 0, 0, + 0, 0, 0, 0, 0, 0, 49, 112, 0, 111, + 107, 108, 109, 104, 105, 0, 0, 0, 0, 0, + 0, 95, 0, 0, 0, 0, 0, 110, 106, 0, + 0, 90, 91, 92, 0, 0, 0, 0, 84, 51, + 0, 0, 0, 73, 74, 26, 0, 0, 0, 0, + 0, 52, 53, 75, 62, 63, 64, 65, 66, 67, + 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 85, + 78, 119, 117, 118, 114, 72, 15, 0, 33, 727, + 58, 0, 50, 0, 0, 0, 55, 54, 56, 57, + 70, 100, 88, 89, 69, 45, 93, 94, 36, 0, + 116, 0, 28, 0, 0, 0, 113, 27, 19, 18, + 0, 20, 0, 31, 0, 32, 0, 0, 21, 0, + 0, 0, 22, 23, 35, 219, 115, 0, 24, 34, + 0, 0, 76, 0, 0, 25, 0, 30, 86, 87, + 0, 0, 0, 0, 0, 0, 0, 0, 49, 112, + 0, 111, 107, 108, 109, 104, 105, 0, 0, 0, + 0, 0, 0, 95, 0, 0, 0, 0, 0, 110, + 106, 0, 0, 90, 91, 92, 0, 0, 0, 0, + 84, 51, 0, 0, 0, 73, 74, 26, 0, 0, + 0, 0, 0, 52, 53, 75, 62, 63, 64, 65, + 66, 67, 68, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 85, 78, 119, 117, 118, 114, 72, 15, 0, + 33, 712, 58, 0, 50, 0, 0, 0, 55, 54, + 56, 57, 70, 100, 88, 89, 69, 45, 93, 94, + 36, 0, 116, 0, 28, 0, 0, 0, 113, 27, + 19, 18, 0, 20, 0, 31, 0, 32, 0, 0, + 21, 0, 0, 0, 22, 23, 35, 219, 115, 0, + 24, 34, 0, 0, 76, 0, 0, 25, 0, 30, + 86, 87, 0, 0, 0, 0, 0, 0, 0, 0, + 49, 112, 0, 111, 107, 108, 109, 104, 105, 0, + 0, 0, 0, 0, 0, 95, 0, 0, 0, 0, + 0, 110, 106, 0, 0, 90, 91, 92, 0, 0, + 0, 0, 84, 51, 0, 0, 0, 73, 74, 26, + 0, 0, 0, 0, 0, 52, 53, 75, 62, 63, + 64, 65, 66, 67, 68, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 85, 78, 119, 117, 118, 114, 72, + 15, 0, 33, 695, 58, 0, 50, 0, 0, 0, + 55, 54, 56, 57, 70, 100, 88, 89, 69, 45, + 93, 94, 36, 0, 116, 0, 28, 0, 0, 0, + 113, 27, 19, 18, 0, 20, 0, 31, 0, 32, + 0, 0, 21, 0, 0, 0, 22, 23, 35, 219, + 115, 0, 24, 34, 0, 0, 76, 0, 0, 25, + 0, 30, 86, 87, 0, 0, 0, 0, 0, 0, + 0, 0, 49, 112, 0, 111, 107, 108, 109, 104, + 105, 0, 0, 0, 0, 0, 0, 95, 0, 0, + 0, 0, 0, 110, 106, 0, 0, 90, 91, 92, + 0, 0, 0, 0, 84, 51, 0, 0, 0, 73, + 74, 26, 0, 0, 0, 0, 0, 52, 53, 75, + 62, 63, 64, 65, 66, 67, 68, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 85, 78, 119, 117, 118, + 114, 72, 15, 0, 33, 0, 58, 0, 50, 0, + 0, 0, 55, 54, 56, 57, 70, 100, 133, 134, + 144, 145, 0, 0, 970, 0, 0, 0, 0, 0, + 0, 0, 0, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 179, 180, 181, 182, 183, 171, + 172, 173, 200, 174, 175, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 0, 191, 189, 190, + 186, 187, 0, 0, 178, 184, 185, 192, 193, 195, + 194, 196, 197, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 188, 199, 198, 0, 0, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 146, 147, + 148, 176, 177, 127, 128, 129, 130, 131, 132, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 133, 134, 144, 145, 0, 201, 970, 119, + 117, 118, 0, 0, 0, 997, 0, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 179, 180, + 181, 182, 183, 171, 172, 173, 200, 174, 175, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 0, 191, 189, 190, 186, 187, 0, 0, 178, 184, + 185, 192, 193, 195, 194, 196, 197, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 188, 199, + 198, 0, 0, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 146, 147, 148, 176, 177, 127, 128, 129, + 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 133, 134, 144, 145, + 0, 201, 123, 119, 117, 118, 0, 0, 0, 961, + 0, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 179, 180, 181, 182, 183, 171, 172, 173, + 200, 174, 175, 160, 161, 162, 163, 164, 165, 166, + 167, 168, 169, 170, 0, 191, 189, 190, 186, 187, + 0, 0, 178, 184, 185, 192, 193, 195, 194, 196, + 197, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 188, 199, 198, 0, 0, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 146, 147, 148, 176, + 177, 127, 128, 129, 130, 131, 132, 88, 89, 69, + 0, 93, 94, 225, 0, 116, 0, 0, 0, 0, + 0, 113, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 219, 115, 0, 0, 0, 201, 0, 76, 125, 0, + 0, 0, 122, 86, 87, 0, 0, 0, 0, 0, + 0, 0, 0, 320, 112, 0, 111, 107, 108, 109, + 104, 105, 0, 0, 0, 0, 0, 0, 95, 0, + 0, 0, 0, 0, 110, 106, 0, 319, 90, 91, + 92, 0, 0, 0, 0, 84, 51, 0, 0, 0, + 73, 74, 224, 0, 0, 0, 0, 0, 52, 53, + 75, 62, 63, 64, 65, 66, 67, 68, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 85, 78, 119, 117, + 118, 114, 72, 0, 0, 0, 0, 58, 0, 50, + 0, 0, 318, 55, 54, 56, 57, 70, 100, 88, + 89, 69, 0, 93, 94, 225, 0, 116, 0, 0, + 0, 0, 0, 113, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 805, 0, + 0, 0, 219, 115, 0, 0, 0, 0, 0, 76, + 0, 0, 0, 0, 0, 86, 87, 0, 0, 0, + 0, 0, 0, 0, 0, 49, 112, 0, 111, 107, + 108, 109, 104, 105, 0, 0, 0, 0, 0, 0, + 95, 0, 0, 0, 0, 0, 110, 106, 0, 0, + 90, 91, 92, 0, 0, 0, 0, 84, 51, 0, + 0, 0, 73, 74, 224, 0, 0, 0, 0, 0, + 52, 53, 75, 62, 63, 64, 65, 66, 67, 68, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 85, 78, + 119, 117, 118, 114, 72, 0, 0, 0, 0, 58, + 0, 50, 0, 0, 0, 55, 54, 56, 57, 70, + 100, 88, 89, 69, 0, 93, 94, 225, 0, 116, + 0, 0, 0, 0, 0, 113, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 219, 115, 0, 0, 0, 0, + 0, 76, 0, 0, 0, 0, 0, 86, 87, 0, + 0, 0, 0, 0, 0, 0, 0, 639, 112, 0, + 111, 107, 108, 109, 104, 105, 0, 0, 0, 0, + 0, 0, 95, 0, 0, 0, 0, 0, 110, 106, + 0, 0, 90, 91, 92, 0, 0, 0, 0, 84, + 51, 0, 0, 0, 73, 74, 224, 0, 0, 0, + 0, 0, 52, 53, 75, 62, 63, 64, 65, 66, + 67, 68, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 85, 78, 119, 117, 118, 114, 72, 0, 0, 0, + 0, 58, 0, 50, 0, 0, 638, 55, 54, 56, + 57, 70, 100, 88, 89, 69, 0, 93, 94, 225, + 519, 116, 0, 0, 0, 0, 0, 113, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 219, 115, 0, 0, + 0, 0, 0, 76, 0, 0, 0, 0, 0, 86, + 87, 0, 0, 0, 0, 0, 0, 0, 0, 49, + 112, 0, 111, 107, 108, 109, 104, 105, 0, 0, + 0, 0, 0, 0, 95, 0, 0, 0, 0, 0, + 110, 106, 0, 0, 90, 91, 92, 0, 0, 0, + 0, 84, 51, 0, 0, 0, 73, 74, 224, 0, + 0, 0, 0, 0, 52, 53, 75, 62, 63, 64, + 65, 66, 67, 68, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 85, 78, 119, 117, 118, 114, 72, 0, + 0, 0, 0, 58, 0, 50, 0, 0, 0, 55, + 54, 56, 57, 70, 100, 88, 89, 69, 0, 93, + 94, 225, 0, 116, 0, 0, 0, 0, 0, 113, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 219, 115, + 0, 0, 0, 0, 0, 76, 0, 0, 0, 0, + 0, 86, 87, 0, 0, 0, 0, 0, 0, 0, + 0, 49, 112, 0, 111, 107, 108, 109, 104, 105, + 0, 0, 0, 0, 0, 0, 95, 0, 0, 0, + 0, 0, 110, 106, 0, 0, 90, 91, 92, 0, + 0, 0, 0, 84, 51, 0, 0, 0, 73, 74, + 224, 0, 0, 0, 0, 0, 52, 53, 75, 62, + 63, 64, 65, 66, 67, 68, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 85, 78, 119, 117, 118, 114, + 72, 0, 0, 0, 0, 58, 0, 50, 0, 0, + 478, 55, 54, 56, 57, 70, 100, 88, 89, 69, + 0, 93, 94, 225, 0, 116, 0, 0, 0, 0, + 0, 113, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 219, 115, 0, 0, 0, 0, 0, 76, 0, 0, + 0, 0, 0, 86, 87, 0, 0, 0, 0, 0, + 0, 0, 0, 49, 112, 0, 111, 107, 108, 109, + 104, 105, 0, 0, 0, 0, 0, 0, 95, 0, + 0, 0, 0, 0, 110, 106, 0, 0, 90, 91, + 92, 0, 0, 0, 0, 84, 51, 0, 0, 0, + 73, 74, 224, 0, 0, 0, 0, 0, 52, 53, + 75, 62, 63, 64, 65, 66, 67, 68, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 85, 78, 119, 117, + 118, 114, 72, 0, 0, 0, 456, 58, 0, 50, + 0, 0, 0, 55, 54, 56, 57, 70, 100, 88, + 89, 69, 0, 93, 94, 225, 0, 116, 0, 0, + 0, 0, 0, 113, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 219, 115, 0, 0, 0, 0, 0, 76, + 0, 0, 0, 0, 0, 86, 87, 0, 0, 0, + 0, 0, 0, 0, 0, 49, 112, 0, 111, 107, + 108, 109, 104, 105, 0, 0, 0, 0, 0, 0, + 95, 0, 0, 0, 0, 0, 110, 106, 0, 0, + 90, 91, 92, 0, 0, 0, 0, 84, 51, 0, + 0, 0, 73, 74, 224, 0, 0, 0, 0, 0, + 52, 53, 75, 62, 63, 64, 65, 66, 67, 68, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 85, 78, + 119, 117, 118, 114, 72, 0, 0, 0, 0, 58, + 0, 50, 0, 0, 0, 55, 54, 56, 57, 70, + 100, 133, 134, 144, 145, 0, 0, 958, 0, 0, + 0, 0, 0, 0, 0, 0, 149, 150, 151, 152, + 153, 154, 155, 156, 157, 158, 159, 179, 180, 181, + 182, 183, 171, 172, 173, 200, 174, 175, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 0, + 191, 189, 190, 186, 187, 0, 0, 178, 184, 185, + 192, 193, 195, 194, 196, 197, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 188, 199, 198, + 0, 0, 135, 136, 137, 138, 139, 140, 141, 142, + 143, 146, 147, 148, 176, 177, 127, 128, 129, 130, + 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 133, 134, 144, 145, + 0, 0, 1016, 0, 0, 0, 0, 0, 0, 0, + 201, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 179, 180, 181, 182, 183, 171, 172, 173, + 200, 174, 175, 160, 161, 162, 163, 164, 165, 166, + 167, 168, 169, 170, 0, 191, 189, 190, 186, 187, + 0, 0, 178, 184, 185, 192, 193, 195, 194, 196, + 197, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 188, 199, 198, 0, 0, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 146, 147, 148, 176, + 177, 858, 859, 860, 857, 856, 855, 241, 243, 242, + 265, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 267, 264, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 201, 0, 0, 0, 0, + 239, 240, 251, 254, 255, 256, 257, 258, 259, 261, + 263, 0, 0, 0, 0, 0, 0, 0, 241, 243, + 242, 265, 0, 0, 0, 0, 799, 266, 245, 249, + 248, 0, 0, 0, 0, 0, 244, 0, 246, 250, + 252, 253, 260, 262, 247, 267, 264, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 239, 240, 251, 254, 255, 256, 257, 258, 259, + 261, 263, 0, 0, 0, 0, 0, 0, 0, 241, + 243, 242, 265, 0, 0, 764, 0, 0, 266, 245, + 249, 248, 0, 0, 0, 0, 0, 244, 0, 246, + 250, 252, 253, 260, 262, 247, 267, 264, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 239, 240, 251, 254, 255, 256, 257, 258, + 259, 261, 263, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 739, 241, 243, 242, 265, 0, 0, 266, + 245, 249, 248, 0, 0, 0, 0, 0, 244, 0, + 246, 250, 252, 253, 260, 262, 247, 0, 0, 0, + 267, 264, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 239, 240, 251, 254, + 255, 256, 257, 258, 259, 261, 263, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 737, 241, 243, 242, + 265, 0, 0, 266, 245, 249, 248, 0, 0, 0, + 0, 0, 244, 0, 246, 250, 252, 253, 260, 262, + 247, 0, 0, 0, 267, 264, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 239, 240, 251, 254, 255, 256, 257, 258, 259, 261, + 263, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 728, 241, 243, 242, 265, 0, 0, 266, 245, 249, + 248, 0, 0, 0, 0, 0, 244, 0, 246, 250, + 252, 253, 260, 262, 247, 0, 0, 0, 267, 264, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 239, 240, 251, 254, 255, 256, + 257, 258, 259, 261, 263, 0, 0, 0, 0, 0, + 0, 0, 241, 243, 242, 265, 0, 0, 724, 0, + 0, 266, 245, 249, 248, 0, 0, 0, 0, 0, + 244, 0, 246, 250, 252, 253, 260, 262, 247, 267, + 264, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 239, 240, 251, 254, 255, + 256, 257, 258, 259, 261, 263, 0, 0, 0, 0, + 0, 0, 0, 241, 243, 242, 265, 0, 0, 723, + 0, 0, 266, 245, 249, 248, 0, 0, 0, 0, + 0, 244, 0, 246, 250, 252, 253, 260, 262, 247, + 267, 264, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 239, 240, 251, 254, + 255, 256, 257, 258, 259, 261, 263, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 673, 241, 243, 242, + 265, 0, 0, 266, 245, 249, 248, 0, 0, 0, + 0, 0, 244, 0, 246, 250, 252, 253, 260, 262, + 247, 0, 0, 0, 267, 264, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 239, 240, 251, 254, 255, 256, 257, 258, 259, 261, + 263, 0, 0, 0, 0, 0, 0, 0, 241, 243, + 242, 265, 0, 0, 672, 0, 0, 266, 245, 249, + 248, 0, 0, 0, 0, 0, 244, 0, 246, 250, + 252, 253, 260, 262, 247, 267, 264, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 239, 240, 251, 254, 255, 256, 257, 258, 259, + 261, 263, 0, 0, 0, 0, 0, 0, 0, 241, + 243, 242, 265, 0, 0, 671, 0, 0, 266, 245, + 249, 248, 0, 0, 0, 0, 0, 244, 0, 246, + 250, 252, 253, 260, 262, 247, 267, 264, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 239, 240, 251, 254, 255, 256, 257, 258, + 259, 261, 263, 0, 0, 0, 0, 0, 0, 0, + 241, 243, 242, 265, 0, 0, 668, 0, 0, 266, + 245, 249, 248, 0, 0, 0, 0, 0, 244, 0, + 246, 250, 252, 253, 260, 262, 247, 267, 264, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 239, 240, 251, 254, 255, 256, 257, + 258, 259, 261, 263, 0, 0, 0, 0, 0, 0, + 0, 241, 243, 242, 265, 0, 0, 666, 0, 0, + 266, 245, 249, 248, 0, 0, 0, 0, 0, 244, + 0, 246, 250, 252, 253, 260, 262, 247, 267, 264, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 239, 240, 251, 254, 255, 256, + 257, 258, 259, 261, 263, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 651, 241, 243, 242, 265, 0, + 0, 266, 245, 249, 248, 0, 0, 0, 0, 0, + 244, 0, 246, 250, 252, 253, 260, 262, 247, 0, + 0, 0, 267, 264, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 239, 240, + 251, 254, 255, 256, 257, 258, 259, 261, 263, 0, + 0, 0, 0, 0, 0, 0, 241, 243, 242, 265, + 0, 0, 641, 0, 0, 266, 245, 249, 248, 0, + 0, 0, 0, 0, 244, 0, 246, 250, 252, 253, + 260, 262, 247, 267, 264, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 239, + 240, 251, 254, 255, 256, 257, 258, 259, 261, 263, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 630, + 241, 243, 242, 265, 614, 0, 266, 245, 249, 248, + 0, 0, 0, 0, 0, 244, 0, 246, 250, 252, + 253, 260, 262, 247, 0, 0, 0, 267, 264, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 239, 240, 251, 254, 255, 256, 257, + 258, 259, 261, 263, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 241, 243, 242, 265, 628, 0, 0, + 266, 245, 249, 248, 0, 0, 0, 0, 0, 244, + 0, 246, 250, 252, 253, 260, 262, 247, 0, 0, + 267, 264, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 239, 240, 251, 254, + 255, 256, 257, 258, 259, 261, 263, 0, 0, 0, + 0, 0, 0, 0, 241, 243, 242, 265, 0, 0, + 0, 0, 0, 266, 245, 249, 248, 0, 0, 0, + 0, 0, 244, 0, 246, 250, 252, 253, 260, 262, + 247, 267, 264, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 239, 240, 251, + 254, 255, 256, 257, 258, 259, 261, 263, 0, 0, + 0, 0, 0, 0, 0, 241, 243, 242, 265, 610, + 0, 0, 0, 0, 266, 245, 249, 248, 0, 0, + 0, 0, 0, 244, 0, 246, 250, 252, 253, 260, + 262, 247, 267, 264, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 239, 240, + 251, 254, 255, 256, 257, 258, 259, 261, 263, 0, + 0, 0, 0, 0, 0, 0, 241, 243, 242, 265, + 0, 0, 605, 0, 0, 266, 245, 249, 248, 0, + 0, 0, 0, 0, 244, 0, 246, 250, 252, 253, + 260, 262, 247, 267, 264, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 239, + 240, 251, 254, 255, 256, 257, 258, 259, 261, 263, + 0, 0, 0, 0, 0, 0, 0, 241, 243, 242, + 265, 0, 0, 601, 0, 0, 266, 245, 249, 248, + 0, 0, 0, 0, 0, 244, 0, 246, 250, 252, + 253, 260, 262, 247, 267, 264, 0, 0, 0, 503, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 239, 240, 251, 254, 255, 256, 257, 258, 259, 261, + 263, 0, 0, 0, 0, 0, 0, 0, 241, 243, + 242, 265, 0, 0, 509, 0, 0, 266, 245, 249, + 248, 0, 0, 0, 0, 0, 244, 0, 246, 250, + 252, 253, 260, 262, 247, 267, 264, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 239, 240, 251, 254, 255, 256, 257, 258, 259, + 261, 263, 0, 0, 0, 0, 0, 0, 0, 241, + 243, 242, 265, 0, 0, 0, 0, 0, 266, 245, + 249, 248, 0, 0, 0, 0, 0, 244, 0, 246, + 250, 252, 253, 260, 262, 247, 267, 264, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 239, 240, 251, 254, 255, 256, 257, 258, + 259, 261, 263, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 238, 241, 243, 242, 265, 0, 266, + 245, 249, 248, 0, 0, 0, 0, 0, 244, 0, + 246, 250, 252, 253, 260, 262, 247, 0, 0, 0, + 0, 267, 264, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 239, 240, 251, + 254, 255, 256, 257, 258, 259, 261, 263, 0, 0, + 0, 0, 0, 0, 0, 0, 243, 242, 265, 0, + 0, 0, 0, 0, 266, 245, 249, 248, 0, 0, + 0, 0, 0, 244, 0, 246, 250, 252, 253, 260, + 262, 247, 267, 264, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 239, 240, + 251, 254, 255, 256, 257, 258, 259, 261, 263, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 242, 265, + 0, 0, 0, 0, 0, 266, 245, 249, 248, 0, + 0, 0, 0, 0, 244, 0, 246, 250, 252, 253, + 260, 262, 247, 267, 264, 0, 0, 0, 521, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 239, + 240, 251, 254, 255, 256, 257, 258, 259, 261, 263, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 265, 0, 0, 0, 0, 0, 266, 245, 249, 248, + 0, 0, 0, 0, 0, 244, 0, 246, 250, 252, + 253, 260, 262, 247, 267, 264, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 239, 240, 251, 254, 255, 256, 257, 258, 259, 261, + 263, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 265, 0, 0, 0, 0, 0, 266, 245, 249, + 248, 0, 0, 0, 0, 0, 244, 0, 246, 250, + 252, 253, 260, 262, 247, 267, 264, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 239, 240, 251, 254, 255, 256, 257, 258, 259, + 261, 263, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 265, 0, 0, 0, 0, 0, 266, 245, + 249, 248, 0, 0, 0, 0, 0, 244, 0, 246, + 250, 252, 253, 260, 262, 247, 267, 264, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 239, 240, 251, 254, 255, 256, 257, 258, + 259, 261, 263, 0, 265, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 245, 249, 248, 0, 0, 0, 0, 0, 244, 264, + 246, 250, 252, 253, 260, 262, 247, 0, 0, 0, + 0, 0, 0, 0, 0, 240, 251, 254, 255, 256, + 257, 258, 259, 261, 263, 0, 265, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 245, 249, 248, 0, 0, 0, 0, 0, + 244, 264, 246, 250, 252, 253, 260, 262, 247, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 251, 254, + 255, 256, 257, 258, 259, 261, 263, 0, 265, 0, + 225, 0, 116, 0, 0, 0, 0, 0, 113, 0, + 0, 0, 0, 0, 245, 249, 248, 0, 0, 0, + 0, 0, 244, 264, 246, 250, 252, 253, 260, 262, + 247, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 251, 254, 255, 256, 257, 258, 259, 261, 263, 265, + 708, 112, 0, 111, 107, 108, 109, 104, 105, 0, + 0, 0, 0, 0, 0, 0, 245, 249, 248, 0, + 0, 110, 106, 0, 264, 0, 0, 250, 252, 253, + 260, 262, 247, 0, 0, 0, 0, 0, 0, 327, + 0, 251, 254, 255, 256, 257, 258, 259, 261, 263, + 0, 0, 0, 225, 0, 116, 0, 0, 0, 0, + 0, 113, 0, 0, 0, 0, 0, 0, 249, 248, + 0, 0, 0, 0, 0, 0, 0, 0, 250, 252, + 253, 260, 262, 247, 0, 119, 117, 118, 114, 0, + 0, 0, 0, 0, 324, 0, 709, 0, 0, 707, + 0, 0, 0, 0, 112, 100, 111, 107, 108, 109, + 104, 105, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 110, 106, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 327, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 119, 117, + 118, 114, 0, 0, 0, 0, 0, 324, 0, 328, + 0, 0, 0, 0, 0, 0, 0, 0, 100, +} +var yyPact = [...]int{ + + -1000, -1000, 1825, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + 225, 5632, 544, -1000, 760, -1000, -1000, -1000, 223, 5202, + 220, 215, 6705, 6705, 6705, 162, 644, 6705, -1000, 8371, + 211, 209, 205, -1000, 403, 795, 248, 38, 642, 596, + 594, 620, 1344, -1000, -1000, 204, -1000, -1000, 268, 187, + 5733, 6705, 9083, 9083, 6705, 6705, 6705, 6705, 6705, -1000, + -1000, -1000, 6705, 6705, 6705, 6705, 6705, 6705, 6705, 186, + 6705, -1000, 879, 6705, 6705, 6705, 6705, -1000, 519, -1000, + -1000, 512, -1000, -1000, 413, 185, 184, 181, 6705, 6705, + 180, 6705, 6705, -1000, -1000, 797, -1000, -1000, -1000, -1000, + 141, 188, 188, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, 161, -1000, 829, 38, -1000, -1000, -1000, -1000, + 125, 261, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, 0, 566, 665, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1, -1000, -44, 4066, 6705, 683, 578, 38, + 6705, 6705, 324, 8436, 578, -1000, 320, 316, -2, -1000, + -1000, -3, -1000, -1000, -47, -9, -1000, 8436, -1000, 6705, + 6705, 6705, 6705, 6705, 6705, 6705, 6705, 6705, 6705, 6705, + 6705, 6705, 6705, 6705, 6705, 6705, 6705, 6705, 6705, 6705, + 6705, 6705, 6705, 6705, 6705, 748, 6543, 6705, 9083, 6705, + 760, -1000, 315, -1000, 788, -1000, -1000, 38, -1000, 607, + 772, 770, 539, -1000, -1000, -1000, 203, 5202, 201, 312, + 241, 6381, 6705, 6705, 6705, 6705, 6705, 6705, 6705, 6705, + 6705, 6705, 6705, 6705, 6705, -1000, -1000, 6705, 6705, 6705, + 116, 116, 5733, 52, 13, -1000, -1000, 8310, 9083, 6705, + 198, -1000, -1000, -1000, 6705, -1000, -1000, -1000, 5733, -1000, + 444, 444, 479, 444, 8249, 444, 444, 444, 444, 444, + 444, 444, -1000, 6705, 444, 391, 782, 735, -1000, 226, + 6219, 9083, 8680, 8619, 8680, 8436, 12, -1000, 188, -1000, + 1987, 188, -1000, 510, 253, 6705, 600, -1000, 411, 6705, + 6705, 6705, 8436, 8436, 6705, 8436, 8436, 714, -1000, 742, + 6705, -1000, -1000, 1171, -1000, 5733, 581, 782, 196, 306, + -1000, -1000, 1661, -1000, 566, -12, 648, 402, 763, -1000, + 760, 6705, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + 195, 8188, 193, -1000, 302, 11, 8436, 8127, -1000, -1000, + -1000, -1000, 162, -1000, 715, 6705, -1000, 6705, 8793, 8845, + 8497, 8680, 8558, 55, 8948, 8897, 227, 14, 14, 479, + 444, 479, 479, 349, 349, 1452, 1452, 1452, 1452, 356, + 356, 356, 356, 1452, -1000, 8066, 6705, 8741, 10, -1000, + -1000, 8005, -18, 3902, -1000, 192, 191, 743, 734, 394, + 588, -1000, 6705, -1000, 6705, -1000, -1000, 8680, 6705, 8680, + 8680, 8680, 8680, 8680, 8680, 8680, 8680, 8680, 8680, 8680, + 8680, 8680, 7942, 51, 7878, 188, -1000, 6705, -1000, 188, + 123, -49, 5733, 6057, -1000, 8436, 5733, 7817, 49, -1000, + 122, -1000, -1000, -1000, -1000, 170, 733, 730, 7753, 56, + 342, 6705, 519, 48, -1000, 188, -1000, -1000, -1000, 6705, + -1000, -1000, -1000, -1000, 162, 6705, 6705, 116, 116, 162, + 7692, 188, 7631, 7, -1000, 8436, 7570, 7509, -1000, -1000, + 7445, -1000, 6, -1000, 8436, 6705, 239, -1000, -1000, 187, + 6705, 186, 6705, 6705, 6705, 578, 413, 185, 184, 181, + 6705, 6705, 180, 6705, 6705, 38, 161, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, 38, 121, -1000, 411, -1000, + 1497, -1000, -1000, 663, -1000, 393, 618, -1000, -1000, 8436, + 120, 5040, 6705, 6705, 6705, 183, -1000, -1000, 8436, -1000, + 6705, 8741, 119, 9083, 8980, 4878, -1000, 411, 411, 136, + 586, -1000, 385, 528, 7384, 7323, 3738, 8948, 4716, -1000, + -1000, -1000, 7259, -1000, -50, 6705, -1000, 8436, 9083, 135, + 117, -1000, -1000, -1000, 47, -1000, -1000, 710, -1000, -1000, + -1000, -1000, -1000, 6705, -1000, 8680, -1000, -1000, -1000, 7195, + -1000, 46, 7131, -1000, -1000, -1000, -1000, 586, 383, 114, + 6705, -1000, -1000, -1000, 84, 1333, 8436, 6705, -1000, 83, + 4, -1000, 497, -1000, 489, 335, 3, -1000, -1000, 489, + 655, -1000, 301, -1000, -1000, -1000, 7070, 299, 8436, -1000, + 297, 294, 8741, 293, -1000, 82, 550, 9083, 134, 5733, + -1000, -1000, -1000, 658, 81, 79, 411, 568, 528, 470, + -1000, -10, -1000, 5202, 238, 292, -1000, -1000, -1000, 6705, + 8680, -1000, 5733, -50, -1000, -1000, 7009, -1000, -1000, -1000, + 568, 5895, -1000, -1000, -1000, -1000, 8436, 171, -1000, 411, + 404, -1000, -1000, -1000, 330, 1, -1000, 290, -1000, 618, + -1000, 724, -1000, 3574, 289, 6705, 372, -1000, 791, -1000, + -1000, 4392, 8980, -1000, 5733, 44, 3410, -1000, -1000, 382, + 129, 171, 589, 78, 375, 528, -1000, -1000, -1000, 969, + 528, 451, 528, -1000, -1000, -1000, 4230, 8680, 77, 329, + 374, 59, -4, -1000, 548, -5, -6, 8436, -1000, 485, + -1000, 41, -1000, -29, 688, -33, -1000, -1000, -1000, 286, + -1000, 489, -1000, -1000, -1000, 285, -1000, 76, -1000, 6705, + 133, 357, 284, 745, -1000, -1000, -1000, 68, -1000, 65, + -1000, 280, -1000, 528, 368, 171, 128, 171, -1000, -10, + 404, 680, 844, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -30, -1000, -1000, 4230, -50, -1000, -1000, -1000, -1000, + 5895, 6705, 538, -1000, -1000, 6705, 535, -1000, -34, 764, + -35, -1000, -1000, 501, -1000, 688, -1000, 688, -1000, -1000, + -1000, 4554, 961, -1000, -1000, -1000, -1000, -1000, 275, 3246, + 4392, -1000, -1000, 3082, 104, -1000, -1000, 364, 169, 361, + 390, 715, 6867, 38, -1000, -1000, -1000, 5498, 362, -1000, + 8436, 6705, 8436, 6705, 764, -1000, 764, 715, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, 4230, -1000, 270, -1000, -1000, + 64, 528, -1000, 2918, -1000, 63, -7, -1000, -1000, 715, + -1000, -1000, -22, -1000, -53, -25, -1000, -55, -1000, -1000, + 6867, -1000, 5364, -1000, 265, 263, 601, 638, 258, -1000, + -1000, -1000, 8436, 8436, -1000, -1000, -62, 2754, 4230, -1000, + 350, -1000, -1000, 2590, -1000, -1000, 169, -1000, 2426, -1000, + 715, -1000, 6705, -1000, 6867, 6705, 57, -1000, -1000, -1000, + -1000, 528, 6992, 6867, 6705, 256, -1000, -1000, -1000, -1000, + -1000, 8436, -1000, 8436, 411, -10, -1000, -1000, 6867, -1000, + 8436, -1000, 2262, -1000, -1000, 58, -1000, -1000, 171, 233, + -1000, -1000, -1000, 2098, -1000, +} +var yyPgo = [...]int{ + + 0, 1041, 1039, 53, 10, 32, 17, 78, 72, 1038, + 80, 15, 724, 1037, 46, 155, 95, 94, 81, 70, + 47, 1035, 37, 1033, 0, 87, 8, 1031, 1030, 1028, + 38, 380, 29, 33, 1026, 1025, 62, 1024, 45, 1012, + 5, 1010, 1002, 1001, 999, 13, 49, 992, 987, 50, + 986, 88, 763, 985, 983, 35, 982, 979, 2, 976, + 975, 41, 376, 54, 48, 974, 972, 970, 969, 966, + 965, 114, 962, 960, 959, 9, 954, 85, 953, 951, + 950, 949, 940, 936, 933, 931, 929, 27, 61, 21, + 928, 925, 921, 917, 117, 11, 110, 905, 83, 904, + 903, 42, 34, 900, 12, 899, 3, 898, 30, 885, + 16, 60, 96, 40, 882, 880, 878, 14, 877, 870, + 103, 82, 868, 39, 31, 866, 865, 862, 858, 855, + 18, 854, 853, 852, 842, 840, 43, 838, 100, 4, + 26, 587, 831, 36, 829, 79, 7, 20, 828, 817, + 808, 807, 801, 1, 19, 755, 6, +} +var yyR1 = [...]int{ + + 0, 155, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 5, 5, 5, 5, 5, 5, 5, 6, 6, + 7, 7, 10, 10, 9, 9, 8, 145, 145, 97, + 97, 97, 96, 96, 98, 98, 14, 14, 14, 14, + 136, 136, 137, 137, 138, 154, 154, 153, 153, 13, + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, + 13, 13, 13, 12, 12, 86, 86, 93, 92, 92, + 91, 90, 90, 94, 94, 87, 87, 89, 89, 88, + 88, 77, 77, 146, 146, 21, 21, 21, 21, 21, + 21, 21, 15, 15, 15, 15, 15, 15, 15, 15, + 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, + 15, 15, 15, 15, 15, 133, 133, 134, 74, 74, + 29, 29, 122, 122, 30, 16, 16, 1, 1, 2, + 2, 152, 152, 151, 151, 111, 111, 17, 18, 19, + 123, 123, 125, 125, 124, 124, 140, 140, 140, 140, + 118, 118, 117, 117, 28, 28, 115, 115, 115, 115, + 143, 143, 143, 11, 11, 119, 119, 85, 85, 76, + 76, 99, 99, 80, 80, 26, 26, 27, 27, 135, + 135, 135, 135, 32, 32, 103, 103, 103, 104, 104, + 108, 108, 108, 105, 105, 109, 109, 107, 107, 107, + 110, 110, 106, 106, 112, 112, 78, 78, 33, 33, + 33, 35, 35, 36, 37, 37, 38, 38, 147, 147, + 39, 39, 39, 39, 75, 75, 114, 114, 114, 144, + 144, 40, 40, 41, 42, 42, 42, 42, 44, 44, + 43, 116, 116, 149, 149, 148, 148, 150, 150, 139, + 139, 139, 139, 139, 139, 79, 79, 45, 45, 84, + 84, 95, 20, 73, 73, 46, 22, 22, 23, 23, + 48, 47, 47, 127, 128, 128, 129, 131, 131, 132, + 132, 130, 130, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, + 34, 34, 121, 121, 120, 120, 156, 3, 3, 126, + 126, 81, 82, 82, 58, 58, 59, 59, 59, 50, + 50, 49, 49, 51, 51, 51, 56, 56, 142, 142, + 142, 113, 113, 64, 64, 64, 64, 57, 57, 57, + 57, 57, 57, 57, 57, 63, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 24, 24, 25, 25, 65, + 65, 65, 65, 66, 66, 67, 67, 67, 68, 68, + 68, 68, 68, 68, 31, 31, 31, 31, 52, 52, + 52, 69, 70, 70, 70, 70, 70, 70, 70, 60, + 60, 60, 61, 61, 61, 55, 101, 101, 54, 54, + 100, 100, 100, 100, 100, 100, 100, 141, 141, 141, + 141, 71, 71, 71, 71, 71, 71, 71, 71, 72, + 72, 72, 72, 53, 53, 53, 53, 53, 53, 53, + 83, 83, 102, +} +var yyR2 = [...]int{ + + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 0, 1, 0, 1, 1, 2, 0, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 1, 3, 4, 1, 2, 0, 1, 1, + 1, 1, 1, 1, 1, 4, 3, 5, 4, 3, + 4, 1, 3, 1, 1, 8, 7, 2, 3, 1, + 2, 3, 1, 3, 1, 1, 2, 1, 3, 1, + 3, 3, 1, 2, 0, 1, 1, 1, 1, 1, + 1, 4, 3, 1, 1, 5, 7, 9, 5, 3, + 3, 3, 3, 3, 3, 1, 2, 6, 7, 9, + 5, 1, 6, 3, 2, 0, 2, 8, 1, 3, + 0, 4, 1, 3, 1, 10, 11, 0, 1, 0, + 1, 0, 1, 1, 2, 1, 1, 9, 6, 7, + 0, 2, 0, 2, 0, 2, 1, 2, 4, 3, + 1, 4, 1, 4, 1, 4, 3, 4, 4, 5, + 0, 5, 4, 1, 1, 1, 4, 5, 6, 1, + 3, 6, 7, 3, 6, 2, 0, 1, 3, 0, + 1, 1, 1, 6, 8, 1, 2, 1, 1, 1, + 1, 1, 1, 3, 3, 3, 3, 1, 2, 1, + 0, 1, 0, 2, 2, 4, 1, 3, 1, 2, + 3, 3, 1, 1, 3, 1, 1, 3, 2, 0, + 5, 5, 10, 3, 1, 3, 1, 2, 3, 1, + 2, 2, 2, 3, 3, 3, 4, 3, 1, 1, + 3, 1, 3, 1, 1, 0, 1, 1, 2, 1, + 1, 1, 1, 1, 1, 3, 1, 2, 4, 3, + 1, 4, 4, 3, 1, 1, 0, 1, 3, 1, + 8, 3, 2, 2, 3, 1, 7, 0, 2, 1, + 3, 3, 4, 6, 5, 3, 4, 2, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 2, 2, 2, 2, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 2, 2, 2, 2, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 1, 1, 5, + 4, 3, 1, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 1, 3, 2, 1, 2, 4, 2, 2, + 1, 2, 1, 2, 11, 9, 0, 0, 1, 0, + 4, 2, 3, 1, 1, 2, 2, 4, 2, 1, + 1, 1, 1, 1, 1, 3, 0, 3, 0, 1, + 1, 0, 1, 4, 3, 1, 3, 1, 1, 3, + 2, 3, 1, 1, 1, 3, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, + 3, 1, 1, 1, 1, 1, 3, 1, 1, 4, + 4, 4, 4, 1, 1, 1, 3, 3, 1, 4, + 2, 3, 1, 4, 4, 3, 3, 3, 3, 1, + 3, 1, 1, 3, 1, 1, 0, 1, 3, 1, + 3, 1, 4, 2, 2, 6, 4, 2, 2, 1, + 2, 1, 4, 3, 3, 3, 3, 6, 3, 1, + 1, 2, 1, 5, 4, 2, 2, 4, 2, 2, + 1, 3, 1, +} +var yyChk = [...]int{ + + -1000, -155, -145, -13, 2, -15, -16, -17, -18, -19, + 52, 80, 45, -86, 39, 150, -76, -80, 21, 20, + 23, 30, 34, 35, 40, 47, 99, 19, 14, -24, + 49, 25, 27, 152, 41, 36, 10, 37, -154, -153, + -85, -99, -31, -34, -138, 7, -68, -69, -66, 60, + 156, 93, 105, 106, 161, 160, 162, 163, 154, -47, + -129, -53, 108, 109, 110, 111, 112, 113, 114, 6, + 164, -57, 149, 97, 98, 107, 44, -121, 144, -52, + -59, -50, -65, -62, 92, 143, 50, 51, 4, 5, + 85, 86, 87, 8, 9, 75, -64, -63, -120, -8, + 165, -14, -67, -49, 67, 68, 82, 64, 65, 66, + 81, 63, 61, 18, 148, 38, 12, 146, 147, 145, + 154, -97, 150, 10, -5, 146, -4, 99, 100, 101, + 102, 103, 104, 4, 5, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 6, 7, 94, 95, 96, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 35, 36, 37, 39, 40, 97, 98, 60, 30, + 31, 32, 33, 34, 61, 62, 56, 57, 80, 54, + 55, 53, 63, 64, 66, 65, 67, 68, 82, 81, + 38, 143, -94, -12, -98, -88, 37, 39, -96, 147, + 10, 146, -77, -20, 10, -146, 154, -15, -154, 37, + 154, 154, -25, -24, 99, 10, -25, -25, -35, -36, + -52, -37, -121, -38, -8, -73, -46, -24, 152, 131, + 132, 88, 90, 89, 167, 159, 169, 175, 161, 160, + 170, 133, 171, 172, 134, 135, 136, 137, 138, 139, + 173, 140, 174, 141, 116, 91, 158, 115, 154, 154, + 154, 150, 10, 153, -3, 159, -138, 37, -120, -152, + 54, 55, -151, -111, 100, 101, 94, 95, 94, 96, + 95, 168, 118, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 105, 106, 154, 156, 150, + 58, 142, 154, -55, -54, -101, -100, -24, 159, 84, + 60, -24, -31, -62, 154, -64, -63, 99, 156, -31, + -24, -24, -24, -24, -24, -24, -24, -24, -24, -24, + -24, -24, -56, 154, -24, -142, 17, -141, -71, -8, + 77, 78, -24, -24, -24, -24, -137, -136, -49, -14, + 79, -51, -48, -49, -70, 154, -153, -52, -154, 154, + 154, 154, -24, -24, 154, -24, -24, 17, 76, -141, + 150, -52, -112, 154, -112, 154, -141, 17, -3, 155, + 152, 150, -145, 152, 166, -94, -98, 83, 29, 152, + 166, 168, -21, 151, 2, -15, -16, -17, -18, -19, + 52, -24, 21, -3, -22, -23, -24, -24, 152, 152, + 152, 152, 166, 152, 166, 168, 152, 166, -24, -24, + -24, -24, -24, -24, -24, -24, -24, -24, -24, -24, + -24, -24, -24, -24, -24, -24, -24, -24, -24, -24, + -24, -24, -24, -24, -51, -24, 153, -24, -122, -30, + -31, -24, -77, -146, 152, 10, -156, -3, 53, 10, + 10, -111, 154, -15, 154, 152, 153, -24, 159, -24, + -24, -24, -24, -24, -24, -24, -24, -24, -24, -24, + -24, -24, -24, -25, -24, -61, 10, 150, -52, -61, + -55, 157, 166, 59, -31, -24, 154, -24, -55, 155, + -25, 149, -71, -71, 17, 156, 58, 142, -24, 11, + -31, 59, 166, -10, -112, -60, -7, -52, -6, 150, + 10, -5, -113, -112, 79, 156, 150, 58, 142, 79, + -24, 53, -24, -83, -102, -24, -24, -24, 76, 76, + -24, 155, -78, -33, -24, 84, -7, 10, -5, 60, + 93, 6, 97, 98, 44, 99, 92, 143, 50, 51, + 4, 5, 85, 86, 87, 37, 61, 63, 64, 66, + 65, 67, 68, 82, 81, 38, -55, 148, 154, 152, + -145, 151, -88, -98, 152, 83, 150, 10, -20, -24, + 154, 155, 154, 152, 166, 155, -36, -38, -24, -46, + 153, -24, -10, 166, 29, 155, 151, 154, 154, 10, + 10, 150, -125, 56, -24, -24, -146, -24, 155, 157, + 151, -112, -24, -112, 155, 168, -101, -24, 159, 60, + -55, 155, 157, 155, -72, 10, 13, 160, -8, 10, + 10, 151, 151, 156, 151, -24, -136, 157, -112, -24, + -52, -25, -24, -61, -61, -52, 155, -113, 155, -10, + 166, 155, 155, 151, -10, 166, -24, 153, 155, -26, + -27, -32, -153, 151, 150, -93, -92, -87, -89, -12, + -96, -156, 155, -119, -15, 153, -24, -22, -24, -115, + 150, 153, -24, 155, -30, -140, -31, 159, 60, 156, + -28, -15, 153, -133, -26, -26, 154, -123, 56, -147, + 150, -75, -14, 155, 155, 96, -15, 153, 151, 168, + -24, -31, 154, 155, 157, 13, -24, 151, 157, 151, + -123, 150, 155, -102, 155, -33, -24, 155, -10, 166, + -135, 104, 103, 102, -91, -90, -89, 151, -10, 166, + -89, 29, 152, -146, 155, 152, -143, 152, -143, 152, + 152, 155, 59, -31, 154, -55, -146, -29, -134, 43, + 42, 155, 155, -26, -124, 57, -14, 151, -39, -153, + 45, -147, 166, -15, 153, 152, -146, -24, -55, 157, + -124, -131, -132, -130, -127, 33, -128, -24, -106, 153, + -32, -110, -107, -108, 158, -109, 61, 62, -14, 151, + -10, 166, 152, -87, 10, 22, 152, -22, 151, 32, + 33, -143, 31, -143, -117, -15, 153, -140, -31, -55, + 157, 28, 150, 154, -106, -126, 45, 155, 150, -75, + -149, -148, -150, 48, -139, 104, 103, 102, 99, 100, + 101, -75, 151, -14, -146, 155, 151, 150, 151, -10, + 166, 59, -10, 166, -10, 166, -156, -103, -104, 158, + -105, -108, 99, -1, 159, 167, -108, 167, 152, -89, + 152, 155, -24, -11, 153, 152, 151, 152, 31, -146, + 155, 155, 152, -146, -74, -14, 150, -106, 154, -106, + -147, -110, 39, 37, -139, -114, 152, 150, -147, -130, + -24, 59, -24, 59, 167, -104, 167, -2, 84, -108, + -108, -118, -15, 153, -11, -146, 152, 26, -117, 151, + -9, 167, -8, -146, 150, -81, -82, -58, -8, 159, + 150, 151, -79, -45, -8, -84, -95, -6, 10, -5, + -3, 151, -144, -40, -41, -42, -43, -44, -14, -6, + 10, 151, -24, -24, -104, -104, -8, -146, -146, 152, + 155, -14, 151, -146, 155, -10, 166, -8, -146, 152, + 166, -156, 168, 152, 166, 168, -6, 151, -40, 152, + 152, 46, 29, 79, 168, 24, 150, 151, -58, 151, + -45, -24, -95, -24, 154, -75, 10, -4, -139, -6, + -24, 152, -146, -156, -156, -26, -6, 151, 155, -106, + -116, 152, 150, -146, 151, +} +var yyDef = [...]int{ + + 88, -2, -2, 87, 109, 110, 111, 112, 113, 114, + 0, 0, 0, 121, 0, 144, 153, 154, 0, 0, + 0, 0, 477, 477, 477, 0, 441, 0, 165, 0, + 0, 0, 0, 171, 0, 0, 96, 427, 108, 191, + 229, 0, -2, 476, 105, 0, -2, 495, 0, 0, + 516, 0, 0, 0, 0, 0, 0, 0, 0, 397, + 398, 402, 0, 0, 0, 0, 0, 0, 0, 446, + 0, 412, 448, 0, 415, 0, 0, 420, 0, 488, + 493, 0, -2, -2, 107, 0, 0, 0, 0, 0, + 0, 0, 0, 457, 458, 0, -2, -2, 422, 498, + 0, -2, 0, 439, 467, 468, 469, 470, 471, 472, + 473, 474, 0, 455, 0, 427, 86, 97, 98, 99, + 0, 0, 88, 89, 90, 91, 71, 72, 73, 74, + 75, 76, 77, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 0, 0, 139, 134, 123, 124, 94, 95, + 92, 93, 0, 142, 0, -2, 0, 0, 0, 427, + 326, 0, 0, 478, 441, 96, 0, 0, 0, 272, + 273, 0, 421, 275, 276, 0, 324, 325, 166, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 144, 0, 174, 426, 428, 106, 427, 423, 0, + 0, 0, 192, 193, 195, 196, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 361, 363, 0, 477, 0, + 0, 0, 516, 0, 515, 519, 517, 521, 0, 0, + 0, 347, -2, 484, 0, -2, 482, 441, 516, -2, + 382, 383, 384, 385, 0, 403, 404, 405, 406, 407, + 408, 409, 410, 477, 411, 0, 449, 450, 529, 531, + 0, 0, 414, 416, 418, 419, 82, 102, 100, 442, + 0, 451, 332, 443, 444, 0, 0, 502, 108, 0, + 0, 0, 545, 546, 0, 548, 549, 0, 460, 0, + 0, 500, 436, 0, 438, 516, 0, 0, 0, 0, + 116, 88, -2, 119, 0, 0, 139, 0, 0, 122, + 0, 0, 143, 152, 145, 146, 147, 148, 149, 150, + 0, 0, 0, 426, 0, 327, 329, 0, 159, 160, + 161, 162, 0, 163, 0, 0, 164, 0, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, 379, 380, 381, -2, -2, -2, -2, -2, + -2, -2, -2, -2, 395, 0, 0, 401, 82, 182, + -2, 0, 0, -2, 173, 0, 0, 426, 0, 0, + 202, 194, 0, 230, 0, 233, 144, 345, 0, 348, + 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 0, 0, 0, 496, 512, 0, 514, 497, + 0, 454, 516, 0, -2, 524, 516, 0, 0, -2, + 0, 413, 530, 527, 528, 0, 0, 0, 0, 0, + 479, 0, 83, 0, 101, 0, 465, -2, 509, 0, + -2, -2, 331, 452, 0, 477, 0, 0, 0, 0, + 0, 451, 0, 82, 550, 552, 0, 0, 459, 461, + 0, 264, 82, 266, 268, 0, 0, -2, 81, 47, + 12, -2, 45, -2, 32, -2, -2, 70, 38, 39, + 2, 3, 4, 5, 6, -2, 53, -2, -2, -2, + -2, -2, -2, -2, -2, -2, 0, 456, -2, 115, + -2, 118, 133, 139, 120, 0, 0, 140, 141, 426, + 0, 0, 0, 326, 0, 0, 271, 274, 277, 323, + 0, 400, 0, 83, 0, 0, 175, -2, -2, 0, + 200, 279, 0, 0, 0, 0, -2, 346, 0, 489, + 490, 491, 0, 492, 0, 0, 518, 520, 0, 0, + 0, -2, 454, 447, 0, 539, 540, 0, 542, 533, + 534, 535, 536, 0, 538, 417, 103, 104, 437, 0, + 507, 0, 0, 505, 506, 508, 445, 200, 0, 0, + 83, 544, 547, 499, 0, 83, 269, 0, 453, 0, + 82, 237, 239, 117, 0, 0, 82, 129, 135, 0, + 137, 322, 0, 155, 225, 144, 0, 0, 328, 158, + 220, 220, 399, 0, 183, 0, -2, 0, 0, 516, + 170, 214, 144, 180, 0, 0, -2, 204, 0, 107, + 279, 203, 284, 0, 0, 0, 227, 144, 513, 0, + 344, -2, 516, 526, 532, 541, 0, 510, 503, 504, + 204, 337, 543, 551, 265, 267, 270, 262, 235, -2, + 260, 240, 241, 242, 0, 82, 132, 0, 127, 83, + 136, 0, 151, -2, 0, 326, 0, 220, 0, 220, + 167, 0, 0, -2, 516, 0, -2, 172, 176, 0, + 0, 262, 429, 0, 0, 0, 201, 198, 278, 305, + 0, 107, 0, 228, 144, 234, -2, 343, 0, 0, + 0, 0, 82, 339, 0, 82, 82, 335, 426, 0, + 238, 187, 261, 257, 0, 259, 250, 251, 252, 0, + 130, 83, 126, 128, 138, 0, 156, 0, 216, 0, + 0, 0, 0, 0, 168, 212, 144, 0, -2, 0, + -2, 0, 144, 0, 0, 262, 0, 262, 279, 205, + 260, 0, -2, 304, 307, 309, 310, 311, 312, 313, + 314, 0, 199, 285, -2, 525, 537, 279, 336, 338, + 83, 0, 0, 83, 333, 83, 0, 263, 245, 0, + 247, 248, 249, 189, 188, 0, 258, 0, 125, 131, + 226, 0, 0, 144, 223, 224, 217, 218, 0, -2, + 0, 208, 215, -2, 84, 178, 144, 0, 0, 0, + 107, 0, 0, 427, 308, 283, 286, 0, 107, 340, + 341, 0, 334, 0, 0, 246, 0, 0, 190, 255, + 256, 157, 210, 144, 144, -2, 219, 0, 169, 181, + 0, 0, 85, -2, 144, 0, 82, 433, 434, 0, + 144, 197, 0, 316, 426, 0, 320, 0, 78, 79, + 0, 287, 0, 289, 0, 0, 299, 0, 0, 298, + -2, 330, 342, 425, 253, 254, 243, -2, -2, 213, + 0, 179, 185, -2, 430, 431, 83, 435, -2, 280, + 0, 317, 0, 281, 0, 0, 0, 288, 290, 291, + 292, 0, 0, 0, 0, 0, 144, 424, 432, 186, + 315, 426, 319, 426, -2, 293, 294, 295, 297, 300, + 244, 211, -2, 318, 321, 0, 296, 177, 262, 0, + 282, 301, 144, -2, 302, +} +var yyTok1 = [...]int{ + + 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 162, 148, 3, 165, 172, 159, 3, + 154, 155, 170, 161, 166, 160, 175, 171, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 153, 152, + 173, 168, 174, 158, 164, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 156, 3, 157, 169, 3, 149, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 150, 167, 151, 163, +} +var yyTok2 = [...]int{ + + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, +} +var yyTok3 = [...]int{ + 0, +} + +var yyErrorMessages = [...]struct { + state int + token int + msg string +}{} + +// line yaccpar:1 + +/* parser for yacc output */ + +var ( + yyDebug = 0 + yyErrorVerbose = true +) + +type yyLexer interface { + Lex(lval *yySymType) int + Error(s string) +} + +type yyParser interface { + Parse(yyLexer) int + Lookahead() int +} + +type yyParserImpl struct { + lval yySymType + stack [yyInitialStackSize]yySymType + char int +} + +func (p *yyParserImpl) Lookahead() int { + return p.char +} + +func yyNewParser() yyParser { + return &yyParserImpl{} +} + +const yyFlag = -1000 + +func yyTokname(c int) string { + if c >= 1 && c-1 < len(yyToknames) { + if yyToknames[c-1] != "" { + return yyToknames[c-1] + } + } + return __yyfmt__.Sprintf("tok-%v", c) +} + +func yyStatname(s int) string { + if s >= 0 && s < len(yyStatenames) { + if yyStatenames[s] != "" { + return yyStatenames[s] + } + } + return __yyfmt__.Sprintf("state-%v", s) +} + +func yyErrorMessage(state, lookAhead int) string { + const TOKSTART = 4 + + if !yyErrorVerbose { + return "syntax error" + } + + for _, e := range yyErrorMessages { + if e.state == state && e.token == lookAhead { + return "syntax error: " + e.msg + } + } + + res := "syntax error: unexpected " + yyTokname(lookAhead) + + // To match Bison, suggest at most four expected tokens. + expected := make([]int, 0, 4) + + // Look for shiftable tokens. + base := yyPact[state] + for tok := TOKSTART; tok-1 < len(yyToknames); tok++ { + if n := base + tok; n >= 0 && n < yyLast && yyChk[yyAct[n]] == tok { + if len(expected) == cap(expected) { + return res + } + expected = append(expected, tok) + } + } + + if yyDef[state] == -2 { + i := 0 + for yyExca[i] != -1 || yyExca[i+1] != state { + i += 2 + } + + // Look for tokens that we accept or reduce. + for i += 2; yyExca[i] >= 0; i += 2 { + tok := yyExca[i] + if tok < TOKSTART || yyExca[i+1] == 0 { + continue + } + if len(expected) == cap(expected) { + return res + } + expected = append(expected, tok) + } + + // If the default action is to accept or reduce, give up. + if yyExca[i+1] != 0 { + return res + } + } + + for i, tok := range expected { + if i == 0 { + res += ", expecting " + } else { + res += " or " + } + res += yyTokname(tok) + } + return res +} + +func yylex1(lex yyLexer, lval *yySymType) (char, token int) { + token = 0 + char = lex.Lex(lval) + if char <= 0 { + token = yyTok1[0] + goto out + } + if char < len(yyTok1) { + token = yyTok1[char] + goto out + } + if char >= yyPrivate { + if char < yyPrivate+len(yyTok2) { + token = yyTok2[char-yyPrivate] + goto out + } + } + for i := 0; i < len(yyTok3); i += 2 { + token = yyTok3[i+0] + if token == char { + token = yyTok3[i+1] + goto out + } + } + +out: + if token == 0 { + token = yyTok2[1] /* unknown char */ + } + if yyDebug >= 3 { + __yyfmt__.Printf("lex %s(%d)\n", yyTokname(token), uint(char)) + } + return char, token +} + +func yyParse(yylex yyLexer) int { + return yyNewParser().Parse(yylex) +} + +func (yyrcvr *yyParserImpl) Parse(yylex yyLexer) int { + var yyn int + var yyVAL yySymType + var yyDollar []yySymType + _ = yyDollar // silence set and not used + yyS := yyrcvr.stack[:] + + Nerrs := 0 /* number of errors */ + Errflag := 0 /* error recovery flag */ + yystate := 0 + yyrcvr.char = -1 + yytoken := -1 // yyrcvr.char translated into internal numbering + defer func() { + // Make sure we report no lookahead when not parsing. + yystate = -1 + yyrcvr.char = -1 + yytoken = -1 + }() + yyp := -1 + goto yystack + +ret0: + return 0 + +ret1: + return 1 + +yystack: + /* put a state and value onto the stack */ + if yyDebug >= 4 { + __yyfmt__.Printf("char %v in %v\n", yyTokname(yytoken), yyStatname(yystate)) + } + + yyp++ + if yyp >= len(yyS) { + nyys := make([]yySymType, len(yyS)*2) + copy(nyys, yyS) + yyS = nyys + } + yyS[yyp] = yyVAL + yyS[yyp].yys = yystate + +yynewstate: + yyn = yyPact[yystate] + if yyn <= yyFlag { + goto yydefault /* simple state */ + } + if yyrcvr.char < 0 { + yyrcvr.char, yytoken = yylex1(yylex, &yyrcvr.lval) + } + yyn += yytoken + if yyn < 0 || yyn >= yyLast { + goto yydefault + } + yyn = yyAct[yyn] + if yyChk[yyn] == yytoken { /* valid shift */ + yyrcvr.char = -1 + yytoken = -1 + yyVAL = yyrcvr.lval + yystate = yyn + if Errflag > 0 { + Errflag-- + } + goto yystack + } + +yydefault: + /* default state action */ + yyn = yyDef[yystate] + if yyn == -2 { + if yyrcvr.char < 0 { + yyrcvr.char, yytoken = yylex1(yylex, &yyrcvr.lval) + } + + /* look through exception table */ + xi := 0 + for { + if yyExca[xi+0] == -1 && yyExca[xi+1] == yystate { + break + } + xi += 2 + } + for xi += 2; ; xi += 2 { + yyn = yyExca[xi+0] + if yyn < 0 || yyn == yytoken { + break + } + } + yyn = yyExca[xi+1] + if yyn < 0 { + goto ret0 + } + } + if yyn == 0 { + /* error ... attempt to resume parsing */ + switch Errflag { + case 0: /* brand new error */ + yylex.Error(yyErrorMessage(yystate, yytoken)) + Nerrs++ + if yyDebug >= 1 { + __yyfmt__.Printf("%s", yyStatname(yystate)) + __yyfmt__.Printf(" saw %s\n", yyTokname(yytoken)) + } + fallthrough + + case 1, 2: /* incompletely recovered error ... try again */ + Errflag = 3 + + /* find a state where "error" is a legal shift action */ + for yyp >= 0 { + yyn = yyPact[yyS[yyp].yys] + yyErrCode + if yyn >= 0 && yyn < yyLast { + yystate = yyAct[yyn] /* simulate a shift of "error" */ + if yyChk[yystate] == yyErrCode { + goto yystack + } + } + + /* the current p has no shift on "error", pop stack */ + if yyDebug >= 2 { + __yyfmt__.Printf("error recovery pops state %d\n", yyS[yyp].yys) + } + yyp-- + } + /* there is no state on the stack with an error shift ... abort */ + goto ret1 + + case 3: /* no shift yet; clobber input char */ + if yyDebug >= 2 { + __yyfmt__.Printf("error recovery discards %s\n", yyTokname(yytoken)) + } + if yytoken == yyEofCode { + goto ret1 + } + yyrcvr.char = -1 + yytoken = -1 + goto yynewstate /* try again in the same state */ + } + } + + /* reduction by production yyn */ + if yyDebug >= 2 { + __yyfmt__.Printf("reduce %v in:\n\t%v\n", yyn, yyStatname(yystate)) + } + + yynt := yyn + yypt := yyp + _ = yypt // guard against "declared and not used" + + yyp -= yyR2[yyn] + // yyp is now the index of $0. Perform the default action. Iff the + // reduced production is ε, $1 is possibly out of range. + if yyp+1 >= len(yyS) { + nyys := make([]yySymType, len(yyS)*2) + copy(nyys, yyS) + yyS = nyys + } + yyVAL = yyS[yyp+1] + + /* consult goto table to find next state */ + yyn = yyR1[yyn] + yyg := yyPgo[yyn] + yyj := yyg + yyS[yyp].yys + 1 + + if yyj >= yyLast { + yystate = yyAct[yyg] + } else { + yystate = yyAct[yyj] + if yyChk[yystate] != -yyn { + yystate = yyAct[yyg] + } + } + // dummy call; replaced with literal code + switch yynt { + + case 1: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:305 + { + yylex.(*Parser).currentToken.Value = nil + + yylex.(*Parser).rootNode = &ast.Root{ + Position: yylex.(*Parser).builder.Pos.NewNodeListPosition(yyDollar[1].list), + Stmts: yyDollar[1].list, + EndTkn: yylex.(*Parser).currentToken, + } + } + case 2: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:317 + { + yyVAL.token = yyDollar[1].token + } + case 3: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:317 + { + yyVAL.token = yyDollar[1].token + } + case 4: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:317 + { + yyVAL.token = yyDollar[1].token + } + case 5: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:317 + { + yyVAL.token = yyDollar[1].token + } + case 6: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:317 + { + yyVAL.token = yyDollar[1].token + } + case 7: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:317 + { + yyVAL.token = yyDollar[1].token + } + case 8: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:317 + { + yyVAL.token = yyDollar[1].token + } + case 9: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:317 + { + yyVAL.token = yyDollar[1].token + } + case 10: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:318 + { + yyVAL.token = yyDollar[1].token + } + case 11: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:318 + { + yyVAL.token = yyDollar[1].token + } + case 12: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:318 + { + yyVAL.token = yyDollar[1].token + } + case 13: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:318 + { + yyVAL.token = yyDollar[1].token + } + case 14: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:318 + { + yyVAL.token = yyDollar[1].token + } + case 15: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:318 + { + yyVAL.token = yyDollar[1].token + } + case 16: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:318 + { + yyVAL.token = yyDollar[1].token + } + case 17: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:318 + { + yyVAL.token = yyDollar[1].token + } + case 18: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:318 + { + yyVAL.token = yyDollar[1].token + } + case 19: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:318 + { + yyVAL.token = yyDollar[1].token + } + case 20: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:318 + { + yyVAL.token = yyDollar[1].token + } + case 21: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:318 + { + yyVAL.token = yyDollar[1].token + } + case 22: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:319 + { + yyVAL.token = yyDollar[1].token + } + case 23: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:319 + { + yyVAL.token = yyDollar[1].token + } + case 24: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:319 + { + yyVAL.token = yyDollar[1].token + } + case 25: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:319 + { + yyVAL.token = yyDollar[1].token + } + case 26: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:319 + { + yyVAL.token = yyDollar[1].token + } + case 27: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:319 + { + yyVAL.token = yyDollar[1].token + } + case 28: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:319 + { + yyVAL.token = yyDollar[1].token + } + case 29: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:319 + { + yyVAL.token = yyDollar[1].token + } + case 30: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:319 + { + yyVAL.token = yyDollar[1].token + } + case 31: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:319 + { + yyVAL.token = yyDollar[1].token + } + case 32: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:320 + { + yyVAL.token = yyDollar[1].token + } + case 33: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:320 + { + yyVAL.token = yyDollar[1].token + } + case 34: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:320 + { + yyVAL.token = yyDollar[1].token + } + case 35: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:320 + { + yyVAL.token = yyDollar[1].token + } + case 36: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:320 + { + yyVAL.token = yyDollar[1].token + } + case 37: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:320 + { + yyVAL.token = yyDollar[1].token + } + case 38: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:320 + { + yyVAL.token = yyDollar[1].token + } + case 39: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:320 + { + yyVAL.token = yyDollar[1].token + } + case 40: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:320 + { + yyVAL.token = yyDollar[1].token + } + case 41: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:320 + { + yyVAL.token = yyDollar[1].token + } + case 42: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:321 + { + yyVAL.token = yyDollar[1].token + } + case 43: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:321 + { + yyVAL.token = yyDollar[1].token + } + case 44: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:321 + { + yyVAL.token = yyDollar[1].token + } + case 45: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:321 + { + yyVAL.token = yyDollar[1].token + } + case 46: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:321 + { + yyVAL.token = yyDollar[1].token + } + case 47: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:321 + { + yyVAL.token = yyDollar[1].token + } + case 48: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:321 + { + yyVAL.token = yyDollar[1].token + } + case 49: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:321 + { + yyVAL.token = yyDollar[1].token + } + case 50: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:321 + { + yyVAL.token = yyDollar[1].token + } + case 51: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:321 + { + yyVAL.token = yyDollar[1].token + } + case 52: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:321 + { + yyVAL.token = yyDollar[1].token + } + case 53: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:322 + { + yyVAL.token = yyDollar[1].token + } + case 54: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:322 + { + yyVAL.token = yyDollar[1].token + } + case 55: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:322 + { + yyVAL.token = yyDollar[1].token + } + case 56: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:322 + { + yyVAL.token = yyDollar[1].token + } + case 57: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:322 + { + yyVAL.token = yyDollar[1].token + } + case 58: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:322 + { + yyVAL.token = yyDollar[1].token + } + case 59: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:322 + { + yyVAL.token = yyDollar[1].token + } + case 60: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:322 + { + yyVAL.token = yyDollar[1].token + } + case 61: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:323 + { + yyVAL.token = yyDollar[1].token + } + case 62: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:323 + { + yyVAL.token = yyDollar[1].token + } + case 63: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:323 + { + yyVAL.token = yyDollar[1].token + } + case 64: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:323 + { + yyVAL.token = yyDollar[1].token + } + case 65: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:323 + { + yyVAL.token = yyDollar[1].token + } + case 66: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:323 + { + yyVAL.token = yyDollar[1].token + } + case 67: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:323 + { + yyVAL.token = yyDollar[1].token + } + case 68: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:323 + { + yyVAL.token = yyDollar[1].token + } + case 69: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:323 + { + yyVAL.token = yyDollar[1].token + } + case 70: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:323 + { + yyVAL.token = yyDollar[1].token + } + case 71: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:328 + { + yyVAL.token = yyDollar[1].token + } + case 72: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:331 + { + yyVAL.token = yyDollar[1].token + } + case 73: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:331 + { + yyVAL.token = yyDollar[1].token + } + case 74: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:331 + { + yyVAL.token = yyDollar[1].token + } + case 75: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:331 + { + yyVAL.token = yyDollar[1].token + } + case 76: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:331 + { + yyVAL.token = yyDollar[1].token + } + case 77: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:331 + { + yyVAL.token = yyDollar[1].token + } + case 78: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:335 + { + yyVAL.token = yyDollar[1].token + } + case 79: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:336 + { + yyVAL.token = yyDollar[1].token + } + case 80: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:340 + { + yyVAL.token = yyDollar[1].token + } + case 81: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:341 + { + yyVAL.token = yyDollar[1].token + } + case 82: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:345 + { + yyVAL.token = nil + } + case 83: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:346 + { + yyVAL.token = yyDollar[1].token + } + case 84: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:350 + { + yyVAL.token = nil + } + case 85: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:351 + { + yyVAL.token = yyDollar[1].token + } + case 86: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:355 + { + yyVAL.token = yyDollar[1].token + } + case 87: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:359 + { + if yyDollar[2].node != nil { + yyVAL.list = append(yyDollar[1].list, yyDollar[2].node) + } + } + case 88: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:364 + { + yyVAL.list = []ast.Vertex{} + } + case 89: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:368 + { + yyVAL.node = yylex.(*Parser).builder.NewName(yyDollar[1].token) + } + case 90: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:369 + { + yyVAL.node = yylex.(*Parser).builder.NewName(yyDollar[1].token) + } + case 91: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:370 + { + yyVAL.node = yylex.(*Parser).builder.NewNameQualified(yyDollar[1].token) + } + case 92: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:374 + { + yyVAL.node = yylex.(*Parser).builder.NewName(yyDollar[1].token) + } + case 93: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:375 + { + yyVAL.node = yylex.(*Parser).builder.NewNameQualified(yyDollar[1].token) + } + case 94: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:379 + { + yyVAL.node = yyDollar[1].node + } + case 95: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:380 + { + yyVAL.node = yylex.(*Parser).builder.NewNameFullyQualified(yyDollar[1].token) + } + case 96: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:384 + { + yyVAL.node = yylex.(*Parser).builder.NewName(yyDollar[1].token) + } + case 97: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:385 + { + yyVAL.node = yylex.(*Parser).builder.NewNameQualified(yyDollar[1].token) + } + case 98: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:386 + { + yyVAL.node = yylex.(*Parser).builder.NewNameFullyQualified(yyDollar[1].token) + } + case 99: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:387 + { + yyVAL.node = yylex.(*Parser).builder.NewNameRelative(yyDollar[1].token) + } + case 100: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:391 + { + yyVAL.node = yylex.(*Parser).builder.NewAttribute(yyDollar[1].node, nil) + } + case 101: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:392 + { + yyVAL.node = yylex.(*Parser).builder.NewAttribute(yyDollar[1].node, yyDollar[2].node) + } + case 102: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:396 + { + yyVAL.node = yylex.(*Parser).builder.NewSeparatedList(yyDollar[1].node) + } + case 103: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:397 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 104: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:402 + { + yyVAL.node = yylex.(*Parser).builder.NewAttributeGroup(yyDollar[1].token, yyDollar[2].node, yyDollar[3].token, yyDollar[4].token) + } + case 105: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:406 + { + yyVAL.list = []ast.Vertex{yyDollar[1].node} + } + case 106: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:407 + { + yyVAL.list = append(yyDollar[1].list, yyDollar[2].node) + } + case 107: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:411 + { + yyVAL.list = nil + } + case 108: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:412 + { + yyVAL.list = yyDollar[1].list + } + case 109: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:416 + { + yyVAL.node = nil + } + case 110: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:417 + { + yyVAL.node = yyDollar[1].node + } + case 111: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:418 + { + yyVAL.node = yyDollar[1].node + } + case 112: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:419 + { + yyVAL.node = yyDollar[1].node + } + case 113: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:420 + { + yyVAL.node = yyDollar[1].node + } + case 114: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:421 + { + yyVAL.node = yyDollar[1].node + } + case 115: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:423 + { + yyVAL.node = &ast.StmtHaltCompiler{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[4].token), + HaltCompilerTkn: yyDollar[1].token, + OpenParenthesisTkn: yyDollar[2].token, + CloseParenthesisTkn: yyDollar[3].token, + SemiColonTkn: yyDollar[4].token, + } + } + case 116: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:433 + { + yyVAL.node = yylex.(*Parser).builder.NewNamespace(yyDollar[1].token, yyDollar[2].node, nil, nil, nil, yyDollar[3].token) + } + case 117: + yyDollar = yyS[yypt-5 : yypt+1] + // line internal/php8/php8.y:435 + { + yyVAL.node = yylex.(*Parser).builder.NewNamespace(yyDollar[1].token, yyDollar[2].node, yyDollar[3].token, yyDollar[4].list, yyDollar[5].token, nil) + } + case 118: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:437 + { + yyVAL.node = yylex.(*Parser).builder.NewNamespace(yyDollar[1].token, nil, yyDollar[2].token, yyDollar[3].list, yyDollar[4].token, nil) + } + case 119: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:440 + { + yyVAL.node = yylex.(*Parser).builder.NewUseList(yyDollar[1].token, nil, yyDollar[2].node, yyDollar[3].token) + } + case 120: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:442 + { + yyVAL.node = yylex.(*Parser).builder.NewUseList(yyDollar[1].token, yyDollar[2].token, yyDollar[3].node, yyDollar[4].token) + } + case 121: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:444 + { + yyVAL.node = yyDollar[1].node + } + case 122: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:447 + { + yyVAL.node = &ast.StmtConstList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token), + ConstTkn: yyDollar[1].token, + Consts: yyDollar[2].node.(*ParserSeparatedList).Items, + SeparatorTkns: yyDollar[2].node.(*ParserSeparatedList).SeparatorTkns, + SemiColonTkn: yyDollar[3].token, + } + } + case 123: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:459 + { + yyVAL.token = yyDollar[1].token + } + case 124: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:460 + { + yyVAL.token = yyDollar[1].token + } + case 125: + yyDollar = yyS[yypt-8 : yypt+1] + // line internal/php8/php8.y:465 + { + yyVAL.node = yylex.(*Parser).builder.NewGroupUseList(yyDollar[1].token, yyDollar[2].token, yyDollar[3].node, yyDollar[4].token, yyDollar[5].token, yyDollar[6].node, yyDollar[7].token, yyDollar[8].token) + } + case 126: + yyDollar = yyS[yypt-7 : yypt+1] + // line internal/php8/php8.y:467 + { + yyVAL.node = yylex.(*Parser).builder.NewGroupUseList(yyDollar[1].token, nil, yyDollar[2].node, yyDollar[3].token, yyDollar[4].token, yyDollar[5].node, yyDollar[6].token, yyDollar[7].token) + } + case 127: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:472 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, nil) + } + case 128: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:477 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 129: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:479 + { + yyVAL.node = yylex.(*Parser).builder.NewSeparatedList(yyDollar[1].node) + } + case 130: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:484 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, nil) + } + case 131: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:489 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 132: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:491 + { + yyVAL.node = yylex.(*Parser).builder.NewSeparatedList(yyDollar[1].node) + } + case 133: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:495 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 134: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:496 + { + yyVAL.node = yylex.(*Parser).builder.NewSeparatedList(yyDollar[1].node) + } + case 135: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:500 + { + yyVAL.node = yyDollar[1].node + } + case 136: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:501 + { + decl := yyDollar[2].node.(*ast.StmtUse) + decl.Type = yylex.(*Parser).builder.NewIdentifier(yyDollar[1].token) + decl.Position = yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node) + yyVAL.node = yyDollar[2].node + } + case 137: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:510 + { + yyVAL.node = yylex.(*Parser).builder.NewUse(nil, yyDollar[1].node, nil, nil) + } + case 138: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:511 + { + yyVAL.node = yylex.(*Parser).builder.NewUse(nil, yyDollar[1].node, yyDollar[2].token, yyDollar[3].token) + } + case 139: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:515 + { + yyVAL.node = yylex.(*Parser).builder.NewUse(nil, yyDollar[1].node, nil, nil) + } + case 140: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:516 + { + yyVAL.node = yylex.(*Parser).builder.NewUse(nil, yyDollar[1].node, yyDollar[2].token, yyDollar[3].token) + } + case 141: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:520 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 142: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:521 + { + yyVAL.node = yylex.(*Parser).builder.NewSeparatedList(yyDollar[1].node) + } + case 143: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:525 + { + if yyDollar[2].node != nil { + yyVAL.list = append(yyDollar[1].list, yyDollar[2].node) + } + } + case 144: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:530 + { + yyVAL.list = []ast.Vertex{} + } + case 145: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:534 + { + yyVAL.node = nil + } + case 146: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:535 + { + yyVAL.node = yyDollar[1].node + } + case 147: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:536 + { + yyVAL.node = yyDollar[1].node + } + case 148: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:537 + { + yyVAL.node = yyDollar[1].node + } + case 149: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:538 + { + yyVAL.node = yyDollar[1].node + } + case 150: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:539 + { + yyVAL.node = yyDollar[1].node + } + case 151: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:541 + { + yyVAL.node = &ast.StmtHaltCompiler{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[4].token), + HaltCompilerTkn: yyDollar[1].token, + OpenParenthesisTkn: yyDollar[2].token, + CloseParenthesisTkn: yyDollar[3].token, + SemiColonTkn: yyDollar[4].token, + } + } + case 152: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:553 + { + yyVAL.node = &ast.StmtStmtList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token), + OpenCurlyBracketTkn: yyDollar[1].token, + Stmts: yyDollar[2].list, + CloseCurlyBracketTkn: yyDollar[3].token, + } + } + case 153: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:562 + { + yyVAL.node = yyDollar[1].node + } + case 154: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:566 + { + yyVAL.node = yyDollar[1].node + } + case 155: + yyDollar = yyS[yypt-5 : yypt+1] + // line internal/php8/php8.y:570 + { + yyDollar[5].node.(*ast.StmtWhile).WhileTkn = yyDollar[1].token + yyDollar[5].node.(*ast.StmtWhile).OpenParenthesisTkn = yyDollar[2].token + yyDollar[5].node.(*ast.StmtWhile).Cond = yyDollar[3].node + yyDollar[5].node.(*ast.StmtWhile).CloseParenthesisTkn = yyDollar[4].token + yyDollar[5].node.(*ast.StmtWhile).Position = yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[5].node) + + yyVAL.node = yyDollar[5].node + } + case 156: + yyDollar = yyS[yypt-7 : yypt+1] + // line internal/php8/php8.y:580 + { + yyVAL.node = &ast.StmtDo{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[7].token), + DoTkn: yyDollar[1].token, + Stmt: yyDollar[2].node, + WhileTkn: yyDollar[3].token, + OpenParenthesisTkn: yyDollar[4].token, + Cond: yyDollar[5].node, + CloseParenthesisTkn: yyDollar[6].token, + SemiColonTkn: yyDollar[7].token, + } + } + case 157: + yyDollar = yyS[yypt-9 : yypt+1] + // line internal/php8/php8.y:593 + { + yyDollar[9].node.(*ast.StmtFor).ForTkn = yyDollar[1].token + yyDollar[9].node.(*ast.StmtFor).OpenParenthesisTkn = yyDollar[2].token + yyDollar[9].node.(*ast.StmtFor).Init = yyDollar[3].node.(*ParserSeparatedList).Items + yyDollar[9].node.(*ast.StmtFor).InitSeparatorTkns = yyDollar[3].node.(*ParserSeparatedList).SeparatorTkns + yyDollar[9].node.(*ast.StmtFor).InitSemiColonTkn = yyDollar[4].token + yyDollar[9].node.(*ast.StmtFor).Cond = yyDollar[5].node.(*ParserSeparatedList).Items + yyDollar[9].node.(*ast.StmtFor).CondSeparatorTkns = yyDollar[5].node.(*ParserSeparatedList).SeparatorTkns + yyDollar[9].node.(*ast.StmtFor).CondSemiColonTkn = yyDollar[6].token + yyDollar[9].node.(*ast.StmtFor).Loop = yyDollar[7].node.(*ParserSeparatedList).Items + yyDollar[9].node.(*ast.StmtFor).LoopSeparatorTkns = yyDollar[7].node.(*ParserSeparatedList).SeparatorTkns + yyDollar[9].node.(*ast.StmtFor).CloseParenthesisTkn = yyDollar[8].token + yyDollar[9].node.(*ast.StmtFor).Position = yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[9].node) + + yyVAL.node = yyDollar[9].node + } + case 158: + yyDollar = yyS[yypt-5 : yypt+1] + // line internal/php8/php8.y:610 + { + yyDollar[5].node.(*ast.StmtSwitch).SwitchTkn = yyDollar[1].token + yyDollar[5].node.(*ast.StmtSwitch).OpenParenthesisTkn = yyDollar[2].token + yyDollar[5].node.(*ast.StmtSwitch).Cond = yyDollar[3].node + yyDollar[5].node.(*ast.StmtSwitch).CloseParenthesisTkn = yyDollar[4].token + yyDollar[5].node.(*ast.StmtSwitch).Position = yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[5].node) + + yyVAL.node = yyDollar[5].node + } + case 159: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:620 + { + yyVAL.node = &ast.StmtBreak{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token), + BreakTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + SemiColonTkn: yyDollar[3].token, + } + } + case 160: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:629 + { + yyVAL.node = &ast.StmtContinue{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token), + ContinueTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + SemiColonTkn: yyDollar[3].token, + } + } + case 161: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:638 + { + yyVAL.node = &ast.StmtReturn{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token), + ReturnTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + SemiColonTkn: yyDollar[3].token, + } + } + case 162: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:647 + { + yyDollar[2].node.(*ast.StmtGlobal).GlobalTkn = yyDollar[1].token + yyDollar[2].node.(*ast.StmtGlobal).SemiColonTkn = yyDollar[3].token + yyDollar[2].node.(*ast.StmtGlobal).Position = yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token) + + yyVAL.node = yyDollar[2].node + } + case 163: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:655 + { + yyDollar[2].node.(*ast.StmtStatic).StaticTkn = yyDollar[1].token + yyDollar[2].node.(*ast.StmtStatic).SemiColonTkn = yyDollar[3].token + yyDollar[2].node.(*ast.StmtStatic).Position = yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token) + + yyVAL.node = yyDollar[2].node + } + case 164: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:663 + { + yyDollar[2].node.(*ast.StmtEcho).EchoTkn = yyDollar[1].token + yyDollar[2].node.(*ast.StmtEcho).SemiColonTkn = yyDollar[3].token + yyDollar[2].node.(*ast.StmtEcho).Position = yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token) + + yyVAL.node = yyDollar[2].node + } + case 165: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:671 + { + yyVAL.node = &ast.StmtInlineHtml{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + InlineHtmlTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + } + } + case 166: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:679 + { + yyVAL.node = yylex.(*Parser).builder.NewExpressionStmt(yyDollar[1].node, yyDollar[2].token) + } + case 167: + yyDollar = yyS[yypt-6 : yypt+1] + // line internal/php8/php8.y:683 + { + yyDollar[3].node.(*ast.StmtUnset).UnsetTkn = yyDollar[1].token + yyDollar[3].node.(*ast.StmtUnset).OpenParenthesisTkn = yyDollar[2].token + if yyDollar[4].token != nil { + yyDollar[3].node.(*ast.StmtUnset).SeparatorTkns = append(yyDollar[3].node.(*ast.StmtUnset).SeparatorTkns, yyDollar[4].token) + } + yyDollar[3].node.(*ast.StmtUnset).CloseParenthesisTkn = yyDollar[5].token + yyDollar[3].node.(*ast.StmtUnset).SemiColonTkn = yyDollar[6].token + yyDollar[3].node.(*ast.StmtUnset).Position = yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[6].token) + + yyVAL.node = yyDollar[3].node + } + case 168: + yyDollar = yyS[yypt-7 : yypt+1] + // line internal/php8/php8.y:696 + { + foreach := yyDollar[7].node.(*ast.StmtForeach) + + foreach.Position = yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[7].node) + foreach.ForeachTkn = yyDollar[1].token + foreach.OpenParenthesisTkn = yyDollar[2].token + foreach.Expr = yyDollar[3].node + foreach.AsTkn = yyDollar[4].token + foreach.Var = yyDollar[5].node + foreach.CloseParenthesisTkn = yyDollar[6].token + + if val, ok := yyDollar[5].node.(*ast.StmtForeach); ok { + foreach.AmpersandTkn = val.AmpersandTkn + foreach.Var = val.Var + } + + yyVAL.node = foreach + } + case 169: + yyDollar = yyS[yypt-9 : yypt+1] + // line internal/php8/php8.y:715 + { + foreach := yyDollar[9].node.(*ast.StmtForeach) + + foreach.Position = yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[9].node) + foreach.ForeachTkn = yyDollar[1].token + foreach.OpenParenthesisTkn = yyDollar[2].token + foreach.Expr = yyDollar[3].node + foreach.AsTkn = yyDollar[4].token + foreach.Key = yyDollar[5].node + foreach.DoubleArrowTkn = yyDollar[6].token + foreach.Var = yyDollar[7].node + foreach.CloseParenthesisTkn = yyDollar[8].token + + if val, ok := yyDollar[7].node.(*ast.StmtForeach); ok { + foreach.AmpersandTkn = val.AmpersandTkn + foreach.Var = val.Var + } + + yyVAL.node = foreach + } + case 170: + yyDollar = yyS[yypt-5 : yypt+1] + // line internal/php8/php8.y:736 + { + yyDollar[5].node.(*ast.StmtDeclare).DeclareTkn = yyDollar[1].token + yyDollar[5].node.(*ast.StmtDeclare).OpenParenthesisTkn = yyDollar[2].token + yyDollar[5].node.(*ast.StmtDeclare).Consts = yyDollar[3].node.(*ParserSeparatedList).Items + yyDollar[5].node.(*ast.StmtDeclare).SeparatorTkns = yyDollar[3].node.(*ParserSeparatedList).SeparatorTkns + yyDollar[5].node.(*ast.StmtDeclare).CloseParenthesisTkn = yyDollar[4].token + yyDollar[5].node.(*ast.StmtDeclare).Position = yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[5].node) + + yyVAL.node = yyDollar[5].node + } + case 171: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:747 + { + yyVAL.node = &ast.StmtNop{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + SemiColonTkn: yyDollar[1].token, + } + } + case 172: + yyDollar = yyS[yypt-6 : yypt+1] + // line internal/php8/php8.y:754 + { + yyVAL.node = yylex.(*Parser).builder.NewTry(yyDollar[1].token, yyDollar[2].token, yyDollar[3].list, yyDollar[4].token, yyDollar[5].node, yyDollar[6].node) + } + case 173: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:758 + { + yyVAL.node = &ast.StmtGoto{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token), + GotoTkn: yyDollar[1].token, + Label: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[2].token), + IdentifierTkn: yyDollar[2].token, + Value: yyDollar[2].token.Value, + }, + SemiColonTkn: yyDollar[3].token, + } + } + case 174: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:771 + { + yyVAL.node = &ast.StmtLabel{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[2].token), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + IdentifierTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + }, + ColonTkn: yyDollar[2].token, + } + } + case 175: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:784 + { + yyVAL.node = yylex.(*Parser).builder.NewEmptySeparatedList() + } + case 176: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:785 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, nil, yyDollar[2].node) + } + case 177: + yyDollar = yyS[yypt-8 : yypt+1] + // line internal/php8/php8.y:790 + { + yyVAL.node = yylex.(*Parser).builder.NewCatch(yyDollar[1].token, yyDollar[2].token, yyDollar[3].node, yyDollar[4].token, yyDollar[5].token, yyDollar[6].token, yyDollar[7].list, yyDollar[8].token) + } + case 178: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:794 + { + yyVAL.node = yylex.(*Parser).builder.NewSeparatedList(yyDollar[1].node) + } + case 179: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:795 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 180: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:800 + { + yyVAL.node = nil + } + case 181: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:804 + { + yyVAL.node = &ast.StmtFinally{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[4].token), + FinallyTkn: yyDollar[1].token, + OpenCurlyBracketTkn: yyDollar[2].token, + Stmts: yyDollar[3].list, + CloseCurlyBracketTkn: yyDollar[4].token, + } + } + case 182: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:817 + { + yyVAL.node = &ast.StmtUnset{ + Vars: []ast.Vertex{yyDollar[1].node}, + } + } + case 183: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:823 + { + yyDollar[1].node.(*ast.StmtUnset).Vars = append(yyDollar[1].node.(*ast.StmtUnset).Vars, yyDollar[3].node) + yyDollar[1].node.(*ast.StmtUnset).SeparatorTkns = append(yyDollar[1].node.(*ast.StmtUnset).SeparatorTkns, yyDollar[2].token) + + yyVAL.node = yyDollar[1].node + } + case 184: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:832 + { + yyVAL.node = yyDollar[1].node + } + case 185: + yyDollar = yyS[yypt-10 : yypt+1] + // line internal/php8/php8.y:837 + { + yyVAL.node = yylex.(*Parser).builder.NewFunction(nil, yyDollar[1].token, yyDollar[2].token, yyDollar[3].token, yyDollar[4].token, yyDollar[5].node, yyDollar[6].token, yyDollar[7].node, yyDollar[8].token, yyDollar[9].list, yyDollar[10].token) + } + case 186: + yyDollar = yyS[yypt-11 : yypt+1] + // line internal/php8/php8.y:840 + { + yyVAL.node = yylex.(*Parser).builder.NewFunction(yyDollar[1].list, yyDollar[2].token, yyDollar[3].token, yyDollar[4].token, yyDollar[5].token, yyDollar[6].node, yyDollar[7].token, yyDollar[8].node, yyDollar[9].token, yyDollar[10].list, yyDollar[11].token) + } + case 187: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:844 + { + yyVAL.token = nil + } + case 188: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:845 + { + yyVAL.token = yyDollar[1].token + } + case 189: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:849 + { + yyVAL.token = nil + } + case 190: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:850 + { + yyVAL.token = yyDollar[1].token + } + case 191: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:854 + { + yyVAL.list = nil + } + case 192: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:855 + { + yyVAL.list = yyDollar[1].list + } + case 193: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:859 + { + yyVAL.list = []ast.Vertex{yyDollar[1].node} + } + case 194: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:860 + { + yyVAL.list = append(yyDollar[1].list, yyDollar[2].node) + } + case 195: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:864 + { + yyVAL.node = yylex.(*Parser).builder.NewIdentifier(yyDollar[1].token) + } + case 196: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:865 + { + yyVAL.node = yylex.(*Parser).builder.NewIdentifier(yyDollar[1].token) + } + case 197: + yyDollar = yyS[yypt-9 : yypt+1] + // line internal/php8/php8.y:871 + { + yyVAL.node = yylex.(*Parser).builder.NewClass(yyDollar[1].list, yyDollar[2].list, yyDollar[3].token, yyDollar[4].token, yyDollar[5].node, yyDollar[6].node, yyDollar[7].token, yyDollar[8].list, yyDollar[9].token) + } + case 198: + yyDollar = yyS[yypt-6 : yypt+1] + // line internal/php8/php8.y:877 + { + yyVAL.node = yylex.(*Parser).builder.NewTrait(yyDollar[1].list, yyDollar[2].token, yyDollar[3].token, yyDollar[4].token, yyDollar[5].list, yyDollar[6].token) + } + case 199: + yyDollar = yyS[yypt-7 : yypt+1] + // line internal/php8/php8.y:883 + { + yyVAL.node = yylex.(*Parser).builder.NewInterface(yyDollar[1].list, yyDollar[2].token, yyDollar[3].token, yyDollar[4].node, yyDollar[5].token, yyDollar[6].list, yyDollar[7].token) + } + case 200: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:888 + { + yyVAL.node = nil + } + case 201: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:892 + { + yyVAL.node = &ast.StmtClass{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + ExtendsTkn: yyDollar[1].token, + Extends: yyDollar[2].node, + } + } + case 202: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:903 + { + yyVAL.node = nil + } + case 203: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:907 + { + yyVAL.node = &ast.StmtInterface{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodeListPosition(yyDollar[1].token, yyDollar[2].node.(*ParserSeparatedList).Items), + ExtendsTkn: yyDollar[1].token, + Extends: yyDollar[2].node.(*ParserSeparatedList).Items, + ExtendsSeparatorTkns: yyDollar[2].node.(*ParserSeparatedList).SeparatorTkns, + } + } + case 204: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:919 + { + yyVAL.node = nil + } + case 205: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:923 + { + yyVAL.node = &ast.StmtClass{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodeListPosition(yyDollar[1].token, yyDollar[2].node.(*ParserSeparatedList).Items), + ImplementsTkn: yyDollar[1].token, + Implements: yyDollar[2].node.(*ParserSeparatedList).Items, + ImplementsSeparatorTkns: yyDollar[2].node.(*ParserSeparatedList).SeparatorTkns, + } + } + case 206: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:935 + { + yyVAL.node = yyDollar[1].node + } + case 207: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:939 + { + yyVAL.node = &ast.StmtForeach{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + AmpersandTkn: yyDollar[1].token, + Var: yyDollar[2].node, + } + } + case 208: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:947 + { + yyVAL.node = &ast.ExprList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[4].token), + ListTkn: yyDollar[1].token, + OpenBracketTkn: yyDollar[2].token, + Items: yyDollar[3].node.(*ParserSeparatedList).Items, + SeparatorTkns: yyDollar[3].node.(*ParserSeparatedList).SeparatorTkns, + CloseBracketTkn: yyDollar[4].token, + } + } + case 209: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:958 + { + yyVAL.node = &ast.ExprList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token), + OpenBracketTkn: yyDollar[1].token, + Items: yyDollar[2].node.(*ParserSeparatedList).Items, + SeparatorTkns: yyDollar[2].node.(*ParserSeparatedList).SeparatorTkns, + CloseBracketTkn: yyDollar[3].token, + } + } + case 210: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:971 + { + yyVAL.node = &ast.StmtFor{ + Position: yylex.(*Parser).builder.Pos.NewNodePosition(yyDollar[1].node), + Stmt: yyDollar[1].node, + } + } + case 211: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:978 + { + yyVAL.node = &ast.StmtFor{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[4].token), + ColonTkn: yyDollar[1].token, + Stmt: &ast.StmtStmtList{ + Position: yylex.(*Parser).builder.Pos.NewNodeListPosition(yyDollar[2].list), + Stmts: yyDollar[2].list, + }, + EndForTkn: yyDollar[3].token, + SemiColonTkn: yyDollar[4].token, + } + } + case 212: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:994 + { + yyVAL.node = &ast.StmtForeach{ + Position: yylex.(*Parser).builder.Pos.NewNodePosition(yyDollar[1].node), + Stmt: yyDollar[1].node, + } + } + case 213: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:1001 + { + yyVAL.node = &ast.StmtForeach{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[4].token), + ColonTkn: yyDollar[1].token, + Stmt: &ast.StmtStmtList{ + Position: yylex.(*Parser).builder.Pos.NewNodeListPosition(yyDollar[2].list), + Stmts: yyDollar[2].list, + }, + EndForeachTkn: yyDollar[3].token, + SemiColonTkn: yyDollar[4].token, + } + } + case 214: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1017 + { + yyVAL.node = &ast.StmtDeclare{ + Position: yylex.(*Parser).builder.Pos.NewNodePosition(yyDollar[1].node), + Stmt: yyDollar[1].node, + } + } + case 215: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:1024 + { + yyVAL.node = &ast.StmtDeclare{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[4].token), + ColonTkn: yyDollar[1].token, + Stmt: &ast.StmtStmtList{ + Position: yylex.(*Parser).builder.Pos.NewNodeListPosition(yyDollar[2].list), + Stmts: yyDollar[2].list, + }, + EndDeclareTkn: yyDollar[3].token, + SemiColonTkn: yyDollar[4].token, + } + } + case 216: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1040 + { + yyVAL.node = &ast.StmtSwitch{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token), + OpenCurlyBracketTkn: yyDollar[1].token, + Cases: yyDollar[2].list, + CloseCurlyBracketTkn: yyDollar[3].token, + } + } + case 217: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:1049 + { + yyVAL.node = &ast.StmtSwitch{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[4].token), + OpenCurlyBracketTkn: yyDollar[1].token, + CaseSeparatorTkn: yyDollar[2].token, + Cases: yyDollar[3].list, + CloseCurlyBracketTkn: yyDollar[4].token, + } + } + case 218: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:1059 + { + yyVAL.node = &ast.StmtSwitch{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[4].token), + ColonTkn: yyDollar[1].token, + Cases: yyDollar[2].list, + EndSwitchTkn: yyDollar[3].token, + SemiColonTkn: yyDollar[4].token, + } + } + case 219: + yyDollar = yyS[yypt-5 : yypt+1] + // line internal/php8/php8.y:1069 + { + yyVAL.node = &ast.StmtSwitch{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[5].token), + ColonTkn: yyDollar[1].token, + CaseSeparatorTkn: yyDollar[2].token, + Cases: yyDollar[3].list, + EndSwitchTkn: yyDollar[4].token, + SemiColonTkn: yyDollar[5].token, + } + } + case 220: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:1083 + { + yyVAL.list = nil + } + case 221: + yyDollar = yyS[yypt-5 : yypt+1] + // line internal/php8/php8.y:1087 + { + yyVAL.list = append(yyDollar[1].list, &ast.StmtCase{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodeListPosition(yyDollar[2].token, yyDollar[5].list), + CaseTkn: yyDollar[2].token, + Cond: yyDollar[3].node, + CaseSeparatorTkn: yyDollar[4].token, + Stmts: yyDollar[5].list, + }) + } + case 222: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:1097 + { + yyVAL.list = append(yyDollar[1].list, &ast.StmtDefault{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodeListPosition(yyDollar[2].token, yyDollar[4].list), + DefaultTkn: yyDollar[2].token, + CaseSeparatorTkn: yyDollar[3].token, + Stmts: yyDollar[4].list, + }) + } + case 223: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1108 + { + yyVAL.token = yyDollar[1].token + } + case 224: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1109 + { + yyVAL.token = yyDollar[1].token + } + case 225: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1114 + { + yyVAL.node = &ast.StmtWhile{ + Position: yylex.(*Parser).builder.Pos.NewNodePosition(yyDollar[1].node), + Stmt: yyDollar[1].node, + } + } + case 226: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:1121 + { + yyVAL.node = &ast.StmtWhile{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[4].token), + ColonTkn: yyDollar[1].token, + Stmt: &ast.StmtStmtList{ + Position: yylex.(*Parser).builder.Pos.NewNodeListPosition(yyDollar[2].list), + Stmts: yyDollar[2].list, + }, + EndWhileTkn: yyDollar[3].token, + SemiColonTkn: yyDollar[4].token, + } + } + case 227: + yyDollar = yyS[yypt-5 : yypt+1] + // line internal/php8/php8.y:1137 + { + yyVAL.node = &ast.StmtIf{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[5].node), + IfTkn: yyDollar[1].token, + OpenParenthesisTkn: yyDollar[2].token, + Cond: yyDollar[3].node, + CloseParenthesisTkn: yyDollar[4].token, + Stmt: yyDollar[5].node, + } + } + case 228: + yyDollar = yyS[yypt-6 : yypt+1] + // line internal/php8/php8.y:1148 + { + yyDollar[1].node.(*ast.StmtIf).ElseIf = append(yyDollar[1].node.(*ast.StmtIf).ElseIf, &ast.StmtElseIf{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[2].token, yyDollar[6].node), + ElseIfTkn: yyDollar[2].token, + OpenParenthesisTkn: yyDollar[3].token, + Cond: yyDollar[4].node, + CloseParenthesisTkn: yyDollar[5].token, + Stmt: yyDollar[6].node, + }) + + yyDollar[1].node.(*ast.StmtIf).Position = yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[6].node) + + yyVAL.node = yyDollar[1].node + } + case 229: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1166 + { + yyVAL.node = yyDollar[1].node + } + case 230: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1170 + { + yyDollar[1].node.(*ast.StmtIf).Else = &ast.StmtElse{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[2].token, yyDollar[3].node), + ElseTkn: yyDollar[2].token, + Stmt: yyDollar[3].node, + } + + yyDollar[1].node.(*ast.StmtIf).Position = yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node) + + yyVAL.node = yyDollar[1].node + } + case 231: + yyDollar = yyS[yypt-6 : yypt+1] + // line internal/php8/php8.y:1185 + { + yyVAL.node = &ast.StmtIf{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodeListPosition(yyDollar[1].token, yyDollar[6].list), + IfTkn: yyDollar[1].token, + OpenParenthesisTkn: yyDollar[2].token, + Cond: yyDollar[3].node, + CloseParenthesisTkn: yyDollar[4].token, + ColonTkn: yyDollar[5].token, + Stmt: &ast.StmtStmtList{ + Position: yylex.(*Parser).builder.Pos.NewNodeListPosition(yyDollar[6].list), + Stmts: yyDollar[6].list, + }, + } + } + case 232: + yyDollar = yyS[yypt-7 : yypt+1] + // line internal/php8/php8.y:1200 + { + yyDollar[1].node.(*ast.StmtIf).ElseIf = append(yyDollar[1].node.(*ast.StmtIf).ElseIf, &ast.StmtElseIf{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodeListPosition(yyDollar[2].token, yyDollar[7].list), + ElseIfTkn: yyDollar[2].token, + OpenParenthesisTkn: yyDollar[3].token, + Cond: yyDollar[4].node, + CloseParenthesisTkn: yyDollar[5].token, + ColonTkn: yyDollar[6].token, + Stmt: &ast.StmtStmtList{ + Position: yylex.(*Parser).builder.Pos.NewNodeListPosition(yyDollar[7].list), + Stmts: yyDollar[7].list, + }, + }) + + yyVAL.node = yyDollar[1].node + } + case 233: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1220 + { + yyDollar[1].node.(*ast.StmtIf).EndIfTkn = yyDollar[2].token + yyDollar[1].node.(*ast.StmtIf).SemiColonTkn = yyDollar[3].token + yyDollar[1].node.(*ast.StmtIf).Position = yylex.(*Parser).builder.Pos.NewNodeTokenPosition(yyDollar[1].node, yyDollar[3].token) + + yyVAL.node = yyDollar[1].node + } + case 234: + yyDollar = yyS[yypt-6 : yypt+1] + // line internal/php8/php8.y:1228 + { + yyDollar[1].node.(*ast.StmtIf).Else = &ast.StmtElse{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodeListPosition(yyDollar[2].token, yyDollar[4].list), + ElseTkn: yyDollar[2].token, + ColonTkn: yyDollar[3].token, + Stmt: &ast.StmtStmtList{ + Position: yylex.(*Parser).builder.Pos.NewNodeListPosition(yyDollar[4].list), + Stmts: yyDollar[4].list, + }, + } + yyDollar[1].node.(*ast.StmtIf).EndIfTkn = yyDollar[5].token + yyDollar[1].node.(*ast.StmtIf).SemiColonTkn = yyDollar[6].token + yyDollar[1].node.(*ast.StmtIf).Position = yylex.(*Parser).builder.Pos.NewNodeTokenPosition(yyDollar[1].node, yyDollar[6].token) + + yyVAL.node = yyDollar[1].node + } + case 235: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:1247 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, nil) + } + case 236: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:1248 + { + yyVAL.node = yylex.(*Parser).builder.NewEmptySeparatedList() + } + case 237: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1252 + { + yyVAL.node = yylex.(*Parser).builder.NewSeparatedList(yyDollar[1].node) + } + case 238: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1253 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 239: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:1257 + { + yyVAL.node = nil + } + case 240: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1258 + { + yyVAL.node = yylex.(*Parser).builder.NewIdentifier(yyDollar[1].token) + } + case 241: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1259 + { + yyVAL.node = yylex.(*Parser).builder.NewIdentifier(yyDollar[1].token) + } + case 242: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1260 + { + yyVAL.node = yylex.(*Parser).builder.NewIdentifier(yyDollar[1].token) + } + case 243: + yyDollar = yyS[yypt-6 : yypt+1] + // line internal/php8/php8.y:1266 + { + yyVAL.node = yylex.(*Parser).builder.NewParameter(yyDollar[1].list, yyDollar[2].node, yyDollar[3].node, yyDollar[4].token, yyDollar[5].token, yyDollar[6].token, nil, nil, false) + } + case 244: + yyDollar = yyS[yypt-8 : yypt+1] + // line internal/php8/php8.y:1269 + { + yyVAL.node = yylex.(*Parser).builder.NewParameter(yyDollar[1].list, yyDollar[2].node, yyDollar[3].node, yyDollar[4].token, yyDollar[5].token, yyDollar[6].token, yyDollar[7].token, yyDollar[8].node, true) + } + case 245: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1273 + { + yyVAL.node = yyDollar[1].node + } + case 246: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:1274 + { + yyVAL.node = yylex.(*Parser).builder.NewNullableType(yyDollar[1].token, yyDollar[2].node) + } + case 247: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1275 + { + yyVAL.node = yylex.(*Parser).builder.NewUnionType(yyDollar[1].node) + } + case 248: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1279 + { + yyVAL.node = yyDollar[1].node + } + case 249: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1280 + { + yyVAL.node = yylex.(*Parser).builder.NewNameType(yyDollar[1].token) + } + case 250: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1284 + { + yyVAL.node = yylex.(*Parser).builder.NewNameType(yyDollar[1].token) + } + case 251: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1285 + { + yyVAL.node = yylex.(*Parser).builder.NewNameType(yyDollar[1].token) + } + case 252: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1286 + { + yyVAL.node = yyDollar[1].node + } + case 253: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1290 + { + yyVAL.node = yylex.(*Parser).builder.NewSeparatedListWithTwoElements(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 254: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1291 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 255: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1296 + { + yyVAL.node = yylex.(*Parser).builder.NewSeparatedListWithTwoElements(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 256: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1298 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 257: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1302 + { + yyVAL.node = yyDollar[1].node + } + case 258: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:1303 + { + yyVAL.node = yylex.(*Parser).builder.NewNullableType(yyDollar[1].token, yyDollar[2].node) + } + case 259: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1304 + { + yyVAL.node = yylex.(*Parser).builder.NewUnionType(yyDollar[1].node) + } + case 260: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:1308 + { + yyVAL.node = nil + } + case 261: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1309 + { + yyVAL.node = yyDollar[1].node + } + case 262: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:1313 + { + yyVAL.node = &ReturnType{} + } + case 263: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:1314 + { + yyVAL.node = yylex.(*Parser).builder.NewReturnType(yyDollar[1].token, yyDollar[2].node) + } + case 264: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:1319 + { + yyVAL.node = &ArgumentList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[2].token), + OpenParenthesisTkn: yyDollar[1].token, + CloseParenthesisTkn: yyDollar[2].token, + } + } + case 265: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:1327 + { + argumentList := yyDollar[2].node.(*ArgumentList) + argumentList.Position = yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[4].token) + argumentList.OpenParenthesisTkn = yyDollar[1].token + if yyDollar[3].token != nil { + argumentList.SeparatorTkns = append(argumentList.SeparatorTkns, yyDollar[3].token) + } + argumentList.CloseParenthesisTkn = yyDollar[4].token + + yyVAL.node = argumentList + } + case 266: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1342 + { + yyVAL.node = &ArgumentList{ + Arguments: []ast.Vertex{yyDollar[1].node}, + } + } + case 267: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1348 + { + yyDollar[1].node.(*ArgumentList).SeparatorTkns = append(yyDollar[1].node.(*ArgumentList).SeparatorTkns, yyDollar[2].token) + yyDollar[1].node.(*ArgumentList).Arguments = append(yyDollar[1].node.(*ArgumentList).Arguments, yyDollar[3].node) + + yyVAL.node = yyDollar[1].node + } + case 268: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1357 + { + yyVAL.node = yylex.(*Parser).builder.NewArgument(yyDollar[1].node) + } + case 269: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:1358 + { + yyVAL.node = yylex.(*Parser).builder.NewVariadicArgument(yyDollar[1].token, yyDollar[2].node) + } + case 270: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1359 + { + yyVAL.node = yylex.(*Parser).builder.NewNamedArgument(yyDollar[1].token, yyDollar[2].token, yyDollar[3].node) + } + case 271: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1364 + { + yyDollar[1].node.(*ast.StmtGlobal).Vars = append(yyDollar[1].node.(*ast.StmtGlobal).Vars, yyDollar[3].node) + yyDollar[1].node.(*ast.StmtGlobal).SeparatorTkns = append(yyDollar[1].node.(*ast.StmtGlobal).SeparatorTkns, yyDollar[2].token) + + yyVAL.node = yyDollar[1].node + } + case 272: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1371 + { + yyVAL.node = &ast.StmtGlobal{ + Vars: []ast.Vertex{yyDollar[1].node}, + } + } + case 273: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1379 + { + yyVAL.node = yyDollar[1].node + } + case 274: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1384 + { + yyDollar[1].node.(*ast.StmtStatic).Vars = append(yyDollar[1].node.(*ast.StmtStatic).Vars, yyDollar[3].node) + yyDollar[1].node.(*ast.StmtStatic).SeparatorTkns = append(yyDollar[1].node.(*ast.StmtStatic).SeparatorTkns, yyDollar[2].token) + + yyVAL.node = yyDollar[1].node + } + case 275: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1391 + { + yyVAL.node = &ast.StmtStatic{ + Vars: []ast.Vertex{yyDollar[1].node}, + } + } + case 276: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1400 + { + yyVAL.node = &ast.StmtStaticVar{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + Var: &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + IdentifierTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + }, + }, + } + } + case 277: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1414 + { + yyVAL.node = &ast.StmtStaticVar{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[3].node), + Var: &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + IdentifierTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + }, + }, + EqualTkn: yyDollar[2].token, + Expr: yyDollar[3].node, + } + } + case 278: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:1432 + { + yyVAL.list = append(yyDollar[1].list, yyDollar[2].node) + } + case 279: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:1433 + { + yyVAL.list = []ast.Vertex{} + } + case 280: + yyDollar = yyS[yypt-5 : yypt+1] + // line internal/php8/php8.y:1438 + { + yyVAL.node = yylex.(*Parser).builder.NewPropertyList(yyDollar[1].list, yyDollar[2].list, yyDollar[3].node, yyDollar[4].node, yyDollar[5].token) + } + case 281: + yyDollar = yyS[yypt-5 : yypt+1] + // line internal/php8/php8.y:1440 + { + yyVAL.node = yylex.(*Parser).builder.NewClassConstList(yyDollar[1].list, yyDollar[2].list, yyDollar[3].token, yyDollar[4].node, yyDollar[5].token) + } + case 282: + yyDollar = yyS[yypt-10 : yypt+1] + // line internal/php8/php8.y:1442 + { + yyVAL.node = yylex.(*Parser).builder.NewClassMethod(yyDollar[1].list, yyDollar[2].list, yyDollar[3].token, yyDollar[4].token, yyDollar[5].token, yyDollar[6].token, yyDollar[7].node, yyDollar[8].token, yyDollar[9].node, yyDollar[10].node) + } + case 283: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1444 + { + traitUse := &ast.StmtTraitUse{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[3].node), + UseTkn: yyDollar[1].token, + Traits: yyDollar[2].node.(*ParserSeparatedList).Items, + SeparatorTkns: yyDollar[2].node.(*ParserSeparatedList).SeparatorTkns, + } + + switch n := yyDollar[3].node.(type) { + case *TraitAdaptationList: + traitUse.OpenCurlyBracketTkn = n.OpenCurlyBracketTkn + traitUse.Adaptations = n.Adaptations + traitUse.CloseCurlyBracketTkn = n.CloseCurlyBracketTkn + case *ast.StmtNop: + traitUse.SemiColonTkn = n.SemiColonTkn + } + + yyVAL.node = traitUse + } + case 284: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1466 + { + yyVAL.node = yylex.(*Parser).builder.NewSeparatedList(yyDollar[1].node) + } + case 285: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1467 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 286: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1472 + { + yyVAL.node = &ast.StmtNop{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + SemiColonTkn: yyDollar[1].token, + } + } + case 287: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:1479 + { + yyVAL.node = &TraitAdaptationList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[2].token), + OpenCurlyBracketTkn: yyDollar[1].token, + CloseCurlyBracketTkn: yyDollar[2].token, + } + } + case 288: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1487 + { + yyVAL.node = &TraitAdaptationList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token), + OpenCurlyBracketTkn: yyDollar[1].token, + Adaptations: yyDollar[2].list, + CloseCurlyBracketTkn: yyDollar[3].token, + } + } + case 289: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1498 + { + yyVAL.list = []ast.Vertex{yyDollar[1].node} + } + case 290: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:1499 + { + yyVAL.list = append(yyDollar[1].list, yyDollar[2].node) + } + case 291: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:1504 + { + yyDollar[1].node.(*ast.StmtTraitUsePrecedence).SemiColonTkn = yyDollar[2].token + + yyVAL.node = yyDollar[1].node + } + case 292: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:1510 + { + yyDollar[1].node.(*ast.StmtTraitUseAlias).SemiColonTkn = yyDollar[2].token + + yyVAL.node = yyDollar[1].node + } + case 293: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1519 + { + yyVAL.node = &ast.StmtTraitUsePrecedence{ + Position: yylex.(*Parser).builder.Pos.NewNodeNodeListPosition(yyDollar[1].node, yyDollar[3].node.(*ParserSeparatedList).Items), + Trait: yyDollar[1].node.(*TraitMethodRef).Trait, + DoubleColonTkn: yyDollar[1].node.(*TraitMethodRef).DoubleColonTkn, + Method: yyDollar[1].node.(*TraitMethodRef).Method, + InsteadofTkn: yyDollar[2].token, + Insteadof: yyDollar[3].node.(*ParserSeparatedList).Items, + SeparatorTkns: yyDollar[3].node.(*ParserSeparatedList).SeparatorTkns, + } + } + case 294: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1534 + { + yyVAL.node = &ast.StmtTraitUseAlias{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition(yyDollar[1].node, yyDollar[3].token), + Trait: yyDollar[1].node.(*TraitMethodRef).Trait, + DoubleColonTkn: yyDollar[1].node.(*TraitMethodRef).DoubleColonTkn, + Method: yyDollar[1].node.(*TraitMethodRef).Method, + AsTkn: yyDollar[2].token, + Alias: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[3].token), + IdentifierTkn: yyDollar[3].token, + Value: yyDollar[3].token.Value, + }, + } + } + case 295: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1549 + { + yyVAL.node = &ast.StmtTraitUseAlias{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition(yyDollar[1].node, yyDollar[3].token), + Trait: yyDollar[1].node.(*TraitMethodRef).Trait, + DoubleColonTkn: yyDollar[1].node.(*TraitMethodRef).DoubleColonTkn, + Method: yyDollar[1].node.(*TraitMethodRef).Method, + AsTkn: yyDollar[2].token, + Alias: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[3].token), + IdentifierTkn: yyDollar[3].token, + Value: yyDollar[3].token.Value, + }, + } + } + case 296: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:1564 + { + yyVAL.node = &ast.StmtTraitUseAlias{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition(yyDollar[1].node, yyDollar[4].token), + Trait: yyDollar[1].node.(*TraitMethodRef).Trait, + DoubleColonTkn: yyDollar[1].node.(*TraitMethodRef).DoubleColonTkn, + Method: yyDollar[1].node.(*TraitMethodRef).Method, + AsTkn: yyDollar[2].token, + Modifier: yyDollar[3].node, + Alias: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[4].token), + IdentifierTkn: yyDollar[4].token, + Value: yyDollar[4].token.Value, + }, + } + } + case 297: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1580 + { + yyVAL.node = &ast.StmtTraitUseAlias{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Trait: yyDollar[1].node.(*TraitMethodRef).Trait, + DoubleColonTkn: yyDollar[1].node.(*TraitMethodRef).DoubleColonTkn, + Method: yyDollar[1].node.(*TraitMethodRef).Method, + AsTkn: yyDollar[2].token, + Modifier: yyDollar[3].node, + } + } + case 298: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1594 + { + yyVAL.node = &TraitMethodRef{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + Method: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + IdentifierTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + }, + } + } + case 299: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1605 + { + yyVAL.node = yyDollar[1].node + } + case 300: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1612 + { + yyVAL.node = &TraitMethodRef{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition(yyDollar[1].node, yyDollar[3].token), + Trait: yyDollar[1].node, + DoubleColonTkn: yyDollar[2].token, + Method: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[3].token), + IdentifierTkn: yyDollar[3].token, + Value: yyDollar[3].token.Value, + }, + } + } + case 301: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1628 + { + yyVAL.node = &ast.StmtNop{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + SemiColonTkn: yyDollar[1].token, + } + } + case 302: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1635 + { + yyVAL.node = &ast.StmtStmtList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token), + OpenCurlyBracketTkn: yyDollar[1].token, + Stmts: yyDollar[2].list, + CloseCurlyBracketTkn: yyDollar[3].token, + } + } + case 303: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1646 + { + yyVAL.list = yyDollar[1].list + } + case 304: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1647 + { + yyVAL.list = []ast.Vertex{yylex.(*Parser).builder.NewIdentifier(yyDollar[1].token)} + } + case 305: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:1651 + { + yyVAL.list = nil + } + case 306: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1652 + { + yyVAL.list = yyDollar[1].list + } + case 307: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1656 + { + yyVAL.list = []ast.Vertex{yyDollar[1].node} + } + case 308: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:1657 + { + yyVAL.list = append(yyDollar[1].list, yyDollar[2].node) + } + case 309: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1661 + { + yyVAL.node = yylex.(*Parser).builder.NewIdentifier(yyDollar[1].token) + } + case 310: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1662 + { + yyVAL.node = yylex.(*Parser).builder.NewIdentifier(yyDollar[1].token) + } + case 311: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1663 + { + yyVAL.node = yylex.(*Parser).builder.NewIdentifier(yyDollar[1].token) + } + case 312: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1664 + { + yyVAL.node = yylex.(*Parser).builder.NewIdentifier(yyDollar[1].token) + } + case 313: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1665 + { + yyVAL.node = yylex.(*Parser).builder.NewIdentifier(yyDollar[1].token) + } + case 314: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1666 + { + yyVAL.node = yylex.(*Parser).builder.NewIdentifier(yyDollar[1].token) + } + case 315: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1670 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 316: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1671 + { + yyVAL.node = yylex.(*Parser).builder.NewSeparatedList(yyDollar[1].node) + } + case 317: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:1676 + { + yyVAL.node = &ast.StmtProperty{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + Var: &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + IdentifierTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + }, + }, + Expr: nil, + } + } + case 318: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:1691 + { + yyVAL.node = &ast.StmtProperty{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[3].node), + Var: &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + IdentifierTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + }, + }, + EqualTkn: yyDollar[2].token, + Expr: yyDollar[3].node, + } + } + case 319: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1709 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 320: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1710 + { + yyVAL.node = yylex.(*Parser).builder.NewSeparatedList(yyDollar[1].node) + } + case 321: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:1715 + { + yyVAL.node = &ast.StmtConstant{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[3].node), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + IdentifierTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + }, + EqualTkn: yyDollar[2].token, + Expr: yyDollar[3].node, + } + } + case 322: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:1731 + { + yyVAL.node = &ast.StmtConstant{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[3].node), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + IdentifierTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + }, + EqualTkn: yyDollar[2].token, + Expr: yyDollar[3].node, + } + } + case 323: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1747 + { + yyDollar[1].node.(*ast.StmtEcho).Exprs = append(yyDollar[1].node.(*ast.StmtEcho).Exprs, yyDollar[3].node) + yyDollar[1].node.(*ast.StmtEcho).SeparatorTkns = append(yyDollar[1].node.(*ast.StmtEcho).SeparatorTkns, yyDollar[2].token) + + yyVAL.node = yyDollar[1].node + } + case 324: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1754 + { + yyVAL.node = &ast.StmtEcho{ + Exprs: []ast.Vertex{yyDollar[1].node}, + } + } + case 325: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1762 + { + yyVAL.node = yyDollar[1].node + } + case 326: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:1766 + { + yyVAL.node = &ParserSeparatedList{} + } + case 327: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1767 + { + yyVAL.node = yyDollar[1].node + } + case 328: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1771 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 329: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1772 + { + yyVAL.node = yylex.(*Parser).builder.NewSeparatedList(yyDollar[1].node) + } + case 330: + yyDollar = yyS[yypt-8 : yypt+1] + // line internal/php8/php8.y:1778 + { + yyVAL.node = yylex.(*Parser).builder.NewAnonClass(yyDollar[1].list, yyDollar[2].token, yyDollar[3].node, yyDollar[4].node, yyDollar[5].node, yyDollar[6].token, yyDollar[7].list, yyDollar[8].token) + } + case 331: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1783 + { + if yyDollar[3].node != nil { + yyVAL.node = &ast.ExprNew{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[3].node), + NewTkn: yyDollar[1].token, + Class: yyDollar[2].node, + OpenParenthesisTkn: yyDollar[3].node.(*ArgumentList).OpenParenthesisTkn, + Args: yyDollar[3].node.(*ArgumentList).Arguments, + SeparatorTkns: yyDollar[3].node.(*ArgumentList).SeparatorTkns, + CloseParenthesisTkn: yyDollar[3].node.(*ArgumentList).CloseParenthesisTkn, + } + } else { + yyVAL.node = &ast.ExprNew{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + NewTkn: yyDollar[1].token, + Class: yyDollar[2].node, + } + } + } + case 332: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:1803 + { + yyVAL.node = &ast.ExprNew{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + NewTkn: yyDollar[1].token, + Class: yyDollar[2].node, + } + } + case 333: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:1814 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, nil) + } + case 334: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1818 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 335: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1819 + { + yyVAL.node = yylex.(*Parser).builder.NewSeparatedList(yyDollar[1].node) + } + case 336: + yyDollar = yyS[yypt-7 : yypt+1] + // line internal/php8/php8.y:1824 + { + yyVAL.node = yylex.(*Parser).builder.NewMatch(yyDollar[1].token, yyDollar[2].token, yyDollar[3].node, yyDollar[4].token, yyDollar[5].token, yyDollar[6].node, yyDollar[7].token) + } + case 337: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:1829 + { + yyVAL.node = nil + } + case 338: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:1831 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, nil) + } + case 339: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:1836 + { + yyVAL.node = yylex.(*Parser).builder.NewSeparatedList(yyDollar[1].node) + } + case 340: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1838 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 341: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1843 + { + yyVAL.node = yylex.(*Parser).builder.NewMatchArm(nil, nil, yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 342: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:1845 + { + yyVAL.node = yylex.(*Parser).builder.NewMatchArm(yyDollar[1].token, yyDollar[2].token, nil, yyDollar[3].token, yyDollar[4].node) + } + case 343: + yyDollar = yyS[yypt-6 : yypt+1] + // line internal/php8/php8.y:1850 + { + yyVAL.node = &ast.ExprAssign{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[6].node), + Var: &ast.ExprList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[4].token), + ListTkn: yyDollar[1].token, + OpenBracketTkn: yyDollar[2].token, + Items: yyDollar[3].node.(*ParserSeparatedList).Items, + SeparatorTkns: yyDollar[3].node.(*ParserSeparatedList).SeparatorTkns, + CloseBracketTkn: yyDollar[4].token, + }, + EqualTkn: yyDollar[5].token, + Expr: yyDollar[6].node, + } + } + case 344: + yyDollar = yyS[yypt-5 : yypt+1] + // line internal/php8/php8.y:1866 + { + yyVAL.node = &ast.ExprAssign{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[5].node), + Var: &ast.ExprList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token), + OpenBracketTkn: yyDollar[1].token, + Items: yyDollar[2].node.(*ParserSeparatedList).Items, + SeparatorTkns: yyDollar[2].node.(*ParserSeparatedList).SeparatorTkns, + CloseBracketTkn: yyDollar[3].token, + }, + EqualTkn: yyDollar[4].token, + Expr: yyDollar[5].node, + } + } + case 345: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1881 + { + yyVAL.node = &ast.ExprAssign{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Var: yyDollar[1].node, + EqualTkn: yyDollar[2].token, + Expr: yyDollar[3].node, + } + } + case 346: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:1890 + { + yyVAL.node = &ast.ExprAssignReference{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[4].node), + Var: yyDollar[1].node, + EqualTkn: yyDollar[2].token, + AmpersandTkn: yyDollar[3].token, + Expr: yyDollar[4].node, + } + } + case 347: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:1900 + { + yyVAL.node = &ast.ExprClone{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + CloneTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + } + } + case 348: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1908 + { + yyVAL.node = &ast.ExprAssignPlus{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Var: yyDollar[1].node, + EqualTkn: yyDollar[2].token, + Expr: yyDollar[3].node, + } + } + case 349: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1917 + { + yyVAL.node = &ast.ExprAssignMinus{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Var: yyDollar[1].node, + EqualTkn: yyDollar[2].token, + Expr: yyDollar[3].node, + } + } + case 350: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1926 + { + yyVAL.node = &ast.ExprAssignMul{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Var: yyDollar[1].node, + EqualTkn: yyDollar[2].token, + Expr: yyDollar[3].node, + } + } + case 351: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1935 + { + yyVAL.node = &ast.ExprAssignPow{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Var: yyDollar[1].node, + EqualTkn: yyDollar[2].token, + Expr: yyDollar[3].node, + } + } + case 352: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1944 + { + yyVAL.node = &ast.ExprAssignDiv{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Var: yyDollar[1].node, + EqualTkn: yyDollar[2].token, + Expr: yyDollar[3].node, + } + } + case 353: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1953 + { + yyVAL.node = &ast.ExprAssignConcat{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Var: yyDollar[1].node, + EqualTkn: yyDollar[2].token, + Expr: yyDollar[3].node, + } + } + case 354: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1962 + { + yyVAL.node = &ast.ExprAssignMod{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Var: yyDollar[1].node, + EqualTkn: yyDollar[2].token, + Expr: yyDollar[3].node, + } + } + case 355: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1971 + { + yyVAL.node = &ast.ExprAssignBitwiseAnd{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Var: yyDollar[1].node, + EqualTkn: yyDollar[2].token, + Expr: yyDollar[3].node, + } + } + case 356: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1980 + { + yyVAL.node = &ast.ExprAssignBitwiseOr{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Var: yyDollar[1].node, + EqualTkn: yyDollar[2].token, + Expr: yyDollar[3].node, + } + } + case 357: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1989 + { + yyVAL.node = &ast.ExprAssignBitwiseXor{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Var: yyDollar[1].node, + EqualTkn: yyDollar[2].token, + Expr: yyDollar[3].node, + } + } + case 358: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:1998 + { + yyVAL.node = &ast.ExprAssignShiftLeft{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Var: yyDollar[1].node, + EqualTkn: yyDollar[2].token, + Expr: yyDollar[3].node, + } + } + case 359: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2007 + { + yyVAL.node = &ast.ExprAssignShiftRight{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Var: yyDollar[1].node, + EqualTkn: yyDollar[2].token, + Expr: yyDollar[3].node, + } + } + case 360: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2016 + { + yyVAL.node = &ast.ExprAssignCoalesce{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Var: yyDollar[1].node, + EqualTkn: yyDollar[2].token, + Expr: yyDollar[3].node, + } + } + case 361: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2025 + { + yyVAL.node = &ast.ExprPostInc{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition(yyDollar[1].node, yyDollar[2].token), + Var: yyDollar[1].node, + IncTkn: yyDollar[2].token, + } + } + case 362: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2033 + { + yyVAL.node = &ast.ExprPreInc{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + IncTkn: yyDollar[1].token, + Var: yyDollar[2].node, + } + } + case 363: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2041 + { + yyVAL.node = &ast.ExprPostDec{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition(yyDollar[1].node, yyDollar[2].token), + Var: yyDollar[1].node, + DecTkn: yyDollar[2].token, + } + } + case 364: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2049 + { + yyVAL.node = &ast.ExprPreDec{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + DecTkn: yyDollar[1].token, + Var: yyDollar[2].node, + } + } + case 365: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2057 + { + yyVAL.node = &ast.ExprBinaryBooleanOr{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 366: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2066 + { + yyVAL.node = &ast.ExprBinaryBooleanAnd{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 367: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2075 + { + yyVAL.node = &ast.ExprBinaryLogicalOr{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 368: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2084 + { + yyVAL.node = &ast.ExprBinaryLogicalAnd{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 369: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2093 + { + yyVAL.node = &ast.ExprBinaryLogicalXor{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 370: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2102 + { + yyVAL.node = &ast.ExprBinaryBitwiseOr{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 371: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2111 + { + yyVAL.node = &ast.ExprBinaryBitwiseAnd{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 372: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2120 + { + yyVAL.node = &ast.ExprBinaryBitwiseXor{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 373: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2129 + { + yyVAL.node = &ast.ExprBinaryConcat{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 374: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2138 + { + yyVAL.node = &ast.ExprBinaryPlus{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 375: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2147 + { + yyVAL.node = &ast.ExprBinaryMinus{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 376: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2156 + { + yyVAL.node = &ast.ExprBinaryMul{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 377: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2165 + { + yyVAL.node = &ast.ExprBinaryPow{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 378: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2174 + { + yyVAL.node = &ast.ExprBinaryDiv{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 379: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2183 + { + yyVAL.node = &ast.ExprBinaryMod{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 380: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2192 + { + yyVAL.node = &ast.ExprBinaryShiftLeft{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 381: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2201 + { + yyVAL.node = &ast.ExprBinaryShiftRight{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 382: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2210 + { + yyVAL.node = &ast.ExprUnaryPlus{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + PlusTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + } + } + case 383: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2218 + { + yyVAL.node = &ast.ExprUnaryMinus{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + MinusTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + } + } + case 384: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2226 + { + yyVAL.node = &ast.ExprBooleanNot{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + ExclamationTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + } + } + case 385: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2234 + { + yyVAL.node = &ast.ExprBitwiseNot{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + TildaTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + } + } + case 386: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2242 + { + yyVAL.node = &ast.ExprBinaryIdentical{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 387: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2251 + { + yyVAL.node = &ast.ExprBinaryNotIdentical{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 388: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2260 + { + yyVAL.node = &ast.ExprBinaryEqual{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 389: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2269 + { + yyVAL.node = &ast.ExprBinaryNotEqual{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 390: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2278 + { + yyVAL.node = &ast.ExprBinarySmaller{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 391: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2287 + { + yyVAL.node = &ast.ExprBinarySmallerOrEqual{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 392: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2296 + { + yyVAL.node = &ast.ExprBinaryGreater{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 393: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2305 + { + yyVAL.node = &ast.ExprBinaryGreaterOrEqual{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 394: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2314 + { + yyVAL.node = &ast.ExprBinarySpaceship{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 395: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2323 + { + yyVAL.node = &ast.ExprInstanceOf{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Expr: yyDollar[1].node, + InstanceOfTkn: yyDollar[2].token, + Class: yyDollar[3].node, + } + } + case 396: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2332 + { + yyVAL.node = &ast.ExprBrackets{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token), + OpenParenthesisTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + CloseParenthesisTkn: yyDollar[3].token, + } + } + case 397: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2341 + { + yyVAL.node = yyDollar[1].node + } + case 398: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2345 + { + yyVAL.node = yyDollar[1].node + } + case 399: + yyDollar = yyS[yypt-5 : yypt+1] + // line internal/php8/php8.y:2349 + { + yyVAL.node = &ast.ExprTernary{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[5].node), + Cond: yyDollar[1].node, + QuestionTkn: yyDollar[2].token, + IfTrue: yyDollar[3].node, + ColonTkn: yyDollar[4].token, + IfFalse: yyDollar[5].node, + } + } + case 400: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:2360 + { + yyVAL.node = &ast.ExprTernary{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[4].node), + Cond: yyDollar[1].node, + QuestionTkn: yyDollar[2].token, + ColonTkn: yyDollar[3].token, + IfFalse: yyDollar[4].node, + } + } + case 401: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2370 + { + yyVAL.node = &ast.ExprBinaryCoalesce{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Left: yyDollar[1].node, + OpTkn: yyDollar[2].token, + Right: yyDollar[3].node, + } + } + case 402: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2379 + { + yyVAL.node = yyDollar[1].node + } + case 403: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2383 + { + yyVAL.node = &ast.ExprCastInt{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + CastTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + } + } + case 404: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2391 + { + yyVAL.node = &ast.ExprCastDouble{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + CastTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + } + } + case 405: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2399 + { + yyVAL.node = &ast.ExprCastString{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + CastTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + } + } + case 406: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2407 + { + yyVAL.node = &ast.ExprCastArray{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + CastTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + } + } + case 407: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2415 + { + yyVAL.node = &ast.ExprCastObject{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + CastTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + } + } + case 408: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2423 + { + yyVAL.node = &ast.ExprCastBool{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + CastTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + } + } + case 409: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2431 + { + yyVAL.node = &ast.ExprCastUnset{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + CastTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + } + } + case 410: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2439 + { + exit := &ast.ExprExit{ + ExitTkn: yyDollar[1].token, + } + + if yyDollar[2].node == nil { + exit.Position = yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token) + } else { + exit.Position = yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node) + exit.OpenParenthesisTkn = yyDollar[2].node.(*ast.ExprBrackets).OpenParenthesisTkn + exit.Expr = yyDollar[2].node.(*ast.ExprBrackets).Expr + exit.CloseParenthesisTkn = yyDollar[2].node.(*ast.ExprBrackets).CloseParenthesisTkn + } + + yyVAL.node = exit + } + case 411: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2456 + { + yyVAL.node = &ast.ExprErrorSuppress{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + AtTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + } + } + case 412: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2464 + { + yyVAL.node = yyDollar[1].node + } + case 413: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2468 + { + yyVAL.node = &ast.ExprShellExec{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token), + OpenBacktickTkn: yyDollar[1].token, + Parts: yyDollar[2].list, + CloseBacktickTkn: yyDollar[3].token, + } + } + case 414: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2477 + { + yyVAL.node = &ast.ExprPrint{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + PrintTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + } + } + case 415: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2485 + { + yyVAL.node = &ast.ExprYield{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + YieldTkn: yyDollar[1].token, + } + } + case 416: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2492 + { + yyVAL.node = &ast.ExprYield{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + YieldTkn: yyDollar[1].token, + Val: yyDollar[2].node, + } + } + case 417: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:2500 + { + yyVAL.node = &ast.ExprYield{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[4].node), + YieldTkn: yyDollar[1].token, + Key: yyDollar[2].node, + DoubleArrowTkn: yyDollar[3].token, + Val: yyDollar[4].node, + } + } + case 418: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2510 + { + yyVAL.node = &ast.ExprYieldFrom{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + YieldFromTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + } + } + case 419: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2518 + { + yyVAL.node = yylex.(*Parser).builder.NewThrowExpr(yyDollar[1].token, yyDollar[2].node) + } + case 420: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2522 + { + yyVAL.node = yyDollar[1].node + } + case 421: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2526 + { + switch n := yyDollar[2].node.(type) { + case *ast.ExprClosure: + n.Position = yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node) + n.StaticTkn = yyDollar[1].token + case *ast.ExprArrowFunction: + n.Position = yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node) + n.StaticTkn = yyDollar[1].token + } + + yyVAL.node = yyDollar[2].node + } + case 422: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2541 + { + yyVAL.node = yyDollar[1].node + } + case 423: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2543 + { + switch n := yyDollar[2].node.(type) { + case *ast.ExprClosure: + n.Position = yylex.(*Parser).builder.Pos.NewNodeListNodePosition(yyDollar[1].list, yyDollar[2].node) + n.AttrGroups = yyDollar[1].list + case *ast.ExprArrowFunction: + n.Position = yylex.(*Parser).builder.Pos.NewNodeListNodePosition(yyDollar[1].list, yyDollar[2].node) + n.AttrGroups = yyDollar[1].list + } + + yyVAL.node = yyDollar[2].node + } + case 424: + yyDollar = yyS[yypt-11 : yypt+1] + // line internal/php8/php8.y:2559 + { + closure := yyDollar[7].node.(*ast.ExprClosure) + + closure.Position = yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[11].token) + closure.FunctionTkn = yyDollar[1].token + closure.AmpersandTkn = yyDollar[2].token + closure.OpenParenthesisTkn = yyDollar[4].token + closure.Params = yyDollar[5].node.(*ParserSeparatedList).Items + closure.SeparatorTkns = yyDollar[5].node.(*ParserSeparatedList).SeparatorTkns + closure.CloseParenthesisTkn = yyDollar[6].token + closure.ColonTkn = yyDollar[8].node.(*ReturnType).ColonTkn + closure.ReturnType = yyDollar[8].node.(*ReturnType).Type + closure.OpenCurlyBracketTkn = yyDollar[9].token + closure.Stmts = yyDollar[10].list + closure.CloseCurlyBracketTkn = yyDollar[11].token + + yyVAL.node = closure + } + case 425: + yyDollar = yyS[yypt-9 : yypt+1] + // line internal/php8/php8.y:2578 + { + yyVAL.node = &ast.ExprArrowFunction{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[9].node), + FnTkn: yyDollar[1].token, + AmpersandTkn: yyDollar[2].token, + OpenParenthesisTkn: yyDollar[3].token, + Params: yyDollar[4].node.(*ParserSeparatedList).Items, + SeparatorTkns: yyDollar[4].node.(*ParserSeparatedList).SeparatorTkns, + CloseParenthesisTkn: yyDollar[5].token, + ColonTkn: yyDollar[6].node.(*ReturnType).ColonTkn, + ReturnType: yyDollar[6].node.(*ReturnType).Type, + DoubleArrowTkn: yyDollar[8].token, + Expr: yyDollar[9].node, + } + } + case 427: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:2600 + { + yyVAL.token = nil + } + case 428: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2601 + { + yyVAL.token = yyDollar[1].token + } + case 429: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:2606 + { + yyVAL.node = &ast.ExprClosure{} + } + case 430: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:2608 + { + yyVAL.node = &ast.ExprClosure{ + UseTkn: yyDollar[1].token, + UseOpenParenthesisTkn: yyDollar[2].token, + Uses: yyDollar[3].node.(*ParserSeparatedList).Items, + UseSeparatorTkns: yyDollar[3].node.(*ParserSeparatedList).SeparatorTkns, + UseCloseParenthesisTkn: yyDollar[4].token, + } + } + case 431: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2620 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, nil) + } + case 432: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2624 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 433: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2625 + { + yyVAL.node = yylex.(*Parser).builder.NewSeparatedList(yyDollar[1].node) + } + case 434: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2630 + { + yyVAL.node = &ast.ExprClosureUse{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + Var: &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + IdentifierTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + }, + }, + } + } + case 435: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2644 + { + yyVAL.node = &ast.ExprClosureUse{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[2].token), + AmpersandTkn: yyDollar[1].token, + Var: &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[2].token), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[2].token), + IdentifierTkn: yyDollar[2].token, + Value: yyDollar[2].token.Value, + }, + }, + } + } + case 436: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2662 + { + yyVAL.node = &ast.ExprFunctionCall{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[2].node), + Function: yyDollar[1].node, + OpenParenthesisTkn: yyDollar[2].node.(*ArgumentList).OpenParenthesisTkn, + Args: yyDollar[2].node.(*ArgumentList).Arguments, + SeparatorTkns: yyDollar[2].node.(*ArgumentList).SeparatorTkns, + CloseParenthesisTkn: yyDollar[2].node.(*ArgumentList).CloseParenthesisTkn, + } + } + case 437: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:2673 + { + staticCall := &ast.ExprStaticCall{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[4].node), + Class: yyDollar[1].node, + DoubleColonTkn: yyDollar[2].token, + Call: yyDollar[3].node, + OpenParenthesisTkn: yyDollar[4].node.(*ArgumentList).OpenParenthesisTkn, + Args: yyDollar[4].node.(*ArgumentList).Arguments, + SeparatorTkns: yyDollar[4].node.(*ArgumentList).SeparatorTkns, + CloseParenthesisTkn: yyDollar[4].node.(*ArgumentList).CloseParenthesisTkn, + } + + if brackets, ok := yyDollar[3].node.(*ParserBrackets); ok { + staticCall.OpenCurlyBracketTkn = brackets.OpenBracketTkn + staticCall.Call = brackets.Child + staticCall.CloseCurlyBracketTkn = brackets.CloseBracketTkn + } + + yyVAL.node = staticCall + } + case 438: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2694 + { + yyVAL.node = &ast.ExprFunctionCall{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[2].node), + Function: yyDollar[1].node, + OpenParenthesisTkn: yyDollar[2].node.(*ArgumentList).OpenParenthesisTkn, + Args: yyDollar[2].node.(*ArgumentList).Arguments, + SeparatorTkns: yyDollar[2].node.(*ArgumentList).SeparatorTkns, + CloseParenthesisTkn: yyDollar[2].node.(*ArgumentList).CloseParenthesisTkn, + } + } + case 439: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2707 + { + yyVAL.node = yyDollar[1].node + } + case 440: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2708 + { + yyVAL.node = yyDollar[1].node + } + case 441: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2712 + { + yyVAL.node = yylex.(*Parser).builder.NewIdentifier(yyDollar[1].token) + } + case 442: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2713 + { + yyVAL.node = yyDollar[1].node + } + case 443: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2717 + { + yyVAL.node = yyDollar[1].node + } + case 444: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2718 + { + yyVAL.node = yyDollar[1].node + } + case 445: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2719 + { + yyVAL.node = yylex.(*Parser).builder.NewBracket(yyDollar[1].token, yyDollar[2].node, yyDollar[3].token) + } + case 446: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:2723 + { + yyVAL.node = nil + } + case 447: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2724 + { + yyVAL.node = yylex.(*Parser).builder.NewBracket(yyDollar[1].token, yyDollar[2].node, yyDollar[3].token) + } + case 448: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:2729 + { + yyVAL.list = []ast.Vertex{} + } + case 449: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2733 + { + yyVAL.list = []ast.Vertex{ + &ast.ScalarEncapsedStringPart{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + EncapsedStrTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + }, + } + } + case 450: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2743 + { + yyVAL.list = yyDollar[1].list + } + case 451: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:2749 + { + yyVAL.node = nil + } + case 452: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2750 + { + yyVAL.node = yyDollar[1].node + } + case 453: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:2755 + { + yyVAL.node = &ast.ExprArray{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[4].token), + ArrayTkn: yyDollar[1].token, + OpenBracketTkn: yyDollar[2].token, + Items: yyDollar[3].node.(*ParserSeparatedList).Items, + SeparatorTkns: yyDollar[3].node.(*ParserSeparatedList).SeparatorTkns, + CloseBracketTkn: yyDollar[4].token, + } + } + case 454: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2766 + { + yyVAL.node = &ast.ExprArray{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token), + OpenBracketTkn: yyDollar[1].token, + Items: yyDollar[2].node.(*ParserSeparatedList).Items, + SeparatorTkns: yyDollar[2].node.(*ParserSeparatedList).SeparatorTkns, + CloseBracketTkn: yyDollar[3].token, + } + } + case 455: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2776 + { + yyVAL.node = &ast.ScalarString{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + StringTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + } + } + case 456: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2784 + { + yyVAL.node = &ast.ScalarEncapsed{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token), + OpenQuoteTkn: yyDollar[1].token, + Parts: yyDollar[2].list, + CloseQuoteTkn: yyDollar[3].token, + } + } + case 457: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2796 + { + yyVAL.node = &ast.ScalarLnumber{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + NumberTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + } + } + case 458: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2804 + { + yyVAL.node = &ast.ScalarDnumber{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + NumberTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + } + } + case 459: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2812 + { + yyVAL.node = &ast.ScalarHeredoc{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token), + OpenHeredocTkn: yyDollar[1].token, + Parts: []ast.Vertex{ + &ast.ScalarEncapsedStringPart{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[2].token), + EncapsedStrTkn: yyDollar[2].token, + Value: yyDollar[2].token.Value, + }, + }, + CloseHeredocTkn: yyDollar[3].token, + } + } + case 460: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2827 + { + yyVAL.node = &ast.ScalarHeredoc{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[2].token), + OpenHeredocTkn: yyDollar[1].token, + CloseHeredocTkn: yyDollar[2].token, + } + } + case 461: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2835 + { + yyVAL.node = &ast.ScalarHeredoc{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token), + OpenHeredocTkn: yyDollar[1].token, + Parts: yyDollar[2].list, + CloseHeredocTkn: yyDollar[3].token, + } + } + case 462: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2843 + { + yyVAL.node = yyDollar[1].node + } + case 463: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2844 + { + yyVAL.node = yyDollar[1].node + } + case 464: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2845 + { + yyVAL.node = yyDollar[1].node + } + case 465: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2850 + { + yyVAL.node = &ast.ExprClassConstFetch{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition(yyDollar[1].node, yyDollar[3].token), + Class: yyDollar[1].node, + DoubleColonTkn: yyDollar[2].token, + Const: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[3].token), + IdentifierTkn: yyDollar[3].token, + Value: yyDollar[3].token.Value, + }, + } + } + case 466: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2865 + { + yyVAL.node = yylex.(*Parser).builder.NewConstFetch(yyDollar[1].node) + } + case 467: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2866 + { + yyVAL.node = yylex.(*Parser).builder.NewScalarMagicConstant(yyDollar[1].token) + } + case 468: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2867 + { + yyVAL.node = yylex.(*Parser).builder.NewScalarMagicConstant(yyDollar[1].token) + } + case 469: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2868 + { + yyVAL.node = yylex.(*Parser).builder.NewScalarMagicConstant(yyDollar[1].token) + } + case 470: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2869 + { + yyVAL.node = yylex.(*Parser).builder.NewScalarMagicConstant(yyDollar[1].token) + } + case 471: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2870 + { + yyVAL.node = yylex.(*Parser).builder.NewScalarMagicConstant(yyDollar[1].token) + } + case 472: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2871 + { + yyVAL.node = yylex.(*Parser).builder.NewScalarMagicConstant(yyDollar[1].token) + } + case 473: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2872 + { + yyVAL.node = yylex.(*Parser).builder.NewScalarMagicConstant(yyDollar[1].token) + } + case 474: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2873 + { + yyVAL.node = yylex.(*Parser).builder.NewScalarMagicConstant(yyDollar[1].token) + } + case 475: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2877 + { + yyVAL.node = yyDollar[1].node + } + case 476: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2878 + { + yyVAL.node = yyDollar[1].node + } + case 477: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:2882 + { + yyVAL.node = nil + } + case 478: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2883 + { + yyVAL.node = yyDollar[1].node + } + case 479: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2887 + { + yyVAL.node = yyDollar[1].node + } + case 480: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2888 + { + yyVAL.node = yylex.(*Parser).builder.NewBracket(yyDollar[1].token, yyDollar[2].node, yyDollar[3].token) + } + case 481: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2889 + { + yyVAL.node = yyDollar[1].node + } + case 482: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2890 + { + yyVAL.node = yyDollar[1].node + } + case 483: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2894 + { + yyVAL.node = yyDollar[1].node + } + case 484: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2895 + { + yyVAL.node = yyDollar[1].node + } + case 485: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2899 + { + yyVAL.node = yyDollar[1].node + } + case 486: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2900 + { + yyVAL.node = yylex.(*Parser).builder.NewBracket(yyDollar[1].token, yyDollar[2].node, yyDollar[3].token) + } + case 487: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2901 + { + yyVAL.node = yyDollar[1].node + } + case 488: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2906 + { + yyVAL.node = yyDollar[1].node + } + case 489: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:2908 + { + yyVAL.node = &ast.ExprArrayDimFetch{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition(yyDollar[1].node, yyDollar[4].token), + Var: yyDollar[1].node, + OpenBracketTkn: yyDollar[2].token, + Dim: yyDollar[3].node, + CloseBracketTkn: yyDollar[4].token, + } + } + case 490: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:2918 + { + yylex.(*Parser).Error("Array and string offset access syntax with curly braces is no longer supported") + + yyVAL.node = &ast.ExprArrayDimFetch{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition(yyDollar[1].node, yyDollar[4].token), + Var: yyDollar[1].node, + OpenBracketTkn: yyDollar[2].token, + Dim: yyDollar[3].node, + CloseBracketTkn: yyDollar[4].token, + } + } + case 491: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:2930 + { + yyVAL.node = yylex.(*Parser).builder.NewMethodCall(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node, yyDollar[4].node) + } + case 492: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:2932 + { + yyVAL.node = yylex.(*Parser).builder.NewNullsafeMethodCall(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node, yyDollar[4].node) + } + case 493: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2934 + { + yyVAL.node = yyDollar[1].node + } + case 494: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2939 + { + yyVAL.node = yyDollar[1].node + } + case 495: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2941 + { + yyVAL.node = yyDollar[1].node + } + case 496: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2943 + { + yyVAL.node = yylex.(*Parser).builder.NewPropertyFetch(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 497: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2945 + { + yyVAL.node = yylex.(*Parser).builder.NewNullsafePropertyFetch(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 498: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2950 + { + yyVAL.node = &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + IdentifierTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + }, + } + } + case 499: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:2961 + { + yyVAL.node = &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[4].token), + DollarTkn: yyDollar[1].token, + OpenCurlyBracketTkn: yyDollar[2].token, + Name: yyDollar[3].node, + CloseCurlyBracketTkn: yyDollar[4].token, + } + } + case 500: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:2971 + { + yyVAL.node = &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + DollarTkn: yyDollar[1].token, + Name: yyDollar[2].node, + } + } + case 501: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:2982 + { + yyVAL.node = &ast.ExprStaticPropertyFetch{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Class: yyDollar[1].node, + DoubleColonTkn: yyDollar[2].token, + Prop: yyDollar[3].node, + } + } + case 502: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:2994 + { + yyVAL.node = yyDollar[1].node + } + case 503: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:2998 + { + yyVAL.node = &ast.ExprArrayDimFetch{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition(yyDollar[1].node, yyDollar[4].token), + Var: yyDollar[1].node, + OpenBracketTkn: yyDollar[2].token, + Dim: yyDollar[3].node, + CloseBracketTkn: yyDollar[4].token, + } + } + case 504: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:3008 + { + yylex.(*Parser).Error("Array and string offset access syntax with curly braces is no longer supported") + + yyVAL.node = &ast.ExprArrayDimFetch{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition(yyDollar[1].node, yyDollar[4].token), + Var: yyDollar[1].node, + OpenBracketTkn: yyDollar[2].token, + Dim: yyDollar[3].node, + CloseBracketTkn: yyDollar[4].token, + } + } + case 505: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:3020 + { + yyVAL.node = yylex.(*Parser).builder.NewPropertyFetch(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 506: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:3024 + { + yyVAL.node = yylex.(*Parser).builder.NewNullsafePropertyFetch(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 507: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:3028 + { + yyVAL.node = &ast.ExprStaticPropertyFetch{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Class: yyDollar[1].node, + DoubleColonTkn: yyDollar[2].token, + Prop: yyDollar[3].node, + } + } + case 508: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:3037 + { + yyVAL.node = &ast.ExprStaticPropertyFetch{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Class: yyDollar[1].node, + DoubleColonTkn: yyDollar[2].token, + Prop: yyDollar[3].node, + } + } + case 509: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:3048 + { + yyVAL.node = yylex.(*Parser).builder.NewIdentifier(yyDollar[1].token) + } + case 510: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:3049 + { + yyVAL.node = yylex.(*Parser).builder.NewBracket(yyDollar[1].token, yyDollar[2].node, yyDollar[3].token) + } + case 511: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:3050 + { + yyVAL.node = yyDollar[1].node + } + case 512: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:3054 + { + yyVAL.node = yylex.(*Parser).builder.NewIdentifier(yyDollar[1].token) + } + case 513: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:3055 + { + yyVAL.node = yylex.(*Parser).builder.NewBracket(yyDollar[1].token, yyDollar[2].node, yyDollar[3].token) + } + case 514: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:3056 + { + yyVAL.node = yyDollar[1].node + } + case 515: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:3061 + { + pairList := yyDollar[1].node.(*ParserSeparatedList) + fistPair := pairList.Items[0].(*ast.ExprArrayItem) + + if fistPair.Key == nil && fistPair.Val == nil && len(pairList.Items) == 1 { + pairList.Items = nil + } + + yyVAL.node = yyDollar[1].node + } + case 516: + yyDollar = yyS[yypt-0 : yypt+1] + // line internal/php8/php8.y:3074 + { + yyVAL.node = &ast.ExprArrayItem{} + } + case 517: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:3075 + { + yyVAL.node = yyDollar[1].node + } + case 518: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:3080 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 519: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:3082 + { + yyVAL.node = yylex.(*Parser).builder.NewSeparatedList(yyDollar[1].node) + } + case 520: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:3087 + { + yyVAL.node = &ast.ExprArrayItem{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[3].node), + Key: yyDollar[1].node, + DoubleArrowTkn: yyDollar[2].token, + Val: yyDollar[3].node, + } + } + case 521: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:3096 + { + yyVAL.node = &ast.ExprArrayItem{ + Position: yylex.(*Parser).builder.Pos.NewNodePosition(yyDollar[1].node), + Val: yyDollar[1].node, + } + } + case 522: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:3103 + { + yyVAL.node = &ast.ExprArrayItem{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition(yyDollar[1].node, yyDollar[4].node), + Key: yyDollar[1].node, + DoubleArrowTkn: yyDollar[2].token, + AmpersandTkn: yyDollar[3].token, + Val: yyDollar[4].node, + } + } + case 523: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:3113 + { + yyVAL.node = &ast.ExprArrayItem{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + AmpersandTkn: yyDollar[1].token, + Val: yyDollar[2].node, + } + } + case 524: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:3121 + { + yyVAL.node = &ast.ExprArrayItem{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + EllipsisTkn: yyDollar[1].token, + Val: yyDollar[2].node, + } + } + case 525: + yyDollar = yyS[yypt-6 : yypt+1] + // line internal/php8/php8.y:3129 + { + yyVAL.node = &ast.ExprArrayItem{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition(yyDollar[1].node, yyDollar[6].token), + Key: yyDollar[1].node, + DoubleArrowTkn: yyDollar[2].token, + Val: &ast.ExprList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[3].token, yyDollar[6].token), + ListTkn: yyDollar[3].token, + OpenBracketTkn: yyDollar[4].token, + Items: yyDollar[5].node.(*ParserSeparatedList).Items, + SeparatorTkns: yyDollar[5].node.(*ParserSeparatedList).SeparatorTkns, + CloseBracketTkn: yyDollar[6].token, + }, + } + } + case 526: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:3145 + { + yyVAL.node = &ast.ExprArrayItem{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[4].token), + Val: &ast.ExprList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[4].token), + ListTkn: yyDollar[1].token, + OpenBracketTkn: yyDollar[2].token, + Items: yyDollar[3].node.(*ParserSeparatedList).Items, + SeparatorTkns: yyDollar[3].node.(*ParserSeparatedList).SeparatorTkns, + CloseBracketTkn: yyDollar[4].token, + }, + } + } + case 527: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:3162 + { + yyVAL.list = append(yyDollar[1].list, yyDollar[2].node) + } + case 528: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:3166 + { + yyVAL.list = append( + yyDollar[1].list, + &ast.ScalarEncapsedStringPart{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[2].token), + EncapsedStrTkn: yyDollar[2].token, + Value: yyDollar[2].token.Value, + }, + ) + } + case 529: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:3177 + { + yyVAL.list = []ast.Vertex{yyDollar[1].node} + } + case 530: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:3181 + { + yyVAL.list = []ast.Vertex{ + &ast.ScalarEncapsedStringPart{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + EncapsedStrTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + }, + yyDollar[2].node, + } + } + case 531: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:3195 + { + yyVAL.node = &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + IdentifierTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + }, + } + } + case 532: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:3206 + { + yyVAL.node = &ast.ExprArrayDimFetch{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[4].token), + Var: &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + IdentifierTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + }, + }, + OpenBracketTkn: yyDollar[2].token, + Dim: yyDollar[3].node, + CloseBracketTkn: yyDollar[4].token, + } + } + case 533: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:3223 + { + yyVAL.node = yylex.(*Parser).builder.NewPropertyFetchFromTokens(yyDollar[1].token, yyDollar[2].token, yyDollar[3].token) + } + case 534: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:3227 + { + yyVAL.node = yylex.(*Parser).builder.NewNullsafePropertyFetchFromTokens(yyDollar[1].token, yyDollar[2].token, yyDollar[3].token) + } + case 535: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:3231 + { + yyVAL.node = &ast.ScalarEncapsedStringVar{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token), + DollarOpenCurlyBracketTkn: yyDollar[1].token, + Name: yyDollar[2].node, + CloseCurlyBracketTkn: yyDollar[3].token, + } + } + case 536: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:3240 + { + yyVAL.node = &ast.ScalarEncapsedStringVar{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token), + DollarOpenCurlyBracketTkn: yyDollar[1].token, + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[2].token), + IdentifierTkn: yyDollar[2].token, + Value: yyDollar[2].token.Value, + }, + CloseCurlyBracketTkn: yyDollar[3].token, + } + } + case 537: + yyDollar = yyS[yypt-6 : yypt+1] + // line internal/php8/php8.y:3253 + { + yyVAL.node = &ast.ScalarEncapsedStringVar{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token), + DollarOpenCurlyBracketTkn: yyDollar[1].token, + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[2].token), + IdentifierTkn: yyDollar[2].token, + Value: yyDollar[2].token.Value, + }, + OpenSquareBracketTkn: yyDollar[3].token, + Dim: yyDollar[4].node, + CloseSquareBracketTkn: yyDollar[5].token, + CloseCurlyBracketTkn: yyDollar[6].token, + } + } + case 538: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:3269 + { + yyVAL.node = &ast.ScalarEncapsedStringBrackets{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[3].token), + OpenCurlyBracketTkn: yyDollar[1].token, + Var: yyDollar[2].node, + CloseCurlyBracketTkn: yyDollar[3].token, + } + } + case 539: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:3281 + { + yyVAL.node = &ast.ScalarString{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + StringTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + } + } + case 540: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:3289 + { + // TODO: add option to handle 64 bit integer + if _, err := strconv.Atoi(string(yyDollar[1].token.Value)); err == nil { + yyVAL.node = &ast.ScalarLnumber{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + NumberTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + } + } else { + yyVAL.node = &ast.ScalarString{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + StringTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + } + } + } + case 541: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:3306 + { + _, err := strconv.Atoi(string(yyDollar[2].token.Value)) + isInt := err == nil + + if isInt { + yyVAL.node = &ast.ExprUnaryMinus{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[2].token), + MinusTkn: yyDollar[1].token, + Expr: &ast.ScalarLnumber{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[2].token), + NumberTkn: yyDollar[2].token, + Value: yyDollar[2].token.Value, + }, + } + } else { + yyVAL.node = &ast.ScalarString{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[2].token), + MinusTkn: yyDollar[1].token, + StringTkn: yyDollar[2].token, + Value: append([]byte("-"), yyDollar[2].token.Value...), + } + } + } + case 542: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:3330 + { + yyVAL.node = &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition(yyDollar[1].token), + IdentifierTkn: yyDollar[1].token, + Value: yyDollar[1].token.Value, + }, + } + } + case 543: + yyDollar = yyS[yypt-5 : yypt+1] + // line internal/php8/php8.y:3344 + { + if yyDollar[4].token != nil { + yyDollar[3].node.(*ParserSeparatedList).SeparatorTkns = append(yyDollar[3].node.(*ParserSeparatedList).SeparatorTkns, yyDollar[4].token) + } + + yyVAL.node = &ast.ExprIsset{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[5].token), + IssetTkn: yyDollar[1].token, + OpenParenthesisTkn: yyDollar[2].token, + Vars: yyDollar[3].node.(*ParserSeparatedList).Items, + SeparatorTkns: yyDollar[3].node.(*ParserSeparatedList).SeparatorTkns, + CloseParenthesisTkn: yyDollar[5].token, + } + } + case 544: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:3359 + { + yyVAL.node = &ast.ExprEmpty{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[4].token), + EmptyTkn: yyDollar[1].token, + OpenParenthesisTkn: yyDollar[2].token, + Expr: yyDollar[3].node, + CloseParenthesisTkn: yyDollar[4].token, + } + } + case 545: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:3369 + { + yyVAL.node = &ast.ExprInclude{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + IncludeTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + } + } + case 546: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:3377 + { + yyVAL.node = &ast.ExprIncludeOnce{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + IncludeOnceTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + } + } + case 547: + yyDollar = yyS[yypt-4 : yypt+1] + // line internal/php8/php8.y:3385 + { + yyVAL.node = &ast.ExprEval{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition(yyDollar[1].token, yyDollar[4].token), + EvalTkn: yyDollar[1].token, + OpenParenthesisTkn: yyDollar[2].token, + Expr: yyDollar[3].node, + CloseParenthesisTkn: yyDollar[4].token, + } + } + case 548: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:3395 + { + yyVAL.node = &ast.ExprRequire{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + RequireTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + } + } + case 549: + yyDollar = yyS[yypt-2 : yypt+1] + // line internal/php8/php8.y:3403 + { + yyVAL.node = &ast.ExprRequireOnce{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition(yyDollar[1].token, yyDollar[2].node), + RequireOnceTkn: yyDollar[1].token, + Expr: yyDollar[2].node, + } + } + case 550: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:3413 + { + yyVAL.node = yylex.(*Parser).builder.NewSeparatedList(yyDollar[1].node) + } + case 551: + yyDollar = yyS[yypt-3 : yypt+1] + // line internal/php8/php8.y:3414 + { + yyVAL.node = yylex.(*Parser).builder.AppendToSeparatedList(yyDollar[1].node, yyDollar[2].token, yyDollar[3].node) + } + case 552: + yyDollar = yyS[yypt-1 : yypt+1] + // line internal/php8/php8.y:3418 + { + yyVAL.node = yyDollar[1].node + } + } + goto yystack /* stack new state and value */ +} diff --git a/internal/php8/php8.y b/internal/php8/php8.y new file mode 100644 index 0000000..1fe8784 --- /dev/null +++ b/internal/php8/php8.y @@ -0,0 +1,3423 @@ +%{ +package php8 + +import ( + "strconv" + + "github.com/z7zmey/php-parser/pkg/ast" + "github.com/z7zmey/php-parser/pkg/token" +) + +%} + +%union{ + node ast.Vertex + token *token.Token + list []ast.Vertex +} + +%token T_INCLUDE +%token T_INCLUDE_ONCE +%token T_EXIT +%token T_IF +%token T_LNUMBER +%token T_DNUMBER +%token T_STRING +%token T_STRING_VARNAME +%token T_VARIABLE +%token T_NUM_STRING +%token T_INLINE_HTML +%token T_CHARACTER +%token T_BAD_CHARACTER +%token T_ENCAPSED_AND_WHITESPACE +%token T_CONSTANT_ENCAPSED_STRING +%token T_ECHO +%token T_DO +%token T_WHILE +%token T_ENDWHILE +%token T_FOR +%token T_ENDFOR +%token T_FOREACH +%token T_ENDFOREACH +%token T_DECLARE +%token T_ENDDECLARE +%token T_AS +%token T_SWITCH +%token T_ENDSWITCH +%token T_CASE +%token T_DEFAULT +%token T_BREAK +%token T_CONTINUE +%token T_GOTO +%token T_FUNCTION +%token T_FN +%token T_CONST +%token T_RETURN +%token T_TRY +%token T_CATCH +%token T_FINALLY +%token T_THROW +%token T_USE +%token T_INSTEADOF +%token T_GLOBAL +%token T_VAR +%token T_UNSET +%token T_ISSET +%token T_EMPTY +%token T_HALT_COMPILER +%token T_CLASS +%token T_TRAIT +%token T_INTERFACE +%token T_EXTENDS +%token T_IMPLEMENTS +%token T_OBJECT_OPERATOR +%token T_DOUBLE_ARROW +%token T_LIST +%token T_ARRAY +%token T_CALLABLE +%token T_CLASS_C +%token T_TRAIT_C +%token T_METHOD_C +%token T_FUNC_C +%token T_LINE +%token T_FILE +%token T_COMMENT +%token T_DOC_COMMENT +%token T_OPEN_TAG +%token T_OPEN_TAG_WITH_ECHO +%token T_CLOSE_TAG +%token T_WHITESPACE +%token T_START_HEREDOC +%token T_END_HEREDOC +%token T_DOLLAR_OPEN_CURLY_BRACES +%token T_CURLY_OPEN +%token T_PAAMAYIM_NEKUDOTAYIM +%token T_NAMESPACE +%token T_NS_C +%token T_DIR +%token T_NS_SEPARATOR +%token T_ELLIPSIS +%token T_EVAL +%token T_REQUIRE +%token T_REQUIRE_ONCE +%token T_LOGICAL_OR +%token T_LOGICAL_XOR +%token T_LOGICAL_AND +%token T_INSTANCEOF +%token T_NEW +%token T_CLONE +%token T_ELSEIF +%token T_ELSE +%token T_ENDIF +%token T_PRINT +%token T_YIELD +%token T_STATIC +%token T_ABSTRACT +%token T_FINAL +%token T_PRIVATE +%token T_PROTECTED +%token T_PUBLIC +%token T_INC +%token T_DEC +%token T_YIELD_FROM +%token T_INT_CAST +%token T_DOUBLE_CAST +%token T_STRING_CAST +%token T_ARRAY_CAST +%token T_OBJECT_CAST +%token T_BOOL_CAST +%token T_UNSET_CAST +%token T_COALESCE +%token T_SPACESHIP +%token T_NOELSE +%token T_PLUS_EQUAL +%token T_MINUS_EQUAL +%token T_MUL_EQUAL +%token T_POW_EQUAL +%token T_DIV_EQUAL +%token T_CONCAT_EQUAL +%token T_MOD_EQUAL +%token T_AND_EQUAL +%token T_OR_EQUAL +%token T_XOR_EQUAL +%token T_SL_EQUAL +%token T_SR_EQUAL +%token T_COALESCE_EQUAL +%token T_BOOLEAN_OR +%token T_BOOLEAN_AND +%token T_POW +%token T_SL +%token T_SR +%token T_IS_IDENTICAL +%token T_IS_NOT_IDENTICAL +%token T_IS_EQUAL +%token T_IS_NOT_EQUAL +%token T_IS_SMALLER_OR_EQUAL +%token T_IS_GREATER_OR_EQUAL +%token T_NULLSAFE_OBJECT_OPERATOR +%token T_MATCH +%token T_ATTRIBUTE +%token T_NAME_RELATIVE +%token T_NAME_QUALIFIED +%token T_NAME_FULLY_QUALIFIED +%token '"' +%token '`' +%token '{' +%token '}' +%token ';' +%token ':' +%token '(' +%token ')' +%token '[' +%token ']' +%token '?' +%token '&' +%token '-' +%token '+' +%token '!' +%token '~' +%token '@' +%token '$' +%token ',' +%token '|' +%token '=' +%token '^' +%token '*' +%token '/' +%token '%' +%token '<' +%token '>' +%token '.' + +%right T_THROW +%left T_INCLUDE T_INCLUDE_ONCE T_EVAL T_REQUIRE T_REQUIRE_ONCE +%left ',' +%left T_LOGICAL_OR +%left T_LOGICAL_XOR +%left T_LOGICAL_AND +%right T_PRINT +%right T_YIELD +%right T_DOUBLE_ARROW +%right T_YIELD_FROM +%left '=' T_PLUS_EQUAL T_MINUS_EQUAL T_MUL_EQUAL T_DIV_EQUAL T_CONCAT_EQUAL T_MOD_EQUAL T_AND_EQUAL T_OR_EQUAL T_XOR_EQUAL T_SL_EQUAL T_SR_EQUAL T_POW_EQUAL T_COALESCE_EQUAL +%left '?' ':' +%right T_COALESCE +%left T_BOOLEAN_OR +%left T_BOOLEAN_AND +%left '|' +%left '^' +%left '&' +%nonassoc T_IS_EQUAL T_IS_NOT_EQUAL T_IS_IDENTICAL T_IS_NOT_IDENTICAL T_SPACESHIP +%nonassoc '<' T_IS_SMALLER_OR_EQUAL '>' T_IS_GREATER_OR_EQUAL +%left '.' +%left T_SL T_SR +%left '+' '-' +%left '*' '/' '%' +%right '!' +%nonassoc T_INSTANCEOF +%right '~' T_INC T_DEC T_INT_CAST T_DOUBLE_CAST T_STRING_CAST T_ARRAY_CAST T_OBJECT_CAST T_BOOL_CAST T_UNSET_CAST '@' +%right T_POW +%right '[' +%nonassoc T_NEW T_CLONE +%left T_NOELSE +%left T_ELSEIF +%left T_ELSE +%left T_ENDIF +%right T_STATIC T_ABSTRACT T_FINAL T_PRIVATE T_PROTECTED T_PUBLIC + +%type optional_arg_ref optional_ellipsis returns_ref + +%type reserved_non_modifiers +%type semi_reserved +%type identifier identifier_ex +%type plain_variable optional_plain_variable +%type possible_comma +%type case_separator +%type use_type + +%type top_statement name statement function_declaration_statement +%type class_declaration_statement trait_declaration_statement +%type interface_declaration_statement +%type const_decl inner_statement for_exprs non_empty_for_exprs +%type expr optional_expr parameter_list non_empty_parameter_list +%type declare_statement finally_statement unset_variable variable +%type parameter argument expr_without_variable global_var_list global_var +%type static_var_list static_var class_statement trait_adaptation trait_precedence trait_alias +%type absolute_trait_method_reference trait_method_reference property echo_expr +%type new_expr anonymous_class class_name class_name_or_var class_name_reference simple_variable +%type internal_functions_in_yacc non_empty_array_pair_list array_pair_list +%type exit_expr scalar lexical_var function_call member_name property_name +%type constant class_constant +%type dereferencable_scalar fully_dereferencable array_object_dereferencable +%type callable_expr callable_variable static_member new_variable +%type encaps_var encaps_var_offset echo_expr_list name_union name_list +%type if_stmt const_list non_empty_argument_list property_list +%type alt_if_stmt lexical_var_list non_empty_lexical_var_list isset_variables class_const_list +%type if_stmt_without_else +%type group_use_declaration inline_use_declaration +%type use_declaration unprefixed_use_declaration non_empty_unprefixed_use_declarations +%type unprefixed_use_declarations non_empty_inline_use_declarations inline_use_declarations use_declarations +%type class_const_decl +%type namespace_name namespace_declaration_name legacy_namespace_name +%type alt_if_stmt_without_else +%type array_pair possible_array_pair +%type isset_variable + +%type type_expr type union_type optional_return_type +%type type_expr_without_static type_without_static union_type_without_static optional_type_without_static + +%type class_modifier +%type argument_list ctor_arguments +%type trait_adaptations +%type switch_case_list +%type method_body +%type foreach_statement for_statement while_statement +%type inline_function attributed_inline_function +%type unset_variables +%type extends_from +%type implements_list +%type interface_extends_list +%type lexical_vars +%type expr_list_allow_comma non_empty_expr_list +%type match match_arm match_arm_list non_empty_match_arm_list +%type catch_list catch +%type optional_visibility_modifier +%type attribute_decl attribute_group attribute + +%type member_modifier +%type foreach_variable + + +%type encaps_list backticks_expr +%type case_list trait_adaptation_list +%type top_statement_list +%type inner_statement_list class_statement_list +%type method_modifiers variable_modifiers +%type non_empty_member_modifiers class_modifiers optional_class_modifiers +%type optional_attributes attributes + +%% + +///////////////////////////////////////////////////////////////////////// + +start: + top_statement_list + { + yylex.(*Parser).currentToken.Value = nil + + yylex.(*Parser).rootNode = &ast.Root{ + Position: yylex.(*Parser).builder.Pos.NewNodeListPosition($1), + Stmts: $1, + EndTkn: yylex.(*Parser).currentToken, + } + } +; + +reserved_non_modifiers: + T_INCLUDE {$$=$1} | T_INCLUDE_ONCE {$$=$1} | T_EVAL {$$=$1} | T_REQUIRE {$$=$1} | T_REQUIRE_ONCE {$$=$1} | T_LOGICAL_OR {$$=$1} | T_LOGICAL_XOR {$$=$1} | T_LOGICAL_AND {$$=$1} + | T_INSTANCEOF {$$=$1} | T_NEW {$$=$1} | T_CLONE {$$=$1} | T_EXIT {$$=$1} | T_IF {$$=$1} | T_ELSEIF {$$=$1} | T_ELSE {$$=$1} | T_ENDIF {$$=$1} | T_ECHO {$$=$1} | T_DO {$$=$1} | T_WHILE {$$=$1} | T_ENDWHILE {$$=$1} + | T_FOR {$$=$1} | T_ENDFOR {$$=$1} | T_FOREACH {$$=$1} | T_ENDFOREACH {$$=$1} | T_DECLARE {$$=$1} | T_ENDDECLARE {$$=$1} | T_AS {$$=$1} | T_TRY {$$=$1} | T_CATCH {$$=$1} | T_FINALLY {$$=$1} + | T_THROW {$$=$1} | T_USE {$$=$1} | T_INSTEADOF {$$=$1} | T_GLOBAL {$$=$1} | T_VAR {$$=$1} | T_UNSET {$$=$1} | T_ISSET {$$=$1} | T_EMPTY {$$=$1} | T_CONTINUE {$$=$1} | T_GOTO {$$=$1} + | T_FUNCTION {$$=$1} | T_CONST {$$=$1} | T_RETURN {$$=$1} | T_PRINT {$$=$1} | T_YIELD {$$=$1} | T_LIST {$$=$1} | T_SWITCH {$$=$1} | T_ENDSWITCH {$$=$1} | T_CASE {$$=$1} | T_DEFAULT {$$=$1} | T_BREAK {$$=$1} + | T_ARRAY {$$=$1} | T_CALLABLE {$$=$1} | T_EXTENDS {$$=$1} | T_IMPLEMENTS {$$=$1} | T_NAMESPACE {$$=$1} | T_TRAIT {$$=$1} | T_INTERFACE {$$=$1} | T_CLASS {$$=$1} + | T_CLASS_C {$$=$1} | T_TRAIT_C {$$=$1} | T_FUNC_C {$$=$1} | T_METHOD_C {$$=$1} | T_LINE {$$=$1} | T_FILE {$$=$1} | T_DIR {$$=$1} | T_NS_C {$$=$1} | T_FN {$$=$1} | T_MATCH {$$=$1} +; + +semi_reserved: + reserved_non_modifiers + { + $$ = $1 + } + | T_STATIC {$$=$1} | T_ABSTRACT {$$=$1} | T_FINAL {$$=$1} | T_PRIVATE {$$=$1} | T_PROTECTED {$$=$1} | T_PUBLIC {$$=$1} +; + +identifier: + T_STRING { $$ = $1 } + | semi_reserved { $$ = $1 } +; + +identifier_ex: + T_STRING { $$ = $1 } + | semi_reserved { $$ = $1 } +; + +possible_comma: + /* empty */ { $$ = nil } + | ',' { $$ = $1 } +; + +optional_plain_variable: + /* empty */ { $$ = nil } + | plain_variable { $$ = $1 } +; + +plain_variable: + T_VARIABLE { $$ = $1 } +; + +top_statement_list: + top_statement_list top_statement { + if $2 != nil { + $$ = append($1, $2) + } + } + | /* empty */ { $$ = []ast.Vertex{} } +; + +namespace_declaration_name: + T_STRING { $$ = yylex.(*Parser).builder.NewName($1) } + | semi_reserved { $$ = yylex.(*Parser).builder.NewName($1) } + | T_NAME_QUALIFIED { $$ = yylex.(*Parser).builder.NewNameQualified($1) } +; + +namespace_name: + T_STRING { $$ = yylex.(*Parser).builder.NewName($1) } + | T_NAME_QUALIFIED { $$ = yylex.(*Parser).builder.NewNameQualified($1) } +; + +legacy_namespace_name: + namespace_name { $$ = $1 } + | T_NAME_FULLY_QUALIFIED { $$ = yylex.(*Parser).builder.NewNameFullyQualified($1) } +; + +name: + T_STRING { $$ = yylex.(*Parser).builder.NewName($1) } + | T_NAME_QUALIFIED { $$ = yylex.(*Parser).builder.NewNameQualified($1) } + | T_NAME_FULLY_QUALIFIED { $$ = yylex.(*Parser).builder.NewNameFullyQualified($1) } + | T_NAME_RELATIVE { $$ = yylex.(*Parser).builder.NewNameRelative($1) } +; + +attribute_decl: + class_name { $$ = yylex.(*Parser).builder.NewAttribute($1, nil) } + | class_name argument_list { $$ = yylex.(*Parser).builder.NewAttribute($1, $2) } +; + +attribute_group: + attribute_decl { $$ = yylex.(*Parser).builder.NewSeparatedList($1) } + | attribute_group ',' attribute_decl { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, $3) } +; + +attribute: + T_ATTRIBUTE attribute_group possible_comma ']' + { $$ = yylex.(*Parser).builder.NewAttributeGroup($1, $2, $3, $4) } +; + +attributes: + attribute { $$ = []ast.Vertex{$1} } + | attributes attribute { $$ = append($1, $2) } +; + +optional_attributes: + /* empty */ { $$ = nil } + | attributes { $$ = $1 } +; + +top_statement: + error { $$ = nil } + | statement { $$ = $1 } + | function_declaration_statement { $$ = $1 } + | class_declaration_statement { $$ = $1 } + | trait_declaration_statement { $$ = $1 } + | interface_declaration_statement { $$ = $1 } + | T_HALT_COMPILER '(' ')' ';' + { + $$ = &ast.StmtHaltCompiler{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $4), + HaltCompilerTkn: $1, + OpenParenthesisTkn: $2, + CloseParenthesisTkn: $3, + SemiColonTkn: $4, + } + } + | T_NAMESPACE namespace_declaration_name ';' + { $$ = yylex.(*Parser).builder.NewNamespace($1, $2, nil, nil, nil, $3) } + | T_NAMESPACE namespace_declaration_name '{' top_statement_list '}' + { $$ = yylex.(*Parser).builder.NewNamespace($1, $2, $3, $4, $5, nil) } + | T_NAMESPACE '{' top_statement_list '}' + { $$ = yylex.(*Parser).builder.NewNamespace($1, nil, $2, $3, $4, nil) } + + | T_USE use_declarations ';' + { $$ = yylex.(*Parser).builder.NewUseList($1, nil, $2, $3) } + | T_USE use_type use_declarations ';' + { $$ = yylex.(*Parser).builder.NewUseList($1, $2, $3, $4) } + | group_use_declaration + { $$ = $1 } + + | T_CONST const_list ';' + { + $$ = &ast.StmtConstList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3), + ConstTkn: $1, + Consts: $2.(*ParserSeparatedList).Items, + SeparatorTkns: $2.(*ParserSeparatedList).SeparatorTkns, + SemiColonTkn: $3, + } + } +; + +use_type: + T_FUNCTION { $$ = $1 } + | T_CONST { $$ = $1 } +; + +group_use_declaration: + T_USE use_type legacy_namespace_name T_NS_SEPARATOR '{' unprefixed_use_declarations '}' ';' + { $$ = yylex.(*Parser).builder.NewGroupUseList($1, $2, $3, $4, $5, $6, $7, $8) } + | T_USE legacy_namespace_name T_NS_SEPARATOR '{' inline_use_declarations '}' ';' + { $$ = yylex.(*Parser).builder.NewGroupUseList($1, nil, $2, $3, $4, $5, $6, $7) } +; + +inline_use_declarations: + non_empty_inline_use_declarations possible_comma + { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, nil) } +; + +non_empty_inline_use_declarations: + non_empty_inline_use_declarations ',' inline_use_declaration + { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, $3) } + | inline_use_declaration + { $$ = yylex.(*Parser).builder.NewSeparatedList($1) } +; + +unprefixed_use_declarations: + non_empty_unprefixed_use_declarations possible_comma + { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, nil) } +; + +non_empty_unprefixed_use_declarations: + non_empty_unprefixed_use_declarations ',' unprefixed_use_declaration + { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, $3) } + | unprefixed_use_declaration + { $$ = yylex.(*Parser).builder.NewSeparatedList($1) } +; + +use_declarations: + use_declarations ',' use_declaration { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, $3) } + | use_declaration { $$ = yylex.(*Parser).builder.NewSeparatedList($1) } +; + +inline_use_declaration: + unprefixed_use_declaration { $$ = $1 } + | use_type unprefixed_use_declaration { + decl := $2.(*ast.StmtUse) + decl.Type = yylex.(*Parser).builder.NewIdentifier($1) + decl.Position = yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2) + $$ = $2 + } +; + +unprefixed_use_declaration: + namespace_name { $$ = yylex.(*Parser).builder.NewUse(nil, $1, nil, nil) } + | namespace_name T_AS T_STRING { $$ = yylex.(*Parser).builder.NewUse(nil, $1, $2, $3)} +; + +use_declaration: + legacy_namespace_name { $$ = yylex.(*Parser).builder.NewUse(nil, $1, nil, nil) } + | legacy_namespace_name T_AS T_STRING { $$ = yylex.(*Parser).builder.NewUse(nil, $1, $2, $3)} +; + +const_list: + const_list ',' const_decl { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, $3) } + | const_decl { $$ = yylex.(*Parser).builder.NewSeparatedList($1)} +; + +inner_statement_list: + inner_statement_list inner_statement { + if $2 != nil { + $$ = append($1, $2) + } + } + | /* empty */ { $$ = []ast.Vertex{} } +; + +inner_statement: + error { $$ = nil } + | statement { $$ = $1 } + | function_declaration_statement { $$ = $1 } + | class_declaration_statement { $$ = $1 } + | trait_declaration_statement { $$ = $1 } + | interface_declaration_statement { $$ = $1 } + | T_HALT_COMPILER '(' ')' ';' + { + $$ = &ast.StmtHaltCompiler{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $4), + HaltCompilerTkn: $1, + OpenParenthesisTkn: $2, + CloseParenthesisTkn: $3, + SemiColonTkn: $4, + } + } + +statement: + '{' inner_statement_list '}' + { + $$ = &ast.StmtStmtList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3), + OpenCurlyBracketTkn: $1, + Stmts: $2, + CloseCurlyBracketTkn: $3, + } + } + | if_stmt + { + $$ = $1 + } + | alt_if_stmt + { + $$ = $1 + } + | T_WHILE '(' expr ')' while_statement + { + $5.(*ast.StmtWhile).WhileTkn = $1 + $5.(*ast.StmtWhile).OpenParenthesisTkn = $2 + $5.(*ast.StmtWhile).Cond = $3 + $5.(*ast.StmtWhile).CloseParenthesisTkn = $4 + $5.(*ast.StmtWhile).Position = yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $5) + + $$ = $5 + } + | T_DO statement T_WHILE '(' expr ')' ';' + { + $$ = &ast.StmtDo{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $7), + DoTkn: $1, + Stmt: $2, + WhileTkn: $3, + OpenParenthesisTkn: $4, + Cond: $5, + CloseParenthesisTkn: $6, + SemiColonTkn: $7, + } + } + | T_FOR '(' for_exprs ';' for_exprs ';' for_exprs ')' for_statement + { + $9.(*ast.StmtFor).ForTkn = $1 + $9.(*ast.StmtFor).OpenParenthesisTkn = $2 + $9.(*ast.StmtFor).Init = $3.(*ParserSeparatedList).Items + $9.(*ast.StmtFor).InitSeparatorTkns = $3.(*ParserSeparatedList).SeparatorTkns + $9.(*ast.StmtFor).InitSemiColonTkn = $4 + $9.(*ast.StmtFor).Cond = $5.(*ParserSeparatedList).Items + $9.(*ast.StmtFor).CondSeparatorTkns = $5.(*ParserSeparatedList).SeparatorTkns + $9.(*ast.StmtFor).CondSemiColonTkn = $6 + $9.(*ast.StmtFor).Loop = $7.(*ParserSeparatedList).Items + $9.(*ast.StmtFor).LoopSeparatorTkns = $7.(*ParserSeparatedList).SeparatorTkns + $9.(*ast.StmtFor).CloseParenthesisTkn = $8 + $9.(*ast.StmtFor).Position = yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $9) + + $$ = $9 + } + | T_SWITCH '(' expr ')' switch_case_list + { + $5.(*ast.StmtSwitch).SwitchTkn = $1 + $5.(*ast.StmtSwitch).OpenParenthesisTkn = $2 + $5.(*ast.StmtSwitch).Cond = $3 + $5.(*ast.StmtSwitch).CloseParenthesisTkn = $4 + $5.(*ast.StmtSwitch).Position = yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $5) + + $$ = $5 + } + | T_BREAK optional_expr ';' + { + $$ = &ast.StmtBreak{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3), + BreakTkn: $1, + Expr: $2, + SemiColonTkn: $3, + } + } + | T_CONTINUE optional_expr ';' + { + $$ = &ast.StmtContinue{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3), + ContinueTkn: $1, + Expr: $2, + SemiColonTkn: $3, + } + } + | T_RETURN optional_expr ';' + { + $$ = &ast.StmtReturn{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3), + ReturnTkn: $1, + Expr: $2, + SemiColonTkn: $3, + } + } + | T_GLOBAL global_var_list ';' + { + $2.(*ast.StmtGlobal).GlobalTkn = $1 + $2.(*ast.StmtGlobal).SemiColonTkn = $3 + $2.(*ast.StmtGlobal).Position = yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3) + + $$ = $2 + } + | T_STATIC static_var_list ';' + { + $2.(*ast.StmtStatic).StaticTkn = $1 + $2.(*ast.StmtStatic).SemiColonTkn = $3 + $2.(*ast.StmtStatic).Position = yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3) + + $$ = $2 + } + | T_ECHO echo_expr_list ';' + { + $2.(*ast.StmtEcho).EchoTkn = $1 + $2.(*ast.StmtEcho).SemiColonTkn = $3 + $2.(*ast.StmtEcho).Position = yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3) + + $$ = $2 + } + | T_INLINE_HTML + { + $$ = &ast.StmtInlineHtml{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + InlineHtmlTkn: $1, + Value: $1.Value, + } + } + | expr ';' + { + $$ = yylex.(*Parser).builder.NewExpressionStmt($1, $2) + } + | T_UNSET '(' unset_variables possible_comma ')' ';' + { + $3.(*ast.StmtUnset).UnsetTkn = $1 + $3.(*ast.StmtUnset).OpenParenthesisTkn = $2 + if $4 != nil { + $3.(*ast.StmtUnset).SeparatorTkns = append($3.(*ast.StmtUnset).SeparatorTkns, $4) + } + $3.(*ast.StmtUnset).CloseParenthesisTkn = $5 + $3.(*ast.StmtUnset).SemiColonTkn = $6 + $3.(*ast.StmtUnset).Position = yylex.(*Parser).builder.Pos.NewTokensPosition($1, $6) + + $$ = $3 + } + | T_FOREACH '(' expr T_AS foreach_variable ')' foreach_statement + { + foreach := $7.(*ast.StmtForeach) + + foreach.Position = yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $7) + foreach.ForeachTkn = $1 + foreach.OpenParenthesisTkn = $2 + foreach.Expr = $3 + foreach.AsTkn = $4 + foreach.Var = $5 + foreach.CloseParenthesisTkn = $6 + + if val, ok := $5.(*ast.StmtForeach); ok { + foreach.AmpersandTkn = val.AmpersandTkn + foreach.Var = val.Var + } + + $$ = foreach + } + | T_FOREACH '(' expr T_AS variable T_DOUBLE_ARROW foreach_variable ')' foreach_statement + { + foreach := $9.(*ast.StmtForeach) + + foreach.Position = yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $9) + foreach.ForeachTkn = $1 + foreach.OpenParenthesisTkn = $2 + foreach.Expr = $3 + foreach.AsTkn = $4 + foreach.Key = $5 + foreach.DoubleArrowTkn = $6 + foreach.Var = $7 + foreach.CloseParenthesisTkn = $8 + + if val, ok := $7.(*ast.StmtForeach); ok { + foreach.AmpersandTkn = val.AmpersandTkn + foreach.Var = val.Var + } + + $$ = foreach + } + | T_DECLARE '(' const_list ')' declare_statement + { + $5.(*ast.StmtDeclare).DeclareTkn = $1 + $5.(*ast.StmtDeclare).OpenParenthesisTkn = $2 + $5.(*ast.StmtDeclare).Consts = $3.(*ParserSeparatedList).Items + $5.(*ast.StmtDeclare).SeparatorTkns = $3.(*ParserSeparatedList).SeparatorTkns + $5.(*ast.StmtDeclare).CloseParenthesisTkn = $4 + $5.(*ast.StmtDeclare).Position = yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $5) + + $$ = $5 + } + | ';' + { + $$ = &ast.StmtNop{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + SemiColonTkn: $1, + } + } + | T_TRY '{' inner_statement_list '}' catch_list finally_statement + { + $$ = yylex.(*Parser).builder.NewTry($1, $2, $3, $4, $5, $6) + } + | T_GOTO T_STRING ';' + { + $$ = &ast.StmtGoto{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3), + GotoTkn: $1, + Label: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($2), + IdentifierTkn: $2, + Value: $2.Value, + }, + SemiColonTkn: $3, + } + } + | T_STRING ':' + { + $$ = &ast.StmtLabel{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $2), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + IdentifierTkn: $1, + Value: $1.Value, + }, + ColonTkn: $2, + } + } + +catch_list: + /* empty */ { $$ = yylex.(*Parser).builder.NewEmptySeparatedList() } + | catch_list catch { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, nil, $2) } +; + +catch: + T_CATCH '(' name_union optional_plain_variable ')' '{' inner_statement_list '}' + { $$ = yylex.(*Parser).builder.NewCatch($1, $2, $3, $4, $5, $6, $7, $8) } +; + +name_union: + name { $$ = yylex.(*Parser).builder.NewSeparatedList($1) } + | name_union '|' name { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, $3) } +; + +finally_statement: + /* empty */ + { + $$ = nil + } + | T_FINALLY '{' inner_statement_list '}' + { + $$ = &ast.StmtFinally{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $4), + FinallyTkn: $1, + OpenCurlyBracketTkn: $2, + Stmts: $3, + CloseCurlyBracketTkn: $4, + } + } +; + +unset_variables: + unset_variable + { + $$ = &ast.StmtUnset{ + Vars: []ast.Vertex{$1}, + } + } + | unset_variables ',' unset_variable + { + $1.(*ast.StmtUnset).Vars = append($1.(*ast.StmtUnset).Vars, $3) + $1.(*ast.StmtUnset).SeparatorTkns = append($1.(*ast.StmtUnset).SeparatorTkns, $2) + + $$ = $1 + } +; + +unset_variable: + variable { $$ = $1 } +; + +function_declaration_statement: + T_FUNCTION returns_ref T_STRING '(' parameter_list ')' optional_return_type '{' inner_statement_list '}' + { $$ = yylex.(*Parser).builder.NewFunction(nil, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10) } + | attributes + T_FUNCTION returns_ref T_STRING '(' parameter_list ')' optional_return_type '{' inner_statement_list '}' + { $$ = yylex.(*Parser).builder.NewFunction($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) } +; + +optional_arg_ref: + /* empty */ { $$ = nil } + | '&' { $$ = $1 } +; + +optional_ellipsis: + /* empty */ { $$ = nil } + | T_ELLIPSIS { $$ = $1 } +; + +optional_class_modifiers: + /* empty */ { $$ = nil } + | class_modifiers { $$ = $1 } +; + +class_modifiers: + class_modifier { $$ = []ast.Vertex{$1} } + | class_modifiers class_modifier { $$ = append($1, $2) } +; + +class_modifier: + T_ABSTRACT { $$ = yylex.(*Parser).builder.NewIdentifier($1) } + | T_FINAL { $$ = yylex.(*Parser).builder.NewIdentifier($1) } +; + +class_declaration_statement: + optional_attributes optional_class_modifiers + T_CLASS T_STRING extends_from implements_list '{' class_statement_list '}' + { $$ = yylex.(*Parser).builder.NewClass($1, $2, $3, $4, $5, $6, $7, $8, $9) } +; + +trait_declaration_statement: + optional_attributes + T_TRAIT T_STRING '{' class_statement_list '}' + { $$ = yylex.(*Parser).builder.NewTrait($1, $2, $3, $4, $5, $6) } +; + +interface_declaration_statement: + optional_attributes + T_INTERFACE T_STRING interface_extends_list '{' class_statement_list '}' + { $$ = yylex.(*Parser).builder.NewInterface($1, $2, $3, $4, $5, $6, $7) } +; + +extends_from: + /* empty */ + { + $$ = nil + } + | T_EXTENDS name + { + $$ = &ast.StmtClass{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + ExtendsTkn: $1, + Extends: $2, + } + } +; + +interface_extends_list: + /* empty */ + { + $$ = nil + } + | T_EXTENDS name_list + { + $$ = &ast.StmtInterface{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodeListPosition($1, $2.(*ParserSeparatedList).Items), + ExtendsTkn: $1, + Extends: $2.(*ParserSeparatedList).Items, + ExtendsSeparatorTkns: $2.(*ParserSeparatedList).SeparatorTkns, + }; + } +; + +implements_list: + /* empty */ + { + $$ = nil + } + | T_IMPLEMENTS name_list + { + $$ = &ast.StmtClass{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodeListPosition($1, $2.(*ParserSeparatedList).Items), + ImplementsTkn: $1, + Implements: $2.(*ParserSeparatedList).Items, + ImplementsSeparatorTkns: $2.(*ParserSeparatedList).SeparatorTkns, + }; + } +; + +foreach_variable: + variable + { + $$ = $1 + } + | '&' variable + { + $$ = &ast.StmtForeach{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + AmpersandTkn: $1, + Var: $2, + } + } + | T_LIST '(' array_pair_list ')' + { + $$ = &ast.ExprList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $4), + ListTkn: $1, + OpenBracketTkn: $2, + Items: $3.(*ParserSeparatedList).Items, + SeparatorTkns: $3.(*ParserSeparatedList).SeparatorTkns, + CloseBracketTkn: $4, + } + } + | '[' array_pair_list ']' + { + $$ = &ast.ExprList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3), + OpenBracketTkn: $1, + Items: $2.(*ParserSeparatedList).Items, + SeparatorTkns: $2.(*ParserSeparatedList).SeparatorTkns, + CloseBracketTkn: $3, + } + } +; + +for_statement: + statement + { + $$ = &ast.StmtFor{ + Position: yylex.(*Parser).builder.Pos.NewNodePosition($1), + Stmt: $1, + } + } + | ':' inner_statement_list T_ENDFOR ';' + { + $$ = &ast.StmtFor{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $4), + ColonTkn: $1, + Stmt: &ast.StmtStmtList{ + Position: yylex.(*Parser).builder.Pos.NewNodeListPosition($2), + Stmts: $2, + }, + EndForTkn: $3, + SemiColonTkn: $4, + } + } +; + +foreach_statement: + statement + { + $$ = &ast.StmtForeach{ + Position: yylex.(*Parser).builder.Pos.NewNodePosition($1), + Stmt: $1, + } + } + | ':' inner_statement_list T_ENDFOREACH ';' + { + $$ = &ast.StmtForeach{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $4), + ColonTkn: $1, + Stmt: &ast.StmtStmtList{ + Position: yylex.(*Parser).builder.Pos.NewNodeListPosition($2), + Stmts: $2, + }, + EndForeachTkn: $3, + SemiColonTkn: $4, + } + } +; + +declare_statement: + statement + { + $$ = &ast.StmtDeclare{ + Position: yylex.(*Parser).builder.Pos.NewNodePosition($1), + Stmt: $1, + } + } + | ':' inner_statement_list T_ENDDECLARE ';' + { + $$ = &ast.StmtDeclare{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $4), + ColonTkn: $1, + Stmt: &ast.StmtStmtList{ + Position: yylex.(*Parser).builder.Pos.NewNodeListPosition($2), + Stmts: $2, + }, + EndDeclareTkn: $3, + SemiColonTkn: $4, + } + } +; + +switch_case_list: + '{' case_list '}' + { + $$ = &ast.StmtSwitch{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3), + OpenCurlyBracketTkn: $1, + Cases: $2, + CloseCurlyBracketTkn: $3, + } + } + | '{' ';' case_list '}' + { + $$ = &ast.StmtSwitch{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $4), + OpenCurlyBracketTkn: $1, + CaseSeparatorTkn: $2, + Cases: $3, + CloseCurlyBracketTkn: $4, + } + } + | ':' case_list T_ENDSWITCH ';' + { + $$ = &ast.StmtSwitch{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $4), + ColonTkn: $1, + Cases: $2, + EndSwitchTkn: $3, + SemiColonTkn: $4, + } + } + | ':' ';' case_list T_ENDSWITCH ';' + { + $$ = &ast.StmtSwitch{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $5), + ColonTkn: $1, + CaseSeparatorTkn: $2, + Cases: $3, + EndSwitchTkn: $4, + SemiColonTkn: $5, + } + } +; + +case_list: + /* empty */ + { + $$ = nil + } + | case_list T_CASE expr case_separator inner_statement_list + { + $$ = append($1, &ast.StmtCase{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodeListPosition($2, $5), + CaseTkn: $2, + Cond: $3, + CaseSeparatorTkn: $4, + Stmts: $5, + }) + } + | case_list T_DEFAULT case_separator inner_statement_list + { + $$ = append($1, &ast.StmtDefault{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodeListPosition($2, $4), + DefaultTkn: $2, + CaseSeparatorTkn: $3, + Stmts: $4, + }) + } +; + +case_separator: + ':' { $$ = $1 } + | ';' { $$ = $1 } +; + +while_statement: + statement + { + $$ = &ast.StmtWhile{ + Position: yylex.(*Parser).builder.Pos.NewNodePosition($1), + Stmt: $1, + } + } + | ':' inner_statement_list T_ENDWHILE ';' + { + $$ = &ast.StmtWhile{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $4), + ColonTkn: $1, + Stmt: &ast.StmtStmtList{ + Position: yylex.(*Parser).builder.Pos.NewNodeListPosition($2), + Stmts: $2, + }, + EndWhileTkn: $3, + SemiColonTkn: $4, + } + } +; + +if_stmt_without_else: + T_IF '(' expr ')' statement + { + $$ = &ast.StmtIf{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $5), + IfTkn: $1, + OpenParenthesisTkn: $2, + Cond: $3, + CloseParenthesisTkn: $4, + Stmt: $5, + } + } + | if_stmt_without_else T_ELSEIF '(' expr ')' statement + { + $1.(*ast.StmtIf).ElseIf = append($1.(*ast.StmtIf).ElseIf, &ast.StmtElseIf{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($2, $6), + ElseIfTkn: $2, + OpenParenthesisTkn: $3, + Cond: $4, + CloseParenthesisTkn: $5, + Stmt: $6, + }) + + $1.(*ast.StmtIf).Position = yylex.(*Parser).builder.Pos.NewNodesPosition($1, $6) + + $$ = $1 + } +; + +if_stmt: + if_stmt_without_else %prec T_NOELSE + { + $$ = $1 + } + | if_stmt_without_else T_ELSE statement + { + $1.(*ast.StmtIf).Else = &ast.StmtElse{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($2, $3), + ElseTkn: $2, + Stmt: $3, + } + + $1.(*ast.StmtIf).Position = yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3) + + $$ = $1 + } +; + +alt_if_stmt_without_else: + T_IF '(' expr ')' ':' inner_statement_list + { + $$ = &ast.StmtIf{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodeListPosition($1, $6), + IfTkn: $1, + OpenParenthesisTkn: $2, + Cond: $3, + CloseParenthesisTkn: $4, + ColonTkn: $5, + Stmt: &ast.StmtStmtList{ + Position: yylex.(*Parser).builder.Pos.NewNodeListPosition($6), + Stmts: $6, + }, + } + } + | alt_if_stmt_without_else T_ELSEIF '(' expr ')' ':' inner_statement_list + { + $1.(*ast.StmtIf).ElseIf = append($1.(*ast.StmtIf).ElseIf, &ast.StmtElseIf{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodeListPosition($2, $7), + ElseIfTkn: $2, + OpenParenthesisTkn: $3, + Cond: $4, + CloseParenthesisTkn: $5, + ColonTkn: $6, + Stmt: &ast.StmtStmtList{ + Position: yylex.(*Parser).builder.Pos.NewNodeListPosition($7), + Stmts: $7, + }, + }) + + $$ = $1 + } +; + +alt_if_stmt: + alt_if_stmt_without_else T_ENDIF ';' + { + $1.(*ast.StmtIf).EndIfTkn = $2 + $1.(*ast.StmtIf).SemiColonTkn = $3 + $1.(*ast.StmtIf).Position = yylex.(*Parser).builder.Pos.NewNodeTokenPosition($1, $3) + + $$ = $1 + } + | alt_if_stmt_without_else T_ELSE ':' inner_statement_list T_ENDIF ';' + { + $1.(*ast.StmtIf).Else = &ast.StmtElse{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodeListPosition($2, $4), + ElseTkn: $2, + ColonTkn: $3, + Stmt: &ast.StmtStmtList{ + Position: yylex.(*Parser).builder.Pos.NewNodeListPosition($4), + Stmts: $4, + }, + } + $1.(*ast.StmtIf).EndIfTkn = $5 + $1.(*ast.StmtIf).SemiColonTkn = $6 + $1.(*ast.StmtIf).Position = yylex.(*Parser).builder.Pos.NewNodeTokenPosition($1, $6) + + $$ = $1 + } +; + +parameter_list: + non_empty_parameter_list possible_comma { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, nil) } + | /* empty */ { $$ = yylex.(*Parser).builder.NewEmptySeparatedList() } +; + +non_empty_parameter_list: + parameter { $$ = yylex.(*Parser).builder.NewSeparatedList($1) } + | non_empty_parameter_list ',' parameter { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, $3) } +; + +optional_visibility_modifier: + /* empty */ { $$ = nil; } + | T_PUBLIC { $$ = yylex.(*Parser).builder.NewIdentifier($1) } + | T_PROTECTED { $$ = yylex.(*Parser).builder.NewIdentifier($1) } + | T_PRIVATE { $$ = yylex.(*Parser).builder.NewIdentifier($1) } +; + +parameter: + optional_attributes optional_visibility_modifier optional_type_without_static + optional_arg_ref optional_ellipsis plain_variable + { $$ = yylex.(*Parser).builder.NewParameter($1, $2, $3, $4, $5, $6, nil, nil, false) } + | optional_attributes optional_visibility_modifier optional_type_without_static + optional_arg_ref optional_ellipsis plain_variable '=' expr + { $$ = yylex.(*Parser).builder.NewParameter($1, $2, $3, $4, $5, $6, $7, $8, true) } +; + +type_expr: + type { $$ = $1 } + | '?' type { $$ = yylex.(*Parser).builder.NewNullableType($1, $2) } + | union_type { $$ = yylex.(*Parser).builder.NewUnionType($1) } +; + +type: + type_without_static { $$ = $1 } + | T_STATIC { $$ = yylex.(*Parser).builder.NewNameType($1) } +; + +type_without_static: + T_ARRAY { $$ = yylex.(*Parser).builder.NewNameType($1) } + | T_CALLABLE { $$ = yylex.(*Parser).builder.NewNameType($1) } + | name { $$ = $1 } +; + +union_type: + type '|' type { $$ = yylex.(*Parser).builder.NewSeparatedListWithTwoElements($1, $2, $3) } + | union_type '|' type { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, $3) } +; + +union_type_without_static: + type_without_static '|' type_without_static + { $$ = yylex.(*Parser).builder.NewSeparatedListWithTwoElements($1, $2, $3) } + | union_type_without_static '|' type_without_static + { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, $3) } +; + +type_expr_without_static: + type_without_static { $$ = $1 } + | '?' type_without_static { $$ = yylex.(*Parser).builder.NewNullableType($1, $2) } + | union_type_without_static { $$ = yylex.(*Parser).builder.NewUnionType($1) } +; + +optional_type_without_static: + /* empty */ { $$ = nil } + | type_expr_without_static { $$ = $1 } +; + +optional_return_type: + /* empty */ { $$ = &ReturnType{} } + | ':' type_expr { $$ = yylex.(*Parser).builder.NewReturnType($1, $2) } +; + +argument_list: + '(' ')' + { + $$ = &ArgumentList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $2), + OpenParenthesisTkn: $1, + CloseParenthesisTkn: $2, + } + } + | '(' non_empty_argument_list possible_comma ')' + { + argumentList := $2.(*ArgumentList) + argumentList.Position = yylex.(*Parser).builder.Pos.NewTokensPosition($1, $4) + argumentList.OpenParenthesisTkn = $1 + if $3 != nil { + argumentList.SeparatorTkns = append(argumentList.SeparatorTkns, $3) + } + argumentList.CloseParenthesisTkn = $4 + + $$ = argumentList + } +; + +non_empty_argument_list: + argument + { + $$ = &ArgumentList{ + Arguments: []ast.Vertex{$1}, + } + } + | non_empty_argument_list ',' argument + { + $1.(*ArgumentList).SeparatorTkns = append($1.(*ArgumentList).SeparatorTkns, $2) + $1.(*ArgumentList).Arguments = append($1.(*ArgumentList).Arguments, $3) + + $$ = $1 + } +; + +argument: + expr { $$ = yylex.(*Parser).builder.NewArgument($1) } + | T_ELLIPSIS expr { $$ = yylex.(*Parser).builder.NewVariadicArgument($1, $2) } + | identifier_ex ':' expr { $$ = yylex.(*Parser).builder.NewNamedArgument($1, $2, $3) } +; + +global_var_list: + global_var_list ',' global_var + { + $1.(*ast.StmtGlobal).Vars = append($1.(*ast.StmtGlobal).Vars, $3) + $1.(*ast.StmtGlobal).SeparatorTkns = append($1.(*ast.StmtGlobal).SeparatorTkns, $2) + + $$ = $1 + } + | global_var + { + $$ = &ast.StmtGlobal{ + Vars: []ast.Vertex{$1}, + } + } +; + +global_var: + simple_variable { $$ = $1 } +; + +static_var_list: + static_var_list ',' static_var + { + $1.(*ast.StmtStatic).Vars = append($1.(*ast.StmtStatic).Vars, $3) + $1.(*ast.StmtStatic).SeparatorTkns = append($1.(*ast.StmtStatic).SeparatorTkns, $2) + + $$ = $1 + } + | static_var + { + $$ = &ast.StmtStatic{ + Vars: []ast.Vertex{$1}, + } + } +; + +static_var: + plain_variable + { + $$ = &ast.StmtStaticVar{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + Var: &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + IdentifierTkn: $1, + Value: $1.Value, + }, + }, + } + } + | plain_variable '=' expr + { + $$ = &ast.StmtStaticVar{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $3), + Var: &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + IdentifierTkn: $1, + Value: $1.Value, + }, + }, + EqualTkn: $2, + Expr: $3, + } + } +; + +class_statement_list: + class_statement_list class_statement { $$ = append($1, $2) } + | /* empty */ { $$ = []ast.Vertex{} } +; + +class_statement: + optional_attributes variable_modifiers optional_type_without_static property_list ';' + { $$ = yylex.(*Parser).builder.NewPropertyList($1, $2, $3, $4, $5) } + | optional_attributes method_modifiers T_CONST class_const_list ';' + { $$ = yylex.(*Parser).builder.NewClassConstList($1, $2, $3, $4, $5) } + | optional_attributes method_modifiers T_FUNCTION returns_ref identifier '(' parameter_list ')' optional_return_type method_body + { $$ = yylex.(*Parser).builder.NewClassMethod($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) } + | T_USE name_list trait_adaptations + { + traitUse := &ast.StmtTraitUse{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $3), + UseTkn: $1, + Traits: $2.(*ParserSeparatedList).Items, + SeparatorTkns: $2.(*ParserSeparatedList).SeparatorTkns, + } + + switch n := $3.(type) { + case *TraitAdaptationList : + traitUse.OpenCurlyBracketTkn = n.OpenCurlyBracketTkn + traitUse.Adaptations = n.Adaptations + traitUse.CloseCurlyBracketTkn = n.CloseCurlyBracketTkn + case *ast.StmtNop : + traitUse.SemiColonTkn = n.SemiColonTkn + }; + + $$ = traitUse + } +; + +name_list: + name { $$ = yylex.(*Parser).builder.NewSeparatedList($1) } + | name_list ',' name { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, $3) } +; + +trait_adaptations: + ';' + { + $$ = &ast.StmtNop{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + SemiColonTkn: $1, + } + } + | '{' '}' + { + $$ = &TraitAdaptationList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $2), + OpenCurlyBracketTkn: $1, + CloseCurlyBracketTkn: $2, + } + } + | '{' trait_adaptation_list '}' + { + $$ = &TraitAdaptationList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3), + OpenCurlyBracketTkn: $1, + Adaptations: $2, + CloseCurlyBracketTkn: $3, + } + } +; + +trait_adaptation_list: + trait_adaptation { $$ = []ast.Vertex{$1} } + | trait_adaptation_list trait_adaptation { $$ = append($1, $2) } +; + +trait_adaptation: + trait_precedence ';' + { + $1.(*ast.StmtTraitUsePrecedence).SemiColonTkn = $2 + + $$ = $1; + } + | trait_alias ';' + { + $1.(*ast.StmtTraitUseAlias).SemiColonTkn = $2 + + $$ = $1; + } +; + +trait_precedence: + absolute_trait_method_reference T_INSTEADOF name_list + { + $$ = &ast.StmtTraitUsePrecedence{ + Position: yylex.(*Parser).builder.Pos.NewNodeNodeListPosition($1, $3.(*ParserSeparatedList).Items), + Trait: $1.(*TraitMethodRef).Trait, + DoubleColonTkn: $1.(*TraitMethodRef).DoubleColonTkn, + Method: $1.(*TraitMethodRef).Method, + InsteadofTkn: $2, + Insteadof: $3.(*ParserSeparatedList).Items, + SeparatorTkns: $3.(*ParserSeparatedList).SeparatorTkns, + } + } +; + +trait_alias: + trait_method_reference T_AS T_STRING + { + $$ = &ast.StmtTraitUseAlias{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition($1, $3), + Trait: $1.(*TraitMethodRef).Trait, + DoubleColonTkn: $1.(*TraitMethodRef).DoubleColonTkn, + Method: $1.(*TraitMethodRef).Method, + AsTkn: $2, + Alias: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($3), + IdentifierTkn: $3, + Value: $3.Value, + }, + } + } + | trait_method_reference T_AS reserved_non_modifiers + { + $$ = &ast.StmtTraitUseAlias{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition($1, $3), + Trait: $1.(*TraitMethodRef).Trait, + DoubleColonTkn: $1.(*TraitMethodRef).DoubleColonTkn, + Method: $1.(*TraitMethodRef).Method, + AsTkn: $2, + Alias: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($3), + IdentifierTkn: $3, + Value: $3.Value, + }, + } + } + | trait_method_reference T_AS member_modifier identifier + { + $$ = &ast.StmtTraitUseAlias{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition($1, $4), + Trait: $1.(*TraitMethodRef).Trait, + DoubleColonTkn: $1.(*TraitMethodRef).DoubleColonTkn, + Method: $1.(*TraitMethodRef).Method, + AsTkn: $2, + Modifier: $3, + Alias: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($4), + IdentifierTkn: $4, + Value: $4.Value, + }, + } + } + | trait_method_reference T_AS member_modifier + { + $$ = &ast.StmtTraitUseAlias{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Trait: $1.(*TraitMethodRef).Trait, + DoubleColonTkn: $1.(*TraitMethodRef).DoubleColonTkn, + Method: $1.(*TraitMethodRef).Method, + AsTkn: $2, + Modifier: $3, + } + } +; + +trait_method_reference: + identifier + { + $$ = &TraitMethodRef{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + Method: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + IdentifierTkn: $1, + Value: $1.Value, + }, + } + } + | absolute_trait_method_reference + { + $$ = $1 + } +; + +absolute_trait_method_reference: + name T_PAAMAYIM_NEKUDOTAYIM identifier + { + $$ = &TraitMethodRef{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition($1, $3), + Trait: $1, + DoubleColonTkn: $2, + Method: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($3), + IdentifierTkn: $3, + Value: $3.Value, + }, + } + } +; + +method_body: + ';' /* abstract method */ + { + $$ = &ast.StmtNop{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + SemiColonTkn: $1, + } + } + | '{' inner_statement_list '}' + { + $$ = &ast.StmtStmtList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3), + OpenCurlyBracketTkn: $1, + Stmts: $2, + CloseCurlyBracketTkn: $3, + } + } +; + +variable_modifiers: + non_empty_member_modifiers { $$ = $1 } + | T_VAR { $$ = []ast.Vertex{yylex.(*Parser).builder.NewIdentifier($1)} } +; + +method_modifiers: + /* empty */ { $$ = nil } + | non_empty_member_modifiers { $$ = $1 } +; + +non_empty_member_modifiers: + member_modifier { $$ = []ast.Vertex{$1} } + | non_empty_member_modifiers member_modifier { $$ = append($1, $2) } +; + +member_modifier: + T_PUBLIC { $$ = yylex.(*Parser).builder.NewIdentifier($1) } + | T_PROTECTED { $$ = yylex.(*Parser).builder.NewIdentifier($1) } + | T_PRIVATE { $$ = yylex.(*Parser).builder.NewIdentifier($1) } + | T_STATIC { $$ = yylex.(*Parser).builder.NewIdentifier($1) } + | T_ABSTRACT { $$ = yylex.(*Parser).builder.NewIdentifier($1) } + | T_FINAL { $$ = yylex.(*Parser).builder.NewIdentifier($1) } +; + +property_list: + property_list ',' property { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, $3) } + | property { $$ = yylex.(*Parser).builder.NewSeparatedList($1) } +; + +property: + plain_variable backup_doc_comment + { + $$ = &ast.StmtProperty{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + Var: &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + IdentifierTkn: $1, + Value: $1.Value, + }, + }, + Expr: nil, + } + } + | plain_variable '=' expr backup_doc_comment + { + $$ = &ast.StmtProperty{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $3), + Var: &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + IdentifierTkn: $1, + Value: $1.Value, + }, + }, + EqualTkn: $2, + Expr: $3, + } + } +; + +class_const_list: + class_const_list ',' class_const_decl { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, $3) } + | class_const_decl { $$ = yylex.(*Parser).builder.NewSeparatedList($1) } +; + +class_const_decl: + identifier '=' expr backup_doc_comment + { + $$ = &ast.StmtConstant{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $3), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + IdentifierTkn: $1, + Value: $1.Value, + }, + EqualTkn: $2, + Expr: $3, + } + } +; + +const_decl: + T_STRING '=' expr backup_doc_comment + { + $$ = &ast.StmtConstant{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $3), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + IdentifierTkn: $1, + Value: $1.Value, + }, + EqualTkn: $2, + Expr: $3, + } + } +; + +echo_expr_list: + echo_expr_list ',' echo_expr + { + $1.(*ast.StmtEcho).Exprs = append($1.(*ast.StmtEcho).Exprs, $3) + $1.(*ast.StmtEcho).SeparatorTkns = append($1.(*ast.StmtEcho).SeparatorTkns, $2) + + $$ = $1 + } + | echo_expr + { + $$ = &ast.StmtEcho{ + Exprs: []ast.Vertex{$1}, + } + } +; + +echo_expr: + expr { $$ = $1 } +; + +for_exprs: + /* empty */ { $$ = &ParserSeparatedList{} } + | non_empty_for_exprs { $$ = $1 } +; + +non_empty_for_exprs: + non_empty_for_exprs ',' expr { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, $3) } + | expr { $$ = yylex.(*Parser).builder.NewSeparatedList($1) } +; + +anonymous_class: + optional_attributes + T_CLASS ctor_arguments extends_from implements_list '{' class_statement_list '}' + { $$ = yylex.(*Parser).builder.NewAnonClass($1, $2, $3, $4, $5, $6, $7, $8) } +; + +new_expr: + T_NEW class_name_reference ctor_arguments + { + if $3 != nil { + $$ = &ast.ExprNew{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $3), + NewTkn: $1, + Class: $2, + OpenParenthesisTkn: $3.(*ArgumentList).OpenParenthesisTkn, + Args: $3.(*ArgumentList).Arguments, + SeparatorTkns: $3.(*ArgumentList).SeparatorTkns, + CloseParenthesisTkn: $3.(*ArgumentList).CloseParenthesisTkn, + } + } else { + $$ = &ast.ExprNew{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + NewTkn: $1, + Class: $2, + } + } + } + | T_NEW anonymous_class + { + $$ = &ast.ExprNew{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + NewTkn: $1, + Class: $2, + } + } +; + +expr_list_allow_comma: + non_empty_expr_list possible_comma + { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, nil) } +; + +non_empty_expr_list: + non_empty_expr_list ',' expr { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, $3) } + | expr { $$ = yylex.(*Parser).builder.NewSeparatedList($1) } +; + +match: + T_MATCH '(' expr ')' '{' match_arm_list '}' + { $$ = yylex.(*Parser).builder.NewMatch($1, $2, $3, $4, $5, $6, $7) } +; + +match_arm_list: + /* empty */ + { $$ = nil; } + | non_empty_match_arm_list possible_comma + { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, nil) } +; + +non_empty_match_arm_list: + match_arm + { $$ = yylex.(*Parser).builder.NewSeparatedList($1) } + | non_empty_match_arm_list ',' match_arm + { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, $3) } +; + +match_arm: + expr_list_allow_comma T_DOUBLE_ARROW expr + { $$ = yylex.(*Parser).builder.NewMatchArm(nil, nil, $1, $2, $3) } + | T_DEFAULT possible_comma T_DOUBLE_ARROW expr + { $$ = yylex.(*Parser).builder.NewMatchArm($1, $2, nil, $3, $4) } +; + +expr_without_variable: + T_LIST '(' array_pair_list ')' '=' expr + { + $$ = &ast.ExprAssign{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $6), + Var: &ast.ExprList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $4), + ListTkn: $1, + OpenBracketTkn: $2, + Items: $3.(*ParserSeparatedList).Items, + SeparatorTkns: $3.(*ParserSeparatedList).SeparatorTkns, + CloseBracketTkn: $4, + }, + EqualTkn: $5, + Expr: $6, + } + } + | '[' array_pair_list ']' '=' expr + { + $$ = &ast.ExprAssign{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $5), + Var: &ast.ExprList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3), + OpenBracketTkn: $1, + Items: $2.(*ParserSeparatedList).Items, + SeparatorTkns: $2.(*ParserSeparatedList).SeparatorTkns, + CloseBracketTkn: $3, + }, + EqualTkn: $4, + Expr: $5, + } + } + | variable '=' expr + { + $$ = &ast.ExprAssign{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Var: $1, + EqualTkn: $2, + Expr: $3, + } + } + | variable '=' '&' expr + { + $$ = &ast.ExprAssignReference{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $4), + Var: $1, + EqualTkn: $2, + AmpersandTkn: $3, + Expr: $4, + } + } + | T_CLONE expr + { + $$ = &ast.ExprClone{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + CloneTkn: $1, + Expr: $2, + } + } + | variable T_PLUS_EQUAL expr + { + $$ = &ast.ExprAssignPlus{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Var: $1, + EqualTkn: $2, + Expr: $3, + } + } + | variable T_MINUS_EQUAL expr + { + $$ = &ast.ExprAssignMinus{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Var: $1, + EqualTkn: $2, + Expr: $3, + } + } + | variable T_MUL_EQUAL expr + { + $$ = &ast.ExprAssignMul{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Var: $1, + EqualTkn: $2, + Expr: $3, + } + } + | variable T_POW_EQUAL expr + { + $$ = &ast.ExprAssignPow{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Var: $1, + EqualTkn: $2, + Expr: $3, + } + } + | variable T_DIV_EQUAL expr + { + $$ = &ast.ExprAssignDiv{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Var: $1, + EqualTkn: $2, + Expr: $3, + } + } + | variable T_CONCAT_EQUAL expr + { + $$ = &ast.ExprAssignConcat{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Var: $1, + EqualTkn: $2, + Expr: $3, + } + } + | variable T_MOD_EQUAL expr + { + $$ = &ast.ExprAssignMod{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Var: $1, + EqualTkn: $2, + Expr: $3, + } + } + | variable T_AND_EQUAL expr + { + $$ = &ast.ExprAssignBitwiseAnd{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Var: $1, + EqualTkn: $2, + Expr: $3, + } + } + | variable T_OR_EQUAL expr + { + $$ = &ast.ExprAssignBitwiseOr{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Var: $1, + EqualTkn: $2, + Expr: $3, + } + } + | variable T_XOR_EQUAL expr + { + $$ = &ast.ExprAssignBitwiseXor{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Var: $1, + EqualTkn: $2, + Expr: $3, + } + } + | variable T_SL_EQUAL expr + { + $$ = &ast.ExprAssignShiftLeft{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Var: $1, + EqualTkn: $2, + Expr: $3, + } + } + | variable T_SR_EQUAL expr + { + $$ = &ast.ExprAssignShiftRight{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Var: $1, + EqualTkn: $2, + Expr: $3, + } + } + | variable T_COALESCE_EQUAL expr + { + $$ = &ast.ExprAssignCoalesce{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Var: $1, + EqualTkn: $2, + Expr: $3, + } + } + | variable T_INC + { + $$ = &ast.ExprPostInc{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition($1, $2), + Var: $1, + IncTkn: $2, + } + } + | T_INC variable + { + $$ = &ast.ExprPreInc{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + IncTkn: $1, + Var: $2, + } + } + | variable T_DEC + { + $$ = &ast.ExprPostDec{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition($1, $2), + Var: $1, + DecTkn: $2, + } + } + | T_DEC variable + { + $$ = &ast.ExprPreDec{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + DecTkn: $1, + Var: $2, + } + } + | expr T_BOOLEAN_OR expr + { + $$ = &ast.ExprBinaryBooleanOr{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr T_BOOLEAN_AND expr + { + $$ = &ast.ExprBinaryBooleanAnd{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr T_LOGICAL_OR expr + { + $$ = &ast.ExprBinaryLogicalOr{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr T_LOGICAL_AND expr + { + $$ = &ast.ExprBinaryLogicalAnd{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr T_LOGICAL_XOR expr + { + $$ = &ast.ExprBinaryLogicalXor{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr '|' expr + { + $$ = &ast.ExprBinaryBitwiseOr{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr '&' expr + { + $$ = &ast.ExprBinaryBitwiseAnd{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr '^' expr + { + $$ = &ast.ExprBinaryBitwiseXor{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr '.' expr + { + $$ = &ast.ExprBinaryConcat{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr '+' expr + { + $$ = &ast.ExprBinaryPlus{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr '-' expr + { + $$ = &ast.ExprBinaryMinus{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr '*' expr + { + $$ = &ast.ExprBinaryMul{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr T_POW expr + { + $$ = &ast.ExprBinaryPow{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr '/' expr + { + $$ = &ast.ExprBinaryDiv{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr '%' expr + { + $$ = &ast.ExprBinaryMod{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr T_SL expr + { + $$ = &ast.ExprBinaryShiftLeft{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr T_SR expr + { + $$ = &ast.ExprBinaryShiftRight{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | '+' expr %prec T_INC + { + $$ = &ast.ExprUnaryPlus{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + PlusTkn: $1, + Expr: $2, + } + } + | '-' expr %prec T_INC + { + $$ = &ast.ExprUnaryMinus{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + MinusTkn: $1, + Expr: $2, + } + } + | '!' expr + { + $$ = &ast.ExprBooleanNot{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + ExclamationTkn: $1, + Expr: $2, + } + } + | '~' expr + { + $$ = &ast.ExprBitwiseNot{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + TildaTkn: $1, + Expr: $2, + } + } + | expr T_IS_IDENTICAL expr + { + $$ = &ast.ExprBinaryIdentical{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr T_IS_NOT_IDENTICAL expr + { + $$ = &ast.ExprBinaryNotIdentical{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr T_IS_EQUAL expr + { + $$ = &ast.ExprBinaryEqual{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr T_IS_NOT_EQUAL expr + { + $$ = &ast.ExprBinaryNotEqual{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr '<' expr + { + $$ = &ast.ExprBinarySmaller{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr T_IS_SMALLER_OR_EQUAL expr + { + $$ = &ast.ExprBinarySmallerOrEqual{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr '>' expr + { + $$ = &ast.ExprBinaryGreater{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr T_IS_GREATER_OR_EQUAL expr + { + $$ = &ast.ExprBinaryGreaterOrEqual{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr T_SPACESHIP expr + { + $$ = &ast.ExprBinarySpaceship{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | expr T_INSTANCEOF class_name_reference + { + $$ = &ast.ExprInstanceOf{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Expr: $1, + InstanceOfTkn: $2, + Class: $3, + } + } + | '(' expr ')' + { + $$ = &ast.ExprBrackets{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3), + OpenParenthesisTkn: $1, + Expr: $2, + CloseParenthesisTkn: $3, + } + } + | new_expr + { + $$ = $1 + } + | match + { + $$ = $1 + } + | expr '?' expr ':' expr + { + $$ = &ast.ExprTernary{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $5), + Cond: $1, + QuestionTkn: $2, + IfTrue: $3, + ColonTkn: $4, + IfFalse: $5, + } + } + | expr '?' ':' expr + { + $$ = &ast.ExprTernary{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $4), + Cond: $1, + QuestionTkn: $2, + ColonTkn: $3, + IfFalse: $4, + } + } + | expr T_COALESCE expr + { + $$ = &ast.ExprBinaryCoalesce{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Left: $1, + OpTkn: $2, + Right: $3, + } + } + | internal_functions_in_yacc + { + $$ = $1 + } + | T_INT_CAST expr + { + $$ = &ast.ExprCastInt{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + CastTkn: $1, + Expr: $2, + } + } + | T_DOUBLE_CAST expr + { + $$ = &ast.ExprCastDouble{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + CastTkn: $1, + Expr: $2, + } + } + | T_STRING_CAST expr + { + $$ = &ast.ExprCastString{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + CastTkn: $1, + Expr: $2, + } + } + | T_ARRAY_CAST expr + { + $$ = &ast.ExprCastArray{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + CastTkn: $1, + Expr: $2, + } + } + | T_OBJECT_CAST expr + { + $$ = &ast.ExprCastObject{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + CastTkn: $1, + Expr: $2, + } + } + | T_BOOL_CAST expr + { + $$ = &ast.ExprCastBool{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + CastTkn: $1, + Expr: $2, + } + } + | T_UNSET_CAST expr + { + $$ = &ast.ExprCastUnset{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + CastTkn: $1, + Expr: $2, + } + } + | T_EXIT exit_expr + { + exit := &ast.ExprExit{ + ExitTkn: $1, + } + + if $2 == nil { + exit.Position = yylex.(*Parser).builder.Pos.NewTokenPosition($1) + } else { + exit.Position = yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2) + exit.OpenParenthesisTkn = $2.(*ast.ExprBrackets).OpenParenthesisTkn + exit.Expr = $2.(*ast.ExprBrackets).Expr + exit.CloseParenthesisTkn = $2.(*ast.ExprBrackets).CloseParenthesisTkn + } + + $$ = exit + } + | '@' expr + { + $$ = &ast.ExprErrorSuppress{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + AtTkn: $1, + Expr: $2, + } + } + | scalar + { + $$ = $1 + } + | '`' backticks_expr '`' + { + $$ = &ast.ExprShellExec{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3), + OpenBacktickTkn: $1, + Parts: $2, + CloseBacktickTkn: $3, + } + } + | T_PRINT expr + { + $$ = &ast.ExprPrint{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + PrintTkn: $1, + Expr: $2, + } + } + | T_YIELD + { + $$ = &ast.ExprYield{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + YieldTkn: $1, + } + } + | T_YIELD expr + { + $$ = &ast.ExprYield{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + YieldTkn: $1, + Val: $2, + } + } + | T_YIELD expr T_DOUBLE_ARROW expr + { + $$ = &ast.ExprYield{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $4), + YieldTkn: $1, + Key: $2, + DoubleArrowTkn: $3, + Val: $4, + } + } + | T_YIELD_FROM expr + { + $$ = &ast.ExprYieldFrom{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + YieldFromTkn: $1, + Expr: $2, + } + } + | T_THROW expr + { + $$ = yylex.(*Parser).builder.NewThrowExpr($1, $2) + } + | attributed_inline_function + { + $$ = $1; + } + | T_STATIC attributed_inline_function + { + switch n := $2.(type) { + case *ast.ExprClosure : + n.Position = yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2) + n.StaticTkn = $1; + case *ast.ExprArrowFunction : + n.Position = yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2) + n.StaticTkn = $1; + }; + + $$ = $2 + } +; + +attributed_inline_function: + inline_function { $$ = $1 } + | attributes inline_function + { + switch n := $2.(type) { + case *ast.ExprClosure : + n.Position = yylex.(*Parser).builder.Pos.NewNodeListNodePosition($1, $2) + n.AttrGroups = $1; + case *ast.ExprArrowFunction : + n.Position = yylex.(*Parser).builder.Pos.NewNodeListNodePosition($1, $2) + n.AttrGroups = $1; + }; + + $$ = $2 + } +; + +inline_function: + T_FUNCTION returns_ref backup_doc_comment '(' parameter_list ')' lexical_vars optional_return_type '{' inner_statement_list '}' + { + closure := $7.(*ast.ExprClosure) + + closure.Position = yylex.(*Parser).builder.Pos.NewTokensPosition($1, $11) + closure.FunctionTkn = $1 + closure.AmpersandTkn = $2 + closure.OpenParenthesisTkn = $4 + closure.Params = $5.(*ParserSeparatedList).Items + closure.SeparatorTkns = $5.(*ParserSeparatedList).SeparatorTkns + closure.CloseParenthesisTkn = $6 + closure.ColonTkn = $8.(*ReturnType).ColonTkn + closure.ReturnType = $8.(*ReturnType).Type + closure.OpenCurlyBracketTkn = $9 + closure.Stmts = $10 + closure.CloseCurlyBracketTkn = $11 + + $$ = closure + } + | T_FN returns_ref '(' parameter_list ')' optional_return_type backup_doc_comment T_DOUBLE_ARROW expr %prec T_THROW + { + $$ = &ast.ExprArrowFunction{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $9), + FnTkn: $1, + AmpersandTkn: $2, + OpenParenthesisTkn: $3, + Params: $4.(*ParserSeparatedList).Items, + SeparatorTkns: $4.(*ParserSeparatedList).SeparatorTkns, + CloseParenthesisTkn: $5, + ColonTkn: $6.(*ReturnType).ColonTkn, + ReturnType: $6.(*ReturnType).Type, + DoubleArrowTkn: $8, + Expr: $9, + } + } +; + +backup_doc_comment: + /* empty */ +; + +returns_ref: + /* empty */ { $$ = nil } + | '&' { $$ = $1 } +; + +lexical_vars: + /* empty */ + { $$ = &ast.ExprClosure{} } + | T_USE '(' lexical_var_list ')' + { + $$ = &ast.ExprClosure{ + UseTkn: $1, + UseOpenParenthesisTkn: $2, + Uses: $3.(*ParserSeparatedList).Items, + UseSeparatorTkns: $3.(*ParserSeparatedList).SeparatorTkns, + UseCloseParenthesisTkn: $4, + } + } +; + +lexical_var_list: + non_empty_lexical_var_list possible_comma { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, nil) } +; + +non_empty_lexical_var_list: + non_empty_lexical_var_list ',' lexical_var { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, $3) } + | lexical_var { $$ = yylex.(*Parser).builder.NewSeparatedList($1) } +; + +lexical_var: + plain_variable + { + $$ = &ast.ExprClosureUse{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + Var: &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + IdentifierTkn: $1, + Value: $1.Value, + }, + }, + } + } + | '&' plain_variable + { + $$ = &ast.ExprClosureUse{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $2), + AmpersandTkn: $1, + Var: &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($2), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($2), + IdentifierTkn: $2, + Value: $2.Value, + }, + }, + } + } +; + +function_call: + name argument_list + { + $$ = &ast.ExprFunctionCall{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $2), + Function: $1, + OpenParenthesisTkn: $2.(*ArgumentList).OpenParenthesisTkn, + Args: $2.(*ArgumentList).Arguments, + SeparatorTkns: $2.(*ArgumentList).SeparatorTkns, + CloseParenthesisTkn: $2.(*ArgumentList).CloseParenthesisTkn, + } + } + | class_name_or_var T_PAAMAYIM_NEKUDOTAYIM member_name argument_list + { + staticCall := &ast.ExprStaticCall{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $4), + Class: $1, + DoubleColonTkn: $2, + Call: $3, + OpenParenthesisTkn: $4.(*ArgumentList).OpenParenthesisTkn, + Args: $4.(*ArgumentList).Arguments, + SeparatorTkns: $4.(*ArgumentList).SeparatorTkns, + CloseParenthesisTkn: $4.(*ArgumentList).CloseParenthesisTkn, + } + + if brackets, ok := $3.(*ParserBrackets); ok { + staticCall.OpenCurlyBracketTkn = brackets.OpenBracketTkn + staticCall.Call = brackets.Child + staticCall.CloseCurlyBracketTkn = brackets.CloseBracketTkn + } + + $$ = staticCall + } + | callable_expr argument_list + { + $$ = &ast.ExprFunctionCall{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $2), + Function: $1, + OpenParenthesisTkn: $2.(*ArgumentList).OpenParenthesisTkn, + Args: $2.(*ArgumentList).Arguments, + SeparatorTkns: $2.(*ArgumentList).SeparatorTkns, + CloseParenthesisTkn: $2.(*ArgumentList).CloseParenthesisTkn, + } + } +; + +class_name_or_var: + class_name { $$ = $1 } + | fully_dereferencable { $$ = $1 } +; + +class_name: + T_STATIC { $$ = yylex.(*Parser).builder.NewIdentifier($1) } + | name { $$ = $1 } +; + +class_name_reference: + class_name { $$ = $1 } + | new_variable { $$ = $1 } + | '(' expr ')' { $$ = yylex.(*Parser).builder.NewBracket($1, $2, $3) } +; + +exit_expr: + /* empty */ { $$ = nil } + | '(' optional_expr ')' { $$ = yylex.(*Parser).builder.NewBracket($1, $2, $3) } +; + +backticks_expr: + /* empty */ + { + $$ = []ast.Vertex{} + } + | T_ENCAPSED_AND_WHITESPACE + { + $$ = []ast.Vertex{ + &ast.ScalarEncapsedStringPart{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + EncapsedStrTkn: $1, + Value: $1.Value, + }, + } + } + | encaps_list + { + $$ = $1 + } +; + +ctor_arguments: + /* empty */ { $$ = nil } + | argument_list { $$ = $1 } +; + +dereferencable_scalar: + T_ARRAY '(' array_pair_list ')' + { + $$ = &ast.ExprArray{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $4), + ArrayTkn: $1, + OpenBracketTkn: $2, + Items: $3.(*ParserSeparatedList).Items, + SeparatorTkns: $3.(*ParserSeparatedList).SeparatorTkns, + CloseBracketTkn: $4, + } + } + | '[' array_pair_list ']' + { + $$ = &ast.ExprArray{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3), + OpenBracketTkn: $1, + Items: $2.(*ParserSeparatedList).Items, + SeparatorTkns: $2.(*ParserSeparatedList).SeparatorTkns, + CloseBracketTkn: $3, + } + } + | T_CONSTANT_ENCAPSED_STRING + { + $$ = &ast.ScalarString{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + StringTkn: $1, + Value: $1.Value, + } + } + | '"' encaps_list '"' + { + $$ = &ast.ScalarEncapsed{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3), + OpenQuoteTkn: $1, + Parts: $2, + CloseQuoteTkn: $3, + } + } +; + +scalar: + T_LNUMBER + { + $$ = &ast.ScalarLnumber{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + NumberTkn: $1, + Value: $1.Value, + } + } + | T_DNUMBER + { + $$ = &ast.ScalarDnumber{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + NumberTkn: $1, + Value: $1.Value, + } + } + | T_START_HEREDOC T_ENCAPSED_AND_WHITESPACE T_END_HEREDOC + { + $$ = &ast.ScalarHeredoc{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3), + OpenHeredocTkn: $1, + Parts: []ast.Vertex{ + &ast.ScalarEncapsedStringPart{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($2), + EncapsedStrTkn: $2, + Value: $2.Value, + }, + }, + CloseHeredocTkn: $3, + } + } + | T_START_HEREDOC T_END_HEREDOC + { + $$ = &ast.ScalarHeredoc{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $2), + OpenHeredocTkn: $1, + CloseHeredocTkn: $2, + } + } + | T_START_HEREDOC encaps_list T_END_HEREDOC + { + $$ = &ast.ScalarHeredoc{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3), + OpenHeredocTkn: $1, + Parts: $2, + CloseHeredocTkn: $3, + } + } + | dereferencable_scalar { $$ = $1 } + | class_constant { $$ = $1 } + | constant { $$ = $1 } +; + +class_constant: + class_name_or_var T_PAAMAYIM_NEKUDOTAYIM identifier_ex + { + $$ = &ast.ExprClassConstFetch{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition($1, $3), + Class: $1, + DoubleColonTkn: $2, + Const: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($3), + IdentifierTkn: $3, + Value: $3.Value, + }, + } + } +; + +constant: + name { $$ = yylex.(*Parser).builder.NewConstFetch($1) } + | T_LINE { $$ = yylex.(*Parser).builder.NewScalarMagicConstant($1) } + | T_FILE { $$ = yylex.(*Parser).builder.NewScalarMagicConstant($1) } + | T_DIR { $$ = yylex.(*Parser).builder.NewScalarMagicConstant($1) } + | T_TRAIT_C { $$ = yylex.(*Parser).builder.NewScalarMagicConstant($1) } + | T_METHOD_C { $$ = yylex.(*Parser).builder.NewScalarMagicConstant($1) } + | T_FUNC_C { $$ = yylex.(*Parser).builder.NewScalarMagicConstant($1) } + | T_NS_C { $$ = yylex.(*Parser).builder.NewScalarMagicConstant($1) } + | T_CLASS_C { $$ = yylex.(*Parser).builder.NewScalarMagicConstant($1) } +; + +expr: + variable { $$ = $1 } + | expr_without_variable { $$ = $1 } +; + +optional_expr: + /* empty */ { $$ = nil } + | expr { $$ = $1 } +; + +fully_dereferencable: + variable { $$ = $1 } + | '(' expr ')' { $$ = yylex.(*Parser).builder.NewBracket($1, $2, $3) } + | dereferencable_scalar { $$ = $1 } + | class_constant { $$ = $1 } +; + +array_object_dereferencable: + fully_dereferencable { $$ = $1 } + | constant { $$ = $1 } +; + +callable_expr: + callable_variable { $$ = $1 } + | '(' expr ')' { $$ = yylex.(*Parser).builder.NewBracket($1, $2, $3) } + | dereferencable_scalar { $$ = $1 } +; + +callable_variable: + simple_variable + { $$ = $1 } + | array_object_dereferencable '[' optional_expr ']' + { + $$ = &ast.ExprArrayDimFetch{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition($1, $4), + Var: $1, + OpenBracketTkn: $2, + Dim: $3, + CloseBracketTkn: $4, + } + } + | array_object_dereferencable '{' expr '}' + { + yylex.(*Parser).Error("Array and string offset access syntax with curly braces is no longer supported") + + $$ = &ast.ExprArrayDimFetch{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition($1, $4), + Var: $1, + OpenBracketTkn: $2, + Dim: $3, + CloseBracketTkn: $4, + } + } + | array_object_dereferencable T_OBJECT_OPERATOR property_name argument_list + { $$ = yylex.(*Parser).builder.NewMethodCall($1, $2, $3, $4) } + | array_object_dereferencable T_NULLSAFE_OBJECT_OPERATOR property_name argument_list + { $$ = yylex.(*Parser).builder.NewNullsafeMethodCall($1, $2, $3, $4) } + | function_call + { $$ = $1 } +; + +variable: + callable_variable + { $$ = $1 } + | static_member + { $$ = $1 } + | array_object_dereferencable T_OBJECT_OPERATOR property_name + { $$ = yylex.(*Parser).builder.NewPropertyFetch($1, $2, $3) } + | array_object_dereferencable T_NULLSAFE_OBJECT_OPERATOR property_name + { $$ = yylex.(*Parser).builder.NewNullsafePropertyFetch($1, $2, $3) } +; + +simple_variable: + plain_variable + { + $$ = &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + IdentifierTkn: $1, + Value: $1.Value, + }, + } + } + | '$' '{' expr '}' + { + $$ = &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $4), + DollarTkn: $1, + OpenCurlyBracketTkn: $2, + Name: $3, + CloseCurlyBracketTkn: $4, + } + } + | '$' simple_variable + { + $$ = &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + DollarTkn: $1, + Name: $2, + } + } +; + +static_member: + class_name_or_var T_PAAMAYIM_NEKUDOTAYIM simple_variable + { + $$ = &ast.ExprStaticPropertyFetch{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Class: $1, + DoubleColonTkn: $2, + Prop: $3, + } + } +; + +new_variable: + simple_variable + { + $$ = $1 + } + | new_variable '[' optional_expr ']' + { + $$ = &ast.ExprArrayDimFetch{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition($1, $4), + Var: $1, + OpenBracketTkn: $2, + Dim: $3, + CloseBracketTkn: $4, + } + } + | new_variable '{' expr '}' + { + yylex.(*Parser).Error("Array and string offset access syntax with curly braces is no longer supported") + + $$ = &ast.ExprArrayDimFetch{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition($1, $4), + Var: $1, + OpenBracketTkn: $2, + Dim: $3, + CloseBracketTkn: $4, + } + } + | new_variable T_OBJECT_OPERATOR property_name + { + $$ = yylex.(*Parser).builder.NewPropertyFetch($1, $2, $3) + } + | new_variable T_NULLSAFE_OBJECT_OPERATOR property_name + { + $$ = yylex.(*Parser).builder.NewNullsafePropertyFetch($1, $2, $3) + } + | class_name T_PAAMAYIM_NEKUDOTAYIM simple_variable + { + $$ = &ast.ExprStaticPropertyFetch{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Class: $1, + DoubleColonTkn: $2, + Prop: $3, + } + } + | new_variable T_PAAMAYIM_NEKUDOTAYIM simple_variable + { + $$ = &ast.ExprStaticPropertyFetch{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Class: $1, + DoubleColonTkn: $2, + Prop: $3, + } + } +; + +member_name: + identifier { $$ = yylex.(*Parser).builder.NewIdentifier($1) } + | '{' expr '}' { $$ = yylex.(*Parser).builder.NewBracket($1, $2, $3) } + | simple_variable { $$ = $1 } +; + +property_name: + T_STRING { $$ = yylex.(*Parser).builder.NewIdentifier($1) } + | '{' expr '}' { $$ = yylex.(*Parser).builder.NewBracket($1, $2, $3) } + | simple_variable { $$ = $1 } +; + +array_pair_list: + non_empty_array_pair_list + { + pairList := $1.(*ParserSeparatedList) + fistPair := pairList.Items[0].(*ast.ExprArrayItem) + + if fistPair.Key == nil && fistPair.Val == nil && len(pairList.Items) == 1 { + pairList.Items = nil + } + + $$ = $1 + } +; + +possible_array_pair: + /* empty */ { $$ = &ast.ExprArrayItem{} } + | array_pair { $$ = $1} +; + +non_empty_array_pair_list: + non_empty_array_pair_list ',' possible_array_pair + { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, $3) } + | possible_array_pair + { $$ = yylex.(*Parser).builder.NewSeparatedList($1) } +; + +array_pair: + expr T_DOUBLE_ARROW expr + { + $$ = &ast.ExprArrayItem{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $3), + Key: $1, + DoubleArrowTkn: $2, + Val: $3, + } + } + | expr + { + $$ = &ast.ExprArrayItem{ + Position: yylex.(*Parser).builder.Pos.NewNodePosition($1), + Val: $1, + } + } + | expr T_DOUBLE_ARROW '&' variable + { + $$ = &ast.ExprArrayItem{ + Position: yylex.(*Parser).builder.Pos.NewNodesPosition($1, $4), + Key: $1, + DoubleArrowTkn: $2, + AmpersandTkn: $3, + Val: $4, + } + } + | '&' variable + { + $$ = &ast.ExprArrayItem{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + AmpersandTkn: $1, + Val: $2, + } + } + | T_ELLIPSIS expr + { + $$ = &ast.ExprArrayItem{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + EllipsisTkn: $1, + Val: $2, + } + } + | expr T_DOUBLE_ARROW T_LIST '(' array_pair_list ')' + { + $$ = &ast.ExprArrayItem{ + Position: yylex.(*Parser).builder.Pos.NewNodeTokenPosition($1, $6), + Key: $1, + DoubleArrowTkn: $2, + Val: &ast.ExprList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($3, $6), + ListTkn: $3, + OpenBracketTkn: $4, + Items: $5.(*ParserSeparatedList).Items, + SeparatorTkns: $5.(*ParserSeparatedList).SeparatorTkns, + CloseBracketTkn: $6, + }, + } + } + | T_LIST '(' array_pair_list ')' + { + $$ = &ast.ExprArrayItem{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $4), + Val: &ast.ExprList{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $4), + ListTkn: $1, + OpenBracketTkn: $2, + Items: $3.(*ParserSeparatedList).Items, + SeparatorTkns: $3.(*ParserSeparatedList).SeparatorTkns, + CloseBracketTkn: $4, + }, + } + } +; + +encaps_list: + encaps_list encaps_var + { + $$ = append($1, $2) + } + | encaps_list T_ENCAPSED_AND_WHITESPACE + { + $$ = append( + $1, + &ast.ScalarEncapsedStringPart{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($2), + EncapsedStrTkn: $2, + Value: $2.Value, + }, + ) + } + | encaps_var + { + $$ = []ast.Vertex{$1} + } + | T_ENCAPSED_AND_WHITESPACE encaps_var + { + $$ = []ast.Vertex{ + &ast.ScalarEncapsedStringPart{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + EncapsedStrTkn: $1, + Value: $1.Value, + }, + $2, + } + } +; + +encaps_var: + plain_variable + { + $$ = &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + IdentifierTkn: $1, + Value: $1.Value, + }, + } + } + | plain_variable '[' encaps_var_offset ']' + { + $$ = &ast.ExprArrayDimFetch{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $4), + Var: &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + IdentifierTkn: $1, + Value: $1.Value, + }, + }, + OpenBracketTkn: $2, + Dim: $3, + CloseBracketTkn: $4, + } + } + | plain_variable T_OBJECT_OPERATOR T_STRING + { + $$ = yylex.(*Parser).builder.NewPropertyFetchFromTokens($1, $2, $3) + } + | plain_variable T_NULLSAFE_OBJECT_OPERATOR T_STRING + { + $$ = yylex.(*Parser).builder.NewNullsafePropertyFetchFromTokens($1, $2, $3) + } + | T_DOLLAR_OPEN_CURLY_BRACES expr '}' + { + $$ = &ast.ScalarEncapsedStringVar{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3), + DollarOpenCurlyBracketTkn: $1, + Name: $2, + CloseCurlyBracketTkn: $3, + } + } + | T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '}' + { + $$ = &ast.ScalarEncapsedStringVar{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3), + DollarOpenCurlyBracketTkn: $1, + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($2), + IdentifierTkn: $2, + Value: $2.Value, + }, + CloseCurlyBracketTkn: $3, + } + } + | T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '[' expr ']' '}' + { + $$ = &ast.ScalarEncapsedStringVar{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3), + DollarOpenCurlyBracketTkn: $1, + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($2), + IdentifierTkn: $2, + Value: $2.Value, + }, + OpenSquareBracketTkn: $3, + Dim: $4, + CloseSquareBracketTkn: $5, + CloseCurlyBracketTkn: $6, + } + } + | T_CURLY_OPEN variable '}' + { + $$ = &ast.ScalarEncapsedStringBrackets{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $3), + OpenCurlyBracketTkn: $1, + Var: $2, + CloseCurlyBracketTkn: $3, + } + } +; + +encaps_var_offset: + T_STRING + { + $$ = &ast.ScalarString{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + StringTkn: $1, + Value: $1.Value, + } + } + | T_NUM_STRING + { + // TODO: add option to handle 64 bit integer + if _, err := strconv.Atoi(string($1.Value)); err == nil { + $$ = &ast.ScalarLnumber{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + NumberTkn: $1, + Value: $1.Value, + } + } else { + $$ = &ast.ScalarString{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + StringTkn: $1, + Value: $1.Value, + } + } + } + | '-' T_NUM_STRING + { + _, err := strconv.Atoi(string($2.Value)); + isInt := err == nil + + if isInt { + $$ = &ast.ExprUnaryMinus{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $2), + MinusTkn: $1, + Expr: &ast.ScalarLnumber{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($2), + NumberTkn: $2, + Value: $2.Value, + }, + } + } else { + $$ = &ast.ScalarString{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $2), + MinusTkn: $1, + StringTkn: $2, + Value: append([]byte("-"), $2.Value...), + } + } + } + | plain_variable + { + $$ = &ast.ExprVariable{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + Name: &ast.Identifier{ + Position: yylex.(*Parser).builder.Pos.NewTokenPosition($1), + IdentifierTkn: $1, + Value: $1.Value, + }, + } + } +; + +internal_functions_in_yacc: + T_ISSET '(' isset_variables possible_comma ')' + { + if $4 != nil { + $3.(*ParserSeparatedList).SeparatorTkns = append($3.(*ParserSeparatedList).SeparatorTkns, $4) + } + + $$ = &ast.ExprIsset{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $5), + IssetTkn: $1, + OpenParenthesisTkn: $2, + Vars: $3.(*ParserSeparatedList).Items, + SeparatorTkns: $3.(*ParserSeparatedList).SeparatorTkns, + CloseParenthesisTkn: $5, + } + } + | T_EMPTY '(' expr ')' + { + $$ = &ast.ExprEmpty{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $4), + EmptyTkn: $1, + OpenParenthesisTkn: $2, + Expr: $3, + CloseParenthesisTkn: $4, + } + } + | T_INCLUDE expr + { + $$ = &ast.ExprInclude{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + IncludeTkn: $1, + Expr: $2, + } + } + | T_INCLUDE_ONCE expr + { + $$ = &ast.ExprIncludeOnce{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + IncludeOnceTkn: $1, + Expr: $2, + } + } + | T_EVAL '(' expr ')' + { + $$ = &ast.ExprEval{ + Position: yylex.(*Parser).builder.Pos.NewTokensPosition($1, $4), + EvalTkn: $1, + OpenParenthesisTkn: $2, + Expr: $3, + CloseParenthesisTkn: $4, + } + } + | T_REQUIRE expr + { + $$ = &ast.ExprRequire{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + RequireTkn: $1, + Expr: $2, + } + } + | T_REQUIRE_ONCE expr + { + $$ = &ast.ExprRequireOnce{ + Position: yylex.(*Parser).builder.Pos.NewTokenNodePosition($1, $2), + RequireOnceTkn: $1, + Expr: $2, + } + } +; + +isset_variables: + isset_variable { $$ = yylex.(*Parser).builder.NewSeparatedList($1) } + | isset_variables ',' isset_variable { $$ = yylex.(*Parser).builder.AppendToSeparatedList($1, $2, $3) } +; + +isset_variable: + expr { $$ = $1 } +; + +///////////////////////////////////////////////////////////////////////// + +%% diff --git a/internal/php8/php8_bench_test.go b/internal/php8/php8_bench_test.go new file mode 100644 index 0000000..5a8eee7 --- /dev/null +++ b/internal/php8/php8_bench_test.go @@ -0,0 +1,30 @@ +package php8_test + +import ( + "io/ioutil" + "testing" + + "github.com/z7zmey/php-parser/internal/php8" + "github.com/z7zmey/php-parser/pkg/conf" + "github.com/z7zmey/php-parser/pkg/version" +) + +func BenchmarkPhp8(b *testing.B) { + src, err := ioutil.ReadFile("test.php") + + if err != nil { + b.Fatal("can not read test.php: " + err.Error()) + } + + for n := 0; n < b.N; n++ { + config := conf.Config{ + Version: &version.Version{ + Major: 8, + Minor: 8, + }, + } + lexer := php8.NewLexer(src, config) + php8parser := php8.NewParser(lexer, config) + php8parser.Parse() + } +} diff --git a/internal/php8/scanner.go b/internal/php8/scanner.go new file mode 100644 index 0000000..58642a4 --- /dev/null +++ b/internal/php8/scanner.go @@ -0,0 +1,28084 @@ +// line internal/php8/scanner.rl:1 +package php8 + +import ( + "fmt" + "strconv" + "strings" + + "github.com/z7zmey/php-parser/pkg/token" +) + +// line internal/php8/scanner.go:15 +const lexer_start int = 121 +const lexer_first_final int = 121 +const lexer_error int = 0 + +const lexer_en_main int = 121 +const lexer_en_html int = 124 +const lexer_en_php int = 131 +const lexer_en_property int = 485 +const lexer_en_nowdoc int = 492 +const lexer_en_heredoc int = 496 +const lexer_en_backqote int = 503 +const lexer_en_template_string int = 509 +const lexer_en_heredoc_end int = 515 +const lexer_en_string_var int = 517 +const lexer_en_string_var_index int = 523 +const lexer_en_string_var_name int = 533 +const lexer_en_halt_compiller_open_parenthesis int = 535 +const lexer_en_halt_compiller_close_parenthesis int = 539 +const lexer_en_halt_compiller_close_semicolon int = 543 +const lexer_en_halt_compiller_end int = 547 + +// line internal/php8/scanner.rl:17 + +func initLexer(lex *Lexer) { + + // line internal/php8/scanner.go:43 + { + lex.cs = lexer_start + lex.top = 0 + lex.ts = 0 + lex.te = 0 + lex.act = 0 + } + + // line internal/php8/scanner.rl:21 +} + +func (lex *Lexer) Lex() *token.Token { + eof := lex.pe + var tok token.ID + + tkn := lex.tokenPool.Get() + + lblStart := 0 + lblEnd := 0 + + _, _ = lblStart, lblEnd + + // line internal/php8/scanner.go:67 + { + var _widec int16 + if (lex.p) == (lex.pe) { + goto _test_eof + } + goto _resume + + _again: + switch lex.cs { + case 121: + goto st121 + case 122: + goto st122 + case 1: + goto st1 + case 123: + goto st123 + case 124: + goto st124 + case 125: + goto st125 + case 126: + goto st126 + case 127: + goto st127 + case 128: + goto st128 + case 129: + goto st129 + case 2: + goto st2 + case 3: + goto st3 + case 4: + goto st4 + case 130: + goto st130 + case 5: + goto st5 + case 131: + goto st131 + case 132: + goto st132 + case 133: + goto st133 + case 6: + goto st6 + case 134: + goto st134 + case 135: + goto st135 + case 136: + goto st136 + case 137: + goto st137 + case 7: + goto st7 + case 8: + goto st8 + case 9: + goto st9 + case 10: + goto st10 + case 138: + goto st138 + case 139: + goto st139 + case 140: + goto st140 + case 141: + goto st141 + case 142: + goto st142 + case 143: + goto st143 + case 144: + goto st144 + case 145: + goto st145 + case 11: + goto st11 + case 12: + goto st12 + case 146: + goto st146 + 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 + case 66: + goto st66 + case 67: + goto st67 + case 147: + goto st147 + case 148: + goto st148 + case 149: + goto st149 + case 150: + goto st150 + case 151: + goto st151 + case 68: + goto st68 + case 152: + goto st152 + case 69: + goto st69 + case 70: + goto st70 + case 153: + goto st153 + case 71: + goto st71 + case 154: + goto st154 + case 72: + goto st72 + case 73: + goto st73 + case 74: + goto st74 + case 155: + goto st155 + case 156: + goto st156 + case 157: + goto st157 + case 75: + goto st75 + case 76: + goto st76 + case 158: + goto st158 + case 77: + goto st77 + case 159: + goto st159 + case 160: + goto st160 + case 161: + goto st161 + case 78: + goto st78 + case 79: + goto st79 + case 80: + goto st80 + case 81: + goto st81 + case 162: + goto st162 + case 163: + goto st163 + case 82: + goto st82 + case 164: + goto st164 + case 165: + goto st165 + case 83: + goto st83 + case 84: + goto st84 + case 85: + goto st85 + case 86: + goto st86 + case 166: + goto st166 + case 87: + goto st87 + case 88: + goto st88 + case 89: + goto st89 + case 90: + goto st90 + case 167: + goto st167 + case 168: + goto st168 + case 169: + goto st169 + case 170: + goto st170 + case 171: + goto st171 + case 172: + goto st172 + case 91: + goto st91 + case 173: + goto st173 + case 174: + goto st174 + case 92: + goto st92 + case 175: + goto st175 + case 176: + goto st176 + case 177: + goto st177 + case 93: + goto st93 + case 178: + goto st178 + case 179: + goto st179 + 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 94: + goto st94 + case 95: + goto st95 + 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 96: + goto st96 + 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 + case 393: + goto st393 + case 394: + goto st394 + case 395: + goto st395 + case 396: + goto st396 + case 397: + goto st397 + case 398: + goto st398 + case 399: + goto st399 + 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 97: + goto st97 + case 98: + goto st98 + case 99: + goto st99 + case 100: + goto st100 + case 101: + goto st101 + case 102: + goto st102 + case 416: + goto st416 + case 417: + goto st417 + case 103: + goto st103 + 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 + case 470: + goto st470 + case 471: + goto st471 + case 472: + goto st472 + case 473: + goto st473 + case 474: + goto st474 + case 475: + goto st475 + case 476: + goto st476 + case 477: + goto st477 + case 478: + goto st478 + case 479: + goto st479 + case 480: + goto st480 + case 481: + goto st481 + case 482: + goto st482 + case 483: + goto st483 + case 484: + goto st484 + case 485: + goto st485 + case 486: + goto st486 + case 487: + goto st487 + case 104: + goto st104 + case 488: + goto st488 + case 489: + goto st489 + case 490: + goto st490 + case 105: + goto st105 + case 491: + goto st491 + case 492: + goto st492 + case 0: + goto st0 + case 493: + goto st493 + case 494: + goto st494 + case 495: + goto st495 + case 496: + goto st496 + case 497: + goto st497 + case 106: + goto st106 + case 498: + goto st498 + case 499: + goto st499 + case 500: + goto st500 + case 501: + goto st501 + case 502: + goto st502 + case 503: + goto st503 + case 107: + goto st107 + case 108: + goto st108 + case 504: + goto st504 + case 505: + goto st505 + case 506: + goto st506 + case 507: + goto st507 + case 508: + goto st508 + case 509: + goto st509 + case 109: + goto st109 + case 110: + goto st110 + case 510: + goto st510 + case 511: + goto st511 + case 512: + goto st512 + case 513: + goto st513 + case 514: + goto st514 + case 515: + goto st515 + case 516: + goto st516 + case 517: + goto st517 + case 518: + goto st518 + case 519: + goto st519 + case 520: + goto st520 + case 111: + goto st111 + case 521: + goto st521 + case 112: + goto st112 + case 113: + goto st113 + case 522: + goto st522 + case 523: + goto st523 + case 524: + goto st524 + case 525: + goto st525 + case 526: + goto st526 + case 527: + goto st527 + case 528: + goto st528 + case 529: + goto st529 + case 114: + goto st114 + case 115: + goto st115 + case 530: + goto st530 + case 116: + goto st116 + case 531: + goto st531 + case 532: + goto st532 + case 533: + goto st533 + case 534: + goto st534 + case 117: + goto st117 + case 535: + goto st535 + case 536: + goto st536 + case 537: + goto st537 + case 118: + goto st118 + case 538: + goto st538 + case 539: + goto st539 + case 540: + goto st540 + case 541: + goto st541 + case 119: + goto st119 + case 542: + goto st542 + case 543: + goto st543 + case 544: + goto st544 + case 545: + goto st545 + case 120: + goto st120 + case 546: + goto st546 + case 547: + goto st547 + case 548: + goto st548 + case 549: + goto st549 + case 550: + goto st550 + } + + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof + } + _resume: + switch lex.cs { + case 121: + goto st_case_121 + case 122: + goto st_case_122 + case 1: + goto st_case_1 + case 123: + goto st_case_123 + case 124: + goto st_case_124 + case 125: + goto st_case_125 + case 126: + goto st_case_126 + case 127: + goto st_case_127 + case 128: + goto st_case_128 + case 129: + goto st_case_129 + case 2: + goto st_case_2 + case 3: + goto st_case_3 + case 4: + goto st_case_4 + case 130: + goto st_case_130 + case 5: + goto st_case_5 + case 131: + goto st_case_131 + case 132: + goto st_case_132 + case 133: + goto st_case_133 + case 6: + goto st_case_6 + case 134: + goto st_case_134 + case 135: + goto st_case_135 + case 136: + goto st_case_136 + case 137: + goto st_case_137 + case 7: + goto st_case_7 + case 8: + goto st_case_8 + case 9: + goto st_case_9 + case 10: + goto st_case_10 + case 138: + goto st_case_138 + case 139: + goto st_case_139 + case 140: + goto st_case_140 + case 141: + goto st_case_141 + case 142: + goto st_case_142 + case 143: + goto st_case_143 + case 144: + goto st_case_144 + case 145: + goto st_case_145 + case 11: + goto st_case_11 + case 12: + goto st_case_12 + case 146: + goto st_case_146 + 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 + case 66: + goto st_case_66 + case 67: + goto st_case_67 + case 147: + goto st_case_147 + case 148: + goto st_case_148 + case 149: + goto st_case_149 + case 150: + goto st_case_150 + case 151: + goto st_case_151 + case 68: + goto st_case_68 + case 152: + goto st_case_152 + case 69: + goto st_case_69 + case 70: + goto st_case_70 + case 153: + goto st_case_153 + case 71: + goto st_case_71 + case 154: + goto st_case_154 + case 72: + goto st_case_72 + case 73: + goto st_case_73 + case 74: + goto st_case_74 + case 155: + goto st_case_155 + case 156: + goto st_case_156 + case 157: + goto st_case_157 + case 75: + goto st_case_75 + case 76: + goto st_case_76 + case 158: + goto st_case_158 + case 77: + goto st_case_77 + case 159: + goto st_case_159 + case 160: + goto st_case_160 + case 161: + goto st_case_161 + case 78: + goto st_case_78 + case 79: + goto st_case_79 + case 80: + goto st_case_80 + case 81: + goto st_case_81 + case 162: + goto st_case_162 + case 163: + goto st_case_163 + case 82: + goto st_case_82 + case 164: + goto st_case_164 + case 165: + goto st_case_165 + case 83: + goto st_case_83 + case 84: + goto st_case_84 + case 85: + goto st_case_85 + case 86: + goto st_case_86 + case 166: + goto st_case_166 + case 87: + goto st_case_87 + case 88: + goto st_case_88 + case 89: + goto st_case_89 + case 90: + goto st_case_90 + 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 + case 91: + goto st_case_91 + case 173: + goto st_case_173 + case 174: + goto st_case_174 + case 92: + goto st_case_92 + case 175: + goto st_case_175 + case 176: + goto st_case_176 + case 177: + goto st_case_177 + case 93: + goto st_case_93 + case 178: + goto st_case_178 + case 179: + goto st_case_179 + 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 94: + goto st_case_94 + case 95: + goto st_case_95 + 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 96: + goto st_case_96 + 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 + case 393: + goto st_case_393 + case 394: + goto st_case_394 + case 395: + goto st_case_395 + case 396: + goto st_case_396 + case 397: + goto st_case_397 + case 398: + goto st_case_398 + case 399: + goto st_case_399 + 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 97: + goto st_case_97 + case 98: + goto st_case_98 + case 99: + goto st_case_99 + case 100: + goto st_case_100 + case 101: + goto st_case_101 + case 102: + goto st_case_102 + case 416: + goto st_case_416 + case 417: + goto st_case_417 + case 103: + goto st_case_103 + 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 + case 470: + goto st_case_470 + case 471: + goto st_case_471 + case 472: + goto st_case_472 + case 473: + goto st_case_473 + 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 + 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 + case 485: + goto st_case_485 + case 486: + goto st_case_486 + case 487: + goto st_case_487 + case 104: + goto st_case_104 + case 488: + goto st_case_488 + case 489: + goto st_case_489 + case 490: + goto st_case_490 + case 105: + goto st_case_105 + case 491: + goto st_case_491 + case 492: + goto st_case_492 + case 0: + goto st_case_0 + 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 106: + goto st_case_106 + case 498: + goto st_case_498 + case 499: + goto st_case_499 + case 500: + goto st_case_500 + case 501: + goto st_case_501 + case 502: + goto st_case_502 + case 503: + goto st_case_503 + case 107: + goto st_case_107 + case 108: + goto st_case_108 + case 504: + goto st_case_504 + case 505: + goto st_case_505 + case 506: + goto st_case_506 + case 507: + goto st_case_507 + case 508: + goto st_case_508 + case 509: + goto st_case_509 + case 109: + goto st_case_109 + case 110: + goto st_case_110 + case 510: + goto st_case_510 + case 511: + goto st_case_511 + case 512: + goto st_case_512 + case 513: + goto st_case_513 + case 514: + goto st_case_514 + case 515: + goto st_case_515 + case 516: + goto st_case_516 + case 517: + goto st_case_517 + case 518: + goto st_case_518 + case 519: + goto st_case_519 + case 520: + goto st_case_520 + case 111: + goto st_case_111 + case 521: + goto st_case_521 + case 112: + goto st_case_112 + case 113: + goto st_case_113 + case 522: + goto st_case_522 + case 523: + goto st_case_523 + case 524: + goto st_case_524 + case 525: + goto st_case_525 + case 526: + goto st_case_526 + case 527: + goto st_case_527 + case 528: + goto st_case_528 + case 529: + goto st_case_529 + case 114: + goto st_case_114 + case 115: + goto st_case_115 + case 530: + goto st_case_530 + case 116: + goto st_case_116 + case 531: + goto st_case_531 + case 532: + goto st_case_532 + case 533: + goto st_case_533 + case 534: + goto st_case_534 + case 117: + goto st_case_117 + case 535: + goto st_case_535 + case 536: + goto st_case_536 + case 537: + goto st_case_537 + case 118: + goto st_case_118 + case 538: + goto st_case_538 + case 539: + goto st_case_539 + case 540: + goto st_case_540 + case 541: + goto st_case_541 + case 119: + goto st_case_119 + case 542: + goto st_case_542 + case 543: + goto st_case_543 + case 544: + goto st_case_544 + case 545: + goto st_case_545 + case 120: + goto st_case_120 + case 546: + goto st_case_546 + case 547: + goto st_case_547 + case 548: + goto st_case_548 + case 549: + goto st_case_549 + case 550: + goto st_case_550 + } + goto st_out + tr0: + lex.cs = 121 + // line internal/php8/scanner.rl:130 + (lex.p) = (lex.te) - 1 + { + lex.cs = 124 + lex.ungetCnt(1) + } + goto _again + tr180: + lex.cs = 121 + // line internal/php8/scanner.rl:130 + lex.te = (lex.p) + 1 + { + lex.cs = 124 + lex.ungetCnt(1) + } + goto _again + tr182: + lex.cs = 121 + // line internal/php8/scanner.rl:130 + lex.te = (lex.p) + (lex.p)-- + { + lex.cs = 124 + lex.ungetCnt(1) + } + goto _again + tr183: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:127 + lex.te = (lex.p) + (lex.p)-- + { + lex.addFreeFloatingToken(tkn, token.T_COMMENT, lex.ts, lex.te) + } + goto st121 + st121: + // line NONE:1 + lex.ts = 0 + + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof121 + } + st_case_121: + // line NONE:1 + lex.ts = (lex.p) + + // line internal/php8/scanner.go:2339 + if lex.data[(lex.p)] == 35 { + goto tr181 + } + goto tr180 + tr181: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st122 + st122: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof122 + } + st_case_122: + // line internal/php8/scanner.go:2354 + if lex.data[(lex.p)] == 33 { + goto st1 + } + goto tr182 + tr3: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st1 + st1: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof1 + } + st_case_1: + // line internal/php8/scanner.go:2376 + switch lex.data[(lex.p)] { + case 10: + goto tr2 + case 13: + goto tr3 + } + goto st1 + tr2: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st123 + st123: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof123 + } + st_case_123: + // line internal/php8/scanner.go:2401 + goto tr183 + tr4: + lex.cs = 124 + // line internal/php8/scanner.rl:143 + (lex.p) = (lex.te) - 1 + { + lex.addFreeFloatingToken(tkn, token.T_OPEN_TAG, lex.ts, lex.te) + lex.cs = 131 + } + goto _again + tr7: + lex.cs = 124 + // line internal/php8/scanner.rl:147 + lex.te = (lex.p) + 1 + { + lex.ungetCnt(lex.te - lex.ts - 5) + lex.addFreeFloatingToken(tkn, token.T_OPEN_TAG, lex.ts, lex.ts+5) + lex.cs = 131 + } + goto _again + tr188: + // line internal/php8/scanner.rl:137 + lex.te = (lex.p) + (lex.p)-- + { + lex.ungetStr("<") + lex.setTokenPosition(tkn) + tok = token.T_INLINE_HTML + { + (lex.p)++ + lex.cs = 124 + goto _out + } + } + goto st124 + tr190: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:137 + lex.te = (lex.p) + (lex.p)-- + { + lex.ungetStr("<") + lex.setTokenPosition(tkn) + tok = token.T_INLINE_HTML + { + (lex.p)++ + lex.cs = 124 + goto _out + } + } + goto st124 + tr196: + lex.cs = 124 + // line internal/php8/scanner.rl:143 + lex.te = (lex.p) + (lex.p)-- + { + lex.addFreeFloatingToken(tkn, token.T_OPEN_TAG, lex.ts, lex.te) + lex.cs = 131 + } + goto _again + tr197: + lex.cs = 124 + // line internal/php8/scanner.rl:152 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_ECHO + lex.cs = 131 + { + (lex.p)++ + goto _out + } + } + goto _again + tr199: + lex.cs = 124 + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:147 + lex.te = (lex.p) + (lex.p)-- + { + lex.ungetCnt(lex.te - lex.ts - 5) + lex.addFreeFloatingToken(tkn, token.T_OPEN_TAG, lex.ts, lex.ts+5) + lex.cs = 131 + } + goto _again + st124: + // line NONE:1 + lex.ts = 0 + + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof124 + } + st_case_124: + // line NONE:1 + lex.ts = (lex.p) + + // line internal/php8/scanner.go:2491 + switch lex.data[(lex.p)] { + case 10: + goto tr185 + case 13: + goto tr186 + case 60: + goto st128 + } + goto st125 + tr186: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st125 + tr191: + // line internal/php8/scanner.rl:54 + + goto st125 + tr193: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st125 + st125: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof125 + } + st_case_125: + // line internal/php8/scanner.go:2536 + switch lex.data[(lex.p)] { + case 10: + goto tr185 + case 13: + goto tr186 + case 60: + goto st127 + } + goto st125 + tr185: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st126 + tr192: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st126 + st126: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof126 + } + st_case_126: + // line internal/php8/scanner.go:2577 + switch lex.data[(lex.p)] { + case 10: + goto tr192 + case 13: + goto tr193 + case 60: + goto tr194 + } + goto tr191 + tr194: + // line internal/php8/scanner.rl:54 + + goto st127 + st127: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof127 + } + st_case_127: + // line internal/php8/scanner.go:2596 + switch lex.data[(lex.p)] { + case 10: + goto tr185 + case 13: + goto tr186 + case 60: + goto st127 + case 63: + goto tr188 + } + goto st125 + st128: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof128 + } + st_case_128: + switch lex.data[(lex.p)] { + case 10: + goto tr185 + case 13: + goto tr186 + case 60: + goto st127 + case 63: + goto tr195 + } + goto st125 + tr195: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st129 + st129: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof129 + } + st_case_129: + // line internal/php8/scanner.go:2634 + switch lex.data[(lex.p)] { + case 61: + goto tr197 + case 80: + goto st2 + case 112: + goto st2 + } + goto tr196 + st2: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof2 + } + st_case_2: + switch lex.data[(lex.p)] { + case 72: + goto st3 + case 104: + goto st3 + } + goto tr4 + st3: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof3 + } + st_case_3: + switch lex.data[(lex.p)] { + case 80: + goto st4 + case 112: + goto st4 + } + goto tr4 + st4: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof4 + } + st_case_4: + switch lex.data[(lex.p)] { + case 9: + goto tr7 + case 10: + goto tr8 + case 13: + goto tr9 + case 32: + goto tr7 + } + goto tr4 + tr8: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st130 + st130: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof130 + } + st_case_130: + // line internal/php8/scanner.go:2701 + goto tr199 + tr9: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st5 + st5: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof5 + } + st_case_5: + // line internal/php8/scanner.go:2720 + if lex.data[(lex.p)] == 10 { + goto tr8 + } + goto tr4 + tr10: + // line internal/php8/scanner.rl:161 + (lex.p) = (lex.te) - 1 + { + lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te) + } + goto st131 + tr12: + lex.cs = 131 + // line NONE:1 + switch lex.act { + case 10: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_DNUMBER + { + (lex.p)++ + goto _out + } + } + case 11: + { + (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 { + lex.setTokenPosition(tkn) + tok = token.T_LNUMBER + { + (lex.p)++ + goto _out + } + } + + lex.setTokenPosition(tkn) + tok = token.T_DNUMBER + { + (lex.p)++ + goto _out + } + } + case 12: + { + (lex.p) = (lex.te) - 1 + + 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 { + lex.setTokenPosition(tkn) + tok = token.T_LNUMBER + { + (lex.p)++ + goto _out + } + } + + lex.setTokenPosition(tkn) + tok = token.T_DNUMBER + { + (lex.p)++ + goto _out + } + } + case 13: + { + (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 { + lex.setTokenPosition(tkn) + tok = token.T_LNUMBER + { + (lex.p)++ + goto _out + } + } + + lex.setTokenPosition(tkn) + tok = token.T_DNUMBER + { + (lex.p)++ + goto _out + } + } + case 14: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_NAME_RELATIVE + { + (lex.p)++ + goto _out + } + } + case 15: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_NAME_QUALIFIED + { + (lex.p)++ + goto _out + } + } + case 18: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_ABSTRACT + { + (lex.p)++ + goto _out + } + } + case 19: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_ARRAY + { + (lex.p)++ + goto _out + } + } + case 20: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_AS + { + (lex.p)++ + goto _out + } + } + case 21: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_BREAK + { + (lex.p)++ + goto _out + } + } + case 22: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_CALLABLE + { + (lex.p)++ + goto _out + } + } + case 23: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_CASE + { + (lex.p)++ + goto _out + } + } + case 24: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_CATCH + { + (lex.p)++ + goto _out + } + } + case 25: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_CLASS + { + (lex.p)++ + goto _out + } + } + case 26: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_CLONE + { + (lex.p)++ + goto _out + } + } + case 27: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_CONST + { + (lex.p)++ + goto _out + } + } + case 28: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_CONTINUE + { + (lex.p)++ + goto _out + } + } + case 29: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_DECLARE + { + (lex.p)++ + goto _out + } + } + case 30: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_DEFAULT + { + (lex.p)++ + goto _out + } + } + case 31: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_DO + { + (lex.p)++ + goto _out + } + } + case 32: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_ECHO + { + (lex.p)++ + goto _out + } + } + case 33: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_ELSE + { + (lex.p)++ + goto _out + } + } + case 34: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_ELSEIF + { + (lex.p)++ + goto _out + } + } + case 35: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_EMPTY + { + (lex.p)++ + goto _out + } + } + case 36: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_ENDDECLARE + { + (lex.p)++ + goto _out + } + } + case 37: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_ENDFOR + { + (lex.p)++ + goto _out + } + } + case 38: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_ENDFOREACH + { + (lex.p)++ + goto _out + } + } + case 39: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_ENDIF + { + (lex.p)++ + goto _out + } + } + case 40: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_ENDSWITCH + { + (lex.p)++ + goto _out + } + } + case 41: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_ENDWHILE + { + (lex.p)++ + goto _out + } + } + case 42: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_EVAL + { + (lex.p)++ + goto _out + } + } + case 43: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_EXIT + { + (lex.p)++ + goto _out + } + } + case 44: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_EXTENDS + { + (lex.p)++ + goto _out + } + } + case 45: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_FINAL + { + (lex.p)++ + goto _out + } + } + case 46: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_FINALLY + { + (lex.p)++ + goto _out + } + } + case 47: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_FOR + { + (lex.p)++ + goto _out + } + } + case 48: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_FOREACH + { + (lex.p)++ + goto _out + } + } + case 49: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_FUNCTION + { + (lex.p)++ + goto _out + } + } + case 50: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_FN + { + (lex.p)++ + goto _out + } + } + case 51: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_GLOBAL + { + (lex.p)++ + goto _out + } + } + case 52: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_GOTO + { + (lex.p)++ + goto _out + } + } + case 53: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_IF + { + (lex.p)++ + goto _out + } + } + case 54: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_ISSET + { + (lex.p)++ + goto _out + } + } + case 55: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_IMPLEMENTS + { + (lex.p)++ + goto _out + } + } + case 56: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_INSTANCEOF + { + (lex.p)++ + goto _out + } + } + case 57: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_INSTEADOF + { + (lex.p)++ + goto _out + } + } + case 58: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_INTERFACE + { + (lex.p)++ + goto _out + } + } + case 59: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_LIST + { + (lex.p)++ + goto _out + } + } + case 60: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_NAMESPACE + { + (lex.p)++ + goto _out + } + } + case 61: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_PRIVATE + { + (lex.p)++ + goto _out + } + } + case 62: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_PUBLIC + { + (lex.p)++ + goto _out + } + } + case 63: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_PRINT + { + (lex.p)++ + goto _out + } + } + case 64: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_PROTECTED + { + (lex.p)++ + goto _out + } + } + case 65: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_RETURN + { + (lex.p)++ + goto _out + } + } + case 66: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_STATIC + { + (lex.p)++ + goto _out + } + } + case 67: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_SWITCH + { + (lex.p)++ + goto _out + } + } + case 68: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_MATCH + { + (lex.p)++ + goto _out + } + } + case 69: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_THROW + { + (lex.p)++ + goto _out + } + } + case 70: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_TRAIT + { + (lex.p)++ + goto _out + } + } + case 71: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_TRY + { + (lex.p)++ + goto _out + } + } + case 72: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_UNSET + { + (lex.p)++ + goto _out + } + } + case 73: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_USE + { + (lex.p)++ + goto _out + } + } + case 74: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_VAR + { + (lex.p)++ + goto _out + } + } + case 75: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_WHILE + { + (lex.p)++ + goto _out + } + } + case 77: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_YIELD + { + (lex.p)++ + goto _out + } + } + case 78: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_INCLUDE + { + (lex.p)++ + goto _out + } + } + case 79: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_INCLUDE_ONCE + { + (lex.p)++ + goto _out + } + } + case 80: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_REQUIRE + { + (lex.p)++ + goto _out + } + } + case 81: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_REQUIRE_ONCE + { + (lex.p)++ + goto _out + } + } + case 82: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_CLASS_C + { + (lex.p)++ + goto _out + } + } + case 83: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_DIR + { + (lex.p)++ + goto _out + } + } + case 84: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_FILE + { + (lex.p)++ + goto _out + } + } + case 85: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_FUNC_C + { + (lex.p)++ + goto _out + } + } + case 86: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_LINE + { + (lex.p)++ + goto _out + } + } + case 87: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_NS_C + { + (lex.p)++ + goto _out + } + } + case 88: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_METHOD_C + { + (lex.p)++ + goto _out + } + } + case 89: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_TRAIT_C + { + (lex.p)++ + goto _out + } + } + case 90: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_HALT_COMPILER + lex.cs = 535 + { + (lex.p)++ + goto _out + } + } + case 91: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_NEW + { + (lex.p)++ + goto _out + } + } + case 92: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_LOGICAL_AND + { + (lex.p)++ + goto _out + } + } + case 93: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_LOGICAL_OR + { + (lex.p)++ + goto _out + } + } + case 94: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_LOGICAL_XOR + { + (lex.p)++ + goto _out + } + } + case 123: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_SL + { + (lex.p)++ + goto _out + } + } + case 142: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_STRING + { + (lex.p)++ + goto _out + } + } + case 148: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.ID(int('"')) + lex.cs = 509 + { + (lex.p)++ + goto _out + } + } + } + + goto _again + tr15: + // line internal/php8/scanner.rl:360 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_CONSTANT_ENCAPSED_STRING + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr19: + // line internal/php8/scanner.rl:383 + (lex.p) = (lex.te) - 1 + { + c := lex.data[lex.p] + lex.error(fmt.Sprintf("WARNING: Unexpected character in input: '%c' (ASCII=%d)", c, c)) + } + goto st131 + tr23: + // line internal/php8/scanner.rl:346 + (lex.p) = (lex.te) - 1 + { + lex.setTokenPosition(tkn) + tok = token.ID(int(lex.data[lex.ts])) + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr38: + // line internal/php8/scanner.rl:317 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_ARRAY_CAST + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr45: + // line internal/php8/scanner.rl:323 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_STRING_CAST + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr49: + // line internal/php8/scanner.rl:318 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_BOOL_CAST + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr57: + // line internal/php8/scanner.rl:320 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_DOUBLE_CAST + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr64: + // line internal/php8/scanner.rl:321 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_INT_CAST + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr73: + // line internal/php8/scanner.rl:322 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_OBJECT_CAST + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr77: + // line internal/php8/scanner.rl:319 + lex.te = (lex.p) + 1 + { + lex.error(fmt.Sprintf("The (real) cast has been removed, use (float) instead")) + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr86: + // line internal/php8/scanner.rl:324 + lex.te = (lex.p) + 1 + { + lex.error(fmt.Sprintf("The (unset) cast is no longer supported")) + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr87: + // line internal/php8/scanner.rl:285 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_ELLIPSIS + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr90: + // line internal/php8/scanner.rl:165 + (lex.p) = (lex.te) - 1 + { + lex.setTokenPosition(tkn) + tok = token.T_DNUMBER + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr100: + // line internal/php8/scanner.rl:333 + lex.te = (lex.p) + 1 + { + isDocComment := false + if lex.te-lex.ts > 4 && string(lex.data[lex.ts:lex.ts+3]) == "/**" { + isDocComment = true + } + + if isDocComment { + lex.addFreeFloatingToken(tkn, token.T_DOC_COMMENT, lex.ts, lex.te) + } else { + lex.addFreeFloatingToken(tkn, token.T_COMMENT, lex.ts, lex.te) + } + } + goto st131 + tr101: + // line internal/php8/scanner.rl:176 + (lex.p) = (lex.te) - 1 + { + 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 { + lex.setTokenPosition(tkn) + tok = token.T_LNUMBER + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + + lex.setTokenPosition(tkn) + tok = token.T_DNUMBER + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr114: + lex.cs = 131 + // line internal/php8/scanner.rl:163 + (lex.p) = (lex.te) - 1 + { + lex.setTokenPosition(tkn) + tok = token.ID(int(';')) + lex.cs = 124 + { + (lex.p)++ + goto _out + } + } + goto _again + tr130: + lex.cs = 131 + // line internal/php8/scanner.rl:358 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_NULLSAFE_OBJECT_OPERATOR + lex.cs = 485 + { + (lex.p)++ + goto _out + } + } + goto _again + tr131: + lex.cs = 131 + // line internal/php8/scanner.rl:162 + (lex.p) = (lex.te) - 1 + { + lex.setTokenPosition(tkn) + tok = token.ID(int(';')) + lex.cs = 124 + { + (lex.p)++ + goto _out + } + } + goto _again + tr134: + // line internal/php8/scanner.rl:355 + (lex.p) = (lex.te) - 1 + { + lex.setTokenPosition(tkn) + tok = token.T_STRING + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr137: + // line internal/php8/scanner.rl:266 + (lex.p) = (lex.te) - 1 + { + lex.setTokenPosition(tkn) + tok = token.T_YIELD + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr148: + // line internal/php8/scanner.rl:265 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_YIELD_FROM + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr149: + // line internal/php8/scanner.rl:204 + (lex.p) = (lex.te) - 1 + { + lex.setTokenPosition(tkn) + tok = token.T_NAME_FULLY_QUALIFIED + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr200: + // line internal/php8/scanner.rl:383 + lex.te = (lex.p) + 1 + { + c := lex.data[lex.p] + lex.error(fmt.Sprintf("WARNING: Unexpected character in input: '%c' (ASCII=%d)", c, c)) + } + goto st131 + tr211: + // line internal/php8/scanner.rl:346 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.ID(int(lex.data[lex.ts])) + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr249: + lex.cs = 131 + // line internal/php8/scanner.rl:380 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.ID(int('`')) + lex.cs = 503 + { + (lex.p)++ + goto _out + } + } + goto _again + tr250: + // line internal/php8/scanner.rl:352 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.ID(int('{')) + lex.call(131, 131) + goto _out + } + goto st131 + tr252: + // line internal/php8/scanner.rl:353 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.ID(int('}')) + lex.ret(1) + goto _out + } + goto st131 + tr253: + // line internal/php8/scanner.rl:161 + lex.te = (lex.p) + (lex.p)-- + { + lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te) + } + goto st131 + tr255: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:161 + lex.te = (lex.p) + (lex.p)-- + { + lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te) + } + goto st131 + tr259: + // line internal/php8/scanner.rl:383 + lex.te = (lex.p) + (lex.p)-- + { + c := lex.data[lex.p] + lex.error(fmt.Sprintf("WARNING: Unexpected character in input: '%c' (ASCII=%d)", c, c)) + } + goto st131 + tr260: + // line internal/php8/scanner.rl:346 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.ID(int(lex.data[lex.ts])) + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr262: + // line internal/php8/scanner.rl:303 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_IS_NOT_EQUAL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr263: + // line internal/php8/scanner.rl:304 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_IS_NOT_IDENTICAL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr264: + lex.cs = 131 + // line internal/php8/scanner.rl:381 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.ID(int('"')) + lex.cs = 509 + { + (lex.p)++ + goto _out + } + } + goto _again + tr265: + // line internal/php8/scanner.rl:330 + lex.te = (lex.p) + (lex.p)-- + { + lex.addFreeFloatingToken(tkn, token.T_COMMENT, lex.ts, lex.te) + } + goto st131 + tr267: + // line internal/php8/scanner.rl:284 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_ATTRIBUTE + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr268: + // line internal/php8/scanner.rl:326 + lex.te = (lex.p) + (lex.p)-- + { + lex.ungetStr("?>") + lex.addFreeFloatingToken(tkn, token.T_COMMENT, lex.ts, lex.te) + } + goto st131 + tr271: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:326 + lex.te = (lex.p) + (lex.p)-- + { + lex.ungetStr("?>") + lex.addFreeFloatingToken(tkn, token.T_COMMENT, lex.ts, lex.te) + } + goto st131 + tr276: + // line internal/php8/scanner.rl:354 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_VARIABLE + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr277: + // line internal/php8/scanner.rl:298 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_MOD_EQUAL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr278: + // line internal/php8/scanner.rl:287 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_BOOLEAN_AND + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr279: + // line internal/php8/scanner.rl:289 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_AND_EQUAL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr281: + // line internal/php8/scanner.rl:292 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_MUL_EQUAL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr282: + // line internal/php8/scanner.rl:311 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_POW + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr283: + // line internal/php8/scanner.rl:293 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_POW_EQUAL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr284: + // line internal/php8/scanner.rl:300 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_INC + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr285: + // line internal/php8/scanner.rl:295 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_PLUS_EQUAL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr286: + // line internal/php8/scanner.rl:299 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_DEC + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr287: + // line internal/php8/scanner.rl:296 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_MINUS_EQUAL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr288: + lex.cs = 131 + // line internal/php8/scanner.rl:357 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_OBJECT_OPERATOR + lex.cs = 485 + { + (lex.p)++ + goto _out + } + } + goto _again + tr290: + // line internal/php8/scanner.rl:291 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_CONCAT_EQUAL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr291: + // line internal/php8/scanner.rl:165 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_DNUMBER + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr294: + // line internal/php8/scanner.rl:294 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_DIV_EQUAL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr295: + // line internal/php8/scanner.rl:176 + lex.te = (lex.p) + (lex.p)-- + { + 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 { + lex.setTokenPosition(tkn) + tok = token.T_LNUMBER + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + + lex.setTokenPosition(tkn) + tok = token.T_DNUMBER + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr300: + // line internal/php8/scanner.rl:166 + lex.te = (lex.p) + (lex.p)-- + { + s := strings.Replace(string(lex.data[lex.ts+2:lex.te]), "_", "", -1) + _, err := strconv.ParseInt(s, 2, 0) + + if err == nil { + lex.setTokenPosition(tkn) + tok = token.T_LNUMBER + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + + lex.setTokenPosition(tkn) + tok = token.T_DNUMBER + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr301: + // line internal/php8/scanner.rl:191 + lex.te = (lex.p) + (lex.p)-- + { + s := strings.Replace(string(lex.data[lex.ts+2:lex.te]), "_", "", -1) + _, err := strconv.ParseInt(s, 16, 0) + + if err == nil { + lex.setTokenPosition(tkn) + tok = token.T_LNUMBER + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + + lex.setTokenPosition(tkn) + tok = token.T_DNUMBER + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr302: + // line internal/php8/scanner.rl:286 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_PAAMAYIM_NEKUDOTAYIM + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr303: + lex.cs = 131 + // line internal/php8/scanner.rl:163 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.ID(int(';')) + lex.cs = 124 + { + (lex.p)++ + goto _out + } + } + goto _again + tr305: + lex.cs = 131 + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:163 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.ID(int(';')) + lex.cs = 124 + { + (lex.p)++ + goto _out + } + } + goto _again + tr308: + // line internal/php8/scanner.rl:303 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_IS_NOT_EQUAL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr309: + // line internal/php8/scanner.rl:312 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_SL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr310: + // line internal/php8/scanner.rl:307 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_SL_EQUAL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr311: + lex.cs = 131 + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:366 + lex.te = (lex.p) + (lex.p)-- + { + lex.heredocLabel = lex.data[lblStart:lblEnd] + lex.setTokenPosition(tkn) + tok = token.T_START_HEREDOC + + if lex.isHeredocEnd(lex.p + 1) { + lex.cs = 515 + } else if lex.data[lblStart-1] == '\'' { + lex.cs = 492 + } else { + lex.cs = 496 + } + { + (lex.p)++ + goto _out + } + } + goto _again + tr312: + // line internal/php8/scanner.rl:310 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_IS_SMALLER_OR_EQUAL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr313: + // line internal/php8/scanner.rl:302 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_SPACESHIP + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr315: + // line internal/php8/scanner.rl:301 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_DOUBLE_ARROW + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr316: + // line internal/php8/scanner.rl:305 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_IS_EQUAL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr317: + // line internal/php8/scanner.rl:306 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_IS_IDENTICAL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr318: + // line internal/php8/scanner.rl:309 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_IS_GREATER_OR_EQUAL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr320: + // line internal/php8/scanner.rl:313 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_SR + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr321: + // line internal/php8/scanner.rl:308 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_SR_EQUAL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr325: + lex.cs = 131 + // line internal/php8/scanner.rl:162 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.ID(int(';')) + lex.cs = 124 + { + (lex.p)++ + goto _out + } + } + goto _again + tr327: + lex.cs = 131 + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:162 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.ID(int(';')) + lex.cs = 124 + { + (lex.p)++ + goto _out + } + } + goto _again + tr328: + // line internal/php8/scanner.rl:314 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_COALESCE + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr329: + // line internal/php8/scanner.rl:315 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_COALESCE_EQUAL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr330: + // line internal/php8/scanner.rl:355 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_STRING + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr336: + // line internal/php8/scanner.rl:203 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_NAME_QUALIFIED + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr412: + // line internal/php8/scanner.rl:222 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_ELSE + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr432: + // line internal/php8/scanner.rl:226 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_ENDFOR + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr461: + // line internal/php8/scanner.rl:234 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_FINAL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr465: + // line internal/php8/scanner.rl:236 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_FOR + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr497: + // line internal/php8/scanner.rl:267 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_INCLUDE + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr540: + // line internal/php8/scanner.rl:249 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_NAMESPACE + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr542: + // line internal/php8/scanner.rl:202 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_NAME_RELATIVE + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr572: + // line internal/php8/scanner.rl:269 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_REQUIRE + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr618: + // line internal/php8/scanner.rl:266 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_YIELD + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr619: + // line internal/php8/scanner.rl:205 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_NS_SEPARATOR + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr620: + // line internal/php8/scanner.rl:204 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_NAME_FULLY_QUALIFIED + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr622: + // line internal/php8/scanner.rl:297 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_XOR_EQUAL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr696: + // line internal/php8/scanner.rl:290 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_OR_EQUAL + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + tr697: + // line internal/php8/scanner.rl:288 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_BOOLEAN_OR + { + (lex.p)++ + lex.cs = 131 + goto _out + } + } + goto st131 + st131: + // line NONE:1 + lex.ts = 0 + + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof131 + } + st_case_131: + // line NONE:1 + lex.ts = (lex.p) + + // line internal/php8/scanner.go:3652 + switch lex.data[(lex.p)] { + case 10: + goto tr11 + case 13: + goto tr202 + case 32: + goto tr201 + case 33: + goto st135 + case 34: + goto tr204 + case 35: + goto st138 + case 36: + goto st141 + case 37: + goto st143 + case 38: + goto st144 + case 39: + goto tr209 + case 40: + goto tr210 + case 42: + goto st147 + case 43: + goto st149 + case 45: + goto st150 + case 46: + goto tr215 + case 47: + goto tr216 + case 48: + goto tr217 + case 58: + goto st160 + case 59: + goto tr219 + case 60: + goto st164 + case 61: + goto st168 + case 62: + goto st170 + case 63: + goto tr223 + case 64: + goto tr211 + case 65: + goto tr224 + case 66: + goto tr225 + case 67: + goto tr226 + case 68: + goto tr227 + case 69: + goto tr228 + case 70: + goto tr229 + case 71: + goto tr230 + case 73: + goto tr232 + case 76: + goto tr233 + case 77: + goto tr234 + case 78: + goto tr235 + case 79: + goto tr236 + case 80: + goto tr237 + case 82: + goto tr238 + case 83: + goto tr239 + case 84: + goto tr240 + case 85: + goto tr241 + case 86: + goto tr242 + case 87: + goto tr243 + case 88: + goto tr244 + case 89: + goto tr245 + case 92: + goto st416 + case 94: + goto st418 + case 95: + goto tr248 + case 96: + goto tr249 + case 97: + goto tr224 + case 98: + goto tr225 + case 99: + goto tr226 + case 100: + goto tr227 + case 101: + goto tr228 + case 102: + goto tr229 + case 103: + goto tr230 + case 105: + goto tr232 + case 108: + goto tr233 + case 109: + goto tr234 + case 110: + goto tr235 + case 111: + goto tr236 + case 112: + goto tr237 + case 114: + goto tr238 + case 115: + goto tr239 + case 116: + goto tr240 + case 117: + goto tr241 + case 118: + goto tr242 + case 119: + goto tr243 + case 120: + goto tr244 + case 121: + goto tr245 + case 123: + goto tr250 + case 124: + goto st484 + case 125: + goto tr252 + case 126: + goto tr211 + case 127: + goto tr200 + } + 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 tr201 + } + default: + goto tr200 + } + case lex.data[(lex.p)] > 31: + switch { + case lex.data[(lex.p)] < 49: + if 41 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 44 { + goto tr211 + } + case lex.data[(lex.p)] > 57: + if 91 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 93 { + goto tr211 + } + default: + goto tr102 + } + default: + goto tr200 + } + goto tr231 + tr201: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st132 + tr256: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:54 + + goto st132 + st132: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof132 + } + st_case_132: + // line internal/php8/scanner.go:3849 + switch lex.data[(lex.p)] { + case 10: + goto tr11 + case 13: + goto tr254 + case 32: + goto tr201 + } + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr201 + } + goto tr253 + tr11: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st133 + tr257: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st133 + st133: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof133 + } + st_case_133: + // line internal/php8/scanner.go:3899 + switch lex.data[(lex.p)] { + case 10: + goto tr257 + case 13: + goto tr258 + case 32: + goto tr256 + } + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr256 + } + goto tr255 + tr254: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st6 + tr258: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st6 + st6: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof6 + } + st_case_6: + // line internal/php8/scanner.go:3943 + if lex.data[(lex.p)] == 10 { + goto tr11 + } + goto tr10 + tr202: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st134 + st134: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof134 + } + st_case_134: + // line internal/php8/scanner.go:3965 + if lex.data[(lex.p)] == 10 { + goto tr11 + } + goto tr259 + st135: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof135 + } + st_case_135: + if lex.data[(lex.p)] == 61 { + goto st136 + } + goto tr260 + st136: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof136 + } + st_case_136: + if lex.data[(lex.p)] == 61 { + goto tr263 + } + goto tr262 + tr204: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:381 + lex.act = 148 + goto st137 + st137: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof137 + } + st_case_137: + // line internal/php8/scanner.go:4000 + switch lex.data[(lex.p)] { + case 10: + goto tr14 + case 13: + goto tr14 + case 34: + goto tr15 + case 36: + goto st8 + case 92: + goto st9 + case 123: + goto st10 + } + goto st7 + tr14: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st7 + st7: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof7 + } + st_case_7: + // line internal/php8/scanner.go:4033 + switch lex.data[(lex.p)] { + case 10: + goto tr14 + case 13: + goto tr14 + case 34: + goto tr15 + case 36: + goto st8 + case 92: + goto st9 + case 123: + goto st10 + } + goto st7 + st8: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof8 + } + st_case_8: + switch lex.data[(lex.p)] { + case 10: + goto tr14 + case 13: + goto tr14 + case 34: + goto tr15 + case 36: + goto st8 + case 92: + goto st9 + case 96: + goto st7 + } + switch { + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto st7 + } + case lex.data[(lex.p)] > 94: + if 124 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto st7 + } + default: + goto st7 + } + goto tr12 + st9: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof9 + } + st_case_9: + switch lex.data[(lex.p)] { + case 10: + goto tr14 + case 13: + goto tr14 + } + goto st7 + st10: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof10 + } + st_case_10: + switch lex.data[(lex.p)] { + case 10: + goto tr14 + case 13: + goto tr14 + case 34: + goto tr15 + case 36: + goto tr12 + case 92: + goto st9 + } + goto st7 + st138: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof138 + } + st_case_138: + if lex.data[(lex.p)] == 91 { + goto tr267 + } + goto st139 + tr270: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st139 + tr272: + // line internal/php8/scanner.rl:54 + + goto st139 + tr274: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st139 + st139: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof139 + } + st_case_139: + // line internal/php8/scanner.go:4155 + _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 + } + } + switch _widec { + case 522: + goto tr269 + case 525: + goto tr270 + } + if 512 <= _widec && _widec <= 767 { + goto st139 + } + goto tr268 + tr269: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st140 + tr273: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st140 + st140: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof140 + } + st_case_140: + // line internal/php8/scanner.go:4235 + _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 + } + } + switch _widec { + case 522: + goto tr273 + case 525: + goto tr274 + } + if 512 <= _widec && _widec <= 767 { + goto tr272 + } + goto tr271 + st141: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof141 + } + st_case_141: + if lex.data[(lex.p)] == 96 { + goto tr260 + } + switch { + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto tr260 + } + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr260 + } + default: + goto tr260 + } + goto st142 + st142: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof142 + } + st_case_142: + if lex.data[(lex.p)] == 96 { + goto tr276 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr276 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr276 + } + case lex.data[(lex.p)] >= 91: + goto tr276 + } + default: + goto tr276 + } + goto st142 + st143: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof143 + } + st_case_143: + if lex.data[(lex.p)] == 61 { + goto tr277 + } + goto tr260 + st144: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof144 + } + st_case_144: + switch lex.data[(lex.p)] { + case 38: + goto tr278 + case 61: + goto tr279 + } + goto tr260 + tr209: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st145 + st145: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof145 + } + st_case_145: + // line internal/php8/scanner.go:4362 + switch lex.data[(lex.p)] { + case 10: + goto tr21 + case 13: + goto tr21 + case 39: + goto tr15 + case 92: + goto st12 + } + goto st11 + tr21: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st11 + st11: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof11 + } + st_case_11: + // line internal/php8/scanner.go:4391 + switch lex.data[(lex.p)] { + case 10: + goto tr21 + case 13: + goto tr21 + case 39: + goto tr15 + case 92: + goto st12 + } + goto st11 + st12: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof12 + } + st_case_12: + switch lex.data[(lex.p)] { + case 10: + goto tr21 + case 13: + goto tr21 + } + goto st11 + tr210: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st146 + st146: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof146 + } + st_case_146: + // line internal/php8/scanner.go:4425 + switch lex.data[(lex.p)] { + case 9: + goto st13 + case 32: + goto st13 + case 65: + goto st14 + case 66: + goto st19 + case 68: + goto st31 + case 70: + goto st37 + case 73: + goto st41 + case 79: + goto st48 + case 82: + goto st54 + case 83: + goto st58 + case 85: + goto st63 + case 97: + goto st14 + case 98: + goto st19 + case 100: + goto st31 + case 102: + goto st37 + case 105: + goto st41 + case 111: + goto st48 + case 114: + goto st54 + case 115: + goto st58 + case 117: + goto st63 + } + if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st13 + } + goto tr260 + st13: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof13 + } + st_case_13: + switch lex.data[(lex.p)] { + case 9: + goto st13 + case 32: + goto st13 + case 65: + goto st14 + case 66: + goto st19 + case 68: + goto st31 + case 70: + goto st37 + case 73: + goto st41 + case 79: + goto st48 + case 82: + goto st54 + case 83: + goto st58 + case 85: + goto st63 + case 97: + goto st14 + case 98: + goto st19 + case 100: + goto st31 + case 102: + goto st37 + case 105: + goto st41 + case 111: + goto st48 + case 114: + goto st54 + case 115: + goto st58 + case 117: + goto st63 + } + if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st13 + } + goto tr23 + 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 + } + goto tr23 + st15: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof15 + } + st_case_15: + switch lex.data[(lex.p)] { + case 82: + goto st16 + case 114: + goto st16 + } + goto tr23 + st16: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof16 + } + st_case_16: + switch lex.data[(lex.p)] { + case 65: + goto st17 + case 97: + goto st17 + } + goto tr23 + st17: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof17 + } + st_case_17: + switch lex.data[(lex.p)] { + case 89: + goto st18 + case 121: + goto st18 + } + goto tr23 + st18: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof18 + } + st_case_18: + switch lex.data[(lex.p)] { + case 9: + goto st18 + case 32: + goto st18 + case 41: + goto tr38 + } + if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st18 + } + goto tr23 + st19: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof19 + } + st_case_19: + switch lex.data[(lex.p)] { + case 73: + goto st20 + case 79: + goto st25 + case 105: + goto st20 + case 111: + goto st25 + } + goto tr23 + st20: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof20 + } + st_case_20: + switch lex.data[(lex.p)] { + case 78: + goto st21 + case 110: + goto st21 + } + goto tr23 + st21: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof21 + } + st_case_21: + switch lex.data[(lex.p)] { + case 65: + goto st22 + case 97: + goto st22 + } + goto tr23 + st22: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof22 + } + st_case_22: + switch lex.data[(lex.p)] { + case 82: + goto st23 + case 114: + goto st23 + } + goto tr23 + st23: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof23 + } + st_case_23: + switch lex.data[(lex.p)] { + case 89: + goto st24 + case 121: + goto st24 + } + goto tr23 + st24: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof24 + } + st_case_24: + switch lex.data[(lex.p)] { + case 9: + goto st24 + case 32: + goto st24 + case 41: + goto tr45 + } + if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st24 + } + goto tr23 + st25: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof25 + } + st_case_25: + switch lex.data[(lex.p)] { + case 79: + goto st26 + case 111: + goto st26 + } + goto tr23 + st26: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof26 + } + st_case_26: + switch lex.data[(lex.p)] { + case 76: + goto st27 + case 108: + goto st27 + } + goto tr23 + st27: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof27 + } + st_case_27: + switch lex.data[(lex.p)] { + case 9: + goto st28 + case 32: + goto st28 + case 41: + goto tr49 + case 69: + goto st29 + case 101: + goto st29 + } + if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st28 + } + goto tr23 + st28: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof28 + } + st_case_28: + switch lex.data[(lex.p)] { + case 9: + goto st28 + case 32: + goto st28 + case 41: + goto tr49 + } + if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st28 + } + goto tr23 + st29: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof29 + } + st_case_29: + switch lex.data[(lex.p)] { + case 65: + goto st30 + case 97: + goto st30 + } + goto tr23 + st30: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof30 + } + st_case_30: + switch lex.data[(lex.p)] { + case 78: + goto st28 + case 110: + goto st28 + } + goto tr23 + st31: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof31 + } + st_case_31: + switch lex.data[(lex.p)] { + case 79: + goto st32 + case 111: + goto st32 + } + goto tr23 + st32: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof32 + } + st_case_32: + switch lex.data[(lex.p)] { + case 85: + goto st33 + case 117: + goto st33 + } + goto tr23 + st33: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof33 + } + st_case_33: + switch lex.data[(lex.p)] { + case 66: + goto st34 + case 98: + goto st34 + } + goto tr23 + st34: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof34 + } + st_case_34: + switch lex.data[(lex.p)] { + case 76: + goto st35 + case 108: + goto st35 + } + goto tr23 + st35: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof35 + } + st_case_35: + switch lex.data[(lex.p)] { + case 69: + goto st36 + case 101: + goto st36 + } + goto tr23 + st36: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof36 + } + st_case_36: + switch lex.data[(lex.p)] { + case 9: + goto st36 + case 32: + goto st36 + case 41: + goto tr57 + } + if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st36 + } + goto tr23 + st37: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof37 + } + st_case_37: + switch lex.data[(lex.p)] { + case 76: + goto st38 + case 108: + goto st38 + } + goto tr23 + st38: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof38 + } + st_case_38: + switch lex.data[(lex.p)] { + case 79: + goto st39 + case 111: + goto st39 + } + goto tr23 + st39: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof39 + } + st_case_39: + switch lex.data[(lex.p)] { + case 65: + goto st40 + case 97: + goto st40 + } + goto tr23 + st40: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof40 + } + st_case_40: + switch lex.data[(lex.p)] { + case 84: + goto st36 + case 116: + goto st36 + } + goto tr23 + st41: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof41 + } + st_case_41: + switch lex.data[(lex.p)] { + case 78: + goto st42 + case 110: + goto st42 + } + goto tr23 + st42: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof42 + } + st_case_42: + switch lex.data[(lex.p)] { + case 84: + goto st43 + case 116: + goto st43 + } + goto tr23 + st43: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof43 + } + st_case_43: + switch lex.data[(lex.p)] { + case 9: + goto st44 + case 32: + goto st44 + case 41: + goto tr64 + case 69: + goto st45 + case 101: + goto st45 + } + if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st44 + } + goto tr23 + st44: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof44 + } + st_case_44: + switch lex.data[(lex.p)] { + case 9: + goto st44 + case 32: + goto st44 + case 41: + goto tr64 + } + if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st44 + } + goto tr23 + st45: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof45 + } + st_case_45: + switch lex.data[(lex.p)] { + case 71: + goto st46 + case 103: + goto st46 + } + goto tr23 + st46: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof46 + } + st_case_46: + switch lex.data[(lex.p)] { + case 69: + goto st47 + case 101: + goto st47 + } + goto tr23 + st47: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof47 + } + st_case_47: + switch lex.data[(lex.p)] { + case 82: + goto st44 + case 114: + goto st44 + } + goto tr23 + st48: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof48 + } + st_case_48: + switch lex.data[(lex.p)] { + case 66: + goto st49 + case 98: + goto st49 + } + goto tr23 + st49: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof49 + } + st_case_49: + switch lex.data[(lex.p)] { + case 74: + goto st50 + case 106: + goto st50 + } + goto tr23 + st50: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof50 + } + st_case_50: + switch lex.data[(lex.p)] { + case 69: + goto st51 + case 101: + goto st51 + } + goto tr23 + st51: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof51 + } + st_case_51: + switch lex.data[(lex.p)] { + case 67: + goto st52 + case 99: + goto st52 + } + goto tr23 + st52: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof52 + } + st_case_52: + switch lex.data[(lex.p)] { + case 84: + goto st53 + case 116: + goto st53 + } + goto tr23 + st53: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof53 + } + st_case_53: + switch lex.data[(lex.p)] { + case 9: + goto st53 + case 32: + goto st53 + case 41: + goto tr73 + } + if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st53 + } + goto tr23 + st54: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof54 + } + st_case_54: + switch lex.data[(lex.p)] { + case 69: + goto st55 + case 101: + goto st55 + } + goto tr23 + st55: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof55 + } + st_case_55: + switch lex.data[(lex.p)] { + case 65: + goto st56 + case 97: + goto st56 + } + goto tr23 + st56: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof56 + } + st_case_56: + switch lex.data[(lex.p)] { + case 76: + goto st57 + case 108: + goto st57 + } + goto tr23 + st57: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof57 + } + st_case_57: + switch lex.data[(lex.p)] { + case 9: + goto st57 + case 32: + goto st57 + case 41: + goto tr77 + } + if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st57 + } + goto tr23 + st58: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof58 + } + st_case_58: + switch lex.data[(lex.p)] { + case 84: + goto st59 + case 116: + goto st59 + } + goto tr23 + st59: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof59 + } + st_case_59: + switch lex.data[(lex.p)] { + case 82: + goto st60 + case 114: + goto st60 + } + goto tr23 + st60: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof60 + } + st_case_60: + switch lex.data[(lex.p)] { + case 73: + goto st61 + case 105: + goto st61 + } + goto tr23 + st61: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof61 + } + st_case_61: + switch lex.data[(lex.p)] { + case 78: + goto st62 + case 110: + goto st62 + } + goto tr23 + st62: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof62 + } + st_case_62: + switch lex.data[(lex.p)] { + case 71: + goto st24 + case 103: + goto st24 + } + goto tr23 + st63: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof63 + } + st_case_63: + switch lex.data[(lex.p)] { + case 78: + goto st64 + case 110: + goto st64 + } + goto tr23 + st64: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof64 + } + st_case_64: + switch lex.data[(lex.p)] { + case 83: + goto st65 + case 115: + goto st65 + } + goto tr23 + st65: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof65 + } + st_case_65: + switch lex.data[(lex.p)] { + case 69: + goto st66 + case 101: + goto st66 + } + goto tr23 + st66: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof66 + } + st_case_66: + switch lex.data[(lex.p)] { + case 84: + goto st67 + case 116: + goto st67 + } + goto tr23 + st67: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof67 + } + st_case_67: + switch lex.data[(lex.p)] { + case 9: + goto st67 + case 32: + goto st67 + case 41: + goto tr86 + } + if 11 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st67 + } + goto tr23 + st147: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof147 + } + st_case_147: + switch lex.data[(lex.p)] { + case 42: + goto st148 + case 61: + goto tr281 + } + goto tr260 + st148: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof148 + } + st_case_148: + if lex.data[(lex.p)] == 61 { + goto tr283 + } + goto tr282 + st149: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof149 + } + st_case_149: + switch lex.data[(lex.p)] { + case 43: + goto tr284 + case 61: + goto tr285 + } + goto tr260 + st150: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof150 + } + st_case_150: + switch lex.data[(lex.p)] { + case 45: + goto tr286 + case 61: + goto tr287 + case 62: + goto tr288 + } + goto tr260 + tr215: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st151 + st151: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof151 + } + st_case_151: + // line internal/php8/scanner.go:5290 + switch lex.data[(lex.p)] { + case 46: + goto st68 + case 61: + goto tr290 + } + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr91 + } + goto tr260 + st68: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof68 + } + st_case_68: + if lex.data[(lex.p)] == 46 { + goto tr87 + } + goto tr23 + tr91: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:165 + lex.act = 10 + goto st152 + st152: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof152 + } + st_case_152: + // line internal/php8/scanner.go:5322 + switch lex.data[(lex.p)] { + case 69: + goto st69 + case 95: + goto st71 + case 101: + goto st69 + } + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr91 + } + goto tr291 + st69: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof69 + } + st_case_69: + switch lex.data[(lex.p)] { + case 43: + goto st70 + case 45: + goto st70 + } + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr89 + } + goto tr12 + st70: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof70 + } + st_case_70: + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr89 + } + goto tr12 + tr89: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:165 + lex.act = 10 + goto st153 + st153: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof153 + } + st_case_153: + // line internal/php8/scanner.go:5371 + if lex.data[(lex.p)] == 95 { + goto st70 + } + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr89 + } + goto tr291 + st71: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof71 + } + st_case_71: + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr91 + } + goto tr90 + tr216: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st154 + st154: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof154 + } + st_case_154: + // line internal/php8/scanner.go:5398 + switch lex.data[(lex.p)] { + case 42: + goto st72 + case 47: + goto st139 + case 61: + goto tr294 + } + goto tr260 + tr94: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st72 + tr96: + // line internal/php8/scanner.rl:54 + + goto st72 + tr98: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st72 + st72: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof72 + } + st_case_72: + // line internal/php8/scanner.go:5443 + switch lex.data[(lex.p)] { + case 10: + goto tr93 + case 13: + goto tr94 + case 42: + goto st74 + } + goto st72 + tr93: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st73 + tr97: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st73 + st73: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof73 + } + st_case_73: + // line internal/php8/scanner.go:5484 + switch lex.data[(lex.p)] { + case 10: + goto tr97 + case 13: + goto tr98 + case 42: + goto tr99 + } + goto tr96 + tr99: + // line internal/php8/scanner.rl:54 + + goto st74 + st74: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof74 + } + st_case_74: + // line internal/php8/scanner.go:5503 + switch lex.data[(lex.p)] { + case 10: + goto tr93 + case 13: + goto tr94 + case 42: + goto st74 + case 47: + goto tr100 + } + goto st72 + tr217: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:176 + lex.act = 12 + goto st155 + st155: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof155 + } + st_case_155: + // line internal/php8/scanner.go:5527 + switch lex.data[(lex.p)] { + case 46: + goto tr296 + case 69: + goto st69 + case 95: + goto st75 + case 98: + goto st76 + case 101: + goto st69 + case 120: + goto st77 + } + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr102 + } + goto tr295 + tr296: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:165 + lex.act = 10 + goto st156 + st156: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof156 + } + st_case_156: + // line internal/php8/scanner.go:5558 + switch lex.data[(lex.p)] { + case 69: + goto st69 + case 101: + goto st69 + } + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr91 + } + goto tr291 + tr102: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:176 + lex.act = 12 + goto st157 + st157: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof157 + } + st_case_157: + // line internal/php8/scanner.go:5581 + switch lex.data[(lex.p)] { + case 46: + goto tr296 + case 69: + goto st69 + case 95: + goto st75 + case 101: + goto st69 + } + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr102 + } + goto tr295 + st75: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof75 + } + st_case_75: + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr102 + } + goto tr101 + st76: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof76 + } + st_case_76: + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 49 { + goto tr103 + } + goto tr12 + tr103: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:166 + lex.act = 11 + goto st158 + st158: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof158 + } + st_case_158: + // line internal/php8/scanner.go:5626 + if lex.data[(lex.p)] == 95 { + goto st76 + } + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 49 { + goto tr103 + } + goto tr300 + st77: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof77 + } + st_case_77: + switch { + case lex.data[(lex.p)] < 65: + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr104 + } + case lex.data[(lex.p)] > 70: + if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { + goto tr104 + } + default: + goto tr104 + } + goto tr12 + tr104: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:191 + lex.act = 13 + goto st159 + st159: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof159 + } + st_case_159: + // line internal/php8/scanner.go:5664 + if lex.data[(lex.p)] == 95 { + goto st77 + } + switch { + case lex.data[(lex.p)] < 65: + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr104 + } + case lex.data[(lex.p)] > 70: + if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { + goto tr104 + } + default: + goto tr104 + } + goto tr301 + st160: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof160 + } + st_case_160: + if lex.data[(lex.p)] == 58 { + goto tr302 + } + goto tr260 + tr219: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st161 + st161: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof161 + } + st_case_161: + // line internal/php8/scanner.go:5700 + switch lex.data[(lex.p)] { + case 10: + goto tr106 + case 13: + goto tr107 + case 32: + goto st78 + case 63: + goto st81 + } + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st78 + } + goto tr260 + tr109: + // line internal/php8/scanner.rl:54 + + goto st78 + st78: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof78 + } + st_case_78: + // line internal/php8/scanner.go:5724 + switch lex.data[(lex.p)] { + case 10: + goto tr106 + case 13: + goto tr107 + case 32: + goto st78 + case 63: + goto st81 + } + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st78 + } + goto tr23 + tr106: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st79 + tr110: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st79 + st79: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof79 + } + st_case_79: + // line internal/php8/scanner.go:5770 + switch lex.data[(lex.p)] { + case 10: + goto tr110 + case 13: + goto tr111 + case 32: + goto tr109 + case 63: + goto tr112 + } + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr109 + } + goto tr23 + tr107: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st80 + tr111: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st80 + st80: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof80 + } + st_case_80: + // line internal/php8/scanner.go:5816 + if lex.data[(lex.p)] == 10 { + goto tr106 + } + goto tr23 + tr112: + // line internal/php8/scanner.rl:54 + + goto st81 + st81: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof81 + } + st_case_81: + // line internal/php8/scanner.go:5830 + if lex.data[(lex.p)] == 62 { + goto tr113 + } + goto tr23 + tr113: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st162 + st162: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof162 + } + st_case_162: + // line internal/php8/scanner.go:5845 + switch lex.data[(lex.p)] { + case 10: + goto tr115 + case 13: + goto tr304 + } + goto tr303 + tr115: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st163 + st163: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof163 + } + st_case_163: + // line internal/php8/scanner.go:5870 + goto tr305 + tr304: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st82 + st82: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof82 + } + st_case_82: + // line internal/php8/scanner.go:5889 + if lex.data[(lex.p)] == 10 { + goto tr115 + } + goto tr114 + st164: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof164 + } + st_case_164: + switch lex.data[(lex.p)] { + case 60: + goto tr306 + case 61: + goto st167 + case 62: + goto tr308 + } + goto tr260 + tr306: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:312 + lex.act = 123 + goto st165 + st165: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof165 + } + st_case_165: + // line internal/php8/scanner.go:5920 + switch lex.data[(lex.p)] { + case 60: + goto st83 + case 61: + goto tr310 + } + goto tr309 + st83: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof83 + } + st_case_83: + switch lex.data[(lex.p)] { + case 9: + goto st83 + case 32: + goto st83 + case 34: + goto st84 + case 39: + goto st88 + case 96: + goto tr12 + } + switch { + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto tr12 + } + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr12 + } + default: + goto tr12 + } + goto tr119 + st84: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof84 + } + st_case_84: + if lex.data[(lex.p)] == 96 { + goto tr12 + } + switch { + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto tr12 + } + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr12 + } + default: + goto tr12 + } + goto tr120 + tr120: + // line internal/php8/scanner.rl:35 + lblStart = lex.p + goto st85 + st85: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof85 + } + st_case_85: + // line internal/php8/scanner.go:5988 + switch lex.data[(lex.p)] { + case 34: + goto tr121 + case 96: + goto tr12 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr12 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr12 + } + case lex.data[(lex.p)] >= 91: + goto tr12 + } + default: + goto tr12 + } + goto st85 + tr121: + // line internal/php8/scanner.rl:36 + lblEnd = lex.p + goto st86 + st86: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof86 + } + st_case_86: + // line internal/php8/scanner.go:6022 + switch lex.data[(lex.p)] { + case 10: + goto tr123 + case 13: + goto tr124 + } + goto tr12 + tr123: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st166 + tr127: + // line internal/php8/scanner.rl:36 + lblEnd = lex.p + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st166 + st166: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof166 + } + st_case_166: + // line internal/php8/scanner.go:6061 + goto tr311 + tr124: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st87 + tr128: + // line internal/php8/scanner.rl:36 + lblEnd = lex.p + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st87 + st87: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof87 + } + st_case_87: + // line internal/php8/scanner.go:6094 + if lex.data[(lex.p)] == 10 { + goto tr123 + } + goto tr12 + st88: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof88 + } + st_case_88: + if lex.data[(lex.p)] == 96 { + goto tr12 + } + switch { + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto tr12 + } + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr12 + } + default: + goto tr12 + } + goto tr125 + tr125: + // line internal/php8/scanner.rl:35 + lblStart = lex.p + goto st89 + st89: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof89 + } + st_case_89: + // line internal/php8/scanner.go:6129 + switch lex.data[(lex.p)] { + case 39: + goto tr121 + case 96: + goto tr12 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr12 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr12 + } + case lex.data[(lex.p)] >= 91: + goto tr12 + } + default: + goto tr12 + } + goto st89 + tr119: + // line internal/php8/scanner.rl:35 + lblStart = lex.p + goto st90 + st90: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof90 + } + st_case_90: + // line internal/php8/scanner.go:6163 + switch lex.data[(lex.p)] { + case 10: + goto tr127 + case 13: + goto tr128 + case 96: + goto tr12 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr12 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr12 + } + case lex.data[(lex.p)] >= 91: + goto tr12 + } + default: + goto tr12 + } + goto st90 + st167: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof167 + } + st_case_167: + if lex.data[(lex.p)] == 62 { + goto tr313 + } + goto tr312 + st168: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof168 + } + st_case_168: + switch lex.data[(lex.p)] { + case 61: + goto st169 + case 62: + goto tr315 + } + goto tr260 + st169: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof169 + } + st_case_169: + if lex.data[(lex.p)] == 61 { + goto tr317 + } + goto tr316 + st170: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof170 + } + st_case_170: + switch lex.data[(lex.p)] { + case 61: + goto tr318 + case 62: + goto st171 + } + goto tr260 + st171: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof171 + } + st_case_171: + if lex.data[(lex.p)] == 61 { + goto tr321 + } + goto tr320 + tr223: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st172 + st172: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof172 + } + st_case_172: + // line internal/php8/scanner.go:6251 + switch lex.data[(lex.p)] { + case 45: + goto st91 + case 62: + goto tr323 + case 63: + goto st175 + } + goto tr260 + st91: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof91 + } + st_case_91: + if lex.data[(lex.p)] == 62 { + goto tr130 + } + goto tr23 + tr323: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st173 + st173: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof173 + } + st_case_173: + // line internal/php8/scanner.go:6280 + switch lex.data[(lex.p)] { + case 10: + goto tr132 + case 13: + goto tr326 + } + goto tr325 + tr132: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st174 + st174: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof174 + } + st_case_174: + // line internal/php8/scanner.go:6305 + goto tr327 + tr326: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st92 + st92: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof92 + } + st_case_92: + // line internal/php8/scanner.go:6324 + if lex.data[(lex.p)] == 10 { + goto tr132 + } + goto tr131 + st175: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof175 + } + st_case_175: + if lex.data[(lex.p)] == 61 { + goto tr329 + } + goto tr328 + tr224: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st176 + st176: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof176 + } + st_case_176: + // line internal/php8/scanner.go:6350 + switch lex.data[(lex.p)] { + case 66: + goto tr331 + case 78: + goto tr332 + case 82: + goto tr333 + case 83: + goto tr334 + case 92: + goto st93 + case 96: + goto tr330 + case 98: + goto tr331 + case 110: + goto tr332 + case 114: + goto tr333 + case 115: + goto tr334 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr231: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st177 + tr334: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:209 + lex.act = 20 + goto st177 + tr342: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:207 + lex.act = 18 + goto st177 + tr343: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:281 + lex.act = 92 + goto st177 + tr346: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:208 + lex.act = 19 + goto st177 + tr351: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:210 + lex.act = 21 + goto st177 + tr363: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:211 + lex.act = 22 + goto st177 + tr364: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:212 + lex.act = 23 + goto st177 + tr366: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:213 + lex.act = 24 + goto st177 + tr373: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:238 + lex.act = 49 + goto st177 + tr377: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:214 + lex.act = 25 + goto st177 + tr379: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:215 + lex.act = 26 + goto st177 + tr383: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:216 + lex.act = 27 + goto st177 + tr387: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:217 + lex.act = 28 + goto st177 + tr390: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:220 + lex.act = 31 + goto st177 + tr396: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:218 + lex.act = 29 + goto st177 + tr400: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:219 + lex.act = 30 + goto st177 + tr401: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:232 + lex.act = 43 + goto st177 + tr409: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:221 + lex.act = 32 + goto st177 + tr414: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:223 + lex.act = 34 + goto st177 + tr417: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:224 + lex.act = 35 + goto st177 + tr429: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:225 + lex.act = 36 + goto st177 + tr436: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:227 + lex.act = 38 + goto st177 + tr437: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:228 + lex.act = 39 + goto st177 + tr442: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:229 + lex.act = 40 + goto st177 + tr446: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:230 + lex.act = 41 + goto st177 + tr448: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:231 + lex.act = 42 + goto st177 + tr454: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:233 + lex.act = 44 + goto st177 + tr456: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:239 + lex.act = 50 + goto st177 + tr463: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:235 + lex.act = 46 + goto st177 + tr469: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:237 + lex.act = 48 + goto st177 + tr475: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:240 + lex.act = 51 + goto st177 + tr477: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:241 + lex.act = 52 + goto st177 + tr478: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:242 + lex.act = 53 + goto st177 + tr489: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:244 + lex.act = 55 + goto st177 + tr502: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:268 + lex.act = 79 + goto st177 + tr510: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:245 + lex.act = 56 + goto st177 + tr514: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:246 + lex.act = 57 + goto st177 + tr520: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:247 + lex.act = 58 + goto st177 + tr523: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:243 + lex.act = 54 + goto st177 + tr526: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:248 + lex.act = 59 + goto st177 + tr530: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:257 + lex.act = 68 + goto st177 + tr543: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:280 + lex.act = 91 + goto st177 + tr544: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:282 + lex.act = 93 + goto st177 + tr551: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:252 + lex.act = 63 + goto st177 + tr554: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:250 + lex.act = 61 + goto st177 + tr560: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:253 + lex.act = 64 + goto st177 + tr564: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:251 + lex.act = 62 + goto st177 + tr577: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:270 + lex.act = 81 + goto st177 + tr580: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:254 + lex.act = 65 + goto st177 + tr586: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:255 + lex.act = 66 + goto st177 + tr590: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:256 + lex.act = 67 + goto st177 + tr595: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:258 + lex.act = 69 + goto st177 + tr597: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:260 + lex.act = 71 + goto st177 + tr599: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:259 + lex.act = 70 + goto st177 + tr604: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:261 + lex.act = 72 + goto st177 + tr605: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:262 + lex.act = 73 + goto st177 + tr607: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:263 + lex.act = 74 + goto st177 + tr611: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:264 + lex.act = 75 + goto st177 + tr613: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:283 + lex.act = 94 + goto st177 + tr637: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:271 + lex.act = 82 + goto st177 + tr641: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:272 + lex.act = 83 + goto st177 + tr647: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:273 + lex.act = 84 + goto st177 + tr655: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:274 + lex.act = 85 + goto st177 + tr667: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:279 + lex.act = 90 + goto st177 + tr672: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:275 + lex.act = 86 + goto st177 + tr679: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:277 + lex.act = 88 + goto st177 + tr689: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:276 + lex.act = 87 + goto st177 + tr695: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:278 + lex.act = 89 + goto st177 + st177: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof177 + } + st_case_177: + // line internal/php8/scanner.go:6879 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 96: + goto tr12 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr12 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr12 + } + case lex.data[(lex.p)] >= 91: + goto tr12 + } + default: + goto tr12 + } + goto tr231 + st93: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof93 + } + st_case_93: + if lex.data[(lex.p)] == 96 { + goto tr12 + } + switch { + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto tr12 + } + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr12 + } + default: + goto tr12 + } + goto tr133 + tr133: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:203 + lex.act = 15 + goto st178 + st178: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof178 + } + st_case_178: + // line internal/php8/scanner.go:6937 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 96: + goto tr336 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr336 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr336 + } + case lex.data[(lex.p)] >= 91: + goto tr336 + } + default: + goto tr336 + } + goto tr133 + tr331: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st179 + st179: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof179 + } + st_case_179: + // line internal/php8/scanner.go:6974 + switch lex.data[(lex.p)] { + case 83: + goto tr337 + case 92: + goto st93 + case 96: + goto tr330 + case 115: + goto tr337 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr337: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st180 + st180: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof180 + } + st_case_180: + // line internal/php8/scanner.go:7015 + switch lex.data[(lex.p)] { + case 84: + goto tr338 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr338 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr338: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st181 + st181: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof181 + } + st_case_181: + // line internal/php8/scanner.go:7056 + switch lex.data[(lex.p)] { + case 82: + goto tr339 + case 92: + goto st93 + case 96: + goto tr330 + case 114: + goto tr339 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr339: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st182 + st182: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof182 + } + st_case_182: + // line internal/php8/scanner.go:7097 + switch lex.data[(lex.p)] { + case 65: + goto tr340 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr340 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr340: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st183 + st183: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof183 + } + st_case_183: + // line internal/php8/scanner.go:7138 + switch lex.data[(lex.p)] { + case 67: + goto tr341 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr341 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr341: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st184 + st184: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof184 + } + st_case_184: + // line internal/php8/scanner.go:7179 + switch lex.data[(lex.p)] { + case 84: + goto tr342 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr342 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr332: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st185 + st185: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof185 + } + st_case_185: + // line internal/php8/scanner.go:7220 + switch lex.data[(lex.p)] { + case 68: + goto tr343 + case 92: + goto st93 + case 96: + goto tr330 + case 100: + goto tr343 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr333: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st186 + st186: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof186 + } + st_case_186: + // line internal/php8/scanner.go:7261 + switch lex.data[(lex.p)] { + case 82: + goto tr344 + case 92: + goto st93 + case 96: + goto tr330 + case 114: + goto tr344 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr344: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st187 + st187: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof187 + } + st_case_187: + // line internal/php8/scanner.go:7302 + switch lex.data[(lex.p)] { + case 65: + goto tr345 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr345 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr345: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st188 + st188: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof188 + } + st_case_188: + // line internal/php8/scanner.go:7343 + switch lex.data[(lex.p)] { + case 89: + goto tr346 + case 92: + goto st93 + case 96: + goto tr330 + case 121: + goto tr346 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr225: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st189 + st189: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof189 + } + st_case_189: + // line internal/php8/scanner.go:7384 + switch lex.data[(lex.p)] { + case 34: + goto st7 + case 60: + goto st94 + case 82: + goto tr348 + case 92: + goto st93 + case 96: + goto tr330 + case 114: + goto tr348 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + st94: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof94 + } + st_case_94: + if lex.data[(lex.p)] == 60 { + goto st95 + } + goto tr134 + st95: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof95 + } + st_case_95: + if lex.data[(lex.p)] == 60 { + goto st83 + } + goto tr134 + tr348: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st190 + st190: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof190 + } + st_case_190: + // line internal/php8/scanner.go:7447 + switch lex.data[(lex.p)] { + case 69: + goto tr349 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr349 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr349: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st191 + st191: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof191 + } + st_case_191: + // line internal/php8/scanner.go:7488 + switch lex.data[(lex.p)] { + case 65: + goto tr350 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr350 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr350: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st192 + st192: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof192 + } + st_case_192: + // line internal/php8/scanner.go:7529 + switch lex.data[(lex.p)] { + case 75: + goto tr351 + case 92: + goto st93 + case 96: + goto tr330 + case 107: + goto tr351 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr226: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st193 + st193: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof193 + } + st_case_193: + // line internal/php8/scanner.go:7570 + switch lex.data[(lex.p)] { + case 65: + goto tr352 + case 70: + goto tr353 + case 76: + goto tr354 + case 79: + goto tr355 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr352 + case 102: + goto tr353 + case 108: + goto tr354 + case 111: + goto tr355 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr352: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st194 + st194: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof194 + } + st_case_194: + // line internal/php8/scanner.go:7623 + switch lex.data[(lex.p)] { + case 76: + goto tr356 + case 83: + goto tr357 + case 84: + goto tr358 + case 92: + goto st93 + case 96: + goto tr330 + case 108: + goto tr356 + case 115: + goto tr357 + case 116: + goto tr358 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr356: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st195 + st195: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof195 + } + st_case_195: + // line internal/php8/scanner.go:7672 + switch lex.data[(lex.p)] { + case 76: + goto tr359 + case 92: + goto st93 + case 96: + goto tr330 + case 108: + goto tr359 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr359: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st196 + st196: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof196 + } + st_case_196: + // line internal/php8/scanner.go:7713 + switch lex.data[(lex.p)] { + case 65: + goto tr360 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr360 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr360: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st197 + st197: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof197 + } + st_case_197: + // line internal/php8/scanner.go:7754 + switch lex.data[(lex.p)] { + case 66: + goto tr361 + case 92: + goto st93 + case 96: + goto tr330 + case 98: + goto tr361 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr361: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st198 + st198: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof198 + } + st_case_198: + // line internal/php8/scanner.go:7795 + switch lex.data[(lex.p)] { + case 76: + goto tr362 + case 92: + goto st93 + case 96: + goto tr330 + case 108: + goto tr362 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr362: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st199 + st199: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof199 + } + st_case_199: + // line internal/php8/scanner.go:7836 + switch lex.data[(lex.p)] { + case 69: + goto tr363 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr363 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr357: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st200 + st200: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof200 + } + st_case_200: + // line internal/php8/scanner.go:7877 + switch lex.data[(lex.p)] { + case 69: + goto tr364 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr364 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr358: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st201 + st201: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof201 + } + st_case_201: + // line internal/php8/scanner.go:7918 + switch lex.data[(lex.p)] { + case 67: + goto tr365 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr365 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr365: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st202 + st202: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof202 + } + st_case_202: + // line internal/php8/scanner.go:7959 + switch lex.data[(lex.p)] { + case 72: + goto tr366 + case 92: + goto st93 + case 96: + goto tr330 + case 104: + goto tr366 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr353: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st203 + st203: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof203 + } + st_case_203: + // line internal/php8/scanner.go:8000 + switch lex.data[(lex.p)] { + case 85: + goto tr367 + case 92: + goto st93 + case 96: + goto tr330 + case 117: + goto tr367 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr367: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st204 + st204: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof204 + } + st_case_204: + // line internal/php8/scanner.go:8041 + switch lex.data[(lex.p)] { + case 78: + goto tr368 + case 92: + goto st93 + case 96: + goto tr330 + case 110: + goto tr368 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr368: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st205 + st205: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof205 + } + st_case_205: + // line internal/php8/scanner.go:8082 + switch lex.data[(lex.p)] { + case 67: + goto tr369 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr369 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr369: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st206 + st206: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof206 + } + st_case_206: + // line internal/php8/scanner.go:8123 + switch lex.data[(lex.p)] { + case 84: + goto tr370 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr370 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr370: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st207 + st207: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof207 + } + st_case_207: + // line internal/php8/scanner.go:8164 + switch lex.data[(lex.p)] { + case 73: + goto tr371 + case 92: + goto st93 + case 96: + goto tr330 + case 105: + goto tr371 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr371: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st208 + st208: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof208 + } + st_case_208: + // line internal/php8/scanner.go:8205 + switch lex.data[(lex.p)] { + case 79: + goto tr372 + case 92: + goto st93 + case 96: + goto tr330 + case 111: + goto tr372 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr372: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st209 + st209: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof209 + } + st_case_209: + // line internal/php8/scanner.go:8246 + switch lex.data[(lex.p)] { + case 78: + goto tr373 + case 92: + goto st93 + case 96: + goto tr330 + case 110: + goto tr373 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr354: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st210 + st210: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof210 + } + st_case_210: + // line internal/php8/scanner.go:8287 + switch lex.data[(lex.p)] { + case 65: + goto tr374 + case 79: + goto tr375 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr374 + case 111: + goto tr375 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr374: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st211 + st211: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof211 + } + st_case_211: + // line internal/php8/scanner.go:8332 + switch lex.data[(lex.p)] { + case 83: + goto tr376 + case 92: + goto st93 + case 96: + goto tr330 + case 115: + goto tr376 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr376: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st212 + st212: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof212 + } + st_case_212: + // line internal/php8/scanner.go:8373 + switch lex.data[(lex.p)] { + case 83: + goto tr377 + case 92: + goto st93 + case 96: + goto tr330 + case 115: + goto tr377 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr375: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st213 + st213: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof213 + } + st_case_213: + // line internal/php8/scanner.go:8414 + switch lex.data[(lex.p)] { + case 78: + goto tr378 + case 92: + goto st93 + case 96: + goto tr330 + case 110: + goto tr378 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr378: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st214 + st214: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof214 + } + st_case_214: + // line internal/php8/scanner.go:8455 + switch lex.data[(lex.p)] { + case 69: + goto tr379 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr379 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr355: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st215 + st215: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof215 + } + st_case_215: + // line internal/php8/scanner.go:8496 + switch lex.data[(lex.p)] { + case 78: + goto tr380 + case 92: + goto st93 + case 96: + goto tr330 + case 110: + goto tr380 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr380: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st216 + st216: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof216 + } + st_case_216: + // line internal/php8/scanner.go:8537 + switch lex.data[(lex.p)] { + case 83: + goto tr381 + case 84: + goto tr382 + case 92: + goto st93 + case 96: + goto tr330 + case 115: + goto tr381 + case 116: + goto tr382 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr381: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st217 + st217: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof217 + } + st_case_217: + // line internal/php8/scanner.go:8582 + switch lex.data[(lex.p)] { + case 84: + goto tr383 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr383 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr382: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st218 + st218: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof218 + } + st_case_218: + // line internal/php8/scanner.go:8623 + switch lex.data[(lex.p)] { + case 73: + goto tr384 + case 92: + goto st93 + case 96: + goto tr330 + case 105: + goto tr384 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr384: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st219 + st219: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof219 + } + st_case_219: + // line internal/php8/scanner.go:8664 + switch lex.data[(lex.p)] { + case 78: + goto tr385 + case 92: + goto st93 + case 96: + goto tr330 + case 110: + goto tr385 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr385: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st220 + st220: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof220 + } + st_case_220: + // line internal/php8/scanner.go:8705 + switch lex.data[(lex.p)] { + case 85: + goto tr386 + case 92: + goto st93 + case 96: + goto tr330 + case 117: + goto tr386 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr386: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st221 + st221: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof221 + } + st_case_221: + // line internal/php8/scanner.go:8746 + switch lex.data[(lex.p)] { + case 69: + goto tr387 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr387 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr227: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st222 + st222: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof222 + } + st_case_222: + // line internal/php8/scanner.go:8787 + switch lex.data[(lex.p)] { + case 69: + goto tr388 + case 73: + goto tr389 + case 79: + goto tr390 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr388 + case 105: + goto tr389 + case 111: + goto tr390 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr388: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st223 + st223: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof223 + } + st_case_223: + // line internal/php8/scanner.go:8836 + switch lex.data[(lex.p)] { + case 67: + goto tr391 + case 70: + goto tr392 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr391 + case 102: + goto tr392 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr391: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st224 + st224: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof224 + } + st_case_224: + // line internal/php8/scanner.go:8881 + switch lex.data[(lex.p)] { + case 76: + goto tr393 + case 92: + goto st93 + case 96: + goto tr330 + case 108: + goto tr393 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr393: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st225 + st225: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof225 + } + st_case_225: + // line internal/php8/scanner.go:8922 + switch lex.data[(lex.p)] { + case 65: + goto tr394 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr394 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr394: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st226 + st226: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof226 + } + st_case_226: + // line internal/php8/scanner.go:8963 + switch lex.data[(lex.p)] { + case 82: + goto tr395 + case 92: + goto st93 + case 96: + goto tr330 + case 114: + goto tr395 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr395: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st227 + st227: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof227 + } + st_case_227: + // line internal/php8/scanner.go:9004 + switch lex.data[(lex.p)] { + case 69: + goto tr396 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr396 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr392: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st228 + st228: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof228 + } + st_case_228: + // line internal/php8/scanner.go:9045 + switch lex.data[(lex.p)] { + case 65: + goto tr397 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr397 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr397: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st229 + st229: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof229 + } + st_case_229: + // line internal/php8/scanner.go:9086 + switch lex.data[(lex.p)] { + case 85: + goto tr398 + case 92: + goto st93 + case 96: + goto tr330 + case 117: + goto tr398 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr398: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st230 + st230: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof230 + } + st_case_230: + // line internal/php8/scanner.go:9127 + switch lex.data[(lex.p)] { + case 76: + goto tr399 + case 92: + goto st93 + case 96: + goto tr330 + case 108: + goto tr399 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr399: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st231 + st231: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof231 + } + st_case_231: + // line internal/php8/scanner.go:9168 + switch lex.data[(lex.p)] { + case 84: + goto tr400 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr400 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr389: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st232 + st232: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof232 + } + st_case_232: + // line internal/php8/scanner.go:9209 + switch lex.data[(lex.p)] { + case 69: + goto tr401 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr401 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr228: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st233 + st233: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof233 + } + st_case_233: + // line internal/php8/scanner.go:9250 + switch lex.data[(lex.p)] { + case 67: + goto tr402 + case 76: + goto tr403 + case 77: + goto tr404 + case 78: + goto tr405 + case 86: + goto tr406 + case 88: + goto tr407 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr402 + case 108: + goto tr403 + case 109: + goto tr404 + case 110: + goto tr405 + case 118: + goto tr406 + case 120: + goto tr407 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr402: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st234 + st234: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof234 + } + st_case_234: + // line internal/php8/scanner.go:9311 + switch lex.data[(lex.p)] { + case 72: + goto tr408 + case 92: + goto st93 + case 96: + goto tr330 + case 104: + goto tr408 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr408: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st235 + st235: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof235 + } + st_case_235: + // line internal/php8/scanner.go:9352 + switch lex.data[(lex.p)] { + case 79: + goto tr409 + case 92: + goto st93 + case 96: + goto tr330 + case 111: + goto tr409 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr403: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st236 + st236: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof236 + } + st_case_236: + // line internal/php8/scanner.go:9393 + switch lex.data[(lex.p)] { + case 83: + goto tr410 + case 92: + goto st93 + case 96: + goto tr330 + case 115: + goto tr410 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr410: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st237 + st237: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof237 + } + st_case_237: + // line internal/php8/scanner.go:9434 + switch lex.data[(lex.p)] { + case 69: + goto tr411 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr411 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr411: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:222 + lex.act = 33 + goto st238 + st238: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof238 + } + st_case_238: + // line internal/php8/scanner.go:9475 + switch lex.data[(lex.p)] { + case 73: + goto tr413 + case 92: + goto st93 + case 96: + goto tr412 + case 105: + goto tr413 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr412 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr412 + } + case lex.data[(lex.p)] >= 91: + goto tr412 + } + default: + goto tr412 + } + goto tr231 + tr413: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st239 + st239: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof239 + } + st_case_239: + // line internal/php8/scanner.go:9516 + switch lex.data[(lex.p)] { + case 70: + goto tr414 + case 92: + goto st93 + case 96: + goto tr330 + case 102: + goto tr414 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr404: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st240 + st240: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof240 + } + st_case_240: + // line internal/php8/scanner.go:9557 + switch lex.data[(lex.p)] { + case 80: + goto tr415 + case 92: + goto st93 + case 96: + goto tr330 + case 112: + goto tr415 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr415: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st241 + st241: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof241 + } + st_case_241: + // line internal/php8/scanner.go:9598 + switch lex.data[(lex.p)] { + case 84: + goto tr416 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr416 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr416: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st242 + st242: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof242 + } + st_case_242: + // line internal/php8/scanner.go:9639 + switch lex.data[(lex.p)] { + case 89: + goto tr417 + case 92: + goto st93 + case 96: + goto tr330 + case 121: + goto tr417 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr405: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st243 + st243: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof243 + } + st_case_243: + // line internal/php8/scanner.go:9680 + switch lex.data[(lex.p)] { + case 68: + goto tr418 + case 92: + goto st93 + case 96: + goto tr330 + case 100: + goto tr418 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr418: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st244 + st244: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof244 + } + st_case_244: + // line internal/php8/scanner.go:9721 + switch lex.data[(lex.p)] { + case 68: + goto tr419 + case 70: + goto tr420 + case 73: + goto tr421 + case 83: + goto tr422 + case 87: + goto tr423 + case 92: + goto st93 + case 96: + goto tr330 + case 100: + goto tr419 + case 102: + goto tr420 + case 105: + goto tr421 + case 115: + goto tr422 + case 119: + goto tr423 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr419: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st245 + st245: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof245 + } + st_case_245: + // line internal/php8/scanner.go:9778 + switch lex.data[(lex.p)] { + case 69: + goto tr424 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr424 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr424: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st246 + st246: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof246 + } + st_case_246: + // line internal/php8/scanner.go:9819 + switch lex.data[(lex.p)] { + case 67: + goto tr425 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr425 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr425: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st247 + st247: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof247 + } + st_case_247: + // line internal/php8/scanner.go:9860 + switch lex.data[(lex.p)] { + case 76: + goto tr426 + case 92: + goto st93 + case 96: + goto tr330 + case 108: + goto tr426 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr426: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st248 + st248: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof248 + } + st_case_248: + // line internal/php8/scanner.go:9901 + switch lex.data[(lex.p)] { + case 65: + goto tr427 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr427 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr427: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st249 + st249: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof249 + } + st_case_249: + // line internal/php8/scanner.go:9942 + switch lex.data[(lex.p)] { + case 82: + goto tr428 + case 92: + goto st93 + case 96: + goto tr330 + case 114: + goto tr428 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr428: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st250 + st250: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof250 + } + st_case_250: + // line internal/php8/scanner.go:9983 + switch lex.data[(lex.p)] { + case 69: + goto tr429 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr429 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr420: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st251 + st251: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof251 + } + st_case_251: + // line internal/php8/scanner.go:10024 + switch lex.data[(lex.p)] { + case 79: + goto tr430 + case 92: + goto st93 + case 96: + goto tr330 + case 111: + goto tr430 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr430: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st252 + st252: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof252 + } + st_case_252: + // line internal/php8/scanner.go:10065 + switch lex.data[(lex.p)] { + case 82: + goto tr431 + case 92: + goto st93 + case 96: + goto tr330 + case 114: + goto tr431 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr431: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:226 + lex.act = 37 + goto st253 + st253: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof253 + } + st_case_253: + // line internal/php8/scanner.go:10106 + switch lex.data[(lex.p)] { + case 69: + goto tr433 + case 92: + goto st93 + case 96: + goto tr432 + case 101: + goto tr433 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr432 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr432 + } + case lex.data[(lex.p)] >= 91: + goto tr432 + } + default: + goto tr432 + } + goto tr231 + tr433: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st254 + st254: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof254 + } + st_case_254: + // line internal/php8/scanner.go:10147 + switch lex.data[(lex.p)] { + case 65: + goto tr434 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr434 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr434: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st255 + st255: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof255 + } + st_case_255: + // line internal/php8/scanner.go:10188 + switch lex.data[(lex.p)] { + case 67: + goto tr435 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr435 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr435: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st256 + st256: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof256 + } + st_case_256: + // line internal/php8/scanner.go:10229 + switch lex.data[(lex.p)] { + case 72: + goto tr436 + case 92: + goto st93 + case 96: + goto tr330 + case 104: + goto tr436 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr421: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st257 + st257: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof257 + } + st_case_257: + // line internal/php8/scanner.go:10270 + switch lex.data[(lex.p)] { + case 70: + goto tr437 + case 92: + goto st93 + case 96: + goto tr330 + case 102: + goto tr437 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr422: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st258 + st258: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof258 + } + st_case_258: + // line internal/php8/scanner.go:10311 + switch lex.data[(lex.p)] { + case 87: + goto tr438 + case 92: + goto st93 + case 96: + goto tr330 + case 119: + goto tr438 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr438: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st259 + st259: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof259 + } + st_case_259: + // line internal/php8/scanner.go:10352 + switch lex.data[(lex.p)] { + case 73: + goto tr439 + case 92: + goto st93 + case 96: + goto tr330 + case 105: + goto tr439 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr439: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st260 + st260: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof260 + } + st_case_260: + // line internal/php8/scanner.go:10393 + switch lex.data[(lex.p)] { + case 84: + goto tr440 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr440 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr440: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st261 + st261: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof261 + } + st_case_261: + // line internal/php8/scanner.go:10434 + switch lex.data[(lex.p)] { + case 67: + goto tr441 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr441 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr441: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st262 + st262: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof262 + } + st_case_262: + // line internal/php8/scanner.go:10475 + switch lex.data[(lex.p)] { + case 72: + goto tr442 + case 92: + goto st93 + case 96: + goto tr330 + case 104: + goto tr442 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr423: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st263 + st263: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof263 + } + st_case_263: + // line internal/php8/scanner.go:10516 + switch lex.data[(lex.p)] { + case 72: + goto tr443 + case 92: + goto st93 + case 96: + goto tr330 + case 104: + goto tr443 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr443: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st264 + st264: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof264 + } + st_case_264: + // line internal/php8/scanner.go:10557 + switch lex.data[(lex.p)] { + case 73: + goto tr444 + case 92: + goto st93 + case 96: + goto tr330 + case 105: + goto tr444 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr444: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st265 + st265: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof265 + } + st_case_265: + // line internal/php8/scanner.go:10598 + switch lex.data[(lex.p)] { + case 76: + goto tr445 + case 92: + goto st93 + case 96: + goto tr330 + case 108: + goto tr445 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr445: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st266 + st266: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof266 + } + st_case_266: + // line internal/php8/scanner.go:10639 + switch lex.data[(lex.p)] { + case 69: + goto tr446 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr446 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr406: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st267 + st267: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof267 + } + st_case_267: + // line internal/php8/scanner.go:10680 + switch lex.data[(lex.p)] { + case 65: + goto tr447 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr447 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr447: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st268 + st268: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof268 + } + st_case_268: + // line internal/php8/scanner.go:10721 + switch lex.data[(lex.p)] { + case 76: + goto tr448 + case 92: + goto st93 + case 96: + goto tr330 + case 108: + goto tr448 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr407: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st269 + st269: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof269 + } + st_case_269: + // line internal/php8/scanner.go:10762 + switch lex.data[(lex.p)] { + case 73: + goto tr449 + case 84: + goto tr450 + case 92: + goto st93 + case 96: + goto tr330 + case 105: + goto tr449 + case 116: + goto tr450 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr449: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st270 + st270: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof270 + } + st_case_270: + // line internal/php8/scanner.go:10807 + switch lex.data[(lex.p)] { + case 84: + goto tr401 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr401 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr450: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st271 + st271: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof271 + } + st_case_271: + // line internal/php8/scanner.go:10848 + switch lex.data[(lex.p)] { + case 69: + goto tr451 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr451 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr451: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st272 + st272: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof272 + } + st_case_272: + // line internal/php8/scanner.go:10889 + switch lex.data[(lex.p)] { + case 78: + goto tr452 + case 92: + goto st93 + case 96: + goto tr330 + case 110: + goto tr452 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr452: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st273 + st273: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof273 + } + st_case_273: + // line internal/php8/scanner.go:10930 + switch lex.data[(lex.p)] { + case 68: + goto tr453 + case 92: + goto st93 + case 96: + goto tr330 + case 100: + goto tr453 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr453: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st274 + st274: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof274 + } + st_case_274: + // line internal/php8/scanner.go:10971 + switch lex.data[(lex.p)] { + case 83: + goto tr454 + case 92: + goto st93 + case 96: + goto tr330 + case 115: + goto tr454 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr229: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st275 + st275: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof275 + } + st_case_275: + // line internal/php8/scanner.go:11012 + switch lex.data[(lex.p)] { + case 73: + goto tr455 + case 78: + goto tr456 + case 79: + goto tr457 + case 85: + goto tr367 + case 92: + goto st93 + case 96: + goto tr330 + case 105: + goto tr455 + case 110: + goto tr456 + case 111: + goto tr457 + case 117: + goto tr367 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr455: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st276 + st276: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof276 + } + st_case_276: + // line internal/php8/scanner.go:11065 + switch lex.data[(lex.p)] { + case 78: + goto tr458 + case 92: + goto st93 + case 96: + goto tr330 + case 110: + goto tr458 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr458: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st277 + st277: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof277 + } + st_case_277: + // line internal/php8/scanner.go:11106 + switch lex.data[(lex.p)] { + case 65: + goto tr459 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr459 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr459: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st278 + st278: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof278 + } + st_case_278: + // line internal/php8/scanner.go:11147 + switch lex.data[(lex.p)] { + case 76: + goto tr460 + case 92: + goto st93 + case 96: + goto tr330 + case 108: + goto tr460 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr460: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:234 + lex.act = 45 + goto st279 + st279: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof279 + } + st_case_279: + // line internal/php8/scanner.go:11188 + switch lex.data[(lex.p)] { + case 76: + goto tr462 + case 92: + goto st93 + case 96: + goto tr461 + case 108: + goto tr462 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr461 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr461 + } + case lex.data[(lex.p)] >= 91: + goto tr461 + } + default: + goto tr461 + } + goto tr231 + tr462: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st280 + st280: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof280 + } + st_case_280: + // line internal/php8/scanner.go:11229 + switch lex.data[(lex.p)] { + case 89: + goto tr463 + case 92: + goto st93 + case 96: + goto tr330 + case 121: + goto tr463 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr457: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st281 + st281: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof281 + } + st_case_281: + // line internal/php8/scanner.go:11270 + switch lex.data[(lex.p)] { + case 82: + goto tr464 + case 92: + goto st93 + case 96: + goto tr330 + case 114: + goto tr464 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr464: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:236 + lex.act = 47 + goto st282 + st282: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof282 + } + st_case_282: + // line internal/php8/scanner.go:11311 + switch lex.data[(lex.p)] { + case 69: + goto tr466 + case 92: + goto st93 + case 96: + goto tr465 + case 101: + goto tr466 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr465 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr465 + } + case lex.data[(lex.p)] >= 91: + goto tr465 + } + default: + goto tr465 + } + goto tr231 + tr466: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st283 + st283: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof283 + } + st_case_283: + // line internal/php8/scanner.go:11352 + switch lex.data[(lex.p)] { + case 65: + goto tr467 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr467 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr467: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st284 + st284: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof284 + } + st_case_284: + // line internal/php8/scanner.go:11393 + switch lex.data[(lex.p)] { + case 67: + goto tr468 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr468 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr468: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st285 + st285: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof285 + } + st_case_285: + // line internal/php8/scanner.go:11434 + switch lex.data[(lex.p)] { + case 72: + goto tr469 + case 92: + goto st93 + case 96: + goto tr330 + case 104: + goto tr469 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr230: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st286 + st286: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof286 + } + st_case_286: + // line internal/php8/scanner.go:11475 + switch lex.data[(lex.p)] { + case 76: + goto tr470 + case 79: + goto tr471 + case 92: + goto st93 + case 96: + goto tr330 + case 108: + goto tr470 + case 111: + goto tr471 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr470: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st287 + st287: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof287 + } + st_case_287: + // line internal/php8/scanner.go:11520 + switch lex.data[(lex.p)] { + case 79: + goto tr472 + case 92: + goto st93 + case 96: + goto tr330 + case 111: + goto tr472 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr472: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st288 + st288: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof288 + } + st_case_288: + // line internal/php8/scanner.go:11561 + switch lex.data[(lex.p)] { + case 66: + goto tr473 + case 92: + goto st93 + case 96: + goto tr330 + case 98: + goto tr473 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr473: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st289 + st289: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof289 + } + st_case_289: + // line internal/php8/scanner.go:11602 + switch lex.data[(lex.p)] { + case 65: + goto tr474 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr474 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr474: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st290 + st290: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof290 + } + st_case_290: + // line internal/php8/scanner.go:11643 + switch lex.data[(lex.p)] { + case 76: + goto tr475 + case 92: + goto st93 + case 96: + goto tr330 + case 108: + goto tr475 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr471: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st291 + st291: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof291 + } + st_case_291: + // line internal/php8/scanner.go:11684 + switch lex.data[(lex.p)] { + case 84: + goto tr476 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr476 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr476: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st292 + st292: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof292 + } + st_case_292: + // line internal/php8/scanner.go:11725 + switch lex.data[(lex.p)] { + case 79: + goto tr477 + case 92: + goto st93 + case 96: + goto tr330 + case 111: + goto tr477 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr232: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st293 + st293: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof293 + } + st_case_293: + // line internal/php8/scanner.go:11766 + switch lex.data[(lex.p)] { + case 70: + goto tr478 + case 77: + goto tr479 + case 78: + goto tr480 + case 83: + goto tr481 + case 92: + goto st93 + case 96: + goto tr330 + case 102: + goto tr478 + case 109: + goto tr479 + case 110: + goto tr480 + case 115: + goto tr481 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr479: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st294 + st294: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof294 + } + st_case_294: + // line internal/php8/scanner.go:11819 + switch lex.data[(lex.p)] { + case 80: + goto tr482 + case 92: + goto st93 + case 96: + goto tr330 + case 112: + goto tr482 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr482: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st295 + st295: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof295 + } + st_case_295: + // line internal/php8/scanner.go:11860 + switch lex.data[(lex.p)] { + case 76: + goto tr483 + case 92: + goto st93 + case 96: + goto tr330 + case 108: + goto tr483 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr483: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st296 + st296: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof296 + } + st_case_296: + // line internal/php8/scanner.go:11901 + switch lex.data[(lex.p)] { + case 69: + goto tr484 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr484 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr484: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st297 + st297: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof297 + } + st_case_297: + // line internal/php8/scanner.go:11942 + switch lex.data[(lex.p)] { + case 77: + goto tr485 + case 92: + goto st93 + case 96: + goto tr330 + case 109: + goto tr485 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr485: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st298 + st298: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof298 + } + st_case_298: + // line internal/php8/scanner.go:11983 + switch lex.data[(lex.p)] { + case 69: + goto tr486 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr486 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr486: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st299 + st299: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof299 + } + st_case_299: + // line internal/php8/scanner.go:12024 + switch lex.data[(lex.p)] { + case 78: + goto tr487 + case 92: + goto st93 + case 96: + goto tr330 + case 110: + goto tr487 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr487: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st300 + st300: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof300 + } + st_case_300: + // line internal/php8/scanner.go:12065 + switch lex.data[(lex.p)] { + case 84: + goto tr488 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr488 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr488: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st301 + st301: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof301 + } + st_case_301: + // line internal/php8/scanner.go:12106 + switch lex.data[(lex.p)] { + case 83: + goto tr489 + case 92: + goto st93 + case 96: + goto tr330 + case 115: + goto tr489 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr480: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st302 + st302: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof302 + } + st_case_302: + // line internal/php8/scanner.go:12147 + switch lex.data[(lex.p)] { + case 67: + goto tr490 + case 83: + goto tr491 + case 84: + goto tr492 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr490 + case 115: + goto tr491 + case 116: + goto tr492 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr490: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st303 + st303: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof303 + } + st_case_303: + // line internal/php8/scanner.go:12196 + switch lex.data[(lex.p)] { + case 76: + goto tr493 + case 92: + goto st93 + case 96: + goto tr330 + case 108: + goto tr493 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr493: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st304 + st304: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof304 + } + st_case_304: + // line internal/php8/scanner.go:12237 + switch lex.data[(lex.p)] { + case 85: + goto tr494 + case 92: + goto st93 + case 96: + goto tr330 + case 117: + goto tr494 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr494: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st305 + st305: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof305 + } + st_case_305: + // line internal/php8/scanner.go:12278 + switch lex.data[(lex.p)] { + case 68: + goto tr495 + case 92: + goto st93 + case 96: + goto tr330 + case 100: + goto tr495 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr495: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st306 + st306: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof306 + } + st_case_306: + // line internal/php8/scanner.go:12319 + switch lex.data[(lex.p)] { + case 69: + goto tr496 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr496 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr496: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:267 + lex.act = 78 + goto st307 + st307: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof307 + } + st_case_307: + // line internal/php8/scanner.go:12360 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 95: + goto tr498 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr497 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr497 + } + case lex.data[(lex.p)] >= 91: + goto tr497 + } + default: + goto tr497 + } + goto tr231 + tr498: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st308 + st308: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof308 + } + st_case_308: + // line internal/php8/scanner.go:12397 + switch lex.data[(lex.p)] { + case 79: + goto tr499 + case 92: + goto st93 + case 96: + goto tr330 + case 111: + goto tr499 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr499: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st309 + st309: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof309 + } + st_case_309: + // line internal/php8/scanner.go:12438 + switch lex.data[(lex.p)] { + case 78: + goto tr500 + case 92: + goto st93 + case 96: + goto tr330 + case 110: + goto tr500 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr500: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st310 + st310: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof310 + } + st_case_310: + // line internal/php8/scanner.go:12479 + switch lex.data[(lex.p)] { + case 67: + goto tr501 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr501 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr501: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st311 + st311: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof311 + } + st_case_311: + // line internal/php8/scanner.go:12520 + switch lex.data[(lex.p)] { + case 69: + goto tr502 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr502 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr491: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st312 + st312: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof312 + } + st_case_312: + // line internal/php8/scanner.go:12561 + switch lex.data[(lex.p)] { + case 84: + goto tr503 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr503 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr503: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st313 + st313: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof313 + } + st_case_313: + // line internal/php8/scanner.go:12602 + switch lex.data[(lex.p)] { + case 65: + goto tr504 + case 69: + goto tr505 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr504 + case 101: + goto tr505 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr504: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st314 + st314: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof314 + } + st_case_314: + // line internal/php8/scanner.go:12647 + switch lex.data[(lex.p)] { + case 78: + goto tr506 + case 92: + goto st93 + case 96: + goto tr330 + case 110: + goto tr506 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr506: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st315 + st315: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof315 + } + st_case_315: + // line internal/php8/scanner.go:12688 + switch lex.data[(lex.p)] { + case 67: + goto tr507 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr507 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr507: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st316 + st316: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof316 + } + st_case_316: + // line internal/php8/scanner.go:12729 + switch lex.data[(lex.p)] { + case 69: + goto tr508 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr508 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr508: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st317 + st317: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof317 + } + st_case_317: + // line internal/php8/scanner.go:12770 + switch lex.data[(lex.p)] { + case 79: + goto tr509 + case 92: + goto st93 + case 96: + goto tr330 + case 111: + goto tr509 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr509: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st318 + st318: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof318 + } + st_case_318: + // line internal/php8/scanner.go:12811 + switch lex.data[(lex.p)] { + case 70: + goto tr510 + case 92: + goto st93 + case 96: + goto tr330 + case 102: + goto tr510 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr505: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st319 + st319: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof319 + } + st_case_319: + // line internal/php8/scanner.go:12852 + switch lex.data[(lex.p)] { + case 65: + goto tr511 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr511 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr511: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st320 + st320: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof320 + } + st_case_320: + // line internal/php8/scanner.go:12893 + switch lex.data[(lex.p)] { + case 68: + goto tr512 + case 92: + goto st93 + case 96: + goto tr330 + case 100: + goto tr512 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr512: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st321 + st321: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof321 + } + st_case_321: + // line internal/php8/scanner.go:12934 + switch lex.data[(lex.p)] { + case 79: + goto tr513 + case 92: + goto st93 + case 96: + goto tr330 + case 111: + goto tr513 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr513: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st322 + st322: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof322 + } + st_case_322: + // line internal/php8/scanner.go:12975 + switch lex.data[(lex.p)] { + case 70: + goto tr514 + case 92: + goto st93 + case 96: + goto tr330 + case 102: + goto tr514 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr492: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st323 + st323: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof323 + } + st_case_323: + // line internal/php8/scanner.go:13016 + switch lex.data[(lex.p)] { + case 69: + goto tr515 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr515 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr515: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st324 + st324: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof324 + } + st_case_324: + // line internal/php8/scanner.go:13057 + switch lex.data[(lex.p)] { + case 82: + goto tr516 + case 92: + goto st93 + case 96: + goto tr330 + case 114: + goto tr516 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr516: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st325 + st325: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof325 + } + st_case_325: + // line internal/php8/scanner.go:13098 + switch lex.data[(lex.p)] { + case 70: + goto tr517 + case 92: + goto st93 + case 96: + goto tr330 + case 102: + goto tr517 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr517: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st326 + st326: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof326 + } + st_case_326: + // line internal/php8/scanner.go:13139 + switch lex.data[(lex.p)] { + case 65: + goto tr518 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr518 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr518: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st327 + st327: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof327 + } + st_case_327: + // line internal/php8/scanner.go:13180 + switch lex.data[(lex.p)] { + case 67: + goto tr519 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr519 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr519: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st328 + st328: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof328 + } + st_case_328: + // line internal/php8/scanner.go:13221 + switch lex.data[(lex.p)] { + case 69: + goto tr520 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr520 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr481: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st329 + st329: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof329 + } + st_case_329: + // line internal/php8/scanner.go:13262 + switch lex.data[(lex.p)] { + case 83: + goto tr521 + case 92: + goto st93 + case 96: + goto tr330 + case 115: + goto tr521 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr521: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st330 + st330: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof330 + } + st_case_330: + // line internal/php8/scanner.go:13303 + switch lex.data[(lex.p)] { + case 69: + goto tr522 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr522 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr522: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st331 + st331: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof331 + } + st_case_331: + // line internal/php8/scanner.go:13344 + switch lex.data[(lex.p)] { + case 84: + goto tr523 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr523 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr233: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st332 + st332: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof332 + } + st_case_332: + // line internal/php8/scanner.go:13385 + switch lex.data[(lex.p)] { + case 73: + goto tr524 + case 92: + goto st93 + case 96: + goto tr330 + case 105: + goto tr524 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr524: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st333 + st333: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof333 + } + st_case_333: + // line internal/php8/scanner.go:13426 + switch lex.data[(lex.p)] { + case 83: + goto tr525 + case 92: + goto st93 + case 96: + goto tr330 + case 115: + goto tr525 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr525: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st334 + st334: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof334 + } + st_case_334: + // line internal/php8/scanner.go:13467 + switch lex.data[(lex.p)] { + case 84: + goto tr526 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr526 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr234: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st335 + st335: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof335 + } + st_case_335: + // line internal/php8/scanner.go:13508 + switch lex.data[(lex.p)] { + case 65: + goto tr527 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr527 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr527: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st336 + st336: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof336 + } + st_case_336: + // line internal/php8/scanner.go:13549 + switch lex.data[(lex.p)] { + case 84: + goto tr528 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr528 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr528: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st337 + st337: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof337 + } + st_case_337: + // line internal/php8/scanner.go:13590 + switch lex.data[(lex.p)] { + case 67: + goto tr529 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr529 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr529: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st338 + st338: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof338 + } + st_case_338: + // line internal/php8/scanner.go:13631 + switch lex.data[(lex.p)] { + case 72: + goto tr530 + case 92: + goto st93 + case 96: + goto tr330 + case 104: + goto tr530 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr235: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st339 + st339: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof339 + } + st_case_339: + // line internal/php8/scanner.go:13672 + switch lex.data[(lex.p)] { + case 65: + goto tr531 + case 69: + goto tr532 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr531 + case 101: + goto tr532 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr531: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st340 + st340: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof340 + } + st_case_340: + // line internal/php8/scanner.go:13717 + switch lex.data[(lex.p)] { + case 77: + goto tr533 + case 92: + goto st93 + case 96: + goto tr330 + case 109: + goto tr533 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr533: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st341 + st341: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof341 + } + st_case_341: + // line internal/php8/scanner.go:13758 + switch lex.data[(lex.p)] { + case 69: + goto tr534 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr534 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr534: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st342 + st342: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof342 + } + st_case_342: + // line internal/php8/scanner.go:13799 + switch lex.data[(lex.p)] { + case 83: + goto tr535 + case 92: + goto st93 + case 96: + goto tr330 + case 115: + goto tr535 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr535: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st343 + st343: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof343 + } + st_case_343: + // line internal/php8/scanner.go:13840 + switch lex.data[(lex.p)] { + case 80: + goto tr536 + case 92: + goto st93 + case 96: + goto tr330 + case 112: + goto tr536 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr536: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st344 + st344: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof344 + } + st_case_344: + // line internal/php8/scanner.go:13881 + switch lex.data[(lex.p)] { + case 65: + goto tr537 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr537 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr537: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st345 + st345: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof345 + } + st_case_345: + // line internal/php8/scanner.go:13922 + switch lex.data[(lex.p)] { + case 67: + goto tr538 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr538 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr538: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st346 + st346: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof346 + } + st_case_346: + // line internal/php8/scanner.go:13963 + switch lex.data[(lex.p)] { + case 69: + goto tr539 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr539 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr539: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:249 + lex.act = 60 + goto st347 + st347: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof347 + } + st_case_347: + // line internal/php8/scanner.go:14004 + switch lex.data[(lex.p)] { + case 92: + goto st96 + case 96: + goto tr540 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr540 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr540 + } + case lex.data[(lex.p)] >= 91: + goto tr540 + } + default: + goto tr540 + } + goto tr231 + st96: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof96 + } + st_case_96: + if lex.data[(lex.p)] == 96 { + goto tr12 + } + switch { + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto tr12 + } + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr12 + } + default: + goto tr12 + } + goto tr136 + tr136: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:202 + lex.act = 14 + goto st348 + st348: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof348 + } + st_case_348: + // line internal/php8/scanner.go:14062 + switch lex.data[(lex.p)] { + case 92: + goto st96 + case 96: + goto tr542 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr542 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr542 + } + case lex.data[(lex.p)] >= 91: + goto tr542 + } + default: + goto tr542 + } + goto tr136 + tr532: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st349 + st349: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof349 + } + st_case_349: + // line internal/php8/scanner.go:14099 + switch lex.data[(lex.p)] { + case 87: + goto tr543 + case 92: + goto st93 + case 96: + goto tr330 + case 119: + goto tr543 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr236: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st350 + st350: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof350 + } + st_case_350: + // line internal/php8/scanner.go:14140 + switch lex.data[(lex.p)] { + case 82: + goto tr544 + case 92: + goto st93 + case 96: + goto tr330 + case 114: + goto tr544 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr237: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st351 + st351: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof351 + } + st_case_351: + // line internal/php8/scanner.go:14181 + switch lex.data[(lex.p)] { + case 82: + goto tr545 + case 85: + goto tr546 + case 92: + goto st93 + case 96: + goto tr330 + case 114: + goto tr545 + case 117: + goto tr546 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr545: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st352 + st352: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof352 + } + st_case_352: + // line internal/php8/scanner.go:14226 + switch lex.data[(lex.p)] { + case 73: + goto tr547 + case 79: + goto tr548 + case 92: + goto st93 + case 96: + goto tr330 + case 105: + goto tr547 + case 111: + goto tr548 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr547: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st353 + st353: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof353 + } + st_case_353: + // line internal/php8/scanner.go:14271 + switch lex.data[(lex.p)] { + case 78: + goto tr549 + case 86: + goto tr550 + case 92: + goto st93 + case 96: + goto tr330 + case 110: + goto tr549 + case 118: + goto tr550 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr549: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st354 + st354: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof354 + } + st_case_354: + // line internal/php8/scanner.go:14316 + switch lex.data[(lex.p)] { + case 84: + goto tr551 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr551 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr550: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st355 + st355: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof355 + } + st_case_355: + // line internal/php8/scanner.go:14357 + switch lex.data[(lex.p)] { + case 65: + goto tr552 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr552 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr552: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st356 + st356: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof356 + } + st_case_356: + // line internal/php8/scanner.go:14398 + switch lex.data[(lex.p)] { + case 84: + goto tr553 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr553 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr553: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st357 + st357: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof357 + } + st_case_357: + // line internal/php8/scanner.go:14439 + switch lex.data[(lex.p)] { + case 69: + goto tr554 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr554 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr548: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st358 + st358: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof358 + } + st_case_358: + // line internal/php8/scanner.go:14480 + switch lex.data[(lex.p)] { + case 84: + goto tr555 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr555 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr555: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st359 + st359: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof359 + } + st_case_359: + // line internal/php8/scanner.go:14521 + switch lex.data[(lex.p)] { + case 69: + goto tr556 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr556 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr556: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st360 + st360: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof360 + } + st_case_360: + // line internal/php8/scanner.go:14562 + switch lex.data[(lex.p)] { + case 67: + goto tr557 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr557 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr557: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st361 + st361: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof361 + } + st_case_361: + // line internal/php8/scanner.go:14603 + switch lex.data[(lex.p)] { + case 84: + goto tr558 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr558 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr558: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st362 + st362: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof362 + } + st_case_362: + // line internal/php8/scanner.go:14644 + switch lex.data[(lex.p)] { + case 69: + goto tr559 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr559 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr559: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st363 + st363: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof363 + } + st_case_363: + // line internal/php8/scanner.go:14685 + switch lex.data[(lex.p)] { + case 68: + goto tr560 + case 92: + goto st93 + case 96: + goto tr330 + case 100: + goto tr560 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr546: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st364 + st364: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof364 + } + st_case_364: + // line internal/php8/scanner.go:14726 + switch lex.data[(lex.p)] { + case 66: + goto tr561 + case 92: + goto st93 + case 96: + goto tr330 + case 98: + goto tr561 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr561: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st365 + st365: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof365 + } + st_case_365: + // line internal/php8/scanner.go:14767 + switch lex.data[(lex.p)] { + case 76: + goto tr562 + case 92: + goto st93 + case 96: + goto tr330 + case 108: + goto tr562 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr562: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st366 + st366: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof366 + } + st_case_366: + // line internal/php8/scanner.go:14808 + switch lex.data[(lex.p)] { + case 73: + goto tr563 + case 92: + goto st93 + case 96: + goto tr330 + case 105: + goto tr563 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr563: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st367 + st367: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof367 + } + st_case_367: + // line internal/php8/scanner.go:14849 + switch lex.data[(lex.p)] { + case 67: + goto tr564 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr564 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr238: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st368 + st368: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof368 + } + st_case_368: + // line internal/php8/scanner.go:14890 + switch lex.data[(lex.p)] { + case 69: + goto tr565 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr565 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr565: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st369 + st369: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof369 + } + st_case_369: + // line internal/php8/scanner.go:14931 + switch lex.data[(lex.p)] { + case 81: + goto tr566 + case 84: + goto tr567 + case 92: + goto st93 + case 96: + goto tr330 + case 113: + goto tr566 + case 116: + goto tr567 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr566: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st370 + st370: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof370 + } + st_case_370: + // line internal/php8/scanner.go:14976 + switch lex.data[(lex.p)] { + case 85: + goto tr568 + case 92: + goto st93 + case 96: + goto tr330 + case 117: + goto tr568 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr568: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st371 + st371: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof371 + } + st_case_371: + // line internal/php8/scanner.go:15017 + switch lex.data[(lex.p)] { + case 73: + goto tr569 + case 92: + goto st93 + case 96: + goto tr330 + case 105: + goto tr569 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr569: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st372 + st372: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof372 + } + st_case_372: + // line internal/php8/scanner.go:15058 + switch lex.data[(lex.p)] { + case 82: + goto tr570 + case 92: + goto st93 + case 96: + goto tr330 + case 114: + goto tr570 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr570: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st373 + st373: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof373 + } + st_case_373: + // line internal/php8/scanner.go:15099 + switch lex.data[(lex.p)] { + case 69: + goto tr571 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr571 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr571: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:269 + lex.act = 80 + goto st374 + st374: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof374 + } + st_case_374: + // line internal/php8/scanner.go:15140 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 95: + goto tr573 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr572 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr572 + } + case lex.data[(lex.p)] >= 91: + goto tr572 + } + default: + goto tr572 + } + goto tr231 + tr573: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st375 + st375: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof375 + } + st_case_375: + // line internal/php8/scanner.go:15177 + switch lex.data[(lex.p)] { + case 79: + goto tr574 + case 92: + goto st93 + case 96: + goto tr330 + case 111: + goto tr574 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr574: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st376 + st376: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof376 + } + st_case_376: + // line internal/php8/scanner.go:15218 + switch lex.data[(lex.p)] { + case 78: + goto tr575 + case 92: + goto st93 + case 96: + goto tr330 + case 110: + goto tr575 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr575: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st377 + st377: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof377 + } + st_case_377: + // line internal/php8/scanner.go:15259 + switch lex.data[(lex.p)] { + case 67: + goto tr576 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr576 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr576: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st378 + st378: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof378 + } + st_case_378: + // line internal/php8/scanner.go:15300 + switch lex.data[(lex.p)] { + case 69: + goto tr577 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr577 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr567: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st379 + st379: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof379 + } + st_case_379: + // line internal/php8/scanner.go:15341 + switch lex.data[(lex.p)] { + case 85: + goto tr578 + case 92: + goto st93 + case 96: + goto tr330 + case 117: + goto tr578 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr578: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st380 + st380: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof380 + } + st_case_380: + // line internal/php8/scanner.go:15382 + switch lex.data[(lex.p)] { + case 82: + goto tr579 + case 92: + goto st93 + case 96: + goto tr330 + case 114: + goto tr579 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr579: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st381 + st381: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof381 + } + st_case_381: + // line internal/php8/scanner.go:15423 + switch lex.data[(lex.p)] { + case 78: + goto tr580 + case 92: + goto st93 + case 96: + goto tr330 + case 110: + goto tr580 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr239: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st382 + st382: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof382 + } + st_case_382: + // line internal/php8/scanner.go:15464 + switch lex.data[(lex.p)] { + case 84: + goto tr581 + case 87: + goto tr582 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr581 + case 119: + goto tr582 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr581: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st383 + st383: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof383 + } + st_case_383: + // line internal/php8/scanner.go:15509 + switch lex.data[(lex.p)] { + case 65: + goto tr583 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr583 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr583: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st384 + st384: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof384 + } + st_case_384: + // line internal/php8/scanner.go:15550 + switch lex.data[(lex.p)] { + case 84: + goto tr584 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr584 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr584: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st385 + st385: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof385 + } + st_case_385: + // line internal/php8/scanner.go:15591 + switch lex.data[(lex.p)] { + case 73: + goto tr585 + case 92: + goto st93 + case 96: + goto tr330 + case 105: + goto tr585 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr585: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st386 + st386: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof386 + } + st_case_386: + // line internal/php8/scanner.go:15632 + switch lex.data[(lex.p)] { + case 67: + goto tr586 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr586 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr582: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st387 + st387: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof387 + } + st_case_387: + // line internal/php8/scanner.go:15673 + switch lex.data[(lex.p)] { + case 73: + goto tr587 + case 92: + goto st93 + case 96: + goto tr330 + case 105: + goto tr587 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr587: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st388 + st388: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof388 + } + st_case_388: + // line internal/php8/scanner.go:15714 + switch lex.data[(lex.p)] { + case 84: + goto tr588 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr588 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr588: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st389 + st389: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof389 + } + st_case_389: + // line internal/php8/scanner.go:15755 + switch lex.data[(lex.p)] { + case 67: + goto tr589 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr589 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr589: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st390 + st390: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof390 + } + st_case_390: + // line internal/php8/scanner.go:15796 + switch lex.data[(lex.p)] { + case 72: + goto tr590 + case 92: + goto st93 + case 96: + goto tr330 + case 104: + goto tr590 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr240: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st391 + st391: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof391 + } + st_case_391: + // line internal/php8/scanner.go:15837 + switch lex.data[(lex.p)] { + case 72: + goto tr591 + case 82: + goto tr592 + case 92: + goto st93 + case 96: + goto tr330 + case 104: + goto tr591 + case 114: + goto tr592 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr591: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st392 + st392: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof392 + } + st_case_392: + // line internal/php8/scanner.go:15882 + switch lex.data[(lex.p)] { + case 82: + goto tr593 + case 92: + goto st93 + case 96: + goto tr330 + case 114: + goto tr593 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr593: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st393 + st393: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof393 + } + st_case_393: + // line internal/php8/scanner.go:15923 + switch lex.data[(lex.p)] { + case 79: + goto tr594 + case 92: + goto st93 + case 96: + goto tr330 + case 111: + goto tr594 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr594: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st394 + st394: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof394 + } + st_case_394: + // line internal/php8/scanner.go:15964 + switch lex.data[(lex.p)] { + case 87: + goto tr595 + case 92: + goto st93 + case 96: + goto tr330 + case 119: + goto tr595 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr592: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st395 + st395: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof395 + } + st_case_395: + // line internal/php8/scanner.go:16005 + switch lex.data[(lex.p)] { + case 65: + goto tr596 + case 89: + goto tr597 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr596 + case 121: + goto tr597 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr596: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st396 + st396: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof396 + } + st_case_396: + // line internal/php8/scanner.go:16050 + switch lex.data[(lex.p)] { + case 73: + goto tr598 + case 92: + goto st93 + case 96: + goto tr330 + case 105: + goto tr598 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr598: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st397 + st397: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof397 + } + st_case_397: + // line internal/php8/scanner.go:16091 + switch lex.data[(lex.p)] { + case 84: + goto tr599 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr599 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr241: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st398 + st398: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof398 + } + st_case_398: + // line internal/php8/scanner.go:16132 + switch lex.data[(lex.p)] { + case 78: + goto tr600 + case 83: + goto tr601 + case 92: + goto st93 + case 96: + goto tr330 + case 110: + goto tr600 + case 115: + goto tr601 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr600: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st399 + st399: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof399 + } + st_case_399: + // line internal/php8/scanner.go:16177 + switch lex.data[(lex.p)] { + case 83: + goto tr602 + case 92: + goto st93 + case 96: + goto tr330 + case 115: + goto tr602 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr602: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st400 + st400: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof400 + } + st_case_400: + // line internal/php8/scanner.go:16218 + switch lex.data[(lex.p)] { + case 69: + goto tr603 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr603 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr603: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st401 + st401: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof401 + } + st_case_401: + // line internal/php8/scanner.go:16259 + switch lex.data[(lex.p)] { + case 84: + goto tr604 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr604 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr601: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st402 + st402: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof402 + } + st_case_402: + // line internal/php8/scanner.go:16300 + switch lex.data[(lex.p)] { + case 69: + goto tr605 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr605 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr242: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st403 + st403: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof403 + } + st_case_403: + // line internal/php8/scanner.go:16341 + switch lex.data[(lex.p)] { + case 65: + goto tr606 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr606 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr606: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st404 + st404: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof404 + } + st_case_404: + // line internal/php8/scanner.go:16382 + switch lex.data[(lex.p)] { + case 82: + goto tr607 + case 92: + goto st93 + case 96: + goto tr330 + case 114: + goto tr607 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr243: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st405 + st405: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof405 + } + st_case_405: + // line internal/php8/scanner.go:16423 + switch lex.data[(lex.p)] { + case 72: + goto tr608 + case 92: + goto st93 + case 96: + goto tr330 + case 104: + goto tr608 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr608: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st406 + st406: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof406 + } + st_case_406: + // line internal/php8/scanner.go:16464 + switch lex.data[(lex.p)] { + case 73: + goto tr609 + case 92: + goto st93 + case 96: + goto tr330 + case 105: + goto tr609 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr609: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st407 + st407: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof407 + } + st_case_407: + // line internal/php8/scanner.go:16505 + switch lex.data[(lex.p)] { + case 76: + goto tr610 + case 92: + goto st93 + case 96: + goto tr330 + case 108: + goto tr610 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr610: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st408 + st408: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof408 + } + st_case_408: + // line internal/php8/scanner.go:16546 + switch lex.data[(lex.p)] { + case 69: + goto tr611 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr611 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr244: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st409 + st409: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof409 + } + st_case_409: + // line internal/php8/scanner.go:16587 + switch lex.data[(lex.p)] { + case 79: + goto tr612 + case 92: + goto st93 + case 96: + goto tr330 + case 111: + goto tr612 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr612: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st410 + st410: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof410 + } + st_case_410: + // line internal/php8/scanner.go:16628 + switch lex.data[(lex.p)] { + case 82: + goto tr613 + case 92: + goto st93 + case 96: + goto tr330 + case 114: + goto tr613 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr245: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st411 + st411: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof411 + } + st_case_411: + // line internal/php8/scanner.go:16669 + switch lex.data[(lex.p)] { + case 73: + goto tr614 + case 92: + goto st93 + case 96: + goto tr330 + case 105: + goto tr614 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr614: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st412 + st412: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof412 + } + st_case_412: + // line internal/php8/scanner.go:16710 + switch lex.data[(lex.p)] { + case 69: + goto tr615 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr615 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr615: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st413 + st413: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof413 + } + st_case_413: + // line internal/php8/scanner.go:16751 + switch lex.data[(lex.p)] { + case 76: + goto tr616 + case 92: + goto st93 + case 96: + goto tr330 + case 108: + goto tr616 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr616: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st414 + st414: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof414 + } + st_case_414: + // line internal/php8/scanner.go:16792 + switch lex.data[(lex.p)] { + case 68: + goto tr617 + case 92: + goto st93 + case 96: + goto tr330 + case 100: + goto tr617 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr617: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:266 + lex.act = 77 + goto st415 + st415: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof415 + } + st_case_415: + // line internal/php8/scanner.go:16833 + switch lex.data[(lex.p)] { + case 10: + goto tr139 + case 13: + goto tr140 + case 32: + goto st97 + case 92: + goto st93 + case 96: + goto tr618 + } + 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 st97 + } + default: + goto tr618 + } + case lex.data[(lex.p)] > 47: + switch { + case lex.data[(lex.p)] < 91: + if 58 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 64 { + goto tr618 + } + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr618 + } + default: + goto tr618 + } + default: + goto tr618 + } + goto tr231 + tr142: + // line internal/php8/scanner.rl:54 + + goto st97 + st97: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof97 + } + st_case_97: + // line internal/php8/scanner.go:16882 + switch lex.data[(lex.p)] { + case 10: + goto tr139 + case 13: + goto tr140 + case 32: + goto st97 + case 70: + goto st100 + case 102: + goto st100 + } + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto st97 + } + goto tr137 + tr139: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st98 + tr143: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st98 + st98: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof98 + } + st_case_98: + // line internal/php8/scanner.go:16930 + switch lex.data[(lex.p)] { + case 10: + goto tr143 + case 13: + goto tr144 + case 32: + goto tr142 + case 70: + goto tr145 + case 102: + goto tr145 + } + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr142 + } + goto tr137 + tr140: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st99 + tr144: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st99 + st99: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof99 + } + st_case_99: + // line internal/php8/scanner.go:16978 + if lex.data[(lex.p)] == 10 { + goto tr139 + } + goto tr137 + tr145: + // line internal/php8/scanner.rl:54 + + goto st100 + st100: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof100 + } + st_case_100: + // line internal/php8/scanner.go:16992 + switch lex.data[(lex.p)] { + case 82: + goto st101 + case 114: + goto st101 + } + goto tr137 + st101: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof101 + } + st_case_101: + switch lex.data[(lex.p)] { + case 79: + goto st102 + case 111: + goto st102 + } + goto tr137 + st102: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof102 + } + st_case_102: + switch lex.data[(lex.p)] { + case 77: + goto tr148 + case 109: + goto tr148 + } + goto tr137 + st416: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof416 + } + st_case_416: + if lex.data[(lex.p)] == 96 { + goto tr619 + } + switch { + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto tr619 + } + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr619 + } + default: + goto tr619 + } + goto tr150 + tr150: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st417 + st417: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof417 + } + st_case_417: + // line internal/php8/scanner.go:17055 + switch lex.data[(lex.p)] { + case 92: + goto st103 + case 96: + goto tr620 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr620 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr620 + } + case lex.data[(lex.p)] >= 91: + goto tr620 + } + default: + goto tr620 + } + goto tr150 + st103: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof103 + } + st_case_103: + if lex.data[(lex.p)] == 96 { + goto tr149 + } + switch { + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto tr149 + } + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr149 + } + default: + goto tr149 + } + goto tr150 + st418: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof418 + } + st_case_418: + if lex.data[(lex.p)] == 61 { + goto tr622 + } + goto tr260 + tr248: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st419 + st419: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof419 + } + st_case_419: + // line internal/php8/scanner.go:17122 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 95: + goto tr623 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr623: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st420 + st420: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof420 + } + st_case_420: + // line internal/php8/scanner.go:17159 + switch lex.data[(lex.p)] { + case 67: + goto tr624 + case 68: + goto tr625 + case 70: + goto tr626 + case 72: + goto tr627 + case 76: + goto tr628 + case 77: + goto tr629 + case 78: + goto tr630 + case 84: + goto tr631 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr624 + case 100: + goto tr625 + case 102: + goto tr626 + case 104: + goto tr627 + case 108: + goto tr628 + case 109: + goto tr629 + case 110: + goto tr630 + case 116: + goto tr631 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr624: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st421 + st421: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof421 + } + st_case_421: + // line internal/php8/scanner.go:17228 + switch lex.data[(lex.p)] { + case 76: + goto tr632 + case 92: + goto st93 + case 96: + goto tr330 + case 108: + goto tr632 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr632: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st422 + st422: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof422 + } + st_case_422: + // line internal/php8/scanner.go:17269 + switch lex.data[(lex.p)] { + case 65: + goto tr633 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr633 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr633: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st423 + st423: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof423 + } + st_case_423: + // line internal/php8/scanner.go:17310 + switch lex.data[(lex.p)] { + case 83: + goto tr634 + case 92: + goto st93 + case 96: + goto tr330 + case 115: + goto tr634 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr634: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st424 + st424: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof424 + } + st_case_424: + // line internal/php8/scanner.go:17351 + switch lex.data[(lex.p)] { + case 83: + goto tr635 + case 92: + goto st93 + case 96: + goto tr330 + case 115: + goto tr635 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr635: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st425 + st425: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof425 + } + st_case_425: + // line internal/php8/scanner.go:17392 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 95: + goto tr636 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr636: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st426 + st426: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof426 + } + st_case_426: + // line internal/php8/scanner.go:17429 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 95: + goto tr637 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr625: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st427 + st427: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof427 + } + st_case_427: + // line internal/php8/scanner.go:17466 + switch lex.data[(lex.p)] { + case 73: + goto tr638 + case 92: + goto st93 + case 96: + goto tr330 + case 105: + goto tr638 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr638: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st428 + st428: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof428 + } + st_case_428: + // line internal/php8/scanner.go:17507 + switch lex.data[(lex.p)] { + case 82: + goto tr639 + case 92: + goto st93 + case 96: + goto tr330 + case 114: + goto tr639 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr639: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st429 + st429: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof429 + } + st_case_429: + // line internal/php8/scanner.go:17548 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 95: + goto tr640 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr640: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st430 + st430: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof430 + } + st_case_430: + // line internal/php8/scanner.go:17585 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 95: + goto tr641 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr626: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st431 + st431: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof431 + } + st_case_431: + // line internal/php8/scanner.go:17622 + switch lex.data[(lex.p)] { + case 73: + goto tr642 + case 85: + goto tr643 + case 92: + goto st93 + case 96: + goto tr330 + case 105: + goto tr642 + case 117: + goto tr643 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr642: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st432 + st432: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof432 + } + st_case_432: + // line internal/php8/scanner.go:17667 + switch lex.data[(lex.p)] { + case 76: + goto tr644 + case 92: + goto st93 + case 96: + goto tr330 + case 108: + goto tr644 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr644: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st433 + st433: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof433 + } + st_case_433: + // line internal/php8/scanner.go:17708 + switch lex.data[(lex.p)] { + case 69: + goto tr645 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr645 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr645: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st434 + st434: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof434 + } + st_case_434: + // line internal/php8/scanner.go:17749 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 95: + goto tr646 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr646: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st435 + st435: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof435 + } + st_case_435: + // line internal/php8/scanner.go:17786 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 95: + goto tr647 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr643: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st436 + st436: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof436 + } + st_case_436: + // line internal/php8/scanner.go:17823 + switch lex.data[(lex.p)] { + case 78: + goto tr648 + case 92: + goto st93 + case 96: + goto tr330 + case 110: + goto tr648 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr648: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st437 + st437: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof437 + } + st_case_437: + // line internal/php8/scanner.go:17864 + switch lex.data[(lex.p)] { + case 67: + goto tr649 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr649 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr649: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st438 + st438: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof438 + } + st_case_438: + // line internal/php8/scanner.go:17905 + switch lex.data[(lex.p)] { + case 84: + goto tr650 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr650 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr650: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st439 + st439: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof439 + } + st_case_439: + // line internal/php8/scanner.go:17946 + switch lex.data[(lex.p)] { + case 73: + goto tr651 + case 92: + goto st93 + case 96: + goto tr330 + case 105: + goto tr651 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr651: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st440 + st440: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof440 + } + st_case_440: + // line internal/php8/scanner.go:17987 + switch lex.data[(lex.p)] { + case 79: + goto tr652 + case 92: + goto st93 + case 96: + goto tr330 + case 111: + goto tr652 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr652: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st441 + st441: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof441 + } + st_case_441: + // line internal/php8/scanner.go:18028 + switch lex.data[(lex.p)] { + case 78: + goto tr653 + case 92: + goto st93 + case 96: + goto tr330 + case 110: + goto tr653 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr653: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st442 + st442: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof442 + } + st_case_442: + // line internal/php8/scanner.go:18069 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 95: + goto tr654 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr654: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st443 + st443: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof443 + } + st_case_443: + // line internal/php8/scanner.go:18106 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 95: + goto tr655 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr627: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st444 + st444: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof444 + } + st_case_444: + // line internal/php8/scanner.go:18143 + switch lex.data[(lex.p)] { + case 65: + goto tr656 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr656 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr656: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st445 + st445: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof445 + } + st_case_445: + // line internal/php8/scanner.go:18184 + switch lex.data[(lex.p)] { + case 76: + goto tr657 + case 92: + goto st93 + case 96: + goto tr330 + case 108: + goto tr657 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr657: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st446 + st446: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof446 + } + st_case_446: + // line internal/php8/scanner.go:18225 + switch lex.data[(lex.p)] { + case 84: + goto tr658 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr658 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr658: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st447 + st447: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof447 + } + st_case_447: + // line internal/php8/scanner.go:18266 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 95: + goto tr659 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr659: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st448 + st448: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof448 + } + st_case_448: + // line internal/php8/scanner.go:18303 + switch lex.data[(lex.p)] { + case 67: + goto tr660 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr660 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr660: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st449 + st449: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof449 + } + st_case_449: + // line internal/php8/scanner.go:18344 + switch lex.data[(lex.p)] { + case 79: + goto tr661 + case 92: + goto st93 + case 96: + goto tr330 + case 111: + goto tr661 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr661: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st450 + st450: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof450 + } + st_case_450: + // line internal/php8/scanner.go:18385 + switch lex.data[(lex.p)] { + case 77: + goto tr662 + case 92: + goto st93 + case 96: + goto tr330 + case 109: + goto tr662 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr662: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st451 + st451: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof451 + } + st_case_451: + // line internal/php8/scanner.go:18426 + switch lex.data[(lex.p)] { + case 80: + goto tr663 + case 92: + goto st93 + case 96: + goto tr330 + case 112: + goto tr663 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr663: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st452 + st452: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof452 + } + st_case_452: + // line internal/php8/scanner.go:18467 + switch lex.data[(lex.p)] { + case 73: + goto tr664 + case 92: + goto st93 + case 96: + goto tr330 + case 105: + goto tr664 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr664: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st453 + st453: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof453 + } + st_case_453: + // line internal/php8/scanner.go:18508 + switch lex.data[(lex.p)] { + case 76: + goto tr665 + case 92: + goto st93 + case 96: + goto tr330 + case 108: + goto tr665 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr665: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st454 + st454: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof454 + } + st_case_454: + // line internal/php8/scanner.go:18549 + switch lex.data[(lex.p)] { + case 69: + goto tr666 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr666 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr666: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st455 + st455: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof455 + } + st_case_455: + // line internal/php8/scanner.go:18590 + switch lex.data[(lex.p)] { + case 82: + goto tr667 + case 92: + goto st93 + case 96: + goto tr330 + case 114: + goto tr667 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr628: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st456 + st456: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof456 + } + st_case_456: + // line internal/php8/scanner.go:18631 + switch lex.data[(lex.p)] { + case 73: + goto tr668 + case 92: + goto st93 + case 96: + goto tr330 + case 105: + goto tr668 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr668: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st457 + st457: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof457 + } + st_case_457: + // line internal/php8/scanner.go:18672 + switch lex.data[(lex.p)] { + case 78: + goto tr669 + case 92: + goto st93 + case 96: + goto tr330 + case 110: + goto tr669 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr669: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st458 + st458: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof458 + } + st_case_458: + // line internal/php8/scanner.go:18713 + switch lex.data[(lex.p)] { + case 69: + goto tr670 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr670 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr670: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st459 + st459: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof459 + } + st_case_459: + // line internal/php8/scanner.go:18754 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 95: + goto tr671 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr671: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st460 + st460: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof460 + } + st_case_460: + // line internal/php8/scanner.go:18791 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 95: + goto tr672 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr629: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st461 + st461: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof461 + } + st_case_461: + // line internal/php8/scanner.go:18828 + switch lex.data[(lex.p)] { + case 69: + goto tr673 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr673 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr673: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st462 + st462: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof462 + } + st_case_462: + // line internal/php8/scanner.go:18869 + switch lex.data[(lex.p)] { + case 84: + goto tr674 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr674 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr674: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st463 + st463: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof463 + } + st_case_463: + // line internal/php8/scanner.go:18910 + switch lex.data[(lex.p)] { + case 72: + goto tr675 + case 92: + goto st93 + case 96: + goto tr330 + case 104: + goto tr675 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr675: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st464 + st464: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof464 + } + st_case_464: + // line internal/php8/scanner.go:18951 + switch lex.data[(lex.p)] { + case 79: + goto tr676 + case 92: + goto st93 + case 96: + goto tr330 + case 111: + goto tr676 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr676: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st465 + st465: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof465 + } + st_case_465: + // line internal/php8/scanner.go:18992 + switch lex.data[(lex.p)] { + case 68: + goto tr677 + case 92: + goto st93 + case 96: + goto tr330 + case 100: + goto tr677 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr677: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st466 + st466: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof466 + } + st_case_466: + // line internal/php8/scanner.go:19033 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 95: + goto tr678 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr678: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st467 + st467: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof467 + } + st_case_467: + // line internal/php8/scanner.go:19070 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 95: + goto tr679 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr630: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st468 + st468: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof468 + } + st_case_468: + // line internal/php8/scanner.go:19107 + switch lex.data[(lex.p)] { + case 65: + goto tr680 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr680 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr680: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st469 + st469: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof469 + } + st_case_469: + // line internal/php8/scanner.go:19148 + switch lex.data[(lex.p)] { + case 77: + goto tr681 + case 92: + goto st93 + case 96: + goto tr330 + case 109: + goto tr681 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr681: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st470 + st470: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof470 + } + st_case_470: + // line internal/php8/scanner.go:19189 + switch lex.data[(lex.p)] { + case 69: + goto tr682 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr682 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr682: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st471 + st471: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof471 + } + st_case_471: + // line internal/php8/scanner.go:19230 + switch lex.data[(lex.p)] { + case 83: + goto tr683 + case 92: + goto st93 + case 96: + goto tr330 + case 115: + goto tr683 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr683: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st472 + st472: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof472 + } + st_case_472: + // line internal/php8/scanner.go:19271 + switch lex.data[(lex.p)] { + case 80: + goto tr684 + case 92: + goto st93 + case 96: + goto tr330 + case 112: + goto tr684 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr684: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st473 + st473: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof473 + } + st_case_473: + // line internal/php8/scanner.go:19312 + switch lex.data[(lex.p)] { + case 65: + goto tr685 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr685 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr685: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st474 + st474: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof474 + } + st_case_474: + // line internal/php8/scanner.go:19353 + switch lex.data[(lex.p)] { + case 67: + goto tr686 + case 92: + goto st93 + case 96: + goto tr330 + case 99: + goto tr686 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr686: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st475 + st475: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof475 + } + st_case_475: + // line internal/php8/scanner.go:19394 + switch lex.data[(lex.p)] { + case 69: + goto tr687 + case 92: + goto st93 + case 96: + goto tr330 + case 101: + goto tr687 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr687: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st476 + st476: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof476 + } + st_case_476: + // line internal/php8/scanner.go:19435 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 95: + goto tr688 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr688: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st477 + st477: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof477 + } + st_case_477: + // line internal/php8/scanner.go:19472 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 95: + goto tr689 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr631: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st478 + st478: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof478 + } + st_case_478: + // line internal/php8/scanner.go:19509 + switch lex.data[(lex.p)] { + case 82: + goto tr690 + case 92: + goto st93 + case 96: + goto tr330 + case 114: + goto tr690 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr690: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st479 + st479: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof479 + } + st_case_479: + // line internal/php8/scanner.go:19550 + switch lex.data[(lex.p)] { + case 65: + goto tr691 + case 92: + goto st93 + case 96: + goto tr330 + case 97: + goto tr691 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr691: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st480 + st480: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof480 + } + st_case_480: + // line internal/php8/scanner.go:19591 + switch lex.data[(lex.p)] { + case 73: + goto tr692 + case 92: + goto st93 + case 96: + goto tr330 + case 105: + goto tr692 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr692: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st481 + st481: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof481 + } + st_case_481: + // line internal/php8/scanner.go:19632 + switch lex.data[(lex.p)] { + case 84: + goto tr693 + case 92: + goto st93 + case 96: + goto tr330 + case 116: + goto tr693 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr693: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st482 + st482: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof482 + } + st_case_482: + // line internal/php8/scanner.go:19673 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 95: + goto tr694 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + tr694: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:355 + lex.act = 142 + goto st483 + st483: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof483 + } + st_case_483: + // line internal/php8/scanner.go:19710 + switch lex.data[(lex.p)] { + case 92: + goto st93 + case 95: + goto tr695 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr330 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 96: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr330 + } + case lex.data[(lex.p)] >= 91: + goto tr330 + } + default: + goto tr330 + } + goto tr231 + st484: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof484 + } + st_case_484: + switch lex.data[(lex.p)] { + case 61: + goto tr696 + case 124: + goto tr697 + } + goto tr260 + tr151: + // line internal/php8/scanner.rl:390 + (lex.p) = (lex.te) - 1 + { + lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te) + } + goto st485 + tr153: + // line internal/php8/scanner.rl:394 + (lex.p) = (lex.te) - 1 + { + lex.ungetCnt(1) + { + goto st131 + } + } + goto st485 + tr154: + // line internal/php8/scanner.rl:392 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_NULLSAFE_OBJECT_OPERATOR + { + (lex.p)++ + lex.cs = 485 + goto _out + } + } + goto st485 + tr698: + // line internal/php8/scanner.rl:394 + lex.te = (lex.p) + 1 + { + lex.ungetCnt(1) + { + goto st131 + } + } + goto st485 + tr704: + // line internal/php8/scanner.rl:390 + lex.te = (lex.p) + (lex.p)-- + { + lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te) + } + goto st485 + tr706: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:390 + lex.te = (lex.p) + (lex.p)-- + { + lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te) + } + goto st485 + tr710: + // line internal/php8/scanner.rl:394 + lex.te = (lex.p) + (lex.p)-- + { + lex.ungetCnt(1) + { + goto st131 + } + } + goto st485 + tr711: + // line internal/php8/scanner.rl:391 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_OBJECT_OPERATOR + { + (lex.p)++ + lex.cs = 485 + goto _out + } + } + goto st485 + tr713: + lex.cs = 485 + // line internal/php8/scanner.rl:393 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_STRING + lex.cs = 131 + { + (lex.p)++ + goto _out + } + } + goto _again + st485: + // line NONE:1 + lex.ts = 0 + + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof485 + } + st_case_485: + // line NONE:1 + lex.ts = (lex.p) + + // line internal/php8/scanner.go:19810 + switch lex.data[(lex.p)] { + case 10: + goto tr152 + case 13: + goto tr700 + case 32: + goto tr699 + case 45: + goto st489 + case 63: + goto tr702 + case 96: + goto tr698 + } + 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 tr699 + } + default: + goto tr698 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr698 + } + case lex.data[(lex.p)] >= 91: + goto tr698 + } + default: + goto tr698 + } + goto st491 + tr699: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st486 + tr707: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:54 + + goto st486 + st486: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof486 + } + st_case_486: + // line internal/php8/scanner.go:19865 + switch lex.data[(lex.p)] { + case 10: + goto tr152 + case 13: + goto tr705 + case 32: + goto tr699 + } + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr699 + } + goto tr704 + tr152: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st487 + tr708: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st487 + st487: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof487 + } + st_case_487: + // line internal/php8/scanner.go:19915 + switch lex.data[(lex.p)] { + case 10: + goto tr708 + case 13: + goto tr709 + case 32: + goto tr707 + } + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr707 + } + goto tr706 + tr705: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st104 + tr709: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st104 + st104: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof104 + } + st_case_104: + // line internal/php8/scanner.go:19959 + if lex.data[(lex.p)] == 10 { + goto tr152 + } + goto tr151 + tr700: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st488 + st488: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof488 + } + st_case_488: + // line internal/php8/scanner.go:19981 + if lex.data[(lex.p)] == 10 { + goto tr152 + } + goto tr710 + st489: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof489 + } + st_case_489: + if lex.data[(lex.p)] == 62 { + goto tr711 + } + goto tr710 + tr702: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st490 + st490: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof490 + } + st_case_490: + // line internal/php8/scanner.go:20005 + if lex.data[(lex.p)] == 45 { + goto st105 + } + goto tr710 + st105: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof105 + } + st_case_105: + if lex.data[(lex.p)] == 62 { + goto tr154 + } + goto tr153 + st491: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof491 + } + st_case_491: + if lex.data[(lex.p)] == 96 { + goto tr713 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr713 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr713 + } + case lex.data[(lex.p)] >= 91: + goto tr713 + } + default: + goto tr713 + } + goto st491 + tr717: + lex.cs = 492 + // line NONE:1 + switch lex.act { + case 0: + { + { + goto st0 + } + } + case 155: + { + (lex.p) = (lex.te) - 1 + + lex.setTokenPosition(tkn) + tok = token.T_ENCAPSED_AND_WHITESPACE + lex.cs = 515 + { + (lex.p)++ + goto _out + } + } + } + + goto _again + tr718: + lex.cs = 492 + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:398 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_ENCAPSED_AND_WHITESPACE + lex.cs = 515 + { + (lex.p)++ + goto _out + } + } + goto _again + tr722: + lex.cs = 492 + // line internal/php8/scanner.rl:398 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_ENCAPSED_AND_WHITESPACE + lex.cs = 515 + { + (lex.p)++ + goto _out + } + } + goto _again + st492: + // line NONE:1 + lex.ts = 0 + + // line NONE:1 + lex.act = 0 + + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof492 + } + st_case_492: + // line NONE:1 + lex.ts = (lex.p) + + // line internal/php8/scanner.go:20102 + _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: + goto tr715 + case 1037: + goto tr716 + } + if 1024 <= _widec && _widec <= 1279 { + goto tr714 + } + goto st0 + st_case_0: + st0: + lex.cs = 0 + goto _out + tr714: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:398 + lex.act = 155 + goto st493 + tr719: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:398 + lex.act = 155 + goto st493 + st493: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof493 + } + st_case_493: + // line internal/php8/scanner.go:20176 + _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: + goto tr715 + case 1037: + goto tr716 + } + if 1024 <= _widec && _widec <= 1279 { + goto tr714 + } + goto tr717 + tr715: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st494 + tr720: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st494 + st494: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof494 + } + st_case_494: + // line internal/php8/scanner.go:20256 + _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: + goto tr720 + case 1037: + goto tr721 + } + if 1024 <= _widec && _widec <= 1279 { + goto tr719 + } + goto tr718 + tr716: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st495 + tr721: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st495 + st495: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof495 + } + st_case_495: + // line internal/php8/scanner.go:20336 + _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: + goto tr715 + case 1037: + goto tr716 + } + if 1024 <= _widec && _widec <= 1279 { + goto tr714 + } + goto tr722 + tr155: + // line internal/php8/scanner.rl:407 + lex.te = (lex.p) + 1 + { + lex.ungetCnt(1) + lex.setTokenPosition(tkn) + tok = token.T_CURLY_OPEN + lex.call(496, 131) + goto _out + } + goto st496 + tr730: + // line internal/php8/scanner.rl:409 + lex.te = (lex.p) + (lex.p)-- + { + lex.ungetCnt(1) + { + lex.growCallStack() + { + lex.stack[lex.top] = 496 + lex.top++ + goto st517 + } + } + } + goto st496 + tr731: + // line internal/php8/scanner.rl:408 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_DOLLAR_OPEN_CURLY_BRACES + lex.call(496, 533) + goto _out + } + goto st496 + tr732: + lex.cs = 496 + // line NONE:1 + switch lex.act { + case 156: + { + (lex.p) = (lex.te) - 1 + lex.ungetCnt(1) + lex.setTokenPosition(tkn) + tok = token.T_CURLY_OPEN + lex.call(496, 131) + goto _out + } + case 157: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_DOLLAR_OPEN_CURLY_BRACES + lex.call(496, 533) + goto _out + } + case 159: + { + (lex.p) = (lex.te) - 1 + + lex.setTokenPosition(tkn) + tok = token.T_ENCAPSED_AND_WHITESPACE + + if len(lex.data) > lex.p+1 && lex.data[lex.p+1] != '$' && lex.data[lex.p+1] != '{' { + lex.cs = 515 + } + { + (lex.p)++ + goto _out + } + } + } + + goto _again + tr733: + lex.cs = 496 + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:410 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_ENCAPSED_AND_WHITESPACE + + if len(lex.data) > lex.p+1 && lex.data[lex.p+1] != '$' && lex.data[lex.p+1] != '{' { + lex.cs = 515 + } + { + (lex.p)++ + goto _out + } + } + goto _again + tr737: + lex.cs = 496 + // line internal/php8/scanner.rl:410 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_ENCAPSED_AND_WHITESPACE + + if len(lex.data) > lex.p+1 && lex.data[lex.p+1] != '$' && lex.data[lex.p+1] != '{' { + lex.cs = 515 + } + { + (lex.p)++ + goto _out + } + } + goto _again + st496: + // line NONE:1 + lex.ts = 0 + + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof496 + } + st_case_496: + // line NONE:1 + lex.ts = (lex.p) + + // line internal/php8/scanner.go:20468 + _widec = int16(lex.data[(lex.p)]) + switch { + case lex.data[(lex.p)] < 11: + switch { + case lex.data[(lex.p)] > 9: + if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] > 12: + switch { + case lex.data[(lex.p)] > 13: + if 14 <= lex.data[(lex.p)] { + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] >= 13: + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + switch _widec { + case 1316: + goto st497 + case 1403: + goto st106 + case 1546: + goto tr726 + case 1549: + goto tr727 + case 1572: + goto st501 + case 1659: + goto st502 + } + if 1536 <= _widec && _widec <= 1791 { + goto tr725 + } + goto st0 + st497: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof497 + } + st_case_497: + if lex.data[(lex.p)] == 123 { + goto tr731 + } + goto tr730 + st106: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof106 + } + st_case_106: + if lex.data[(lex.p)] == 36 { + goto tr155 + } + goto st0 + tr725: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:410 + lex.act = 159 + goto st498 + tr734: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:410 + lex.act = 159 + goto st498 + tr738: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:408 + lex.act = 157 + goto st498 + tr739: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:407 + lex.act = 156 + goto st498 + st498: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof498 + } + st_case_498: + // line internal/php8/scanner.go:20578 + _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: + goto tr726 + case 1549: + goto tr727 + } + if 1536 <= _widec && _widec <= 1791 { + goto tr725 + } + goto tr732 + tr726: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st499 + tr735: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st499 + st499: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof499 + } + st_case_499: + // line internal/php8/scanner.go:20658 + _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: + goto tr735 + case 1549: + goto tr736 + } + if 1536 <= _widec && _widec <= 1791 { + goto tr734 + } + goto tr733 + tr727: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st500 + tr736: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st500 + st500: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof500 + } + st_case_500: + // line internal/php8/scanner.go:20738 + _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: + goto tr726 + case 1549: + goto tr727 + } + if 1536 <= _widec && _widec <= 1791 { + goto tr725 + } + goto tr737 + st501: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof501 + } + st_case_501: + _widec = int16(lex.data[(lex.p)]) + switch { + case lex.data[(lex.p)] < 11: + switch { + case lex.data[(lex.p)] > 9: + if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] > 12: + switch { + case lex.data[(lex.p)] > 13: + if 14 <= lex.data[(lex.p)] { + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] >= 13: + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + switch _widec { + case 1403: + goto tr731 + case 1546: + goto tr726 + case 1549: + goto tr727 + case 1659: + goto tr738 + } + if 1536 <= _widec && _widec <= 1791 { + goto tr725 + } + goto tr730 + st502: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof502 + } + st_case_502: + _widec = int16(lex.data[(lex.p)]) + switch { + case lex.data[(lex.p)] < 11: + switch { + case lex.data[(lex.p)] > 9: + if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] > 12: + switch { + case lex.data[(lex.p)] > 13: + if 14 <= lex.data[(lex.p)] { + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] >= 13: + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1280 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() { + _widec += 256 + } + } + switch _widec { + case 1316: + goto tr155 + case 1546: + goto tr726 + case 1549: + goto tr727 + case 1572: + goto tr739 + } + if 1536 <= _widec && _widec <= 1791 { + goto tr725 + } + goto tr737 + tr157: + // line internal/php8/scanner.rl:424 + lex.te = (lex.p) + 1 + { + lex.ungetCnt(2) + { + lex.growCallStack() + { + lex.stack[lex.top] = 503 + lex.top++ + goto st517 + } + } + } + goto st503 + tr158: + // line internal/php8/scanner.rl:423 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_DOLLAR_OPEN_CURLY_BRACES + lex.call(503, 533) + goto _out + } + goto st503 + tr159: + // line internal/php8/scanner.rl:422 + lex.te = (lex.p) + 1 + { + lex.ungetCnt(1) + lex.setTokenPosition(tkn) + tok = token.T_CURLY_OPEN + lex.call(503, 131) + goto _out + } + goto st503 + tr741: + lex.cs = 503 + // line internal/php8/scanner.rl:425 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.ID(int('`')) + lex.cs = 131 + { + (lex.p)++ + goto _out + } + } + goto _again + tr749: + lex.cs = 503 + // line NONE:1 + switch lex.act { + case 160: + { + (lex.p) = (lex.te) - 1 + lex.ungetCnt(1) + lex.setTokenPosition(tkn) + tok = token.T_CURLY_OPEN + lex.call(503, 131) + goto _out + } + case 161: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_DOLLAR_OPEN_CURLY_BRACES + lex.call(503, 533) + goto _out + } + case 162: + { + (lex.p) = (lex.te) - 1 + lex.ungetCnt(2) + { + lex.growCallStack() + { + lex.stack[lex.top] = 503 + lex.top++ + goto st517 + } + } + } + case 163: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.ID(int('`')) + lex.cs = 131 + { + (lex.p)++ + goto _out + } + } + case 164: + { + (lex.p) = (lex.te) - 1 + + lex.setTokenPosition(tkn) + tok = token.T_ENCAPSED_AND_WHITESPACE + { + (lex.p)++ + goto _out + } + } + } + + goto _again + tr750: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:426 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_ENCAPSED_AND_WHITESPACE + { + (lex.p)++ + lex.cs = 503 + goto _out + } + } + goto st503 + tr754: + // line internal/php8/scanner.rl:426 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_ENCAPSED_AND_WHITESPACE + { + (lex.p)++ + lex.cs = 503 + goto _out + } + } + goto st503 + st503: + // line NONE:1 + lex.ts = 0 + + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof503 + } + st_case_503: + // line NONE:1 + lex.ts = (lex.p) + + // line internal/php8/scanner.go:20981 + _widec = int16(lex.data[(lex.p)]) + switch { + case lex.data[(lex.p)] < 11: + switch { + case lex.data[(lex.p)] > 9: + if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] > 12: + switch { + case lex.data[(lex.p)] > 13: + if 14 <= lex.data[(lex.p)] { + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] >= 13: + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + switch _widec { + case 1828: + goto st107 + case 1888: + goto tr741 + case 1915: + goto st108 + case 2058: + goto tr744 + case 2061: + goto tr745 + case 2084: + goto st507 + case 2144: + goto tr747 + case 2171: + goto st508 + } + if 2048 <= _widec && _widec <= 2303 { + goto tr743 + } + goto st0 + st107: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof107 + } + st_case_107: + switch lex.data[(lex.p)] { + case 96: + goto st0 + case 123: + goto tr158 + } + 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 + } + goto tr157 + st108: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof108 + } + st_case_108: + if lex.data[(lex.p)] == 36 { + goto tr159 + } + goto st0 + tr743: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:426 + lex.act = 164 + goto st504 + tr747: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:425 + lex.act = 163 + goto st504 + tr751: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:426 + lex.act = 164 + goto st504 + tr755: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:424 + lex.act = 162 + goto st504 + tr756: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:423 + lex.act = 161 + goto st504 + tr757: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:422 + lex.act = 160 + goto st504 + st504: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof504 + } + st_case_504: + // line internal/php8/scanner.go:21124 + _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: + goto tr744 + case 2061: + goto tr745 + } + if 2048 <= _widec && _widec <= 2303 { + goto tr743 + } + goto tr749 + tr744: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st505 + tr752: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st505 + st505: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof505 + } + st_case_505: + // line internal/php8/scanner.go:21204 + _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: + goto tr752 + case 2061: + goto tr753 + } + if 2048 <= _widec && _widec <= 2303 { + goto tr751 + } + goto tr750 + tr745: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st506 + tr753: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st506 + st506: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof506 + } + st_case_506: + // line internal/php8/scanner.go:21284 + _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: + goto tr744 + case 2061: + goto tr745 + } + if 2048 <= _widec && _widec <= 2303 { + goto tr743 + } + goto tr754 + st507: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof507 + } + st_case_507: + _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 tr157 + case 1915: + goto tr158 + case 2058: + goto tr744 + case 2061: + goto tr745 + case 2143: + goto tr755 + case 2171: + goto tr756 + } + switch { + case _widec < 2113: + switch { + case _widec < 1889: + if 1857 <= _widec && _widec <= 1882 { + goto tr157 + } + case _widec > 1914: + switch { + case _widec > 2047: + if 2048 <= _widec && _widec <= 2112 { + goto tr743 + } + case _widec >= 1920: + goto tr157 + } + default: + goto tr157 + } + case _widec > 2138: + switch { + case _widec < 2145: + if 2139 <= _widec && _widec <= 2144 { + goto tr743 + } + case _widec > 2170: + switch { + case _widec > 2175: + if 2176 <= _widec && _widec <= 2303 { + goto tr755 + } + case _widec >= 2172: + goto tr743 + } + default: + goto tr755 + } + default: + goto tr755 + } + goto tr754 + st508: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof508 + } + st_case_508: + _widec = int16(lex.data[(lex.p)]) + switch { + case lex.data[(lex.p)] < 11: + switch { + case lex.data[(lex.p)] > 9: + if 10 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 10 { + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] > 12: + switch { + case lex.data[(lex.p)] > 13: + if 14 <= lex.data[(lex.p)] { + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + case lex.data[(lex.p)] >= 13: + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + default: + _widec = 1792 + (int16(lex.data[(lex.p)]) - 0) + if lex.isNotStringEnd('`') && lex.isNotStringVar() { + _widec += 256 + } + } + switch _widec { + case 1828: + goto tr159 + case 2058: + goto tr744 + case 2061: + goto tr745 + case 2084: + goto tr757 + } + if 2048 <= _widec && _widec <= 2303 { + goto tr743 + } + goto tr754 + tr160: + // line internal/php8/scanner.rl:436 + lex.te = (lex.p) + 1 + { + lex.ungetCnt(2) + { + lex.growCallStack() + { + lex.stack[lex.top] = 509 + lex.top++ + goto st517 + } + } + } + goto st509 + tr161: + // line internal/php8/scanner.rl:435 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_DOLLAR_OPEN_CURLY_BRACES + lex.call(509, 533) + goto _out + } + goto st509 + tr162: + // line internal/php8/scanner.rl:434 + lex.te = (lex.p) + 1 + { + lex.ungetCnt(1) + lex.setTokenPosition(tkn) + tok = token.T_CURLY_OPEN + lex.call(509, 131) + goto _out + } + goto st509 + tr758: + lex.cs = 509 + // line internal/php8/scanner.rl:437 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.ID(int('"')) + lex.cs = 131 + { + (lex.p)++ + goto _out + } + } + goto _again + tr767: + lex.cs = 509 + // line NONE:1 + switch lex.act { + case 165: + { + (lex.p) = (lex.te) - 1 + lex.ungetCnt(1) + lex.setTokenPosition(tkn) + tok = token.T_CURLY_OPEN + lex.call(509, 131) + goto _out + } + case 166: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.T_DOLLAR_OPEN_CURLY_BRACES + lex.call(509, 533) + goto _out + } + case 167: + { + (lex.p) = (lex.te) - 1 + lex.ungetCnt(2) + { + lex.growCallStack() + { + lex.stack[lex.top] = 509 + lex.top++ + goto st517 + } + } + } + case 168: + { + (lex.p) = (lex.te) - 1 + lex.setTokenPosition(tkn) + tok = token.ID(int('"')) + lex.cs = 131 + { + (lex.p)++ + goto _out + } + } + case 169: + { + (lex.p) = (lex.te) - 1 + + lex.setTokenPosition(tkn) + tok = token.T_ENCAPSED_AND_WHITESPACE + { + (lex.p)++ + goto _out + } + } + } + + goto _again + tr768: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:438 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_ENCAPSED_AND_WHITESPACE + { + (lex.p)++ + lex.cs = 509 + goto _out + } + } + goto st509 + tr772: + // line internal/php8/scanner.rl:438 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_ENCAPSED_AND_WHITESPACE + { + (lex.p)++ + lex.cs = 509 + goto _out + } + } + goto st509 + st509: + // line NONE:1 + lex.ts = 0 + + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof509 + } + st_case_509: + // line NONE:1 + lex.ts = (lex.p) + + // line internal/php8/scanner.go:21568 + _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 2338: + goto tr758 + case 2340: + goto st109 + case 2427: + goto st110 + case 2570: + goto tr762 + case 2573: + goto tr763 + case 2594: + goto tr764 + case 2596: + goto st513 + case 2683: + goto st514 + } + if 2560 <= _widec && _widec <= 2815 { + goto tr761 + } + goto st0 + st109: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof109 + } + st_case_109: + switch lex.data[(lex.p)] { + case 96: + goto st0 + case 123: + goto tr161 + } + 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 + } + goto tr160 + st110: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof110 + } + st_case_110: + if lex.data[(lex.p)] == 36 { + goto tr162 + } + goto st0 + tr761: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:438 + lex.act = 169 + goto st510 + tr764: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:437 + lex.act = 168 + goto st510 + tr769: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:438 + lex.act = 169 + goto st510 + tr773: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:436 + lex.act = 167 + goto st510 + tr774: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:435 + lex.act = 166 + goto st510 + tr775: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:434 + lex.act = 165 + goto st510 + st510: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof510 + } + st_case_510: + // line internal/php8/scanner.go:21711 + _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: + goto tr762 + case 2573: + goto tr763 + } + if 2560 <= _widec && _widec <= 2815 { + goto tr761 + } + goto tr767 + tr762: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st511 + tr770: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st511 + st511: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof511 + } + st_case_511: + // line internal/php8/scanner.go:21791 + _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: + goto tr770 + case 2573: + goto tr771 + } + if 2560 <= _widec && _widec <= 2815 { + goto tr769 + } + goto tr768 + tr763: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st512 + tr771: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st512 + st512: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof512 + } + st_case_512: + // line internal/php8/scanner.go:21871 + _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: + goto tr762 + case 2573: + goto tr763 + } + if 2560 <= _widec && _widec <= 2815 { + goto tr761 + } + goto tr772 + st513: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof513 + } + st_case_513: + _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 2399: + goto tr160 + case 2427: + goto tr161 + case 2570: + goto tr762 + case 2573: + goto tr763 + case 2655: + goto tr773 + case 2683: + goto tr774 + } + switch { + case _widec < 2625: + switch { + case _widec < 2401: + if 2369 <= _widec && _widec <= 2394 { + goto tr160 + } + case _widec > 2426: + switch { + case _widec > 2559: + if 2560 <= _widec && _widec <= 2624 { + goto tr761 + } + case _widec >= 2432: + goto tr160 + } + default: + goto tr160 + } + case _widec > 2650: + switch { + case _widec < 2657: + if 2651 <= _widec && _widec <= 2656 { + goto tr761 + } + case _widec > 2682: + switch { + case _widec > 2687: + if 2688 <= _widec && _widec <= 2815 { + goto tr773 + } + case _widec >= 2684: + goto tr761 + } + default: + goto tr773 + } + default: + goto tr773 + } + goto tr772 + st514: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof514 + } + st_case_514: + _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 tr162 + case 2570: + goto tr762 + case 2573: + goto tr763 + case 2596: + goto tr775 + } + if 2560 <= _widec && _widec <= 2815 { + goto tr761 + } + goto tr772 + tr777: + lex.cs = 515 + // line internal/php8/scanner.rl:446 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_END_HEREDOC + lex.cs = 131 + { + (lex.p)++ + goto _out + } + } + goto _again + st515: + // line NONE:1 + lex.ts = 0 + + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof515 + } + st_case_515: + // line NONE:1 + lex.ts = (lex.p) + + // line internal/php8/scanner.go:22098 + if lex.data[(lex.p)] == 96 { + goto st0 + } + switch { + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto st0 + } + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto st0 + } + default: + goto st0 + } + goto st516 + st516: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof516 + } + st_case_516: + if lex.data[(lex.p)] == 96 { + goto tr777 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr777 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr777 + } + case lex.data[(lex.p)] >= 91: + goto tr777 + } + default: + goto tr777 + } + goto st516 + tr163: + // line internal/php8/scanner.rl:466 + (lex.p) = (lex.te) - 1 + { + lex.ungetCnt(1) + { + lex.top-- + lex.cs = lex.stack[lex.top] + goto _again + } + } + goto st517 + tr164: + // line internal/php8/scanner.rl:462 + lex.te = (lex.p) + 1 + { + lex.ungetCnt(1) + lex.setTokenPosition(tkn) + tok = token.T_OBJECT_OPERATOR + { + (lex.p)++ + lex.cs = 517 + goto _out + } + } + goto st517 + tr166: + // line internal/php8/scanner.rl:463 + lex.te = (lex.p) + 1 + { + lex.ungetCnt(1) + lex.setTokenPosition(tkn) + tok = token.T_NULLSAFE_OBJECT_OPERATOR + { + (lex.p)++ + lex.cs = 517 + goto _out + } + } + goto st517 + tr778: + // line internal/php8/scanner.rl:466 + lex.te = (lex.p) + 1 + { + lex.ungetCnt(1) + { + lex.top-- + lex.cs = lex.stack[lex.top] + goto _again + } + } + goto st517 + tr783: + // line internal/php8/scanner.rl:465 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.ID(int('[')) + lex.call(517, 523) + goto _out + } + goto st517 + tr784: + // line internal/php8/scanner.rl:466 + lex.te = (lex.p) + (lex.p)-- + { + lex.ungetCnt(1) + { + lex.top-- + lex.cs = lex.stack[lex.top] + goto _again + } + } + goto st517 + tr786: + // line internal/php8/scanner.rl:461 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_VARIABLE + { + (lex.p)++ + lex.cs = 517 + goto _out + } + } + goto st517 + tr789: + // line internal/php8/scanner.rl:464 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_STRING + { + (lex.p)++ + lex.cs = 517 + goto _out + } + } + goto st517 + st517: + // line NONE:1 + lex.ts = 0 + + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof517 + } + st_case_517: + // line NONE:1 + lex.ts = (lex.p) + + // line internal/php8/scanner.go:22195 + switch lex.data[(lex.p)] { + case 36: + goto st518 + case 45: + goto tr780 + case 63: + goto tr781 + case 91: + goto tr783 + case 96: + goto tr778 + } + switch { + case lex.data[(lex.p)] < 92: + if lex.data[(lex.p)] <= 64 { + goto tr778 + } + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr778 + } + default: + goto tr778 + } + goto st522 + st518: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof518 + } + st_case_518: + if lex.data[(lex.p)] == 96 { + goto tr784 + } + switch { + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto tr784 + } + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr784 + } + default: + goto tr784 + } + goto st519 + st519: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof519 + } + st_case_519: + if lex.data[(lex.p)] == 96 { + goto tr786 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr786 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr786 + } + case lex.data[(lex.p)] >= 91: + goto tr786 + } + default: + goto tr786 + } + goto st519 + tr780: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st520 + st520: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof520 + } + st_case_520: + // line internal/php8/scanner.go:22278 + if lex.data[(lex.p)] == 62 { + goto st111 + } + goto tr784 + st111: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof111 + } + st_case_111: + if lex.data[(lex.p)] == 96 { + goto tr163 + } + switch { + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto tr163 + } + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr163 + } + default: + goto tr163 + } + goto tr164 + tr781: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st521 + st521: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof521 + } + st_case_521: + // line internal/php8/scanner.go:22314 + if lex.data[(lex.p)] == 45 { + goto st112 + } + goto tr784 + st112: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof112 + } + st_case_112: + if lex.data[(lex.p)] == 62 { + goto st113 + } + goto tr163 + st113: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof113 + } + st_case_113: + if lex.data[(lex.p)] == 96 { + goto tr163 + } + switch { + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto tr163 + } + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr163 + } + default: + goto tr163 + } + goto tr166 + st522: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof522 + } + st_case_522: + if lex.data[(lex.p)] == 96 { + goto tr789 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr789 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr789 + } + case lex.data[(lex.p)] >= 91: + goto tr789 + } + default: + goto tr789 + } + goto st522 + tr167: + // line internal/php8/scanner.rl:470 + (lex.p) = (lex.te) - 1 + { + lex.setTokenPosition(tkn) + tok = token.T_NUM_STRING + { + (lex.p)++ + lex.cs = 523 + goto _out + } + } + goto st523 + tr790: + // line internal/php8/scanner.rl:476 + lex.te = (lex.p) + 1 + { + c := lex.data[lex.p] + lex.error(fmt.Sprintf("WARNING: Unexpected character in input: '%c' (ASCII=%d)", c, c)) + } + goto st523 + tr791: + // line internal/php8/scanner.rl:473 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.T_ENCAPSED_AND_WHITESPACE + lex.ret(2) + goto _out + } + goto st523 + tr794: + // line internal/php8/scanner.rl:474 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.ID(int(lex.data[lex.ts])) + { + (lex.p)++ + lex.cs = 523 + goto _out + } + } + goto st523 + tr798: + // line internal/php8/scanner.rl:475 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.ID(int(']')) + lex.ret(2) + goto _out + } + goto st523 + tr799: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:473 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_ENCAPSED_AND_WHITESPACE + lex.ret(2) + goto _out + } + goto st523 + tr800: + // line internal/php8/scanner.rl:476 + lex.te = (lex.p) + (lex.p)-- + { + c := lex.data[lex.p] + lex.error(fmt.Sprintf("WARNING: Unexpected character in input: '%c' (ASCII=%d)", c, c)) + } + goto st523 + tr801: + // line internal/php8/scanner.rl:474 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.ID(int(lex.data[lex.ts])) + { + (lex.p)++ + lex.cs = 523 + goto _out + } + } + goto st523 + tr803: + // line internal/php8/scanner.rl:471 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_VARIABLE + { + (lex.p)++ + lex.cs = 523 + goto _out + } + } + goto st523 + tr804: + // line internal/php8/scanner.rl:470 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_NUM_STRING + { + (lex.p)++ + lex.cs = 523 + goto _out + } + } + goto st523 + tr808: + // line internal/php8/scanner.rl:472 + lex.te = (lex.p) + (lex.p)-- + { + lex.setTokenPosition(tkn) + tok = token.T_STRING + { + (lex.p)++ + lex.cs = 523 + goto _out + } + } + goto st523 + st523: + // line NONE:1 + lex.ts = 0 + + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof523 + } + st_case_523: + // line NONE:1 + lex.ts = (lex.p) + + // line internal/php8/scanner.go:22455 + switch lex.data[(lex.p)] { + case 10: + goto tr792 + case 13: + goto tr793 + case 32: + goto tr791 + case 33: + goto tr794 + case 35: + goto tr791 + case 36: + goto st526 + case 39: + goto tr791 + case 48: + goto tr796 + case 92: + goto tr791 + case 93: + goto tr798 + case 96: + goto tr790 + case 124: + goto tr794 + case 126: + goto tr794 + } + switch { + case lex.data[(lex.p)] < 37: + switch { + case lex.data[(lex.p)] < 9: + if lex.data[(lex.p)] <= 8 { + goto tr790 + } + case lex.data[(lex.p)] > 12: + if 14 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 34 { + goto tr790 + } + default: + goto tr791 + } + case lex.data[(lex.p)] > 47: + switch { + case lex.data[(lex.p)] < 58: + if 49 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr168 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr790 + } + case lex.data[(lex.p)] >= 91: + goto tr794 + } + default: + goto tr794 + } + default: + goto tr794 + } + goto st532 + tr792: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st524 + st524: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof524 + } + st_case_524: + // line internal/php8/scanner.go:22537 + goto tr799 + tr793: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st525 + st525: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof525 + } + st_case_525: + // line internal/php8/scanner.go:22556 + if lex.data[(lex.p)] == 10 { + goto tr792 + } + goto tr800 + st526: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof526 + } + st_case_526: + if lex.data[(lex.p)] == 96 { + goto tr801 + } + switch { + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto tr801 + } + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr801 + } + default: + goto tr801 + } + goto st527 + st527: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof527 + } + st_case_527: + if lex.data[(lex.p)] == 96 { + goto tr803 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr803 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr803 + } + case lex.data[(lex.p)] >= 91: + goto tr803 + } + default: + goto tr803 + } + goto st527 + tr796: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st528 + st528: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof528 + } + st_case_528: + // line internal/php8/scanner.go:22618 + switch lex.data[(lex.p)] { + case 95: + goto st114 + case 98: + goto st115 + case 120: + goto st116 + } + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr168 + } + goto tr804 + tr168: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st529 + st529: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof529 + } + st_case_529: + // line internal/php8/scanner.go:22641 + if lex.data[(lex.p)] == 95 { + goto st114 + } + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr168 + } + goto tr804 + st114: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof114 + } + st_case_114: + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr168 + } + goto tr167 + st115: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof115 + } + st_case_115: + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 49 { + goto tr169 + } + goto tr167 + tr169: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st530 + st530: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof530 + } + st_case_530: + // line internal/php8/scanner.go:22677 + if lex.data[(lex.p)] == 95 { + goto st115 + } + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 49 { + goto tr169 + } + goto tr804 + st116: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof116 + } + st_case_116: + switch { + case lex.data[(lex.p)] < 65: + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr170 + } + case lex.data[(lex.p)] > 70: + if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { + goto tr170 + } + default: + goto tr170 + } + goto tr167 + tr170: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st531 + st531: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof531 + } + st_case_531: + // line internal/php8/scanner.go:22713 + if lex.data[(lex.p)] == 95 { + goto st116 + } + switch { + case lex.data[(lex.p)] < 65: + if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { + goto tr170 + } + case lex.data[(lex.p)] > 70: + if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { + goto tr170 + } + default: + goto tr170 + } + goto tr804 + st532: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof532 + } + st_case_532: + if lex.data[(lex.p)] == 96 { + goto tr808 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr808 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr808 + } + case lex.data[(lex.p)] >= 91: + goto tr808 + } + default: + goto tr808 + } + goto st532 + tr171: + lex.cs = 533 + // line internal/php8/scanner.rl:484 + (lex.p) = (lex.te) - 1 + { + lex.ungetCnt(1) + lex.cs = 131 + } + goto _again + tr173: + lex.cs = 533 + // line internal/php8/scanner.rl:483 + lex.te = (lex.p) + 1 + { + lex.ungetCnt(1) + lex.setTokenPosition(tkn) + tok = token.T_STRING_VARNAME + lex.cs = 131 + { + (lex.p)++ + goto _out + } + } + goto _again + tr809: + lex.cs = 533 + // line internal/php8/scanner.rl:484 + lex.te = (lex.p) + 1 + { + lex.ungetCnt(1) + lex.cs = 131 + } + goto _again + tr811: + lex.cs = 533 + // line internal/php8/scanner.rl:484 + lex.te = (lex.p) + (lex.p)-- + { + lex.ungetCnt(1) + lex.cs = 131 + } + goto _again + st533: + // line NONE:1 + lex.ts = 0 + + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof533 + } + st_case_533: + // line NONE:1 + lex.ts = (lex.p) + + // line internal/php8/scanner.go:22792 + if lex.data[(lex.p)] == 96 { + goto tr809 + } + switch { + case lex.data[(lex.p)] < 91: + if lex.data[(lex.p)] <= 64 { + goto tr809 + } + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr809 + } + default: + goto tr809 + } + goto tr810 + tr810: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st534 + st534: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof534 + } + st_case_534: + // line internal/php8/scanner.go:22819 + switch lex.data[(lex.p)] { + case 91: + goto tr173 + case 96: + goto tr811 + case 125: + goto tr173 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr811 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr811 + } + case lex.data[(lex.p)] >= 92: + goto tr811 + } + default: + goto tr811 + } + goto st117 + st117: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof117 + } + st_case_117: + switch lex.data[(lex.p)] { + case 91: + goto tr173 + case 96: + goto tr171 + case 125: + goto tr173 + } + switch { + case lex.data[(lex.p)] < 58: + if lex.data[(lex.p)] <= 47 { + goto tr171 + } + case lex.data[(lex.p)] > 64: + switch { + case lex.data[(lex.p)] > 94: + if 123 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 127 { + goto tr171 + } + case lex.data[(lex.p)] >= 92: + goto tr171 + } + default: + goto tr171 + } + goto st117 + tr174: + // line internal/php8/scanner.rl:488 + (lex.p) = (lex.te) - 1 + { + lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te) + } + goto st535 + tr812: + lex.cs = 535 + // line internal/php8/scanner.rl:490 + lex.te = (lex.p) + 1 + { + lex.ungetCnt(1) + lex.cs = 131 + } + goto _again + tr815: + lex.cs = 535 + // line internal/php8/scanner.rl:489 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.ID(int('(')) + lex.cs = 539 + { + (lex.p)++ + goto _out + } + } + goto _again + tr816: + // line internal/php8/scanner.rl:488 + lex.te = (lex.p) + (lex.p)-- + { + lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te) + } + goto st535 + tr818: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:488 + lex.te = (lex.p) + (lex.p)-- + { + lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te) + } + goto st535 + tr822: + lex.cs = 535 + // line internal/php8/scanner.rl:490 + lex.te = (lex.p) + (lex.p)-- + { + lex.ungetCnt(1) + lex.cs = 131 + } + goto _again + st535: + // line NONE:1 + lex.ts = 0 + + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof535 + } + st_case_535: + // line NONE:1 + lex.ts = (lex.p) + + // line internal/php8/scanner.go:22926 + switch lex.data[(lex.p)] { + case 10: + goto tr175 + case 13: + goto tr814 + case 32: + goto tr813 + case 40: + goto tr815 + } + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr813 + } + goto tr812 + tr813: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st536 + tr819: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:54 + + goto st536 + st536: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof536 + } + st_case_536: + // line internal/php8/scanner.go:22958 + switch lex.data[(lex.p)] { + case 10: + goto tr175 + case 13: + goto tr817 + case 32: + goto tr813 + } + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr813 + } + goto tr816 + tr175: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st537 + tr820: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st537 + st537: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof537 + } + st_case_537: + // line internal/php8/scanner.go:23008 + switch lex.data[(lex.p)] { + case 10: + goto tr820 + case 13: + goto tr821 + case 32: + goto tr819 + } + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr819 + } + goto tr818 + tr817: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st118 + tr821: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st118 + st118: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof118 + } + st_case_118: + // line internal/php8/scanner.go:23052 + if lex.data[(lex.p)] == 10 { + goto tr175 + } + goto tr174 + tr814: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st538 + st538: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof538 + } + st_case_538: + // line internal/php8/scanner.go:23074 + if lex.data[(lex.p)] == 10 { + goto tr175 + } + goto tr822 + tr176: + // line internal/php8/scanner.rl:494 + (lex.p) = (lex.te) - 1 + { + lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te) + } + goto st539 + tr823: + lex.cs = 539 + // line internal/php8/scanner.rl:496 + lex.te = (lex.p) + 1 + { + lex.ungetCnt(1) + lex.cs = 131 + } + goto _again + tr826: + lex.cs = 539 + // line internal/php8/scanner.rl:495 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.ID(int(')')) + lex.cs = 543 + { + (lex.p)++ + goto _out + } + } + goto _again + tr827: + // line internal/php8/scanner.rl:494 + lex.te = (lex.p) + (lex.p)-- + { + lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te) + } + goto st539 + tr829: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:494 + lex.te = (lex.p) + (lex.p)-- + { + lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te) + } + goto st539 + tr833: + lex.cs = 539 + // line internal/php8/scanner.rl:496 + lex.te = (lex.p) + (lex.p)-- + { + lex.ungetCnt(1) + lex.cs = 131 + } + goto _again + st539: + // line NONE:1 + lex.ts = 0 + + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof539 + } + st_case_539: + // line NONE:1 + lex.ts = (lex.p) + + // line internal/php8/scanner.go:23128 + switch lex.data[(lex.p)] { + case 10: + goto tr177 + case 13: + goto tr825 + case 32: + goto tr824 + case 41: + goto tr826 + } + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr824 + } + goto tr823 + tr824: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st540 + tr830: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:54 + + goto st540 + st540: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof540 + } + st_case_540: + // line internal/php8/scanner.go:23160 + switch lex.data[(lex.p)] { + case 10: + goto tr177 + case 13: + goto tr828 + case 32: + goto tr824 + } + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr824 + } + goto tr827 + tr177: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st541 + tr831: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st541 + st541: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof541 + } + st_case_541: + // line internal/php8/scanner.go:23210 + switch lex.data[(lex.p)] { + case 10: + goto tr831 + case 13: + goto tr832 + case 32: + goto tr830 + } + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr830 + } + goto tr829 + tr828: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st119 + tr832: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st119 + st119: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof119 + } + st_case_119: + // line internal/php8/scanner.go:23254 + if lex.data[(lex.p)] == 10 { + goto tr177 + } + goto tr176 + tr825: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st542 + st542: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof542 + } + st_case_542: + // line internal/php8/scanner.go:23276 + if lex.data[(lex.p)] == 10 { + goto tr177 + } + goto tr833 + tr178: + // line internal/php8/scanner.rl:500 + (lex.p) = (lex.te) - 1 + { + lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te) + } + goto st543 + tr834: + lex.cs = 543 + // line internal/php8/scanner.rl:502 + lex.te = (lex.p) + 1 + { + lex.ungetCnt(1) + lex.cs = 131 + } + goto _again + tr837: + lex.cs = 543 + // line internal/php8/scanner.rl:501 + lex.te = (lex.p) + 1 + { + lex.setTokenPosition(tkn) + tok = token.ID(int(';')) + lex.cs = 547 + { + (lex.p)++ + goto _out + } + } + goto _again + tr838: + // line internal/php8/scanner.rl:500 + lex.te = (lex.p) + (lex.p)-- + { + lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te) + } + goto st543 + tr840: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:500 + lex.te = (lex.p) + (lex.p)-- + { + lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te) + } + goto st543 + tr844: + lex.cs = 543 + // line internal/php8/scanner.rl:502 + lex.te = (lex.p) + (lex.p)-- + { + lex.ungetCnt(1) + lex.cs = 131 + } + goto _again + st543: + // line NONE:1 + lex.ts = 0 + + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof543 + } + st_case_543: + // line NONE:1 + lex.ts = (lex.p) + + // line internal/php8/scanner.go:23330 + switch lex.data[(lex.p)] { + case 10: + goto tr179 + case 13: + goto tr836 + case 32: + goto tr835 + case 59: + goto tr837 + } + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr835 + } + goto tr834 + tr835: + // line NONE:1 + lex.te = (lex.p) + 1 + + goto st544 + tr841: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:54 + + goto st544 + st544: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof544 + } + st_case_544: + // line internal/php8/scanner.go:23362 + switch lex.data[(lex.p)] { + case 10: + goto tr179 + case 13: + goto tr839 + case 32: + goto tr835 + } + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr835 + } + goto tr838 + tr179: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st545 + tr842: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st545 + st545: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof545 + } + st_case_545: + // line internal/php8/scanner.go:23412 + switch lex.data[(lex.p)] { + case 10: + goto tr842 + case 13: + goto tr843 + case 32: + goto tr841 + } + if 9 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 12 { + goto tr841 + } + goto tr840 + tr839: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st120 + tr843: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st120 + st120: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof120 + } + st_case_120: + // line internal/php8/scanner.go:23456 + if lex.data[(lex.p)] == 10 { + goto tr179 + } + goto tr178 + tr836: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st546 + st546: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof546 + } + st_case_546: + // line internal/php8/scanner.go:23478 + if lex.data[(lex.p)] == 10 { + goto tr179 + } + goto tr844 + tr848: + // line NONE:1 + switch lex.act { + case 0: + { + { + goto st0 + } + } + case 196: + { + (lex.p) = (lex.te) - 1 + lex.addFreeFloatingToken(tkn, token.T_HALT_COMPILER, lex.ts, lex.te) + } + } + + goto st547 + tr849: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:506 + lex.te = (lex.p) + (lex.p)-- + { + lex.addFreeFloatingToken(tkn, token.T_HALT_COMPILER, lex.ts, lex.te) + } + goto st547 + tr853: + // line internal/php8/scanner.rl:506 + lex.te = (lex.p) + (lex.p)-- + { + lex.addFreeFloatingToken(tkn, token.T_HALT_COMPILER, lex.ts, lex.te) + } + goto st547 + st547: + // line NONE:1 + lex.ts = 0 + + // line NONE:1 + lex.act = 0 + + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof547 + } + st_case_547: + // line NONE:1 + lex.ts = (lex.p) + + // line internal/php8/scanner.go:23522 + switch lex.data[(lex.p)] { + case 10: + goto tr846 + case 13: + goto tr847 + } + goto tr845 + tr845: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:506 + lex.act = 196 + goto st548 + tr850: + // line NONE:1 + lex.te = (lex.p) + 1 + + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:506 + lex.act = 196 + goto st548 + st548: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof548 + } + st_case_548: + // line internal/php8/scanner.go:23551 + switch lex.data[(lex.p)] { + case 10: + goto tr846 + case 13: + goto tr847 + } + goto tr845 + tr846: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st549 + tr851: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st549 + st549: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof549 + } + st_case_549: + // line internal/php8/scanner.go:23590 + switch lex.data[(lex.p)] { + case 10: + goto tr851 + case 13: + goto tr852 + } + goto tr850 + tr847: + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st550 + tr852: + // line internal/php8/scanner.rl:54 + + // line internal/php8/scanner.rl:38 + + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p + 1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p + 1) + } + + goto st550 + st550: + if (lex.p)++; (lex.p) == (lex.pe) { + goto _test_eof550 + } + st_case_550: + // line internal/php8/scanner.go:23629 + switch lex.data[(lex.p)] { + case 10: + goto tr846 + case 13: + goto tr847 + } + goto tr845 + st_out: + _test_eof121: + lex.cs = 121 + goto _test_eof + _test_eof122: + lex.cs = 122 + goto _test_eof + _test_eof1: + lex.cs = 1 + goto _test_eof + _test_eof123: + lex.cs = 123 + goto _test_eof + _test_eof124: + lex.cs = 124 + goto _test_eof + _test_eof125: + lex.cs = 125 + goto _test_eof + _test_eof126: + lex.cs = 126 + goto _test_eof + _test_eof127: + lex.cs = 127 + goto _test_eof + _test_eof128: + lex.cs = 128 + goto _test_eof + _test_eof129: + lex.cs = 129 + goto _test_eof + _test_eof2: + lex.cs = 2 + goto _test_eof + _test_eof3: + lex.cs = 3 + goto _test_eof + _test_eof4: + lex.cs = 4 + goto _test_eof + _test_eof130: + lex.cs = 130 + goto _test_eof + _test_eof5: + lex.cs = 5 + goto _test_eof + _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_eof6: + lex.cs = 6 + goto _test_eof + _test_eof134: + lex.cs = 134 + goto _test_eof + _test_eof135: + lex.cs = 135 + goto _test_eof + _test_eof136: + lex.cs = 136 + goto _test_eof + _test_eof137: + lex.cs = 137 + goto _test_eof + _test_eof7: + lex.cs = 7 + goto _test_eof + _test_eof8: + lex.cs = 8 + goto _test_eof + _test_eof9: + lex.cs = 9 + goto _test_eof + _test_eof10: + lex.cs = 10 + goto _test_eof + _test_eof138: + lex.cs = 138 + goto _test_eof + _test_eof139: + lex.cs = 139 + goto _test_eof + _test_eof140: + lex.cs = 140 + goto _test_eof + _test_eof141: + lex.cs = 141 + goto _test_eof + _test_eof142: + lex.cs = 142 + goto _test_eof + _test_eof143: + lex.cs = 143 + goto _test_eof + _test_eof144: + lex.cs = 144 + goto _test_eof + _test_eof145: + lex.cs = 145 + goto _test_eof + _test_eof11: + lex.cs = 11 + goto _test_eof + _test_eof12: + lex.cs = 12 + goto _test_eof + _test_eof146: + lex.cs = 146 + goto _test_eof + _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 + _test_eof66: + lex.cs = 66 + goto _test_eof + _test_eof67: + lex.cs = 67 + goto _test_eof + _test_eof147: + lex.cs = 147 + goto _test_eof + _test_eof148: + lex.cs = 148 + goto _test_eof + _test_eof149: + lex.cs = 149 + goto _test_eof + _test_eof150: + lex.cs = 150 + goto _test_eof + _test_eof151: + lex.cs = 151 + goto _test_eof + _test_eof68: + lex.cs = 68 + goto _test_eof + _test_eof152: + lex.cs = 152 + goto _test_eof + _test_eof69: + lex.cs = 69 + goto _test_eof + _test_eof70: + lex.cs = 70 + goto _test_eof + _test_eof153: + lex.cs = 153 + goto _test_eof + _test_eof71: + lex.cs = 71 + goto _test_eof + _test_eof154: + lex.cs = 154 + goto _test_eof + _test_eof72: + lex.cs = 72 + goto _test_eof + _test_eof73: + lex.cs = 73 + goto _test_eof + _test_eof74: + lex.cs = 74 + goto _test_eof + _test_eof155: + lex.cs = 155 + goto _test_eof + _test_eof156: + lex.cs = 156 + goto _test_eof + _test_eof157: + lex.cs = 157 + goto _test_eof + _test_eof75: + lex.cs = 75 + goto _test_eof + _test_eof76: + lex.cs = 76 + goto _test_eof + _test_eof158: + lex.cs = 158 + goto _test_eof + _test_eof77: + lex.cs = 77 + 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_eof78: + lex.cs = 78 + goto _test_eof + _test_eof79: + lex.cs = 79 + goto _test_eof + _test_eof80: + lex.cs = 80 + goto _test_eof + _test_eof81: + lex.cs = 81 + goto _test_eof + _test_eof162: + lex.cs = 162 + goto _test_eof + _test_eof163: + lex.cs = 163 + goto _test_eof + _test_eof82: + lex.cs = 82 + goto _test_eof + _test_eof164: + lex.cs = 164 + goto _test_eof + _test_eof165: + lex.cs = 165 + 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 + _test_eof86: + lex.cs = 86 + goto _test_eof + _test_eof166: + lex.cs = 166 + goto _test_eof + _test_eof87: + lex.cs = 87 + goto _test_eof + _test_eof88: + lex.cs = 88 + goto _test_eof + _test_eof89: + lex.cs = 89 + goto _test_eof + _test_eof90: + lex.cs = 90 + 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 + _test_eof91: + lex.cs = 91 + goto _test_eof + _test_eof173: + lex.cs = 173 + goto _test_eof + _test_eof174: + lex.cs = 174 + goto _test_eof + _test_eof92: + lex.cs = 92 + 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_eof93: + lex.cs = 93 + goto _test_eof + _test_eof178: + lex.cs = 178 + goto _test_eof + _test_eof179: + lex.cs = 179 + goto _test_eof + _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_eof94: + lex.cs = 94 + goto _test_eof + _test_eof95: + lex.cs = 95 + 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_eof96: + lex.cs = 96 + 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 + _test_eof389: + lex.cs = 389 + goto _test_eof + _test_eof390: + lex.cs = 390 + goto _test_eof + _test_eof391: + lex.cs = 391 + goto _test_eof + _test_eof392: + lex.cs = 392 + goto _test_eof + _test_eof393: + lex.cs = 393 + goto _test_eof + _test_eof394: + lex.cs = 394 + goto _test_eof + _test_eof395: + lex.cs = 395 + goto _test_eof + _test_eof396: + lex.cs = 396 + goto _test_eof + _test_eof397: + lex.cs = 397 + goto _test_eof + _test_eof398: + lex.cs = 398 + goto _test_eof + _test_eof399: + lex.cs = 399 + 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_eof97: + lex.cs = 97 + goto _test_eof + _test_eof98: + lex.cs = 98 + goto _test_eof + _test_eof99: + lex.cs = 99 + goto _test_eof + _test_eof100: + lex.cs = 100 + goto _test_eof + _test_eof101: + lex.cs = 101 + goto _test_eof + _test_eof102: + lex.cs = 102 + goto _test_eof + _test_eof416: + lex.cs = 416 + goto _test_eof + _test_eof417: + lex.cs = 417 + goto _test_eof + _test_eof103: + lex.cs = 103 + 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 + _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 + _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 + _test_eof485: + lex.cs = 485 + goto _test_eof + _test_eof486: + lex.cs = 486 + goto _test_eof + _test_eof487: + lex.cs = 487 + goto _test_eof + _test_eof104: + lex.cs = 104 + 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 + _test_eof105: + lex.cs = 105 + goto _test_eof + _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_eof106: + lex.cs = 106 + 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 + _test_eof502: + lex.cs = 502 + goto _test_eof + _test_eof503: + lex.cs = 503 + goto _test_eof + _test_eof107: + lex.cs = 107 + goto _test_eof + _test_eof108: + lex.cs = 108 + goto _test_eof + _test_eof504: + lex.cs = 504 + goto _test_eof + _test_eof505: + lex.cs = 505 + 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 + _test_eof109: + lex.cs = 109 + goto _test_eof + _test_eof110: + lex.cs = 110 + goto _test_eof + _test_eof510: + lex.cs = 510 + goto _test_eof + _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 + _test_eof515: + lex.cs = 515 + goto _test_eof + _test_eof516: + lex.cs = 516 + goto _test_eof + _test_eof517: + lex.cs = 517 + goto _test_eof + _test_eof518: + lex.cs = 518 + goto _test_eof + _test_eof519: + lex.cs = 519 + goto _test_eof + _test_eof520: + lex.cs = 520 + goto _test_eof + _test_eof111: + lex.cs = 111 + goto _test_eof + _test_eof521: + lex.cs = 521 + goto _test_eof + _test_eof112: + lex.cs = 112 + goto _test_eof + _test_eof113: + lex.cs = 113 + goto _test_eof + _test_eof522: + lex.cs = 522 + goto _test_eof + _test_eof523: + lex.cs = 523 + goto _test_eof + _test_eof524: + lex.cs = 524 + goto _test_eof + _test_eof525: + lex.cs = 525 + goto _test_eof + _test_eof526: + lex.cs = 526 + goto _test_eof + _test_eof527: + lex.cs = 527 + goto _test_eof + _test_eof528: + lex.cs = 528 + goto _test_eof + _test_eof529: + lex.cs = 529 + goto _test_eof + _test_eof114: + lex.cs = 114 + goto _test_eof + _test_eof115: + lex.cs = 115 + goto _test_eof + _test_eof530: + lex.cs = 530 + goto _test_eof + _test_eof116: + lex.cs = 116 + goto _test_eof + _test_eof531: + lex.cs = 531 + goto _test_eof + _test_eof532: + lex.cs = 532 + goto _test_eof + _test_eof533: + lex.cs = 533 + goto _test_eof + _test_eof534: + lex.cs = 534 + goto _test_eof + _test_eof117: + lex.cs = 117 + goto _test_eof + _test_eof535: + lex.cs = 535 + goto _test_eof + _test_eof536: + lex.cs = 536 + goto _test_eof + _test_eof537: + lex.cs = 537 + goto _test_eof + _test_eof118: + lex.cs = 118 + goto _test_eof + _test_eof538: + lex.cs = 538 + goto _test_eof + _test_eof539: + lex.cs = 539 + goto _test_eof + _test_eof540: + lex.cs = 540 + goto _test_eof + _test_eof541: + lex.cs = 541 + goto _test_eof + _test_eof119: + lex.cs = 119 + goto _test_eof + _test_eof542: + lex.cs = 542 + goto _test_eof + _test_eof543: + lex.cs = 543 + goto _test_eof + _test_eof544: + lex.cs = 544 + goto _test_eof + _test_eof545: + lex.cs = 545 + goto _test_eof + _test_eof120: + lex.cs = 120 + goto _test_eof + _test_eof546: + lex.cs = 546 + goto _test_eof + _test_eof547: + lex.cs = 547 + goto _test_eof + _test_eof548: + lex.cs = 548 + goto _test_eof + _test_eof549: + lex.cs = 549 + goto _test_eof + _test_eof550: + lex.cs = 550 + goto _test_eof + + _test_eof: + { + } + if (lex.p) == eof { + switch lex.cs { + case 122: + goto tr182 + case 1: + goto tr0 + case 123: + goto tr183 + case 125: + goto tr188 + case 126: + goto tr190 + case 127: + goto tr188 + case 128: + goto tr188 + case 129: + goto tr196 + case 2: + goto tr4 + case 3: + goto tr4 + case 4: + goto tr4 + case 130: + goto tr199 + case 5: + goto tr4 + case 132: + goto tr253 + case 133: + goto tr255 + case 6: + goto tr10 + case 134: + goto tr259 + case 135: + goto tr260 + case 136: + goto tr262 + case 137: + goto tr264 + case 7: + goto tr12 + case 8: + goto tr12 + case 9: + goto tr12 + case 10: + goto tr12 + case 138: + goto tr265 + case 139: + goto tr268 + case 140: + goto tr271 + case 141: + goto tr260 + case 142: + goto tr276 + case 143: + goto tr260 + case 144: + goto tr260 + case 145: + goto tr259 + case 11: + goto tr19 + case 12: + goto tr19 + case 146: + goto tr260 + case 13: + goto tr23 + case 14: + goto tr23 + case 15: + goto tr23 + case 16: + goto tr23 + case 17: + goto tr23 + case 18: + goto tr23 + case 19: + goto tr23 + case 20: + goto tr23 + case 21: + goto tr23 + case 22: + goto tr23 + case 23: + goto tr23 + case 24: + goto tr23 + case 25: + goto tr23 + case 26: + goto tr23 + case 27: + goto tr23 + case 28: + goto tr23 + case 29: + goto tr23 + case 30: + goto tr23 + case 31: + goto tr23 + case 32: + goto tr23 + case 33: + goto tr23 + case 34: + goto tr23 + case 35: + goto tr23 + case 36: + goto tr23 + case 37: + goto tr23 + case 38: + goto tr23 + case 39: + goto tr23 + case 40: + goto tr23 + case 41: + goto tr23 + case 42: + goto tr23 + case 43: + goto tr23 + case 44: + goto tr23 + case 45: + goto tr23 + case 46: + goto tr23 + case 47: + goto tr23 + case 48: + goto tr23 + case 49: + goto tr23 + case 50: + goto tr23 + case 51: + goto tr23 + case 52: + goto tr23 + case 53: + goto tr23 + case 54: + goto tr23 + case 55: + goto tr23 + case 56: + goto tr23 + case 57: + goto tr23 + case 58: + goto tr23 + case 59: + goto tr23 + case 60: + goto tr23 + case 61: + goto tr23 + case 62: + goto tr23 + case 63: + goto tr23 + case 64: + goto tr23 + case 65: + goto tr23 + case 66: + goto tr23 + case 67: + goto tr23 + case 147: + goto tr260 + case 148: + goto tr282 + case 149: + goto tr260 + case 150: + goto tr260 + case 151: + goto tr260 + case 68: + goto tr23 + case 152: + goto tr291 + case 69: + goto tr12 + case 70: + goto tr12 + case 153: + goto tr291 + case 71: + goto tr90 + case 154: + goto tr260 + case 72: + goto tr23 + case 73: + goto tr23 + case 74: + goto tr23 + case 155: + goto tr295 + case 156: + goto tr291 + case 157: + goto tr295 + case 75: + goto tr101 + case 76: + goto tr12 + case 158: + goto tr300 + case 77: + goto tr12 + case 159: + goto tr301 + case 160: + goto tr260 + case 161: + goto tr260 + case 78: + goto tr23 + case 79: + goto tr23 + case 80: + goto tr23 + case 81: + goto tr23 + case 162: + goto tr303 + case 163: + goto tr305 + case 82: + goto tr114 + case 164: + goto tr260 + case 165: + goto tr309 + case 83: + goto tr12 + case 84: + goto tr12 + case 85: + goto tr12 + case 86: + goto tr12 + case 166: + goto tr311 + case 87: + goto tr12 + case 88: + goto tr12 + case 89: + goto tr12 + case 90: + goto tr12 + case 167: + goto tr312 + case 168: + goto tr260 + case 169: + goto tr316 + case 170: + goto tr260 + case 171: + goto tr320 + case 172: + goto tr260 + case 91: + goto tr23 + case 173: + goto tr325 + case 174: + goto tr327 + case 92: + goto tr131 + case 175: + goto tr328 + case 176: + goto tr330 + case 177: + goto tr12 + case 93: + goto tr12 + case 178: + goto tr336 + case 179: + goto tr330 + case 180: + goto tr330 + case 181: + goto tr330 + case 182: + goto tr330 + case 183: + goto tr330 + case 184: + goto tr330 + case 185: + goto tr330 + case 186: + goto tr330 + case 187: + goto tr330 + case 188: + goto tr330 + case 189: + goto tr330 + case 94: + goto tr134 + case 95: + goto tr134 + case 190: + goto tr330 + case 191: + goto tr330 + case 192: + goto tr330 + case 193: + goto tr330 + case 194: + goto tr330 + case 195: + goto tr330 + case 196: + goto tr330 + case 197: + goto tr330 + case 198: + goto tr330 + case 199: + goto tr330 + case 200: + goto tr330 + case 201: + goto tr330 + case 202: + goto tr330 + case 203: + goto tr330 + case 204: + goto tr330 + case 205: + goto tr330 + case 206: + goto tr330 + case 207: + goto tr330 + case 208: + goto tr330 + case 209: + goto tr330 + case 210: + goto tr330 + case 211: + goto tr330 + case 212: + goto tr330 + case 213: + goto tr330 + case 214: + goto tr330 + case 215: + goto tr330 + case 216: + goto tr330 + case 217: + goto tr330 + case 218: + goto tr330 + case 219: + goto tr330 + case 220: + goto tr330 + case 221: + goto tr330 + case 222: + goto tr330 + case 223: + goto tr330 + case 224: + goto tr330 + case 225: + goto tr330 + case 226: + goto tr330 + case 227: + goto tr330 + case 228: + goto tr330 + case 229: + goto tr330 + case 230: + goto tr330 + case 231: + goto tr330 + case 232: + goto tr330 + case 233: + goto tr330 + case 234: + goto tr330 + case 235: + goto tr330 + case 236: + goto tr330 + case 237: + goto tr330 + case 238: + goto tr412 + case 239: + goto tr330 + case 240: + goto tr330 + case 241: + goto tr330 + case 242: + goto tr330 + case 243: + goto tr330 + case 244: + goto tr330 + case 245: + goto tr330 + case 246: + goto tr330 + case 247: + goto tr330 + case 248: + goto tr330 + case 249: + goto tr330 + case 250: + goto tr330 + case 251: + goto tr330 + case 252: + goto tr330 + case 253: + goto tr432 + case 254: + goto tr330 + case 255: + goto tr330 + case 256: + goto tr330 + case 257: + goto tr330 + case 258: + goto tr330 + case 259: + goto tr330 + case 260: + goto tr330 + case 261: + goto tr330 + case 262: + goto tr330 + case 263: + goto tr330 + case 264: + goto tr330 + case 265: + goto tr330 + case 266: + goto tr330 + case 267: + goto tr330 + case 268: + goto tr330 + case 269: + goto tr330 + case 270: + goto tr330 + case 271: + goto tr330 + case 272: + goto tr330 + case 273: + goto tr330 + case 274: + goto tr330 + case 275: + goto tr330 + case 276: + goto tr330 + case 277: + goto tr330 + case 278: + goto tr330 + case 279: + goto tr461 + case 280: + goto tr330 + case 281: + goto tr330 + case 282: + goto tr465 + case 283: + goto tr330 + case 284: + goto tr330 + case 285: + goto tr330 + case 286: + goto tr330 + case 287: + goto tr330 + case 288: + goto tr330 + case 289: + goto tr330 + case 290: + goto tr330 + case 291: + goto tr330 + case 292: + goto tr330 + case 293: + goto tr330 + case 294: + goto tr330 + case 295: + goto tr330 + case 296: + goto tr330 + case 297: + goto tr330 + case 298: + goto tr330 + case 299: + goto tr330 + case 300: + goto tr330 + case 301: + goto tr330 + case 302: + goto tr330 + case 303: + goto tr330 + case 304: + goto tr330 + case 305: + goto tr330 + case 306: + goto tr330 + case 307: + goto tr497 + case 308: + goto tr330 + case 309: + goto tr330 + case 310: + goto tr330 + case 311: + goto tr330 + case 312: + goto tr330 + case 313: + goto tr330 + case 314: + goto tr330 + case 315: + goto tr330 + case 316: + goto tr330 + case 317: + goto tr330 + case 318: + goto tr330 + case 319: + goto tr330 + case 320: + goto tr330 + case 321: + goto tr330 + case 322: + goto tr330 + case 323: + goto tr330 + case 324: + goto tr330 + case 325: + goto tr330 + case 326: + goto tr330 + case 327: + goto tr330 + case 328: + goto tr330 + case 329: + goto tr330 + case 330: + goto tr330 + case 331: + goto tr330 + case 332: + goto tr330 + case 333: + goto tr330 + case 334: + goto tr330 + case 335: + goto tr330 + case 336: + goto tr330 + case 337: + goto tr330 + case 338: + goto tr330 + case 339: + goto tr330 + case 340: + goto tr330 + case 341: + goto tr330 + case 342: + goto tr330 + case 343: + goto tr330 + case 344: + goto tr330 + case 345: + goto tr330 + case 346: + goto tr330 + case 347: + goto tr540 + case 96: + goto tr12 + case 348: + goto tr542 + case 349: + goto tr330 + case 350: + goto tr330 + case 351: + goto tr330 + case 352: + goto tr330 + case 353: + goto tr330 + case 354: + goto tr330 + case 355: + goto tr330 + case 356: + goto tr330 + case 357: + goto tr330 + case 358: + goto tr330 + case 359: + goto tr330 + case 360: + goto tr330 + case 361: + goto tr330 + case 362: + goto tr330 + case 363: + goto tr330 + case 364: + goto tr330 + case 365: + goto tr330 + case 366: + goto tr330 + case 367: + goto tr330 + case 368: + goto tr330 + case 369: + goto tr330 + case 370: + goto tr330 + case 371: + goto tr330 + case 372: + goto tr330 + case 373: + goto tr330 + case 374: + goto tr572 + case 375: + goto tr330 + case 376: + goto tr330 + case 377: + goto tr330 + case 378: + goto tr330 + case 379: + goto tr330 + case 380: + goto tr330 + case 381: + goto tr330 + case 382: + goto tr330 + case 383: + goto tr330 + case 384: + goto tr330 + case 385: + goto tr330 + case 386: + goto tr330 + case 387: + goto tr330 + case 388: + goto tr330 + case 389: + goto tr330 + case 390: + goto tr330 + case 391: + goto tr330 + case 392: + goto tr330 + case 393: + goto tr330 + case 394: + goto tr330 + case 395: + goto tr330 + case 396: + goto tr330 + case 397: + goto tr330 + case 398: + goto tr330 + case 399: + goto tr330 + case 400: + goto tr330 + case 401: + goto tr330 + case 402: + goto tr330 + case 403: + goto tr330 + case 404: + goto tr330 + case 405: + goto tr330 + case 406: + goto tr330 + case 407: + goto tr330 + case 408: + goto tr330 + case 409: + goto tr330 + case 410: + goto tr330 + case 411: + goto tr330 + case 412: + goto tr330 + case 413: + goto tr330 + case 414: + goto tr330 + case 415: + goto tr618 + case 97: + goto tr137 + case 98: + goto tr137 + case 99: + goto tr137 + case 100: + goto tr137 + case 101: + goto tr137 + case 102: + goto tr137 + case 416: + goto tr619 + case 417: + goto tr620 + case 103: + goto tr149 + case 418: + goto tr260 + case 419: + goto tr330 + case 420: + goto tr330 + case 421: + goto tr330 + case 422: + goto tr330 + case 423: + goto tr330 + case 424: + goto tr330 + case 425: + goto tr330 + case 426: + goto tr330 + case 427: + goto tr330 + case 428: + goto tr330 + case 429: + goto tr330 + case 430: + goto tr330 + case 431: + goto tr330 + case 432: + goto tr330 + case 433: + goto tr330 + case 434: + goto tr330 + case 435: + goto tr330 + case 436: + goto tr330 + case 437: + goto tr330 + case 438: + goto tr330 + case 439: + goto tr330 + case 440: + goto tr330 + case 441: + goto tr330 + case 442: + goto tr330 + case 443: + goto tr330 + case 444: + goto tr330 + case 445: + goto tr330 + case 446: + goto tr330 + case 447: + goto tr330 + case 448: + goto tr330 + case 449: + goto tr330 + case 450: + goto tr330 + case 451: + goto tr330 + case 452: + goto tr330 + case 453: + goto tr330 + case 454: + goto tr330 + case 455: + goto tr330 + case 456: + goto tr330 + case 457: + goto tr330 + case 458: + goto tr330 + case 459: + goto tr330 + case 460: + goto tr330 + case 461: + goto tr330 + case 462: + goto tr330 + case 463: + goto tr330 + case 464: + goto tr330 + case 465: + goto tr330 + case 466: + goto tr330 + case 467: + goto tr330 + case 468: + goto tr330 + case 469: + goto tr330 + case 470: + goto tr330 + case 471: + goto tr330 + case 472: + goto tr330 + case 473: + goto tr330 + case 474: + goto tr330 + case 475: + goto tr330 + case 476: + goto tr330 + case 477: + goto tr330 + case 478: + goto tr330 + case 479: + goto tr330 + case 480: + goto tr330 + case 481: + goto tr330 + case 482: + goto tr330 + case 483: + goto tr330 + case 484: + goto tr260 + case 486: + goto tr704 + case 487: + goto tr706 + case 104: + goto tr151 + case 488: + goto tr710 + case 489: + goto tr710 + case 490: + goto tr710 + case 105: + goto tr153 + case 491: + goto tr713 + case 493: + goto tr717 + case 494: + goto tr718 + case 495: + goto tr722 + case 497: + goto tr730 + case 498: + goto tr732 + case 499: + goto tr733 + case 500: + goto tr737 + case 501: + goto tr730 + case 502: + goto tr737 + case 504: + goto tr749 + case 505: + goto tr750 + case 506: + goto tr754 + case 507: + goto tr754 + case 508: + goto tr754 + case 510: + goto tr767 + case 511: + goto tr768 + case 512: + goto tr772 + case 513: + goto tr772 + case 514: + goto tr772 + case 516: + goto tr777 + case 518: + goto tr784 + case 519: + goto tr786 + case 520: + goto tr784 + case 111: + goto tr163 + case 521: + goto tr784 + case 112: + goto tr163 + case 113: + goto tr163 + case 522: + goto tr789 + case 524: + goto tr799 + case 525: + goto tr800 + case 526: + goto tr801 + case 527: + goto tr803 + case 528: + goto tr804 + case 529: + goto tr804 + case 114: + goto tr167 + case 115: + goto tr167 + case 530: + goto tr804 + case 116: + goto tr167 + case 531: + goto tr804 + case 532: + goto tr808 + case 534: + goto tr811 + case 117: + goto tr171 + case 536: + goto tr816 + case 537: + goto tr818 + case 118: + goto tr174 + case 538: + goto tr822 + case 540: + goto tr827 + case 541: + goto tr829 + case 119: + goto tr176 + case 542: + goto tr833 + case 544: + goto tr838 + case 545: + goto tr840 + case 120: + goto tr178 + case 546: + goto tr844 + case 548: + goto tr848 + case 549: + goto tr849 + case 550: + goto tr853 + } + } + + _out: + { + } + } + + // line internal/php8/scanner.rl:510 + + tkn.Value = lex.data[lex.ts:lex.te] + tkn.ID = token.ID(tok) + + return tkn +} diff --git a/internal/php8/scanner.rl b/internal/php8/scanner.rl new file mode 100644 index 0000000..8fc88ce --- /dev/null +++ b/internal/php8/scanner.rl @@ -0,0 +1,516 @@ +package php8 + +import ( + "fmt" + "strconv" + "strings" + + "github.com/z7zmey/php-parser/pkg/token" +) + +%%{ + machine lexer; + write data; + access lex.; + variable p lex.p; + variable pe lex.pe; +}%% + +func initLexer(lex *Lexer) { + %% write init; +} + +func (lex *Lexer) Lex() *token.Token { + eof := lex.pe + var tok token.ID + + tkn := lex.tokenPool.Get() + + lblStart := 0 + lblEnd := 0 + + _, _ = lblStart, lblEnd + + %%{ + action heredoc_lbl_start {lblStart = lex.p} + action heredoc_lbl_end {lblEnd = lex.p} + + action new_line { + if lex.data[lex.p] == '\n' { + lex.newLines.Append(lex.p+1) + } + + if lex.data[lex.p] == '\r' && lex.data[lex.p+1] != '\n' { + lex.newLines.Append(lex.p+1) + } + } + + action is_not_heredoc_end { lex.isNotHeredocEnd(lex.p) } + action is_not_comment_end { lex.isNotPhpCloseToken() && lex.isNotNewLine() } + action is_not_heredoc_end_or_var { lex.isNotHeredocEnd(lex.p) && lex.isNotStringVar() } + action is_not_string_end_or_var { lex.isNotStringEnd('"') && lex.isNotStringVar() } + action is_not_backqoute_end_or_var { lex.isNotStringEnd('`') && lex.isNotStringVar() } + + newline = ('\r\n' >(nl, 1) | '\r' >(nl, 0) | '\n' >(nl, 0)) $new_line %{}; + any_line = any | newline; + whitespace = [\t\v\f ]; + whitespace_line = [\t\v\f ] | newline; + + lnum = [0-9]+('_'[0-9]+)*; + dnum = (lnum?"." lnum)|(lnum"."lnum?); + hnum = '0x'[0-9a-fA-F]+('_'[0-9a-fA-F]+)*; + bnum = '0b'[01]+('_'[01]+)*; + + exponent_dnum = (lnum | dnum) ('e'|'E') ('+'|'-')? lnum; + varname_first = [a-zA-Z_] | (0x0080..0x00FF); + varname_second = varname_first | [0-9]; + varname = varname_first (varname_second)*; + heredoc_label = varname >heredoc_lbl_start %heredoc_lbl_end; + operators = ';'|':'|','|'.'|'['|']'|'('|')'|'|'|'/'|'^'|'&'|'+'|'-'|'*'|'='|'%'|'!'|'~'|'$'|'<'|'>'|'?'|'@'; + + prepush { lex.growCallStack(); } + + constant_string = + start: ( + "'" -> qoute + | "b"i? '"' -> double_qoute + ), + + # single qoute string + + qoute: ( + (any - [\\'\r\n]) -> qoute + | "\r" @new_line -> qoute + | "\n" @new_line -> qoute + | "\\" -> qoute_any + | "'" -> final + ), + qoute_any: ( + (any - [\r\n]) -> qoute + | "\r" @new_line -> qoute + | "\n" @new_line -> qoute + ), + + # double qoute string + + double_qoute: ( + (any - [\\"${\r\n]) -> double_qoute + | "\r" @new_line -> double_qoute + | "\n" @new_line -> double_qoute + | "\\" -> double_qoute_any + | '"' -> final + | '$' -> double_qoute_nonvarname + | '{' -> double_qoute_nondollar + ), + double_qoute_any: ( + (any - [\r\n]) -> double_qoute + | "\r" @new_line -> double_qoute + | "\n" @new_line -> double_qoute + ), + double_qoute_nondollar: ( + (any - [\\$"\r\n]) -> double_qoute + | "\r" @new_line -> double_qoute + | "\n" @new_line -> double_qoute + | "\\" -> double_qoute_any + | '"' -> final + ), + double_qoute_nonvarname: ( + (any - [\\${"\r\n] - varname_first) -> double_qoute + | "\r" @new_line -> double_qoute + | "\n" @new_line -> double_qoute + | "\\" -> double_qoute_any + | '$' -> double_qoute_nonvarname + | '"' -> final + ); + + main := |* + "#!" any* :>> newline => { + lex.addFreeFloatingToken(tkn, token.T_COMMENT, lex.ts, lex.te) + }; + any => { + fnext html; + lex.ungetCnt(1) + }; + *|; + + html := |* + any_line+ -- ' { + lex.ungetStr("<") + lex.setTokenPosition(tkn) + tok = token.T_INLINE_HTML; + fbreak; + }; + ' { + lex.addFreeFloatingToken(tkn, token.T_OPEN_TAG, lex.ts, lex.te) + fnext php; + }; + ' { + lex.ungetCnt(lex.te - lex.ts - 5) + lex.addFreeFloatingToken(tkn, token.T_OPEN_TAG, lex.ts, lex.ts+5) + fnext php; + }; + ' { + lex.setTokenPosition(tkn); + tok = token.T_ECHO; + fnext php; + fbreak; + }; + *|; + + php := |* + whitespace_line* => {lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te)}; + '?>' newline? => {lex.setTokenPosition(tkn); tok = token.ID(int(';')); fnext html; fbreak;}; + ';' whitespace_line* '?>' newline? => {lex.setTokenPosition(tkn); tok = token.ID(int(';')); fnext html; fbreak;}; + + (dnum | exponent_dnum) => {lex.setTokenPosition(tkn); tok = token.T_DNUMBER; fbreak;}; + bnum => { + s := strings.Replace(string(lex.data[lex.ts+2:lex.te]), "_", "", -1) + _, err := strconv.ParseInt(s, 2, 0) + + if err == nil { + lex.setTokenPosition(tkn); tok = token.T_LNUMBER; fbreak; + } + + lex.setTokenPosition(tkn); tok = token.T_DNUMBER; fbreak; + }; + lnum => { + 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 { + lex.setTokenPosition(tkn); tok = token.T_LNUMBER; fbreak; + } + + lex.setTokenPosition(tkn); tok = token.T_DNUMBER; fbreak; + }; + hnum => { + s := strings.Replace(string(lex.data[lex.ts+2:lex.te]), "_", "", -1) + _, err := strconv.ParseInt(s, 16, 0) + + if err == nil { + lex.setTokenPosition(tkn); tok = token.T_LNUMBER; fbreak; + } + + lex.setTokenPosition(tkn); tok = token.T_DNUMBER; fbreak; + }; + + 'namespace'i ('\\' varname)+ => {lex.setTokenPosition(tkn); tok = token.T_NAME_RELATIVE; fbreak;}; + varname ('\\' varname)+ => {lex.setTokenPosition(tkn); tok = token.T_NAME_QUALIFIED; fbreak;}; + '\\' varname ('\\' varname)* => {lex.setTokenPosition(tkn); tok = token.T_NAME_FULLY_QUALIFIED; fbreak;}; + '\\' => {lex.setTokenPosition(tkn); tok = token.T_NS_SEPARATOR; fbreak;}; + + 'abstract'i => {lex.setTokenPosition(tkn); tok = token.T_ABSTRACT; fbreak;}; + 'array'i => {lex.setTokenPosition(tkn); tok = token.T_ARRAY; fbreak;}; + 'as'i => {lex.setTokenPosition(tkn); tok = token.T_AS; fbreak;}; + 'break'i => {lex.setTokenPosition(tkn); tok = token.T_BREAK; fbreak;}; + 'callable'i => {lex.setTokenPosition(tkn); tok = token.T_CALLABLE; fbreak;}; + 'case'i => {lex.setTokenPosition(tkn); tok = token.T_CASE; fbreak;}; + 'catch'i => {lex.setTokenPosition(tkn); tok = token.T_CATCH; fbreak;}; + 'class'i => {lex.setTokenPosition(tkn); tok = token.T_CLASS; fbreak;}; + 'clone'i => {lex.setTokenPosition(tkn); tok = token.T_CLONE; fbreak;}; + 'const'i => {lex.setTokenPosition(tkn); tok = token.T_CONST; fbreak;}; + 'continue'i => {lex.setTokenPosition(tkn); tok = token.T_CONTINUE; fbreak;}; + 'declare'i => {lex.setTokenPosition(tkn); tok = token.T_DECLARE; fbreak;}; + 'default'i => {lex.setTokenPosition(tkn); tok = token.T_DEFAULT; fbreak;}; + 'do'i => {lex.setTokenPosition(tkn); tok = token.T_DO; fbreak;}; + 'echo'i => {lex.setTokenPosition(tkn); tok = token.T_ECHO; fbreak;}; + 'else'i => {lex.setTokenPosition(tkn); tok = token.T_ELSE; fbreak;}; + 'elseif'i => {lex.setTokenPosition(tkn); tok = token.T_ELSEIF; fbreak;}; + 'empty'i => {lex.setTokenPosition(tkn); tok = token.T_EMPTY; fbreak;}; + 'enddeclare'i => {lex.setTokenPosition(tkn); tok = token.T_ENDDECLARE; fbreak;}; + 'endfor'i => {lex.setTokenPosition(tkn); tok = token.T_ENDFOR; fbreak;}; + 'endforeach'i => {lex.setTokenPosition(tkn); tok = token.T_ENDFOREACH; fbreak;}; + 'endif'i => {lex.setTokenPosition(tkn); tok = token.T_ENDIF; fbreak;}; + 'endswitch'i => {lex.setTokenPosition(tkn); tok = token.T_ENDSWITCH; fbreak;}; + 'endwhile'i => {lex.setTokenPosition(tkn); tok = token.T_ENDWHILE; fbreak;}; + 'eval'i => {lex.setTokenPosition(tkn); tok = token.T_EVAL; fbreak;}; + 'exit'i | 'die'i => {lex.setTokenPosition(tkn); tok = token.T_EXIT; fbreak;}; + 'extends'i => {lex.setTokenPosition(tkn); tok = token.T_EXTENDS; fbreak;}; + 'final'i => {lex.setTokenPosition(tkn); tok = token.T_FINAL; fbreak;}; + 'finally'i => {lex.setTokenPosition(tkn); tok = token.T_FINALLY; fbreak;}; + 'for'i => {lex.setTokenPosition(tkn); tok = token.T_FOR; fbreak;}; + 'foreach'i => {lex.setTokenPosition(tkn); tok = token.T_FOREACH; fbreak;}; + 'function'i | 'cfunction'i => {lex.setTokenPosition(tkn); tok = token.T_FUNCTION; fbreak;}; + 'fn'i => {lex.setTokenPosition(tkn); tok = token.T_FN; fbreak;}; + 'global'i => {lex.setTokenPosition(tkn); tok = token.T_GLOBAL; fbreak;}; + 'goto'i => {lex.setTokenPosition(tkn); tok = token.T_GOTO; fbreak;}; + 'if'i => {lex.setTokenPosition(tkn); tok = token.T_IF; fbreak;}; + 'isset'i => {lex.setTokenPosition(tkn); tok = token.T_ISSET; fbreak;}; + 'implements'i => {lex.setTokenPosition(tkn); tok = token.T_IMPLEMENTS; fbreak;}; + 'instanceof'i => {lex.setTokenPosition(tkn); tok = token.T_INSTANCEOF; fbreak;}; + 'insteadof'i => {lex.setTokenPosition(tkn); tok = token.T_INSTEADOF; fbreak;}; + 'interface'i => {lex.setTokenPosition(tkn); tok = token.T_INTERFACE; fbreak;}; + 'list'i => {lex.setTokenPosition(tkn); tok = token.T_LIST; fbreak;}; + 'namespace'i => {lex.setTokenPosition(tkn); tok = token.T_NAMESPACE; fbreak;}; + 'private'i => {lex.setTokenPosition(tkn); tok = token.T_PRIVATE; fbreak;}; + 'public'i => {lex.setTokenPosition(tkn); tok = token.T_PUBLIC; fbreak;}; + 'print'i => {lex.setTokenPosition(tkn); tok = token.T_PRINT; fbreak;}; + 'protected'i => {lex.setTokenPosition(tkn); tok = token.T_PROTECTED; fbreak;}; + 'return'i => {lex.setTokenPosition(tkn); tok = token.T_RETURN; fbreak;}; + 'static'i => {lex.setTokenPosition(tkn); tok = token.T_STATIC; fbreak;}; + 'switch'i => {lex.setTokenPosition(tkn); tok = token.T_SWITCH; fbreak;}; + 'match'i => {lex.setTokenPosition(tkn); tok = token.T_MATCH; fbreak;}; + 'throw'i => {lex.setTokenPosition(tkn); tok = token.T_THROW; fbreak;}; + 'trait'i => {lex.setTokenPosition(tkn); tok = token.T_TRAIT; fbreak;}; + 'try'i => {lex.setTokenPosition(tkn); tok = token.T_TRY; fbreak;}; + 'unset'i => {lex.setTokenPosition(tkn); tok = token.T_UNSET; fbreak;}; + 'use'i => {lex.setTokenPosition(tkn); tok = token.T_USE; fbreak;}; + 'var'i => {lex.setTokenPosition(tkn); tok = token.T_VAR; fbreak;}; + 'while'i => {lex.setTokenPosition(tkn); tok = token.T_WHILE; fbreak;}; + 'yield'i whitespace_line+ 'from'i => {lex.setTokenPosition(tkn); tok = token.T_YIELD_FROM; fbreak;}; + 'yield'i => {lex.setTokenPosition(tkn); tok = token.T_YIELD; fbreak;}; + 'include'i => {lex.setTokenPosition(tkn); tok = token.T_INCLUDE; fbreak;}; + 'include_once'i => {lex.setTokenPosition(tkn); tok = token.T_INCLUDE_ONCE; fbreak;}; + 'require'i => {lex.setTokenPosition(tkn); tok = token.T_REQUIRE; fbreak;}; + 'require_once'i => {lex.setTokenPosition(tkn); tok = token.T_REQUIRE_ONCE; fbreak;}; + '__CLASS__'i => {lex.setTokenPosition(tkn); tok = token.T_CLASS_C; fbreak;}; + '__DIR__'i => {lex.setTokenPosition(tkn); tok = token.T_DIR; fbreak;}; + '__FILE__'i => {lex.setTokenPosition(tkn); tok = token.T_FILE; fbreak;}; + '__FUNCTION__'i => {lex.setTokenPosition(tkn); tok = token.T_FUNC_C; fbreak;}; + '__LINE__'i => {lex.setTokenPosition(tkn); tok = token.T_LINE; fbreak;}; + '__NAMESPACE__'i => {lex.setTokenPosition(tkn); tok = token.T_NS_C; fbreak;}; + '__METHOD__'i => {lex.setTokenPosition(tkn); tok = token.T_METHOD_C; fbreak;}; + '__TRAIT__'i => {lex.setTokenPosition(tkn); tok = token.T_TRAIT_C; fbreak;}; + '__halt_compiler'i => {lex.setTokenPosition(tkn); tok = token.T_HALT_COMPILER; fnext halt_compiller_open_parenthesis; fbreak;}; + 'new'i => {lex.setTokenPosition(tkn); tok = token.T_NEW; fbreak;}; + 'and'i => {lex.setTokenPosition(tkn); tok = token.T_LOGICAL_AND; fbreak;}; + 'or'i => {lex.setTokenPosition(tkn); tok = token.T_LOGICAL_OR; fbreak;}; + 'xor'i => {lex.setTokenPosition(tkn); tok = token.T_LOGICAL_XOR; fbreak;}; + '#[' => {lex.setTokenPosition(tkn); tok = token.T_ATTRIBUTE; fbreak;}; + '...' => {lex.setTokenPosition(tkn); tok = token.T_ELLIPSIS; fbreak;}; + '::' => {lex.setTokenPosition(tkn); tok = token.T_PAAMAYIM_NEKUDOTAYIM; fbreak;}; + '&&' => {lex.setTokenPosition(tkn); tok = token.T_BOOLEAN_AND; fbreak;}; + '||' => {lex.setTokenPosition(tkn); tok = token.T_BOOLEAN_OR; fbreak;}; + '&=' => {lex.setTokenPosition(tkn); tok = token.T_AND_EQUAL; fbreak;}; + '|=' => {lex.setTokenPosition(tkn); tok = token.T_OR_EQUAL; fbreak;}; + '.=' => {lex.setTokenPosition(tkn); tok = token.T_CONCAT_EQUAL; fbreak;}; + '*=' => {lex.setTokenPosition(tkn); tok = token.T_MUL_EQUAL; fbreak;}; + '**=' => {lex.setTokenPosition(tkn); tok = token.T_POW_EQUAL; fbreak;}; + '/=' => {lex.setTokenPosition(tkn); tok = token.T_DIV_EQUAL; fbreak;}; + '+=' => {lex.setTokenPosition(tkn); tok = token.T_PLUS_EQUAL; fbreak;}; + '-=' => {lex.setTokenPosition(tkn); tok = token.T_MINUS_EQUAL; fbreak;}; + '^=' => {lex.setTokenPosition(tkn); tok = token.T_XOR_EQUAL; fbreak;}; + '%=' => {lex.setTokenPosition(tkn); tok = token.T_MOD_EQUAL; fbreak;}; + '--' => {lex.setTokenPosition(tkn); tok = token.T_DEC; fbreak;}; + '++' => {lex.setTokenPosition(tkn); tok = token.T_INC; fbreak;}; + '=>' => {lex.setTokenPosition(tkn); tok = token.T_DOUBLE_ARROW; fbreak;}; + '<=>' => {lex.setTokenPosition(tkn); tok = token.T_SPACESHIP; fbreak;}; + '!=' | '<>' => {lex.setTokenPosition(tkn); tok = token.T_IS_NOT_EQUAL; fbreak;}; + '!==' => {lex.setTokenPosition(tkn); tok = token.T_IS_NOT_IDENTICAL; fbreak;}; + '==' => {lex.setTokenPosition(tkn); tok = token.T_IS_EQUAL; fbreak;}; + '===' => {lex.setTokenPosition(tkn); tok = token.T_IS_IDENTICAL; fbreak;}; + '<<=' => {lex.setTokenPosition(tkn); tok = token.T_SL_EQUAL; fbreak;}; + '>>=' => {lex.setTokenPosition(tkn); tok = token.T_SR_EQUAL; fbreak;}; + '>=' => {lex.setTokenPosition(tkn); tok = token.T_IS_GREATER_OR_EQUAL; fbreak;}; + '<=' => {lex.setTokenPosition(tkn); tok = token.T_IS_SMALLER_OR_EQUAL; fbreak;}; + '**' => {lex.setTokenPosition(tkn); tok = token.T_POW; fbreak;}; + '<<' => {lex.setTokenPosition(tkn); tok = token.T_SL; fbreak;}; + '>>' => {lex.setTokenPosition(tkn); tok = token.T_SR; fbreak;}; + '??' => {lex.setTokenPosition(tkn); tok = token.T_COALESCE; fbreak;}; + '??=' => {lex.setTokenPosition(tkn); tok = token.T_COALESCE_EQUAL; fbreak;}; + + '(' whitespace* 'array'i whitespace* ')' => {lex.setTokenPosition(tkn); tok = token.T_ARRAY_CAST; fbreak;}; + '(' whitespace* ('bool'i|'boolean'i) whitespace* ')' => {lex.setTokenPosition(tkn); tok = token.T_BOOL_CAST; fbreak;}; + '(' whitespace* ('real'i) whitespace* ')' => {lex.error(fmt.Sprintf("The (real) cast has been removed, use (float) instead")); fbreak;}; + '(' whitespace* ('double'i|'float'i) whitespace* ')' => {lex.setTokenPosition(tkn); tok = token.T_DOUBLE_CAST; fbreak;}; + '(' whitespace* ('int'i|'integer'i) whitespace* ')' => {lex.setTokenPosition(tkn); tok = token.T_INT_CAST; fbreak;}; + '(' whitespace* 'object'i whitespace* ')' => {lex.setTokenPosition(tkn); tok = token.T_OBJECT_CAST; fbreak;}; + '(' whitespace* ('string'i|'binary'i) whitespace* ')' => {lex.setTokenPosition(tkn); tok = token.T_STRING_CAST; fbreak;}; + '(' whitespace* 'unset'i whitespace* ')' => {lex.error(fmt.Sprintf("The (unset) cast is no longer supported")); fbreak;}; + + (('#' ^'[') | '//') any_line* when is_not_comment_end => { + lex.ungetStr("?>") + lex.addFreeFloatingToken(tkn, token.T_COMMENT, lex.ts, lex.te) + }; + '#' => { + lex.addFreeFloatingToken(tkn, token.T_COMMENT, lex.ts, lex.te) + }; + '/*' any_line* :>> '*/' { + isDocComment := false; + if lex.te - lex.ts > 4 && string(lex.data[lex.ts:lex.ts+3]) == "/**" { + isDocComment = true; + } + + if isDocComment { + lex.addFreeFloatingToken(tkn, token.T_DOC_COMMENT, lex.ts, lex.te) + } else { + lex.addFreeFloatingToken(tkn, token.T_COMMENT, lex.ts, lex.te) + } + }; + + operators => { + lex.setTokenPosition(tkn); + tok = token.ID(int(lex.data[lex.ts])); + fbreak; + }; + + "{" => { lex.setTokenPosition(tkn); tok = token.ID(int('{')); lex.call(ftargs, fentry(php)); goto _out; }; + "}" => { lex.setTokenPosition(tkn); tok = token.ID(int('}')); lex.ret(1); goto _out;}; + "$" varname => { lex.setTokenPosition(tkn); tok = token.T_VARIABLE; fbreak; }; + varname => { lex.setTokenPosition(tkn); tok = token.T_STRING; fbreak; }; + + "->" => { lex.setTokenPosition(tkn); tok = token.T_OBJECT_OPERATOR; fnext property; fbreak; }; + "?->" => { lex.setTokenPosition(tkn); tok = token.T_NULLSAFE_OBJECT_OPERATOR; fnext property; fbreak; }; + + constant_string => { + lex.setTokenPosition(tkn); + tok = token.T_CONSTANT_ENCAPSED_STRING; + fbreak; + }; + + "b"i? "<<<" [ \t]* ( heredoc_label | ("'" heredoc_label "'") | ('"' heredoc_label '"') ) newline => { + lex.heredocLabel = lex.data[lblStart:lblEnd] + lex.setTokenPosition(tkn); + tok = token.T_START_HEREDOC; + + if lex.isHeredocEnd(lex.p+1) { + fnext heredoc_end; + } else if lex.data[lblStart-1] == '\'' { + fnext nowdoc; + } else { + fnext heredoc; + } + fbreak; + }; + "`" => {lex.setTokenPosition(tkn); tok = token.ID(int('`')); fnext backqote; fbreak;}; + '"' => {lex.setTokenPosition(tkn); tok = token.ID(int('"')); fnext template_string; fbreak;}; + + any_line => { + c := lex.data[lex.p] + lex.error(fmt.Sprintf("WARNING: Unexpected character in input: '%c' (ASCII=%d)", c, c)); + }; + *|; + + property := |* + whitespace_line* => {lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te)}; + "->" => {lex.setTokenPosition(tkn); tok = token.T_OBJECT_OPERATOR; fbreak;}; + "?->" => {lex.setTokenPosition(tkn); tok = token.T_NULLSAFE_OBJECT_OPERATOR; fbreak;}; + varname => {lex.setTokenPosition(tkn); tok = token.T_STRING; fnext php; fbreak;}; + any => {lex.ungetCnt(1); fgoto php;}; + *|; + + nowdoc := |* + any_line* when is_not_heredoc_end => { + lex.setTokenPosition(tkn); + tok = token.T_ENCAPSED_AND_WHITESPACE; + fnext heredoc_end; + fbreak; + }; + *|; + + heredoc := |* + "{$" => {lex.ungetCnt(1); lex.setTokenPosition(tkn); tok = token.T_CURLY_OPEN; lex.call(ftargs, fentry(php)); goto _out;}; + "${" => {lex.setTokenPosition(tkn); tok = token.T_DOLLAR_OPEN_CURLY_BRACES; lex.call(ftargs, fentry(string_var_name)); goto _out;}; + "$" => {lex.ungetCnt(1); fcall string_var;}; + any_line* when is_not_heredoc_end_or_var => { + lex.setTokenPosition(tkn); + tok = token.T_ENCAPSED_AND_WHITESPACE; + + if len(lex.data) > lex.p+1 && lex.data[lex.p+1] != '$' && lex.data[lex.p+1] != '{' { + fnext heredoc_end; + } + fbreak; + }; + *|; + + backqote := |* + "{$" => {lex.ungetCnt(1); lex.setTokenPosition(tkn); tok = token.T_CURLY_OPEN; lex.call(ftargs, fentry(php)); goto _out;}; + "${" => {lex.setTokenPosition(tkn); tok = token.T_DOLLAR_OPEN_CURLY_BRACES; lex.call(ftargs, fentry(string_var_name)); goto _out;}; + "$" varname_first => {lex.ungetCnt(2); fcall string_var;}; + '`' => {lex.setTokenPosition(tkn); tok = token.ID(int('`')); fnext php; fbreak;}; + any_line* when is_not_backqoute_end_or_var => { + lex.setTokenPosition(tkn); + tok = token.T_ENCAPSED_AND_WHITESPACE; + fbreak; + }; + *|; + + template_string := |* + "{$" => {lex.ungetCnt(1); lex.setTokenPosition(tkn); tok = token.T_CURLY_OPEN; lex.call(ftargs, fentry(php)); goto _out;}; + "${" => {lex.setTokenPosition(tkn); tok = token.T_DOLLAR_OPEN_CURLY_BRACES; lex.call(ftargs, fentry(string_var_name)); goto _out;}; + "$" varname_first => {lex.ungetCnt(2); fcall string_var;}; + '"' => {lex.setTokenPosition(tkn); tok = token.ID(int('"')); fnext php; fbreak;}; + any_line* when is_not_string_end_or_var => { + lex.setTokenPosition(tkn); + tok = token.T_ENCAPSED_AND_WHITESPACE; + fbreak; + }; + *|; + + heredoc_end := |* + varname -- ";" => { + lex.setTokenPosition(tkn); + tok = token.T_END_HEREDOC; + fnext php; + fbreak; + }; + varname => { + lex.setTokenPosition(tkn); + tok = token.T_END_HEREDOC; + fnext php; + fbreak; + }; + *|; + + string_var := |* + '$' varname => {lex.setTokenPosition(tkn); tok = token.T_VARIABLE; fbreak;}; + '->' varname_first => {lex.ungetCnt(1); lex.setTokenPosition(tkn); tok = token.T_OBJECT_OPERATOR; fbreak;}; + '?->' varname_first => {lex.ungetCnt(1); lex.setTokenPosition(tkn); tok = token.T_NULLSAFE_OBJECT_OPERATOR; fbreak;}; + varname => {lex.setTokenPosition(tkn); tok = token.T_STRING; fbreak;}; + '[' => {lex.setTokenPosition(tkn); tok = token.ID(int('[')); lex.call(ftargs, fentry(string_var_index)); goto _out;}; + any => {lex.ungetCnt(1); fret;}; + *|; + + string_var_index := |* + lnum | hnum | bnum => {lex.setTokenPosition(tkn); tok = token.T_NUM_STRING; fbreak;}; + '$' varname => {lex.setTokenPosition(tkn); tok = token.T_VARIABLE; fbreak;}; + varname => {lex.setTokenPosition(tkn); tok = token.T_STRING; fbreak;}; + whitespace_line | [\\'#] => {lex.setTokenPosition(tkn); tok = token.T_ENCAPSED_AND_WHITESPACE; lex.ret(2); goto _out;}; + operators > (svi, 1) => {lex.setTokenPosition(tkn); tok = token.ID(int(lex.data[lex.ts])); fbreak;}; + ']' > (svi, 2) => {lex.setTokenPosition(tkn); tok = token.ID(int(']')); lex.ret(2); goto _out;}; + any_line => { + c := lex.data[lex.p] + lex.error(fmt.Sprintf("WARNING: Unexpected character in input: '%c' (ASCII=%d)", c, c)); + }; + *|; + + string_var_name := |* + varname ("[" | "}") => {lex.ungetCnt(1); lex.setTokenPosition(tkn); tok = token.T_STRING_VARNAME; fnext php; fbreak;}; + any => {lex.ungetCnt(1); fnext php;}; + *|; + + halt_compiller_open_parenthesis := |* + whitespace_line* => {lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te)}; + "(" => {lex.setTokenPosition(tkn); tok = token.ID(int('(')); fnext halt_compiller_close_parenthesis; fbreak;}; + any => {lex.ungetCnt(1); fnext php;}; + *|; + + halt_compiller_close_parenthesis := |* + whitespace_line* => {lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te)}; + ")" => {lex.setTokenPosition(tkn); tok = token.ID(int(')')); fnext halt_compiller_close_semicolon; fbreak;}; + any => {lex.ungetCnt(1); fnext php;}; + *|; + + halt_compiller_close_semicolon := |* + whitespace_line* => {lex.addFreeFloatingToken(tkn, token.T_WHITESPACE, lex.ts, lex.te)}; + ";" => {lex.setTokenPosition(tkn); tok = token.ID(int(';')); fnext halt_compiller_end; fbreak;}; + any => {lex.ungetCnt(1); fnext php;}; + *|; + + halt_compiller_end := |* + any_line* => { lex.addFreeFloatingToken(tkn, token.T_HALT_COMPILER, lex.ts, lex.te); }; + *|; + + write exec; + }%% + + tkn.Value = lex.data[lex.ts:lex.te] + tkn.ID = token.ID(tok) + + return tkn +} \ No newline at end of file diff --git a/internal/php8/scanner_php8_test.go b/internal/php8/scanner_php8_test.go new file mode 100644 index 0000000..2a4f0d8 --- /dev/null +++ b/internal/php8/scanner_php8_test.go @@ -0,0 +1,346 @@ +package php8_test + +import ( + "testing" + + "github.com/z7zmey/php-parser/internal/php8" + "github.com/z7zmey/php-parser/internal/tester" + "github.com/z7zmey/php-parser/pkg/conf" + "github.com/z7zmey/php-parser/pkg/token" + "gotest.tools/assert" +) + +func TestNullsafeMethodCallTokens(t *testing.T) { + suite := tester.NewLexerTokenStringTestSuite(t) + suite.UsePHP8() + suite.Code = "foo();" + suite.Expected = []string{ + "$a", + "?->", + "foo", + "(", + ")", + ";", + } + suite.Run() +} + +func TestNullsafePropertyFetchTokens(t *testing.T) { + suite := tester.NewLexerTokenStringTestSuite(t) + suite.UsePHP8() + suite.Code = "prop;" + suite.Expected = []string{ + "$a", + "?->", + "prop", + ";", + } + suite.Run() +} + +func TestNullsafePropertyFetchInStringTokens(t *testing.T) { + suite := tester.NewLexerTokenStringTestSuite(t) + suite.UsePHP8() + suite.Code = "prop\";" + suite.Expected = []string{ + "\"", + "$a", + "?->", + "prop", + "\"", + ";", + } + suite.Run() +} + +func TestNullsafeMethodCallTokensFreeFloating(t *testing.T) { + suite := tester.NewLexerTokenFreeFloatingTestSuite(t) + suite.UsePHP8() + suite.Code = ` bar ( '' ) ;` + + suite.Expected = [][]*token.Token{ + { + { + ID: token.T_OPEN_TAG, + Value: []byte(" 100 }" + suite.Expected = []string{ + "match", + "(", + "$a", + ")", + "{", + "10", + "=>", + "100", + "}", + } + suite.Run() +} + +func TestMatchWithDefaultStringTokens(t *testing.T) { + suite := tester.NewLexerTokenStringTestSuite(t) + suite.UsePHP8() + suite.Code = " 10 }" + suite.Expected = []string{ + "match", + "(", + "$a", + ")", + "{", + "default", + "=>", + "10", + "}", + } + suite.Run() +} + +func TestAttributeTokens(t *testing.T) { + suite := tester.NewLexerTokenStringTestSuite(t) + suite.UsePHP8() + suite.Code = " + + + <=> + != + <> + !== + == + === + <<= + >>= + >= + <= + ** + << + >> + ?? + + # inline comment + // inline comment + + /* + multiline comment + */ + + /** + * PHP Doc comment + */ + + ; + : + , + . + [ + ] + ( + ) + | + / + ^ + & + + + - + * + = + % + ! + ~ + $ + < + > + ? + @ + { + } + + $var + str + + -> ` + "\t\r\n" + ` ->prop + + ( array ) + ( bool ) + ( boolean ) + ( double ) + ( float ) + ( int ) + ( integer ) + ( object ) + ( string ) + ( binary ) + + ` + + expected := []string{ + token.T_INLINE_HTML.String(), + token.ID(int(';')).String(), + token.T_INLINE_HTML.String(), + token.T_ECHO.String(), + token.ID(int(';')).String(), + token.T_INLINE_HTML.String(), + + token.T_ABSTRACT.String(), + token.T_ARRAY.String(), + token.T_AS.String(), + token.T_BREAK.String(), + token.T_CALLABLE.String(), + token.T_CASE.String(), + token.T_CATCH.String(), + token.T_CLASS.String(), + token.T_CLONE.String(), + token.T_CONST.String(), + token.T_CONTINUE.String(), + token.T_DECLARE.String(), + token.T_DEFAULT.String(), + token.T_DO.String(), + token.T_ECHO.String(), + token.T_ELSE.String(), + token.T_ELSEIF.String(), + token.T_EMPTY.String(), + token.T_ENDDECLARE.String(), + token.T_ENDFOR.String(), + token.T_ENDFOREACH.String(), + token.T_ENDIF.String(), + token.T_ENDSWITCH.String(), + token.T_ENDWHILE.String(), + token.T_EVAL.String(), + token.T_EXIT.String(), + token.T_EXTENDS.String(), + token.T_FINAL.String(), + token.T_FINALLY.String(), + token.T_FOR.String(), + token.T_FOREACH.String(), + token.T_FUNCTION.String(), + token.T_FUNCTION.String(), + token.T_GLOBAL.String(), + token.T_GOTO.String(), + token.T_IF.String(), + token.T_ISSET.String(), + token.T_IMPLEMENTS.String(), + token.T_INSTANCEOF.String(), + token.T_INSTEADOF.String(), + token.T_INTERFACE.String(), + token.T_LIST.String(), + token.T_NAMESPACE.String(), + token.T_PRIVATE.String(), + token.T_PUBLIC.String(), + token.T_PRINT.String(), + token.T_PROTECTED.String(), + token.T_RETURN.String(), + token.T_STATIC.String(), + token.T_SWITCH.String(), + token.T_THROW.String(), + token.T_TRAIT.String(), + token.T_TRY.String(), + token.T_UNSET.String(), + token.T_USE.String(), + token.T_VAR.String(), + token.T_WHILE.String(), + token.T_YIELD_FROM.String(), + token.T_YIELD.String(), + token.T_INCLUDE.String(), + token.T_INCLUDE_ONCE.String(), + token.T_REQUIRE.String(), + token.T_REQUIRE_ONCE.String(), + + token.T_CLASS_C.String(), + token.T_DIR.String(), + token.T_FILE.String(), + token.T_FUNC_C.String(), + token.T_LINE.String(), + token.T_NS_C.String(), + token.T_METHOD_C.String(), + token.T_TRAIT_C.String(), + token.T_HALT_COMPILER.String(), + + token.T_NEW.String(), + token.T_LOGICAL_AND.String(), + token.T_LOGICAL_OR.String(), + token.T_LOGICAL_XOR.String(), + + token.T_NS_SEPARATOR.String(), + token.T_ELLIPSIS.String(), + token.T_PAAMAYIM_NEKUDOTAYIM.String(), + token.T_BOOLEAN_AND.String(), + token.T_BOOLEAN_OR.String(), + token.T_AND_EQUAL.String(), + token.T_OR_EQUAL.String(), + token.T_CONCAT_EQUAL.String(), + token.T_MUL_EQUAL.String(), + token.T_POW_EQUAL.String(), + token.T_DIV_EQUAL.String(), + token.T_PLUS_EQUAL.String(), + token.T_MINUS_EQUAL.String(), + token.T_XOR_EQUAL.String(), + token.T_MOD_EQUAL.String(), + token.T_DEC.String(), + token.T_INC.String(), + token.T_DOUBLE_ARROW.String(), + token.T_SPACESHIP.String(), + token.T_IS_NOT_EQUAL.String(), + token.T_IS_NOT_EQUAL.String(), + token.T_IS_NOT_IDENTICAL.String(), + token.T_IS_EQUAL.String(), + token.T_IS_IDENTICAL.String(), + token.T_SL_EQUAL.String(), + token.T_SR_EQUAL.String(), + token.T_IS_GREATER_OR_EQUAL.String(), + token.T_IS_SMALLER_OR_EQUAL.String(), + token.T_POW.String(), + token.T_SL.String(), + token.T_SR.String(), + token.T_COALESCE.String(), + + token.ID(int(';')).String(), + token.ID(int(':')).String(), + token.ID(int(',')).String(), + token.ID(int('.')).String(), + token.ID(int('[')).String(), + token.ID(int(']')).String(), + token.ID(int('(')).String(), + token.ID(int(')')).String(), + token.ID(int('|')).String(), + token.ID(int('/')).String(), + token.ID(int('^')).String(), + token.ID(int('&')).String(), + token.ID(int('+')).String(), + token.ID(int('-')).String(), + token.ID(int('*')).String(), + token.ID(int('=')).String(), + token.ID(int('%')).String(), + token.ID(int('!')).String(), + token.ID(int('~')).String(), + token.ID(int('$')).String(), + token.ID(int('<')).String(), + token.ID(int('>')).String(), + token.ID(int('?')).String(), + token.ID(int('@')).String(), + token.ID(int('{')).String(), + token.ID(int('}')).String(), + + token.T_VARIABLE.String(), + token.T_STRING.String(), + + token.T_OBJECT_OPERATOR.String(), + token.T_OBJECT_OPERATOR.String(), + token.T_STRING.String(), + + token.T_ARRAY_CAST.String(), + token.T_BOOL_CAST.String(), + token.T_BOOL_CAST.String(), + token.T_DOUBLE_CAST.String(), + token.T_DOUBLE_CAST.String(), + token.T_INT_CAST.String(), + token.T_INT_CAST.String(), + token.T_OBJECT_CAST.String(), + token.T_STRING_CAST.String(), + token.T_STRING_CAST.String(), + } + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := NewLexer([]byte(src), config) + actual := []string{} + + for { + tkn := lexer.Lex() + if tkn.ID == 0 { + break + } + + actual = append(actual, tkn.ID.String()) + } + + assert.DeepEqual(t, expected, actual) +} + +func TestShebang(t *testing.T) { + src := `#!/usr/bin/env php +prop + $var[1] + $var[0x1] + $var[0b1] + $var[var_name] + $var[$var] + + {$var} + ${var_name} + {s $ \$a +CAT; + ` + + expected := []string{ + token.T_START_HEREDOC.String(), + token.T_ENCAPSED_AND_WHITESPACE.String(), + token.T_END_HEREDOC.String(), + token.ID(int(';')).String(), + + token.T_START_HEREDOC.String(), + token.T_ENCAPSED_AND_WHITESPACE.String(), + token.T_END_HEREDOC.String(), + token.ID(int(';')).String(), + + token.T_START_HEREDOC.String(), + token.T_ENCAPSED_AND_WHITESPACE.String(), + token.T_VARIABLE.String(), + token.T_OBJECT_OPERATOR.String(), + token.T_STRING.String(), + token.T_ENCAPSED_AND_WHITESPACE.String(), + token.T_VARIABLE.String(), + token.ID(int('[')).String(), + token.T_NUM_STRING.String(), + token.ID(int(']')).String(), + token.T_ENCAPSED_AND_WHITESPACE.String(), + token.T_VARIABLE.String(), + token.ID(int('[')).String(), + token.T_NUM_STRING.String(), + token.ID(int(']')).String(), + token.T_ENCAPSED_AND_WHITESPACE.String(), + token.T_VARIABLE.String(), + token.ID(int('[')).String(), + token.T_NUM_STRING.String(), + token.ID(int(']')).String(), + token.T_ENCAPSED_AND_WHITESPACE.String(), + token.T_VARIABLE.String(), + token.ID(int('[')).String(), + token.T_STRING.String(), + token.ID(int(']')).String(), + token.T_ENCAPSED_AND_WHITESPACE.String(), + token.T_VARIABLE.String(), + token.ID(int('[')).String(), + token.T_VARIABLE.String(), + token.ID(int(']')).String(), + token.T_ENCAPSED_AND_WHITESPACE.String(), + token.T_CURLY_OPEN.String(), + token.T_VARIABLE.String(), + token.ID(int('}')).String(), + token.T_ENCAPSED_AND_WHITESPACE.String(), + token.T_DOLLAR_OPEN_CURLY_BRACES.String(), + token.T_STRING_VARNAME.String(), + token.ID(int('}')).String(), + token.T_ENCAPSED_AND_WHITESPACE.String(), + token.T_END_HEREDOC.String(), + token.ID(int(';')).String(), + } + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := NewLexer([]byte(src), config) + actual := []string{} + + for { + tkn := lexer.Lex() + if tkn.ID == 0 { + break + } + + actual = append(actual, tkn.ID.String()) + } + + assert.DeepEqual(t, expected, actual) +} + +func TestHereDocTokens2(t *testing.T) { + src := ` test test + ` + + expected := []string{ + token.T_VARIABLE.String(), + token.ID(int(';')).String(), + token.T_INLINE_HTML.String(), + + token.T_VARIABLE.String(), + token.ID(int(';')).String(), + token.T_INLINE_HTML.String(), + } + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := NewLexer([]byte(src), config) + actual := []string{} + + for { + tkn := lexer.Lex() + if tkn.ID == 0 { + break + } + + actual = append(actual, tkn.ID.String()) + } + + assert.DeepEqual(t, expected, actual) +} + +func TestStringTokensAfterVariable(t *testing.T) { + src := ` test` + + expected := []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte(" bar ( '' ) ;` + + config := conf.Config{ + Version: &version.Version{ + Major: 7, + Minor: 4, + }, + } + lexer := NewLexer([]byte(src), config) + + expected := []*token.Token{ + { + ID: token.T_OPEN_TAG, + Value: []byte("bar($a, ...$b); +foo::bar($a, ...$b); +$foo::bar($a, ...$b); +new foo($a, ...$b); +/** anonymous class */ +new class ($a, ...$b) {}; +new class {}; +new $foo; +new $foo[1]; +new $foo{$bar}; +new $foo->bar; +new $foo::$bar; +new static::$bar; + +function foo(?bar $bar=null, baz &...$baz) {} +class foo {public function foo(?bar $bar=null, baz &...$baz) {}} +function(?bar $bar=null, baz &...$baz) {}; +static function(?bar $bar=null, baz &...$baz) {}; + +1234567890123456789; +12345678901234567890; +0.; +0b0111111111111111111111111111111111111111111111111111111111111111; +0b1111111111111111111111111111111111111111111111111111111111111111; +0x007111111111111111; +0x8111111111111111; +__CLASS__; +__DIR__; +__FILE__; +__FUNCTION__; +__LINE__; +__NAMESPACE__; +__METHOD__; +__TRAIT__; + +"test $var"; +"test $var[1]"; +"test $var[-1]"; +"test $var[1234567890123456789012345678901234567890]"; +"test $var[-1234567890123456789012345678901234567890]"; +"test $var[bar]"; +"test $var[$bar]"; +"$foo $bar"; +"test $foo->bar()"; +"test ${foo}"; +"test ${foo[0]}"; +"test ${$foo}"; +"test {$foo->bar()}"; + +if ($a) : +endif; +if ($a) : +elseif ($b): +endif; +if ($a) : +else: +endif; +if ($a) : +elseif ($b): +elseif ($c): +else: +endif; + +while (1) { break; } +while (1) { break 2; } +while (1) : break(3); endwhile; +class foo{ public const FOO = 1, BAR = 2; } +class foo{ const FOO = 1, BAR = 2; } +class foo{ function bar() {} } +class foo{ public static function &bar() {} } +class foo{ public static function &bar(): void {} } +abstract class foo{ } +final class foo extends bar { } +final class foo implements bar { } +final class foo implements bar, baz { } +new class() extends foo implements bar, baz { }; + +const FOO = 1, BAR = 2; +while (1) { continue; } +while (1) { continue 2; } +while (1) { continue(3); } +declare(ticks=1); +declare(ticks=1) {} +declare(ticks=1): enddeclare; +do {} while(1); +echo $a, 1; +echo($a); +for($i = 0; $i < 10; $i++, $i++) {} +for(; $i < 10; $i++, $i++) : endfor; +foreach ($a as $v) {} +foreach ($a as $v) : endforeach; +foreach ($a as $k => $v) {} +foreach ($a as $k => &$v) {} +foreach ($a as $k => list($v)) {} +foreach ($a as $k => [$v]) {} +function foo() {} +function foo() {return;} +function &foo() {return 1;} +function &foo(): void {} +global $a, $b; +a: +goto a; +if ($a) {} +if ($a) {} elseif ($b) {} +if ($a) {} else {} +if ($a) {} elseif ($b) {} elseif ($c) {} else {} +if ($a) {} elseif ($b) {} else if ($c) {} else {} +?>
1, &$b,); +~$a; +!$a; + +Foo::Bar; +$foo::Bar; +clone($a); +clone $a; +function(){}; +function($a, $b) use ($c, &$d) {}; +function(): void {}; +foo; +namespace\foo; +\foo; + +empty($a); +@$a; +eval($a); +exit; +exit($a); +die; +die($a); +foo(); +namespace\foo(); +\foo(); +$foo(); + +$a--; +$a++; +--$a; +++$a; + +include $a; +include_once $a; +require $a; +require_once $a; + +$a instanceof Foo; +$a instanceof namespace\Foo; +$a instanceof \Foo; + +isset($a, $b); +list($a) = $b; +list($a[]) = $b; +list(list($a)) = $b; + +$a->foo(); +new Foo(); +new namespace\Foo(); +new \Foo(); +new class ($a, ...$b) {}; +print($a); +$a->foo; +`cmd $a`; +`cmd`; +``; +[]; +[1]; +[1=>1, &$b,]; + +[$a] = $b; +[$a[]] = $b; +[list($a)] = $b; +Foo::bar(); +namespace\Foo::bar(); +\Foo::bar(); +Foo::$bar; +$foo::$bar; +namespace\Foo::$bar; +\Foo::$bar; +$a ? $b : $c; +$a ? : $c; +$a ? $b ? $c : $d : $e; +$a ? $b : $c ? $d : $e; +-$a; ++$a; +$$a; +yield; +yield $a; +yield $a => $b; +yield from $a; + +(array)$a; +(boolean)$a; +(bool)$a; +(double)$a; +(float)$a; +(integer)$a; +(int)$a; +(object)$a; +(string)$a; +(unset)$a; + +$a & $b; +$a | $b; +$a ^ $b; +$a && $b; +$a || $b; +$a ?? $b; +$a . $b; +$a / $b; +$a == $b; +$a >= $b; +$a > $b; +$a === $b; +$a and $b; +$a or $b; +$a xor $b; +$a - $b; +$a % $b; +$a * $b; +$a != $b; +$a !== $b; +$a + $b; +$a ** $b; +$a << $b; +$a >> $b; +$a <= $b; +$a < $b; +$a <=> $b; + +$a =& $b; +$a = $b; +$a &= $b; +$a |= $b; +$a ^= $b; +$a .= $b; +$a /= $b; +$a -= $b; +$a %= $b; +$a *= $b; +$a += $b; +$a **= $b; +$a <<= $b; +$a >>= $b; + +class foo {public function class() {} } +\foo\bar(); + +function foo(&$a, ...$b) { + + function bar() {} + class Baz {} + trait Quux{} + interface Quuux {} +} + +function foo(&$a = 1, ...$b = 1, $c = 1) {} +function foo(array $a, callable $b) {} +abstract final class foo { abstract protected static function bar(); final private function baz() {} } + +(new Foo)->bar; +(new Foo)(); +[$foo][0](); +foo[1](); +"foo"(); +[1]{$foo}(); +${foo()}; + +Foo::$bar(); +Foo::{$bar[0]}(); + +$foo->$bar; +$foo->{$bar[0]}; + +[1=>&$a, 2=>list($b)]; + +__halt_compiler(); + +(new Foo)?->bar; +(new Foo)?->bar(); +$foo?->$bar; +$foo?->{$bar[0]}; +"{$foo?->{$bar[0]}}"; + +parsing process must be terminated \ No newline at end of file diff --git a/internal/tester/lexer_token_freefloating.go b/internal/tester/lexer_token_freefloating.go new file mode 100644 index 0000000..7f0097c --- /dev/null +++ b/internal/tester/lexer_token_freefloating.go @@ -0,0 +1,62 @@ +package tester + +import ( + "testing" + + "github.com/z7zmey/php-parser/internal/php8" + "github.com/z7zmey/php-parser/internal/scanner" + "github.com/z7zmey/php-parser/pkg/conf" + "github.com/z7zmey/php-parser/pkg/token" + "github.com/z7zmey/php-parser/pkg/version" + "gotest.tools/assert" +) + +type Lexer interface { + Lex() *token.Token +} + +type LexerTokenFreeFloatingTestSuite struct { + t *testing.T + + Code string + Expected [][]*token.Token + + Version version.Version +} + +func NewLexerTokenFreeFloatingTestSuite(t *testing.T) *LexerTokenFreeFloatingTestSuite { + return &LexerTokenFreeFloatingTestSuite{ + t: t, + Version: version.Version{ + Major: 7, + Minor: 4, + }, + } +} + +func (l *LexerTokenFreeFloatingTestSuite) UsePHP8() { + l.Version = version.Version{Major: 8, Minor: 0} +} + +func (l *LexerTokenFreeFloatingTestSuite) Run() { + config := conf.Config{ + Version: &l.Version, + } + + var lexer Lexer + + if l.Version.Less(&version.Version{Major: 8, Minor: 0}) { + lexer = scanner.NewLexer([]byte(l.Code), config) + } else { + lexer = php8.NewLexer([]byte(l.Code), config) + } + + for _, expected := range l.Expected { + tkn := lexer.Lex() + actual := tkn.FreeFloating + for _, v := range actual { + v.Position = nil + } + assert.DeepEqual(l.t, expected, actual) + } +} diff --git a/internal/tester/lexer_token_string.go b/internal/tester/lexer_token_string.go new file mode 100644 index 0000000..8a403fa --- /dev/null +++ b/internal/tester/lexer_token_string.go @@ -0,0 +1,54 @@ +package tester + +import ( + "testing" + + "github.com/z7zmey/php-parser/internal/php8" + "github.com/z7zmey/php-parser/internal/scanner" + "github.com/z7zmey/php-parser/pkg/conf" + "github.com/z7zmey/php-parser/pkg/version" + "gotest.tools/assert" +) + +type LexerTokenStringTestSuite struct { + t *testing.T + + Code string + Expected []string + + Version version.Version +} + +func NewLexerTokenStringTestSuite(t *testing.T) *LexerTokenStringTestSuite { + return &LexerTokenStringTestSuite{ + t: t, + Version: version.Version{ + Major: 7, + Minor: 4, + }, + } +} + +func (l *LexerTokenStringTestSuite) UsePHP8() { + l.Version = version.Version{Major: 8, Minor: 0} +} + +func (l *LexerTokenStringTestSuite) Run() { + config := conf.Config{ + Version: &l.Version, + } + + var lexer Lexer + + if l.Version.Less(&version.Version{Major: 8, Minor: 0}) { + lexer = scanner.NewLexer([]byte(l.Code), config) + } else { + lexer = php8.NewLexer([]byte(l.Code), config) + } + + for _, expected := range l.Expected { + tkn := lexer.Lex() + actual := string(tkn.Value) + assert.DeepEqual(l.t, expected, actual) + } +} diff --git a/internal/tester/lexer_token_struct.go b/internal/tester/lexer_token_struct.go new file mode 100644 index 0000000..423fcac --- /dev/null +++ b/internal/tester/lexer_token_struct.go @@ -0,0 +1,56 @@ +package tester + +import ( + "testing" + + "github.com/z7zmey/php-parser/internal/php8" + "github.com/z7zmey/php-parser/internal/scanner" + "github.com/z7zmey/php-parser/pkg/conf" + "github.com/z7zmey/php-parser/pkg/token" + "github.com/z7zmey/php-parser/pkg/version" + "gotest.tools/assert" +) + +type LexerTokenStructTestSuite struct { + t *testing.T + + Code string + Expected []*token.Token + + Version version.Version +} + +func NewLexerTokenStructTestSuite(t *testing.T) *LexerTokenStructTestSuite { + return &LexerTokenStructTestSuite{ + t: t, + Version: version.Version{ + Major: 7, + Minor: 4, + }, + } +} + +func (l *LexerTokenStructTestSuite) UsePHP8() { + l.Version = version.Version{Major: 8, Minor: 0} +} + +func (l *LexerTokenStructTestSuite) Run() { + config := conf.Config{ + Version: &l.Version, + } + + var lexer Lexer + + if l.Version.Less(&version.Version{Major: 8, Minor: 0}) { + lexer = scanner.NewLexer([]byte(l.Code), config) + } else { + lexer = php8.NewLexer([]byte(l.Code), config) + } + + for _, expected := range l.Expected { + actual := lexer.Lex() + actual.Position = nil + actual.FreeFloating = nil + assert.DeepEqual(l.t, expected, actual) + } +} diff --git a/internal/tester/parse_print.go b/internal/tester/parse_print.go new file mode 100644 index 0000000..5659de1 --- /dev/null +++ b/internal/tester/parse_print.go @@ -0,0 +1,60 @@ +package tester + +import ( + "bytes" + "testing" + + "github.com/z7zmey/php-parser/pkg/ast" + "github.com/z7zmey/php-parser/pkg/conf" + "github.com/z7zmey/php-parser/pkg/parser" + "github.com/z7zmey/php-parser/pkg/version" + "github.com/z7zmey/php-parser/pkg/visitor/printer" + "gotest.tools/assert" +) + +type ParserPrintTestSuite struct { + t *testing.T + Version version.Version +} + +func NewParserPrintTestSuite(t *testing.T) *ParserPrintTestSuite { + return &ParserPrintTestSuite{ + t: t, + Version: version.Version{ + Major: 7, + Minor: 4, + }, + } +} + +func (p *ParserPrintTestSuite) UsePHP8() *ParserPrintTestSuite { + p.Version = version.Version{Major: 8, Minor: 0} + return p +} + +func (p *ParserPrintTestSuite) Run(code string) { + actual := p.print(p.parse(code)) + assert.DeepEqual(p.t, code, actual) +} + +func (p *ParserPrintTestSuite) parse(src string) ast.Vertex { + config := conf.Config{ + Version: &p.Version, + } + + root, err := parser.Parse([]byte(src), config) + if err != nil { + p.t.Fatal(err) + } + + return root +} + +func (p *ParserPrintTestSuite) print(n ast.Vertex) string { + o := bytes.NewBufferString("") + + pr := printer.NewPrinter(o) + n.Accept(pr) + + return o.String() +} diff --git a/internal/tester/parser.go b/internal/tester/parser.go new file mode 100644 index 0000000..f536574 --- /dev/null +++ b/internal/tester/parser.go @@ -0,0 +1,46 @@ +package tester + +import ( + "testing" + + "github.com/z7zmey/php-parser/pkg/ast" + "github.com/z7zmey/php-parser/pkg/conf" + "github.com/z7zmey/php-parser/pkg/parser" + "github.com/z7zmey/php-parser/pkg/version" + "gotest.tools/assert" +) + +type ParserTestSuite struct { + t *testing.T + + Code string + Expected ast.Vertex + + Version version.Version +} + +func NewParserTestSuite(t *testing.T) *ParserTestSuite { + return &ParserTestSuite{ + t: t, + Version: version.Version{ + Major: 7, + Minor: 4, + }, + } +} + +func (p *ParserTestSuite) UsePHP8() { + p.Version = version.Version{Major: 8, Minor: 0} +} + +func (p *ParserTestSuite) Run() { + config := conf.Config{ + Version: &p.Version, + } + + actual, err := parser.Parse([]byte(p.Code), config) + if err != nil { + p.t.Fatalf("Error parse: %v", err) + } + assert.DeepEqual(p.t, p.Expected, actual) +} diff --git a/internal/tester/parser_dump.go b/internal/tester/parser_dump.go new file mode 100644 index 0000000..fdda399 --- /dev/null +++ b/internal/tester/parser_dump.go @@ -0,0 +1,64 @@ +package tester + +import ( + "bytes" + "testing" + + "github.com/z7zmey/php-parser/pkg/conf" + "github.com/z7zmey/php-parser/pkg/parser" + "github.com/z7zmey/php-parser/pkg/version" + "github.com/z7zmey/php-parser/pkg/visitor/dumper" + "gotest.tools/assert" +) + +type ParserDumpTestSuite struct { + t *testing.T + + Code string + Expected string + + Version version.Version + + actualDump *bytes.Buffer + dumper *dumper.Dumper +} + +func NewParserDumpTestSuite(t *testing.T) *ParserDumpTestSuite { + actualDump := bytes.NewBuffer(nil) + return &ParserDumpTestSuite{ + t: t, + Version: version.Version{ + Major: 7, + Minor: 4, + }, + actualDump: actualDump, + dumper: dumper.NewDumper(actualDump), + } +} + +func (p *ParserDumpTestSuite) WithTokens() { + p.dumper = p.dumper.WithTokens() +} + +func (p *ParserDumpTestSuite) WithPositions() { + p.dumper = p.dumper.WithPositions() +} + +func (p *ParserDumpTestSuite) UsePHP8() { + p.Version = version.Version{Major: 8, Minor: 0} +} + +func (p *ParserDumpTestSuite) Run() { + config := conf.Config{ + Version: &p.Version, + } + + actual, err := parser.Parse([]byte(p.Code), config) + if err != nil { + p.t.Fatalf("Error parse: %v", err) + } + + p.dumper.Dump(actual) + + assert.DeepEqual(p.t, p.Expected+"\n", p.actualDump.String()) +} diff --git a/internal/tester/parser_error.go b/internal/tester/parser_error.go new file mode 100644 index 0000000..b6a02c4 --- /dev/null +++ b/internal/tester/parser_error.go @@ -0,0 +1,52 @@ +package tester + +import ( + "testing" + + "github.com/z7zmey/php-parser/pkg/conf" + "github.com/z7zmey/php-parser/pkg/errors" + "github.com/z7zmey/php-parser/pkg/parser" + "github.com/z7zmey/php-parser/pkg/version" + "gotest.tools/assert" +) + +type ParserErrorTestSuite struct { + t *testing.T + + Code string + Expected []*errors.Error + + Version version.Version +} + +func NewParserErrorTestSuite(t *testing.T) *ParserErrorTestSuite { + return &ParserErrorTestSuite{ + t: t, + Version: version.Version{ + Major: 7, + Minor: 4, + }, + } +} + +func (p *ParserErrorTestSuite) UsePHP8() { + p.Version = version.Version{Major: 8, Minor: 0} +} + +func (p *ParserErrorTestSuite) Run() { + config := conf.Config{ + Version: &p.Version, + } + + var errs []*errors.Error + + config.ErrorHandlerFunc = func(e *errors.Error) { + errs = append(errs, e) + } + + _, err := parser.Parse([]byte(p.Code), config) + if err != nil { + p.t.Fatalf("Error parse: %v", err) + } + assert.DeepEqual(p.t, p.Expected, errs) +} diff --git a/pkg/ast/ast.go b/pkg/ast/ast.go index 7199459..c07a189 100644 --- a/pkg/ast/ast.go +++ b/pkg/ast/ast.go @@ -13,6 +13,10 @@ type Visitor interface { Parameter(n *Parameter) Identifier(n *Identifier) Argument(n *Argument) + MatchArm(n *MatchArm) + Union(n *Union) + Attribute(n *Attribute) + AttributeGroup(n *AttributeGroup) StmtBreak(n *StmtBreak) StmtCase(n *StmtCase) @@ -85,6 +89,8 @@ type Visitor interface { ExprIsset(n *ExprIsset) ExprList(n *ExprList) ExprMethodCall(n *ExprMethodCall) + ExprNullsafeMethodCall(n *ExprNullsafeMethodCall) + ExprMatch(n *ExprMatch) ExprNew(n *ExprNew) ExprPostDec(n *ExprPostDec) ExprPostInc(n *ExprPostInc) @@ -92,12 +98,14 @@ type Visitor interface { ExprPreInc(n *ExprPreInc) ExprPrint(n *ExprPrint) ExprPropertyFetch(n *ExprPropertyFetch) + ExprNullsafePropertyFetch(n *ExprNullsafePropertyFetch) ExprRequire(n *ExprRequire) ExprRequireOnce(n *ExprRequireOnce) ExprShellExec(n *ExprShellExec) ExprStaticCall(n *ExprStaticCall) ExprStaticPropertyFetch(n *ExprStaticPropertyFetch) ExprTernary(n *ExprTernary) + ExprThrow(n *ExprThrow) ExprUnaryMinus(n *ExprUnaryMinus) ExprUnaryPlus(n *ExprUnaryPlus) ExprVariable(n *ExprVariable) diff --git a/pkg/ast/node.go b/pkg/ast/node.go index 9a9dea7..5c285b3 100644 --- a/pkg/ast/node.go +++ b/pkg/ast/node.go @@ -20,7 +20,7 @@ func (n *Root) GetPosition() *position.Position { return n.Position } -// Nullable node +// Nullable node is ?Expr type Nullable struct { Position *position.Position QuestionTkn *token.Token @@ -35,9 +35,26 @@ func (n *Nullable) GetPosition() *position.Position { return n.Position } +// Union node is Expr|Expr1|... +type Union struct { + Position *position.Position + Types []Vertex + SeparatorTkns []*token.Token +} + +func (n *Union) Accept(v Visitor) { + v.Union(n) +} + +func (n *Union) GetPosition() *position.Position { + return n.Position +} + // Parameter node type Parameter struct { Position *position.Position + AttrGroups []Vertex + Visibility Vertex Type Vertex AmpersandTkn *token.Token VariadicTkn *token.Token @@ -72,6 +89,8 @@ func (n *Identifier) GetPosition() *position.Position { // Argument node type Argument struct { Position *position.Position + Name Vertex + ColonTkn *token.Token VariadicTkn *token.Token AmpersandTkn *token.Token Expr Vertex @@ -85,6 +104,41 @@ func (n *Argument) GetPosition() *position.Position { return n.Position } +// Attribute node +type Attribute struct { + Position *position.Position + Name Vertex + OpenParenthesisTkn *token.Token + Args []Vertex + SeparatorTkns []*token.Token + CloseParenthesisTkn *token.Token +} + +func (n *Attribute) Accept(v Visitor) { + v.Attribute(n) +} + +func (n *Attribute) GetPosition() *position.Position { + return n.Position +} + +// AttributeGroup node +type AttributeGroup struct { + Position *position.Position + OpenAttributeTkn *token.Token + Attrs []Vertex + SeparatorTkns []*token.Token + CloseAttributeTkn *token.Token +} + +func (n *AttributeGroup) Accept(v Visitor) { + v.AttributeGroup(n) +} + +func (n *AttributeGroup) GetPosition() *position.Position { + return n.Position +} + // ScalarDnumber node type ScalarDnumber struct { Position *position.Position @@ -286,6 +340,7 @@ func (n *StmtCatch) GetPosition() *position.Position { // StmtClass node type StmtClass struct { Position *position.Position + AttrGroups []Vertex Modifiers []Vertex ClassTkn *token.Token Name Vertex @@ -314,6 +369,7 @@ func (n *StmtClass) GetPosition() *position.Position { // StmtClassConstList node type StmtClassConstList struct { Position *position.Position + AttrGroups []Vertex Modifiers []Vertex ConstTkn *token.Token Consts []Vertex @@ -332,6 +388,7 @@ func (n *StmtClassConstList) GetPosition() *position.Position { // StmtClassMethod node type StmtClassMethod struct { Position *position.Position + AttrGroups []Vertex Modifiers []Vertex FunctionTkn *token.Token AmpersandTkn *token.Token @@ -601,6 +658,7 @@ func (n *StmtForeach) GetPosition() *position.Position { // StmtFunction node type StmtFunction struct { Position *position.Position + AttrGroups []Vertex FunctionTkn *token.Token AmpersandTkn *token.Token Name Vertex @@ -714,6 +772,7 @@ func (n *StmtInlineHtml) GetPosition() *position.Position { // StmtInterface node type StmtInterface struct { Position *position.Position + AttrGroups []Vertex InterfaceTkn *token.Token Name Vertex ExtendsTkn *token.Token @@ -799,6 +858,7 @@ func (n *StmtProperty) GetPosition() *position.Position { // StmtPropertyList node type StmtPropertyList struct { Position *position.Position + AttrGroups []Vertex Modifiers []Vertex Type Vertex Props []Vertex @@ -922,6 +982,7 @@ func (n *StmtThrow) GetPosition() *position.Position { // StmtTrait node type StmtTrait struct { Position *position.Position + AttrGroups []Vertex TraitTkn *token.Token Name Vertex OpenCurlyBracketTkn *token.Token @@ -1171,6 +1232,7 @@ func (n *ExprArrayItem) GetPosition() *position.Position { // ExprArrowFunction node type ExprArrowFunction struct { Position *position.Position + AttrGroups []Vertex StaticTkn *token.Token FnTkn *token.Token AmpersandTkn *token.Token @@ -1271,6 +1333,7 @@ func (n *ExprClone) GetPosition() *position.Position { // ExprClosure node type ExprClosure struct { Position *position.Position + AttrGroups []Vertex StaticTkn *token.Token FunctionTkn *token.Token AmpersandTkn *token.Token @@ -1515,6 +1578,28 @@ func (n *ExprMethodCall) GetPosition() *position.Position { return n.Position } +// ExprNullsafeMethodCall node is $a?->methodName() +type ExprNullsafeMethodCall struct { + Position *position.Position + Var Vertex + ObjectOperatorTkn *token.Token + OpenCurlyBracketTkn *token.Token + Method Vertex + CloseCurlyBracketTkn *token.Token + OpenParenthesisTkn *token.Token + Args []Vertex + SeparatorTkns []*token.Token + CloseParenthesisTkn *token.Token +} + +func (n *ExprNullsafeMethodCall) Accept(v Visitor) { + v.ExprNullsafeMethodCall(n) +} + +func (n *ExprNullsafeMethodCall) GetPosition() *position.Position { + return n.Position +} + // ExprNew node type ExprNew struct { Position *position.Position @@ -1627,6 +1712,24 @@ func (n *ExprPropertyFetch) GetPosition() *position.Position { return n.Position } +// ExprNullsafePropertyFetch node +type ExprNullsafePropertyFetch struct { + Position *position.Position + Var Vertex + ObjectOperatorTkn *token.Token + OpenCurlyBracketTkn *token.Token + Prop Vertex + CloseCurlyBracketTkn *token.Token +} + +func (n *ExprNullsafePropertyFetch) Accept(v Visitor) { + v.ExprNullsafePropertyFetch(n) +} + +func (n *ExprNullsafePropertyFetch) GetPosition() *position.Position { + return n.Position +} + // ExprRequire node type ExprRequire struct { Position *position.Position @@ -2586,6 +2689,62 @@ func (n *ExprBinarySpaceship) GetPosition() *position.Position { return n.Position } +// ExprMatch node is match(expr) { list } +type ExprMatch struct { + Position *position.Position + MatchTkn *token.Token + OpenParenthesisTkn *token.Token + Expr Vertex + CloseParenthesisTkn *token.Token + OpenCurlyBracketTkn *token.Token + Arms []Vertex + SeparatorTkns []*token.Token + CloseCurlyBracketTkn *token.Token +} + +func (n *ExprMatch) Accept(v Visitor) { + v.ExprMatch(n) +} + +func (n *ExprMatch) GetPosition() *position.Position { + return n.Position +} + +// ExprThrow node is 'throw Expr' +type ExprThrow struct { + Position *position.Position + ThrowTkn *token.Token + Expr Vertex + SemiColonTkn *token.Token +} + +func (n *ExprThrow) Accept(v Visitor) { + v.ExprThrow(n) +} + +func (n *ExprThrow) GetPosition() *position.Position { + return n.Position +} + +// MatchArm node is [expr, expr1, ...]|default => return_expr +type MatchArm struct { + Position *position.Position + DefaultTkn *token.Token + DefaultCommaTkn *token.Token + Exprs []Vertex + SeparatorTkns []*token.Token + DoubleArrowTkn *token.Token + ReturnExpr Vertex +} + +func (n *MatchArm) Accept(v Visitor) { + v.MatchArm(n) +} + +func (n *MatchArm) GetPosition() *position.Position { + return n.Position +} + type Name struct { Position *position.Position Parts []Vertex diff --git a/pkg/parser/parser.go b/pkg/parser/parser.go index ee00309..04a3378 100644 --- a/pkg/parser/parser.go +++ b/pkg/parser/parser.go @@ -5,6 +5,7 @@ import ( "github.com/z7zmey/php-parser/internal/php5" "github.com/z7zmey/php-parser/internal/php7" + "github.com/z7zmey/php-parser/internal/php8" "github.com/z7zmey/php-parser/internal/scanner" "github.com/z7zmey/php-parser/pkg/ast" "github.com/z7zmey/php-parser/pkg/conf" @@ -20,6 +21,9 @@ var ( php7RangeStart = &version.Version{Major: 7} php7RangeEnd = &version.Version{Major: 7, Minor: 4} + + php8RangeStart = &version.Version{Major: 8} + php8RangeEnd = &version.Version{Major: 8, Minor: 1} ) // Parser interface @@ -49,5 +53,12 @@ func Parse(src []byte, config conf.Config) (ast.Vertex, error) { return parser.GetRootNode(), nil } + if config.Version.InRange(php8RangeStart, php8RangeEnd) { + lexer := php8.NewLexer(src, config) + parser = php8.NewParser(lexer, config) + parser.Parse() + return parser.GetRootNode(), nil + } + return nil, ErrVersionOutOfRange } diff --git a/pkg/token/token.go b/pkg/token/token.go index 406a577..08f322f 100644 --- a/pkg/token/token.go +++ b/pkg/token/token.go @@ -144,6 +144,12 @@ const ( T_IS_NOT_EQUAL T_IS_SMALLER_OR_EQUAL T_IS_GREATER_OR_EQUAL + T_NULLSAFE_OBJECT_OPERATOR + T_MATCH + T_ATTRIBUTE + T_NAME_RELATIVE + T_NAME_QUALIFIED + T_NAME_FULLY_QUALIFIED ) type Token struct { diff --git a/pkg/token/token_string.go b/pkg/token/token_string.go index ce34b14..6dcd745 100644 --- a/pkg/token/token_string.go +++ b/pkg/token/token_string.go @@ -146,11 +146,17 @@ func _() { _ = x[T_IS_NOT_EQUAL-57481] _ = x[T_IS_SMALLER_OR_EQUAL-57482] _ = x[T_IS_GREATER_OR_EQUAL-57483] + _ = x[T_NULLSAFE_OBJECT_OPERATOR-57484] + _ = x[T_MATCH-57485] + _ = x[T_ATTRIBUTE-57486] + _ = x[T_NAME_RELATIVE-57487] + _ = x[T_NAME_QUALIFIED-57488] + _ = x[T_NAME_FULLY_QUALIFIED-57489] } -const _ID_name = "T_INCLUDET_INCLUDE_ONCET_EXITT_IFT_LNUMBERT_DNUMBERT_STRINGT_STRING_VARNAMET_VARIABLET_NUM_STRINGT_INLINE_HTMLT_CHARACTERT_BAD_CHARACTERT_ENCAPSED_AND_WHITESPACET_CONSTANT_ENCAPSED_STRINGT_ECHOT_DOT_WHILET_ENDWHILET_FORT_ENDFORT_FOREACHT_ENDFOREACHT_DECLARET_ENDDECLARET_AST_SWITCHT_ENDSWITCHT_CASET_DEFAULTT_BREAKT_CONTINUET_GOTOT_FUNCTIONT_FNT_CONSTT_RETURNT_TRYT_CATCHT_FINALLYT_THROWT_USET_INSTEADOFT_GLOBALT_VART_UNSETT_ISSETT_EMPTYT_HALT_COMPILERT_CLASST_TRAITT_INTERFACET_EXTENDST_IMPLEMENTST_OBJECT_OPERATORT_DOUBLE_ARROWT_LISTT_ARRAYT_CALLABLET_CLASS_CT_TRAIT_CT_METHOD_CT_FUNC_CT_LINET_FILET_COMMENTT_DOC_COMMENTT_OPEN_TAGT_OPEN_TAG_WITH_ECHOT_CLOSE_TAGT_WHITESPACET_START_HEREDOCT_END_HEREDOCT_DOLLAR_OPEN_CURLY_BRACEST_CURLY_OPENT_PAAMAYIM_NEKUDOTAYIMT_NAMESPACET_NS_CT_DIRT_NS_SEPARATORT_ELLIPSIST_EVALT_REQUIRET_REQUIRE_ONCET_LOGICAL_ORT_LOGICAL_XORT_LOGICAL_ANDT_INSTANCEOFT_NEWT_CLONET_ELSEIFT_ELSET_ENDIFT_PRINTT_YIELDT_STATICT_ABSTRACTT_FINALT_PRIVATET_PROTECTEDT_PUBLICT_INCT_DECT_YIELD_FROMT_INT_CASTT_DOUBLE_CASTT_STRING_CASTT_ARRAY_CASTT_OBJECT_CASTT_BOOL_CASTT_UNSET_CASTT_COALESCET_SPACESHIPT_NOELSET_PLUS_EQUALT_MINUS_EQUALT_MUL_EQUALT_POW_EQUALT_DIV_EQUALT_CONCAT_EQUALT_MOD_EQUALT_AND_EQUALT_OR_EQUALT_XOR_EQUALT_SL_EQUALT_SR_EQUALT_COALESCE_EQUALT_BOOLEAN_ORT_BOOLEAN_ANDT_POWT_SLT_SRT_IS_IDENTICALT_IS_NOT_IDENTICALT_IS_EQUALT_IS_NOT_EQUALT_IS_SMALLER_OR_EQUALT_IS_GREATER_OR_EQUAL" +const _ID_name = "T_INCLUDET_INCLUDE_ONCET_EXITT_IFT_LNUMBERT_DNUMBERT_STRINGT_STRING_VARNAMET_VARIABLET_NUM_STRINGT_INLINE_HTMLT_CHARACTERT_BAD_CHARACTERT_ENCAPSED_AND_WHITESPACET_CONSTANT_ENCAPSED_STRINGT_ECHOT_DOT_WHILET_ENDWHILET_FORT_ENDFORT_FOREACHT_ENDFOREACHT_DECLARET_ENDDECLARET_AST_SWITCHT_ENDSWITCHT_CASET_DEFAULTT_BREAKT_CONTINUET_GOTOT_FUNCTIONT_FNT_CONSTT_RETURNT_TRYT_CATCHT_FINALLYT_THROWT_USET_INSTEADOFT_GLOBALT_VART_UNSETT_ISSETT_EMPTYT_HALT_COMPILERT_CLASST_TRAITT_INTERFACET_EXTENDST_IMPLEMENTST_OBJECT_OPERATORT_DOUBLE_ARROWT_LISTT_ARRAYT_CALLABLET_CLASS_CT_TRAIT_CT_METHOD_CT_FUNC_CT_LINET_FILET_COMMENTT_DOC_COMMENTT_OPEN_TAGT_OPEN_TAG_WITH_ECHOT_CLOSE_TAGT_WHITESPACET_START_HEREDOCT_END_HEREDOCT_DOLLAR_OPEN_CURLY_BRACEST_CURLY_OPENT_PAAMAYIM_NEKUDOTAYIMT_NAMESPACET_NS_CT_DIRT_NS_SEPARATORT_ELLIPSIST_EVALT_REQUIRET_REQUIRE_ONCET_LOGICAL_ORT_LOGICAL_XORT_LOGICAL_ANDT_INSTANCEOFT_NEWT_CLONET_ELSEIFT_ELSET_ENDIFT_PRINTT_YIELDT_STATICT_ABSTRACTT_FINALT_PRIVATET_PROTECTEDT_PUBLICT_INCT_DECT_YIELD_FROMT_INT_CASTT_DOUBLE_CASTT_STRING_CASTT_ARRAY_CASTT_OBJECT_CASTT_BOOL_CASTT_UNSET_CASTT_COALESCET_SPACESHIPT_NOELSET_PLUS_EQUALT_MINUS_EQUALT_MUL_EQUALT_POW_EQUALT_DIV_EQUALT_CONCAT_EQUALT_MOD_EQUALT_AND_EQUALT_OR_EQUALT_XOR_EQUALT_SL_EQUALT_SR_EQUALT_COALESCE_EQUALT_BOOLEAN_ORT_BOOLEAN_ANDT_POWT_SLT_SRT_IS_IDENTICALT_IS_NOT_IDENTICALT_IS_EQUALT_IS_NOT_EQUALT_IS_SMALLER_OR_EQUALT_IS_GREATER_OR_EQUALT_NULLSAFE_OBJECT_OPERATORT_MATCHT_ATTRIBUTET_NAME_RELATIVET_NAME_QUALIFIEDT_NAME_FULLY_QUALIFIED" -var _ID_index = [...]uint16{0, 9, 23, 29, 33, 42, 51, 59, 75, 85, 97, 110, 121, 136, 161, 187, 193, 197, 204, 214, 219, 227, 236, 248, 257, 269, 273, 281, 292, 298, 307, 314, 324, 330, 340, 344, 351, 359, 364, 371, 380, 387, 392, 403, 411, 416, 423, 430, 437, 452, 459, 466, 477, 486, 498, 515, 529, 535, 542, 552, 561, 570, 580, 588, 594, 600, 609, 622, 632, 652, 663, 675, 690, 703, 729, 741, 763, 774, 780, 785, 799, 809, 815, 824, 838, 850, 863, 876, 888, 893, 900, 908, 914, 921, 928, 935, 943, 953, 960, 969, 980, 988, 993, 998, 1010, 1020, 1033, 1046, 1058, 1071, 1082, 1094, 1104, 1115, 1123, 1135, 1148, 1159, 1170, 1181, 1195, 1206, 1217, 1227, 1238, 1248, 1258, 1274, 1286, 1299, 1304, 1308, 1312, 1326, 1344, 1354, 1368, 1389, 1410} +var _ID_index = [...]uint16{0, 9, 23, 29, 33, 42, 51, 59, 75, 85, 97, 110, 121, 136, 161, 187, 193, 197, 204, 214, 219, 227, 236, 248, 257, 269, 273, 281, 292, 298, 307, 314, 324, 330, 340, 344, 351, 359, 364, 371, 380, 387, 392, 403, 411, 416, 423, 430, 437, 452, 459, 466, 477, 486, 498, 515, 529, 535, 542, 552, 561, 570, 580, 588, 594, 600, 609, 622, 632, 652, 663, 675, 690, 703, 729, 741, 763, 774, 780, 785, 799, 809, 815, 824, 838, 850, 863, 876, 888, 893, 900, 908, 914, 921, 928, 935, 943, 953, 960, 969, 980, 988, 993, 998, 1010, 1020, 1033, 1046, 1058, 1071, 1082, 1094, 1104, 1115, 1123, 1135, 1148, 1159, 1170, 1181, 1195, 1206, 1217, 1227, 1238, 1248, 1258, 1274, 1286, 1299, 1304, 1308, 1312, 1326, 1344, 1354, 1368, 1389, 1410, 1436, 1443, 1454, 1469, 1485, 1507} func (i ID) String() string { i -= 57346 diff --git a/pkg/version/version.go b/pkg/version/version.go index 632baeb..c8c6820 100644 --- a/pkg/version/version.go +++ b/pkg/version/version.go @@ -22,6 +22,9 @@ var ( php7RangeStart = &Version{Major: 7} php7RangeEnd = &Version{Major: 7, Minor: 4} + + php8RangeStart = &Version{Major: 8} + php8RangeEnd = &Version{Major: 8, Minor: 1} ) func New(v string) (*Version, error) { @@ -48,7 +51,9 @@ func New(v string) (*Version, error) { } func (v *Version) Validate() error { - if !v.InRange(php5RangeStart, php5RangeEnd) && !v.InRange(php7RangeStart, php7RangeEnd) { + if !v.InRange(php5RangeStart, php5RangeEnd) && + !v.InRange(php7RangeStart, php7RangeEnd) && + !v.InRange(php8RangeStart, php8RangeEnd) { return ErrUnsupportedVer } @@ -75,7 +80,7 @@ func (v *Version) GreaterOrEqual(o *Version) bool { return v.Compare(o) >= 0 } -// GreaterOrEqual tests if one version is greater than another one or equal +// InRange tests if version is in range in another one func (v *Version) InRange(s, e *Version) bool { return v.Compare(s) >= 0 && v.Compare(e) <= 0 } diff --git a/pkg/version/version_test.go b/pkg/version/version_test.go index a2bde8b..c66ea06 100644 --- a/pkg/version/version_test.go +++ b/pkg/version/version_test.go @@ -1,9 +1,10 @@ package version_test import ( - "gotest.tools/assert" "testing" + "gotest.tools/assert" + "github.com/z7zmey/php-parser/pkg/version" ) @@ -46,3 +47,19 @@ func TestInRange(t *testing.T) { assert.NilError(t, err) assert.Assert(t, ver.InRange(s, e)) } + +func TestInRangePHP8(t *testing.T) { + s, err := version.New("8.0") + assert.NilError(t, err) + + e, err := version.New("8.1") + assert.NilError(t, err) + + ver, err := version.New("8.0") + assert.NilError(t, err) + assert.Assert(t, ver.InRange(s, e)) + + ver, err = version.New("8.1") + assert.NilError(t, err) + assert.Assert(t, ver.InRange(s, e)) +} diff --git a/pkg/visitor/dumper/dumper.go b/pkg/visitor/dumper/dumper.go index e38ebeb..74469d1 100644 --- a/pkg/visitor/dumper/dumper.go +++ b/pkg/visitor/dumper/dumper.go @@ -1,12 +1,13 @@ package dumper import ( - "github.com/z7zmey/php-parser/pkg/position" - "github.com/z7zmey/php-parser/pkg/token" "io" "strconv" "strings" + "github.com/z7zmey/php-parser/pkg/position" + "github.com/z7zmey/php-parser/pkg/token" + "github.com/z7zmey/php-parser/pkg/ast" ) @@ -192,6 +193,8 @@ func (v *Dumper) Parameter(n *ast.Parameter) { v.indent++ v.dumpPosition(n.Position) + v.dumpVertexList("AttrGroups", n.AttrGroups) + v.dumpVertex("Visibility", n.Visibility) v.dumpVertex("Type", n.Type) v.dumpToken("AmpersandTkn", n.AmpersandTkn) v.dumpToken("VariadicTkn", n.VariadicTkn) @@ -221,6 +224,8 @@ func (v *Dumper) Argument(n *ast.Argument) { v.dumpPosition(n.Position) v.dumpToken("AmpersandTkn", n.AmpersandTkn) + v.dumpVertex("Name", n.Name) + v.dumpToken("ColonTkn", n.ColonTkn) v.dumpToken("VariadicTkn", n.VariadicTkn) v.dumpVertex("Expr", n.Expr) @@ -228,6 +233,63 @@ func (v *Dumper) Argument(n *ast.Argument) { v.print(v.indent, "},\n") } +func (v *Dumper) MatchArm(n *ast.MatchArm) { + v.print(0, "&ast.MatchArm{\n") + v.indent++ + + v.dumpPosition(n.Position) + v.dumpToken("DefaultTkn", n.DefaultTkn) + v.dumpToken("DefaultCommaTkn", n.DefaultCommaTkn) + v.dumpVertexList("Exprs", n.Exprs) + v.dumpTokenList("SeparatorTkns", n.SeparatorTkns) + v.dumpToken("DoubleArrowTkn", n.DoubleArrowTkn) + v.dumpVertex("ReturnExpr", n.ReturnExpr) + + v.indent-- + v.print(v.indent, "},\n") +} + +func (v *Dumper) Union(n *ast.Union) { + v.print(0, "&ast.Union{\n") + v.indent++ + + v.dumpPosition(n.Position) + v.dumpVertexList("Types", n.Types) + v.dumpTokenList("SeparatorTkns", n.SeparatorTkns) + + v.indent-- + v.print(v.indent, "},\n") +} + +func (v *Dumper) Attribute(n *ast.Attribute) { + v.print(0, "&ast.Attribute{\n") + v.indent++ + + v.dumpPosition(n.Position) + v.dumpVertex("Name", n.Name) + v.dumpToken("OpenParenthesisTkn", n.OpenParenthesisTkn) + v.dumpVertexList("Args", n.Args) + v.dumpTokenList("SeparatorTkns", n.SeparatorTkns) + v.dumpToken("CloseParenthesisTkn", n.CloseParenthesisTkn) + + v.indent-- + v.print(v.indent, "},\n") +} + +func (v *Dumper) AttributeGroup(n *ast.AttributeGroup) { + v.print(0, "&ast.AttributeGroup{\n") + v.indent++ + + v.dumpPosition(n.Position) + v.dumpToken("OpenAttributeTkn", n.OpenAttributeTkn) + v.dumpVertexList("Attrs", n.Attrs) + v.dumpTokenList("SeparatorTkns", n.SeparatorTkns) + v.dumpToken("CloseAttributeTkn", n.CloseAttributeTkn) + + v.indent-- + v.print(v.indent, "},\n") +} + func (v *Dumper) StmtBreak(n *ast.StmtBreak) { v.print(0, "&ast.StmtBreak{\n") v.indent++ @@ -279,6 +341,7 @@ func (v *Dumper) StmtClass(n *ast.StmtClass) { v.indent++ v.dumpPosition(n.Position) + v.dumpVertexList("AttrGroups", n.AttrGroups) v.dumpVertexList("Modifiers", n.Modifiers) v.dumpToken("ClassTkn", n.ClassTkn) v.dumpVertex("Name", n.Name) @@ -304,6 +367,7 @@ func (v *Dumper) StmtClassConstList(n *ast.StmtClassConstList) { v.indent++ v.dumpPosition(n.Position) + v.dumpVertexList("AttrGroups", n.AttrGroups) v.dumpVertexList("Modifiers", n.Modifiers) v.dumpToken("ConstTkn", n.ConstTkn) v.dumpVertexList("Consts", n.Consts) @@ -319,6 +383,7 @@ func (v *Dumper) StmtClassMethod(n *ast.StmtClassMethod) { v.indent++ v.dumpPosition(n.Position) + v.dumpVertexList("AttrGroups", n.AttrGroups) v.dumpVertexList("Modifiers", n.Modifiers) v.dumpToken("FunctionTkn", n.FunctionTkn) v.dumpToken("AmpersandTkn", n.AmpersandTkn) @@ -547,6 +612,7 @@ func (v *Dumper) StmtFunction(n *ast.StmtFunction) { v.indent++ v.dumpPosition(n.Position) + v.dumpVertexList("AttrGroups", n.AttrGroups) v.dumpToken("FunctionTkn", n.FunctionTkn) v.dumpToken("AmpersandTkn", n.AmpersandTkn) v.dumpVertex("Name", n.Name) @@ -642,6 +708,7 @@ func (v *Dumper) StmtInterface(n *ast.StmtInterface) { v.indent++ v.dumpPosition(n.Position) + v.dumpVertexList("AttrGroups", n.AttrGroups) v.dumpToken("InterfaceTkn", n.InterfaceTkn) v.dumpVertex("Name", n.Name) v.dumpToken("ExtendsTkn", n.ExtendsTkn) @@ -712,6 +779,7 @@ func (v *Dumper) StmtPropertyList(n *ast.StmtPropertyList) { v.indent++ v.dumpPosition(n.Position) + v.dumpVertexList("AttrGroups", n.AttrGroups) v.dumpVertexList("Modifiers", n.Modifiers) v.dumpVertex("Type", n.Type) v.dumpVertexList("Props", n.Props) @@ -814,6 +882,7 @@ func (v *Dumper) StmtTrait(n *ast.StmtTrait) { v.indent++ v.dumpPosition(n.Position) + v.dumpVertexList("AttrGroups", n.AttrGroups) v.dumpToken("TraitTkn", n.TraitTkn) v.dumpVertex("Name", n.Name) v.dumpToken("OpenCurlyBracketTkn", n.OpenCurlyBracketTkn) @@ -1024,6 +1093,7 @@ func (v *Dumper) ExprArrowFunction(n *ast.ExprArrowFunction) { v.indent++ v.dumpPosition(n.Position) + v.dumpVertexList("AttrGroups", n.AttrGroups) v.dumpToken("StaticTkn", n.StaticTkn) v.dumpToken("FnTkn", n.FnTkn) v.dumpToken("AmpersandTkn", n.AmpersandTkn) @@ -1107,6 +1177,7 @@ func (v *Dumper) ExprClosure(n *ast.ExprClosure) { v.indent++ v.dumpPosition(n.Position) + v.dumpVertexList("AttrGroups", n.AttrGroups) v.dumpToken("StaticTkn", n.StaticTkn) v.dumpToken("FunctionTkn", n.FunctionTkn) v.dumpToken("AmpersandTkn", n.AmpersandTkn) @@ -1307,6 +1378,25 @@ func (v *Dumper) ExprMethodCall(n *ast.ExprMethodCall) { v.print(v.indent, "},\n") } +func (v *Dumper) ExprNullsafeMethodCall(n *ast.ExprNullsafeMethodCall) { + v.print(0, "&ast.ExprNullsafeMethodCall{\n") + v.indent++ + + v.dumpPosition(n.Position) + v.dumpVertex("Var", n.Var) + v.dumpToken("ObjectOperatorTkn", n.ObjectOperatorTkn) + v.dumpToken("OpenCurlyBracketTkn", n.OpenCurlyBracketTkn) + v.dumpVertex("Method", n.Method) + v.dumpToken("CloseCurlyBracketTkn", n.CloseCurlyBracketTkn) + v.dumpToken("OpenParenthesisTkn", n.OpenParenthesisTkn) + v.dumpVertexList("Args", n.Args) + v.dumpTokenList("SeparatorTkns", n.SeparatorTkns) + v.dumpToken("CloseParenthesisTkn", n.CloseParenthesisTkn) + + v.indent-- + v.print(v.indent, "},\n") +} + func (v *Dumper) ExprNew(n *ast.ExprNew) { v.print(0, "&ast.ExprNew{\n") v.indent++ @@ -1398,6 +1488,21 @@ func (v *Dumper) ExprPropertyFetch(n *ast.ExprPropertyFetch) { v.print(v.indent, "},\n") } +func (v *Dumper) ExprNullsafePropertyFetch(n *ast.ExprNullsafePropertyFetch) { + v.print(0, "&ast.ExprNullsafePropertyFetch{\n") + v.indent++ + + v.dumpPosition(n.Position) + v.dumpVertex("Var", n.Var) + v.dumpToken("ObjectOperatorTkn", n.ObjectOperatorTkn) + v.dumpToken("OpenCurlyBracketTkn", n.OpenCurlyBracketTkn) + v.dumpVertex("Prop", n.Prop) + v.dumpToken("CloseCurlyBracketTkn", n.CloseCurlyBracketTkn) + + v.indent-- + v.print(v.indent, "},\n") +} + func (v *Dumper) ExprRequire(n *ast.ExprRequire) { v.print(0, "&ast.ExprRequire{\n") v.indent++ @@ -2177,6 +2282,37 @@ func (v *Dumper) ExprCastUnset(n *ast.ExprCastUnset) { v.print(v.indent, "},\n") } +func (v *Dumper) ExprMatch(n *ast.ExprMatch) { + v.print(0, "&ast.ExprMatch{\n") + v.indent++ + + v.dumpPosition(n.Position) + v.dumpToken("MatchTkn", n.MatchTkn) + v.dumpToken("OpenParenthesisTkn", n.OpenParenthesisTkn) + v.dumpVertex("Expr", n.Expr) + v.dumpToken("CloseParenthesisTkn", n.CloseParenthesisTkn) + v.dumpToken("OpenCurlyBracketTkn", n.OpenCurlyBracketTkn) + v.dumpVertexList("Arms", n.Arms) + v.dumpTokenList("SeparatorTkns", n.SeparatorTkns) + v.dumpToken("CloseCurlyBracketTkn", n.CloseCurlyBracketTkn) + + v.indent-- + v.print(v.indent, "},\n") +} + +func (v *Dumper) ExprThrow(n *ast.ExprThrow) { + v.print(0, "&ast.ExprThrow{\n") + v.indent++ + + v.dumpPosition(n.Position) + v.dumpToken("ThrowTkn", n.ThrowTkn) + v.dumpVertex("Expr", n.Expr) + v.dumpToken("SemiColonTkn", n.SemiColonTkn) + + v.indent-- + v.print(v.indent, "},\n") +} + func (v *Dumper) ScalarDnumber(n *ast.ScalarDnumber) { v.print(0, "&ast.ScalarDnumber{\n") v.indent++ diff --git a/pkg/visitor/formatter/formatter.go b/pkg/visitor/formatter/formatter.go index 4f9ce9c..1a8b003 100644 --- a/pkg/visitor/formatter/formatter.go +++ b/pkg/visitor/formatter/formatter.go @@ -2,6 +2,7 @@ package formatter import ( "bytes" + "github.com/z7zmey/php-parser/pkg/ast" "github.com/z7zmey/php-parser/pkg/token" ) @@ -153,6 +154,18 @@ func (f *formatter) Nullable(n *ast.Nullable) { } func (f *formatter) Parameter(n *ast.Parameter) { + if n.AttrGroups != nil { + for _, group := range n.AttrGroups { + group.Accept(f) + } + f.addFreeFloating(token.T_WHITESPACE, []byte(" ")) + } + + if n.Visibility != nil { + n.Visibility.Accept(f) + f.addFreeFloating(token.T_WHITESPACE, []byte(" ")) + } + if n.Type != nil { n.Type.Accept(f) f.addFreeFloating(token.T_WHITESPACE, []byte(" ")) @@ -185,6 +198,14 @@ func (f *formatter) Identifier(n *ast.Identifier) { } func (f *formatter) Argument(n *ast.Argument) { + if n.Name != nil { + n.Name.Accept(f) + } + + if n.ColonTkn != nil { + n.ColonTkn = f.newToken(':', []byte(":")) + } + if n.VariadicTkn != nil { n.VariadicTkn = f.newToken(token.T_ELLIPSIS, []byte("...")) } @@ -196,6 +217,45 @@ func (f *formatter) Argument(n *ast.Argument) { n.Expr.Accept(f) } +func (f *formatter) MatchArm(n *ast.MatchArm) { + if n.DefaultTkn != nil { + n.DefaultTkn = f.newToken(token.T_DEFAULT, []byte("default")) + } + if n.DefaultCommaTkn != nil { + n.DefaultCommaTkn = f.newToken(',', []byte(",")) + } + n.SeparatorTkns = nil + if len(n.Exprs) > 0 { + n.SeparatorTkns = f.formatList(n.Exprs, ',') + } + n.DoubleArrowTkn = f.newToken(token.T_DOUBLE_ARROW, []byte("=>")) +} + +func (f *formatter) Union(n *ast.Union) { + if len(n.Types) > 0 { + n.SeparatorTkns = f.formatList(n.Types, '|') + } +} + +func (f *formatter) Attribute(n *ast.Attribute) { + n.Name.Accept(f) + n.OpenParenthesisTkn = f.newToken('(', []byte("(")) + n.SeparatorTkns = nil + if len(n.Args) > 0 { + n.SeparatorTkns = f.formatList(n.Args, ',') + } + n.CloseParenthesisTkn = f.newToken(')', []byte(")")) +} + +func (f *formatter) AttributeGroup(n *ast.AttributeGroup) { + n.OpenAttributeTkn = f.newToken(token.T_ATTRIBUTE, []byte("#[")) + n.SeparatorTkns = nil + if len(n.Attrs) > 0 { + n.SeparatorTkns = f.formatList(n.Attrs, ',') + } + n.CloseAttributeTkn = f.newToken(']', []byte("]")) +} + func (f *formatter) StmtBreak(n *ast.StmtBreak) { n.BreakTkn = f.newToken(token.T_BREAK, []byte("break")) @@ -307,6 +367,10 @@ func (f *formatter) StmtClass(n *ast.StmtClass) { } func (f *formatter) StmtClassConstList(n *ast.StmtClassConstList) { + for _, m := range n.AttrGroups { + m.Accept(f) + f.addFreeFloating(token.T_WHITESPACE, []byte("\n")) + } for _, m := range n.Modifiers { m.Accept(f) f.addFreeFloating(token.T_WHITESPACE, []byte(" ")) @@ -736,6 +800,10 @@ func (f *formatter) StmtProperty(n *ast.StmtProperty) { } func (f *formatter) StmtPropertyList(n *ast.StmtPropertyList) { + for _, m := range n.AttrGroups { + m.Accept(f) + f.addFreeFloating(token.T_WHITESPACE, []byte("\n")) + } for _, m := range n.Modifiers { m.Accept(f) f.addFreeFloating(token.T_WHITESPACE, []byte(" ")) @@ -1061,6 +1129,13 @@ func (f *formatter) ExprArrayItem(n *ast.ExprArrayItem) { } func (f *formatter) ExprArrowFunction(n *ast.ExprArrowFunction) { + if n.AttrGroups != nil { + for _, group := range n.AttrGroups { + group.Accept(f) + } + f.addFreeFloating(token.T_WHITESPACE, []byte(" ")) + } + if n.StaticTkn != nil { n.StaticTkn = f.newToken(token.T_STATIC, []byte("static")) f.addFreeFloating(token.T_WHITESPACE, []byte(" ")) @@ -1123,6 +1198,13 @@ func (f *formatter) ExprClone(n *ast.ExprClone) { } func (f *formatter) ExprClosure(n *ast.ExprClosure) { + if n.AttrGroups != nil { + for _, group := range n.AttrGroups { + group.Accept(f) + } + f.addFreeFloating(token.T_WHITESPACE, []byte(" ")) + } + if n.StaticTkn != nil { n.StaticTkn = f.newToken(token.T_STATIC, []byte("static")) f.addFreeFloating(token.T_WHITESPACE, []byte(" ")) @@ -1287,6 +1369,30 @@ func (f *formatter) ExprMethodCall(n *ast.ExprMethodCall) { n.CloseParenthesisTkn = f.newToken(')', []byte(")")) } +func (f *formatter) ExprNullsafeMethodCall(n *ast.ExprNullsafeMethodCall) { + n.Var.Accept(f) + n.ObjectOperatorTkn = f.newToken(token.T_NULLSAFE_OBJECT_OPERATOR, []byte("?->")) + + n.OpenCurlyBracketTkn = nil + n.CloseCurlyBracketTkn = nil + switch n.Method.(type) { + case *ast.Identifier: + case *ast.ExprVariable: + default: + n.OpenCurlyBracketTkn = f.newToken('{', []byte("{")) + n.CloseCurlyBracketTkn = f.newToken('}', []byte("}")) + } + + n.Method.Accept(f) + + n.OpenParenthesisTkn = f.newToken('(', []byte("(")) + n.SeparatorTkns = nil + if len(n.Args) > 0 { + n.SeparatorTkns = f.formatList(n.Args, ',') + } + n.CloseParenthesisTkn = f.newToken(')', []byte(")")) +} + func (f *formatter) ExprNew(n *ast.ExprNew) { n.NewTkn = f.newToken(token.T_NEW, []byte("new")) f.addFreeFloating(token.T_WHITESPACE, []byte(" ")) @@ -1347,6 +1453,23 @@ func (f *formatter) ExprPropertyFetch(n *ast.ExprPropertyFetch) { n.Prop.Accept(f) } +func (f *formatter) ExprNullsafePropertyFetch(n *ast.ExprNullsafePropertyFetch) { + n.Var.Accept(f) + n.ObjectOperatorTkn = f.newToken(token.T_NULLSAFE_OBJECT_OPERATOR, []byte("?->")) + + n.OpenCurlyBracketTkn = nil + n.CloseCurlyBracketTkn = nil + switch n.Prop.(type) { + case *ast.Identifier: + case *ast.ExprVariable: + default: + n.OpenCurlyBracketTkn = f.newToken('{', []byte("{")) + n.CloseCurlyBracketTkn = f.newToken('}', []byte("}")) + } + + n.Prop.Accept(f) +} + func (f *formatter) ExprRequire(n *ast.ExprRequire) { n.RequireTkn = f.newToken(token.T_REQUIRE, []byte("require")) f.addFreeFloating(token.T_WHITESPACE, []byte(" ")) @@ -1916,6 +2039,27 @@ func (f *formatter) ExprCastUnset(n *ast.ExprCastUnset) { n.Expr.Accept(f) } +func (f *formatter) ExprMatch(n *ast.ExprMatch) { + n.MatchTkn = f.newToken(token.T_MATCH, []byte("match")) + n.OpenParenthesisTkn = f.newToken('(', []byte("(")) + n.CloseParenthesisTkn = f.newToken(')', []byte(")")) + n.OpenCurlyBracketTkn = f.newToken('}', []byte("}")) + n.SeparatorTkns = nil + if len(n.Arms) > 0 { + n.SeparatorTkns = f.formatList(n.Arms, ',') + } + n.CloseCurlyBracketTkn = f.newToken('{', []byte("{")) +} + +func (f *formatter) ExprThrow(n *ast.ExprThrow) { + n.ThrowTkn = f.newToken(token.T_THROW, []byte("throw")) + f.addFreeFloating(token.T_WHITESPACE, []byte(" ")) + + n.Expr.Accept(f) + + n.SemiColonTkn = f.newSemicolonTkn() +} + func (f *formatter) ScalarDnumber(n *ast.ScalarDnumber) { if n.NumberTkn == nil { n.NumberTkn = f.newToken(token.T_STRING, n.Value) diff --git a/pkg/visitor/nsresolver/namespace_resolver.go b/pkg/visitor/nsresolver/namespace_resolver.go index 4d17444..86ef054 100644 --- a/pkg/visitor/nsresolver/namespace_resolver.go +++ b/pkg/visitor/nsresolver/namespace_resolver.go @@ -3,9 +3,10 @@ package nsresolver import ( "errors" + "strings" + "github.com/z7zmey/php-parser/pkg/ast" "github.com/z7zmey/php-parser/pkg/visitor" - "strings" ) // NamespaceResolver visitor diff --git a/pkg/visitor/null.go b/pkg/visitor/null.go index e5edcc0..238af60 100644 --- a/pkg/visitor/null.go +++ b/pkg/visitor/null.go @@ -42,6 +42,22 @@ func (v *Null) Argument(_ *ast.Argument) { // do nothing } +func (v *Null) MatchArm(_ *ast.MatchArm) { + // do nothing +} + +func (v *Null) Union(_ *ast.Union) { + // do nothing +} + +func (v *Null) Attribute(_ *ast.Attribute) { + // do nothing +} + +func (v *Null) AttributeGroup(_ *ast.AttributeGroup) { + // do nothing +} + func (v *Null) StmtBreak(_ *ast.StmtBreak) { // do nothing } @@ -322,6 +338,10 @@ func (v *Null) ExprMethodCall(_ *ast.ExprMethodCall) { // do nothing } +func (v *Null) ExprNullsafeMethodCall(_ *ast.ExprNullsafeMethodCall) { + // do nothing +} + func (v *Null) ExprNew(_ *ast.ExprNew) { // do nothing } @@ -350,6 +370,10 @@ func (v *Null) ExprPropertyFetch(_ *ast.ExprPropertyFetch) { // do nothing } +func (v *Null) ExprNullsafePropertyFetch(_ *ast.ExprNullsafePropertyFetch) { + // do nothing +} + func (v *Null) ExprRequire(_ *ast.ExprRequire) { // do nothing } @@ -590,6 +614,14 @@ func (v *Null) ExprCastUnset(_ *ast.ExprCastUnset) { // do nothing } +func (v *Null) ExprMatch(_ *ast.ExprMatch) { + // do nothing +} + +func (v *Null) ExprThrow(_ *ast.ExprThrow) { + // do nothing +} + func (v *Null) ScalarDnumber(_ *ast.ScalarDnumber) { // do nothing } diff --git a/pkg/visitor/printer/printer.go b/pkg/visitor/printer/printer.go index 76e230e..a288028 100644 --- a/pkg/visitor/printer/printer.go +++ b/pkg/visitor/printer/printer.go @@ -2,9 +2,10 @@ package printer import ( "bytes" + "io" + "github.com/z7zmey/php-parser/pkg/ast" "github.com/z7zmey/php-parser/pkg/token" - "io" ) type printerState int @@ -145,6 +146,8 @@ func (p *printer) Nullable(n *ast.Nullable) { } func (p *printer) Parameter(n *ast.Parameter) { + p.printList(n.AttrGroups) + p.printNode(n.Visibility) p.printNode(n.Type) p.printToken(n.AmpersandTkn, nil) p.printToken(n.VariadicTkn, nil) @@ -158,11 +161,38 @@ func (p *printer) Identifier(n *ast.Identifier) { } func (p *printer) Argument(n *ast.Argument) { + p.printNode(n.Name) + p.printToken(n.ColonTkn, nil) p.printToken(n.VariadicTkn, nil) p.printToken(n.AmpersandTkn, nil) p.printNode(n.Expr) } +func (p *printer) MatchArm(n *ast.MatchArm) { + p.printToken(n.DefaultTkn, nil) + p.printToken(n.DefaultCommaTkn, nil) + p.printSeparatedList(n.Exprs, n.SeparatorTkns, []byte(",")) + p.printToken(n.DoubleArrowTkn, []byte("=>")) + p.printNode(n.ReturnExpr) +} + +func (p *printer) Union(n *ast.Union) { + p.printSeparatedList(n.Types, n.SeparatorTkns, []byte("|")) +} + +func (p *printer) Attribute(n *ast.Attribute) { + p.printNode(n.Name) + p.printToken(n.OpenParenthesisTkn, p.ifNodeList(n.Args, []byte("("))) + p.printSeparatedList(n.Args, n.SeparatorTkns, []byte(",")) + p.printToken(n.CloseParenthesisTkn, p.ifNodeList(n.Args, []byte(")"))) +} + +func (p *printer) AttributeGroup(n *ast.AttributeGroup) { + p.printToken(n.OpenAttributeTkn, []byte("#[")) + p.printSeparatedList(n.Attrs, n.SeparatorTkns, []byte(",")) + p.printToken(n.CloseAttributeTkn, []byte("]")) +} + func (p *printer) StmtBreak(n *ast.StmtBreak) { p.printToken(n.BreakTkn, []byte("break")) p.printNode(n.Expr) @@ -188,6 +218,7 @@ func (p *printer) StmtCatch(n *ast.StmtCatch) { } func (p *printer) StmtClass(n *ast.StmtClass) { + p.printList(n.AttrGroups) p.printList(n.Modifiers) p.printToken(n.ClassTkn, []byte("class")) p.printNode(n.Name) @@ -204,6 +235,7 @@ func (p *printer) StmtClass(n *ast.StmtClass) { } func (p *printer) StmtClassConstList(n *ast.StmtClassConstList) { + p.printList(n.AttrGroups) p.printList(n.Modifiers) p.printToken(n.ConstTkn, []byte("const")) p.printSeparatedList(n.Consts, n.SeparatorTkns, []byte(",")) @@ -211,6 +243,7 @@ func (p *printer) StmtClassConstList(n *ast.StmtClassConstList) { } func (p *printer) StmtClassMethod(n *ast.StmtClassMethod) { + p.printList(n.AttrGroups) p.printList(n.Modifiers) p.printToken(n.FunctionTkn, []byte("function")) p.printToken(n.AmpersandTkn, nil) @@ -364,6 +397,7 @@ func (p *printer) StmtForeach(n *ast.StmtForeach) { } func (p *printer) StmtFunction(n *ast.StmtFunction) { + p.printList(n.AttrGroups) p.printToken(n.FunctionTkn, []byte("function")) p.printToken(n.AmpersandTkn, nil) p.printNode(n.Name) @@ -426,6 +460,7 @@ func (p *printer) StmtInlineHtml(n *ast.StmtInlineHtml) { } func (p *printer) StmtInterface(n *ast.StmtInterface) { + p.printList(n.AttrGroups) p.printToken(n.InterfaceTkn, []byte("interface")) p.printNode(n.Name) p.printToken(n.ExtendsTkn, p.ifNodeList(n.Extends, []byte("extends"))) @@ -460,6 +495,7 @@ func (p *printer) StmtProperty(n *ast.StmtProperty) { } func (p *printer) StmtPropertyList(n *ast.StmtPropertyList) { + p.printList(n.AttrGroups) p.printList(n.Modifiers) p.printNode(n.Type) p.printSeparatedList(n.Props, n.SeparatorTkns, []byte(",")) @@ -511,6 +547,7 @@ func (p *printer) StmtThrow(n *ast.StmtThrow) { } func (p *printer) StmtTrait(n *ast.StmtTrait) { + p.printList(n.AttrGroups) p.printToken(n.TraitTkn, []byte("trait")) p.printNode(n.Name) p.printToken(n.OpenCurlyBracketTkn, []byte("{")) @@ -630,6 +667,7 @@ func (p *printer) ExprArrayItem(n *ast.ExprArrayItem) { } func (p *printer) ExprArrowFunction(n *ast.ExprArrowFunction) { + p.printList(n.AttrGroups) p.printToken(n.StaticTkn, nil) p.printToken(n.FnTkn, []byte("fn")) p.printToken(n.AmpersandTkn, nil) @@ -670,6 +708,7 @@ func (p *printer) ExprClone(n *ast.ExprClone) { } func (p *printer) ExprClosure(n *ast.ExprClosure) { + p.printList(n.AttrGroups) p.printToken(n.StaticTkn, nil) p.printToken(n.FunctionTkn, []byte("function")) p.printToken(n.AmpersandTkn, nil) @@ -770,6 +809,17 @@ func (p *printer) ExprMethodCall(n *ast.ExprMethodCall) { p.printToken(n.CloseParenthesisTkn, []byte(")")) } +func (p *printer) ExprNullsafeMethodCall(n *ast.ExprNullsafeMethodCall) { + p.printNode(n.Var) + p.printToken(n.ObjectOperatorTkn, []byte("?->")) + p.printToken(n.OpenCurlyBracketTkn, nil) + p.printNode(n.Method) + p.printToken(n.CloseCurlyBracketTkn, nil) + p.printToken(n.OpenParenthesisTkn, []byte("(")) + p.printSeparatedList(n.Args, n.SeparatorTkns, []byte(",")) + p.printToken(n.CloseParenthesisTkn, []byte(")")) +} + func (p *printer) ExprNew(n *ast.ExprNew) { p.printToken(n.NewTkn, []byte("new")) p.printNode(n.Class) @@ -811,6 +861,14 @@ func (p *printer) ExprPropertyFetch(n *ast.ExprPropertyFetch) { p.printToken(n.CloseCurlyBracketTkn, nil) } +func (p *printer) ExprNullsafePropertyFetch(n *ast.ExprNullsafePropertyFetch) { + p.printNode(n.Var) + p.printToken(n.ObjectOperatorTkn, []byte("?->")) + p.printToken(n.OpenCurlyBracketTkn, nil) + p.printNode(n.Prop) + p.printToken(n.CloseCurlyBracketTkn, nil) +} + func (p *printer) ExprRequire(n *ast.ExprRequire) { p.printToken(n.RequireTkn, []byte("require")) p.printNode(n.Expr) @@ -1169,6 +1227,21 @@ func (p *printer) ExprCastUnset(n *ast.ExprCastUnset) { p.printNode(n.Expr) } +func (p *printer) ExprMatch(n *ast.ExprMatch) { + p.printToken(n.MatchTkn, []byte("match")) + p.printToken(n.OpenParenthesisTkn, []byte("(")) + p.printNode(n.Expr) + p.printToken(n.CloseParenthesisTkn, []byte(")")) + p.printToken(n.OpenCurlyBracketTkn, []byte("{")) + p.printSeparatedList(n.Arms, n.SeparatorTkns, []byte(",")) + p.printToken(n.CloseCurlyBracketTkn, []byte("}")) +} + +func (p *printer) ExprThrow(n *ast.ExprThrow) { + p.printToken(n.ThrowTkn, []byte("throw")) + p.printNode(n.Expr) +} + func (p *printer) ScalarDnumber(n *ast.ScalarDnumber) { p.printToken(n.NumberTkn, n.Value) } diff --git a/pkg/visitor/printer/printer_php8_test.go b/pkg/visitor/printer/printer_php8_test.go new file mode 100644 index 0000000..d4edbc7 --- /dev/null +++ b/pkg/visitor/printer/printer_php8_test.go @@ -0,0 +1,2651 @@ +package printer_test + +import ( + "bytes" + "os" + "testing" + + "github.com/z7zmey/php-parser/internal/php8" + "github.com/z7zmey/php-parser/internal/tester" + "github.com/z7zmey/php-parser/pkg/ast" + "github.com/z7zmey/php-parser/pkg/conf" + "github.com/z7zmey/php-parser/pkg/version" + "github.com/z7zmey/php-parser/pkg/visitor/printer" + "gotest.tools/assert" +) + +func ExamplePrinterPHP8() { + src := `Hello + >= $b ; + ` + + actual := printPHP8(parsePHP8(src)) + + if src != actual { + t.Errorf("\nexpected: %s\ngot: %s\n", src, actual) + } +} + +// test binary + +func TestParseAndPrintBinaryPHP8(t *testing.T) { + src := `= $b ; + $a > $b ; + $a === $b ; + $a and $b ; + $a or $b ; + $a xor $b ; + $a - $b ; + $a % $b ; + $a * $b ; + $a != $b ; + $a <> $b ; + $a !== $b ; + $a + $b ; + $a ** $b ; + $a << $b ; + $a >> $b ; + $a <= $b ; + $a < $b ; + $a <=> $b ; + ` + + actual := printPHP8(parsePHP8(src)) + + if src != actual { + t.Errorf("\nexpected: %s\ngot: %s\n", src, actual) + } +} + +// test cast + +func TestParseAndPrintCastPHP8(t *testing.T) { + src := ` $world , + ... $unpack + ] ; + ` + + actual := printPHP8(parsePHP8(src)) + + if src != actual { + t.Errorf("\nexpected: %s\ngot: %s\n", src, actual) + } +} + +func TestParseAndPrintArrayPHP8(t *testing.T) { + src := ` 2 ) ; + ` + + actual := printPHP8(parsePHP8(src)) + + if src != actual { + t.Errorf("\nexpected: %s\ngot: %s\n", src, actual) + } +} + +func TestParseAndPrintBitwiseNotPHP8(t *testing.T) { + src := ` $c ; + ` + + actual := printPHP8(parsePHP8(src)) + + if src != actual { + t.Errorf("\nexpected: %s\ngot: %s\n", src, actual) + } +} + +func TestParseAndPrintConstFetchPHP8(t *testing.T) { + src := ` bar ( $arg , ) ;` + + actual := printPHP8(parsePHP8(src)) + + if src != actual { + t.Errorf("\nexpected: %s\ngot: %s\n", src, actual) + } +} + +func TestParseAndPrintNewPHP8(t *testing.T) { + src := ` b ;` + + actual := printPHP8(parsePHP8(src)) + + if src != actual { + t.Errorf("\nexpected: %s\ngot: %s\n", src, actual) + } +} + +func TestParseAndPrintReferencePHP8(t *testing.T) { + src := ` & $c ] ; + + $a = function ( ) use ( & $b ) { + // do nothing + } ; + + foreach ( $a as & $b ) { + // do nothing + }` + + actual := printPHP8(parsePHP8(src)) + + if src != actual { + t.Errorf("\nexpected: %s\ngot: %s\n", src, actual) + } +} + +func TestParseAndPrintRequirePHP8(t *testing.T) { + + src := ` & $b , // one + $c , /* two */ + ] ; + $a = [0, 1, 2] ;` + + actual := printPHP8(parsePHP8(src)) + + if src != actual { + t.Errorf("\nexpected: %s\ngot: %s\n", src, actual) + } +} + +func TestParseAndPrintShortListPHP8(t *testing.T) { + src := ` $v ; + yield from $a ;` + + actual := printPHP8(parsePHP8(src)) + + if src != actual { + t.Errorf("\nexpected: %s\ngot: %s\n", src, actual) + } +} + +// test stmt + +func TestParseAndPrintAltIfPHP8(t *testing.T) { + src := ` & $v ) : + echo $v ; + endforeach ;` + + actual := printPHP8(parsePHP8(src)) + + if src != actual { + t.Errorf("\nexpected: %s\ngot: %s\n", src, actual) + } +} + +func TestParseAndPrintAltSwitchPHP8(t *testing.T) { + src := ` + + + & $v ) { + ; + }` + + actual := printPHP8(parsePHP8(src)) + + if src != actual { + t.Errorf("\nexpected: %s\ngot: %s\n", src, actual) + } +} + +func TestParseAndPrintFunctionPHP8(t *testing.T) { + + src := `testtest call ( ) ; + $a -> { $b . 'b' } ; + ` + + actual := printPHP8(parsePHP8(src)) + + if src != actual { + t.Errorf("\nexpected: %s\ngot: %s\n", src, actual) + } +} + +func TestParseAndPrintComplexString1PHP8(t *testing.T) { + src := `bar" ; + ` + + actual := printPHP8(parsePHP8(src)) + + if src != actual { + t.Errorf("\nexpected: %s\ngot: %s\n", src, actual) + } +} + +func TestParseAndPrintComplexString2PHP8(t *testing.T) { + src := ` bar }" ; + "test ${ $foo -> bar ( ) }" ; + "test ${ $a . '' }" ; + ` + + actual := printPHP8(parsePHP8(src)) + + if src != actual { + t.Errorf("\nexpected: %s\ngot: %s\n", src, actual) + } +} + +func TestParseAndPrintComplexString3PHP8(t *testing.T) { + src := ` bar }" ; + "test ${$foo -> bar ( ) }" ; + "test ${$a . '' }" ; + ` + + actual := printPHP8(parsePHP8(src)) + + if src != actual { + t.Errorf("\nexpected: %s\ngot: %s\n", src, actual) + } +} + +func TestParseAndPrintComplexString4PHP8(t *testing.T) { + src := ` bar }" ; + "test {$foo -> bar ( ) }" ; + ` + + actual := printPHP8(parsePHP8(src)) + + if src != actual { + t.Errorf("\nexpected: %s\ngot: %s\n", src, actual) + } +} + +func TestParseAndPrintNullsafePHP8(t *testing.T) { + src := `method(); +$a?->prop; +"$a?->prop_inside_string"; +(f())?->prop_for_expr; + ` + + actual := printPHP8(parsePHP8(src)) + + if src != actual { + t.Errorf("\nexpected: %s\ngot: %s\n", src, actual) + } +} + +func TestParseAndPrintNamedMethods(t *testing.T) { + src := `bar(some: $a); +$foo->bar(some: $a, $b, ...$c); +foo::bar(b: $b); +foo::bar($a, b: $b, ...$c); +$foo::bar(c: $a); +$foo::bar($b, c: $a, ...$b); +new foo(a: $a); +new foo(a: $a, $c, ...$b); +new class (name: $a) {}; +new class (name: $a, $b, ...$c) {}; + ` + + actual := printPHP8(parsePHP8(src)) + + if src != actual { + t.Errorf("\nexpected: %s\ngot: %s\n", src, actual) + } +} + +func TestParseAndPrintMatchPHP8(t *testing.T) { + src := ` 100, +}; +echo match($a) { + default => 100 +}; +echo match($a) { + default, => 100 +}; +echo match($a) { + default, => 100, +}; + +echo match($a) { + 10 => 100 +}; +echo match($a) { + 10 => 100, +}; +echo match($a) { + 10, => 100 +}; +echo match($a) { + 10, => 100, +}; + +echo match($a) { + 10, 20 => 100 +}; +echo match($a) { + 10, 20 => 100, +}; +echo match($a) { + 10, 20, => 100 +}; +echo match($a) { + 10, 20, => 100, +}; + +echo match($a) { + 10, 20 => 100, + 30, 40 => 101 +}; +echo match($a) { + 10, 20 => 100, + 30, 40 => 101, +}; +echo match($a) { + 10, 20, => 100, + 30, 40, => 101 +}; + +echo match($a) { + 10, 20 => 100, + 30, 40 => 101, + default => 102, +}; + ` + + actual := printPHP8(parsePHP8(src)) + + assert.Equal(t, src, actual) +} + +func TestParseAndPrintUnionTypesPHP8(t *testing.T) { + src := ` $a; + $_ = fn(int|string|float $a) => $a; + $_ = fn(int|string|float|bool $a) => $a; + $_ = fn(int|\Foo $a) => $a; + $_ = fn(\Foo|int $a) => $a; + $_ = fn(\Foo|\Boo $a) => $a; + // $_ = fn(\Foo|static $a) => $a; // static cannot be used here. + $_ = fn(\Namespaced\Foo|\Boo $a) => $a; + + $_ = fn(): int|string => null; + $_ = fn(): int|\Boo => null; + $_ = fn(): \Foo|\Boo => null; + $_ = fn(): \Namespaced\Foo|\Boo => null; + $_ = fn(): \Foo|static => null; + $_ = fn(): \Foo|void => null; +} + +class Foo { + public int|string $a; + public int|string|float $a; + public int|\Foo $a; + public \Foo|\Boo $a; + public \Namespaced\Foo|\Boo $a; + public \Namespaced\Foo|\Boo|int $a; + // public static $a; // static cannot be used here. + + public function f(int|\Foo $a) {} + public function f(\Foo|int $a) {} + public function f(\Foo|\Boo $a) {} + public function f(\Namespaced\Foo|\Boo $a) {} + // public function f(static|\Boo $a) {} // static cannot be used here. + + public function f(int|\Foo $a = null) {} + public function f(\Foo|int $a = null) {} + public function f(\Foo|\Boo $a = null) {} + public function f(\Namespaced\Foo|\Boo $a = null) {} + + public function f(): int|string {} + public function f(): int|\Boo {} + public function f(): \Foo|\Boo {} + public function f(): \Namespaced\Foo|\Boo {} + public function f(): int|static {} // static can be used here. +} + ` + + actual := printPHP8(parsePHP8(src)) + + assert.Equal(t, src, actual) +} + +func TestParseAndPrintTryCatchWithoutVariablePHP8(t *testing.T) { + src := ` 10; + + $_ = fn( + $a, + ) => 10; +} + +// Without comma. +function f( + $a, + $b +) {} + +function f( + $a +) {} + + +class Foo { + public function f( + $a, + $b + ) {} + + public function f( + $a + ) {} +} + +function f() { + $_ = function( + $a, + $b + ) {}; + + $_ = function( + $a + ) {}; + + $_ = fn( + $a, + $b + ) => 10; + + $_ = fn( + $a + ) => 10; +} + ` + + actual := printPHP8(parsePHP8(src)) + + assert.Equal(t, src, actual) +} + +func TestParseAndPrintThrowExprAndStmtPHP8(t *testing.T) { + src := `createNotFoundException(); + +throw $exception = new Exception(); + +// As stmt. +throw new InvalidArgumentException(); + ` + + actual := printPHP8(parsePHP8(src)) + + assert.Equal(t, src, actual) +} + +func TestParseAndPrintPropertyInConstructorPHP8(t *testing.T) { + src := ` 1; + + $_ = + #[AttributeWithArgs(100, SomeClass::class)] + fn () => 1; + + $_ = + #[FirstAttribute(100, SomeClass::class), SecondAttribute()] + fn &(): void => 1; + + $_ = + #[ + FirstLineAttribute(100, SomeClass::class), + SecondLineAttribute() + ] + fn () => 1; + + $_ = + #[FirstAttribute(100, SomeClass::class), SecondAttribute()] + #[SecondGroupFirstAttribute(SomeClass::class), SecondGroupSecondAttribute] + fn &(): int|string => 1; + + $_ = + #[\WithSlash] + fn () => 1; + + $_ = + #[\F\Q\N] + fn &(): \Foo|string => 1; +} +` + + actual := printPHP8(parsePHP8(src)) + + if src != actual { + t.Errorf("\nexpected: %s\ngot: %s\n", src, actual) + } +} + +func TestParseAndPrintAnonClassWithAttributesPHP8(t *testing.T) { + src := `length(); +"foo$bar"[0]; +"foo$bar"->length(); +`) +} + +func TestParseAndPrintConstantDerefencablePHP8(t *testing.T) { + tester.NewParserPrintTestSuite(t).UsePHP8().Run(`length; +A->length(); +A[0]; +A[0][1][2]; +A{0}; + +A::B[0]; +A::B[0][1][2]; +A::B{0}; +A::B->length; +A::B->length(); +A::B::C; +A::B::$c; +A::B::c(); +`) +} + +func TestParseAndPrintArbitraryExpressionsInNewAndInstanceOfPHP8(t *testing.T) { + tester.NewParserPrintTestSuite(t).UsePHP8().Run(`length; +__FUNCTION__->length(); +`) +} diff --git a/pkg/visitor/traverser/traverser.go b/pkg/visitor/traverser/traverser.go index 8cc0e30..276dd0a 100644 --- a/pkg/visitor/traverser/traverser.go +++ b/pkg/visitor/traverser/traverser.go @@ -37,6 +37,11 @@ func (t *Traverser) Nullable(n *ast.Nullable) { func (t *Traverser) Parameter(n *ast.Parameter) { n.Accept(t.v) + for _, nn := range n.AttrGroups { + nn.Accept(t) + } + + t.Traverse(n.Visibility) t.Traverse(n.Type) t.Traverse(n.Var) t.Traverse(n.DefaultValue) @@ -49,9 +54,44 @@ func (t *Traverser) Identifier(n *ast.Identifier) { func (t *Traverser) Argument(n *ast.Argument) { n.Accept(t.v) + t.Traverse(n.Name) t.Traverse(n.Expr) } +func (t *Traverser) MatchArm(n *ast.MatchArm) { + n.Accept(t.v) + + for _, nn := range n.Exprs { + nn.Accept(t) + } + t.Traverse(n.ReturnExpr) +} + +func (t *Traverser) Union(n *ast.Union) { + n.Accept(t.v) + + for _, nn := range n.Types { + nn.Accept(t) + } +} + +func (t *Traverser) Attribute(n *ast.Attribute) { + n.Accept(t.v) + + t.Traverse(n.Name) + for _, nn := range n.Args { + nn.Accept(t) + } +} + +func (t *Traverser) AttributeGroup(n *ast.AttributeGroup) { + n.Accept(t.v) + + for _, nn := range n.Attrs { + nn.Accept(t) + } +} + func (t *Traverser) StmtBreak(n *ast.StmtBreak) { n.Accept(t.v) @@ -82,6 +122,9 @@ func (t *Traverser) StmtCatch(n *ast.StmtCatch) { func (t *Traverser) StmtClass(n *ast.StmtClass) { n.Accept(t.v) + for _, nn := range n.AttrGroups { + nn.Accept(t) + } for _, nn := range n.Modifiers { nn.Accept(t) } @@ -101,6 +144,9 @@ func (t *Traverser) StmtClass(n *ast.StmtClass) { func (t *Traverser) StmtClassConstList(n *ast.StmtClassConstList) { n.Accept(t.v) + for _, nn := range n.AttrGroups { + nn.Accept(t) + } for _, nn := range n.Modifiers { nn.Accept(t) } @@ -112,6 +158,9 @@ func (t *Traverser) StmtClassConstList(n *ast.StmtClassConstList) { func (t *Traverser) StmtClassMethod(n *ast.StmtClassMethod) { n.Accept(t.v) + for _, nn := range n.AttrGroups { + nn.Accept(t) + } for _, nn := range n.Modifiers { nn.Accept(t) } @@ -230,6 +279,9 @@ func (t *Traverser) StmtForeach(n *ast.StmtForeach) { func (t *Traverser) StmtFunction(n *ast.StmtFunction) { n.Accept(t.v) + for _, nn := range n.AttrGroups { + nn.Accept(t) + } t.Traverse(n.Name) for _, nn := range n.Params { nn.Accept(t) @@ -276,6 +328,9 @@ func (t *Traverser) StmtInlineHtml(n *ast.StmtInlineHtml) { func (t *Traverser) StmtInterface(n *ast.StmtInterface) { n.Accept(t.v) + for _, nn := range n.AttrGroups { + nn.Accept(t) + } t.Traverse(n.Name) for _, nn := range n.Extends { nn.Accept(t) @@ -314,6 +369,9 @@ func (t *Traverser) StmtProperty(n *ast.StmtProperty) { func (t *Traverser) StmtPropertyList(n *ast.StmtPropertyList) { n.Accept(t.v) + for _, nn := range n.AttrGroups { + nn.Accept(t) + } for _, nn := range n.Modifiers { nn.Accept(t) } @@ -370,6 +428,9 @@ func (t *Traverser) StmtThrow(n *ast.StmtThrow) { func (t *Traverser) StmtTrait(n *ast.StmtTrait) { n.Accept(t.v) + for _, nn := range n.AttrGroups { + nn.Accept(t) + } t.Traverse(n.Name) for _, nn := range n.Stmts { nn.Accept(t) @@ -485,6 +546,9 @@ func (t *Traverser) ExprArrayItem(n *ast.ExprArrayItem) { func (t *Traverser) ExprArrowFunction(n *ast.ExprArrowFunction) { n.Accept(t.v) + for _, nn := range n.AttrGroups { + nn.Accept(t) + } for _, nn := range n.Params { nn.Accept(t) } @@ -526,6 +590,9 @@ func (t *Traverser) ExprClone(n *ast.ExprClone) { func (t *Traverser) ExprClosure(n *ast.ExprClosure) { n.Accept(t.v) + for _, nn := range n.AttrGroups { + nn.Accept(t) + } for _, nn := range n.Params { nn.Accept(t) } @@ -628,6 +695,16 @@ func (t *Traverser) ExprMethodCall(n *ast.ExprMethodCall) { } } +func (t *Traverser) ExprNullsafeMethodCall(n *ast.ExprNullsafeMethodCall) { + n.Accept(t.v) + + t.Traverse(n.Var) + t.Traverse(n.Method) + for _, nn := range n.Args { + nn.Accept(t) + } +} + func (t *Traverser) ExprNew(n *ast.ExprNew) { n.Accept(t.v) @@ -674,6 +751,13 @@ func (t *Traverser) ExprPropertyFetch(n *ast.ExprPropertyFetch) { t.Traverse(n.Prop) } +func (t *Traverser) ExprNullsafePropertyFetch(n *ast.ExprNullsafePropertyFetch) { + n.Accept(t.v) + + t.Traverse(n.Var) + t.Traverse(n.Prop) +} + func (t *Traverser) ExprRequire(n *ast.ExprRequire) { n.Accept(t.v) @@ -1086,6 +1170,21 @@ func (t *Traverser) ExprCastUnset(n *ast.ExprCastUnset) { t.Traverse(n.Expr) } +func (t *Traverser) ExprMatch(n *ast.ExprMatch) { + n.Accept(t.v) + + t.Traverse(n.Expr) + for _, nn := range n.Arms { + nn.Accept(t) + } +} + +func (t *Traverser) ExprThrow(n *ast.ExprThrow) { + n.Accept(t.v) + + t.Traverse(n.Expr) +} + func (t *Traverser) ScalarDnumber(n *ast.ScalarDnumber) { n.Accept(t.v) }