mirror of
https://github.com/cappuccino/cappuccino.git
synced 2026-08-25 13:07:02 +00:00
977 lines
29 KiB
Plaintext
977 lines
29 KiB
Plaintext
/*
|
||
* CPPredicate.j
|
||
*
|
||
* CPPredicate parsing based on NSPredicate.m in GNUStep Base Library (http://www.gnustep.org/)
|
||
* Copyright (c) 2005 Free Software Foundation.
|
||
*
|
||
* Created by cacaodev.
|
||
* Copyright 2010.
|
||
*
|
||
* This library is free software; you can redistribute it and/or
|
||
* modify it under the terms of the GNU Lesser General Public
|
||
* License as published by the Free Software Foundation; either
|
||
* version 2.1 of the License, or (at your option) any later version.
|
||
*
|
||
* This library is distributed in the hope that it will be useful,
|
||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
* Lesser General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU Lesser General Public
|
||
* License along with this library; if not, write to the Free Software
|
||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||
*/
|
||
|
||
@import "CPArray.j"
|
||
@import "CPException.j"
|
||
@import "CPNull.j"
|
||
@import "CPObject.j"
|
||
@import "CPScanner.j"
|
||
@import "CPSet.j"
|
||
@import "CPValue.j"
|
||
@import "CPCharacterSet.j"
|
||
@import "CPComparisonPredicate_Constants.j"
|
||
@import "CPCompoundPredicate_Constants.j"
|
||
@import "_CPExpression.j"
|
||
|
||
@class CPCompoundPredicate
|
||
@class CPComparisonPredicate
|
||
@class _CPKeyPathExpression
|
||
@class _CPSubqueryExpression
|
||
|
||
|
||
/*!
|
||
@ingroup foundation
|
||
@class CPPredicate
|
||
@brief The CPPredicate class is used to define logical conditions used to constrain a search either for a fetch or for in-memory filtering.
|
||
|
||
You use predicates to represent logical conditions, used for describing objects in persistent stores
|
||
and in-memory filtering of objects. Although it is common to create predicates directly from instances
|
||
of CPComparisonPredicate, CPCompoundPredicate, and CPExpression, you often create predicates from a
|
||
format string which is parsed by the class methods on CPPredicate. Examples of predicate format strings include:
|
||
|
||
- Simple comparisons, such as <code>grade == "7"</code> or <code>firstName like "Shaffiq"</code>
|
||
- Case/diacritic insensitive lookups, such as <code>name contains[cd] "itroen"</code>
|
||
- Logical operations, such as <code>(firstName like "Mark") OR (lastName like "Adderley")</code>
|
||
- “Between” predicates such as <code>date between {$YESTERDAY, $TOMORROW}</code>.
|
||
|
||
You can create predicates for relationships, such as:
|
||
|
||
- <code>group.name like "work*"</code>
|
||
- <code>ALL children.age > 12</code>
|
||
- <code>ANY children.age > 12</code>
|
||
|
||
You can create predicates for operations, such as <code>\@sum.items.price < 1000</code>.
|
||
|
||
You can also create predicates that include variables, so that the predicate can be pre-defined before
|
||
substituting concrete values at runtime with the \c evaluateWithObject:substitutionVariables: method.
|
||
*/
|
||
|
||
@implementation CPPredicate : CPObject
|
||
{
|
||
}
|
||
|
||
/*!
|
||
Creates and returns a new predicate formed by creating a new string with a given format and parsing the result.
|
||
@param format The format string for the new predicate.
|
||
@param … A comma-separated list of arguments to substitute into format.
|
||
@return A new predicate formed by creating a new string with format and parsing the result.
|
||
*/
|
||
+ (CPPredicate)predicateWithFormat:(CPString)format, ...
|
||
{
|
||
if (!format)
|
||
[CPException raise:CPInvalidArgumentException reason:_cmd + " the format can't be 'nil'"];
|
||
|
||
var args = Array.prototype.slice.call(arguments, 3);
|
||
return [self predicateWithFormat:arguments[2] argumentArray:args];
|
||
}
|
||
|
||
/*!
|
||
Creates and returns a new predicate by substituting the values in a given array into a format string and parsing the result.
|
||
@param format The format string for the new predicate.
|
||
@param arguments The arguments to substitute into predicateFormat. Values are substituted into predicateFormat in the order they appear in the array.
|
||
@return A new predicate by substituting the values in arguments into predicateFormat, and parsing the result.
|
||
*/
|
||
+ (CPPredicate)predicateWithFormat:(CPString)format argumentArray:(CPArray)args
|
||
{
|
||
if (!format)
|
||
[CPException raise:CPInvalidArgumentException reason:_cmd + " the format can't be 'nil'"];
|
||
|
||
var s = [[CPPredicateScanner alloc] initWithString:format args:args],
|
||
p = [s parse];
|
||
|
||
return p;
|
||
}
|
||
|
||
/*!
|
||
Creates and returns a new predicate by substituting the values in an argument list into a format string and parsing the result.
|
||
@param format The format string for the new predicate.
|
||
@param argList The arguments to substitute into predicateFormat. Values are substituted into predicateFormat in the order they appear in the argument list.
|
||
@return A new predicate by substituting the values in argList into predicateFormat and parsing the result.
|
||
*/
|
||
+ (CPPredicate)predicateWithFormat:(CPString)format arguments:(va_list)argList
|
||
{
|
||
// UNIMPLEMENTED
|
||
return nil;
|
||
}
|
||
|
||
/*!
|
||
Returns a copy of the receiver with the receiver’s variables substituted by values specified in a given substitution variables dictionary.
|
||
@param variables The substitution variables dictionary. The dictionary must contain key-value pairs for all variables in the receiver.
|
||
@return A copy of the receiver with the receiver’s variables substituted by values specified in variables.
|
||
*/
|
||
- (CPPredicate)predicateWithSubstitutionVariables:(CPDictionary)variables
|
||
{
|
||
// IMPLEMENTED BY SUBCLASSES
|
||
}
|
||
|
||
/*!
|
||
Creates and returns a predicate that always evaluates to a given value.
|
||
@param value The value to which the new predicate should evaluate.
|
||
@return A predicate that always evaluates to value.
|
||
*/
|
||
+ (CPPredicate)predicateWithValue:(BOOL)value
|
||
{
|
||
return [[CPPredicate_BOOL alloc] initWithBool:value];
|
||
}
|
||
|
||
// Evaluating a Predicate
|
||
/*!
|
||
Returns a Boolean value that indicates whether a given object matches the conditions specified by the receiver.
|
||
@param object The object against which to evaluate the receiver.
|
||
@return YES if object matches the conditions specified by the receiver, otherwise NO.
|
||
*/
|
||
- (BOOL)evaluateWithObject:(id)object
|
||
{
|
||
// IMPLEMENTED BY SUBCLASSES
|
||
}
|
||
|
||
/*!
|
||
Returns a Boolean value that indicates whether a given object matches the conditions specified by the receiver after substituting in the values in a given variables dictionary.
|
||
@param object The object against which to evaluate the receiver.
|
||
@param variables The substitution variables dictionary. The dictionary must contain key-value pairs for all variables in the receiver.
|
||
@return YES if object matches the conditions specified by the receiver after substituting in the values in variables for any replacement tokens, otherwise NO.
|
||
*/
|
||
- (BOOL)evaluateWithObject:(id)object substitutionVariables:(CPDictionary)variables
|
||
{
|
||
// IMPLEMENTED BY SUBCLASSES
|
||
}
|
||
|
||
// Getting Format Information
|
||
/*!
|
||
Returns the receiver’s format string.
|
||
@return The receiver’s format string.
|
||
*/
|
||
- (CPString)predicateFormat
|
||
{
|
||
// IMPLEMENTED BY SUBCLASSES
|
||
}
|
||
|
||
- (CPString)description
|
||
{
|
||
return [self predicateFormat];
|
||
}
|
||
|
||
@end
|
||
|
||
@implementation CPPredicate_BOOL : CPPredicate
|
||
{
|
||
BOOL _value;
|
||
}
|
||
|
||
- (id)initWithBool:(BOOL)value
|
||
{
|
||
_value = value;
|
||
return self;
|
||
}
|
||
|
||
- (BOOL)isEqual:(id)anObject
|
||
{
|
||
if (self === anObject)
|
||
return YES;
|
||
|
||
if (self.isa !== anObject.isa || _value !== [anObject evaluateWithObject:nil])
|
||
return NO;
|
||
|
||
return YES;
|
||
}
|
||
|
||
- (BOOL)evaluateWithObject:(id)object
|
||
{
|
||
return _value;
|
||
}
|
||
|
||
- (BOOL)evaluateWithObject:(id)object substitutionVariables:(CPDictionary)variables
|
||
{
|
||
return _value;
|
||
}
|
||
|
||
- (CPString)predicateFormat
|
||
{
|
||
return (_value) ? @"TRUEPREDICATE" : @"FALSEPREDICATE";
|
||
}
|
||
|
||
@end
|
||
|
||
|
||
@implementation CPArray (CPPredicate)
|
||
|
||
- (CPArray)filteredArrayUsingPredicate:(CPPredicate)predicate
|
||
{
|
||
var count = [self count],
|
||
result = [CPArray array],
|
||
i = 0;
|
||
|
||
for (; i < count; i++)
|
||
{
|
||
var object = [self objectAtIndex:i];
|
||
if ([predicate evaluateWithObject:object])
|
||
result.push(object);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
- (void)filterUsingPredicate:(CPPredicate)predicate
|
||
{
|
||
var count = [self count];
|
||
|
||
while (count--)
|
||
{
|
||
if (![predicate evaluateWithObject:[self objectAtIndex:count]])
|
||
self.splice(count, 1);
|
||
}
|
||
}
|
||
|
||
@end
|
||
|
||
@implementation CPSet (CPPredicate)
|
||
|
||
- (CPSet)filteredSetUsingPredicate:(CPPredicate)predicate
|
||
{
|
||
var count = [self count],
|
||
result = [CPSet set],
|
||
i = 0;
|
||
|
||
for (; i < count; i++)
|
||
{
|
||
var object = [self objectAtIndex:i];
|
||
|
||
if ([predicate evaluateWithObject:object])
|
||
[result addObject:object];
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
- (void)filterUsingPredicate:(CPPredicate)predicate
|
||
{
|
||
var count = [self count];
|
||
|
||
while (--count >= 0)
|
||
{
|
||
var object = [self objectAtIndex:count];
|
||
|
||
if (![predicate evaluateWithObject:object])
|
||
[self removeObjectAtIndex:count];
|
||
}
|
||
}
|
||
|
||
@end
|
||
|
||
@implementation CPPredicateScanner : CPScanner
|
||
{
|
||
CPEnumerator _args;
|
||
unsigned _retrieved;
|
||
}
|
||
|
||
- (id)initWithString:(CPString)format args:(CPArray)args
|
||
{
|
||
self = [super initWithString:format]
|
||
|
||
if (self)
|
||
{
|
||
_args = [args objectEnumerator];
|
||
}
|
||
return self;
|
||
}
|
||
|
||
- (id)nextArg
|
||
{
|
||
return [_args nextObject];
|
||
}
|
||
|
||
- (BOOL)scanPredicateKeyword:(CPString)key
|
||
{
|
||
var loc = [self scanLocation];
|
||
|
||
[self setCaseSensitive:NO];
|
||
if (![self scanString:key intoString:NULL])
|
||
return NO;
|
||
|
||
if ([self isAtEnd])
|
||
return YES;
|
||
|
||
var c = [[self string] characterAtIndex:[self scanLocation]];
|
||
if (![[CPCharacterSet alphanumericCharacterSet] characterIsMember:c])
|
||
return YES;
|
||
|
||
[self setScanLocation:loc];
|
||
|
||
return NO;
|
||
}
|
||
|
||
- (CPPredicate)parse
|
||
{
|
||
var r = nil;
|
||
|
||
try
|
||
{
|
||
[self setCharactersToBeSkipped:[CPCharacterSet whitespaceCharacterSet]];
|
||
r = [self parsePredicate];
|
||
}
|
||
catch(error)
|
||
{
|
||
CPLogConsole(@"Unable to parse predicate '" + [self string] + "' with " + error);
|
||
}
|
||
finally
|
||
{
|
||
if (![self isAtEnd])
|
||
{
|
||
var pstr = [self string],
|
||
loc = [self scanLocation];
|
||
CPLogConsole(@"Format string contains extra characters: '" + [pstr substringToIndex:loc] + "**" + [pstr substringFromIndex:loc] + "**'");
|
||
}
|
||
}
|
||
|
||
return r;
|
||
}
|
||
|
||
- (CPPredicate)parsePredicate
|
||
{
|
||
return [self parseAnd];
|
||
}
|
||
|
||
- (CPPredicate)parseAnd
|
||
{
|
||
var l = [self parseOr];
|
||
|
||
while ([self scanPredicateKeyword:@"AND"] || [self scanPredicateKeyword:@"&&"])
|
||
{
|
||
var r = [self parseOr];
|
||
|
||
if ([r isKindOfClass:[CPCompoundPredicate class]] && [r compoundPredicateType] == CPAndPredicateType)
|
||
{
|
||
if ([l isKindOfClass:[CPCompoundPredicate class]] && [l compoundPredicateType] == CPAndPredicateType)
|
||
{
|
||
[[l subpredicates] addObjectsFromArray:[r subpredicates]];
|
||
}
|
||
else
|
||
{
|
||
[[r subpredicates] insertObject:l atIndex:0];
|
||
l = r;
|
||
}
|
||
}
|
||
else if ([l isKindOfClass:[CPCompoundPredicate class]] && [l compoundPredicateType] == CPAndPredicateType)
|
||
{
|
||
[[l subpredicates] addObject:r];
|
||
}
|
||
else
|
||
{
|
||
l = [CPCompoundPredicate andPredicateWithSubpredicates:[CPArray arrayWithObjects:l, r]];
|
||
}
|
||
}
|
||
return l;
|
||
}
|
||
|
||
- (CPPredicate)parseNot
|
||
{
|
||
if ([self scanString:@"(" intoString:NULL])
|
||
{
|
||
var r = [self parsePredicate];
|
||
|
||
if (![self scanString:@")" intoString:NULL])
|
||
CPRaiseParseError(self, @"predicate");
|
||
|
||
return r;
|
||
}
|
||
|
||
if ([self scanPredicateKeyword:@"NOT"] || [self scanPredicateKeyword:@"!"])
|
||
{
|
||
return [CPCompoundPredicate notPredicateWithSubpredicate:[self parseNot]];
|
||
}
|
||
if ([self scanPredicateKeyword:@"TRUEPREDICATE"])
|
||
{
|
||
return [CPPredicate predicateWithValue:YES];
|
||
}
|
||
if ([self scanPredicateKeyword:@"FALSEPREDICATE"])
|
||
{
|
||
return [CPPredicate predicateWithValue:NO];
|
||
}
|
||
|
||
return [self parseComparison];
|
||
}
|
||
|
||
- (CPPredicate)parseOr
|
||
{
|
||
var l = [self parseNot];
|
||
while ([self scanPredicateKeyword:@"OR"] || [self scanPredicateKeyword:@"||"])
|
||
{
|
||
var r = [self parseNot];
|
||
|
||
if ([r isKindOfClass:[CPCompoundPredicate class]] && [r compoundPredicateType] == CPOrPredicateType)
|
||
{
|
||
if ([l isKindOfClass:[CPCompoundPredicate class]] && [l compoundPredicateType] == CPOrPredicateType)
|
||
{
|
||
[[l subpredicates] addObjectsFromArray:[r subpredicates]];
|
||
}
|
||
else
|
||
{
|
||
[[r subpredicates] insertObject:l atIndex:0];
|
||
l = r;
|
||
}
|
||
}
|
||
else if ([l isKindOfClass:[CPCompoundPredicate class]] && [l compoundPredicateType] == CPOrPredicateType)
|
||
{
|
||
[[l subpredicates] addObject:r];
|
||
}
|
||
else
|
||
{
|
||
l = [CPCompoundPredicate orPredicateWithSubpredicates:[CPArray arrayWithObjects:l, r]];
|
||
}
|
||
}
|
||
return l;
|
||
}
|
||
|
||
- (CPPredicate)parseComparison
|
||
{
|
||
var modifier = CPDirectPredicateModifier,
|
||
type = 0,
|
||
opts = 0,
|
||
left,
|
||
right,
|
||
p,
|
||
negate = NO;
|
||
|
||
if ([self scanPredicateKeyword:@"ANY"])
|
||
{
|
||
modifier = CPAnyPredicateModifier;
|
||
}
|
||
else if ([self scanPredicateKeyword:@"ALL"])
|
||
{
|
||
modifier = CPAllPredicateModifier;
|
||
}
|
||
else if ([self scanPredicateKeyword:@"NONE"])
|
||
{
|
||
modifier = CPAnyPredicateModifier;
|
||
negate = YES;
|
||
}
|
||
else if ([self scanPredicateKeyword:@"SOME"])
|
||
{
|
||
modifier = CPAllPredicateModifier;
|
||
negate = YES;
|
||
}
|
||
|
||
left = [self parseExpression];
|
||
if ([self scanString:@"!=" intoString:NULL] || [self scanString:@"<>" intoString:NULL])
|
||
{
|
||
type = CPNotEqualToPredicateOperatorType;
|
||
}
|
||
else if ([self scanString:@"<=" intoString:NULL] || [self scanString:@"=<" intoString:NULL])
|
||
{
|
||
type = CPLessThanOrEqualToPredicateOperatorType;
|
||
}
|
||
else if ([self scanString:@">=" intoString:NULL] || [self scanString:@"=>" intoString:NULL])
|
||
{
|
||
type = CPGreaterThanOrEqualToPredicateOperatorType;
|
||
}
|
||
else if ([self scanString:@"<" intoString:NULL])
|
||
{
|
||
type = CPLessThanPredicateOperatorType;
|
||
}
|
||
else if ([self scanString:@">" intoString:NULL])
|
||
{
|
||
type = CPGreaterThanPredicateOperatorType;
|
||
}
|
||
else if ([self scanString:@"==" intoString:NULL] || [self scanString:@"=" intoString:NULL])
|
||
{
|
||
type = CPEqualToPredicateOperatorType;
|
||
}
|
||
else if ([self scanPredicateKeyword:@"MATCHES"])
|
||
{
|
||
type = CPMatchesPredicateOperatorType;
|
||
}
|
||
else if ([self scanPredicateKeyword:@"LIKE"])
|
||
{
|
||
type = CPLikePredicateOperatorType;
|
||
}
|
||
else if ([self scanPredicateKeyword:@"BEGINSWITH"])
|
||
{
|
||
type = CPBeginsWithPredicateOperatorType;
|
||
}
|
||
else if ([self scanPredicateKeyword:@"ENDSWITH"])
|
||
{
|
||
type = CPEndsWithPredicateOperatorType;
|
||
}
|
||
else if ([self scanPredicateKeyword:@"IN"])
|
||
{
|
||
type = CPInPredicateOperatorType;
|
||
}
|
||
else if ([self scanPredicateKeyword:@"CONTAINS"])
|
||
{
|
||
type = CPContainsPredicateOperatorType;
|
||
}
|
||
else if ([self scanPredicateKeyword:@"BETWEEN"])
|
||
{
|
||
type = CPBetweenPredicateOperatorType;
|
||
}
|
||
else
|
||
CPRaiseParseError(self, @"comparison predicate");
|
||
|
||
if ([self scanString:@"[cd]" intoString:NULL])
|
||
{
|
||
opts = CPCaseInsensitivePredicateOption | CPDiacriticInsensitivePredicateOption;
|
||
}
|
||
else if ([self scanString:@"[c]" intoString:NULL])
|
||
{
|
||
opts = CPCaseInsensitivePredicateOption;
|
||
}
|
||
else if ([self scanString:@"[d]" intoString:NULL])
|
||
{
|
||
opts = CPDiacriticInsensitivePredicateOption;
|
||
}
|
||
|
||
right = [self parseExpression];
|
||
|
||
p = [CPComparisonPredicate predicateWithLeftExpression:left
|
||
rightExpression:right
|
||
modifier:modifier
|
||
type:type
|
||
options:opts];
|
||
|
||
return negate ? [CPCompoundPredicate notPredicateWithSubpredicate:p]:p;
|
||
}
|
||
|
||
- (CPExpression)parseExpression
|
||
{
|
||
return [self parseBinaryExpression];
|
||
}
|
||
|
||
- (CPExpression)parseSimpleExpression
|
||
{
|
||
var identifier,
|
||
location,
|
||
ident,
|
||
dbl;
|
||
|
||
if ([self scanDouble:@ref(dbl)])
|
||
return [CPExpression expressionForConstantValue:dbl];
|
||
|
||
// FIXME: handle integer, hex constants, 0x 0o 0b
|
||
if ([self scanString:@"-" intoString:NULL])
|
||
return [CPExpression expressionForFunction:@"chs:" arguments:[CPArray arrayWithObject:[self parseExpression]]];
|
||
|
||
if ([self scanString:@"(" intoString:NULL])
|
||
{
|
||
var arg = [self parseExpression];
|
||
|
||
if (![self scanString:@")" intoString:NULL])
|
||
CPRaiseParseError(self, @"expression");
|
||
|
||
return arg;
|
||
}
|
||
|
||
if ([self scanString:@"{" intoString:NULL])
|
||
{
|
||
var a = [];
|
||
|
||
if ([self scanString:@"}" intoString:NULL])
|
||
return [CPExpression expressionForConstantValue:a];
|
||
|
||
[a addObject:[self parseExpression]];
|
||
|
||
while ([self scanString:@"," intoString:NULL])
|
||
[a addObject:[self parseExpression]];
|
||
|
||
if (![self scanString:@"}" intoString:NULL])
|
||
CPRaiseParseError(self, @"expression");
|
||
|
||
return [CPExpression expressionForAggregate:a];
|
||
}
|
||
|
||
if ([self scanPredicateKeyword:@"NULL"] || [self scanPredicateKeyword:@"NIL"])
|
||
{
|
||
return [CPExpression expressionForConstantValue:[CPNull null]];
|
||
}
|
||
if ([self scanPredicateKeyword:@"TRUE"] || [self scanPredicateKeyword:@"YES"])
|
||
{
|
||
return [CPExpression expressionForConstantValue:[CPNumber numberWithBool:YES]];
|
||
}
|
||
if ([self scanPredicateKeyword:@"FALSE"] || [self scanPredicateKeyword:@"NO"])
|
||
{
|
||
return [CPExpression expressionForConstantValue:[CPNumber numberWithBool:NO]];
|
||
}
|
||
if ([self scanPredicateKeyword:@"SELF"])
|
||
{
|
||
return [CPExpression expressionForEvaluatedObject];
|
||
}
|
||
|
||
if ([self scanString:@"$" intoString:NULL])
|
||
{
|
||
var variable = [self parseSimpleExpression];
|
||
|
||
if (![variable keyPath])
|
||
CPRaiseParseError(self, @"expression");
|
||
|
||
return [CPExpression expressionForVariable:variable];
|
||
}
|
||
|
||
location = [self scanLocation];
|
||
|
||
if ([self scanString:@"%" intoString:NULL])
|
||
{
|
||
if ([self isAtEnd] == NO)
|
||
{
|
||
var c = [[self string] characterAtIndex:[self scanLocation]];
|
||
|
||
switch (c)
|
||
{
|
||
case '%':// '%%' is treated as '%'
|
||
location = [self scanLocation];
|
||
break;
|
||
case 'K':
|
||
[self setScanLocation:[self scanLocation] + 1];
|
||
return [CPExpression expressionForKeyPath:[self nextArg]];
|
||
case '@':
|
||
case 'c':
|
||
case 'C':
|
||
case 'd':
|
||
case 'D':
|
||
case 'i':
|
||
case 'o':
|
||
case 'O':
|
||
case 'u':
|
||
case 'U':
|
||
case 'x':
|
||
case 'X':
|
||
case 'e':
|
||
case 'E':
|
||
case 'f':
|
||
case 'g':
|
||
case 'G':
|
||
[self setScanLocation:[self scanLocation] + 1];
|
||
return [CPExpression expressionForConstantValue:[self nextArg]];
|
||
case 'h':
|
||
[self scanString:@"h" intoString:NULL];
|
||
if ([self isAtEnd] == NO)
|
||
{
|
||
c = [[self string] characterAtIndex:[self scanLocation]];
|
||
if (c == 'i' || c == 'u')
|
||
{
|
||
[self setScanLocation:[self scanLocation] + 1];
|
||
return [CPExpression expressionForConstantValue:[self nextArg]];
|
||
}
|
||
}
|
||
break;
|
||
case 'q':
|
||
[self scanString:@"q" intoString:NULL];
|
||
if ([self isAtEnd] == NO)
|
||
{
|
||
c = [[self string] characterAtIndex:[self scanLocation]];
|
||
if (c == 'i' || c == 'u' || c == 'x' || c == 'X')
|
||
{
|
||
[self setScanLocation:[self scanLocation] + 1];
|
||
return [CPExpression expressionForConstantValue:[self nextArg]];
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
[self setScanLocation:location];
|
||
}
|
||
|
||
if ([self scanString:@"\"" intoString:NULL])
|
||
{
|
||
var skip = [self charactersToBeSkipped],
|
||
str = @"";
|
||
|
||
[self setCharactersToBeSkipped:nil];
|
||
[self scanUpToString:@"\"" intoString:@ref(str)];
|
||
|
||
if ([self scanString:@"\"" intoString:NULL] == NO)
|
||
CPRaiseParseError(self, @"expression");
|
||
|
||
[self setCharactersToBeSkipped:skip];
|
||
|
||
return [CPExpression expressionForConstantValue:str];
|
||
}
|
||
|
||
if ([self scanString:@"'" intoString:NULL])
|
||
{
|
||
var skip = [self charactersToBeSkipped],
|
||
str = @"";
|
||
|
||
[self setCharactersToBeSkipped:nil];
|
||
[self scanUpToString:@"'" intoString:@ref(str)];
|
||
|
||
if ([self scanString:@"'" intoString:NULL] == NO)
|
||
CPRaiseParseError(self, @"expression");
|
||
|
||
[self setCharactersToBeSkipped:skip];
|
||
|
||
return [CPExpression expressionForConstantValue:str];
|
||
}
|
||
|
||
if ([self scanString:@"@" intoString:NULL])
|
||
{
|
||
var e = [self parseExpression];
|
||
|
||
if (![e keyPath])
|
||
CPRaiseParseError(self, @"expression");
|
||
|
||
return [CPExpression expressionForKeyPath:[e keyPath] + "@"];
|
||
}
|
||
|
||
if ([self scanString:@"SUBQUERY" intoString:NULL])
|
||
{
|
||
if (![self scanString:@"(" intoString:NULL])
|
||
CPRaiseParseError(self, @"expression");
|
||
|
||
var collection = [self parseExpression],
|
||
variableExpression,
|
||
subpredicate;
|
||
|
||
if (![self scanString:@"," intoString:NULL])
|
||
CPRaiseParseError(self, @"expression");
|
||
variableExpression = [self parseExpression];
|
||
|
||
if (![self scanString:@"," intoString:NULL])
|
||
CPRaiseParseError(self, @"expression");
|
||
subpredicate = [self parsePredicate];
|
||
|
||
if (![self scanString:@")" intoString:NULL])
|
||
CPRaiseParseError(self, @"expression");
|
||
|
||
return [[_CPSubqueryExpression alloc] initWithExpression:collection usingIteratorExpression:variableExpression predicate:subpredicate];
|
||
}
|
||
|
||
if ([self scanString:@"FUNCTION" intoString:NULL])
|
||
{
|
||
if (![self scanString:@"(" intoString:NULL])
|
||
CPRaiseParseError(self, @"expression");
|
||
|
||
var args = [CPArray arrayWithObject:[self parseExpression]];
|
||
while ([self scanString:@"," intoString:NULL])
|
||
[args addObject:[self parseExpression]];
|
||
|
||
if (![self scanString:@")" intoString:NULL] || [args count] < 2 || [args[1] expressionType] != CPConstantValueExpressionType)
|
||
CPRaiseParseError(self, @"expression");
|
||
|
||
return [CPExpression expressionForFunction:args[0] selectorName:[args[1] constantValue] arguments:args.slice(2)];
|
||
}
|
||
|
||
[self scanString:@"#" intoString:NULL];
|
||
if (!identifier)
|
||
identifier = [CPCharacterSet characterSetWithCharactersInString:@"_$abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"];
|
||
|
||
if (![self scanCharactersFromSet:identifier intoString:@ref(ident)])
|
||
CPRaiseParseError(self, @"expression");
|
||
|
||
return [CPExpression expressionForKeyPath:ident];
|
||
}
|
||
|
||
- (CPExpression)parseFunctionalExpression
|
||
{
|
||
var left = [self parseSimpleExpression];
|
||
|
||
while (YES)
|
||
{
|
||
if ([self scanString:@"." intoString:NULL])
|
||
{
|
||
var right = [self parseSimpleExpression],
|
||
expressionType = [right expressionType];
|
||
|
||
if (expressionType == CPKeyPathExpressionType)
|
||
left = [[_CPKeyPathExpression alloc] initWithOperand:left andKeyPath:[right keyPath]];
|
||
else if (expressionType == CPVariableExpressionType)
|
||
left = [CPExpression expressionForFunction:left selectorName:@"valueForKey:" arguments:[right]];
|
||
else
|
||
CPRaiseParseError(self, @"expression");
|
||
}
|
||
else if ([self scanString:@"[" intoString:NULL])
|
||
{
|
||
// index expression
|
||
if ([self scanPredicateKeyword:@"FIRST"])
|
||
{
|
||
left = [CPExpression expressionForFunction:@"first:" arguments:[CPArray arrayWithObject:left]];
|
||
}
|
||
else if ([self scanPredicateKeyword:@"LAST"])
|
||
{
|
||
left = [CPExpression expressionForFunction:@"last:" arguments:[CPArray arrayWithObject:left]];
|
||
}
|
||
else if ([self scanPredicateKeyword:@"SIZE"])
|
||
{
|
||
left = [CPExpression expressionForFunction:@"count:" arguments:[CPArray arrayWithObject:left]];
|
||
}
|
||
else
|
||
{
|
||
var index = [self parseExpression];
|
||
left = [CPExpression expressionForFunction:@"fromObject:index:" arguments:[CPArray arrayWithObjects:left, index]];
|
||
}
|
||
|
||
if (![self scanString:@"]" intoString:NULL])
|
||
CPRaiseParseError(self, @"expression");
|
||
}
|
||
else if ([self scanString:@":" intoString:NULL])
|
||
{
|
||
// function - this parser allows for (max)(a, b, c) to be properly
|
||
// recognized and even (%K)(a, b, c) if %K evaluates to "max"
|
||
|
||
if (![left keyPath])
|
||
CPRaiseParseError(self, @"expression");
|
||
|
||
var selector = [left keyPath] + @":",
|
||
args = [];
|
||
|
||
if (![self scanString:@"(" intoString:NULL])
|
||
{
|
||
var str;
|
||
[self scanCharactersFromSet:[CPCharacterSet lowercaseLetterCharacterSet] intoString:@ref(str)];
|
||
|
||
if (![self scanString:@":(" intoString:NULL])
|
||
CPRaiseParseError(self, @"expression");
|
||
|
||
selector += str + @":";
|
||
}
|
||
|
||
if (![self scanString:@")" intoString:NULL])
|
||
{
|
||
[args addObject:[self parseExpression]];
|
||
while ([self scanString:@"," intoString:NULL])
|
||
[args addObject:[self parseExpression]];
|
||
|
||
if (![self scanString:@")" intoString:NULL])
|
||
CPRaiseParseError(self, @"expression");
|
||
}
|
||
|
||
left = [CPExpression expressionForFunction:selector arguments:args];
|
||
}
|
||
else if ([self scanString:@"UNION" intoString:NULL])
|
||
{
|
||
left = [CPExpression expressionForUnionSet:left with:[self parseExpression]];
|
||
}
|
||
else if ([self scanString:@"INTERSECT" intoString:NULL])
|
||
{
|
||
left = [CPExpression expressionForIntersectSet:left with:[self parseExpression]];
|
||
}
|
||
else if ([self scanString:@"MINUS" intoString:NULL])
|
||
{
|
||
left = [CPExpression expressionForMinusSet:left with:[self parseExpression]];
|
||
}
|
||
else
|
||
{
|
||
// done with suffixes
|
||
return left;
|
||
}
|
||
}
|
||
}
|
||
|
||
- (CPExpression)parsePowerExpression
|
||
{
|
||
var left = [self parseFunctionalExpression];
|
||
|
||
while (YES)
|
||
{
|
||
var right;
|
||
|
||
if ([self scanString:@"**" intoString:NULL])
|
||
{
|
||
right = [self parseFunctionalExpression];
|
||
left = [CPExpression expressionForFunction:@"raise:to:" arguments:[CPArray arrayWithObjects:left, right]];
|
||
}
|
||
else
|
||
{
|
||
return left;
|
||
}
|
||
}
|
||
}
|
||
|
||
- (CPExpression)parseMultiplicationExpression
|
||
{
|
||
var left = [self parsePowerExpression];
|
||
|
||
while (YES)
|
||
{
|
||
var right;
|
||
|
||
if ([self scanString:@"*" intoString:NULL])
|
||
{
|
||
right = [self parsePowerExpression];
|
||
left = [CPExpression expressionForFunction:@"multiply:by:" arguments:[CPArray arrayWithObjects:left, right]];
|
||
}
|
||
else if ([self scanString:@"/" intoString:NULL])
|
||
{
|
||
right = [self parsePowerExpression];
|
||
left = [CPExpression expressionForFunction:@"divide:by:" arguments:[CPArray arrayWithObjects:left, right]];
|
||
}
|
||
else
|
||
{
|
||
return left;
|
||
}
|
||
}
|
||
}
|
||
|
||
- (CPExpression)parseAdditionExpression
|
||
{
|
||
var left = [self parseMultiplicationExpression];
|
||
|
||
while (YES)
|
||
{
|
||
var right;
|
||
|
||
if ([self scanString:@"+" intoString:NULL])
|
||
{
|
||
right = [self parseMultiplicationExpression];
|
||
left = [CPExpression expressionForFunction:@"add:to:" arguments:[CPArray arrayWithObjects:left, right]];
|
||
}
|
||
else if ([self scanString:@"-" intoString:NULL])
|
||
{
|
||
right = [self parseMultiplicationExpression];
|
||
left = [CPExpression expressionForFunction:@"from:substract:" arguments:[CPArray arrayWithObjects:left, right]];
|
||
}
|
||
else
|
||
{
|
||
return left;
|
||
}
|
||
}
|
||
}
|
||
|
||
- (CPExpression)parseBinaryExpression
|
||
{
|
||
var left = [self parseAdditionExpression];
|
||
|
||
while (YES)
|
||
{
|
||
var right;
|
||
|
||
if ([self scanString:@":=" intoString:NULL]) // assignment
|
||
{
|
||
// check left to be a variable?
|
||
right = [self parseAdditionExpression];
|
||
// FIXME
|
||
}
|
||
else
|
||
{
|
||
return left;
|
||
}
|
||
}
|
||
}
|
||
|
||
@end
|
||
|
||
var CPRaiseParseError = function CPRaiseParseError(aScanner, target)
|
||
{
|
||
[CPException raise:CPInvalidArgumentException reason:@"unable to parse " + target + " at index " + [aScanner scanLocation]];
|
||
};
|