692 lines
30 KiB
Plaintext
692 lines
30 KiB
Plaintext
%{
|
|
// Copyright (c) 2011 CZ.NIC z.s.p.o. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// blame: jnml, labs.nic.cz
|
|
|
|
package scanner
|
|
|
|
import (
|
|
"fmt"
|
|
"github.com/z7zmey/php-parser/meta"
|
|
"github.com/cznic/golex/lex"
|
|
)
|
|
|
|
const (
|
|
INITIAL = iota
|
|
PHP
|
|
STRING
|
|
STRING_VAR
|
|
STRING_VAR_INDEX
|
|
STRING_VAR_NAME
|
|
PROPERTY
|
|
HEREDOC_END
|
|
NOWDOC
|
|
HEREDOC
|
|
BACKQUOTE
|
|
HALT_COMPILER
|
|
)
|
|
|
|
func isValidFirstVarNameRune(r rune) bool {
|
|
return r >= 'A' && r <= 'Z' || r == '_' || r >= 'a' && r <= 'z' || r >= '\u007f' && r <= 'ÿ'
|
|
}
|
|
|
|
func (l *Lexer) Lex(lval Lval) int {
|
|
l.Meta = nil
|
|
c := l.Enter()
|
|
|
|
%}
|
|
|
|
%s PHP STRING STRING_VAR STRING_VAR_INDEX STRING_VAR_NAME PROPERTY HEREDOC_END NOWDOC HEREDOC BACKQUOTE HALT_COMPILER
|
|
|
|
%yyb last == '\n' || last = '\0'
|
|
%yyt l.getCurrentState()
|
|
%yyc c
|
|
%yyn c = l.Next()
|
|
%yym l.Mark()
|
|
%optioncase-insensitive
|
|
|
|
LNUM [0-9]+
|
|
DNUM ([0-9]*"."[0-9]+)|([0-9]+"."[0-9]*)
|
|
HNUM 0x[0-9a-fA-F]+
|
|
BNUM 0b[01]+
|
|
EXPONENT_DNUM (({LNUM}|{DNUM})[eE][+-]?{LNUM})
|
|
VAR_NAME [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*
|
|
OPERATORS [;:,.\[\]()|\/\^&\+-*=%!~$<>?@]
|
|
NEW_LINE (\r|\n|\r\n)
|
|
ANY_CHAR .
|
|
|
|
%%
|
|
c = l.Rule0()
|
|
|
|
<INITIAL>[ \t\n\r]+ l.addMeta(meta.WhiteSpaceType, l.Token())
|
|
<INITIAL>.
|
|
tb := []lex.Char{}
|
|
|
|
for {
|
|
if c == -1 {
|
|
tb = l.Token();
|
|
break;
|
|
}
|
|
|
|
if '?' == rune(c) {
|
|
tb = l.Token();
|
|
if (len(tb) < 2 || tb[len(tb)-1].Rune != '<') {
|
|
c = l.Next()
|
|
continue;
|
|
}
|
|
|
|
tb = l.ungetChars(1)
|
|
break;
|
|
}
|
|
|
|
c = l.Next()
|
|
}
|
|
|
|
lval.Token(l.createToken(tb))
|
|
return int(T_INLINE_HTML)
|
|
|
|
<INITIAL>\<\?php([ \t]|{NEW_LINE}) l.addMeta(meta.TokenType, l.Token()[:5]);l.Begin(PHP);l.ungetChars(len(l.Token())-5)
|
|
<INITIAL>\<\? l.addMeta(meta.TokenType, l.Token());l.Begin(PHP);
|
|
<INITIAL>\<\?= l.Begin(PHP);lval.Token(l.createToken(l.Token())); return int(T_ECHO);
|
|
|
|
|
|
<PHP>[ \t\n\r]+ l.addMeta(meta.WhiteSpaceType, l.Token())
|
|
<PHP>[;][ \t\n\r]*\?\>{NEW_LINE}? l.Begin(INITIAL);lval.Token(l.createToken(l.Token())); return Rune2Class(';');
|
|
<PHP>\?\>{NEW_LINE}? l.Begin(INITIAL);lval.Token(l.createToken(l.Token())); return Rune2Class(';');
|
|
|
|
<PHP>{DNUM}|{EXPONENT_DNUM} lval.Token(l.createToken(l.Token())); return int(T_DNUMBER)
|
|
<PHP>{BNUM}
|
|
tb := l.Token()
|
|
i:=2
|
|
BNUMFOR:for {
|
|
if i > len(tb)-1 {
|
|
break BNUMFOR;
|
|
}
|
|
switch tb[i].Rune {
|
|
case '0': i++;
|
|
default: break BNUMFOR;
|
|
}
|
|
}
|
|
if len(tb) - i < 64 {
|
|
lval.Token(l.createToken(l.Token())); return int(T_LNUMBER)
|
|
} else {
|
|
lval.Token(l.createToken(l.Token())); return int(T_DNUMBER)
|
|
}
|
|
<PHP>{LNUM}
|
|
if len(l.Token()) < 20 {
|
|
lval.Token(l.createToken(l.Token())); return int(T_LNUMBER)
|
|
} else {
|
|
lval.Token(l.createToken(l.Token())); return int(T_DNUMBER)
|
|
}
|
|
<PHP>{HNUM}
|
|
tb := l.Token()
|
|
i:=2
|
|
HNUMFOR:for {
|
|
if i > len(tb)-1 {
|
|
break HNUMFOR;
|
|
}
|
|
switch tb[i].Rune {
|
|
case '0': i++;
|
|
default: break HNUMFOR;
|
|
}
|
|
}
|
|
length := len(tb) - i
|
|
if length < 16 || (length == 16 && tb[i].Rune <= '7') {
|
|
lval.Token(l.createToken(l.Token())); return int(T_LNUMBER)
|
|
} else {
|
|
lval.Token(l.createToken(l.Token())); return int(T_DNUMBER)
|
|
}
|
|
|
|
<PHP>abstract lval.Token(l.createToken(l.Token())); return int(T_ABSTRACT)
|
|
<PHP>array lval.Token(l.createToken(l.Token())); return int(T_ARRAY)
|
|
<PHP>as lval.Token(l.createToken(l.Token())); return int(T_AS)
|
|
<PHP>break lval.Token(l.createToken(l.Token())); return int(T_BREAK)
|
|
<PHP>callable lval.Token(l.createToken(l.Token())); return int(T_CALLABLE)
|
|
<PHP>case lval.Token(l.createToken(l.Token())); return int(T_CASE)
|
|
<PHP>catch lval.Token(l.createToken(l.Token())); return int(T_CATCH)
|
|
<PHP>class lval.Token(l.createToken(l.Token())); return int(T_CLASS)
|
|
<PHP>clone lval.Token(l.createToken(l.Token())); return int(T_CLONE)
|
|
<PHP>const lval.Token(l.createToken(l.Token())); return int(T_CONST)
|
|
<PHP>continue lval.Token(l.createToken(l.Token())); return int(T_CONTINUE)
|
|
<PHP>declare lval.Token(l.createToken(l.Token())); return int(T_DECLARE)
|
|
<PHP>default lval.Token(l.createToken(l.Token())); return int(T_DEFAULT)
|
|
<PHP>do lval.Token(l.createToken(l.Token())); return int(T_DO)
|
|
<PHP>echo lval.Token(l.createToken(l.Token())); return int(T_ECHO)
|
|
<PHP>else lval.Token(l.createToken(l.Token())); return int(T_ELSE)
|
|
<PHP>elseif lval.Token(l.createToken(l.Token())); return int(T_ELSEIF)
|
|
<PHP>empty lval.Token(l.createToken(l.Token())); return int(T_EMPTY)
|
|
<PHP>enddeclare lval.Token(l.createToken(l.Token())); return int(T_ENDDECLARE)
|
|
<PHP>endfor lval.Token(l.createToken(l.Token())); return int(T_ENDFOR)
|
|
<PHP>endforeach lval.Token(l.createToken(l.Token())); return int(T_ENDFOREACH)
|
|
<PHP>endif lval.Token(l.createToken(l.Token())); return int(T_ENDIF)
|
|
<PHP>endswitch lval.Token(l.createToken(l.Token())); return int(T_ENDSWITCH)
|
|
<PHP>endwhile lval.Token(l.createToken(l.Token())); return int(T_ENDWHILE)
|
|
<PHP>eval lval.Token(l.createToken(l.Token())); return int(T_EVAL)
|
|
<PHP>exit|die lval.Token(l.createToken(l.Token())); return int(T_EXIT)
|
|
<PHP>extends lval.Token(l.createToken(l.Token())); return int(T_EXTENDS)
|
|
<PHP>final lval.Token(l.createToken(l.Token())); return int(T_FINAL)
|
|
<PHP>finally lval.Token(l.createToken(l.Token())); return int(T_FINALLY)
|
|
<PHP>for lval.Token(l.createToken(l.Token())); return int(T_FOR)
|
|
<PHP>foreach lval.Token(l.createToken(l.Token())); return int(T_FOREACH)
|
|
<PHP>function|cfunction lval.Token(l.createToken(l.Token())); return int(T_FUNCTION)
|
|
<PHP>global lval.Token(l.createToken(l.Token())); return int(T_GLOBAL)
|
|
<PHP>goto lval.Token(l.createToken(l.Token())); return int(T_GOTO)
|
|
<PHP>if lval.Token(l.createToken(l.Token())); return int(T_IF)
|
|
<PHP>isset lval.Token(l.createToken(l.Token())); return int(T_ISSET)
|
|
<PHP>implements lval.Token(l.createToken(l.Token())); return int(T_IMPLEMENTS)
|
|
<PHP>instanceof lval.Token(l.createToken(l.Token())); return int(T_INSTANCEOF)
|
|
<PHP>insteadof lval.Token(l.createToken(l.Token())); return int(T_INSTEADOF)
|
|
<PHP>interface lval.Token(l.createToken(l.Token())); return int(T_INTERFACE)
|
|
<PHP>list lval.Token(l.createToken(l.Token())); return int(T_LIST)
|
|
<PHP>namespace lval.Token(l.createToken(l.Token())); return int(T_NAMESPACE)
|
|
<PHP>private lval.Token(l.createToken(l.Token())); return int(T_PRIVATE)
|
|
<PHP>public lval.Token(l.createToken(l.Token())); return int(T_PUBLIC)
|
|
<PHP>print lval.Token(l.createToken(l.Token())); return int(T_PRINT)
|
|
<PHP>protected lval.Token(l.createToken(l.Token())); return int(T_PROTECTED)
|
|
<PHP>return lval.Token(l.createToken(l.Token())); return int(T_RETURN)
|
|
<PHP>static lval.Token(l.createToken(l.Token())); return int(T_STATIC)
|
|
<PHP>switch lval.Token(l.createToken(l.Token())); return int(T_SWITCH)
|
|
<PHP>throw lval.Token(l.createToken(l.Token())); return int(T_THROW)
|
|
<PHP>trait lval.Token(l.createToken(l.Token())); return int(T_TRAIT)
|
|
<PHP>try lval.Token(l.createToken(l.Token())); return int(T_TRY)
|
|
<PHP>unset lval.Token(l.createToken(l.Token())); return int(T_UNSET)
|
|
<PHP>use lval.Token(l.createToken(l.Token())); return int(T_USE)
|
|
<PHP>var lval.Token(l.createToken(l.Token())); return int(T_VAR)
|
|
<PHP>while lval.Token(l.createToken(l.Token())); return int(T_WHILE)
|
|
<PHP>yield[ \t\n\r]+from lval.Token(l.createToken(l.Token())); return int(T_YIELD_FROM)
|
|
<PHP>yield lval.Token(l.createToken(l.Token())); return int(T_YIELD)
|
|
<PHP>include lval.Token(l.createToken(l.Token())); return int(T_INCLUDE)
|
|
<PHP>include_once lval.Token(l.createToken(l.Token())); return int(T_INCLUDE_ONCE)
|
|
<PHP>require lval.Token(l.createToken(l.Token())); return int(T_REQUIRE)
|
|
<PHP>require_once lval.Token(l.createToken(l.Token())); return int(T_REQUIRE_ONCE)
|
|
<PHP>__CLASS__ lval.Token(l.createToken(l.Token())); return int(T_CLASS_C)
|
|
<PHP>__DIR__ lval.Token(l.createToken(l.Token())); return int(T_DIR)
|
|
<PHP>__FILE__ lval.Token(l.createToken(l.Token())); return int(T_FILE)
|
|
<PHP>__FUNCTION__ lval.Token(l.createToken(l.Token())); return int(T_FUNC_C)
|
|
<PHP>__LINE__ lval.Token(l.createToken(l.Token())); return int(T_LINE)
|
|
<PHP>__NAMESPACE__ lval.Token(l.createToken(l.Token())); return int(T_NS_C)
|
|
<PHP>__METHOD__ lval.Token(l.createToken(l.Token())); return int(T_METHOD_C)
|
|
<PHP>__TRAIT__ lval.Token(l.createToken(l.Token())); return int(T_TRAIT_C)
|
|
<PHP>__halt_compiler lval.Token(l.createToken(l.Token())); return int(T_HALT_COMPILER)
|
|
<PHP>\([ \t]*array[ \t]*\) lval.Token(l.createToken(l.Token())); return int(T_ARRAY_CAST)
|
|
<PHP>\([ \t]*(bool|boolean)[ \t]*\) lval.Token(l.createToken(l.Token())); return int(T_BOOL_CAST)
|
|
<PHP>\([ \t]*(real|double|float)[ \t]*\) lval.Token(l.createToken(l.Token())); return int(T_DOUBLE_CAST)
|
|
<PHP>\([ \t]*(int|integer)[ \t]*\) lval.Token(l.createToken(l.Token())); return int(T_INT_CAST)
|
|
<PHP>\([ \t]*object[ \t]*\) lval.Token(l.createToken(l.Token())); return int(T_OBJECT_CAST)
|
|
<PHP>\([ \t]*(string|binary)[ \t]*\) lval.Token(l.createToken(l.Token())); return int(T_STRING_CAST)
|
|
<PHP>\([ \t]*unset[ \t]*\) lval.Token(l.createToken(l.Token())); return int(T_UNSET_CAST)
|
|
<PHP>new lval.Token(l.createToken(l.Token())); return int(T_NEW)
|
|
<PHP>and lval.Token(l.createToken(l.Token())); return int(T_LOGICAL_AND)
|
|
<PHP>or lval.Token(l.createToken(l.Token())); return int(T_LOGICAL_OR)
|
|
<PHP>xor lval.Token(l.createToken(l.Token())); return int(T_LOGICAL_XOR)
|
|
<PHP>\\ lval.Token(l.createToken(l.Token())); return int(T_NS_SEPARATOR)
|
|
<PHP>\.\.\. lval.Token(l.createToken(l.Token())); return int(T_ELLIPSIS)
|
|
<PHP>:: lval.Token(l.createToken(l.Token())); return int(T_PAAMAYIM_NEKUDOTAYIM) // T_DOUBLE_COLON
|
|
<PHP>&& lval.Token(l.createToken(l.Token())); return int(T_BOOLEAN_AND)
|
|
<PHP>\|\| lval.Token(l.createToken(l.Token())); return int(T_BOOLEAN_OR)
|
|
<PHP>&= lval.Token(l.createToken(l.Token())); return int(T_AND_EQUAL)
|
|
<PHP>\|= lval.Token(l.createToken(l.Token())); return int(T_OR_EQUAL)
|
|
<PHP>\.= lval.Token(l.createToken(l.Token())); return int(T_CONCAT_EQUAL)
|
|
<PHP>\*= lval.Token(l.createToken(l.Token())); return int(T_MUL_EQUAL)
|
|
<PHP>\*\*= lval.Token(l.createToken(l.Token())); return int(T_POW_EQUAL)
|
|
<PHP>[/]= lval.Token(l.createToken(l.Token())); return int(T_DIV_EQUAL)
|
|
<PHP>\+= lval.Token(l.createToken(l.Token())); return int(T_PLUS_EQUAL)
|
|
<PHP>-= lval.Token(l.createToken(l.Token())); return int(T_MINUS_EQUAL)
|
|
<PHP>\^= lval.Token(l.createToken(l.Token())); return int(T_XOR_EQUAL)
|
|
<PHP>%= lval.Token(l.createToken(l.Token())); return int(T_MOD_EQUAL)
|
|
<PHP>-- lval.Token(l.createToken(l.Token())); return int(T_DEC)
|
|
<PHP>\+\+ lval.Token(l.createToken(l.Token())); return int(T_INC)
|
|
<PHP>=> lval.Token(l.createToken(l.Token())); return int(T_DOUBLE_ARROW)
|
|
<PHP>\<=\> lval.Token(l.createToken(l.Token())); return int(T_SPACESHIP)
|
|
<PHP>\!=|\<\> lval.Token(l.createToken(l.Token())); return int(T_IS_NOT_EQUAL)
|
|
<PHP>\!== lval.Token(l.createToken(l.Token())); return int(T_IS_NOT_IDENTICAL)
|
|
<PHP>== lval.Token(l.createToken(l.Token())); return int(T_IS_EQUAL)
|
|
<PHP>=== lval.Token(l.createToken(l.Token())); return int(T_IS_IDENTICAL)
|
|
<PHP>\<\<= lval.Token(l.createToken(l.Token())); return int(T_SL_EQUAL)
|
|
<PHP>\>\>= lval.Token(l.createToken(l.Token())); return int(T_SR_EQUAL)
|
|
<PHP>\>= lval.Token(l.createToken(l.Token())); return int(T_IS_GREATER_OR_EQUAL)
|
|
<PHP>\<= lval.Token(l.createToken(l.Token())); return int(T_IS_SMALLER_OR_EQUAL)
|
|
<PHP>\*\* lval.Token(l.createToken(l.Token())); return int(T_POW)
|
|
<PHP>\<\< lval.Token(l.createToken(l.Token())); return int(T_SL)
|
|
<PHP>\>\> lval.Token(l.createToken(l.Token())); return int(T_SR)
|
|
<PHP>\?\? lval.Token(l.createToken(l.Token())); return int(T_COALESCE)
|
|
<PHP>(#|[/][/])
|
|
tb := l.Token()
|
|
|
|
for {
|
|
if c == -1 {
|
|
break
|
|
}
|
|
|
|
tb = append(tb, l.Last)
|
|
|
|
switch c {
|
|
case '\r':
|
|
c = l.Next()
|
|
if c == '\n' {
|
|
continue
|
|
}
|
|
|
|
case '\n':
|
|
c = l.Next()
|
|
|
|
case '?':
|
|
c = l.Next()
|
|
if c == '>' {
|
|
l.ungetChars(1)
|
|
tb = tb[:len(tb)-1]
|
|
break
|
|
}
|
|
continue
|
|
|
|
default:
|
|
c = l.Next()
|
|
continue
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
l.addMeta(meta.CommentType, tb)
|
|
|
|
<PHP>[/][*][*][/]
|
|
l.addMeta(meta.CommentType, l.Token())
|
|
<PHP>([/][*])|([/][*][*])
|
|
tb := l.Token()
|
|
is_doc_comment := false
|
|
if len(tb) > 2 {
|
|
is_doc_comment = true
|
|
l.PhpDocComment = ""
|
|
}
|
|
|
|
c = l.Next()
|
|
for {
|
|
if c == -1 {
|
|
break; // TODO: Unterminated comment starting line %d
|
|
}
|
|
|
|
if l.Prev.Rune == '*' && l.Last.Rune == '/' {
|
|
c = l.Next()
|
|
break;
|
|
}
|
|
|
|
c = l.Next()
|
|
}
|
|
|
|
if is_doc_comment {
|
|
l.PhpDocComment = string(l.TokenBytes(nil))
|
|
l.addMeta(meta.CommentType, l.Token())
|
|
} else {
|
|
l.addMeta(meta.CommentType, l.Token())
|
|
}
|
|
|
|
<PHP>{OPERATORS} lval.Token(l.createToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
|
|
|
<PHP>\{ l.pushState(PHP); lval.Token(l.createToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
|
<PHP>\} l.popState(); lval.Token(l.createToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0])); l.PhpDocComment = ""
|
|
<PHP>\${VAR_NAME} lval.Token(l.createToken(l.Token())); return int(T_VARIABLE)
|
|
<PHP>{VAR_NAME} lval.Token(l.createToken(l.Token())); return int(T_STRING)
|
|
|
|
<PHP>-> l.Begin(PROPERTY);lval.Token(l.createToken(l.Token())); return int(T_OBJECT_OPERATOR);
|
|
<PROPERTY>[ \t\n\r]+ l.addMeta(meta.WhiteSpaceType, l.Token())
|
|
<PROPERTY>-> lval.Token(l.createToken(l.Token())); return int(T_OBJECT_OPERATOR);
|
|
<PROPERTY>{VAR_NAME} l.Begin(PHP);lval.Token(l.createToken(l.Token())); return int(T_STRING);
|
|
<PROPERTY>. l.ungetChars(1);l.Begin(PHP)
|
|
|
|
<PHP>[\']([^\\\']*(\\(.|\n))*)*[\'] lval.Token(l.createToken(l.Token())); return int(T_CONSTANT_ENCAPSED_STRING);
|
|
|
|
<PHP>` l.Begin(BACKQUOTE); lval.Token(l.createToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
|
<BACKQUOTE>` l.Begin(PHP); lval.Token(l.createToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
|
|
|
<PHP>[b]?\<\<\<[ \t]*({VAR_NAME}|([']{VAR_NAME}['])|(["]{VAR_NAME}["])){NEW_LINE}
|
|
tb := l.Token()
|
|
binPrefix := 0
|
|
if tb[0].Rune == 'b' {
|
|
binPrefix = 1
|
|
}
|
|
|
|
lblFirst := 3 + binPrefix
|
|
lblLast := len(tb)-2
|
|
if tb[lblLast].Rune == '\r' {
|
|
lblLast--
|
|
}
|
|
|
|
for {
|
|
if tb[lblFirst].Rune == ' ' || tb[lblFirst].Rune == '\t' {
|
|
lblFirst++
|
|
continue
|
|
}
|
|
|
|
break
|
|
}
|
|
|
|
heredocToken := make([]lex.Char, lblLast - lblFirst + 1)
|
|
copy(heredocToken, tb[lblFirst:lblLast+1])
|
|
|
|
switch tb[lblFirst].Rune {
|
|
case '\'' :
|
|
lblFirst++
|
|
lblLast--
|
|
l.Begin(NOWDOC)
|
|
case '"' :
|
|
lblFirst++
|
|
lblLast--
|
|
l.Begin(HEREDOC)
|
|
default:
|
|
l.Begin(HEREDOC)
|
|
}
|
|
|
|
l.heredocLabel = l.tokenString(tb[lblFirst:lblLast+1])
|
|
|
|
ungetCnt := len(l.heredocLabel)
|
|
searchLabelAhead := []byte{}
|
|
for i := 0; i < len(l.heredocLabel); i++ {
|
|
if c == -1 {
|
|
break;
|
|
}
|
|
searchLabelAhead = append(searchLabelAhead, byte(rune(c)))
|
|
c = l.Next()
|
|
}
|
|
|
|
if l.heredocLabel == string(searchLabelAhead) && ';' == rune(c) {
|
|
ungetCnt++
|
|
c = l.Next()
|
|
if '\n' == rune(c) || '\r' == rune(c) {
|
|
l.Begin(HEREDOC_END)
|
|
}
|
|
}
|
|
|
|
l.ungetChars(ungetCnt)
|
|
|
|
lval.Token(l.createToken(heredocToken));
|
|
return int(T_START_HEREDOC)
|
|
|
|
<NOWDOC>.|[ \t\n\r]
|
|
searchLabel := []byte{}
|
|
tb := []lex.Char{}
|
|
|
|
for {
|
|
if c == -1 {
|
|
break;
|
|
}
|
|
|
|
if '\n' == rune(c) || '\r' == rune(c) {
|
|
if l.heredocLabel + ";" == string(searchLabel) {
|
|
l.Begin(HEREDOC_END)
|
|
tb = l.ungetChars(len(l.heredocLabel)+1)
|
|
tb = tb[:len(tb)-1]
|
|
break;
|
|
}
|
|
|
|
if l.heredocLabel == string(searchLabel) {
|
|
l.Begin(HEREDOC_END)
|
|
tb = l.ungetChars(len(l.heredocLabel))
|
|
tb = tb[:len(tb)-1]
|
|
break;
|
|
}
|
|
|
|
searchLabel = []byte{}
|
|
} else {
|
|
searchLabel = append(searchLabel, byte(rune(c)))
|
|
}
|
|
|
|
c = l.Next()
|
|
}
|
|
|
|
lval.Token(l.createToken(tb) )
|
|
return int(T_ENCAPSED_AND_WHITESPACE)
|
|
|
|
<HEREDOC_END>{VAR_NAME}\; l.Begin(PHP);lval.Token(l.createToken(l.ungetChars(1))); return int(T_END_HEREDOC)
|
|
<HEREDOC_END>{VAR_NAME} l.Begin(PHP);lval.Token(l.createToken(l.Token())); return int(T_END_HEREDOC)
|
|
|
|
<PHP>[b]?[\"]
|
|
binPrefix := l.Token()[0].Rune == 'b'
|
|
|
|
beginString := func() int {
|
|
cnt := 1; if (binPrefix) {cnt = 2}
|
|
|
|
l.ungetChars(len(l.Token())-cnt)
|
|
chars := l.Token()[:cnt]
|
|
l.pushState(STRING)
|
|
|
|
lval.Token(l.createToken(chars)); return Rune2Class('"')
|
|
}
|
|
|
|
F:for {
|
|
if c == -1 {
|
|
break;
|
|
}
|
|
|
|
switch c {
|
|
case '"' :
|
|
c = l.Next();
|
|
lval.Token(l.createToken(l.Token())); return int(T_CONSTANT_ENCAPSED_STRING)
|
|
break F;
|
|
|
|
case '$':
|
|
c = l.Next();
|
|
if rune(c) == '{' || c >= 'A' && c <= 'Z' || c == '_' || c >= 'a' && c <= 'z' || c >= '\u007f' && c <= 'ÿ' {
|
|
return beginString()
|
|
break F;
|
|
}
|
|
l.ungetChars(0)
|
|
|
|
case '{':
|
|
c = l.Next();
|
|
if rune(c) == '$' {
|
|
return beginString()
|
|
break F;
|
|
}
|
|
l.ungetChars(0)
|
|
|
|
case '\\':
|
|
c = l.Next();
|
|
}
|
|
|
|
c = l.Next()
|
|
}
|
|
|
|
<STRING>\" l.popState(); lval.Token(l.createToken(l.Token())); return Rune2Class(l.Token()[0].Rune)
|
|
<STRING,HEREDOC,BACKQUOTE>\{\$ lval.Token(l.createToken(l.ungetChars(1))); l.pushState(PHP); return int(T_CURLY_OPEN)
|
|
<STRING,HEREDOC,BACKQUOTE>\$\{ l.pushState(STRING_VAR_NAME); lval.Token(l.createToken(l.Token())); return int(T_DOLLAR_OPEN_CURLY_BRACES)
|
|
<STRING,HEREDOC,BACKQUOTE>\${VAR_NAME} l.ungetChars(len(l.Token()));l.pushState(STRING_VAR)
|
|
<STRING>.|[ \t\n\r]
|
|
currentChar := l.Prev
|
|
tb := []lex.Char{currentChar}
|
|
for {
|
|
switch currentChar.Rune {
|
|
case '$':
|
|
if c == '{' || isValidFirstVarNameRune(rune(c)) {
|
|
l.ungetChars(1)
|
|
lval.Token(l.createToken(tb[:len(tb)-1]));
|
|
return int(T_ENCAPSED_AND_WHITESPACE)
|
|
}
|
|
|
|
case '{':
|
|
if rune(c) == '$' {
|
|
l.ungetChars(1)
|
|
lval.Token(l.createToken(tb[:len(tb)-1]));
|
|
return int(T_ENCAPSED_AND_WHITESPACE)
|
|
}
|
|
|
|
case '\\':
|
|
currentChar := l.Last
|
|
tb = append(tb, currentChar)
|
|
c = l.Next();
|
|
}
|
|
|
|
if rune(c) == '"' {
|
|
lval.Token(l.createToken(l.Token()));
|
|
return int(T_ENCAPSED_AND_WHITESPACE)
|
|
}
|
|
|
|
currentChar = l.Last
|
|
tb = append(tb, currentChar)
|
|
c = l.Next()
|
|
|
|
if c == -1 {
|
|
break;
|
|
}
|
|
}
|
|
|
|
<BACKQUOTE>.|[ \t\n\r]
|
|
currentChar := l.Prev
|
|
tb := []lex.Char{currentChar}
|
|
|
|
for {
|
|
switch currentChar.Rune {
|
|
case '$':
|
|
if c == '{' || isValidFirstVarNameRune(rune(c)) {
|
|
l.ungetChars(1)
|
|
lval.Token(l.createToken(tb[:len(tb)-1]));
|
|
return int(T_ENCAPSED_AND_WHITESPACE)
|
|
}
|
|
|
|
case '{':
|
|
if rune(c) == '$' {
|
|
l.ungetChars(1)
|
|
lval.Token(l.createToken(tb[:len(tb)-1]));
|
|
return int(T_ENCAPSED_AND_WHITESPACE)
|
|
}
|
|
|
|
case '\\':
|
|
currentChar := l.Last
|
|
tb = append(tb, currentChar)
|
|
c = l.Next();
|
|
}
|
|
|
|
if rune(c) == '`' {
|
|
lval.Token(l.createToken(l.Token()));
|
|
return int(T_ENCAPSED_AND_WHITESPACE)
|
|
}
|
|
|
|
currentChar = l.Last
|
|
tb = append(tb, currentChar)
|
|
c = l.Next()
|
|
|
|
if c == -1 {
|
|
break;
|
|
}
|
|
}
|
|
|
|
<HEREDOC>.|[ \t\n\r]
|
|
searchLabel := []byte{}
|
|
currentChar := l.Prev
|
|
tb := []lex.Char{currentChar}
|
|
|
|
HEREDOC_FOR:for {
|
|
nls := 0
|
|
|
|
switch currentChar.Rune {
|
|
case '\r':
|
|
|
|
if c == '\n' {
|
|
nls = 1
|
|
currentChar := l.Last
|
|
tb = append(tb, currentChar)
|
|
c = l.Next();
|
|
}
|
|
|
|
fallthrough
|
|
|
|
case '\n':
|
|
if l.heredocLabel + ";" == string(searchLabel) {
|
|
l.Begin(HEREDOC_END)
|
|
l.ungetChars(len(l.heredocLabel)+1+nls)
|
|
|
|
i := len(tb) - len(l.heredocLabel) - 3 - nls
|
|
if i < 1 {
|
|
break HEREDOC_FOR;
|
|
}
|
|
tb = tb[:i]
|
|
|
|
lval.Token(l.createToken(tb));
|
|
return int(T_ENCAPSED_AND_WHITESPACE)
|
|
}
|
|
|
|
if l.heredocLabel == string(searchLabel) {
|
|
l.Begin(HEREDOC_END)
|
|
l.ungetChars(len(l.heredocLabel)+nls)
|
|
|
|
i := len(tb) - len(l.heredocLabel) - 2 - nls
|
|
if i < 1 {
|
|
break HEREDOC_FOR;
|
|
}
|
|
tb = tb[:i]
|
|
|
|
lval.Token(l.createToken(tb));
|
|
return int(T_ENCAPSED_AND_WHITESPACE)
|
|
}
|
|
|
|
searchLabel = []byte{}
|
|
|
|
case '$':
|
|
if c == '{' || isValidFirstVarNameRune(rune(c)) {
|
|
l.ungetChars(1)
|
|
lval.Token(l.createToken(tb[:len(tb)-1]));
|
|
return int(T_ENCAPSED_AND_WHITESPACE)
|
|
}
|
|
|
|
case '{':
|
|
if rune(c) == '$' {
|
|
l.ungetChars(1)
|
|
lval.Token(l.createToken(tb[:len(tb)-1]));
|
|
return int(T_ENCAPSED_AND_WHITESPACE)
|
|
}
|
|
|
|
case '\\':
|
|
if c != '\n' && c != '\r' {
|
|
currentChar := l.Last
|
|
tb = append(tb, currentChar)
|
|
c = l.Next();
|
|
}
|
|
|
|
default:
|
|
searchLabel = append(searchLabel, byte(rune(currentChar.Rune)))
|
|
}
|
|
|
|
if c == -1 {
|
|
break;
|
|
}
|
|
|
|
currentChar = l.Last
|
|
tb = append(tb, currentChar)
|
|
c = l.Next()
|
|
|
|
}
|
|
|
|
<STRING_VAR>\${VAR_NAME} lval.Token(l.createToken(l.Token())); return int(T_VARIABLE)
|
|
<STRING_VAR>->{VAR_NAME} lval.Token(l.createToken(l.ungetChars(len(l.Token())-2))); return int(T_OBJECT_OPERATOR)
|
|
<STRING_VAR>{VAR_NAME} l.popState();lval.Token(l.createToken(l.Token())); return int(T_STRING)
|
|
<STRING_VAR>\[ l.pushState(STRING_VAR_INDEX);lval.Token(l.createToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
|
<STRING_VAR>.|[ \t\n\r] l.ungetChars(1);l.popState()
|
|
|
|
<STRING_VAR_INDEX>{LNUM}|{HNUM}|{BNUM} lval.Token(l.createToken(l.Token())); return int(T_NUM_STRING)
|
|
<STRING_VAR_INDEX>\${VAR_NAME} lval.Token(l.createToken(l.Token())); return int(T_VARIABLE)
|
|
<STRING_VAR_INDEX>{VAR_NAME} lval.Token(l.createToken(l.Token())); return int(T_STRING)
|
|
<STRING_VAR_INDEX>\] l.popState(); l.popState();lval.Token(l.createToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
|
<STRING_VAR_INDEX>[ \n\r\t\\'#] l.popState(); l.popState();lval.Token(l.createToken(l.Token())); return int(T_ENCAPSED_AND_WHITESPACE)
|
|
<STRING_VAR_INDEX>{OPERATORS} lval.Token(l.createToken(l.Token())); return Rune2Class(rune(l.TokenBytes(nil)[0]))
|
|
<STRING_VAR_INDEX>{ANY_CHAR} l.Error(fmt.Sprintf("WARNING: Unexpected character in input: '%c' (ASCII=%d)", l.TokenBytes(nil)[0], l.TokenBytes(nil)[0]));l.Abort();
|
|
|
|
<STRING_VAR_NAME>{VAR_NAME}[\[\}] l.popState();l.pushState(PHP);lval.Token(l.createToken(l.ungetChars(1))); return int(T_STRING_VARNAME)
|
|
<STRING_VAR_NAME>. l.ungetChars(1);l.popState();l.pushState(PHP)
|
|
|
|
<HALT_COMPILER>.|[ \t\n\r] l.addMeta(meta.TokenType, l.Token())
|
|
|
|
<PHP>{ANY_CHAR} l.Error(fmt.Sprintf("WARNING: Unexpected character in input: '%c' (ASCII=%d)", l.TokenBytes(nil)[0], l.TokenBytes(nil)[0]));l.Abort();
|
|
|
|
%%
|
|
if _, ok := l.Abort(); ok {
|
|
// always return same $end token
|
|
if l.lastToken == nil {
|
|
l.lastToken = l.createToken(l.Token())
|
|
}
|
|
lval.Token(l.lastToken);
|
|
return -1
|
|
}
|
|
goto yyAction
|
|
}
|