RetailCRM-Mirror/doctrine2
1
0
Fork 0
mirror of synced 2024-12-12 22:36:02 +03:00
Code Issues Projects Releases Wiki Activity

[2.0] More refactorings in Annotations parser and DQL parser. Now they only use constants instead of string processment

Browse Source
This commit is contained in:
guilhermeblanco 2009-11-04 01:52:40 +00:00
parent e05ec39ff3
commit 4a861f08a8
24 changed files with 252 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
lib/Doctrine/Common/Annotations/Lexer.php
View File

@ -34,13 +34,22 @@ namespace Doctrine\Common\Annotations;
*/
class Lexer extends \Doctrine\Common\Lexer
{
const T_NONE = 1;
const T_FLOAT = 2;
const T_INTEGER = 3;
const T_STRING = 4;
const T_IDENTIFIER = 5;
const T_TRUE = 6;
const T_FALSE = 7;
const T_NONE = 1;
const T_IDENTIFIER = 2;
const T_INTEGER = 3;
const T_STRING = 4;
const T_FLOAT = 5;
const T_AT = 101;
const T_CLOSE_CURLY_BRACES = 102;
const T_CLOSE_PARENTHESIS = 103;
const T_COMMA = 104;
const T_EQUALS = 105;
const T_FALSE = 106;
const T_NAMESPACE_SEPARATOR = 107;
const T_OPEN_CURLY_BRACES = 108;
const T_OPEN_PARENTHESIS = 109;
const T_TRUE = 110;
/**
* @inheritdoc
@ -70,21 +79,34 @@ class Lexer extends \Doctrine\Common\Lexer
$type = self::T_NONE;
$newVal = $this->_getNumeric($value);
// Checking numeric value
if ($newVal !== false){
$value = $newVal;
if (strpos($value, '.') !== false || stripos($value, 'e') !== false) {
$type = self::T_FLOAT;
} else {
$type = self::T_INTEGER;
}
return (strpos($value, '.') !== false || stripos($value, 'e') !== false)
? self::T_FLOAT : self::T_INTEGER;
}
if ($value[0] === '"') {
$type = self::T_STRING;
$value = str_replace('""', '"', substr($value, 1, strlen($value) - 2));
return self::T_STRING;
} else if (ctype_alpha($value[0]) || $value[0] === '_') {
$type = $this->_checkLiteral($value);
return $this->_checkLiteral($value);
} else {
switch ($value) {
case '@': return self::T_AT;
case ',': return self::T_COMMA;
case '(': return self::T_OPEN_PARENTHESIS;
case ')': return self::T_CLOSE_PARENTHESIS;
case '{': return self::T_OPEN_CURLY_BRACES;
case '}': return self::T_CLOSE_CURLY_BRACES;
case '=': return self::T_EQUALS;
case '\\': return self::T_NAMESPACE_SEPARATOR;
default:
// Do nothing
break;
}
}
return $type;

65
lib/Doctrine/Common/Annotations/Parser.php
View File

@ -130,7 +130,7 @@ class Parser
$this->_lexer->setInput(trim($input, '* /'));
$this->_lexer->moveNext();
if ($this->_lexer->isNextToken('@')) {
if ($this->_lexer->isNextToken(Lexer::T_AT)) {
return $this->Annotations();
}
@ -146,11 +146,8 @@ class Parser
*/
public function match($token)
{
$key = (is_string($token)) ? 'value' : 'type';
if ( ! ($this->_lexer->lookahead[$key] === $token)) {
$token = (is_string($token)) ? $token : $token['value'];
$this->syntaxError($token);
if ( ! ($this->_lexer->lookahead['type'] === $token)) {
$this->syntaxError($this->_lexer->getLiteral($token));
}
$this->_lexer->moveNext();
@ -169,7 +166,7 @@ class Parser
$token = $this->_lexer->lookahead;
}
$message = "Expected '{$expected}', got ";
$message = "Expected {$expected}, got ";
if ($this->_lexer->lookahead === null) {
$message .= 'end of string';
@ -201,7 +198,7 @@ class Parser
$annotations[get_class($annot)] = $annot;
}
while ($this->_lexer->lookahead !== null && $this->_lexer->lookahead['value'] == '@') {
while ($this->_lexer->lookahead !== null && $this->_lexer->isNextToken(Lexer::T_AT)) {
$this->_isNestedAnnotation = false;
$annot = $this->Annotation();
@ -228,12 +225,12 @@ class Parser
$values = array();
$nameParts = array();
$this->match('@');
$this->match(Lexer::T_AT);
$this->match(Lexer::T_IDENTIFIER);
$nameParts[] = $this->_lexer->token['value'];
while ($this->_lexer->isNextToken('\\')) {
$this->match('\\');
while ($this->_lexer->isNextToken(Lexer::T_NAMESPACE_SEPARATOR)) {
$this->match(Lexer::T_NAMESPACE_SEPARATOR);
$this->match(Lexer::T_IDENTIFIER);
$nameParts[] = $this->_lexer->token['value'];
}
@ -250,12 +247,12 @@ class Parser
// If it really an annotation class?
if (
(! $this->_isNestedAnnotation && $this->_lexer->lookahead != null &&
! $this->_lexer->isNextToken('(') &&
! $this->_lexer->isNextToken('@')) ||
! $this->_lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS) &&
! $this->_lexer->isNextToken(Lexer::T_AT)) ||
! class_exists($name, false) ||
! is_subclass_of($name, 'Doctrine\Common\Annotations\Annotation')
) {
$this->_lexer->skipUntil('@');
$this->_lexer->skipUntil(Lexer::T_AT);
return false;
}
@ -263,14 +260,14 @@ class Parser
// Next will be nested
$this->_isNestedAnnotation = true;
if ($this->_lexer->isNextToken('(')) {
$this->match('(');
if ($this->_lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
$this->match(Lexer::T_OPEN_PARENTHESIS);
if ( ! $this->_lexer->isNextToken(')')) {
if ( ! $this->_lexer->isNextToken(Lexer::T_CLOSE_PARENTHESIS)) {
$values = $this->Values();
}
$this->match(')');
$this->match(Lexer::T_CLOSE_PARENTHESIS);
}
return new $name($values);
@ -286,19 +283,19 @@ class Parser
$values = array();
// Handle the case of a single array as value, i.e. @Foo({....})
if ($this->_lexer->isNextToken('{')) {
if ($this->_lexer->isNextToken(Lexer::T_OPEN_CURLY_BRACES)) {
$values['value'] = $this->Value();
return $values;
}
$values[] = $this->Value();
while ($this->_lexer->isNextToken(',')) {
$this->match(',');
while ($this->_lexer->isNextToken(Lexer::T_COMMA)) {
$this->match(Lexer::T_COMMA);
$value = $this->Value();
if ( ! is_array($value)) {
$this->syntaxError('FieldAssignment', $value);
$this->syntaxError('Value', $value);
}
$values[] = $value;
@ -341,11 +338,11 @@ class Parser
*/
public function PlainValue()
{
if ($this->_lexer->lookahead['value'] == '{') {
if ($this->_lexer->isNextToken(Lexer::T_OPEN_CURLY_BRACES)) {
return $this->Arrayx();
}
if ($this->_lexer->lookahead['value'] == '@') {
if ($this->_lexer->isNextToken(Lexer::T_AT)) {
return $this->Annotation();
}
@ -385,7 +382,7 @@ class Parser
{
$this->match(Lexer::T_IDENTIFIER);
$fieldName = $this->_lexer->token['value'];
$this->match('=');
$this->match(Lexer::T_EQUALS);
return array($fieldName => $this->PlainValue());
}
@ -399,15 +396,15 @@ class Parser
{
$array = $values = array();
$this->match('{');
$this->match(Lexer::T_OPEN_CURLY_BRACES);
$values[] = $this->ArrayEntry();
while ($this->_lexer->isNextToken(',')) {
$this->match(',');
while ($this->_lexer->isNextToken(Lexer::T_COMMA)) {
$this->match(Lexer::T_COMMA);
$values[] = $this->ArrayEntry();
}
$this->match('}');
$this->match(Lexer::T_CLOSE_CURLY_BRACES);
foreach ($values as $value) {
$key = key($value);
@ -434,14 +431,12 @@ class Parser
$peek = $this->_lexer->glimpse();
if ($peek['value'] == '=') {
if ($this->_lexer->lookahead['type'] === Lexer::T_INTEGER) {
$this->match(Lexer::T_INTEGER);
} else {
$this->match(Lexer::T_STRING);
}
$this->match(
$this->_lexer->isNextToken(Lexer::T_INTEGER) ? Lexer::T_INTEGER : Lexer::T_STRING
);
$key = $this->_lexer->token['value'];
$this->match('=');
$this->match(Lexer::T_EQUALS);
return array($key => $this->PlainValue());
}

30
lib/Doctrine/Common/Lexer.php
View File

@ -110,8 +110,7 @@ abstract class Lexer
*/
public function isNextToken($token)
{
$la = $this->lookahead;
return ($la['type'] === $token || $la['value'] === $token);
return $this->lookahead['type'] === $token;
}
/**
@ -138,11 +137,11 @@ abstract class Lexer
/**
* Tells the lexer to skip input tokens until it sees a token with the given value.
*
* @param $value The value to skip until.
* @param $type The token type to skip until.
*/
public function skipUntil($value)
public function skipUntil($type)
{
while ($this->lookahead !== null && $this->lookahead['value'] !== $value) {
while ($this->lookahead !== null && $this->lookahead['type'] !== $type) {
$this->moveNext();
}
}
@ -214,6 +213,27 @@ abstract class Lexer
}
}
/**
* Gets the literal for a given token.
*
* @param integer $token
* @return string
*/
public function getLiteral($token)
{
$className = get_class($this);
$reflClass = new \ReflectionClass($className);
$constants = $reflClass->getConstants();
foreach ($constants as $name => $value) {
if ($value === $token) {
return $className . '::' . $name;
}
}
return $token;
}
/**
* Lexical catchable patterns
*

11
lib/Doctrine/ORM/Query/AST/Functions/AbsFunction.php
View File

@ -21,6 +21,8 @@
namespace Doctrine\ORM\Query\AST\Functions;
use Doctrine\ORM\Query\Lexer;
/**
* "ABS" "(" SimpleArithmeticExpression ")"
*
@ -52,10 +54,13 @@ class AbsFunction extends FunctionNode
public function parse(\Doctrine\ORM\Query\Parser $parser)
{
$lexer = $parser->getLexer();
$parser->match($lexer->lookahead['value']);
$parser->match('(');
$parser->match(Lexer::T_ABS);
$parser->match(Lexer::T_OPEN_PARENTHESIS);
$this->simpleArithmeticExpression = $parser->SimpleArithmeticExpression();
$parser->match(')');
$parser->match(Lexer::T_CLOSE_PARENTHESIS);
}
}

11
lib/Doctrine/ORM/Query/AST/Functions/ConcatFunction.php
View File

@ -21,6 +21,8 @@
namespace Doctrine\ORM\Query\AST\Functions;
use Doctrine\ORM\Query\Lexer;
/**
* "CONCAT" "(" StringPrimary "," StringPrimary ")"
*
@ -55,14 +57,15 @@ class ConcatFunction extends FunctionNode
public function parse(\Doctrine\ORM\Query\Parser $parser)
{
$lexer = $parser->getLexer();
$parser->match($lexer->lookahead['value']);
$parser->match('(');
$parser->match(Lexer::T_IDENTIFIER);
$parser->match(Lexer::T_OPEN_PARENTHESIS);
$this->firstStringPrimary = $parser->StringPrimary();
$parser->match(',');
$parser->match(Lexer::T_COMMA);
$this->secondStringPrimary = $parser->StringPrimary();
$parser->match(')');
$parser->match(Lexer::T_CLOSE_PARENTHESIS);
}
}

9
lib/Doctrine/ORM/Query/AST/Functions/CurrentDateFunction.php
View File

@ -21,6 +21,8 @@
namespace Doctrine\ORM\Query\AST\Functions;
use Doctrine\ORM\Query\Lexer;
/**
* "CURRENT_DATE"
*
@ -48,8 +50,9 @@ class CurrentDateFunction extends FunctionNode
public function parse(\Doctrine\ORM\Query\Parser $parser)
{
$lexer = $parser->getLexer();
$parser->match($lexer->lookahead['value']);
$parser->match('(');
$parser->match(')');
$parser->match(Lexer::T_IDENTIFIER);
$parser->match(Lexer::T_OPEN_PARENTHESIS);
$parser->match(Lexer::T_CLOSE_PARENTHESIS);
}
}

9
lib/Doctrine/ORM/Query/AST/Functions/CurrentTimeFunction.php
View File

@ -21,6 +21,8 @@
namespace Doctrine\ORM\Query\AST\Functions;
use Doctrine\ORM\Query\Lexer;
/**
* "CURRENT_TIME"
*
@ -48,8 +50,9 @@ class CurrentTimeFunction extends FunctionNode
public function parse(\Doctrine\ORM\Query\Parser $parser)
{
$lexer = $parser->getLexer();
$parser->match($lexer->lookahead['value']);
$parser->match('(');
$parser->match(')');
$parser->match(Lexer::T_IDENTIFIER);
$parser->match(Lexer::T_OPEN_PARENTHESIS);
$parser->match(Lexer::T_CLOSE_PARENTHESIS);
}
}

9
lib/Doctrine/ORM/Query/AST/Functions/CurrentTimestampFunction.php
View File

@ -6,6 +6,8 @@
namespace Doctrine\ORM\Query\AST\Functions;
use Doctrine\ORM\Query\Lexer;
/**
* "CURRENT_TIMESTAMP"
*
@ -27,8 +29,9 @@ class CurrentTimestampFunction extends FunctionNode
public function parse(\Doctrine\ORM\Query\Parser $parser)
{
$lexer = $parser->getLexer();
$parser->match($lexer->lookahead['value']);
$parser->match('(');
$parser->match(')');
$parser->match(Lexer::T_IDENTIFIER);
$parser->match(Lexer::T_OPEN_PARENTHESIS);
$parser->match(Lexer::T_CLOSE_PARENTHESIS);
}
}

8
lib/Doctrine/ORM/Query/AST/Functions/LengthFunction.php
View File

@ -21,6 +21,8 @@
namespace Doctrine\ORM\Query\AST\Functions;
use Doctrine\ORM\Query\Lexer;
/**
* "LENGTH" "(" StringPrimary ")"
*
@ -52,12 +54,12 @@ class LengthFunction extends FunctionNode
{
$lexer = $parser->getLexer();
$parser->match($lexer->lookahead['value']);
$parser->match('(');
$parser->match(Lexer::T_IDENTIFIER);
$parser->match(Lexer::T_OPEN_PARENTHESIS);
$this->stringPrimary = $parser->StringPrimary();
$parser->match(')');
$parser->match(Lexer::T_CLOSE_PARENTHESIS);
}
}

14
lib/Doctrine/ORM/Query/AST/Functions/LocateFunction.php
View File

@ -21,6 +21,8 @@
namespace Doctrine\ORM\Query\AST\Functions;
use Doctrine\ORM\Query\Lexer;
/**
* "LOCATE" "(" StringPrimary "," StringPrimary ["," SimpleArithmeticExpression]")"
*
@ -59,22 +61,22 @@ class LocateFunction extends FunctionNode
{
$lexer = $parser->getLexer();
$parser->match($lexer->lookahead['value']);
$parser->match('(');
$parser->match(Lexer::T_IDENTIFIER);
$parser->match(Lexer::T_OPEN_PARENTHESIS);
$this->firstStringPrimary = $parser->StringPrimary();
$parser->match(',');
$parser->match(Lexer::T_COMMA);
$this->secondStringPrimary = $parser->StringPrimary();
if ($lexer->isNextToken(',')) {
$parser->match(',');
if ($lexer->isNextToken(Lexer::T_COMMA)) {
$parser->match(Lexer::T_COMMA);
$this->simpleArithmeticExpression = $parser->SimpleArithmeticExpression();
}
$parser->match(')');
$parser->match(Lexer::T_CLOSE_PARENTHESIS);
}
}

8
lib/Doctrine/ORM/Query/AST/Functions/LowerFunction.php
View File

@ -21,6 +21,8 @@
namespace Doctrine\ORM\Query\AST\Functions;
use Doctrine\ORM\Query\Lexer;
/**
* "LOWER" "(" StringPrimary ")"
*
@ -52,12 +54,12 @@ class LowerFunction extends FunctionNode
{
$lexer = $parser->getLexer();
$parser->match($lexer->lookahead['value']);
$parser->match('(');
$parser->match(Lexer::T_IDENTIFIER);
$parser->match(Lexer::T_OPEN_PARENTHESIS);
$this->stringPrimary = $parser->StringPrimary();
$parser->match(')');
$parser->match(Lexer::T_CLOSE_PARENTHESIS);
}
}

10
lib/Doctrine/ORM/Query/AST/Functions/ModFunction.php
View File

@ -21,6 +21,8 @@
namespace Doctrine\ORM\Query\AST\Functions;
use Doctrine\ORM\Query\Lexer;
/**
* "MOD" "(" SimpleArithmeticExpression "," SimpleArithmeticExpression ")"
*
@ -57,16 +59,16 @@ class ModFunction extends FunctionNode
{
$lexer = $parser->getLexer();
$parser->match($lexer->lookahead['value']);
$parser->match('(');
$parser->match(Lexer::T_MOD);
$parser->match(Lexer::T_OPEN_PARENTHESIS);
$this->firstSimpleArithmeticExpression = $parser->SimpleArithmeticExpression();
$parser->match(',');
$parser->match(Lexer::T_COMMA);
$this->secondSimpleArithmeticExpression = $parser->SimpleArithmeticExpression();
$parser->match(')');
$parser->match(Lexer::T_CLOSE_PARENTHESIS);
}
}

8
lib/Doctrine/ORM/Query/AST/Functions/SizeFunction.php
View File

@ -21,6 +21,8 @@
namespace Doctrine\ORM\Query\AST\Functions;
use Doctrine\ORM\Query\Lexer;
/**
* "SIZE" "(" CollectionValuedPathExpression ")"
*
@ -77,12 +79,12 @@ class SizeFunction extends FunctionNode
{
$lexer = $parser->getLexer();
$parser->match($lexer->lookahead['value']);
$parser->match('(');
$parser->match(Lexer::T_SIZE);
$parser->match(Lexer::T_OPEN_PARENTHESIS);
$this->collectionPathExpression = $parser->CollectionValuedPathExpression();
$parser->match(')');
$parser->match(Lexer::T_CLOSE_PARENTHESIS);
}
}

8
lib/Doctrine/ORM/Query/AST/Functions/SqrtFunction.php
View File

@ -21,6 +21,8 @@
namespace Doctrine\ORM\Query\AST\Functions;
use Doctrine\ORM\Query\Lexer;
/**
* "SQRT" "(" SimpleArithmeticExpression ")"
*
@ -52,12 +54,12 @@ class SqrtFunction extends FunctionNode
{
$lexer = $parser->getLexer();
$parser->match($lexer->lookahead['value']);
$parser->match('(');
$parser->match(Lexer::T_IDENTIFIER);
$parser->match(Lexer::T_OPEN_PARENTHESIS);
$this->simpleArithmeticExpression = $parser->SimpleArithmeticExpression();
$parser->match(')');
$parser->match(Lexer::T_CLOSE_PARENTHESIS);
}
}

13
lib/Doctrine/ORM/Query/AST/Functions/SubstringFunction.php
View File

@ -21,6 +21,8 @@
namespace Doctrine\ORM\Query\AST\Functions;
use Doctrine\ORM\Query\Lexer;
/**
* "SUBSTRING" "(" StringPrimary "," SimpleArithmeticExpression "," SimpleArithmeticExpression ")"
*
@ -60,19 +62,20 @@ class SubstringFunction extends FunctionNode
{
$lexer = $parser->getLexer();
$parser->match($lexer->lookahead['value']);
$parser->match('(');
$parser->match(Lexer::T_IDENTIFIER);
$parser->match(Lexer::T_OPEN_PARENTHESIS);
$this->stringPrimary = $parser->StringPrimary();
$parser->match(',');
$parser->match(Lexer::T_COMMA);
$this->firstSimpleArithmeticExpression = $parser->SimpleArithmeticExpression();
$parser->match(',');
$parser->match(Lexer::T_COMMA);
$this->secondSimpleArithmeticExpression = $parser->SimpleArithmeticExpression();
$parser->match(')');
$parser->match(Lexer::T_CLOSE_PARENTHESIS);
}
}

12
lib/Doctrine/ORM/Query/AST/Functions/TrimFunction.php
View File

@ -71,17 +71,17 @@ class TrimFunction extends FunctionNode
{
$lexer = $parser->getLexer();
$parser->match($lexer->lookahead['value']);
$parser->match('(');
$parser->match(Lexer::T_IDENTIFIER);
$parser->match(Lexer::T_OPEN_PARENTHESIS);
if (strcasecmp('leading', $lexer->lookahead['value']) === 0) {
$parser->match($lexer->lookahead['value']);
$parser->match(Lexer::T_LEADING);
$this->leading = true;
} else if (strcasecmp('trailing', $lexer->lookahead['value']) === 0) {
$parser->match($lexer->lookahead['value']);
$parser->match(Lexer::T_TRAILING);
$this->trailing = true;
} else if (strcasecmp('both', $lexer->lookahead['value']) === 0) {
$parser->match($lexer->lookahead['value']);
$parser->match(Lexer::T_BOTH);
$this->both = true;
}
@ -96,7 +96,7 @@ class TrimFunction extends FunctionNode
$this->stringPrimary = $parser->StringPrimary();
$parser->match(')');
$parser->match(Lexer::T_CLOSE_PARENTHESIS);
}
}

8
lib/Doctrine/ORM/Query/AST/Functions/UpperFunction.php
View File

@ -21,6 +21,8 @@
namespace Doctrine\ORM\Query\AST\Functions;
use Doctrine\ORM\Query\Lexer;
/**
* "UPPER" "(" StringPrimary ")"
*
@ -52,12 +54,12 @@ class UpperFunction extends FunctionNode
{
$lexer = $parser->getLexer();
$parser->match($lexer->lookahead['value']);
$parser->match('(');
$parser->match(Lexer::T_IDENTIFIER);
$parser->match(Lexer::T_OPEN_PARENTHESIS);
$this->stringPrimary = $parser->StringPrimary();
$parser->match(')');
$parser->match(Lexer::T_CLOSE_PARENTHESIS);
}
}

173
lib/Doctrine/ORM/Query/Lexer.php
View File

@ -48,59 +48,62 @@ class Lexer extends \Doctrine\Common\Lexer
const T_ASC = 105;
const T_AVG = 106;
const T_BETWEEN = 107;
const T_BY = 108;
const T_CLOSE_PARENTHESIS = 109;
const T_COMMA = 110;
const T_COUNT = 111;
const T_DELETE = 112;
const T_DESC = 113;
const T_DISTINCT = 114;
const T_DIVIDE = 115;
const T_DOT = 116;
const T_EMPTY = 117;
const T_EQUALS = 118;
const T_ESCAPE = 119;
const T_EXISTS = 120;
const T_FALSE = 121;
const T_FROM = 122;
const T_GREATER_THAN = 123;
const T_GROUP = 124;
const T_HAVING = 125;
const T_IN = 126;
const T_INDEX = 127;
const T_INNER = 128;
const T_IS = 129;
const T_JOIN = 130;
const T_LEFT = 131;
const T_LIKE = 132;
const T_LIMIT = 133;
const T_LOWER_THAN = 134;
const T_MAX = 135;
const T_MEMBER = 136;
const T_MIN = 137;
const T_MINUS = 138;
const T_MOD = 139;
const T_MULTIPLY = 140;
const T_NEGATE = 141;
const T_NOT = 142;
const T_NULL = 143;
const T_OF = 144;
const T_OFFSET = 145;
const T_ON = 146;
const T_OPEN_PARENTHESIS = 147;
const T_OR = 148;
const T_ORDER = 149;
const T_OUTER = 150;
const T_PLUS = 151;
const T_SELECT = 152;
const T_SET = 153;
const T_SIZE = 154;
const T_SOME = 155;
const T_SUM = 156;
const T_TRUE = 157;
const T_UPDATE = 158;
const T_WHERE = 159;
const T_WITH = 160;
const T_BOTH = 108;
const T_BY = 109;
const T_CLOSE_PARENTHESIS = 110;
const T_COMMA = 111;
const T_COUNT = 112;
const T_DELETE = 113;
const T_DESC = 114;
const T_DISTINCT = 115;
const T_DIVIDE = 116;
const T_DOT = 117;
const T_EMPTY = 118;
const T_EQUALS = 119;
const T_ESCAPE = 120;
const T_EXISTS = 121;
const T_FALSE = 122;
const T_FROM = 123;
const T_GREATER_THAN = 124;
const T_GROUP = 125;
const T_HAVING = 126;
const T_IN = 127;
const T_INDEX = 128;
const T_INNER = 129;
const T_IS = 130;
const T_JOIN = 131;
const T_LEADING = 132;
const T_LEFT = 133;
const T_LIKE = 134;
const T_LIMIT = 135;
const T_LOWER_THAN = 136;
const T_MAX = 137;
const T_MEMBER = 138;
const T_MIN = 139;
const T_MINUS = 140;
const T_MOD = 141;
const T_MULTIPLY = 142;
const T_NEGATE = 143;
const T_NOT = 144;
const T_NULL = 145;
const T_OF = 146;
const T_OFFSET = 147;
const T_ON = 148;
const T_OPEN_PARENTHESIS = 149;
const T_OR = 150;
const T_ORDER = 151;
const T_OUTER = 152;
const T_PLUS = 153;
const T_SELECT = 154;
const T_SET = 155;
const T_SIZE = 156;
const T_SOME = 157;
const T_SUM = 158;
const T_TRAILING = 159;
const T_TRUE = 160;
const T_UPDATE = 161;
const T_WHERE = 162;
const T_WITH = 163;
private $_keywordsTable;
@ -217,68 +220,4 @@ class Lexer extends \Doctrine\Common\Lexer
return self::T_IDENTIFIER;
}
/**
* Gets the literal for a given token.
*
* @param mixed $token
* @return string
*/
public function getLiteral($token)
{
if ( ! $this->_keywordsTable) {
$this->_keywordsTable = array(
self::T_ALL => "ALL",
self::T_AND => "AND",
self::T_ANY => "ANY",
self::T_AS => "AS",
self::T_ASC => "ASC",
self::T_AVG => "AVG",
self::T_BETWEEN => "BETWEEN",
self::T_BY => "BY",
self::T_COMMA => ",",
self::T_COUNT => "COUNT",
self::T_DELETE => "DELETE",
self::T_DESC => "DESC",
self::T_DISTINCT => "DISTINCT",
self::T_DOT => ".",
self::T_EMPTY => "EMPTY",
self::T_ESCAPE => "ESCAPE",
self::T_EXISTS => "EXISTS",
self::T_FALSE => "FALSE",
self::T_FROM => "FROM",
self::T_GROUP => "GROUP",
self::T_HAVING => "HAVING",
self::T_IN => "IN",
self::T_INDEX => "INDEX",
self::T_INNER => "INNER",
self::T_IS => "IS",
self::T_JOIN => "JOIN",
self::T_LEFT => "LEFT",
self::T_LIKE => "LIKE",
self::T_LIMIT => "LIMIT",
self::T_MAX => "MAX",
self::T_MIN => "MIN",
self::T_MOD => "MOD",
self::T_NOT => "NOT",
self::T_NULL => "NULL",
self::T_OFFSET => "OFFSET",
self::T_ON => "ON",
self::T_OR => "OR",
self::T_ORDER => "ORDER",
self::T_OUTER => "OUTER",
self::T_SELECT => "SELECT",
self::T_SET => "SET",
self::T_SIZE => "SIZE",
self::T_SOME => "SOME",
self::T_SUM => "SUM",
self::T_TRUE => "TRUE",
self::T_UPDATE => "UPDATE",
self::T_WHERE => "WHERE",
self::T_WITH => "WITH");
}
return isset($this->_keywordsTable[$token])
? $this->_keywordsTable[$token]
: (is_string($token) ? $token : '');
}
}

13
lib/Doctrine/ORM/Query/Parser.php
View File

@ -237,9 +237,7 @@ class Parser
*/
public function match($token)
{
$key = (is_string($token)) ? 'value' : 'type';
if ( ! ($this->_lexer->lookahead[$key] === $token)) {
if ( ! ($this->_lexer->lookahead['type'] === $token)) {
$this->syntaxError($this->_lexer->getLiteral($token));
}
@ -334,7 +332,7 @@ class Parser
$message = "line 0, col {$tokenPos}: Error: ";
if ($expected !== '') {
$message .= "Expected '{$expected}', got ";
$message .= "Expected {$expected}, got ";
} else {
$message .= 'Unexpected ';
}
@ -1601,9 +1599,7 @@ class Parser
return new AST\SimpleSelectExpression($this->StateFieldPathExpression());
}
// TODO Fix this!!!
echo 'SimpleSelectExpression: '; var_dump($this->_lexer->lookahead);
$this->match($this->_lexer->lookahead['value']);
$this->match(Lexer::T_IDENTIFIER);
return new AST\SimpleSelectExpression($this->_lexer->token['value']);
}
@ -1696,7 +1692,7 @@ class Parser
{
$condPrimary = new AST\ConditionalPrimary;
if ($this->_lexer->isNextToken('(')) {
if ($this->_lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
// Peek beyond the matching closing paranthesis ')'
$numUnmatched = 1;
$peek = $this->_lexer->peek();
@ -2023,6 +2019,7 @@ class Parser
if ($this->_lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
$this->match(Lexer::T_OPEN_PARENTHESIS);
$expr = $this->SimpleArithmeticExpression();
$this->match(Lexer::T_CLOSE_PARENTHESIS);
return $expr;

6
tests/Doctrine/Tests/Common/Annotations/AnnotationReaderTest.php
View File

@ -62,7 +62,7 @@ class AnnotationReaderTest extends \Doctrine\Tests\DoctrineTestCase
{
$this->setExpectedException(
"Doctrine\Common\Annotations\AnnotationException",
"[Syntax Error] Expected '', got ')' at position 18 in class ".
"[Syntax Error] Expected Doctrine\Common\Annotations\Lexer::T_IDENTIFIER, got ')' at position 18 in class ".
"Doctrine\Tests\Common\Annotations\DummyClassSyntaxError."
);
@ -76,7 +76,7 @@ class AnnotationReaderTest extends \Doctrine\Tests\DoctrineTestCase
{
$this->setExpectedException(
"Doctrine\Common\Annotations\AnnotationException",
"[Syntax Error] Expected '', got ')' at position 18 in ".
"[Syntax Error] Expected Doctrine\Common\Annotations\Lexer::T_IDENTIFIER, got ')' at position 18 in ".
"method Doctrine\Tests\Common\Annotations\DummyClassMethodSyntaxError::foo()."
);
@ -91,7 +91,7 @@ class AnnotationReaderTest extends \Doctrine\Tests\DoctrineTestCase
{
$this->setExpectedException(
"Doctrine\Common\Annotations\AnnotationException",
"[Syntax Error] Expected '', got ')' at position 18 in ".
"[Syntax Error] Expected Doctrine\Common\Annotations\Lexer::T_IDENTIFIER, got ')' at position 18 in ".
"property Doctrine\Tests\Common\Annotations\DummyClassPropertySyntaxError::\$foo."
);

4
tests/Doctrine/Tests/Common/Annotations/ParserTest.php
View File

@ -94,7 +94,7 @@ DOCBLOCK;
{
$this->setExpectedException(
'Doctrine\Common\Annotations\AnnotationException',
"[Syntax Error] Expected 'PlainValue', got ''' at position 10."
"[Syntax Error] Expected PlainValue, got ''' at position 10."
);
$parser = $this->createTestParser();
@ -115,7 +115,7 @@ DOCBLOCK;
{
$this->setExpectedException(
'Doctrine\Common\Annotations\AnnotationException',
"[Syntax Error] Expected 'PlainValue', got ''' at position 10 ".
"[Syntax Error] Expected PlainValue, got ''' at position 10 ".
"in class \Doctrine\Tests\Common\Annotations\Name"
);

4
tests/Doctrine/Tests/ORM/Query/DeleteSqlGenerationTest.php
View File

@ -52,6 +52,10 @@ class DeleteSqlGenerationTest extends \Doctrine\Tests\OrmTestCase
parent::assertEquals($sqlToBeConfirmed, $query->getSql());
$query->free();
} catch (\Exception $e) {
if ($debug) {
echo $e->getTraceAsString() . PHP_EOL;
}
$this->fail($e->getMessage());
}
}

1
tests/Doctrine/Tests/ORM/Query/LanguageRecognitionTest.php
View File

@ -22,6 +22,7 @@ class LanguageRecognitionTest extends \Doctrine\Tests\OrmTestCase
if ($debug) {
echo $e->getTraceAsString() . PHP_EOL;
}
$this->fail($e->getMessage());
}
}

6
tests/Doctrine/Tests/ORM/Query/SelectSqlGenerationTest.php
View File

@ -23,8 +23,10 @@ class SelectSqlGenerationTest extends \Doctrine\Tests\OrmTestCase
parent::assertEquals($sqlToBeConfirmed, $query->getSql());
$query->free();
} catch (Doctrine_Exception $e) {
echo $e->getMessage();
echo $e->getTraceAsString();
if ($debug) {
echo $e->getTraceAsString() . PHP_EOL;
}
$this->fail($e->getMessage());
}
}