From f2cf2061ee900bd2965b457558a46fbcf0c21f12 Mon Sep 17 00:00:00 2001
From: z7zmey <z7zmey@gmail.com>
Date: Mon, 8 Jan 2018 17:02:56 +0200
Subject: [PATCH] use Token.File to handle new lines

---
 parser/lexer.go   |  31 ++---
 parser/scanner.go | 337 +++++++++++++++++++++++----------------------
 parser/scanner.l  | 339 +++++++++++++++++++++++-----------------------
 3 files changed, 345 insertions(+), 362 deletions(-)

diff --git a/parser/lexer.go b/parser/lexer.go
index 98e4ea9..b76056f 100644
--- a/parser/lexer.go
+++ b/parser/lexer.go
@@ -21,7 +21,6 @@ const (
 type lexer struct {
 	*lex.Lexer
 	stateStack    []int
-	lineNumber    int
 	phpDocComment string
 	comments      *[]comment.Comment
 }
@@ -46,7 +45,7 @@ func newLexer(src io.Reader, fName string) *lexer {
 	if err != nil {
 		panic(err)
 	}
-	return &lexer{lx, []int{0}, 1, "", nil}
+	return &lexer{lx, []int{0}, "", nil}
 }
 
 func (l *lexer) ungetN(n int) []byte {
@@ -88,31 +87,17 @@ func (l *lexer) getCurrentState() int {
 	return l.stateStack[len(l.stateStack)-1]
 }
 
-func (l *lexer) handleNewLine(tokenBytes []byte) ([]byte, int, int, int, int) {
-	startln := l.lineNumber
+func (l *lexer) newToken(tokenBytes []byte) t.Token {
+	tokenBytesEnd := len(tokenBytes) - 1
 
-	var prev byte
-
-	for _, b := range tokenBytes {
-		if b == '\n' || prev == '\r' {
-			l.lineNumber++
-		}
-
-		prev = b
-	}
-
-	// handle last \r
-	if prev == '\r' {
-		l.lineNumber++
-	}
+	startLine := l.File.Line(l.First.Pos())
+	lastChar := l.Token()[tokenBytesEnd]
+	endLine := l.File.Line(lastChar.Pos())
 
 	startPos := int(l.First.Pos())
-	endPos := startPos + len(tokenBytes) - 1
-	return tokenBytes, startln, l.lineNumber, startPos, endPos
-}
+	endPos := startPos + tokenBytesEnd
 
-func (l *lexer) newToken() t.Token {
-	return t.NewToken(l.handleNewLine(l.TokenBytes(nil))).SetComments(l.comments)
+	return t.NewToken(tokenBytes, startLine, endLine, startPos, endPos).SetComments(l.comments)
 }
 
 func (l *lexer) addComment(c comment.Comment) {
diff --git a/parser/scanner.go b/parser/scanner.go
index ff2704f..a83cb79 100644
--- a/parser/scanner.go
+++ b/parser/scanner.go
@@ -12,7 +12,6 @@ import (
 	"bytes"
 	"fmt"
 	"github.com/z7zmey/php-parser/comment"
-	"github.com/z7zmey/php-parser/token"
 )
 
 const (
@@ -7431,7 +7430,7 @@ yystate593:
 
 yyrule1: // [ \t\n\r]+
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		goto yystate0
 	}
 yyrule2: // .
@@ -7454,43 +7453,43 @@ yyrule2: // .
 			}
 			c = l.Next()
 		}
-		lval.token = token.NewToken(l.handleNewLine(tb))
+		lval.token = l.newToken(tb)
 		return T_INLINE_HTML
 	}
 yyrule3: // \<\?php([ \t]|{NEW_LINE})
 	{
 		l.begin(PHP)
-		lval.token = l.newToken() // return T_OPEN_TAG;
+		lval.token = l.newToken(l.TokenBytes(nil)) // return T_OPEN_TAG;
 		goto yystate0
 	}
 yyrule4: // \<\?
 	{
 		l.begin(PHP)
-		lval.token = l.newToken() // return T_OPEN_TAG;
+		lval.token = l.newToken(l.TokenBytes(nil)) // return T_OPEN_TAG;
 		goto yystate0
 	}
 yyrule5: // \<\?=
 	{
 		l.begin(PHP)
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_ECHO
 		goto yystate0
 	}
 yyrule6: // [ \t\n\r]+
 	{
-		lval.token = l.newToken() // return T_WHITESPACE
+		lval.token = l.newToken(l.TokenBytes(nil)) // return T_WHITESPACE
 		goto yystate0
 	}
 yyrule7: // \?\>{NEW_LINE}?
 	{
 		l.begin(INITIAL)
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return rune2Class(';')
 		goto yystate0
 	}
 yyrule8: // {DNUM}|{EXPONENT_DNUM}
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_DNUMBER
 		goto yystate0
 	}
@@ -7512,10 +7511,10 @@ yyrule9: // {BNUM}
 			}
 		}
 		if len(tb)-i < 64 {
-			lval.token = l.newToken()
+			lval.token = l.newToken(l.TokenBytes(nil))
 			return T_LNUMBER
 		} else {
-			lval.token = l.newToken()
+			lval.token = l.newToken(l.TokenBytes(nil))
 			return T_DNUMBER
 		}
 		goto yystate0
