maride/php-parser
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[#82] handle php version

Browse Source
This commit is contained in:
z7zmey
2019-12-26 17:57:56 +02:00
parent 6afa2a089b
commit ec6be0d9bd
90 changed files with 673 additions and 616 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
parser/parser.go
View File

@@ -3,6 +3,9 @@ package parser
import (
"github.com/z7zmey/php-parser/errors"
"github.com/z7zmey/php-parser/node"
"github.com/z7zmey/php-parser/php5"
"github.com/z7zmey/php-parser/php7"
"github.com/z7zmey/php-parser/version"
)
// Parser interface
@@ -12,3 +15,20 @@ type Parser interface {
GetErrors() []*errors.Error
WithFreeFloating()
}
func NewParser(src []byte, v string) (Parser, error) {
var parser Parser
r, err := version.Compare(v, "7.0")
if err != nil {
return nil, err
}
if r == -1 {
parser = php5.NewParser(src, v)
} else {
parser = php7.NewParser(src, v)
}
return parser, nil
}

207
parser/position_builder.go
View File

@@ -1,207 +0,0 @@
package parser
import (
"github.com/z7zmey/php-parser/node"
"github.com/z7zmey/php-parser/position"
"github.com/z7zmey/php-parser/scanner"
)
// PositionBuilder provide functions to constuct positions
type PositionBuilder struct{}
type startPos struct {
startLine int
startPos int
}
type endPos struct {
endLine int
endPos int
}
func (b *PositionBuilder) getListStartPos(l []node.Node) startPos {
if l == nil {
return startPos{-1, -1}
}
if len(l) == 0 {
return startPos{-1, -1}
}
return b.getNodeStartPos(l[0])
}
func (b *PositionBuilder) getNodeStartPos(n node.Node) startPos {
sl := -1
sp := -1
if n == nil {
return startPos{-1, -1}
}
p := n.GetPosition()
if p != nil {
sl = p.StartLine
sp = p.StartPos
}
return startPos{sl, sp}
}
func (b *PositionBuilder) getListEndPos(l []node.Node) endPos {
if l == nil {
return endPos{-1, -1}
}
if len(l) == 0 {
return endPos{-1, -1}
}
return b.getNodeEndPos(l[len(l)-1])
}
func (b *PositionBuilder) getNodeEndPos(n node.Node) endPos {
el := -1
ep := -1
if n == nil {
return endPos{-1, -1}
}
p := n.GetPosition()
if p != nil {
el = p.EndLine
ep = p.EndPos
}
return endPos{el, ep}
}
// NewNodeListPosition returns new Position
func (b *PositionBuilder) NewNodeListPosition(list []node.Node) *position.Position {
return &position.Position{
StartLine: b.getListStartPos(list).startLine,
EndLine: b.getListEndPos(list).endLine,
StartPos: b.getListStartPos(list).startPos,
EndPos: b.getListEndPos(list).endPos,
}
}
// NewNodePosition returns new Position
func (b *PositionBuilder) NewNodePosition(n node.Node) *position.Position {
return &position.Position{
StartLine: b.getNodeStartPos(n).startLine,
EndLine: b.getNodeEndPos(n).endLine,
StartPos: b.getNodeStartPos(n).startPos,
EndPos: b.getNodeEndPos(n).endPos,
}
}
// NewTokenPosition returns new Position
func (b *PositionBuilder) NewTokenPosition(t *scanner.Token) *position.Position {
return &position.Position{
StartLine: t.StartLine,
EndLine: t.EndLine,
StartPos: t.StartPos,
EndPos: t.EndPos,
}
}
// NewTokensPosition returns new Position
func (b *PositionBuilder) NewTokensPosition(startToken *scanner.Token, endToken *scanner.Token) *position.Position {
return &position.Position{
StartLine: startToken.StartLine,
EndLine: endToken.EndLine,
StartPos: startToken.StartPos,
EndPos: endToken.EndPos,
}
}
// NewTokenNodePosition returns new Position
func (b *PositionBuilder) NewTokenNodePosition(t *scanner.Token, n node.Node) *position.Position {
return &position.Position{
StartLine: t.StartLine,
EndLine: b.getNodeEndPos(n).endLine,
StartPos: t.StartPos,
EndPos: b.getNodeEndPos(n).endPos,
}
}
// NewNodeTokenPosition returns new Position
func (b *PositionBuilder) NewNodeTokenPosition(n node.Node, t *scanner.Token) *position.Position {
return &position.Position{
StartLine: b.getNodeStartPos(n).startLine,
EndLine: t.EndLine,
StartPos: b.getNodeStartPos(n).startPos,
EndPos: t.EndPos,
}
}
// NewNodesPosition returns new Position
func (b *PositionBuilder) NewNodesPosition(startNode node.Node, endNode node.Node) *position.Position {
return &position.Position{
StartLine: b.getNodeStartPos(startNode).startLine,
EndLine: b.getNodeEndPos(endNode).endLine,
StartPos: b.getNodeStartPos(startNode).startPos,
EndPos: b.getNodeEndPos(endNode).endPos,
}
}
// NewNodeListTokenPosition returns new Position
func (b *PositionBuilder) NewNodeListTokenPosition(list []node.Node, t *scanner.Token) *position.Position {
return &position.Position{
StartLine: b.getListStartPos(list).startLine,
EndLine: t.EndLine,
StartPos: b.getListStartPos(list).startPos,
EndPos: t.EndPos,
}
}
// NewTokenNodeListPosition returns new Position
func (b *PositionBuilder) NewTokenNodeListPosition(t *scanner.Token, list []node.Node) *position.Position {
return &position.Position{
StartLine: t.StartLine,
EndLine: b.getListEndPos(list).endLine,
StartPos: t.StartPos,
EndPos: b.getListEndPos(list).endPos,
}
}
// NewNodeNodeListPosition returns new Position
func (b *PositionBuilder) NewNodeNodeListPosition(n node.Node, list []node.Node) *position.Position {
return &position.Position{
StartLine: b.getNodeStartPos(n).startLine,
EndLine: b.getListEndPos(list).endLine,
StartPos: b.getNodeStartPos(n).startPos,
EndPos: b.getListEndPos(list).endPos,
}
}
// NewNodeListNodePosition returns new Position
func (b *PositionBuilder) NewNodeListNodePosition(list []node.Node, n node.Node) *position.Position {
return &position.Position{
StartLine: b.getListStartPos(list).startLine,
EndLine: b.getNodeEndPos(n).endLine,
StartPos: b.getListStartPos(list).startPos,
EndPos: b.getNodeEndPos(n).endPos,
}
}
// NewOptionalListTokensPosition returns new Position
func (b *PositionBuilder) NewOptionalListTokensPosition(list []node.Node, t *scanner.Token, endToken *scanner.Token) *position.Position {
if list == nil {
return &position.Position{
StartLine: t.StartLine,
EndLine: endToken.EndLine,
StartPos: t.StartPos,
EndPos: endToken.EndPos,
}
}
return &position.Position{
StartLine: b.getListStartPos(list).startLine,
EndLine: endToken.EndLine,
StartPos: b.getListStartPos(list).startPos,
EndPos: endToken.EndPos,
}
}

463
parser/position_builder_test.go
View File

@@ -1,463 +0,0 @@
package parser_test
import (
"testing"
"github.com/z7zmey/php-parser/node"
"github.com/z7zmey/php-parser/parser"
"github.com/z7zmey/php-parser/position"
"github.com/z7zmey/php-parser/scanner"
)
func TestNewTokenPosition(t *testing.T) {
builder := parser.PositionBuilder{}
tkn := &scanner.Token{
Value: `foo`,
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 3,
}
pos := builder.NewTokenPosition(tkn)
if pos.String() != `Pos{Line: 1-1 Pos: 0-3}` {
t.Errorf("token value is not equal\n")
}
}
func TestNewTokensPosition(t *testing.T) {
builder := parser.PositionBuilder{}
token1 := &scanner.Token{
Value: `foo`,
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 3,
}
token2 := &scanner.Token{
Value: `foo`,
StartLine: 2,
EndLine: 2,
StartPos: 4,
EndPos: 6,
}
pos := builder.NewTokensPosition(token1, token2)
if pos.String() != `Pos{Line: 1-2 Pos: 0-6}` {
t.Errorf("token value is not equal\n")
}
}
func TestNewNodePosition(t *testing.T) {
n := node.NewIdentifier("test node")
n.SetPosition(&position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 3,
})
builder := parser.PositionBuilder{}
pos := builder.NewNodePosition(n)
if pos.String() != `Pos{Line: 1-1 Pos: 0-3}` {
t.Errorf("token value is not equal\n")
}
}
func TestNewTokenNodePosition(t *testing.T) {
tkn := &scanner.Token{
Value: `foo`,
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 3,
}
n := node.NewIdentifier("test node")
n.SetPosition(&position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 4,
EndPos: 12,
})
builder := parser.PositionBuilder{}
pos := builder.NewTokenNodePosition(tkn, n)
if pos.String() != `Pos{Line: 1-2 Pos: 0-12}` {
t.Errorf("token value is not equal\n")
}
}
func TestNewNodeTokenPosition(t *testing.T) {
n := node.NewIdentifier("test node")
n.SetPosition(&position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 9,
})
tkn := &scanner.Token{
Value: `foo`,
StartLine: 2,
EndLine: 2,
StartPos: 10,
EndPos: 12,
}
builder := parser.PositionBuilder{}
pos := builder.NewNodeTokenPosition(n, tkn)
if pos.String() != `Pos{Line: 1-2 Pos: 0-12}` {
t.Errorf("token value is not equal\n")
}
}
func TestNewNodeListPosition(t *testing.T) {
n1 := node.NewIdentifier("test node")
n1.SetPosition(&position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 9,
})
n2 := node.NewIdentifier("test node")
n2.SetPosition(&position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 10,
EndPos: 19,
})
builder := parser.PositionBuilder{}
pos := builder.NewNodeListPosition([]node.Node{n1, n2})
if pos.String() != `Pos{Line: 1-2 Pos: 0-19}` {
t.Errorf("token value is not equal\n")
}
}
func TestNewNodesPosition(t *testing.T) {
n1 := node.NewIdentifier("test node")
n1.SetPosition(&position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 9,
})
n2 := node.NewIdentifier("test node")
n2.SetPosition(&position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 10,
EndPos: 19,
})
builder := parser.PositionBuilder{}
pos := builder.NewNodesPosition(n1, n2)
if pos.String() != `Pos{Line: 1-2 Pos: 0-19}` {
t.Errorf("token value is not equal\n")
}
}
func TestNewNodeListTokenPosition(t *testing.T) {
n1 := node.NewIdentifier("test node")
n1.SetPosition(&position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 9,
})
n2 := node.NewIdentifier("test node")
n2.SetPosition(&position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 10,
EndPos: 19,
})
tkn := &scanner.Token{
Value: `foo`,
StartLine: 3,
EndLine: 3,
StartPos: 20,
EndPos: 22,
}
builder := parser.PositionBuilder{}
pos := builder.NewNodeListTokenPosition([]node.Node{n1, n2}, tkn)
if pos.String() != `Pos{Line: 1-3 Pos: 0-22}` {
t.Errorf("token value is not equal\n")
}
}
func TestNewTokenNodeListPosition(t *testing.T) {
tkn := &scanner.Token{
Value: `foo`,
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 2,
}
n1 := node.NewIdentifier("test node")
n1.SetPosition(&position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 3,
EndPos: 10,
})
n2 := node.NewIdentifier("test node")
n2.SetPosition(&position.Position{
StartLine: 3,
EndLine: 3,
StartPos: 11,
EndPos: 20,
})
builder := parser.PositionBuilder{}
pos := builder.NewTokenNodeListPosition(tkn, []node.Node{n1, n2})
if pos.String() != `Pos{Line: 1-3 Pos: 0-20}` {
t.Errorf("token value is not equal\n")
}
}
func TestNewNodeNodeListPosition(t *testing.T) {
n1 := node.NewIdentifier("test node")
n1.SetPosition(&position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 8,
})
n2 := node.NewIdentifier("test node")
n2.SetPosition(&position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 9,
EndPos: 17,
})
n3 := node.NewIdentifier("test node")
n3.SetPosition(&position.Position{
StartLine: 3,
EndLine: 3,
StartPos: 18,
EndPos: 26,
})
builder := parser.PositionBuilder{}
pos := builder.NewNodeNodeListPosition(n1, []node.Node{n2, n3})
if pos.String() != `Pos{Line: 1-3 Pos: 0-26}` {
t.Errorf("token value is not equal\n")
}
}
func TestNewNodeListNodePosition(t *testing.T) {
n1 := node.NewIdentifier("test node")
n1.SetPosition(&position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 8,
})
n2 := node.NewIdentifier("test node")
n2.SetPosition(&position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 9,
EndPos: 17,
})
n3 := node.NewIdentifier("test node")
n3.SetPosition(&position.Position{
StartLine: 3,
EndLine: 3,
StartPos: 18,
EndPos: 26,
})
builder := parser.PositionBuilder{}
pos := builder.NewNodeListNodePosition([]node.Node{n1, n2}, n3)
if pos.String() != `Pos{Line: 1-3 Pos: 0-26}` {
t.Errorf("token value is not equal\n")
}
}
func TestNewOptionalListTokensPosition(t *testing.T) {
builder := parser.PositionBuilder{}
token1 := &scanner.Token{
Value: `foo`,
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 3,
}
token2 := &scanner.Token{
Value: `foo`,
StartLine: 2,
EndLine: 2,
StartPos: 4,
EndPos: 6,
}
pos := builder.NewOptionalListTokensPosition(nil, token1, token2)
if pos.String() != `Pos{Line: 1-2 Pos: 0-6}` {
t.Errorf("token value is not equal\n")
}
}
func TestNewOptionalListTokensPosition2(t *testing.T) {
n1 := node.NewIdentifier("test node")
n1.SetPosition(&position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 8,
})
n2 := node.NewIdentifier("test node")
n2.SetPosition(&position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 9,
EndPos: 17,
})
n3 := node.NewIdentifier("test node")
n3.SetPosition(&position.Position{
StartLine: 3,
EndLine: 3,
StartPos: 18,
EndPos: 26,
})
builder := parser.PositionBuilder{}
token1 := &scanner.Token{
Value: `foo`,
StartLine: 4,
EndLine: 4,
StartPos: 27,
EndPos: 29,
}
token2 := &scanner.Token{
Value: `foo`,
StartLine: 5,
EndLine: 5,
StartPos: 30,
EndPos: 32,
}
pos := builder.NewOptionalListTokensPosition([]node.Node{n2, n3}, token1, token2)
if pos.String() != `Pos{Line: 2-5 Pos: 9-32}` {
t.Errorf("token value is not equal\n")
}
}
func TestNilNodePos(t *testing.T) {
builder := parser.PositionBuilder{}
pos := builder.NewNodesPosition(nil, nil)
if pos.String() != `Pos{Line: -1--1 Pos: -1--1}` {
t.Errorf("token value is not equal\n")
}
}
func TestNilNodeListPos(t *testing.T) {
n1 := node.NewIdentifier("test node")
n1.SetPosition(&position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 8,
})
builder := parser.PositionBuilder{}
pos := builder.NewNodeNodeListPosition(n1, nil)
if pos.String() != `Pos{Line: 1--1 Pos: 0--1}` {
t.Errorf("token value is not equal\n")
}
}
func TestNilNodeListTokenPos(t *testing.T) {
token := &scanner.Token{
Value: `foo`,
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 3,
}
builder := parser.PositionBuilder{}
pos := builder.NewNodeListTokenPosition(nil, token)
if pos.String() != `Pos{Line: -1-1 Pos: -1-3}` {
t.Errorf("token value is not equal\n")
}
}
func TestEmptyNodeListPos(t *testing.T) {
n1 := node.NewIdentifier("test node")
n1.SetPosition(&position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 8,
})
builder := parser.PositionBuilder{}
pos := builder.NewNodeNodeListPosition(n1, []node.Node{})
if pos.String() != `Pos{Line: 1--1 Pos: 0--1}` {
t.Errorf("token value is not equal\n")
}
}
func TestEmptyNodeListTokenPos(t *testing.T) {
token := &scanner.Token{
Value: `foo`,
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 3,
}
builder := parser.PositionBuilder{}
pos := builder.NewNodeListTokenPosition([]node.Node{}, token)
if pos.String() != `Pos{Line: -1-1 Pos: -1-3}` {
t.Errorf("token value is not equal\n")
}
}