Merge branch 'comments3'
This commit is contained in:
z7zmey
@@ -8,9 +8,10 @@ import (
|
||||
"io"
|
||||
"unicode"
|
||||
|
||||
"github.com/z7zmey/php-parser/position"
|
||||
|
||||
"github.com/cznic/golex/lex"
|
||||
"github.com/z7zmey/php-parser/comment"
|
||||
t "github.com/z7zmey/php-parser/token"
|
||||
)
|
||||
|
||||
// Allocate Character classes anywhere in [0x80, 0xFF].
|
||||
@@ -369,32 +370,32 @@ const T_MINUS_EQUAL = 57460
|
||||
// T_MUL_EQUAL token
|
||||
const T_MUL_EQUAL = 57461
|
||||
|
||||
// T_POW_EQUAL token
|
||||
const T_POW_EQUAL = 57462
|
||||
|
||||
// T_DIV_EQUAL token
|
||||
const T_DIV_EQUAL = 57462
|
||||
const T_DIV_EQUAL = 57463
|
||||
|
||||
// T_CONCAT_EQUAL token
|
||||
const T_CONCAT_EQUAL = 57463
|
||||
const T_CONCAT_EQUAL = 57464
|
||||
|
||||
// T_MOD_EQUAL token
|
||||
const T_MOD_EQUAL = 57464
|
||||
const T_MOD_EQUAL = 57465
|
||||
|
||||
// T_AND_EQUAL token
|
||||
const T_AND_EQUAL = 57465
|
||||
const T_AND_EQUAL = 57466
|
||||
|
||||
// T_OR_EQUAL token
|
||||
const T_OR_EQUAL = 57466
|
||||
const T_OR_EQUAL = 57467
|
||||
|
||||
// T_XOR_EQUAL token
|
||||
const T_XOR_EQUAL = 57467
|
||||
const T_XOR_EQUAL = 57468
|
||||
|
||||
// T_SL_EQUAL token
|
||||
const T_SL_EQUAL = 57468
|
||||
const T_SL_EQUAL = 57469
|
||||
|
||||
// T_SR_EQUAL token
|
||||
const T_SR_EQUAL = 57469
|
||||
|
||||
// T_POW_EQUAL token
|
||||
const T_POW_EQUAL = 57470
|
||||
const T_SR_EQUAL = 57470
|
||||
|
||||
// T_BOOLEAN_OR token
|
||||
const T_BOOLEAN_OR = 57471
|
||||
@@ -402,36 +403,36 @@ const T_BOOLEAN_OR = 57471
|
||||
// T_BOOLEAN_AND token
|
||||
const T_BOOLEAN_AND = 57472
|
||||
|
||||
// T_IS_EQUAL token
|
||||
const T_IS_EQUAL = 57473
|
||||
|
||||
// T_IS_NOT_EQUAL token
|
||||
const T_IS_NOT_EQUAL = 57474
|
||||
|
||||
// T_IS_IDENTICAL token
|
||||
const T_IS_IDENTICAL = 57475
|
||||
|
||||
// T_IS_NOT_IDENTICAL token
|
||||
const T_IS_NOT_IDENTICAL = 57476
|
||||
|
||||
// T_IS_SMALLER_OR_EQUAL token
|
||||
const T_IS_SMALLER_OR_EQUAL = 57477
|
||||
|
||||
// T_IS_GREATER_OR_EQUAL token
|
||||
const T_IS_GREATER_OR_EQUAL = 57478
|
||||
// T_POW token
|
||||
const T_POW = 57473
|
||||
|
||||
// T_SL token
|
||||
const T_SL = 57479
|
||||
const T_SL = 57474
|
||||
|
||||
// T_SR token
|
||||
const T_SR = 57480
|
||||
const T_SR = 57475
|
||||
|
||||
// T_POW token
|
||||
const T_POW = 57481
|
||||
// T_IS_IDENTICAL token
|
||||
const T_IS_IDENTICAL = 57476
|
||||
|
||||
// T_IS_NOT_IDENTICAL token
|
||||
const T_IS_NOT_IDENTICAL = 57477
|
||||
|
||||
// T_IS_EQUAL token
|
||||
const T_IS_EQUAL = 57478
|
||||
|
||||
// T_IS_NOT_EQUAL token
|
||||
const T_IS_NOT_EQUAL = 57479
|
||||
|
||||
// T_IS_SMALLER_OR_EQUAL token
|
||||
const T_IS_SMALLER_OR_EQUAL = 57480
|
||||
|
||||
// T_IS_GREATER_OR_EQUAL token
|
||||
const T_IS_GREATER_OR_EQUAL = 57481
|
||||
|
||||
// Lval parsers yySymType must implement this interface
|
||||
type Lval interface {
|
||||
Token(tkn t.Token)
|
||||
Token(tkn *Token)
|
||||
}
|
||||
|
||||
// Lexer php lexer
|
||||
@@ -439,7 +440,7 @@ type Lexer struct {
|
||||
*lex.Lexer
|
||||
StateStack []int
|
||||
PhpDocComment string
|
||||
Comments []comment.Comment
|
||||
Comments []*comment.Comment
|
||||
heredocLabel string
|
||||
tokenBytesBuf *bytes.Buffer
|
||||
}
|
||||
@@ -511,19 +512,32 @@ func (l *Lexer) getCurrentState() int {
|
||||
return l.StateStack[len(l.StateStack)-1]
|
||||
}
|
||||
|
||||
func (l *Lexer) newToken(chars []lex.Char) t.Token {
|
||||
func (l *Lexer) createToken(chars []lex.Char) *Token {
|
||||
firstChar := chars[0]
|
||||
lastChar := chars[len(chars)-1]
|
||||
|
||||
startLine := l.File.Line(firstChar.Pos())
|
||||
endLine := l.File.Line(lastChar.Pos())
|
||||
startPos := int(firstChar.Pos())
|
||||
endPos := int(lastChar.Pos())
|
||||
pos := position.NewPosition(
|
||||
l.File.Line(firstChar.Pos()),
|
||||
l.File.Line(lastChar.Pos()),
|
||||
int(firstChar.Pos()),
|
||||
int(lastChar.Pos()),
|
||||
)
|
||||
|
||||
return t.NewToken(l.tokenString(chars), startLine, endLine, startPos, endPos).SetComments(l.Comments)
|
||||
return NewToken(l.tokenString(chars), pos).SetComments(l.Comments)
|
||||
}
|
||||
|
||||
func (l *Lexer) addComment(c comment.Comment) {
|
||||
func (l *Lexer) addComment(chars []lex.Char) {
|
||||
firstChar := chars[0]
|
||||
lastChar := chars[len(chars)-1]
|
||||
|
||||
pos := position.NewPosition(
|
||||
l.File.Line(firstChar.Pos()),
|
||||
l.File.Line(lastChar.Pos()),
|
||||
int(firstChar.Pos()),
|
||||
int(lastChar.Pos()),
|
||||
)
|
||||
|
||||
c := comment.NewComment(l.tokenString(chars), pos)
|
||||
l.Comments = append(l.Comments, c)
|
||||
}
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -10,7 +10,6 @@ package scanner
|
||||
import (
|
||||
"fmt"
|
||||
"github.com/cznic/golex/lex"
|
||||
"github.com/z7zmey/php-parser/comment"
|
||||
)
|
||||
|
||||
const (
|
||||
@@ -58,7 +57,7 @@ NEW_LINE (\r|\n|\r\n)
|
||||
%%
|
||||
c = l.Rule0()
|
||||
|
||||
<INITIAL>[ \t\n\r]+ lval.Token(l.newToken(l.Token()));
|
||||
<INITIAL>[ \t\n\r]+
|
||||
<INITIAL>.
|
||||
tb := []lex.Char{}
|
||||
|
||||
@@ -82,18 +81,18 @@ NEW_LINE (\r|\n|\r\n)
|
||||
c = l.Next()
|
||||
}
|
||||
|
||||
lval.Token(l.newToken(tb))
|
||||
lval.Token(l.createToken(tb))
|
||||
return T_INLINE_HTML
|
||||
|
||||
<INITIAL>\<\?php([ \t]|{NEW_LINE}) l.begin(PHP);lval.Token(l.newToken(l.Token()));// return T_OPEN_TAG;
|
||||
<INITIAL>\<\? l.begin(PHP);lval.Token(l.newToken(l.Token()));// return T_OPEN_TAG;
|
||||
<INITIAL>\<\?= l.begin(PHP);lval.Token(l.newToken(l.Token())); return T_ECHO;
|
||||
<INITIAL>\<\?php([ \t]|{NEW_LINE}) l.begin(PHP);
|
||||
<INITIAL>\<\? l.begin(PHP);
|
||||
<INITIAL>\<\?= l.begin(PHP);lval.Token(l.createToken(l.Token())); return T_ECHO;
|
||||
|
||||
<PHP>[ \t\n\r]+ lval.Token(l.newToken(l.Token()));// return T_WHITESPACE
|
||||
<PHP>[;][ \t\n\r]*\?\>{NEW_LINE}? l.begin(INITIAL);lval.Token(l.newToken(l.Token())); return Rune2Class(';');
|
||||
<PHP>\?\>{NEW_LINE}? l.begin(INITIAL);lval.Token(l.newToken(l.Token())); return Rune2Class(';');
|
||||
<PHP>[ \t\n\r]+
|
||||
<PHP>[;][ \t\n\r]*\?\>{NEW_LINE}? l.begin(INITIAL);lval.Token(l.createToken(l.Token())); return Rune2Class(';');
|
||||
<PHP>\?\>{NEW_LINE}? l.begin(INITIAL);lval.Token(l.createToken(l.Token())); return Rune2Class(';');
|
||||
|
||||
<PHP>{DNUM}|{EXPONENT_DNUM} lval.Token(l.newToken(l.Token())); return T_DNUMBER
|
||||
<PHP>{DNUM}|{EXPONENT_DNUM} lval.Token(l.createToken(l.Token())); return T_DNUMBER
|
||||
<PHP>{BNUM}
|
||||
tb := l.Token()
|
||||
i:=2
|
||||
@@ -107,15 +106,15 @@ NEW_LINE (\r|\n|\r\n)
|
||||
}
|
||||
}
|
||||
if len(tb) - i < 64 {
|
||||
lval.Token(l.newToken(l.Token())); return T_LNUMBER
|
||||
lval.Token(l.createToken(l.Token())); return T_LNUMBER
|
||||
} else {
|
||||
lval.Token(l.newToken(l.Token())); return T_DNUMBER
|
||||
lval.Token(l.createToken(l.Token())); return T_DNUMBER
|
||||
}
|
||||
<PHP>{LNUM}
|
||||
if len(l.Token()) < 20 {
|
||||
lval.Token(l.newToken(l.Token())); return T_LNUMBER
|
||||
lval.Token(l.createToken(l.Token())); return T_LNUMBER
|
||||
} else {
|
||||
lval.Token(l.newToken(l.Token())); return T_DNUMBER
|
||||
lval.Token(l.createToken(l.Token())); return T_DNUMBER
|
||||
}
|
||||
<PHP>{HNUM}
|
||||
tb := l.Token()
|
||||
@@ -131,137 +130,133 @@ NEW_LINE (\r|\n|\r\n)
|
||||
}
|
||||
length := len(tb) - i
|
||||
if length < 16 || (length == 16 && tb[i].Rune <= '7') {
|
||||
lval.Token(l.newToken(l.Token())); return T_LNUMBER
|
||||
lval.Token(l.createToken(l.Token())); return T_LNUMBER
|
||||
} else {
|
||||
lval.Token(l.newToken(l.Token())); return T_DNUMBER
|
||||
lval.Token(l.createToken(l.Token())); return T_DNUMBER
|
||||
}
|
||||
|
||||
<PHP>abstract lval.Token(l.newToken(l.Token())); return T_ABSTRACT
|
||||
<PHP>array lval.Token(l.newToken(l.Token())); return T_ARRAY
|
||||
<PHP>as lval.Token(l.newToken(l.Token())); return T_AS
|
||||
<PHP>break lval.Token(l.newToken(l.Token())); return T_BREAK
|
||||
<PHP>callable lval.Token(l.newToken(l.Token())); return T_CALLABLE
|
||||
<PHP>case lval.Token(l.newToken(l.Token())); return T_CASE
|
||||
<PHP>catch lval.Token(l.newToken(l.Token())); return T_CATCH
|
||||
<PHP>class lval.Token(l.newToken(l.Token())); return T_CLASS
|
||||
<PHP>clone lval.Token(l.newToken(l.Token())); return T_CLONE
|
||||
<PHP>const lval.Token(l.newToken(l.Token())); return T_CONST
|
||||
<PHP>continue lval.Token(l.newToken(l.Token())); return T_CONTINUE
|
||||
<PHP>declare lval.Token(l.newToken(l.Token())); return T_DECLARE
|
||||
<PHP>default lval.Token(l.newToken(l.Token())); return T_DEFAULT
|
||||
<PHP>do lval.Token(l.newToken(l.Token())); return T_DO
|
||||
<PHP>echo lval.Token(l.newToken(l.Token())); return T_ECHO
|
||||
<PHP>else lval.Token(l.newToken(l.Token())); return T_ELSE
|
||||
<PHP>elseif lval.Token(l.newToken(l.Token())); return T_ELSEIF
|
||||
<PHP>empty lval.Token(l.newToken(l.Token())); return T_EMPTY
|
||||
<PHP>enddeclare lval.Token(l.newToken(l.Token())); return T_ENDDECLARE
|
||||
<PHP>endfor lval.Token(l.newToken(l.Token())); return T_ENDFOR
|
||||
<PHP>endforeach lval.Token(l.newToken(l.Token())); return T_ENDFOREACH
|
||||
<PHP>endif lval.Token(l.newToken(l.Token())); return T_ENDIF
|
||||
<PHP>endswitch lval.Token(l.newToken(l.Token())); return T_ENDSWITCH
|
||||
<PHP>endwhile lval.Token(l.newToken(l.Token())); return T_ENDWHILE
|
||||
<PHP>eval lval.Token(l.newToken(l.Token())); return T_EVAL
|
||||
<PHP>exit|die lval.Token(l.newToken(l.Token())); return T_EXIT
|
||||
<PHP>extends lval.Token(l.newToken(l.Token())); return T_EXTENDS
|
||||
<PHP>final lval.Token(l.newToken(l.Token())); return T_FINAL
|
||||
<PHP>finally lval.Token(l.newToken(l.Token())); return T_FINALLY
|
||||
<PHP>for lval.Token(l.newToken(l.Token())); return T_FOR
|
||||
<PHP>foreach lval.Token(l.newToken(l.Token())); return T_FOREACH
|
||||
<PHP>function|cfunction lval.Token(l.newToken(l.Token())); return T_FUNCTION
|
||||
<PHP>global lval.Token(l.newToken(l.Token())); return T_GLOBAL
|
||||
<PHP>goto lval.Token(l.newToken(l.Token())); return T_GOTO
|
||||
<PHP>if lval.Token(l.newToken(l.Token())); return T_IF
|
||||
<PHP>isset lval.Token(l.newToken(l.Token())); return T_ISSET
|
||||
<PHP>implements lval.Token(l.newToken(l.Token())); return T_IMPLEMENTS
|
||||
<PHP>instanceof lval.Token(l.newToken(l.Token())); return T_INSTANCEOF
|
||||
<PHP>insteadof lval.Token(l.newToken(l.Token())); return T_INSTEADOF
|
||||
<PHP>interface lval.Token(l.newToken(l.Token())); return T_INTERFACE
|
||||
<PHP>list lval.Token(l.newToken(l.Token())); return T_LIST
|
||||
<PHP>namespace lval.Token(l.newToken(l.Token())); return T_NAMESPACE
|
||||
<PHP>private lval.Token(l.newToken(l.Token())); return T_PRIVATE
|
||||
<PHP>public lval.Token(l.newToken(l.Token())); return T_PUBLIC
|
||||
<PHP>print lval.Token(l.newToken(l.Token())); return T_PRINT
|
||||
<PHP>protected lval.Token(l.newToken(l.Token())); return T_PROTECTED
|
||||
<PHP>return lval.Token(l.newToken(l.Token())); return T_RETURN
|
||||
<PHP>static lval.Token(l.newToken(l.Token())); return T_STATIC
|
||||
<PHP>switch lval.Token(l.newToken(l.Token())); return T_SWITCH
|
||||
<PHP>throw lval.Token(l.newToken(l.Token())); return T_THROW
|
||||
<PHP>trait lval.Token(l.newToken(l.Token())); return T_TRAIT
|
||||
<PHP>try lval.Token(l.newToken(l.Token())); return T_TRY
|
||||
<PHP>unset lval.Token(l.newToken(l.Token())); return T_UNSET
|
||||
<PHP>use lval.Token(l.newToken(l.Token())); return T_USE
|
||||
<PHP>var lval.Token(l.newToken(l.Token())); return T_VAR
|
||||
<PHP>while lval.Token(l.newToken(l.Token())); return T_WHILE
|
||||
<PHP>yield[ \t\n\r]+from[^a-zA-Z0-9_\x80-\xff] lval.Token(l.newToken(l.Token())); return T_YIELD_FROM
|
||||
<PHP>yield lval.Token(l.newToken(l.Token())); return T_YIELD
|
||||
<PHP>include lval.Token(l.newToken(l.Token())); return T_INCLUDE
|
||||
<PHP>include_once lval.Token(l.newToken(l.Token())); return T_INCLUDE_ONCE
|
||||
<PHP>require lval.Token(l.newToken(l.Token())); return T_REQUIRE
|
||||
<PHP>require_once lval.Token(l.newToken(l.Token())); return T_REQUIRE_ONCE
|
||||
<PHP>__CLASS__ lval.Token(l.newToken(l.Token())); return T_CLASS_C
|
||||
<PHP>__DIR__ lval.Token(l.newToken(l.Token())); return T_DIR
|
||||
<PHP>__FILE__ lval.Token(l.newToken(l.Token())); return T_FILE
|
||||
<PHP>__FUNCTION__ lval.Token(l.newToken(l.Token())); return T_FUNC_C
|
||||
<PHP>__LINE__ lval.Token(l.newToken(l.Token())); return T_LINE
|
||||
<PHP>__NAMESPACE__ lval.Token(l.newToken(l.Token())); return T_NS_C
|
||||
<PHP>__METHOD__ lval.Token(l.newToken(l.Token())); return T_METHOD_C
|
||||
<PHP>__TRAIT__ lval.Token(l.newToken(l.Token())); return T_TRAIT_C
|
||||
<PHP>__halt_compiler lval.Token(l.newToken(l.Token())); return T_HALT_COMPILER
|
||||
<PHP>\([ \t]*array[ \t]*\) lval.Token(l.newToken(l.Token())); return T_ARRAY_CAST
|
||||
<PHP>\([ \t]*(bool|boolean)[ \t]*\) lval.Token(l.newToken(l.Token())); return T_BOOL_CAST
|
||||
<PHP>\([ \t]*(real|double|float)[ \t]*\) lval.Token(l.newToken(l.Token())); return T_DOUBLE_CAST
|
||||
<PHP>\([ \t]*(int|integer)[ \t]*\) lval.Token(l.newToken(l.Token())); return T_INT_CAST
|
||||
<PHP>\([ \t]*object[ \t]*\) lval.Token(l.newToken(l.Token())); return T_OBJECT_CAST
|
||||
<PHP>\([ \t]*(string|binary)[ \t]*\) lval.Token(l.newToken(l.Token())); return T_STRING_CAST
|
||||
<PHP>\([ \t]*unset[ \t]*\) lval.Token(l.newToken(l.Token())); return T_UNSET_CAST
|
||||
<PHP>new lval.Token(l.newToken(l.Token())); return T_NEW
|
||||
<PHP>and lval.Token(l.newToken(l.Token())); return T_LOGICAL_AND
|
||||
<PHP>or lval.Token(l.newToken(l.Token())); return T_LOGICAL_OR
|
||||
<PHP>xor lval.Token(l.newToken(l.Token())); return T_LOGICAL_XOR
|
||||
<PHP>\\ lval.Token(l.newToken(l.Token())); return T_NS_SEPARATOR
|
||||
<PHP>\.\.\. lval.Token(l.newToken(l.Token())); return T_ELLIPSIS
|
||||
<PHP>:: lval.Token(l.newToken(l.Token())); return T_PAAMAYIM_NEKUDOTAYIM // T_DOUBLE_COLON
|
||||
<PHP>&& lval.Token(l.newToken(l.Token())); return T_BOOLEAN_AND
|
||||
<PHP>\|\| lval.Token(l.newToken(l.Token())); return T_BOOLEAN_OR
|
||||
<PHP>&= lval.Token(l.newToken(l.Token())); return T_AND_EQUAL
|
||||
<PHP>\|= lval.Token(l.newToken(l.Token())); return T_OR_EQUAL
|
||||
<PHP>\.= lval.Token(l.newToken(l.Token())); return T_CONCAT_EQUAL
|
||||
<PHP>\*= lval.Token(l.newToken(l.Token())); return T_MUL_EQUAL
|
||||
<PHP>\*\*= lval.Token(l.newToken(l.Token())); return T_POW_EQUAL
|
||||
<PHP>[/]= lval.Token(l.newToken(l.Token())); return T_DIV_EQUAL
|
||||
<PHP>\+= lval.Token(l.newToken(l.Token())); return T_PLUS_EQUAL
|
||||
<PHP>-= lval.Token(l.newToken(l.Token())); return T_MINUS_EQUAL
|
||||
<PHP>\^= lval.Token(l.newToken(l.Token())); return T_XOR_EQUAL
|
||||
<PHP>%= lval.Token(l.newToken(l.Token())); return T_MOD_EQUAL
|
||||
<PHP>-- lval.Token(l.newToken(l.Token())); return T_DEC
|
||||
<PHP>\+\+ lval.Token(l.newToken(l.Token())); return T_INC
|
||||
<PHP>=> lval.Token(l.newToken(l.Token())); return T_DOUBLE_ARROW
|
||||
<PHP>\<=\> lval.Token(l.newToken(l.Token())); return T_SPACESHIP
|
||||
<PHP>\!=|\<\> lval.Token(l.newToken(l.Token())); return T_IS_NOT_EQUAL
|
||||
<PHP>\!== lval.Token(l.newToken(l.Token())); return T_IS_NOT_IDENTICAL
|
||||
<PHP>== lval.Token(l.newToken(l.Token())); return T_IS_EQUAL
|
||||
<PHP>=== lval.Token(l.newToken(l.Token())); return T_IS_IDENTICAL
|
||||
<PHP>\<\<= lval.Token(l.newToken(l.Token())); return T_SL_EQUAL
|
||||
<PHP>\>\>= lval.Token(l.newToken(l.Token())); return T_SR_EQUAL
|
||||
<PHP>\>= lval.Token(l.newToken(l.Token())); return T_IS_GREATER_OR_EQUAL
|
||||
<PHP>\<= lval.Token(l.newToken(l.Token())); return T_IS_SMALLER_OR_EQUAL
|
||||
<PHP>\*\* lval.Token(l.newToken(l.Token())); return T_POW
|
||||
<PHP>\<\< lval.Token(l.newToken(l.Token())); return T_SL
|
||||
<PHP>\>\> lval.Token(l.newToken(l.Token())); return T_SR
|
||||
<PHP>\?\? lval.Token(l.newToken(l.Token())); return T_COALESCE
|
||||
<PHP>abstract lval.Token(l.createToken(l.Token())); return T_ABSTRACT
|
||||
<PHP>array lval.Token(l.createToken(l.Token())); return T_ARRAY
|
||||
<PHP>as lval.Token(l.createToken(l.Token())); return T_AS
|
||||
<PHP>break lval.Token(l.createToken(l.Token())); return T_BREAK
|
||||
<PHP>callable lval.Token(l.createToken(l.Token())); return T_CALLABLE
|
||||
<PHP>case lval.Token(l.createToken(l.Token())); return T_CASE
|
||||
<PHP>catch lval.Token(l.createToken(l.Token())); return T_CATCH
|
||||
<PHP>class lval.Token(l.createToken(l.Token())); return T_CLASS
|
||||
<PHP>clone lval.Token(l.createToken(l.Token())); return T_CLONE
|
||||
<PHP>const lval.Token(l.createToken(l.Token())); return T_CONST
|
||||
<PHP>continue lval.Token(l.createToken(l.Token())); return T_CONTINUE
|
||||
<PHP>declare lval.Token(l.createToken(l.Token())); return T_DECLARE
|
||||
<PHP>default lval.Token(l.createToken(l.Token())); return T_DEFAULT
|
||||
<PHP>do lval.Token(l.createToken(l.Token())); return T_DO
|
||||
<PHP>echo lval.Token(l.createToken(l.Token())); return T_ECHO
|
||||
<PHP>else lval.Token(l.createToken(l.Token())); return T_ELSE
|
||||
<PHP>elseif lval.Token(l.createToken(l.Token())); return T_ELSEIF
|
||||
<PHP>empty lval.Token(l.createToken(l.Token())); return T_EMPTY
|
||||
<PHP>enddeclare lval.Token(l.createToken(l.Token())); return T_ENDDECLARE
|
||||
<PHP>endfor lval.Token(l.createToken(l.Token())); return T_ENDFOR
|
||||
<PHP>endforeach lval.Token(l.createToken(l.Token())); return T_ENDFOREACH
|
||||
<PHP>endif lval.Token(l.createToken(l.Token())); return T_ENDIF
|
||||
<PHP>endswitch lval.Token(l.createToken(l.Token())); return T_ENDSWITCH
|
||||
<PHP>endwhile lval.Token(l.createToken(l.Token())); return T_ENDWHILE
|
||||
<PHP>eval lval.Token(l.createToken(l.Token())); return T_EVAL
|
||||
<PHP>exit|die lval.Token(l.createToken(l.Token())); return T_EXIT
|
||||
<PHP>extends lval.Token(l.createToken(l.Token())); return T_EXTENDS
|
||||
<PHP>final lval.Token(l.createToken(l.Token())); return T_FINAL
|
||||
<PHP>finally lval.Token(l.createToken(l.Token())); return T_FINALLY
|
||||
<PHP>for lval.Token(l.createToken(l.Token())); return T_FOR
|
||||
<PHP>foreach lval.Token(l.createToken(l.Token())); return T_FOREACH
|
||||
<PHP>function|cfunction lval.Token(l.createToken(l.Token())); return T_FUNCTION
|
||||
<PHP>global lval.Token(l.createToken(l.Token())); return T_GLOBAL
|
||||
<PHP>goto lval.Token(l.createToken(l.Token())); return T_GOTO
|
||||
<PHP>if lval.Token(l.createToken(l.Token())); return T_IF
|
||||
<PHP>isset lval.Token(l.createToken(l.Token())); return T_ISSET
|
||||
<PHP>implements lval.Token(l.createToken(l.Token())); return T_IMPLEMENTS
|
||||
<PHP>instanceof lval.Token(l.createToken(l.Token())); return T_INSTANCEOF
|
||||
<PHP>insteadof lval.Token(l.createToken(l.Token())); return T_INSTEADOF
|
||||
<PHP>interface lval.Token(l.createToken(l.Token())); return T_INTERFACE
|
||||
<PHP>list lval.Token(l.createToken(l.Token())); return T_LIST
|
||||
<PHP>namespace lval.Token(l.createToken(l.Token())); return T_NAMESPACE
|
||||
<PHP>private lval.Token(l.createToken(l.Token())); return T_PRIVATE
|
||||
<PHP>public lval.Token(l.createToken(l.Token())); return T_PUBLIC
|
||||
<PHP>print lval.Token(l.createToken(l.Token())); return T_PRINT
|
||||
<PHP>protected lval.Token(l.createToken(l.Token())); return T_PROTECTED
|
||||
<PHP>return lval.Token(l.createToken(l.Token())); return T_RETURN
|
||||
<PHP>static lval.Token(l.createToken(l.Token())); return T_STATIC
|
||||
<PHP>switch lval.Token(l.createToken(l.Token())); return T_SWITCH
|
||||
<PHP>throw lval.Token(l.createToken(l.Token())); return T_THROW
|
||||
<PHP>trait lval.Token(l.createToken(l.Token())); return T_TRAIT
|
||||
<PHP>try lval.Token(l.createToken(l.Token())); return T_TRY
|
||||
<PHP>unset lval.Token(l.createToken(l.Token())); return T_UNSET
|
||||
<PHP>use lval.Token(l.createToken(l.Token())); return T_USE
|
||||
<PHP>var lval.Token(l.createToken(l.Token())); return T_VAR
|
||||
<PHP>while lval.Token(l.createToken(l.Token())); return T_WHILE
|
||||
<PHP>yield[ \t\n\r]+from[^a-zA-Z0-9_\x80-\xff] lval.Token(l.createToken(l.Token())); return T_YIELD_FROM
|
||||
<PHP>yield lval.Token(l.createToken(l.Token())); return T_YIELD
|
||||
<PHP>include lval.Token(l.createToken(l.Token())); return T_INCLUDE
|
||||
<PHP>include_once lval.Token(l.createToken(l.Token())); return T_INCLUDE_ONCE
|
||||
<PHP>require lval.Token(l.createToken(l.Token())); return T_REQUIRE
|
||||
<PHP>require_once lval.Token(l.createToken(l.Token())); return T_REQUIRE_ONCE
|
||||
<PHP>__CLASS__ lval.Token(l.createToken(l.Token())); return T_CLASS_C
|
||||
<PHP>__DIR__ lval.Token(l.createToken(l.Token())); return T_DIR
|
||||
<PHP>__FILE__ lval.Token(l.createToken(l.Token())); return T_FILE
|
||||
<PHP>__FUNCTION__ lval.Token(l.createToken(l.Token())); return T_FUNC_C
|
||||
<PHP>__LINE__ lval.Token(l.createToken(l.Token())); return T_LINE
|
||||
<PHP>__NAMESPACE__ lval.Token(l.createToken(l.Token())); return T_NS_C
|
||||
<PHP>__METHOD__ lval.Token(l.createToken(l.Token())); return T_METHOD_C
|
||||
<PHP>__TRAIT__ lval.Token(l.createToken(l.Token())); return T_TRAIT_C
|
||||
<PHP>__halt_compiler lval.Token(l.createToken(l.Token())); return T_HALT_COMPILER
|
||||
<PHP>\([ \t]*array[ \t]*\) lval.Token(l.createToken(l.Token())); return T_ARRAY_CAST
|
||||
<PHP>\([ \t]*(bool|boolean)[ \t]*\) lval.Token(l.createToken(l.Token())); return T_BOOL_CAST
|
||||
<PHP>\([ \t]*(real|double|float)[ \t]*\) lval.Token(l.createToken(l.Token())); return T_DOUBLE_CAST
|
||||
<PHP>\([ \t]*(int|integer)[ \t]*\) lval.Token(l.createToken(l.Token())); return T_INT_CAST
|
||||
<PHP>\([ \t]*object[ \t]*\) lval.Token(l.createToken(l.Token())); return T_OBJECT_CAST
|
||||
<PHP>\([ \t]*(string|binary)[ \t]*\) lval.Token(l.createToken(l.Token())); return T_STRING_CAST
|
||||
<PHP>\([ \t]*unset[ \t]*\) lval.Token(l.createToken(l.Token())); return T_UNSET_CAST
|
||||
<PHP>new lval.Token(l.createToken(l.Token())); return T_NEW
|
||||
<PHP>and lval.Token(l.createToken(l.Token())); return T_LOGICAL_AND
|
||||
<PHP>or lval.Token(l.createToken(l.Token())); return T_LOGICAL_OR
|
||||
<PHP>xor lval.Token(l.createToken(l.Token())); return T_LOGICAL_XOR
|
||||
<PHP>\\ lval.Token(l.createToken(l.Token())); return T_NS_SEPARATOR
|
||||
<PHP>\.\.\. lval.Token(l.createToken(l.Token())); return T_ELLIPSIS
|
||||
<PHP>:: lval.Token(l.createToken(l.Token())); return T_PAAMAYIM_NEKUDOTAYIM // T_DOUBLE_COLON
|
||||
<PHP>&& lval.Token(l.createToken(l.Token())); return T_BOOLEAN_AND
|
||||
<PHP>\|\| lval.Token(l.createToken(l.Token())); return T_BOOLEAN_OR
|
||||
<PHP>&= lval.Token(l.createToken(l.Token())); return T_AND_EQUAL
|
||||
<PHP>\|= lval.Token(l.createToken(l.Token())); return T_OR_EQUAL
|
||||
<PHP>\.= lval.Token(l.createToken(l.Token())); return T_CONCAT_EQUAL
|
||||
<PHP>\*= lval.Token(l.createToken(l.Token())); return T_MUL_EQUAL
|
||||
<PHP>\*\*= lval.Token(l.createToken(l.Token())); return T_POW_EQUAL
|
||||
<PHP>[/]= lval.Token(l.createToken(l.Token())); return T_DIV_EQUAL
|
||||
<PHP>\+= lval.Token(l.createToken(l.Token())); return T_PLUS_EQUAL
|
||||
<PHP>-= lval.Token(l.createToken(l.Token())); return T_MINUS_EQUAL
|
||||
<PHP>\^= lval.Token(l.createToken(l.Token())); return T_XOR_EQUAL
|
||||
<PHP>%= lval.Token(l.createToken(l.Token())); return T_MOD_EQUAL
|
||||
<PHP>-- lval.Token(l.createToken(l.Token())); return T_DEC
|
||||
<PHP>\+\+ lval.Token(l.createToken(l.Token())); return T_INC
|
||||
<PHP>=> lval.Token(l.createToken(l.Token())); return T_DOUBLE_ARROW
|
||||
<PHP>\<=\> lval.Token(l.createToken(l.Token())); return T_SPACESHIP
|
||||
<PHP>\!=|\<\> lval.Token(l.createToken(l.Token())); return T_IS_NOT_EQUAL
|
||||
<PHP>\!== lval.Token(l.createToken(l.Token())); return T_IS_NOT_IDENTICAL
|
||||
<PHP>== lval.Token(l.createToken(l.Token())); return T_IS_EQUAL
|
||||
<PHP>=== lval.Token(l.createToken(l.Token())); return T_IS_IDENTICAL
|
||||
<PHP>\<\<= lval.Token(l.createToken(l.Token())); return T_SL_EQUAL
|
||||
<PHP>\>\>= lval.Token(l.createToken(l.Token())); return T_SR_EQUAL
|
||||
<PHP>\>= lval.Token(l.createToken(l.Token())); return T_IS_GREATER_OR_EQUAL
|
||||
<PHP>\<= lval.Token(l.createToken(l.Token())); return T_IS_SMALLER_OR_EQUAL
|
||||
<PHP>\*\* lval.Token(l.createToken(l.Token())); return T_POW
|
||||
<PHP>\<\< lval.Token(l.createToken(l.Token())); return T_SL
|
||||
<PHP>\>\> lval.Token(l.createToken(l.Token())); return T_SR
|
||||
<PHP>\?\? lval.Token(l.createToken(l.Token())); return T_COALESCE
|
||||
<PHP>(#|[/][/])
|
||||
tb := []rune{}
|
||||
|
||||
for _, chr := range(l.Token()) {
|
||||
tb = append(tb, chr.Rune)
|
||||
}
|
||||
tb := l.Token()
|
||||
|
||||
for {
|
||||
if c == -1 {
|
||||
break
|
||||
}
|
||||
|
||||
tb = append(tb, rune(c))
|
||||
tb = append(tb, l.Last)
|
||||
|
||||
switch c {
|
||||
case '\r':
|
||||
@@ -289,7 +284,7 @@ NEW_LINE (\r|\n|\r\n)
|
||||
break;
|
||||
}
|
||||
|
||||
l.addComment(comment.NewPlainComment(string(tb)))
|
||||
l.addComment(tb)
|
||||
|
||||
<PHP>([/][*])|([/][*][*])
|
||||
tb := l.Token()
|
||||
@@ -312,33 +307,30 @@ NEW_LINE (\r|\n|\r\n)
|
||||
c = l.Next()
|
||||
}
|
||||
|
||||
lval.Token(l.newToken(l.Token()))
|
||||
if is_doc_comment {
|
||||
l.PhpDocComment = string(l.TokenBytes(nil))
|
||||
l.addComment(comment.NewDocComment(string(l.TokenBytes(nil))))
|
||||
// return T_DOC_COMMENT
|
||||
l.addComment(l.Token())
|
||||
} else {
|
||||
l.addComment(comment.NewPlainComment(string(l.TokenBytes(nil))))
|
||||
// return T_COMMENT
|
||||
l.addComment(l.Token())
|
||||
}
|
||||
|
||||
<PHP>{OPERATORS} lval.Token(l.newToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
||||
<PHP>{OPERATORS} lval.Token(l.createToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
||||
|
||||
<PHP>\{ l.pushState(PHP); lval.Token(l.newToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
||||
<PHP>\} l.popState(); lval.Token(l.newToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0])); l.PhpDocComment = ""
|
||||
<PHP>\${VAR_NAME} lval.Token(l.newToken(l.Token())); return T_VARIABLE
|
||||
<PHP>{VAR_NAME} lval.Token(l.newToken(l.Token())); return T_STRING
|
||||
<PHP>\{ l.pushState(PHP); lval.Token(l.createToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
||||
<PHP>\} l.popState(); lval.Token(l.createToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0])); l.PhpDocComment = ""
|
||||
<PHP>\${VAR_NAME} lval.Token(l.createToken(l.Token())); return T_VARIABLE
|
||||
<PHP>{VAR_NAME} lval.Token(l.createToken(l.Token())); return T_STRING
|
||||
|
||||
<PHP>-> l.begin(PROPERTY);lval.Token(l.newToken(l.Token())); return T_OBJECT_OPERATOR;
|
||||
<PROPERTY>[ \t\n\r]+ lval.Token(l.newToken(l.Token())); // return T_WHITESPACE;
|
||||
<PROPERTY>-> lval.Token(l.newToken(l.Token())); return T_OBJECT_OPERATOR;
|
||||
<PROPERTY>{VAR_NAME} l.begin(PHP);lval.Token(l.newToken(l.Token())); return T_STRING;
|
||||
<PHP>-> l.begin(PROPERTY);lval.Token(l.createToken(l.Token())); return T_OBJECT_OPERATOR;
|
||||
<PROPERTY>[ \t\n\r]+
|
||||
<PROPERTY>-> lval.Token(l.createToken(l.Token())); return T_OBJECT_OPERATOR;
|
||||
<PROPERTY>{VAR_NAME} l.begin(PHP);lval.Token(l.createToken(l.Token())); return T_STRING;
|
||||
<PROPERTY>. l.ungetChars(1);l.begin(PHP)
|
||||
|
||||
<PHP>[\']([^\\\']*([\\].)*)*[\'] lval.Token(l.newToken(l.Token())); return T_CONSTANT_ENCAPSED_STRING;
|
||||
<PHP>[\']([^\\\']*([\\].)*)*[\'] lval.Token(l.createToken(l.Token())); return T_CONSTANT_ENCAPSED_STRING;
|
||||
|
||||
<PHP>` l.begin(BACKQUOTE); lval.Token(l.newToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
||||
<BACKQUOTE>` l.begin(PHP); lval.Token(l.newToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
||||
<PHP>` l.begin(BACKQUOTE); lval.Token(l.createToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
||||
<BACKQUOTE>` l.begin(PHP); lval.Token(l.createToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
||||
|
||||
<PHP>[b]?\<\<\<[ \t]*({VAR_NAME}|([']{VAR_NAME}['])|(["]{VAR_NAME}["])){NEW_LINE}
|
||||
tb := l.Token()
|
||||
@@ -400,7 +392,7 @@ NEW_LINE (\r|\n|\r\n)
|
||||
|
||||
l.ungetChars(ungetCnt)
|
||||
|
||||
lval.Token(l.newToken(heredocToken));
|
||||
lval.Token(l.createToken(heredocToken));
|
||||
return T_START_HEREDOC
|
||||
|
||||
<NOWDOC>.|[ \t\n\r]
|
||||
@@ -433,11 +425,11 @@ NEW_LINE (\r|\n|\r\n)
|
||||
c = l.Next()
|
||||
}
|
||||
|
||||
lval.Token(l.newToken(tb) )
|
||||
lval.Token(l.createToken(tb) )
|
||||
return T_ENCAPSED_AND_WHITESPACE
|
||||
|
||||
<HEREDOC_END>{VAR_NAME}\; l.begin(PHP);lval.Token(l.newToken(l.ungetChars(1))); return T_END_HEREDOC
|
||||
<HEREDOC_END>{VAR_NAME} l.begin(PHP);lval.Token(l.newToken(l.Token())); return T_END_HEREDOC
|
||||
<HEREDOC_END>{VAR_NAME}\; l.begin(PHP);lval.Token(l.createToken(l.ungetChars(1))); return T_END_HEREDOC
|
||||
<HEREDOC_END>{VAR_NAME} l.begin(PHP);lval.Token(l.createToken(l.Token())); return T_END_HEREDOC
|
||||
|
||||
<PHP>[b]?[\"]
|
||||
binPrefix := l.Token()[0].Rune == 'b'
|
||||
@@ -449,7 +441,7 @@ NEW_LINE (\r|\n|\r\n)
|
||||
chars := l.Token()[:cnt]
|
||||
l.pushState(STRING)
|
||||
|
||||
lval.Token(l.newToken(chars)); return Rune2Class('"')
|
||||
lval.Token(l.createToken(chars)); return Rune2Class('"')
|
||||
}
|
||||
|
||||
F:for {
|
||||
@@ -460,7 +452,7 @@ NEW_LINE (\r|\n|\r\n)
|
||||
switch c {
|
||||
case '"' :
|
||||
c = l.Next();
|
||||
lval.Token(l.newToken(l.Token())); return T_CONSTANT_ENCAPSED_STRING
|
||||
lval.Token(l.createToken(l.Token())); return T_CONSTANT_ENCAPSED_STRING
|
||||
break F;
|
||||
|
||||
case '$':
|
||||
@@ -486,9 +478,9 @@ NEW_LINE (\r|\n|\r\n)
|
||||
c = l.Next()
|
||||
}
|
||||
|
||||
<STRING>\" l.popState(); lval.Token(l.newToken(l.Token())); return Rune2Class(l.Token()[0].Rune)
|
||||
<STRING,HEREDOC,BACKQUOTE>\{\$ lval.Token(l.newToken(l.ungetChars(1))); l.pushState(PHP); return T_CURLY_OPEN
|
||||
<STRING,HEREDOC,BACKQUOTE>\$\{ l.pushState(STRING_VAR_NAME); lval.Token(l.newToken(l.Token())); return T_DOLLAR_OPEN_CURLY_BRACES
|
||||
<STRING>\" l.popState(); lval.Token(l.createToken(l.Token())); return Rune2Class(l.Token()[0].Rune)
|
||||
<STRING,HEREDOC,BACKQUOTE>\{\$ lval.Token(l.createToken(l.ungetChars(1))); l.pushState(PHP); return T_CURLY_OPEN
|
||||
<STRING,HEREDOC,BACKQUOTE>\$\{ l.pushState(STRING_VAR_NAME); lval.Token(l.createToken(l.Token())); return T_DOLLAR_OPEN_CURLY_BRACES
|
||||
<STRING,HEREDOC,BACKQUOTE>\${VAR_NAME} l.ungetChars(len(l.Token()));l.pushState(STRING_VAR)
|
||||
<STRING>.|[ \t\n\r]
|
||||
currentChar := l.Prev
|
||||
@@ -498,14 +490,14 @@ NEW_LINE (\r|\n|\r\n)
|
||||
case '$':
|
||||
if c == '{' || isValidFirstVarNameRune(rune(c)) {
|
||||
l.ungetChars(1)
|
||||
lval.Token(l.newToken(tb[:len(tb)-1]));
|
||||
lval.Token(l.createToken(tb[:len(tb)-1]));
|
||||
return T_ENCAPSED_AND_WHITESPACE
|
||||
}
|
||||
|
||||
case '{':
|
||||
if rune(c) == '$' {
|
||||
l.ungetChars(1)
|
||||
lval.Token(l.newToken(tb[:len(tb)-1]));
|
||||
lval.Token(l.createToken(tb[:len(tb)-1]));
|
||||
return T_ENCAPSED_AND_WHITESPACE
|
||||
}
|
||||
|
||||
@@ -516,7 +508,7 @@ NEW_LINE (\r|\n|\r\n)
|
||||
}
|
||||
|
||||
if rune(c) == '"' {
|
||||
lval.Token(l.newToken(l.Token()));
|
||||
lval.Token(l.createToken(l.Token()));
|
||||
return T_ENCAPSED_AND_WHITESPACE
|
||||
}
|
||||
|
||||
@@ -538,14 +530,14 @@ NEW_LINE (\r|\n|\r\n)
|
||||
case '$':
|
||||
if c == '{' || isValidFirstVarNameRune(rune(c)) {
|
||||
l.ungetChars(1)
|
||||
lval.Token(l.newToken(tb[:len(tb)-1]));
|
||||
lval.Token(l.createToken(tb[:len(tb)-1]));
|
||||
return T_ENCAPSED_AND_WHITESPACE
|
||||
}
|
||||
|
||||
case '{':
|
||||
if rune(c) == '$' {
|
||||
l.ungetChars(1)
|
||||
lval.Token(l.newToken(tb[:len(tb)-1]));
|
||||
lval.Token(l.createToken(tb[:len(tb)-1]));
|
||||
return T_ENCAPSED_AND_WHITESPACE
|
||||
}
|
||||
|
||||
@@ -556,7 +548,7 @@ NEW_LINE (\r|\n|\r\n)
|
||||
}
|
||||
|
||||
if rune(c) == '`' {
|
||||
lval.Token(l.newToken(l.Token()));
|
||||
lval.Token(l.createToken(l.Token()));
|
||||
return T_ENCAPSED_AND_WHITESPACE
|
||||
}
|
||||
|
||||
@@ -596,14 +588,14 @@ NEW_LINE (\r|\n|\r\n)
|
||||
if l.heredocLabel + ";" == string(searchLabel) {
|
||||
l.begin(HEREDOC_END)
|
||||
tb = l.ungetChars(len(l.heredocLabel)+1+nls)
|
||||
lval.Token(l.newToken(tb));
|
||||
lval.Token(l.createToken(tb));
|
||||
return T_ENCAPSED_AND_WHITESPACE
|
||||
}
|
||||
|
||||
if l.heredocLabel == string(searchLabel) {
|
||||
l.begin(HEREDOC_END)
|
||||
tb = l.ungetChars(len(l.heredocLabel)+nls)
|
||||
lval.Token(l.newToken(tb));
|
||||
lval.Token(l.createToken(tb));
|
||||
return T_ENCAPSED_AND_WHITESPACE
|
||||
}
|
||||
|
||||
@@ -613,7 +605,7 @@ NEW_LINE (\r|\n|\r\n)
|
||||
c = l.Next();
|
||||
if rune(c) == '{' || isValidFirstVarNameRune(rune(c)) {
|
||||
tb = l.ungetChars(1)
|
||||
lval.Token(l.newToken(tb));
|
||||
lval.Token(l.createToken(tb));
|
||||
return T_ENCAPSED_AND_WHITESPACE
|
||||
}
|
||||
l.ungetChars(0)
|
||||
@@ -622,7 +614,7 @@ NEW_LINE (\r|\n|\r\n)
|
||||
c = l.Next();
|
||||
if rune(c) == '$' {
|
||||
tb = l.ungetChars(1)
|
||||
lval.Token(l.newToken(tb));
|
||||
lval.Token(l.createToken(tb));
|
||||
return T_ENCAPSED_AND_WHITESPACE
|
||||
}
|
||||
l.ungetChars(0)
|
||||
@@ -640,21 +632,21 @@ NEW_LINE (\r|\n|\r\n)
|
||||
c = l.Next()
|
||||
}
|
||||
|
||||
<STRING_VAR>\${VAR_NAME} lval.Token(l.newToken(l.Token())); return T_VARIABLE
|
||||
<STRING_VAR>->{VAR_NAME} lval.Token(l.newToken(l.ungetChars(len(l.Token())-2))); return T_OBJECT_OPERATOR
|
||||
<STRING_VAR>{VAR_NAME} l.popState();lval.Token(l.newToken(l.Token())); return T_STRING
|
||||
<STRING_VAR>\[ l.pushState(STRING_VAR_INDEX);lval.Token(l.newToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
||||
<STRING_VAR>\${VAR_NAME} lval.Token(l.createToken(l.Token())); return T_VARIABLE
|
||||
<STRING_VAR>->{VAR_NAME} lval.Token(l.createToken(l.ungetChars(len(l.Token())-2))); return T_OBJECT_OPERATOR
|
||||
<STRING_VAR>{VAR_NAME} l.popState();lval.Token(l.createToken(l.Token())); return T_STRING
|
||||
<STRING_VAR>\[ l.pushState(STRING_VAR_INDEX);lval.Token(l.createToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
||||
<STRING_VAR>.|[ \t\n\r] l.ungetChars(1);l.popState()
|
||||
|
||||
<STRING_VAR_INDEX>{LNUM}|{HNUM}|{BNUM} lval.Token(l.newToken(l.Token())); return T_NUM_STRING
|
||||
<STRING_VAR_INDEX>\${VAR_NAME} lval.Token(l.newToken(l.Token())); return T_VARIABLE
|
||||
<STRING_VAR_INDEX>{VAR_NAME} lval.Token(l.newToken(l.Token())); return T_STRING
|
||||
<STRING_VAR_INDEX>\] l.popState(); l.popState();lval.Token(l.newToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
||||
<STRING_VAR_INDEX>[ \n\r\t\\'#] l.popState(); l.popState();lval.Token(l.newToken(l.Token())); return T_ENCAPSED_AND_WHITESPACE
|
||||
<STRING_VAR_INDEX>{OPERATORS} lval.Token(l.newToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
||||
<STRING_VAR_INDEX>. lval.Token(l.newToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
||||
<STRING_VAR_INDEX>{LNUM}|{HNUM}|{BNUM} lval.Token(l.createToken(l.Token())); return T_NUM_STRING
|
||||
<STRING_VAR_INDEX>\${VAR_NAME} lval.Token(l.createToken(l.Token())); return T_VARIABLE
|
||||
<STRING_VAR_INDEX>{VAR_NAME} lval.Token(l.createToken(l.Token())); return T_STRING
|
||||
<STRING_VAR_INDEX>\] l.popState(); l.popState();lval.Token(l.createToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
||||
<STRING_VAR_INDEX>[ \n\r\t\\'#] l.popState(); l.popState();lval.Token(l.createToken(l.Token())); return T_ENCAPSED_AND_WHITESPACE
|
||||
<STRING_VAR_INDEX>{OPERATORS} lval.Token(l.createToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
||||
<STRING_VAR_INDEX>. lval.Token(l.createToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
||||
|
||||
<STRING_VAR_NAME>{VAR_NAME}[\[\}] l.popState();l.pushState(PHP);lval.Token(l.newToken(l.ungetChars(1))); return T_STRING_VARNAME
|
||||
<STRING_VAR_NAME>{VAR_NAME}[\[\}] l.popState();l.pushState(PHP);lval.Token(l.createToken(l.ungetChars(1))); return T_STRING_VARNAME
|
||||
<STRING_VAR_NAME>. l.ungetChars(1);l.popState();l.pushState(PHP)
|
||||
|
||||
%%
|
||||
|
||||
@@ -5,10 +5,11 @@ import (
|
||||
"reflect"
|
||||
"testing"
|
||||
|
||||
"github.com/z7zmey/php-parser/position"
|
||||
|
||||
"github.com/z7zmey/php-parser/comment"
|
||||
|
||||
"github.com/z7zmey/php-parser/scanner"
|
||||
"github.com/z7zmey/php-parser/token"
|
||||
|
||||
"github.com/kylelemons/godebug/pretty"
|
||||
)
|
||||
@@ -27,10 +28,10 @@ func assertEqual(t *testing.T, expected interface{}, actual interface{}) {
|
||||
}
|
||||
|
||||
type lval struct {
|
||||
Tkn token.Token
|
||||
Tkn *scanner.Token
|
||||
}
|
||||
|
||||
func (lv *lval) Token(t token.Token) {
|
||||
func (lv *lval) Token(t *scanner.Token) {
|
||||
lv.Tkn = t
|
||||
}
|
||||
|
||||
@@ -875,8 +876,8 @@ func TestSlashAfterVariable(t *testing.T) {
|
||||
func TestCommentEnd(t *testing.T) {
|
||||
src := `<?php //test`
|
||||
|
||||
expected := []comment.Comment{
|
||||
comment.NewPlainComment("//test"),
|
||||
expected := []*comment.Comment{
|
||||
comment.NewComment("//test", position.NewPosition(1, 1, 7, 12)),
|
||||
}
|
||||
|
||||
lexer := scanner.NewLexer(bytes.NewBufferString(src), "test.php")
|
||||
@@ -892,8 +893,8 @@ func TestCommentEnd(t *testing.T) {
|
||||
func TestCommentNewLine(t *testing.T) {
|
||||
src := "<?php //test\n$a"
|
||||
|
||||
expected := []comment.Comment{
|
||||
comment.NewPlainComment("//test\n"),
|
||||
expected := []*comment.Comment{
|
||||
comment.NewComment("//test\n", position.NewPosition(1, 1, 7, 13)),
|
||||
}
|
||||
|
||||
lexer := scanner.NewLexer(bytes.NewBufferString(src), "test.php")
|
||||
@@ -909,8 +910,8 @@ func TestCommentNewLine(t *testing.T) {
|
||||
func TestCommentNewLine1(t *testing.T) {
|
||||
src := "<?php //test\r$a"
|
||||
|
||||
expected := []comment.Comment{
|
||||
comment.NewPlainComment("//test\r"),
|
||||
expected := []*comment.Comment{
|
||||
comment.NewComment("//test\r", position.NewPosition(1, 1, 7, 13)),
|
||||
}
|
||||
|
||||
lexer := scanner.NewLexer(bytes.NewBufferString(src), "test.php")
|
||||
@@ -926,8 +927,8 @@ func TestCommentNewLine1(t *testing.T) {
|
||||
func TestCommentNewLine2(t *testing.T) {
|
||||
src := "<?php #test\r\n$a"
|
||||
|
||||
expected := []comment.Comment{
|
||||
comment.NewPlainComment("#test\r\n"),
|
||||
expected := []*comment.Comment{
|
||||
comment.NewComment("#test\r\n", position.NewPosition(1, 1, 7, 13)),
|
||||
}
|
||||
|
||||
lexer := scanner.NewLexer(bytes.NewBufferString(src), "test.php")
|
||||
@@ -944,8 +945,8 @@ func TestCommentWithPhpEndTag(t *testing.T) {
|
||||
src := `<?php
|
||||
//test?> test`
|
||||
|
||||
expected := []comment.Comment{
|
||||
comment.NewPlainComment("//test"),
|
||||
expected := []*comment.Comment{
|
||||
comment.NewComment("//test", position.NewPosition(2, 2, 8, 13)),
|
||||
}
|
||||
|
||||
lexer := scanner.NewLexer(bytes.NewBufferString(src), "test.php")
|
||||
@@ -962,8 +963,8 @@ func TestInlineComment(t *testing.T) {
|
||||
src := `<?php
|
||||
/*test*/`
|
||||
|
||||
expected := []comment.Comment{
|
||||
comment.NewPlainComment("/*test*/"),
|
||||
expected := []*comment.Comment{
|
||||
comment.NewComment("/*test*/", position.NewPosition(2, 2, 8, 15)),
|
||||
}
|
||||
|
||||
lexer := scanner.NewLexer(bytes.NewBufferString(src), "test.php")
|
||||
@@ -980,8 +981,8 @@ func TestEmptyInlineComment(t *testing.T) {
|
||||
src := `<?php
|
||||
/**/`
|
||||
|
||||
expected := []comment.Comment{
|
||||
comment.NewDocComment("/**/"),
|
||||
expected := []*comment.Comment{
|
||||
comment.NewComment("/**/", position.NewPosition(2, 2, 8, 11)),
|
||||
}
|
||||
|
||||
lexer := scanner.NewLexer(bytes.NewBufferString(src), "test.php")
|
||||
@@ -998,8 +999,8 @@ func TestEmptyInlineComment2(t *testing.T) {
|
||||
src := `<?php
|
||||
/***/`
|
||||
|
||||
expected := []comment.Comment{
|
||||
comment.NewDocComment("/***/"),
|
||||
expected := []*comment.Comment{
|
||||
comment.NewComment("/***/", position.NewPosition(2, 2, 8, 12)),
|
||||
}
|
||||
|
||||
lexer := scanner.NewLexer(bytes.NewBufferString(src), "test.php")
|
||||
|
||||
42
scanner/token.go
Normal file
42
scanner/token.go
Normal file
@@ -0,0 +1,42 @@
|
||||
package scanner
|
||||
|
||||
import (
|
||||
"github.com/z7zmey/php-parser/comment"
|
||||
"github.com/z7zmey/php-parser/position"
|
||||
)
|
||||
|
||||
// Token value returned by lexer
|
||||
type Token struct {
|
||||
Value string
|
||||
position *position.Position
|
||||
comments []*comment.Comment
|
||||
}
|
||||
|
||||
// NewToken Token constructor
|
||||
func NewToken(value string, pos *position.Position) *Token {
|
||||
return &Token{
|
||||
Value: value,
|
||||
position: pos,
|
||||
comments: nil,
|
||||
}
|
||||
}
|
||||
|
||||
func (t *Token) String() string {
|
||||
return string(t.Value)
|
||||
}
|
||||
|
||||
// Position returns token position
|
||||
func (t *Token) Position() *position.Position {
|
||||
return t.position
|
||||
}
|
||||
|
||||
// Comments returns attached comments
|
||||
func (t *Token) Comments() []*comment.Comment {
|
||||
return t.comments
|
||||
}
|
||||
|
||||
// SetComments attach comments
|
||||
func (t *Token) SetComments(comments []*comment.Comment) *Token {
|
||||
t.comments = comments
|
||||
return t
|
||||
}
|
||||
35
scanner/token_test.go
Normal file
35
scanner/token_test.go
Normal file
@@ -0,0 +1,35 @@
|
||||
package scanner_test
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
"testing"
|
||||
|
||||
"github.com/z7zmey/php-parser/position"
|
||||
|
||||
"github.com/z7zmey/php-parser/comment"
|
||||
|
||||
"github.com/z7zmey/php-parser/scanner"
|
||||
)
|
||||
|
||||
func TestToken(t *testing.T) {
|
||||
pos := position.NewPosition(1, 1, 0, 3)
|
||||
tkn := scanner.NewToken(`foo`, pos)
|
||||
|
||||
c := []*comment.Comment{
|
||||
comment.NewComment("test comment", nil),
|
||||
}
|
||||
|
||||
tkn.SetComments(c)
|
||||
|
||||
if !reflect.DeepEqual(tkn.Comments(), c) {
|
||||
t.Errorf("comments are not equal\n")
|
||||
}
|
||||
|
||||
if tkn.String() != `foo` {
|
||||
t.Errorf("token value is not equal\n")
|
||||
}
|
||||
|
||||
if tkn.Position() != pos {
|
||||
t.Errorf("token position is not equal\n")
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user