@@ -7524,10 +7523,10 @@ yyrule10: // {LNUM}
 	{
 
 		if len(l.TokenBytes(nil)) < 20 {
-			lval.token = l.newToken()
+			lval.token = l.newToken(l.TokenBytes(nil))
 			return T_LNUMBER
 		} else {
-			lval.token = l.newToken()
+			lval.token = l.newToken(l.TokenBytes(nil))
 			return T_DNUMBER
 		}
 		goto yystate0
@@ -7551,695 +7550,695 @@ yyrule11: // {HNUM}
 		}
 		length := len(tb) - i
 		if length < 16 || (length == 16 && tb[i] <= '7') {
-			lval.token = l.newToken()
+			lval.token = l.newToken(l.TokenBytes(nil))
 			return T_LNUMBER
 		} else {
-			lval.token = l.newToken()
+			lval.token = l.newToken(l.TokenBytes(nil))
 			return T_DNUMBER
 		}
 		goto yystate0
 	}
 yyrule12: // abstract
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_ABSTRACT
 		goto yystate0
 	}
 yyrule13: // array
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_ARRAY
 		goto yystate0
 	}
 yyrule14: // as
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_AS
 		goto yystate0
 	}
 yyrule15: // break
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_BREAK
 		goto yystate0
 	}
 yyrule16: // callable
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_CALLABLE
 		goto yystate0
 	}
 yyrule17: // case
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_CASE
 		goto yystate0
 	}
 yyrule18: // catch
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_CATCH
 		goto yystate0
 	}
 yyrule19: // class
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_CLASS
 		goto yystate0
 	}
 yyrule20: // clone
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_CLONE
 		goto yystate0
 	}
 yyrule21: // const
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_CONST
 		goto yystate0
 	}
 yyrule22: // continue
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_CONTINUE
 		goto yystate0
 	}
 yyrule23: // declare
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_DECLARE
 		goto yystate0
 	}
 yyrule24: // default
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_DEFAULT
 		goto yystate0
 	}
 yyrule25: // do
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_DO
 		goto yystate0
 	}
 yyrule26: // echo
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_ECHO
 		goto yystate0
 	}
 yyrule27: // else
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_ELSE
 		goto yystate0
 	}
 yyrule28: // elseif
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_ELSEIF
 		goto yystate0
 	}
 yyrule29: // empty
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_EMPTY
 		goto yystate0
 	}
 yyrule30: // enddeclare
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_ENDDECLARE
 		goto yystate0
 	}
 yyrule31: // endfor
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_ENDFOR
 		goto yystate0
 	}
 yyrule32: // endforeach
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_ENDFOREACH
 		goto yystate0
 	}
 yyrule33: // endif
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_ENDIF
 		goto yystate0
 	}
 yyrule34: // endswitch
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_ENDSWITCH
 		goto yystate0
 	}
 yyrule35: // endwhile
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_ENDWHILE
 		goto yystate0
 	}
 yyrule36: // eval
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_EVAL
 		goto yystate0
 	}
 yyrule37: // exit|die
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_EXIT
 		goto yystate0
 	}
 yyrule38: // extends
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_EXTENDS
 		goto yystate0
 	}
 yyrule39: // final
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_FINAL
 		goto yystate0
 	}
 yyrule40: // finally
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_FINALLY
 		goto yystate0
 	}
 yyrule41: // for
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_FOR
 		goto yystate0
 	}
 yyrule42: // foreach
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_FOREACH
 		goto yystate0
 	}
 yyrule43: // function|cfunction
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_FUNCTION
 		goto yystate0
 	}
 yyrule44: // global
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_GLOBAL
 		goto yystate0
 	}
 yyrule45: // goto
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_GOTO
 		goto yystate0
 	}
 yyrule46: // if
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_IF
 		goto yystate0
 	}
 yyrule47: // isset
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_ISSET
 		goto yystate0
 	}
 yyrule48: // implements
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_IMPLEMENTS
 		goto yystate0
 	}
 yyrule49: // instanceof
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_INSTANCEOF
 		goto yystate0
 	}
 yyrule50: // insteadof
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_INSTEADOF
 		goto yystate0
 	}
 yyrule51: // interface
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_INTERFACE
 		goto yystate0
 	}
 yyrule52: // list
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_LIST
 		goto yystate0
 	}
 yyrule53: // namespace
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_NAMESPACE
 		goto yystate0
 	}
 yyrule54: // private
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_PRIVATE
 		goto yystate0
 	}
 yyrule55: // public
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_PUBLIC
 		goto yystate0
 	}
 yyrule56: // print
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_PRINT
 		goto yystate0
 	}
 yyrule57: // protected
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_PROTECTED
 		goto yystate0
 	}
 yyrule58: // return
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_RETURN
 		goto yystate0
 	}
 yyrule59: // static
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_STATIC
 		goto yystate0
 	}
 yyrule60: // switch
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_SWITCH
 		goto yystate0
 	}
 yyrule61: // throw
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_THROW
 		goto yystate0
 	}
 yyrule62: // trait
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_TRAIT
 		goto yystate0
 	}
 yyrule63: // try
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_TRY
 		goto yystate0
 	}
 yyrule64: // unset
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_UNSET
 		goto yystate0
 	}
 yyrule65: // use
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_USE
 		goto yystate0
 	}
 yyrule66: // var
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_VAR
 		goto yystate0
 	}
 yyrule67: // while
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_WHILE
 		goto yystate0
 	}
 yyrule68: // yield[ \t\n\r]+from[^a-zA-Z0-9_\x80-\xff]
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_YIELD_FROM
 		goto yystate0
 	}
 yyrule69: // yield
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_YIELD
 		goto yystate0
 	}
 yyrule70: // include
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_INCLUDE
 		goto yystate0
 	}
 yyrule71: // include_once
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_INCLUDE_ONCE
 		goto yystate0
 	}
 yyrule72: // require
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_REQUIRE
 		goto yystate0
 	}
 yyrule73: // require_once
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_REQUIRE_ONCE
 		goto yystate0
 	}
 yyrule74: // __CLASS__
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_CLASS_C
 		goto yystate0
 	}
 yyrule75: // __DIR__
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_DIR
 		goto yystate0
 	}
 yyrule76: // __FILE__
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_FILE
 		goto yystate0
 	}
 yyrule77: // __FUNCTION__
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_FUNC_C
 		goto yystate0
 	}
 yyrule78: // __LINE__
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_LINE
 		goto yystate0
 	}
 yyrule79: // __NAMESPACE__
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_NS_C
 		goto yystate0
 	}
 yyrule80: // __METHOD__
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_METHOD_C
 		goto yystate0
 	}
 yyrule81: // __TRAIT__
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_TRAIT_C
 		goto yystate0
 	}
 yyrule82: // __halt_compiler
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_HALT_COMPILER
 		goto yystate0
 	}
 yyrule83: // \([ \t]*array[ \t]*\)
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_ARRAY_CAST
 		goto yystate0
 	}
 yyrule84: // \([ \t]*(bool|boolean)[ \t]*\)
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_BOOL_CAST
 		goto yystate0
 	}
 yyrule85: // \([ \t]*(real|double|float)[ \t]*\)
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_DOUBLE_CAST
 		goto yystate0
 	}
 yyrule86: // \([ \t]*(int|integer)[ \t]*\)
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_INT_CAST
 		goto yystate0
 	}
 yyrule87: // \([ \t]*object[ \t]*\)
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_OBJECT_CAST
 		goto yystate0
 	}
 yyrule88: // \([ \t]*string[ \t]*\)
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_STRING_CAST
 		goto yystate0
 	}
 yyrule89: // \([ \t]*unset[ \t]*\)
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_UNSET_CAST
 		goto yystate0
 	}
 yyrule90: // new
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_NEW
 		goto yystate0
 	}
 yyrule91: // and
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_LOGICAL_AND
 		goto yystate0
 	}
 yyrule92: // or
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_LOGICAL_OR
 		goto yystate0
 	}
 yyrule93: // xor
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_LOGICAL_XOR
 		goto yystate0
 	}
 yyrule94: // \\
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_NS_SEPARATOR
 		goto yystate0
 	}
 yyrule95: // \.\.\.
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_ELLIPSIS
 		goto yystate0
 	}
 yyrule96: // ::
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_PAAMAYIM_NEKUDOTAYIM // T_DOUBLE_COLON
 		goto yystate0
 	}
 yyrule97: // &&
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_BOOLEAN_AND
 		goto yystate0
 	}
 yyrule98: // \|\|
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_BOOLEAN_OR
 		goto yystate0
 	}
 yyrule99: // &=
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_AND_EQUAL
 		goto yystate0
 	}
 yyrule100: // \|=
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_OR_EQUAL
 		goto yystate0
 	}
 yyrule101: // \.=
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_CONCAT_EQUAL
 		goto yystate0
 	}
 yyrule102: // \*=
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_MUL_EQUAL
 		goto yystate0
 	}
 yyrule103: // \*\*=
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_POW_EQUAL
 		goto yystate0
 	}
 yyrule104: // [/]=
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_DIV_EQUAL
 		goto yystate0
 	}
 yyrule105: // \+=
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_PLUS_EQUAL
 		goto yystate0
 	}
 yyrule106: // -=
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_MINUS_EQUAL
 		goto yystate0
 	}
 yyrule107: // \^=
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_XOR_EQUAL
 		goto yystate0
 	}
 yyrule108: // %=
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_MOD_EQUAL
 		goto yystate0
 	}
 yyrule109: // --
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_DEC
 		goto yystate0
 	}
 yyrule110: // \+\+
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_INC
 		goto yystate0
 	}
 yyrule111: // =>
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_DOUBLE_ARROW
 		goto yystate0
 	}
 yyrule112: // \<=\>
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_SPACESHIP
 		goto yystate0
 	}
 yyrule113: // \!=|\<\>
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_IS_NOT_EQUAL
 		goto yystate0
 	}
 yyrule114: // \!==
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_IS_NOT_IDENTICAL
 		goto yystate0
 	}
 yyrule115: // ==
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_IS_EQUAL
 		goto yystate0
 	}
 yyrule116: // ===
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_IS_IDENTICAL
 		goto yystate0
 	}
 yyrule117: // \<\<=
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_SL_EQUAL
 		goto yystate0
 	}
 yyrule118: // \>\>=
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_SR_EQUAL
 		goto yystate0
 	}
 yyrule119: // \>=
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_IS_GREATER_OR_EQUAL
 		goto yystate0
 	}
 yyrule120: // \<=
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_IS_SMALLER_OR_EQUAL
 		goto yystate0
 	}
 yyrule121: // \*\*
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_POW
 		goto yystate0
 	}
 yyrule122: // \<\<
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_SL
 		goto yystate0
 	}
 yyrule123: // \>\>
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_SR
 		goto yystate0
 	}
 yyrule124: // \?\?
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_COALESCE
 		goto yystate0
 	}
 yyrule125: // (#|[/][/]).*{NEW_LINE}
 	{
-		lval.token = l.newToken() // return T_COMMENT; // TODO: handle ?>
+		lval.token = l.newToken(l.TokenBytes(nil)) // return T_COMMENT; // TODO: handle ?>
 		goto yystate0
 	}
 yyrule126: // ([/][*])|([/][*][*])
@@ -8262,7 +8261,7 @@ yyrule126: // ([/][*])|([/][*][*])
 				break
 			}
 		}
