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

add node and token namespaces

Browse Source
This commit is contained in:
z7zmey
2017-12-03 20:49:18 +02:00
parent 71949dbcd2
commit 4da2844ea8
11 changed files with 1715 additions and 1684 deletions
Download Patch File Download Diff File Expand all files Collapse all files
example.php
+2 -3
View File
@@ -31,10 +31,9 @@ $a = 'string
with out $var'; with out $var';
$a = <<<test $a = <<<test
heredoc string
$var
test; test;
?> ?>
<?= $b; $b ?> <?= $b = 22; $b ?>
lexer.go
+2 -2
View File
@@ -2,7 +2,7 @@ package main
import ( import (
"bufio" "bufio"
gotoken "go/token" "go/token"
"io" "io"
"unicode" "unicode"
@@ -37,7 +37,7 @@ func rune2Class(r rune) int {
} }
func newLexer(src io.Reader, fName string) *lexer { func newLexer(src io.Reader, fName string) *lexer {
file := gotoken.NewFileSet().AddFile(fName, -1, 1<<31-1) file := token.NewFileSet().AddFile(fName, -1, 1<<31-1)
lx, err := lex.New(file, bufio.NewReader(src), lex.RuneClass(rune2Class)) lx, err := lex.New(file, bufio.NewReader(src), lex.RuneClass(rune2Class))
if err != nil { if err != nil {
panic(err) panic(err)
main.go
+2 -2
View File
@@ -21,8 +21,8 @@ func main() {
fmt.Printf("\n==> %s", real) fmt.Printf("\n==> %s", real)
src, _ := os.Open(string(real)) src, _ := os.Open(string(real))
rn := parse(src, real) rootnode := parse(src, real)
fmt.Println(rn) fmt.Println(rootnode)
} }
} }
node.go
-44
View File
@@ -1,44 +0,0 @@
package main
import (
"bytes"
"fmt"
"io"
)
type node struct {
name string
children []node
attributes map[string]string
}
func (n node) String() string {
buf := new(bytes.Buffer)
n.print(buf, " ")
return buf.String()
}
func (n node) print(out io.Writer, indent string) {
if len(n.attributes) > 0 {
fmt.Fprintf(out, "\n%v%v %s", indent, n.name, n.attributes)
} else {
fmt.Fprintf(out, "\n%v%v", indent, n.name)
}
for _, nn := range n.children {
nn.print(out, indent+" ")
}
}
func Node(name string) node {
return node{name: name, attributes: make(map[string]string)}
}
func (n node) append(nn ...node) node {
n.children = append(n.children, nn...)
return n
}
func (n node) attribute(key string, value string) node {
n.attributes[key] = value
return n
}
node/node.go
+70
View File
@@ -0,0 +1,70 @@
package node
import (
"bytes"
"fmt"
"github.com/z7zmey/php-parser/token"
"io"
)
type Node interface {
Print(out io.Writer, indent string)
Append(nn ...Node) Node
Attribute(key string, value string) Node
}
type simpleNode struct {
name string
children []Node
attributes map[string]string
}
type tokenNode struct {
*simpleNode
token token.Token
}
func (n simpleNode) String() string {
buf := new(bytes.Buffer)
n.Print(buf, " ")
return buf.String()
}
func (n simpleNode) Print(out io.Writer, indent string) {
if len(n.attributes) > 0 {
fmt.Fprintf(out, "\n%v%v %s", indent, n.name, n.attributes)
} else {
fmt.Fprintf(out, "\n%v%v", indent, n.name)
}
for _, nn := range n.children {
nn.Print(out, indent+" ")
}
}
func SimpleNode(name string) Node {
return simpleNode{name: name, attributes: make(map[string]string)}
}
func TokenNode(name string, t token.Token) Node {
return tokenNode{
&simpleNode{name: name, attributes: make(map[string]string)},
t,
}
}
func (n tokenNode) Print(out io.Writer, indent string) {
fmt.Fprintf(out, "\n%v%v [%d %d] %q", indent, n.name, n.token.StartLine, n.token.EndLine, n.token.Value)
for _, nn := range n.children {
nn.Print(out, indent+" ")
}
}
func (n simpleNode) Append(nn ...Node) Node {
n.children = append(n.children, nn...)
return n
}
func (n simpleNode) Attribute(key string, value string) Node {
n.attributes[key] = value
return n
}
parser.go
+906 -904
View File
File diff suppressed because it is too large Load Diff
parser.y
+376 -374
View File
File diff suppressed because it is too large Load Diff
scanner.go
+171 -170
View File
File diff suppressed because it is too large Load Diff
scanner.l
+171 -170
View File
@@ -10,6 +10,7 @@ package main
import ( import (
"fmt" "fmt"
"bytes" "bytes"
"github.com/z7zmey/php-parser/token"
) )
const ( const (
@@ -53,7 +54,7 @@ NEW_LINE (\r|\n|\r\n)
%% %%
c = l.Rule0() c = l.Rule0()
<INITIAL>[ \t\n\r]+ lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); <INITIAL>[ \t\n\r]+ lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil)));
<INITIAL>. <INITIAL>.
tb := []byte{} tb := []byte{}
@@ -77,17 +78,17 @@ NEW_LINE (\r|\n|\r\n)
c = l.Next() c = l.Next()
} }
lval.token = newToken(l.handleNewLine(tb)); lval.token = token.NewToken(l.handleNewLine(tb));
return T_INLINE_HTML return T_INLINE_HTML
<INITIAL>\<\?php([ \t]|{NEW_LINE}) l.begin(PHP);lval.token = newToken(l.handleNewLine(l.TokenBytes(nil)));// return T_OPEN_TAG; <INITIAL>\<\?php([ \t]|{NEW_LINE}) l.begin(PHP);lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil)));// return T_OPEN_TAG;
<INITIAL>\<\? l.begin(PHP);lval.token = newToken(l.handleNewLine(l.TokenBytes(nil)));// return T_OPEN_TAG; <INITIAL>\<\? l.begin(PHP);lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil)));// return T_OPEN_TAG;
<INITIAL>\<\?= l.begin(PHP);lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_ECHO; <INITIAL>\<\?= l.begin(PHP);lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_ECHO;
<PHP>[ \t\n\r]+ lval.token = newToken(l.handleNewLine(l.TokenBytes(nil)));// return T_WHITESPACE <PHP>[ \t\n\r]+ lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil)));// return T_WHITESPACE
<PHP>\?\>{NEW_LINE}? l.begin(INITIAL);lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return rune2Class(';'); <PHP>\?\>{NEW_LINE}? l.begin(INITIAL);lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return rune2Class(';');
<PHP>{DNUM}|{EXPONENT_DNUM} lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_DNUMBER <PHP>{DNUM}|{EXPONENT_DNUM} lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_DNUMBER
<PHP>{BNUM} <PHP>{BNUM}
tb := l.TokenBytes(nil) tb := l.TokenBytes(nil)
i:=2 i:=2
@@ -98,15 +99,15 @@ NEW_LINE (\r|\n|\r\n)
} }
} }
if len(tb) - i < 64 { if len(tb) - i < 64 {
lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_LNUMBER lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_LNUMBER
} else { } else {
lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_DNUMBER lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_DNUMBER
} }
<PHP>{LNUM} <PHP>{LNUM}
if len(l.TokenBytes(nil)) < 20 { if len(l.TokenBytes(nil)) < 20 {
lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_LNUMBER lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_LNUMBER
} else { } else {
lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_DNUMBER lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_DNUMBER
} }
<PHP>{HNUM} <PHP>{HNUM}
tb := l.TokenBytes(nil) tb := l.TokenBytes(nil)
@@ -119,145 +120,145 @@ NEW_LINE (\r|\n|\r\n)
} }
length := len(tb) - i length := len(tb) - i
if length < 16 || (length == 16 && tb[i] <= '7') { if length < 16 || (length == 16 && tb[i] <= '7') {
lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_LNUMBER lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_LNUMBER
} else { } else {
lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_DNUMBER lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_DNUMBER
} }
<PHP>abstract lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_ABSTRACT <PHP>abstract lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_ABSTRACT
<PHP>array lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_ARRAY <PHP>array lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_ARRAY
<PHP>as lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_AS <PHP>as lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_AS
<PHP>break lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_BREAK <PHP>break lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_BREAK
<PHP>callable lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_CALLABLE <PHP>callable lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_CALLABLE
<PHP>case lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_CASE <PHP>case lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_CASE
<PHP>catch lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_CATCH <PHP>catch lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_CATCH
<PHP>class lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_CLASS <PHP>class lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_CLASS
<PHP>clone lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_CLONE <PHP>clone lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_CLONE
<PHP>const lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_CONST; <PHP>const lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_CONST;
<PHP>continue lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_CONTINUE; <PHP>continue lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_CONTINUE;
<PHP>declare lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_DECLARE; <PHP>declare lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_DECLARE;
<PHP>default lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_DEFAULT; <PHP>default lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_DEFAULT;
<PHP>do lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_DO; <PHP>do lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_DO;
<PHP>echo lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_ECHO; <PHP>echo lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_ECHO;
<PHP>else lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_ELSE; <PHP>else lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_ELSE;
<PHP>elseif lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_ELSEIF; <PHP>elseif lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_ELSEIF;
<PHP>empty lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_EMPTY; <PHP>empty lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_EMPTY;
<PHP>enddeclare lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_ENDDECLARE <PHP>enddeclare lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_ENDDECLARE
<PHP>endfor lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_ENDFOR <PHP>endfor lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_ENDFOR
<PHP>endforeach lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_ENDFOREACH <PHP>endforeach lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_ENDFOREACH
<PHP>endif lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_ENDIF <PHP>endif lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_ENDIF
<PHP>endswitch lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_ENDSWITCH <PHP>endswitch lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_ENDSWITCH
<PHP>endwhile lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_ENDWHILE <PHP>endwhile lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_ENDWHILE
<PHP>eval lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_EVAL <PHP>eval lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_EVAL
<PHP>exit|die lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_EXIT <PHP>exit|die lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_EXIT
<PHP>extends lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_EXTENDS <PHP>extends lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_EXTENDS
<PHP>final lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_FINAL <PHP>final lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_FINAL
<PHP>finally lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_FINALLY <PHP>finally lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_FINALLY
<PHP>for lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_FOR <PHP>for lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_FOR
<PHP>foreach lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_FOREACH <PHP>foreach lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_FOREACH
<PHP>function|cfunction lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_FUNCTION <PHP>function|cfunction lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_FUNCTION
<PHP>global lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_GLOBAL <PHP>global lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_GLOBAL
<PHP>goto lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_GOTO <PHP>goto lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_GOTO
<PHP>if lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_IF <PHP>if lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_IF
<PHP>isset lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_ISSET <PHP>isset lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_ISSET
<PHP>implements lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_IMPLEMENTS <PHP>implements lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_IMPLEMENTS
<PHP>instanceof lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_INSTANCEOF <PHP>instanceof lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_INSTANCEOF
<PHP>insteadof lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_INSTEADOF <PHP>insteadof lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_INSTEADOF
<PHP>interface lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_INTERFACE <PHP>interface lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_INTERFACE
<PHP>list lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_LIST <PHP>list lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_LIST
<PHP>namespace lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_NAMESPACE <PHP>namespace lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_NAMESPACE
<PHP>private lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_PRIVATE <PHP>private lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_PRIVATE
<PHP>public lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_PUBLIC <PHP>public lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_PUBLIC
<PHP>print lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_PRINT <PHP>print lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_PRINT
<PHP>protected lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_PROTECTED <PHP>protected lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_PROTECTED
<PHP>return lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_RETURN <PHP>return lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_RETURN
<PHP>static lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_STATIC <PHP>static lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_STATIC
<PHP>switch lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_SWITCH <PHP>switch lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_SWITCH
<PHP>throw lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_THROW <PHP>throw lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_THROW
<PHP>trait lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_TRAIT <PHP>trait lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_TRAIT
<PHP>try lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_TRY <PHP>try lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_TRY
<PHP>unset lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_UNSET <PHP>unset lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_UNSET
<PHP>use lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_USE <PHP>use lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_USE
<PHP>var lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_VAR <PHP>var lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_VAR
<PHP>while lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_WHILE <PHP>while lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_WHILE
<PHP>yield[ \t\n\r]+from[^a-zA-Z0-9_\x80-\xff] lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_YIELD_FROM <PHP>yield[ \t\n\r]+from[^a-zA-Z0-9_\x80-\xff] lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_YIELD_FROM
<PHP>yield lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_YIELD <PHP>yield lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_YIELD
<PHP>include lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_INCLUDE <PHP>include lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_INCLUDE
<PHP>include_once lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_INCLUDE_ONCE <PHP>include_once lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_INCLUDE_ONCE
<PHP>require lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_REQUIRE <PHP>require lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_REQUIRE
<PHP>require_once lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_REQUIRE_ONCE <PHP>require_once lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_REQUIRE_ONCE
<PHP>__CLASS__ lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_CLASS_C <PHP>__CLASS__ lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_CLASS_C
<PHP>__DIR__ lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_DIR <PHP>__DIR__ lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_DIR
<PHP>__FILE__ lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_FILE <PHP>__FILE__ lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_FILE
<PHP>__FUNCTION__ lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_FUNC_C <PHP>__FUNCTION__ lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_FUNC_C
<PHP>__LINE__ lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_LINE <PHP>__LINE__ lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_LINE
<PHP>__NAMESPACE__ lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_NS_C <PHP>__NAMESPACE__ lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_NS_C
<PHP>__METHOD__ lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_METHOD_C <PHP>__METHOD__ lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_METHOD_C
<PHP>__TRAIT__ lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_TRAIT_C <PHP>__TRAIT__ lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_TRAIT_C
<PHP>__halt_compiler lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_HALT_COMPILER <PHP>__halt_compiler lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_HALT_COMPILER
<PHP>\([ \t]*array[ \t]*\) lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_ARRAY_CAST <PHP>\([ \t]*array[ \t]*\) lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_ARRAY_CAST
<PHP>\([ \t]*(bool|boolean)[ \t]*\) lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_BOOL_CAST <PHP>\([ \t]*(bool|boolean)[ \t]*\) lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_BOOL_CAST
<PHP>\([ \t]*(real|double|float)[ \t]*\) lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_DOUBLE_CAST <PHP>\([ \t]*(real|double|float)[ \t]*\) lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_DOUBLE_CAST
<PHP>\([ \t]*(int|integer)[ \t]*\) lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_INT_CAST <PHP>\([ \t]*(int|integer)[ \t]*\) lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_INT_CAST
<PHP>\([ \t]*object[ \t]*\) lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_OBJECT_CAST <PHP>\([ \t]*object[ \t]*\) lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_OBJECT_CAST
<PHP>\([ \t]*string[ \t]*\) lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_STRING_CAST <PHP>\([ \t]*string[ \t]*\) lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_STRING_CAST
<PHP>\([ \t]*unset[ \t]*\) lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_UNSET_CAST <PHP>\([ \t]*unset[ \t]*\) lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_UNSET_CAST
<PHP>new lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_NEW <PHP>new lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_NEW
<PHP>and lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_LOGICAL_AND <PHP>and lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_LOGICAL_AND
<PHP>or lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_LOGICAL_OR <PHP>or lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_LOGICAL_OR
<PHP>xor lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_LOGICAL_XOR <PHP>xor lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_LOGICAL_XOR
<PHP>\\ lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_NS_SEPARATOR <PHP>\\ lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_NS_SEPARATOR
<PHP>\.\.\. lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_ELLIPSIS; <PHP>\.\.\. lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_ELLIPSIS;
<PHP>:: lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_PAAMAYIM_NEKUDOTAYIM; // T_DOUBLE_COLON <PHP>:: lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_PAAMAYIM_NEKUDOTAYIM; // T_DOUBLE_COLON
<PHP>&& lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_BOOLEAN_AND <PHP>&& lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_BOOLEAN_AND
<PHP>\|\| lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_BOOLEAN_OR <PHP>\|\| lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_BOOLEAN_OR
<PHP>&= lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_AND_EQUAL <PHP>&= lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_AND_EQUAL
<PHP>\|= lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_OR_EQUAL <PHP>\|= lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_OR_EQUAL
<PHP>\.= lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_CONCAT_EQUAL; <PHP>\.= lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_CONCAT_EQUAL;
<PHP>\*= lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_MUL_EQUAL <PHP>\*= lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_MUL_EQUAL
<PHP>\*\*= lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_POW_EQUAL <PHP>\*\*= lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_POW_EQUAL
<PHP>[/]= lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_DIV_EQUAL; <PHP>[/]= lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_DIV_EQUAL;
<PHP>\+= lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_PLUS_EQUAL <PHP>\+= lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_PLUS_EQUAL
<PHP>-= lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_MINUS_EQUAL <PHP>-= lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_MINUS_EQUAL
<PHP>\^= lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_XOR_EQUAL <PHP>\^= lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_XOR_EQUAL
<PHP>%= lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_MOD_EQUAL <PHP>%= lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_MOD_EQUAL
<PHP>-- lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_DEC; <PHP>-- lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_DEC;
<PHP>\+\+ lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_INC <PHP>\+\+ lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_INC
<PHP>=> lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_DOUBLE_ARROW; <PHP>=> lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_DOUBLE_ARROW;
<PHP>\<=\> lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_SPACESHIP <PHP>\<=\> lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_SPACESHIP
<PHP>\!=|\<\> lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_IS_NOT_EQUAL <PHP>\!=|\<\> lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_IS_NOT_EQUAL
<PHP>\!== lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_IS_NOT_IDENTICAL <PHP>\!== lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_IS_NOT_IDENTICAL
<PHP>== lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_IS_EQUAL <PHP>== lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_IS_EQUAL
<PHP>=== lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_IS_IDENTICAL <PHP>=== lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_IS_IDENTICAL
<PHP>\<\<= lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_SL_EQUAL <PHP>\<\<= lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_SL_EQUAL
<PHP>\>\>= lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_SR_EQUAL <PHP>\>\>= lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_SR_EQUAL
<PHP>\>= lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_IS_GREATER_OR_EQUAL <PHP>\>= lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_IS_GREATER_OR_EQUAL
<PHP>\<= lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_IS_SMALLER_OR_EQUAL <PHP>\<= lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_IS_SMALLER_OR_EQUAL
<PHP>\*\* lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_POW <PHP>\*\* lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_POW
<PHP>\<\< lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_SL <PHP>\<\< lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_SL
<PHP>\>\> lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_SR <PHP>\>\> lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_SR
<PHP>\?\? lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_COALESCE <PHP>\?\? lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_COALESCE
<PHP>(#|[/][/]).*{NEW_LINE} lval.token = newToken(l.handleNewLine(l.TokenBytes(nil)));// return T_COMMENT; // TODO: handle ?> <PHP>(#|[/][/]).*{NEW_LINE} lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil)));// return T_COMMENT; // TODO: handle ?>
<PHP>[/][*][^*]*[*]+([^*/][^*]*[*]+)*[/] lval.token = newToken(l.handleNewLine(l.TokenBytes(nil)));// return T_COMMENT; // TODO: handle ?> <PHP>[/][*][^*]*[*]+([^*/][^*]*[*]+)*[/] lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil)));// return T_COMMENT; // TODO: handle ?>
<PHP>[/][*][*][^*]*[*]+([^*/][^*]*[*]+)*[/] lval.token = newToken(l.handleNewLine(l.TokenBytes(nil)));// return T_DOC_COMMENT; // TODO: handle ?> <PHP>[/][*][*][^*]*[*]+([^*/][^*]*[*]+)*[/] lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil)));// return T_DOC_COMMENT; // TODO: handle ?>
<PHP>'[^']*(\\')*' lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_CONSTANT_ENCAPSED_STRING <PHP>'[^']*(\\')*' lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_CONSTANT_ENCAPSED_STRING
<PHP>{OPERATORS} lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return rune2Class(rune(l.TokenBytes(nil)[0])) <PHP>{OPERATORS} lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return rune2Class(rune(l.TokenBytes(nil)[0]))
<PHP>\{ l.pushState(PHP); lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return rune2Class(rune(l.TokenBytes(nil)[0])) <PHP>\{ l.pushState(PHP); lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return rune2Class(rune(l.TokenBytes(nil)[0]))
<PHP>\} l.popState(); lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return rune2Class(rune(l.TokenBytes(nil)[0])) <PHP>\} l.popState(); lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return rune2Class(rune(l.TokenBytes(nil)[0]))
<PHP>\${VAR_NAME} lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_VARIABLE <PHP>\${VAR_NAME} lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_VARIABLE
<PHP>{VAR_NAME} lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_STRING <PHP>{VAR_NAME} lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_STRING
<PHP>-> l.begin(PROPERTY);lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_OBJECT_OPERATOR; <PHP>-> l.begin(PROPERTY);lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_OBJECT_OPERATOR;
<PROPERTY>[ \t\n\r]+ lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_WHITESPACE; <PROPERTY>[ \t\n\r]+ lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_WHITESPACE;
<PROPERTY>-> lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_OBJECT_OPERATOR; <PROPERTY>-> lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_OBJECT_OPERATOR;
<PROPERTY>{VAR_NAME} l.begin(PHP);lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_STRING; <PROPERTY>{VAR_NAME} l.begin(PHP);lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_STRING;
<PROPERTY>. l.ungetN(1);l.begin(PHP) <PROPERTY>. l.ungetN(1);l.begin(PHP)
<PHP>[\']([^\\\']*([\\][\'])*)*[\'] lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_CONSTANT_ENCAPSED_STRING; <PHP>[\']([^\\\']*([\\][\'])*)*[\'] lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_CONSTANT_ENCAPSED_STRING;
<PHP>` l.begin(BACKQUOTE); lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); rune2Class(rune(l.TokenBytes(nil)[0])) <PHP>` l.begin(BACKQUOTE); lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); rune2Class(rune(l.TokenBytes(nil)[0]))
<BACKQUOTE>` l.begin(PHP); lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); rune2Class(rune(l.TokenBytes(nil)[0])) <BACKQUOTE>` l.begin(PHP); lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); rune2Class(rune(l.TokenBytes(nil)[0]))
<PHP>[b]?\<\<\<[ \t]*({VAR_NAME}|([']{VAR_NAME}['])|(["]{VAR_NAME}["])){NEW_LINE} <PHP>[b]?\<\<\<[ \t]*({VAR_NAME}|([']{VAR_NAME}['])|(["]{VAR_NAME}["])){NEW_LINE}
tb := l.TokenBytes(nil) tb := l.TokenBytes(nil)
@@ -317,7 +318,7 @@ NEW_LINE (\r|\n|\r\n)
l.ungetN(ungetCnt) l.ungetN(ungetCnt)
lval.token = newToken(l.handleNewLine(tb)); lval.token = token.NewToken(l.handleNewLine(tb));
return T_START_HEREDOC return T_START_HEREDOC
<NOWDOC>. <NOWDOC>.
@@ -344,10 +345,10 @@ NEW_LINE (\r|\n|\r\n)
c = l.Next() c = l.Next()
} }
lval.token = newToken(l.handleNewLine(tb)); lval.token = token.NewToken(l.handleNewLine(tb));
return T_ENCAPSED_AND_WHITESPACE return T_ENCAPSED_AND_WHITESPACE
<HEREDOC_END>{VAR_NAME}\; l.begin(PHP);lval.token = newToken(l.handleNewLine(l.ungetN(1))); return T_END_HEREDOC <HEREDOC_END>{VAR_NAME}\; l.begin(PHP);lval.token = token.NewToken(l.handleNewLine(l.ungetN(1))); return T_END_HEREDOC
<PHP>[b]?[\"] <PHP>[b]?[\"]
binPrefix := l.TokenBytes(nil)[0] == 'b' binPrefix := l.TokenBytes(nil)[0] == 'b'
@@ -359,7 +360,7 @@ NEW_LINE (\r|\n|\r\n)
tokenBytes := l.TokenBytes(nil)[:cnt] tokenBytes := l.TokenBytes(nil)[:cnt]
l.pushState(STRING) l.pushState(STRING)
lval.token = newToken(l.handleNewLine(tokenBytes)); return rune2Class('"') lval.token = token.NewToken(l.handleNewLine(tokenBytes)); return rune2Class('"')
} }
F:for { F:for {
@@ -370,7 +371,7 @@ NEW_LINE (\r|\n|\r\n)
switch c { switch c {
case '"' : case '"' :
c = l.Next(); c = l.Next();
lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_CONSTANT_ENCAPSED_STRING lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_CONSTANT_ENCAPSED_STRING
break F; break F;
case '$': case '$':
@@ -396,9 +397,9 @@ NEW_LINE (\r|\n|\r\n)
c = l.Next() c = l.Next()
} }
<STRING>\" l.popState(); lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return rune2Class(rune(l.TokenBytes(nil)[0])) <STRING>\" l.popState(); lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return rune2Class(rune(l.TokenBytes(nil)[0]))
<STRING,HEREDOC,BACKQUOTE>\{\$ lval.token = newToken(l.handleNewLine(l.ungetN(1))); l.pushState(PHP); return T_CURLY_OPEN <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 = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_DOLLAR_OPEN_CURLY_BRACES <STRING,HEREDOC,BACKQUOTE>\$\{ l.pushState(STRING_VAR_NAME);lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_DOLLAR_OPEN_CURLY_BRACES
<STRING,HEREDOC,BACKQUOTE>\$ l.ungetN(1);l.pushState(STRING_VAR) <STRING,HEREDOC,BACKQUOTE>\$ l.ungetN(1);l.pushState(STRING_VAR)
<STRING>.|[ \t\n\r] <STRING>.|[ \t\n\r]
F1:for { F1:for {
@@ -408,7 +409,7 @@ NEW_LINE (\r|\n|\r\n)
switch c { switch c {
case '"' : case '"' :
lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil)));
return T_ENCAPSED_AND_WHITESPACE return T_ENCAPSED_AND_WHITESPACE
break F1; break F1;
@@ -417,7 +418,7 @@ NEW_LINE (\r|\n|\r\n)
if rune(c) == '{' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z' || c >= '\u007f' && c <= 'ÿ' { if rune(c) == '{' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z' || c >= '\u007f' && c <= 'ÿ' {
l.ungetN(1) l.ungetN(1)
tb := l.TokenBytes(nil) tb := l.TokenBytes(nil)
lval.token = newToken(l.handleNewLine(tb[:len(tb)-1])); lval.token = token.NewToken(l.handleNewLine(tb[:len(tb)-1]));
return T_ENCAPSED_AND_WHITESPACE return T_ENCAPSED_AND_WHITESPACE
break F1; break F1;
} }
@@ -428,7 +429,7 @@ NEW_LINE (\r|\n|\r\n)
if rune(c) == '$' { if rune(c) == '$' {
l.ungetN(1) l.ungetN(1)
tb := l.TokenBytes(nil) tb := l.TokenBytes(nil)
lval.token = newToken(l.handleNewLine(tb[:len(tb)-1])); lval.token = token.NewToken(l.handleNewLine(tb[:len(tb)-1]));
return T_ENCAPSED_AND_WHITESPACE return T_ENCAPSED_AND_WHITESPACE
break F1; break F1;
} }
@@ -449,7 +450,7 @@ NEW_LINE (\r|\n|\r\n)
switch c { switch c {
case '`' : case '`' :
lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil)));
return T_ENCAPSED_AND_WHITESPACE return T_ENCAPSED_AND_WHITESPACE
break F2; break F2;
@@ -458,7 +459,7 @@ NEW_LINE (\r|\n|\r\n)
if rune(c) == '{' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z' || c >= '\u007f' && c <= 'ÿ' { if rune(c) == '{' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z' || c >= '\u007f' && c <= 'ÿ' {
l.ungetN(1) l.ungetN(1)
tb := l.TokenBytes(nil) tb := l.TokenBytes(nil)
lval.token = newToken(l.handleNewLine(tb[:len(tb)-1])); lval.token = token.NewToken(l.handleNewLine(tb[:len(tb)-1]));
return T_ENCAPSED_AND_WHITESPACE return T_ENCAPSED_AND_WHITESPACE
break F2; break F2;
} }
@@ -469,7 +470,7 @@ NEW_LINE (\r|\n|\r\n)
if rune(c) == '$' { if rune(c) == '$' {
l.ungetN(1) l.ungetN(1)
tb := l.TokenBytes(nil) tb := l.TokenBytes(nil)
lval.token = newToken(l.handleNewLine(tb[:len(tb)-1])); lval.token = token.NewToken(l.handleNewLine(tb[:len(tb)-1]));
return T_ENCAPSED_AND_WHITESPACE return T_ENCAPSED_AND_WHITESPACE
break F2; break F2;
} }
@@ -531,24 +532,24 @@ NEW_LINE (\r|\n|\r\n)
c = l.Next() c = l.Next()
} }
lval.token = newToken(l.handleNewLine(tb)); lval.token = token.NewToken(l.handleNewLine(tb));
return T_ENCAPSED_AND_WHITESPACE return T_ENCAPSED_AND_WHITESPACE
<STRING_VAR>\${VAR_NAME} lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_VARIABLE <STRING_VAR>\${VAR_NAME} lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_VARIABLE
<STRING_VAR>->{VAR_NAME} lval.token = newToken(l.handleNewLine(l.ungetN(len(l.TokenBytes(nil))-2))); return T_OBJECT_OPERATOR <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 = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_STRING <STRING_VAR>{VAR_NAME} l.popState();lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_STRING
<STRING_VAR>\[ l.pushState(STRING_VAR_INDEX);lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return rune2Class(rune(l.TokenBytes(nil)[0])) <STRING_VAR>\[ l.pushState(STRING_VAR_INDEX);lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return rune2Class(rune(l.TokenBytes(nil)[0]))
<STRING_VAR>.|[ \t\n\r] l.ungetN(1);l.popState() <STRING_VAR>.|[ \t\n\r] l.ungetN(1);l.popState()
<STRING_VAR_INDEX>{LNUM}|{HNUM}|{BNUM} lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_NUM_STRING <STRING_VAR_INDEX>{LNUM}|{HNUM}|{BNUM} lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_NUM_STRING
<STRING_VAR_INDEX>\${VAR_NAME} lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_VARIABLE <STRING_VAR_INDEX>\${VAR_NAME} lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_VARIABLE
<STRING_VAR_INDEX>{VAR_NAME} lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_STRING <STRING_VAR_INDEX>{VAR_NAME} lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_STRING
<STRING_VAR_INDEX>\] l.popState(); l.popState();lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return rune2Class(rune(l.TokenBytes(nil)[0])) <STRING_VAR_INDEX>\] l.popState(); l.popState();lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return rune2Class(rune(l.TokenBytes(nil)[0]))
<STRING_VAR_INDEX>[ \n\r\t\\'#] l.popState(); l.popState();lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return T_ENCAPSED_AND_WHITESPACE <STRING_VAR_INDEX>[ \n\r\t\\'#] l.popState(); l.popState();lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return T_ENCAPSED_AND_WHITESPACE
<STRING_VAR_INDEX>{OPERATORS} lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return rune2Class(rune(l.TokenBytes(nil)[0])) <STRING_VAR_INDEX>{OPERATORS} lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return rune2Class(rune(l.TokenBytes(nil)[0]))
<STRING_VAR_INDEX>. lval.token = newToken(l.handleNewLine(l.TokenBytes(nil))); return rune2Class(rune(l.TokenBytes(nil)[0])) <STRING_VAR_INDEX>. lval.token = token.NewToken(l.handleNewLine(l.TokenBytes(nil))); return rune2Class(rune(l.TokenBytes(nil)[0]))
<STRING_VAR_NAME>{VAR_NAME}[\[\}] l.popState();l.pushState(PHP);lval.token = newToken(l.handleNewLine(l.ungetN(1))); return T_STRING_VARNAME <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>. l.ungetN(1);l.popState();l.pushState(PHP) <STRING_VAR_NAME>. l.ungetN(1);l.popState();l.pushState(PHP)
%% %%
token.go
-15
View File
@@ -1,15 +0,0 @@
package main
type token struct {
value []byte
startLine int
endLine int
}
func newToken(value []byte, startLine int, endLine int) token {
return token{value, startLine, endLine}
}
func (t token) String() string {
return string(t.value)
}
token/token.go
+15
View File
@@ -0,0 +1,15 @@
package token
type Token struct {
Value string
StartLine int
EndLine int
}
func NewToken(value []byte, startLine int, endLine int) Token {
return Token{string(value), startLine, endLine}
}
func (t Token) String() string {
return string(t.Value)
}