#include "config.h"
#include "IDBKeyPath.h"
#if ENABLE(INDEXED_DATABASE)
#include <wtf/ASCIICType.h>
#include <wtf/dtoa.h>
namespace WebCore {
class IDBKeyPathLexer {
public:
enum TokenType {
TokenLeftBracket,
TokenRightBracket,
TokenIdentifier,
TokenNumber,
TokenDot,
TokenEnd,
TokenError
};
explicit IDBKeyPathLexer(const String& s)
: m_string(s)
, m_ptr(s.characters())
, m_end(s.characters() + s.length())
, m_currentTokenType(TokenError)
{
}
TokenType currentTokenType() const { return m_currentTokenType; }
TokenType nextTokenType()
{
m_currentTokenType = lex(m_currentElement);
return m_currentTokenType;
}
const IDBKeyPathElement& currentElement() { return m_currentElement; }
private:
TokenType lex(IDBKeyPathElement&);
TokenType lexIdentifier(IDBKeyPathElement&);
TokenType lexNumber(IDBKeyPathElement&);
IDBKeyPathElement m_currentElement;
String m_string;
const UChar* m_ptr;
const UChar* m_end;
TokenType m_currentTokenType;
};
IDBKeyPathLexer::TokenType IDBKeyPathLexer::lex(IDBKeyPathElement& element)
{
while (m_ptr < m_end && isASCIISpace(*m_ptr))
++m_ptr;
if (m_ptr >= m_end)
return TokenEnd;
ASSERT(m_ptr < m_end);
switch (*m_ptr) {
case '[':
++m_ptr;
return TokenLeftBracket;
case ']':
++m_ptr;
return TokenRightBracket;
case '.':
++m_ptr;
return TokenDot;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
return lexNumber(element);
default:
return lexIdentifier(element);
}
return TokenError;
}
static inline bool isSafeIdentifierStartCharacter(UChar c)
{
return isASCIIAlpha(c) || (c == '_') || (c == '$');
}
static inline bool isSafeIdentifierCharacter(UChar c)
{
return isASCIIAlphanumeric(c) || (c == '_') || (c == '$');
}
IDBKeyPathLexer::TokenType IDBKeyPathLexer::lexIdentifier(IDBKeyPathElement& element)
{
const UChar* start = m_ptr;
if (m_ptr < m_end && isSafeIdentifierStartCharacter(*m_ptr))
++m_ptr;
else
return TokenError;
while (m_ptr < m_end && isSafeIdentifierCharacter(*m_ptr))
++m_ptr;
element.type = IDBKeyPathElement::IsNamed;
element.identifier = String(start, m_ptr - start);
return TokenIdentifier;
}
IDBKeyPathLexer::TokenType IDBKeyPathLexer::lexNumber(IDBKeyPathElement& element)
{
if (m_ptr >= m_end)
return TokenError;
const UChar* start = m_ptr;
while (m_ptr < m_end && isASCIIDigit(*m_ptr))
++m_ptr;
String numberAsString;
numberAsString = String(start, m_ptr - start);
bool ok = false;
unsigned number = numberAsString.toUIntStrict(&ok);
if (!ok)
return TokenError;
element.type = IDBKeyPathElement::IsIndexed;
element.index = number;
return TokenNumber;
}
void IDBParseKeyPath(const String& keyPath, Vector<IDBKeyPathElement>& elements, IDBKeyPathParseError& error)
{
enum ParserState { Identifier, Array, Dot, End };
IDBKeyPathLexer lexer(keyPath);
IDBKeyPathLexer::TokenType tokenType = lexer.nextTokenType();
ParserState state;
if (tokenType == IDBKeyPathLexer::TokenIdentifier)
state = Identifier;
else if (tokenType == IDBKeyPathLexer::TokenLeftBracket)
state = Array;
else if (tokenType == IDBKeyPathLexer::TokenEnd)
state = End;
else {
error = IDBKeyPathParseErrorStart;
return;
}
while (1) {
switch (state) {
case Identifier : {
IDBKeyPathLexer::TokenType tokenType = lexer.currentTokenType();
ASSERT(tokenType == IDBKeyPathLexer::TokenIdentifier);
IDBKeyPathElement element = lexer.currentElement();
ASSERT(element.type == IDBKeyPathElement::IsNamed);
elements.append(element);
tokenType = lexer.nextTokenType();
if (tokenType == IDBKeyPathLexer::TokenDot)
state = Dot;
else if (tokenType == IDBKeyPathLexer::TokenLeftBracket)
state = Array;
else if (tokenType == IDBKeyPathLexer::TokenEnd)
state = End;
else {
error = IDBKeyPathParseErrorIdentifier;
return;
}
break;
}
case Array : {
IDBKeyPathLexer::TokenType tokenType = lexer.currentTokenType();
ASSERT(tokenType == IDBKeyPathLexer::TokenLeftBracket);
tokenType = lexer.nextTokenType();
if (tokenType != IDBKeyPathLexer::TokenNumber) {
error = IDBKeyPathParseErrorArrayIndex;
return;
}
ASSERT(tokenType == IDBKeyPathLexer::TokenNumber);
IDBKeyPathElement element = lexer.currentElement();
ASSERT(element.type == IDBKeyPathElement::IsIndexed);
elements.append(element);
tokenType = lexer.nextTokenType();
if (tokenType != IDBKeyPathLexer::TokenRightBracket) {
error = IDBKeyPathParseErrorArrayIndex;
return;
}
tokenType = lexer.nextTokenType();
if (tokenType == IDBKeyPathLexer::TokenDot)
state = Dot;
else if (tokenType == IDBKeyPathLexer::TokenLeftBracket)
state = Array;
else if (tokenType == IDBKeyPathLexer::TokenEnd)
state = End;
else {
error = IDBKeyPathParseErrorAfterArray;
return;
}
break;
}
case Dot: {
IDBKeyPathLexer::TokenType tokenType = lexer.currentTokenType();
ASSERT(tokenType == IDBKeyPathLexer::TokenDot);
tokenType = lexer.nextTokenType();
if (tokenType != IDBKeyPathLexer::TokenIdentifier) {
error = IDBKeyPathParseErrorDot;
return;
}
state = Identifier;
break;
}
case End: {
error = IDBKeyPathParseErrorNone;
return;
}
}
}
}
}
#endif // ENABLE(INDEXED_DATABASE)