-		lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil)))
+		lval.token = l.newToken(l.TokenBytes(nil))
 		if is_doc_comment {
 			l.phpDocComment = string(l.TokenBytes(nil))
 			l.addComment(comment.NewDocComment(string(l.TokenBytes(nil))))
@@ -8275,60 +8274,60 @@ yyrule126: // ([/][*])|([/][*][*])
 	}
 yyrule127: // {OPERATORS}
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return rune2Class(rune(l.TokenBytes(nil)[0]))
 		goto yystate0
 	}
 yyrule128: // \{
 	{
 		l.pushState(PHP)
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return rune2Class(rune(l.TokenBytes(nil)[0]))
 		goto yystate0
 	}
 yyrule129: // \}
 	{
 		l.popState()
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return rune2Class(rune(l.TokenBytes(nil)[0]))
 		l.phpDocComment = ""
 		goto yystate0
 	}
 yyrule130: // \${VAR_NAME}
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_VARIABLE
 		goto yystate0
 	}
 yyrule131: // {VAR_NAME}
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_STRING
 		goto yystate0
 	}
 yyrule132: // ->
 	{
 		l.begin(PROPERTY)
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_OBJECT_OPERATOR
 		goto yystate0
 	}
 yyrule133: // [ \t\n\r]+
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_WHITESPACE
 		goto yystate0
 	}
 yyrule134: // ->
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_OBJECT_OPERATOR
 		goto yystate0
 	}
 yyrule135: // {VAR_NAME}
 	{
 		l.begin(PHP)
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_STRING
 		goto yystate0
 	}
@@ -8340,21 +8339,21 @@ yyrule136: // .
 	}
 yyrule137: // [\']([^\\\']*([\\].)*)*[\']
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_CONSTANT_ENCAPSED_STRING
 		goto yystate0
 	}
 yyrule138: // `
 	{
 		l.begin(BACKQUOTE)
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return rune2Class(rune(l.TokenBytes(nil)[0]))
 		goto yystate0
 	}
 yyrule139: // `
 	{
 		l.begin(PHP)
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return rune2Class(rune(l.TokenBytes(nil)[0]))
 		goto yystate0
 	}
@@ -8411,7 +8410,7 @@ yyrule140: // [b]?\<\<\<[ \t]*({VAR_NAME}|([']{VAR_NAME}['])|(["]{VAR_NAME}["]))
 			}
 		}
 		l.ungetN(ungetCnt)
-		lval.token = token.NewToken(l.handleNewLine(tb))
+		lval.token = l.newToken(tb)
 		return T_START_HEREDOC
 	}
 yyrule141: // .
@@ -8437,13 +8436,13 @@ yyrule141: // .
 			}
 			c = l.Next()
 		}
-		lval.token = token.NewToken(l.handleNewLine(tb))
+		lval.token = l.newToken(tb)
 		return T_ENCAPSED_AND_WHITESPACE
 	}
 yyrule142: // {VAR_NAME}\;
 	{
 		l.begin(PHP)
-		lval.token = token.NewToken(l.handleNewLine(l.ungetN(1)))
+		lval.token = l.newToken(l.ungetN(1))
 		return T_END_HEREDOC
 		goto yystate0
 	}
@@ -8460,7 +8459,7 @@ yyrule143: // [b]?[\"]
 			l.ungetN(len(l.TokenBytes(nil)) - cnt)
 			tokenBytes := l.TokenBytes(nil)[:cnt]
 			l.pushState(STRING)
-			lval.token = token.NewToken(l.handleNewLine(tokenBytes))
+			lval.token = l.newToken(tokenBytes)
 			return rune2Class('"')
 		}
 	F:
@@ -8471,7 +8470,7 @@ yyrule143: // [b]?[\"]
 			switch c {
 			case '"':
 				c = l.Next()
-				lval.token = l.newToken()
+				lval.token = l.newToken(l.TokenBytes(nil))
 				return T_CONSTANT_ENCAPSED_STRING
 				break F
 
@@ -8500,13 +8499,13 @@ yyrule143: // [b]?[\"]
 yyrule144: // \"
 	{
 		l.popState()
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return rune2Class(rune(l.TokenBytes(nil)[0]))
 		goto yystate0
 	}
 yyrule145: // \{\$
 	{
-		lval.token = token.NewToken(l.handleNewLine(l.ungetN(1)))
+		lval.token = l.newToken(l.ungetN(1))
 		l.pushState(PHP)
 		return T_CURLY_OPEN
 		goto yystate0
@@ -8514,7 +8513,7 @@ yyrule145: // \{\$
 yyrule146: // \$\{
 	{
 		l.pushState(STRING_VAR_NAME)
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_DOLLAR_OPEN_CURLY_BRACES
 		goto yystate0
 	}
@@ -8534,7 +8533,7 @@ yyrule148: // .|[ \t\n\r]
 			}
 			switch c {
 			case '"':
-				lval.token = l.newToken()
+				lval.token = l.newToken(l.TokenBytes(nil))
 				return T_ENCAPSED_AND_WHITESPACE
 				break F1
 
@@ -8543,7 +8542,7 @@ yyrule148: // .|[ \t\n\r]
 				if rune(c) == '{' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z' || c >= '\u007f' && c <= 'ÿ' {
 					l.ungetN(1)
 					tb := l.TokenBytes(nil)
-					lval.token = token.NewToken(l.handleNewLine(tb[:len(tb)-1]))
+					lval.token = l.newToken(tb[:len(tb)-1])
 					return T_ENCAPSED_AND_WHITESPACE
 					break F1
 				}
@@ -8554,7 +8553,7 @@ yyrule148: // .|[ \t\n\r]
 				if rune(c) == '$' {
 					l.ungetN(1)
 					tb := l.TokenBytes(nil)
-					lval.token = token.NewToken(l.handleNewLine(tb[:len(tb)-1]))
+					lval.token = l.newToken(tb[:len(tb)-1])
 					return T_ENCAPSED_AND_WHITESPACE
 					break F1
 				}
@@ -8576,7 +8575,7 @@ yyrule149: // .|[ \t\n\r]
 			}
 			switch c {
 			case '`':
-				lval.token = l.newToken()
+				lval.token = l.newToken(l.TokenBytes(nil))
 				return T_ENCAPSED_AND_WHITESPACE
 				break F2
 
@@ -8585,7 +8584,7 @@ yyrule149: // .|[ \t\n\r]
 				if rune(c) == '{' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z' || c >= '\u007f' && c <= 'ÿ' {
 					l.ungetN(1)
 					tb := l.TokenBytes(nil)
-					lval.token = token.NewToken(l.handleNewLine(tb[:len(tb)-1]))
+					lval.token = l.newToken(tb[:len(tb)-1])
 					return T_ENCAPSED_AND_WHITESPACE
 					break F2
 				}
@@ -8596,7 +8595,7 @@ yyrule149: // .|[ \t\n\r]
 				if rune(c) == '$' {
 					l.ungetN(1)
 					tb := l.TokenBytes(nil)
-					lval.token = token.NewToken(l.handleNewLine(tb[:len(tb)-1]))
+					lval.token = l.newToken(tb[:len(tb)-1])
 					return T_ENCAPSED_AND_WHITESPACE
 					break F2
 				}
@@ -8658,32 +8657,32 @@ yyrule150: // .|[ \t\n\r]
 			c = l.Next()
 		}
 
-		lval.token = token.NewToken(l.handleNewLine(tb))
+		lval.token = l.newToken(tb)
 		return T_ENCAPSED_AND_WHITESPACE
 	}
 yyrule151: // \${VAR_NAME}
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_VARIABLE
 		goto yystate0
 	}
 yyrule152: // ->{VAR_NAME}
 	{
-		lval.token = token.NewToken(l.handleNewLine(l.ungetN(len(l.TokenBytes(nil)) - 2)))
+		lval.token = l.newToken(l.ungetN(len(l.TokenBytes(nil)) - 2))
 		return T_OBJECT_OPERATOR
 		goto yystate0
 	}
 yyrule153: // {VAR_NAME}
 	{
 		l.popState()
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_STRING
 		goto yystate0
 	}
 yyrule154: // \[
 	{
 		l.pushState(STRING_VAR_INDEX)
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return rune2Class(rune(l.TokenBytes(nil)[0]))
 		goto yystate0
 	}
@@ -8695,19 +8694,19 @@ yyrule155: // .|[ \t\n\r]
 	}
 yyrule156: // {LNUM}|{HNUM}|{BNUM}
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_NUM_STRING
 		goto yystate0
 	}
 yyrule157: // \${VAR_NAME}
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_VARIABLE
 		goto yystate0
 	}
 yyrule158: // {VAR_NAME}
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_STRING
 		goto yystate0
 	}
@@ -8715,7 +8714,7 @@ yyrule159: // \]
 	{
 		l.popState()
 		l.popState()
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return rune2Class(rune(l.TokenBytes(nil)[0]))
 		goto yystate0
 	}
