public function parse(TokenPool $aTokenPool, INonlinearIterator $aTokenPoolIter, State $aState)
{
$aToken = $aTokenPoolIter->current();
if ($aState->isPHPCode()) {
// 检查 php 结束标签
if ($aToken->tokenType() == T_CLOSE_TAG) {
$aState->setPHPCode(false);
}
} else {
// 检查 php 开始标签
if ($aToken->tokenType() == T_OPEN_TAG) {
$aState->setPHPCode(true);
}
}
}
public function parse(TokenPool $aTokenPool, INonlinearIterator $aTokenPoolIter, State $aState)
{
$aOriToken = $aTokenPoolIter->current();
if (!$aOriToken or $aOriToken->tokenType() != T_NAMESPACE) {
return;
}
$aTokenPoolIter = clone $aTokenPoolIter;
$aNewToken = new NamespaceDeclare($aOriToken);
for ($aTokenPoolIter->next(); $aToken = $aTokenPoolIter->current() and $aToken->tokenType() != Token::T_SEMICOLON; $aTokenPoolIter->next()) {
if ($aToken->tokenType() == T_STRING) {
$aNewToken->addNameToken($aToken);
}
}
$aTokenPool->replace($aOriToken, $aNewToken);
$aState->setCurrentNamespace($aNewToken);
}
public function parse(TokenPool $aTokenPool, INonlinearIterator $aTokenPoolIter, State $aState)
{
if (!($aOriToken = $aTokenPoolIter->current())) {
return;
}
// 已经处于 function 状态中
if ($aFunction = $aState->currentFunction()) {
// 遇到
if ($aFunction->bodyToken() and $aFunction->bodyToken()->theOther() === $aOriToken) {
$aState->setCurrentFunction(null);
}
return;
} else {
if ($aOriToken->tokenType() != T_FUNCTION) {
return;
}
$aTokenPoolIter = clone $aTokenPoolIter;
$aNewToken = new FunctionDefine($aOriToken);
// function 修饰符 ------
for ($aTokenPoolIter->prev(); $aToken = $aTokenPoolIter->current(); $aTokenPoolIter->prev()) {
switch ($aToken->tokenType()) {
case T_PUBLIC:
$aNewToken->setAccessToken($aToken);
break;
case T_PROTECTED:
$aNewToken->setAccessToken($aToken);
break;
case T_PRIVATE:
$aNewToken->setAccessToken($aToken);
break;
case T_STATIC:
$aNewToken->setStaticToken($aToken);
break;
case T_ABSTRACT:
$aNewToken->setAbstractToken($aToken);
break;
case T_DOC_COMMENT:
$aDocToken = new DocCommentDeclare($aToken);
$aNewToken->setDocToken($aDocToken);
$aTokenPool->replace($aToken, $aDocToken);
break 2;
case T_WHITESPACE:
break;
default:
break 2;
}
}
// function name ------
for ($aTokenPoolIter->next(); $aToken = $aTokenPoolIter->current(); $aTokenPoolIter->next()) {
switch ($aToken->tokenType()) {
// 函数名称
case T_STRING:
$aNewToken->setNameToken($aToken);
break 2;
// 匿名函数
// 匿名函数
case Token::T_BRACE_ROUND_OPEN:
$aTokenPoolIter->prev();
break 2;
case Token::T_BIT_AND:
$aNewToken->setReturnByRef(true);
break;
}
}
// function argv list ------
do {
$aTokenPoolIter->next();
} while ($aToken = $aTokenPoolIter->current() and $aToken->tokenType() != Token::T_BRACE_ROUND_OPEN);
$aNewToken->setArgListToken($aToken);
// 移动到参数表结束符号后
$nPosition = $aTokenPoolIter->search($aToken->theOther());
$aTokenPoolIter->seek($nPosition);
// function body ------
do {
$aTokenPoolIter->next();
} while ($aToken = $aTokenPoolIter->current() and !in_array($aToken->tokenType(), array(Token::T_BRACE_OPEN, Token::T_SEMICOLON)));
if ($aToken) {
if ($aToken->tokenType() == Token::T_BRACE_OPEN) {
$aNewToken->setBodyToken($aToken);
$aState->setCurrentFunction($aNewToken);
} else {
if ($aToken->tokenType() == Token::T_SEMICOLON) {
$aNewToken->setEndToken($aToken);
}
}
}
$aTokenPool->replace($aOriToken, $aNewToken);
$aNewToken->setBelongsNamespace($aState->currentNamespace());
$aNewToken->setBelongsClass($aState->currentClass());
$aTokenPool->addFunction($aNewToken);
}
}
public function parse(TokenPool $aTokenPool, INonlinearIterator $aTokenPoolIter, State $aState)
{
if (!($aOriToken = $aTokenPoolIter->current())) {
return;
}
// 已经处于 class 状态中
if ($aClass = $aState->currentClass()) {
// 遇到
if ($aOriToken === $aClass->bodyToken()->theOther()) {
$aState->setCurrentClass(null);
}
return;
} else {
if (T_INTERFACE !== $aOriToken->tokenType() && T_CLASS !== $aOriToken->tokenType()) {
return;
}
$aTokenPoolIter = clone $aTokenPoolIter;
$aNewToken = new ClassDefine($aOriToken);
// class name
do {
$aTokenPoolIter->next();
} while ($aToken = $aTokenPoolIter->current() and $aToken->tokenType() != T_STRING);
$aNewToken->setNameToken($aToken);
$aNewToken->setBelongsNamespace($aState->currentNamespace());
// doc comment and abstract
for ($aTokenPoolIter->prev(); $aToken = $aTokenPoolIter->current(); $aTokenPoolIter->prev()) {
switch ($aToken->tokenType()) {
case T_ABSTRACT:
$aNewToken->setAbstract(true);
break;
case T_DOC_COMMENT:
$aDocToken = new DocCommentDeclare($aToken);
$aNewToken->setDocToken($aDocToken);
$aTokenPool->replace($aToken, $aDocToken);
break;
case T_WHITESPACE:
case T_CLASS:
break;
default:
break 2;
}
}
// init extends implements body
$sState = 'init';
// parent/body
$aClassBodyToken = $aParentNameToken = null;
for ($aTokenPoolIter->next(); $aToken = $aTokenPoolIter->current(); $aTokenPoolIter->next()) {
// 控制触发 addParentClassName 操作
$sAddParentClassName = false;
// 分析 tokenType
switch ($aToken->tokenType()) {
case Token::T_BRACE_OPEN:
$aClassBodyToken = $aToken;
$sAddParentClassName = $sState;
$sState = 'body';
break 2;
case T_EXTENDS:
$sAddParentClassName = $sState;
$sState = 'extends';
break;
case T_IMPLEMENTS:
$sAddParentClassName = $sState;
$sState = 'implements';
break;
case T_STRING:
case T_NS_SEPARATOR:
switch ($sState) {
case 'extends':
case 'implements':
if (!$aParentNameToken) {
$aParentNameToken = new NamespaceString(0, '');
$aParentNameToken->setBelongsNamespace($aState->currentNamespace());
}
$aParentNameToken->addNameToken($aToken);
break;
}
break;
case Token::T_COLON:
case T_WHITESPACE:
$sAddParentClassName = $sState;
break;
}
// addParentClassName
if ($sAddParentClassName && $aParentNameToken) {
switch ($sAddParentClassName) {
case 'init':
break;
case 'extends':
$aNewToken->addParentClassName($aParentNameToken->findRealName($aTokenPool));
$aParentNameToken = null;
break;
case 'implements':
$aNewToken->addImplementsInterfaceName($aParentNameToken->findRealName($aTokenPool));
$aParentNameToken = null;
break;
case 'body':
break;
}
}
}
if (!$aClassBodyToken) {
throw new ClassCompileException(null, $aOriToken, "编译class: %s时遇到了错误，class没有body", $aNewToken->name());
}
$aNewToken->setBodyToken($aClassBodyToken);
// 完成
$aTokenPool->replace($aOriToken, $aNewToken);
$aState->setCurrentClass($aNewToken);
$aTokenPool->addClass($aNewToken);
}
}
public function parse(TokenPool $aTokenPool, INonlinearIterator $aTokenPoolIter, State $aState)
{
if (!($aOriToken = $aTokenPoolIter->current())) {
return;
}
// 是否处在function中
if (!($aFunction = $aState->currentFunction())) {
return;
}
// 是否是function的argListToken
if ($aFunction->argListToken() !== $aOriToken) {
return;
}
$aTokenPoolIter = clone $aTokenPoolIter;
$aNewToken = null;
for ($aTokenPoolIter->next(); $aToken = $aTokenPoolIter->current(); $aTokenPoolIter->next()) {
switch ($aToken->tokenType()) {
// 结束
case Token::T_BRACE_ROUND_CLOSE:
if ($aToken === $aOriToken->theOther()) {
if (null !== $aNewToken) {
$aNewToken->setBelongsFunction($aFunction);
$aFunction->addParameterToken($aNewToken);
$aTokenPool->replace($aNewToken->nameToken(), $aNewToken);
$aNewToken = null;
}
break 2;
}
break;
// 类型
// 类型
case T_STRING:
if (null === $aNewToken) {
$aNewToken = new Parameter($aToken);
}
$aNewToken->setTypeToken($aToken);
break;
// 引用传递
// 引用传递
case Token::T_BIT_AND:
if (null === $aNewToken) {
$aNewToken = new Parameter($aToken);
}
$aNewToken->setReference(true);
break;
// 参数名
// 参数名
case T_VARIABLE:
if (null === $aNewToken) {
$aNewToken = new Parameter($aToken);
}
$aNewToken->setNameToken($aToken);
break;
// 默认值
// 默认值
case Token::T_EQUAL:
if (null === $aNewToken) {
$aNewToken = new Parameter($aToken);
}
$aDefaultValueToken = new ParameterDefaultValue();
//直接跳到结束（右括号）或下一个参数（逗号）之前
for ($aTokenPoolIter->next(); $aEscapeToken = $aTokenPoolIter->current(); $aTokenPoolIter->next()) {
switch ($aEscapeToken->tokenType()) {
// 在默认值中遇到左括号，直接跳过到它匹配的右括号后面
case Token::T_BRACE_ROUND_OPEN:
//$nPosition = $aTokenPoolIter->search($aEscapeToken->theOther()) ;
//$aTokenPoolIter->seek($nPosition) ;
// 括号之间的全部加入DefaultValueToken
$aDefaultValueToken->addSubToken($aEscapeToken);
do {
$aTokenPoolIter->next();
$aInsideBraceToken = $aTokenPoolIter->current();
$aDefaultValueToken->addSubToken($aInsideBraceToken);
} while ($aInsideBraceToken !== $aEscapeToken->theOther());
break;
// 跳到结束右括号之前，不加入DefaultValueToken
// 跳到结束右括号之前，不加入DefaultValueToken
case Token::T_BRACE_ROUND_CLOSE:
if ($aEscapeToken === $aOriToken->theOther()) {
$aTokenPoolIter->prev();
break 2;
}
break;
// 跳到下一个参数的逗号之前，不加入DefaultValueToken
// 跳到下一个参数的逗号之前，不加入DefaultValueToken
case Token::T_COLON:
$aTokenPoolIter->prev();
break 2;
default:
$aDefaultValueToken->addSubToken($aEscapeToken);
break;
}
}
$aNewToken->setDefaultValueToken($aDefaultValueToken);
break;
// 逗号，下一个参数
// 逗号，下一个参数
case Token::T_COLON:
if (null !== $aNewToken) {
$aNewToken->setBelongsFunction($aFunction);
$aFunction->addParameterToken($aNewToken);
$aTokenPool->replace($aNewToken->nameToken(), $aNewToken);
$aNewToken = null;
}
break;
}
}
}
