#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 {
TokenIdentifier,
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 String& currentElement() { return m_currentElement; }
private:
TokenType lex(String&);
TokenType lexIdentifier(String&);
String m_currentElement;
String m_string;
const UChar* m_ptr;
const UChar* m_end;
TokenType m_currentTokenType;
};
IDBKeyPathLexer::TokenType IDBKeyPathLexer::lex(String& element)
{
if (m_ptr >= m_end)
return TokenEnd;
ASSERT(m_ptr < m_end);
if (*m_ptr == '.') {
++m_ptr;
return TokenDot;
}
return lexIdentifier(element);
}
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(String& 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 = String(start, m_ptr - start);
return TokenIdentifier;
}
bool IDBIsValidKeyPath(const String& keyPath)
{
IDBKeyPathParseError error;
Vector<String> keyPathElements;
IDBParseKeyPath(keyPath, keyPathElements, error);
return error == IDBKeyPathParseErrorNone;
}
void IDBParseKeyPath(const String& keyPath, Vector<String>& elements, IDBKeyPathParseError& error)
{
enum ParserState { Identifier, Dot, End };
IDBKeyPathLexer lexer(keyPath);
IDBKeyPathLexer::TokenType tokenType = lexer.nextTokenType();
ParserState state;
if (tokenType == IDBKeyPathLexer::TokenIdentifier)
state = Identifier;
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);
String element = lexer.currentElement();
elements.append(element);
tokenType = lexer.nextTokenType();
if (tokenType == IDBKeyPathLexer::TokenDot)
state = Dot;
else if (tokenType == IDBKeyPathLexer::TokenEnd)
state = End;
else {
error = IDBKeyPathParseErrorIdentifier;
return;
}
break;
}
case Dot: {
IDBKeyPathLexer::TokenType tokenType = lexer.currentTokenType();
ASSERT(tokenType == IDBKeyPathLexer::TokenDot);
tokenType = lexer.nextTokenType();
if (tokenType == IDBKeyPathLexer::TokenIdentifier)
state = Identifier;
else {
error = IDBKeyPathParseErrorDot;
return;
}
break;
}
case End: {
error = IDBKeyPathParseErrorNone;
return;
}
}
}
}
}
#endif // ENABLE(INDEXED_DATABASE)