@@ -8723,19 +8722,19 @@ yyrule160: // [ \n\r\t\\'#]
 	{
 		l.popState()
 		l.popState()
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return T_ENCAPSED_AND_WHITESPACE
 		goto yystate0
 	}
 yyrule161: // {OPERATORS}
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return rune2Class(rune(l.TokenBytes(nil)[0]))
 		goto yystate0
 	}
 yyrule162: // .
 	{
-		lval.token = l.newToken()
+		lval.token = l.newToken(l.TokenBytes(nil))
 		return rune2Class(rune(l.TokenBytes(nil)[0]))
 		goto yystate0
 	}
@@ -8743,7 +8742,7 @@ yyrule163: // {VAR_NAME}[\[\}]
 	{
 		l.popState()
 		l.pushState(PHP)
-		lval.token = token.NewToken(l.handleNewLine(l.ungetN(1)))
+		lval.token = l.newToken(l.ungetN(1))
 		return T_STRING_VARNAME
 		goto yystate0
 	}
diff --git a/parser/scanner.l b/parser/scanner.l
index fb7506a..522fedd 100644
--- a/parser/scanner.l
+++ b/parser/scanner.l
@@ -10,8 +10,7 @@ package parser
 import (
     "fmt"
     "bytes"
-    "github.com/z7zmey/php-parser/token"
-	"github.com/z7zmey/php-parser/comment"
+    "github.com/z7zmey/php-parser/comment"
 )
 
 const (
@@ -57,7 +56,7 @@ NEW_LINE        (\r|\n|\r\n)
 %%
     c = l.Rule0()
 
-<INITIAL>[ \t\n\r]+                             lval.token = l.newToken();
+<INITIAL>[ \t\n\r]+                             lval.token =  l.newToken(l.TokenBytes(nil));
 <INITIAL>.
     tb := []byte{}
 
@@ -81,17 +80,17 @@ NEW_LINE        (\r|\n|\r\n)
         c = l.Next()
     }
 
-    lval.token = token.NewToken(l.handleNewLine(tb)); 
+    lval.token = l.newToken(tb)
     return T_INLINE_HTML
 
-<INITIAL>\<\?php([ \t]|{NEW_LINE})              l.begin(PHP);lval.token = l.newToken();// return T_OPEN_TAG;
-<INITIAL>\<\?                                   l.begin(PHP);lval.token = l.newToken();// return T_OPEN_TAG;
-<INITIAL>\<\?=                                  l.begin(PHP);lval.token = l.newToken(); return T_ECHO;
+<INITIAL>\<\?php([ \t]|{NEW_LINE})              l.begin(PHP);lval.token =  l.newToken(l.TokenBytes(nil));// return T_OPEN_TAG;
+<INITIAL>\<\?                                   l.begin(PHP);lval.token =  l.newToken(l.TokenBytes(nil));// return T_OPEN_TAG;
+<INITIAL>\<\?=                                  l.begin(PHP);lval.token =  l.newToken(l.TokenBytes(nil)); return T_ECHO;
 
-<PHP>[ \t\n\r]+                                 lval.token = l.newToken();// return T_WHITESPACE
-<PHP>\?\>{NEW_LINE}?                            l.begin(INITIAL);lval.token = l.newToken(); return rune2Class(';');
+<PHP>[ \t\n\r]+                                 lval.token =  l.newToken(l.TokenBytes(nil));// return T_WHITESPACE
+<PHP>\?\>{NEW_LINE}?                            l.begin(INITIAL);lval.token =  l.newToken(l.TokenBytes(nil)); return rune2Class(';');
 
-<PHP>{DNUM}|{EXPONENT_DNUM}                     lval.token = l.newToken(); return T_DNUMBER
+<PHP>{DNUM}|{EXPONENT_DNUM}                     lval.token =  l.newToken(l.TokenBytes(nil)); return T_DNUMBER
 <PHP>{BNUM}
     tb := l.TokenBytes(nil)
     i:=2
@@ -105,15 +104,15 @@ NEW_LINE        (\r|\n|\r\n)
         }
     }
     if len(tb) - i < 64 {
-        lval.token = l.newToken(); return T_LNUMBER
+        lval.token =  l.newToken(l.TokenBytes(nil)); return T_LNUMBER
     } else {
-        lval.token = l.newToken(); return T_DNUMBER
+        lval.token =  l.newToken(l.TokenBytes(nil)); return T_DNUMBER
     }
 <PHP>{LNUM}
     if len(l.TokenBytes(nil)) < 20 {
-        lval.token = l.newToken(); return T_LNUMBER
+        lval.token =  l.newToken(l.TokenBytes(nil)); return T_LNUMBER
     } else {
-        lval.token = l.newToken(); return T_DNUMBER
+        lval.token =  l.newToken(l.TokenBytes(nil)); return T_DNUMBER
     }
 <PHP>{HNUM}
     tb := l.TokenBytes(nil)
@@ -129,125 +128,125 @@ NEW_LINE        (\r|\n|\r\n)
     }
     length := len(tb) - i
     if length < 16 || (length == 16 && tb[i] <= '7') {
-        lval.token = l.newToken(); return T_LNUMBER
+        lval.token =  l.newToken(l.TokenBytes(nil)); return T_LNUMBER
     } else {
-        lval.token = l.newToken(); return T_DNUMBER
+        lval.token =  l.newToken(l.TokenBytes(nil)); return T_DNUMBER
     }
 
-<PHP>abstract                                   lval.token = l.newToken(); return T_ABSTRACT
-<PHP>array                                      lval.token = l.newToken(); return T_ARRAY
-<PHP>as                                         lval.token = l.newToken(); return T_AS
-<PHP>break                                      lval.token = l.newToken(); return T_BREAK
-<PHP>callable                                   lval.token = l.newToken(); return T_CALLABLE
-<PHP>case                                       lval.token = l.newToken(); return T_CASE
-<PHP>catch                                      lval.token = l.newToken(); return T_CATCH
-<PHP>class                                      lval.token = l.newToken(); return T_CLASS
-<PHP>clone                                      lval.token = l.newToken(); return T_CLONE
-<PHP>const                                      lval.token = l.newToken(); return T_CONST;
-<PHP>continue                                   lval.token = l.newToken(); return T_CONTINUE;
-<PHP>declare                                    lval.token = l.newToken(); return T_DECLARE;
-<PHP>default                                    lval.token = l.newToken(); return T_DEFAULT;
-<PHP>do                                         lval.token = l.newToken(); return T_DO;
-<PHP>echo                                       lval.token = l.newToken(); return T_ECHO;
-<PHP>else                                       lval.token = l.newToken(); return T_ELSE;
-<PHP>elseif                                     lval.token = l.newToken(); return T_ELSEIF;
-<PHP>empty                                      lval.token = l.newToken(); return T_EMPTY;
-<PHP>enddeclare                                 lval.token = l.newToken(); return T_ENDDECLARE
-<PHP>endfor                                     lval.token = l.newToken(); return T_ENDFOR
-<PHP>endforeach                                 lval.token = l.newToken(); return T_ENDFOREACH
-<PHP>endif                                      lval.token = l.newToken(); return T_ENDIF
-<PHP>endswitch                                  lval.token = l.newToken(); return T_ENDSWITCH
-<PHP>endwhile                                   lval.token = l.newToken(); return T_ENDWHILE
-<PHP>eval                                       lval.token = l.newToken(); return T_EVAL
-<PHP>exit|die                                   lval.token = l.newToken(); return T_EXIT
-<PHP>extends                                    lval.token = l.newToken(); return T_EXTENDS
-<PHP>final                                      lval.token = l.newToken(); return T_FINAL
-<PHP>finally                                    lval.token = l.newToken(); return T_FINALLY
-<PHP>for                                        lval.token = l.newToken(); return T_FOR
-<PHP>foreach                                    lval.token = l.newToken(); return T_FOREACH
-<PHP>function|cfunction                         lval.token = l.newToken(); return T_FUNCTION
-<PHP>global                                     lval.token = l.newToken(); return T_GLOBAL
-<PHP>goto                                       lval.token = l.newToken(); return T_GOTO
-<PHP>if                                         lval.token = l.newToken(); return T_IF
-<PHP>isset                                      lval.token = l.newToken(); return T_ISSET
-<PHP>implements                                 lval.token = l.newToken(); return T_IMPLEMENTS
-<PHP>instanceof                                 lval.token = l.newToken(); return T_INSTANCEOF
-<PHP>insteadof                                  lval.token = l.newToken(); return T_INSTEADOF
-<PHP>interface                                  lval.token = l.newToken(); return T_INTERFACE
-<PHP>list                                       lval.token = l.newToken(); return T_LIST
-<PHP>namespace                                  lval.token = l.newToken(); return T_NAMESPACE
-<PHP>private                                    lval.token = l.newToken(); return T_PRIVATE
-<PHP>public                                     lval.token = l.newToken(); return T_PUBLIC
-<PHP>print                                      lval.token = l.newToken(); return T_PRINT
-<PHP>protected                                  lval.token = l.newToken(); return T_PROTECTED
-<PHP>return                                     lval.token = l.newToken(); return T_RETURN
-<PHP>static                                     lval.token = l.newToken(); return T_STATIC
-<PHP>switch                                     lval.token = l.newToken(); return T_SWITCH
-<PHP>throw                                      lval.token = l.newToken(); return T_THROW
-<PHP>trait                                      lval.token = l.newToken(); return T_TRAIT
-<PHP>try                                        lval.token = l.newToken(); return T_TRY
-<PHP>unset                                      lval.token = l.newToken(); return T_UNSET
-<PHP>use                                        lval.token = l.newToken(); return T_USE
-<PHP>var                                        lval.token = l.newToken(); return T_VAR
-<PHP>while                                      lval.token = l.newToken(); return T_WHILE
-<PHP>yield[ \t\n\r]+from[^a-zA-Z0-9_\x80-\xff]  lval.token = l.newToken(); return T_YIELD_FROM
-<PHP>yield                                      lval.token = l.newToken(); return T_YIELD
-<PHP>include                                    lval.token = l.newToken(); return T_INCLUDE
-<PHP>include_once                               lval.token = l.newToken(); return T_INCLUDE_ONCE
-<PHP>require                                    lval.token = l.newToken(); return T_REQUIRE
-<PHP>require_once                               lval.token = l.newToken(); return T_REQUIRE_ONCE
-<PHP>__CLASS__                                  lval.token = l.newToken(); return T_CLASS_C
-<PHP>__DIR__                                    lval.token = l.newToken(); return T_DIR
-<PHP>__FILE__                                   lval.token = l.newToken(); return T_FILE
-<PHP>__FUNCTION__                               lval.token = l.newToken(); return T_FUNC_C
-<PHP>__LINE__                                   lval.token = l.newToken(); return T_LINE
-<PHP>__NAMESPACE__                              lval.token = l.newToken(); return T_NS_C
-<PHP>__METHOD__                                 lval.token = l.newToken(); return T_METHOD_C
-<PHP>__TRAIT__                                  lval.token = l.newToken(); return T_TRAIT_C
-<PHP>__halt_compiler                            lval.token = l.newToken(); return T_HALT_COMPILER
-<PHP>\([ \t]*array[ \t]*\)                      lval.token = l.newToken(); return T_ARRAY_CAST
-<PHP>\([ \t]*(bool|boolean)[ \t]*\)             lval.token = l.newToken(); return T_BOOL_CAST
-<PHP>\([ \t]*(real|double|float)[ \t]*\)        lval.token = l.newToken(); return T_DOUBLE_CAST
-<PHP>\([ \t]*(int|integer)[ \t]*\)              lval.token = l.newToken(); return T_INT_CAST
-<PHP>\([ \t]*object[ \t]*\)                     lval.token = l.newToken(); return T_OBJECT_CAST
-<PHP>\([ \t]*string[ \t]*\)                     lval.token = l.newToken(); return T_STRING_CAST
-<PHP>\([ \t]*unset[ \t]*\)                      lval.token = l.newToken(); return T_UNSET_CAST
-<PHP>new                                        lval.token = l.newToken(); return T_NEW
-<PHP>and                                        lval.token = l.newToken(); return T_LOGICAL_AND
-<PHP>or                                         lval.token = l.newToken(); return T_LOGICAL_OR
-<PHP>xor                                        lval.token = l.newToken(); return T_LOGICAL_XOR
-<PHP>\\                                         lval.token = l.newToken(); return T_NS_SEPARATOR
-<PHP>\.\.\.                                     lval.token = l.newToken(); return T_ELLIPSIS;
-<PHP>::                                         lval.token = l.newToken(); return T_PAAMAYIM_NEKUDOTAYIM; // T_DOUBLE_COLON
-<PHP>&&                                         lval.token = l.newToken(); return T_BOOLEAN_AND
-<PHP>\|\|                                       lval.token = l.newToken(); return T_BOOLEAN_OR
-<PHP>&=                                         lval.token = l.newToken(); return T_AND_EQUAL
-<PHP>\|=                                        lval.token = l.newToken(); return T_OR_EQUAL
-<PHP>\.=                                        lval.token = l.newToken(); return T_CONCAT_EQUAL;
-<PHP>\*=                                        lval.token = l.newToken(); return T_MUL_EQUAL
-<PHP>\*\*=                                      lval.token = l.newToken(); return T_POW_EQUAL
-<PHP>[/]=                                       lval.token = l.newToken(); return T_DIV_EQUAL;
-<PHP>\+=                                        lval.token = l.newToken(); return T_PLUS_EQUAL
-<PHP>-=                                         lval.token = l.newToken(); return T_MINUS_EQUAL
-<PHP>\^=                                        lval.token = l.newToken(); return T_XOR_EQUAL
-<PHP>%=                                         lval.token = l.newToken(); return T_MOD_EQUAL
-<PHP>--                                         lval.token = l.newToken(); return T_DEC;
-<PHP>\+\+                                       lval.token = l.newToken(); return T_INC
-<PHP>=>                                         lval.token = l.newToken(); return T_DOUBLE_ARROW;
-<PHP>\<=\>                                      lval.token = l.newToken(); return T_SPACESHIP
-<PHP>\!=|\<\>                                   lval.token = l.newToken(); return T_IS_NOT_EQUAL
-<PHP>\!==                                       lval.token = l.newToken(); return T_IS_NOT_IDENTICAL
-<PHP>==                                         lval.token = l.newToken(); return T_IS_EQUAL
-<PHP>===                                        lval.token = l.newToken(); return T_IS_IDENTICAL
-<PHP>\<\<=                                      lval.token = l.newToken(); return T_SL_EQUAL
-<PHP>\>\>=                                      lval.token = l.newToken(); return T_SR_EQUAL
-<PHP>\>=                                        lval.token = l.newToken(); return T_IS_GREATER_OR_EQUAL
-<PHP>\<=                                        lval.token = l.newToken(); return T_IS_SMALLER_OR_EQUAL
-<PHP>\*\*                                       lval.token = l.newToken(); return T_POW
-<PHP>\<\<                                       lval.token = l.newToken(); return T_SL
-<PHP>\>\>                                       lval.token = l.newToken(); return T_SR
-<PHP>\?\?                                       lval.token = l.newToken(); return T_COALESCE
-<PHP>(#|[/][/]).*{NEW_LINE}                     lval.token = l.newToken();// return T_COMMENT; // TODO: handle ?>
+<PHP>abstract                                   lval.token =  l.newToken(l.TokenBytes(nil)); return T_ABSTRACT
+<PHP>array                                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_ARRAY
+<PHP>as                                         lval.token =  l.newToken(l.TokenBytes(nil)); return T_AS
+<PHP>break                                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_BREAK
+<PHP>callable                                   lval.token =  l.newToken(l.TokenBytes(nil)); return T_CALLABLE
+<PHP>case                                       lval.token =  l.newToken(l.TokenBytes(nil)); return T_CASE
+<PHP>catch                                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_CATCH
+<PHP>class                                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_CLASS
+<PHP>clone                                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_CLONE
+<PHP>const                                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_CONST;
+<PHP>continue                                   lval.token =  l.newToken(l.TokenBytes(nil)); return T_CONTINUE;
+<PHP>declare                                    lval.token =  l.newToken(l.TokenBytes(nil)); return T_DECLARE;
+<PHP>default                                    lval.token =  l.newToken(l.TokenBytes(nil)); return T_DEFAULT;
+<PHP>do                                         lval.token =  l.newToken(l.TokenBytes(nil)); return T_DO;
+<PHP>echo                                       lval.token =  l.newToken(l.TokenBytes(nil)); return T_ECHO;
+<PHP>else                                       lval.token =  l.newToken(l.TokenBytes(nil)); return T_ELSE;
+<PHP>elseif                                     lval.token =  l.newToken(l.TokenBytes(nil)); return T_ELSEIF;
+<PHP>empty                                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_EMPTY;
+<PHP>enddeclare                                 lval.token =  l.newToken(l.TokenBytes(nil)); return T_ENDDECLARE
+<PHP>endfor                                     lval.token =  l.newToken(l.TokenBytes(nil)); return T_ENDFOR
+<PHP>endforeach                                 lval.token =  l.newToken(l.TokenBytes(nil)); return T_ENDFOREACH
+<PHP>endif                                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_ENDIF
+<PHP>endswitch                                  lval.token =  l.newToken(l.TokenBytes(nil)); return T_ENDSWITCH
+<PHP>endwhile                                   lval.token =  l.newToken(l.TokenBytes(nil)); return T_ENDWHILE
+<PHP>eval                                       lval.token =  l.newToken(l.TokenBytes(nil)); return T_EVAL
+<PHP>exit|die                                   lval.token =  l.newToken(l.TokenBytes(nil)); return T_EXIT
+<PHP>extends                                    lval.token =  l.newToken(l.TokenBytes(nil)); return T_EXTENDS
+<PHP>final                                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_FINAL
+<PHP>finally                                    lval.token =  l.newToken(l.TokenBytes(nil)); return T_FINALLY
+<PHP>for                                        lval.token =  l.newToken(l.TokenBytes(nil)); return T_FOR
+<PHP>foreach                                    lval.token =  l.newToken(l.TokenBytes(nil)); return T_FOREACH
+<PHP>function|cfunction                         lval.token =  l.newToken(l.TokenBytes(nil)); return T_FUNCTION
+<PHP>global                                     lval.token =  l.newToken(l.TokenBytes(nil)); return T_GLOBAL
+<PHP>goto                                       lval.token =  l.newToken(l.TokenBytes(nil)); return T_GOTO
+<PHP>if                                         lval.token =  l.newToken(l.TokenBytes(nil)); return T_IF
+<PHP>isset                                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_ISSET
+<PHP>implements                                 lval.token =  l.newToken(l.TokenBytes(nil)); return T_IMPLEMENTS
+<PHP>instanceof                                 lval.token =  l.newToken(l.TokenBytes(nil)); return T_INSTANCEOF
+<PHP>insteadof                                  lval.token =  l.newToken(l.TokenBytes(nil)); return T_INSTEADOF
+<PHP>interface                                  lval.token =  l.newToken(l.TokenBytes(nil)); return T_INTERFACE
+<PHP>list                                       lval.token =  l.newToken(l.TokenBytes(nil)); return T_LIST
+<PHP>namespace                                  lval.token =  l.newToken(l.TokenBytes(nil)); return T_NAMESPACE
+<PHP>private                                    lval.token =  l.newToken(l.TokenBytes(nil)); return T_PRIVATE
+<PHP>public                                     lval.token =  l.newToken(l.TokenBytes(nil)); return T_PUBLIC
+<PHP>print                                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_PRINT
+<PHP>protected                                  lval.token =  l.newToken(l.TokenBytes(nil)); return T_PROTECTED
+<PHP>return                                     lval.token =  l.newToken(l.TokenBytes(nil)); return T_RETURN
+<PHP>static                                     lval.token =  l.newToken(l.TokenBytes(nil)); return T_STATIC
+<PHP>switch                                     lval.token =  l.newToken(l.TokenBytes(nil)); return T_SWITCH
+<PHP>throw                                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_THROW
+<PHP>trait                                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_TRAIT
+<PHP>try                                        lval.token =  l.newToken(l.TokenBytes(nil)); return T_TRY
+<PHP>unset                                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_UNSET
+<PHP>use                                        lval.token =  l.newToken(l.TokenBytes(nil)); return T_USE
+<PHP>var                                        lval.token =  l.newToken(l.TokenBytes(nil)); return T_VAR
+<PHP>while                                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_WHILE
+<PHP>yield[ \t\n\r]+from[^a-zA-Z0-9_\x80-\xff]  lval.token =  l.newToken(l.TokenBytes(nil)); return T_YIELD_FROM
+<PHP>yield                                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_YIELD
+<PHP>include                                    lval.token =  l.newToken(l.TokenBytes(nil)); return T_INCLUDE
+<PHP>include_once                               lval.token =  l.newToken(l.TokenBytes(nil)); return T_INCLUDE_ONCE
+<PHP>require                                    lval.token =  l.newToken(l.TokenBytes(nil)); return T_REQUIRE
+<PHP>require_once                               lval.token =  l.newToken(l.TokenBytes(nil)); return T_REQUIRE_ONCE
+<PHP>__CLASS__                                  lval.token =  l.newToken(l.TokenBytes(nil)); return T_CLASS_C
+<PHP>__DIR__                                    lval.token =  l.newToken(l.TokenBytes(nil)); return T_DIR
+<PHP>__FILE__                                   lval.token =  l.newToken(l.TokenBytes(nil)); return T_FILE
+<PHP>__FUNCTION__                               lval.token =  l.newToken(l.TokenBytes(nil)); return T_FUNC_C
+<PHP>__LINE__                                   lval.token =  l.newToken(l.TokenBytes(nil)); return T_LINE
+<PHP>__NAMESPACE__                              lval.token =  l.newToken(l.TokenBytes(nil)); return T_NS_C
+<PHP>__METHOD__                                 lval.token =  l.newToken(l.TokenBytes(nil)); return T_METHOD_C
+<PHP>__TRAIT__                                  lval.token =  l.newToken(l.TokenBytes(nil)); return T_TRAIT_C
+<PHP>__halt_compiler                            lval.token =  l.newToken(l.TokenBytes(nil)); return T_HALT_COMPILER
+<PHP>\([ \t]*array[ \t]*\)                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_ARRAY_CAST
+<PHP>\([ \t]*(bool|boolean)[ \t]*\)             lval.token =  l.newToken(l.TokenBytes(nil)); return T_BOOL_CAST
+<PHP>\([ \t]*(real|double|float)[ \t]*\)        lval.token =  l.newToken(l.TokenBytes(nil)); return T_DOUBLE_CAST
+<PHP>\([ \t]*(int|integer)[ \t]*\)              lval.token =  l.newToken(l.TokenBytes(nil)); return T_INT_CAST
+<PHP>\([ \t]*object[ \t]*\)                     lval.token =  l.newToken(l.TokenBytes(nil)); return T_OBJECT_CAST
+<PHP>\([ \t]*string[ \t]*\)                     lval.token =  l.newToken(l.TokenBytes(nil)); return T_STRING_CAST
+<PHP>\([ \t]*unset[ \t]*\)                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_UNSET_CAST
+<PHP>new                                        lval.token =  l.newToken(l.TokenBytes(nil)); return T_NEW
+<PHP>and                                        lval.token =  l.newToken(l.TokenBytes(nil)); return T_LOGICAL_AND
+<PHP>or                                         lval.token =  l.newToken(l.TokenBytes(nil)); return T_LOGICAL_OR
+<PHP>xor                                        lval.token =  l.newToken(l.TokenBytes(nil)); return T_LOGICAL_XOR
+<PHP>\\                                         lval.token =  l.newToken(l.TokenBytes(nil)); return T_NS_SEPARATOR
+<PHP>\.\.\.                                     lval.token =  l.newToken(l.TokenBytes(nil)); return T_ELLIPSIS;
+<PHP>::                                         lval.token =  l.newToken(l.TokenBytes(nil)); return T_PAAMAYIM_NEKUDOTAYIM; // T_DOUBLE_COLON
+<PHP>&&                                         lval.token =  l.newToken(l.TokenBytes(nil)); return T_BOOLEAN_AND
+<PHP>\|\|                                       lval.token =  l.newToken(l.TokenBytes(nil)); return T_BOOLEAN_OR
+<PHP>&=                                         lval.token =  l.newToken(l.TokenBytes(nil)); return T_AND_EQUAL
+<PHP>\|=                                        lval.token =  l.newToken(l.TokenBytes(nil)); return T_OR_EQUAL
+<PHP>\.=                                        lval.token =  l.newToken(l.TokenBytes(nil)); return T_CONCAT_EQUAL;
+<PHP>\*=                                        lval.token =  l.newToken(l.TokenBytes(nil)); return T_MUL_EQUAL
+<PHP>\*\*=                                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_POW_EQUAL
+<PHP>[/]=                                       lval.token =  l.newToken(l.TokenBytes(nil)); return T_DIV_EQUAL;
+<PHP>\+=                                        lval.token =  l.newToken(l.TokenBytes(nil)); return T_PLUS_EQUAL
+<PHP>-=                                         lval.token =  l.newToken(l.TokenBytes(nil)); return T_MINUS_EQUAL
+<PHP>\^=                                        lval.token =  l.newToken(l.TokenBytes(nil)); return T_XOR_EQUAL
+<PHP>%=                                         lval.token =  l.newToken(l.TokenBytes(nil)); return T_MOD_EQUAL
+<PHP>--                                         lval.token =  l.newToken(l.TokenBytes(nil)); return T_DEC;
+<PHP>\+\+                                       lval.token =  l.newToken(l.TokenBytes(nil)); return T_INC
+<PHP>=>                                         lval.token =  l.newToken(l.TokenBytes(nil)); return T_DOUBLE_ARROW;
+<PHP>\<=\>                                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_SPACESHIP
+<PHP>\!=|\<\>                                   lval.token =  l.newToken(l.TokenBytes(nil)); return T_IS_NOT_EQUAL
+<PHP>\!==                                       lval.token =  l.newToken(l.TokenBytes(nil)); return T_IS_NOT_IDENTICAL
+<PHP>==                                         lval.token =  l.newToken(l.TokenBytes(nil)); return T_IS_EQUAL
+<PHP>===                                        lval.token =  l.newToken(l.TokenBytes(nil)); return T_IS_IDENTICAL
+<PHP>\<\<=                                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_SL_EQUAL
+<PHP>\>\>=                                      lval.token =  l.newToken(l.TokenBytes(nil)); return T_SR_EQUAL
+<PHP>\>=                                        lval.token =  l.newToken(l.TokenBytes(nil)); return T_IS_GREATER_OR_EQUAL
+<PHP>\<=                                        lval.token =  l.newToken(l.TokenBytes(nil)); return T_IS_SMALLER_OR_EQUAL
+<PHP>\*\*                                       lval.token =  l.newToken(l.TokenBytes(nil)); return T_POW
+<PHP>\<\<                                       lval.token =  l.newToken(l.TokenBytes(nil)); return T_SL
+<PHP>\>\>                                       lval.token =  l.newToken(l.TokenBytes(nil)); return T_SR
+<PHP>\?\?                                       lval.token =  l.newToken(l.TokenBytes(nil)); return T_COALESCE
+<PHP>(#|[/][/]).*{NEW_LINE}                     lval.token =  l.newToken(l.TokenBytes(nil));// return T_COMMENT; // TODO: handle ?>
 <PHP>([/][*])|([/][*][*])
     tb := l.TokenBytes(nil)
     is_doc_comment := false
@@ -270,7 +269,7 @@ NEW_LINE        (\r|\n|\r\n)
         }
     }
 
-    lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil)))
+    lval.token = l.newToken(l.TokenBytes(nil))
     if is_doc_comment {
         l.phpDocComment = string(l.TokenBytes(nil))
         l.addComment(comment.NewDocComment(string(l.TokenBytes(nil))))
@@ -280,23 +279,23 @@ NEW_LINE        (\r|\n|\r\n)
         // return T_COMMENT
     }
 
-<PHP>{OPERATORS}                                lval.token = l.newToken(); return rune2Class(rune(l.TokenBytes(nil)[0]))
+<PHP>{OPERATORS}                                lval.token =  l.newToken(l.TokenBytes(nil)); return rune2Class(rune(l.TokenBytes(nil)[0]))
 
-<PHP>\{                                         l.pushState(PHP); lval.token = l.newToken(); return rune2Class(rune(l.TokenBytes(nil)[0]))
-<PHP>\}                                         l.popState();     lval.token = l.newToken(); return rune2Class(rune(l.TokenBytes(nil)[0])); l.phpDocComment = ""
-<PHP>\${VAR_NAME}                               lval.token = l.newToken(); return T_VARIABLE
-<PHP>{VAR_NAME}                                 lval.token = l.newToken(); return T_STRING
+<PHP>\{                                         l.pushState(PHP); lval.token =  l.newToken(l.TokenBytes(nil)); return rune2Class(rune(l.TokenBytes(nil)[0]))
+<PHP>\}                                         l.popState();     lval.token =  l.newToken(l.TokenBytes(nil)); return rune2Class(rune(l.TokenBytes(nil)[0])); l.phpDocComment = ""
+<PHP>\${VAR_NAME}                               lval.token =  l.newToken(l.TokenBytes(nil)); return T_VARIABLE
+<PHP>{VAR_NAME}                                 lval.token =  l.newToken(l.TokenBytes(nil)); return T_STRING
 
-<PHP>->                                         l.begin(PROPERTY);lval.token = l.newToken(); return T_OBJECT_OPERATOR;
-<PROPERTY>[ \t\n\r]+                            lval.token = l.newToken(); return T_WHITESPACE;
-<PROPERTY>->                                    lval.token = l.newToken(); return T_OBJECT_OPERATOR;
-<PROPERTY>{VAR_NAME}                            l.begin(PHP);lval.token = l.newToken(); return T_STRING;
+<PHP>->                                         l.begin(PROPERTY);lval.token =  l.newToken(l.TokenBytes(nil)); return T_OBJECT_OPERATOR;
+<PROPERTY>[ \t\n\r]+                            lval.token =  l.newToken(l.TokenBytes(nil)); return T_WHITESPACE;
+<PROPERTY>->                                    lval.token =  l.newToken(l.TokenBytes(nil)); return T_OBJECT_OPERATOR;
+<PROPERTY>{VAR_NAME}                            l.begin(PHP);lval.token =  l.newToken(l.TokenBytes(nil)); return T_STRING;
 <PROPERTY>.                                     l.ungetN(1);l.begin(PHP)
 
-<PHP>[\']([^\\\']*([\\].)*)*[\']             lval.token = l.newToken(); return T_CONSTANT_ENCAPSED_STRING;
+<PHP>[\']([^\\\']*([\\].)*)*[\']             lval.token =  l.newToken(l.TokenBytes(nil)); return T_CONSTANT_ENCAPSED_STRING;
 
-<PHP>`                                          l.begin(BACKQUOTE); lval.token = l.newToken(); return rune2Class(rune(l.TokenBytes(nil)[0]))
-<BACKQUOTE>`                                    l.begin(PHP); lval.token = l.newToken(); return rune2Class(rune(l.TokenBytes(nil)[0]))
+<PHP>`                                          l.begin(BACKQUOTE); lval.token =  l.newToken(l.TokenBytes(nil)); return rune2Class(rune(l.TokenBytes(nil)[0]))
+<BACKQUOTE>`                                    l.begin(PHP); lval.token =  l.newToken(l.TokenBytes(nil)); return rune2Class(rune(l.TokenBytes(nil)[0]))
 
 <PHP>[b]?\<\<\<[ \t]*({VAR_NAME}|([']{VAR_NAME}['])|(["]{VAR_NAME}["])){NEW_LINE}
     tb := l.TokenBytes(nil)
@@ -356,7 +355,7 @@ NEW_LINE        (\r|\n|\r\n)
 
     l.ungetN(ungetCnt)
 
-    lval.token = token.NewToken(l.handleNewLine(tb)); 
+    lval.token = l.newToken(tb); 
     return T_START_HEREDOC
 
 <NOWDOC>.
@@ -383,10 +382,10 @@ NEW_LINE        (\r|\n|\r\n)
         c = l.Next()
     }
 
-    lval.token = token.NewToken(l.handleNewLine(tb)); 
+    lval.token = l.newToken(tb) 
     return T_ENCAPSED_AND_WHITESPACE
 
-<HEREDOC_END>{VAR_NAME}\;                       l.begin(PHP);lval.token = token.NewToken(l.handleNewLine(l.ungetN(1))); return T_END_HEREDOC
+<HEREDOC_END>{VAR_NAME}\;                       l.begin(PHP);lval.token = l.newToken(l.ungetN(1)); return T_END_HEREDOC
 
 <PHP>[b]?[\"]
     binPrefix := l.TokenBytes(nil)[0] == 'b'
@@ -398,7 +397,7 @@ NEW_LINE        (\r|\n|\r\n)
         tokenBytes := l.TokenBytes(nil)[:cnt]
         l.pushState(STRING)
 
-        lval.token = token.NewToken(l.handleNewLine(tokenBytes)); return rune2Class('"')
+        lval.token = l.newToken(tokenBytes); return rune2Class('"')
     }
 
     F:for {
@@ -409,7 +408,7 @@ NEW_LINE        (\r|\n|\r\n)
         switch c {
             case '"' : 
                 c = l.Next();
-                lval.token = l.newToken(); return T_CONSTANT_ENCAPSED_STRING
+                lval.token =  l.newToken(l.TokenBytes(nil)); return T_CONSTANT_ENCAPSED_STRING
                 break F;
             
             case '$':
@@ -435,9 +434,9 @@ NEW_LINE        (\r|\n|\r\n)
         c = l.Next()
     }
 
-<STRING>\"                                  l.popState(); lval.token = l.newToken(); return rune2Class(rune(l.TokenBytes(nil)[0]))
-<STRING,HEREDOC,BACKQUOTE>\{\$              lval.token = token.NewToken(l.handleNewLine(l.ungetN(1))); l.pushState(PHP); return T_CURLY_OPEN
-<STRING,HEREDOC,BACKQUOTE>\$\{              l.pushState(STRING_VAR_NAME);lval.token = l.newToken(); return T_DOLLAR_OPEN_CURLY_BRACES
+<STRING>\"                                  l.popState(); lval.token =  l.newToken(l.TokenBytes(nil)); return rune2Class(rune(l.TokenBytes(nil)[0]))
+<STRING,HEREDOC,BACKQUOTE>\{\$              lval.token = l.newToken(l.ungetN(1)); l.pushState(PHP); return T_CURLY_OPEN
+<STRING,HEREDOC,BACKQUOTE>\$\{              l.pushState(STRING_VAR_NAME);lval.token =  l.newToken(l.TokenBytes(nil)); return T_DOLLAR_OPEN_CURLY_BRACES
 <STRING,HEREDOC,BACKQUOTE>\$                l.ungetN(1);l.pushState(STRING_VAR)
 <STRING>.|[ \t\n\r]
     F1:for {
@@ -447,7 +446,7 @@ NEW_LINE        (\r|\n|\r\n)
 
         switch c {
             case '"' : 
-                lval.token = l.newToken();
+                lval.token =  l.newToken(l.TokenBytes(nil));
                 return T_ENCAPSED_AND_WHITESPACE
                 break F1;
             
@@ -456,7 +455,7 @@ NEW_LINE        (\r|\n|\r\n)
                 if rune(c) == '{' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z' || c >= '\u007f' && c <= 'ÿ' {
                     l.ungetN(1)
                     tb := l.TokenBytes(nil)
-                    lval.token = token.NewToken(l.handleNewLine(tb[:len(tb)-1]));
+                    lval.token = l.newToken(tb[:len(tb)-1]);
                     return T_ENCAPSED_AND_WHITESPACE
                     break F1;
                 } 
@@ -467,7 +466,7 @@ NEW_LINE        (\r|\n|\r\n)
                 if rune(c) == '$' {
                     l.ungetN(1)
                     tb := l.TokenBytes(nil)
-                    lval.token = token.NewToken(l.handleNewLine(tb[:len(tb)-1])); 
+                    lval.token = l.newToken(tb[:len(tb)-1]); 
                     return T_ENCAPSED_AND_WHITESPACE
                     break F1;
                 } 
@@ -488,7 +487,7 @@ NEW_LINE        (\r|\n|\r\n)
 
         switch c {
             case '`' :
-                lval.token = l.newToken(); 
+                lval.token =  l.newToken(l.TokenBytes(nil)); 
                 return T_ENCAPSED_AND_WHITESPACE
                 break F2;
             
@@ -497,7 +496,7 @@ NEW_LINE        (\r|\n|\r\n)
                 if rune(c) == '{' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z' || c >= '\u007f' && c <= 'ÿ' {
                     l.ungetN(1)
                     tb := l.TokenBytes(nil)
-                    lval.token = token.NewToken(l.handleNewLine(tb[:len(tb)-1])); 
+                    lval.token = l.newToken(tb[:len(tb)-1]); 
                     return T_ENCAPSED_AND_WHITESPACE
                     break F2;
                 } 
@@ -508,7 +507,7 @@ NEW_LINE        (\r|\n|\r\n)
                 if rune(c) == '$' {
                     l.ungetN(1)
                     tb := l.TokenBytes(nil)
-                    lval.token = token.NewToken(l.handleNewLine(tb[:len(tb)-1])); 
+                    lval.token = l.newToken(tb[:len(tb)-1]); 
                     return T_ENCAPSED_AND_WHITESPACE
                     break F2;
                 } 
@@ -570,24 +569,24 @@ NEW_LINE        (\r|\n|\r\n)
         c = l.Next()
     }
     
-    lval.token = token.NewToken(l.handleNewLine(tb)); 
+    lval.token = l.newToken(tb); 
     return T_ENCAPSED_AND_WHITESPACE
 
-<STRING_VAR>\${VAR_NAME}                    lval.token = l.newToken(); return T_VARIABLE
-<STRING_VAR>->{VAR_NAME}                    lval.token = token.NewToken(l.handleNewLine(l.ungetN(len(l.TokenBytes(nil))-2))); return T_OBJECT_OPERATOR
-<STRING_VAR>{VAR_NAME}                      l.popState();lval.token = l.newToken(); return T_STRING
-<STRING_VAR>\[                              l.pushState(STRING_VAR_INDEX);lval.token = l.newToken(); return rune2Class(rune(l.TokenBytes(nil)[0]))
+<STRING_VAR>\${VAR_NAME}                    lval.token =  l.newToken(l.TokenBytes(nil)); return T_VARIABLE
+<STRING_VAR>->{VAR_NAME}                    lval.token = l.newToken(l.ungetN(len(l.TokenBytes(nil))-2)); return T_OBJECT_OPERATOR
+<STRING_VAR>{VAR_NAME}                      l.popState();lval.token =  l.newToken(l.TokenBytes(nil)); return T_STRING
+<STRING_VAR>\[                              l.pushState(STRING_VAR_INDEX);lval.token =  l.newToken(l.TokenBytes(nil)); return rune2Class(rune(l.TokenBytes(nil)[0]))
 <STRING_VAR>.|[ \t\n\r]                     l.ungetN(1);l.popState()
 
-<STRING_VAR_INDEX>{LNUM}|{HNUM}|{BNUM}      lval.token = l.newToken(); return T_NUM_STRING
-<STRING_VAR_INDEX>\${VAR_NAME}              lval.token = l.newToken(); return T_VARIABLE
-<STRING_VAR_INDEX>{VAR_NAME}                lval.token = l.newToken(); return T_STRING
-<STRING_VAR_INDEX>\]                        l.popState(); l.popState();lval.token = l.newToken(); return rune2Class(rune(l.TokenBytes(nil)[0]))
-<STRING_VAR_INDEX>[ \n\r\t\\'#]             l.popState(); l.popState();lval.token = l.newToken(); return T_ENCAPSED_AND_WHITESPACE
-<STRING_VAR_INDEX>{OPERATORS}               lval.token = l.newToken(); return rune2Class(rune(l.TokenBytes(nil)[0]))
-<STRING_VAR_INDEX>.                         lval.token = l.newToken(); return rune2Class(rune(l.TokenBytes(nil)[0]))
+<STRING_VAR_INDEX>{LNUM}|{HNUM}|{BNUM}      lval.token =  l.newToken(l.TokenBytes(nil)); return T_NUM_STRING
+<STRING_VAR_INDEX>\${VAR_NAME}              lval.token =  l.newToken(l.TokenBytes(nil)); return T_VARIABLE
+<STRING_VAR_INDEX>{VAR_NAME}                lval.token =  l.newToken(l.TokenBytes(nil)); return T_STRING
+<STRING_VAR_INDEX>\]                        l.popState(); l.popState();lval.token =  l.newToken(l.TokenBytes(nil)); return rune2Class(rune(l.TokenBytes(nil)[0]))
+<STRING_VAR_INDEX>[ \n\r\t\\'#]             l.popState(); l.popState();lval.token =  l.newToken(l.TokenBytes(nil)); return T_ENCAPSED_AND_WHITESPACE
+<STRING_VAR_INDEX>{OPERATORS}               lval.token =  l.newToken(l.TokenBytes(nil)); return rune2Class(rune(l.TokenBytes(nil)[0]))
+<STRING_VAR_INDEX>.                         lval.token =  l.newToken(l.TokenBytes(nil)); return rune2Class(rune(l.TokenBytes(nil)[0]))
 
-<STRING_VAR_NAME>{VAR_NAME}[\[\}]           l.popState();l.pushState(PHP);lval.token = token.NewToken(l.handleNewLine(l.ungetN(1))); return T_STRING_VARNAME
+<STRING_VAR_NAME>{VAR_NAME}[\[\}]           l.popState();l.pushState(PHP);lval.token = l.newToken(l.ungetN(1)); return T_STRING_VARNAME
 <STRING_VAR_NAME>.                          l.ungetN(1);l.popState();l.pushState(PHP)
 
 %%