//TODO: look at using the property cache here (as in the compiler)
// for further optimization
QMetaMethod signal = QMetaObjectPrivate::signal(m_target->metaObject(), m_index);
- QQmlRewrite::RewriteSignalHandler rewriter;
+ QQmlRewrite::RewriteSignalHandler rewriter(ep->v4engine());
QString expression;
bool ok = true;
store.signalIndex = prop->index;
const QList<QByteArray> ¶meterNameList = obj->metatype->signalParameterNames(prop->index);
- QQmlRewrite::RewriteSignalHandler rewriter;
+ QQmlRewrite::RewriteSignalHandler rewriter(enginePrivate->v4engine());
int count = 0;
const QString &rewrite = rewriter(v->value.asAST(), v->value.asScript(),
prop->name().toString(),
QString QQmlCompiler::rewriteSignalHandler(const QQmlScript::Variant& value, const QString &name)
{
- QQmlRewrite::RewriteSignalHandler rewriteSignalHandler;
+ QQmlRewrite::RewriteSignalHandler rewriteSignalHandler(enginePrivate->v4engine());
return rewriteSignalHandler(value.asAST(), value.asScript(), name);
}
tr("Property names cannot begin with an upper case letter"));
}
- if (enginePrivate->v8engine()->illegalNames().contains(prop.name)) {
+ if (enginePrivate->v8engine()->illegalNames().contains(prop.name.toString())) {
COMPILE_EXCEPTION_LOCATION(prop.nameLocation.line,
prop.nameLocation.column,
tr("Illegal property name"));
if (currSig.name.at(0).isUpper())
COMPILE_EXCEPTION(&currSig, tr("Signal names cannot begin with an upper case letter"));
- if (enginePrivate->v8engine()->illegalNames().contains(currSig.name))
+ if (enginePrivate->v8engine()->illegalNames().contains(currSig.name.toString()))
COMPILE_EXCEPTION(&currSig, tr("Illegal signal name"));
}
if (currSlot.name.at(0).isUpper())
COMPILE_EXCEPTION(&currSlot, tr("Method names cannot begin with an upper case letter"));
- if (enginePrivate->v8engine()->illegalNames().contains(currSlot.name))
+ if (enginePrivate->v8engine()->illegalNames().contains(currSlot.name.toString()))
COMPILE_EXCEPTION(&currSlot, tr("Illegal method name"));
}
signalData->arguments = args;
}
- QQmlRewrite::RewriteSignalHandler rewriter;
QQmlEnginePrivate *ep = QQmlEnginePrivate::get(engine);
+ QQmlRewrite::RewriteSignalHandler rewriter(ep->v4engine());
const QString ¶meters = rewriter.createParameterString(parameterNameList,
ep->v8engine()->illegalNames());
to perform a second rewrite with the parameter information (using createParameterString)
once the target object is known.
*/
-RewriteSignalHandler::RewriteSignalHandler()
+RewriteSignalHandler::RewriteSignalHandler(QV4::ExecutionEngine *engine)
: _writer(0)
, _code(0)
, _position(0)
+ , _parameterNames(engine)
, _parameterAccess(UnknownAccess)
, _parameterCountForJS(0)
{
return false;
static const QString argumentsString = QStringLiteral("arguments");
- if (_parameterNames.contains(e->name) || e->name == argumentsString)
+ if (_parameterNames.contains(e->name.toString()) || e->name == argumentsString)
_parameterAccess = ParametersAccessed;
return false;
}
//create a parameter string which can be inserted into a generic rewrite
QString RewriteSignalHandler::createParameterString(const QList<QByteArray> ¶meterNameList,
- const QStringHash<bool> &illegalNames)
-{
- QList<QHashedString> hashedParameterNameList;
- for (int i = 0; i < parameterNameList.count(); ++i)
- hashedParameterNameList.append(QString::fromUtf8(parameterNameList.at(i).constData()));
-
- return createParameterString(hashedParameterNameList, illegalNames);
-}
-
-QString RewriteSignalHandler::createParameterString(const QList<QHashedString> ¶meterNameList,
- const QStringHash<bool> &illegalNames)
+ const QV4::IdentifierHash<bool> &illegalNames)
{
QString parameters;
bool unnamedParam = false;
for (int i = 0; i < parameterNameList.count(); ++i) {
- const QHashedString ¶m = parameterNameList.at(i);
+ QString param = QString::fromUtf8(parameterNameList.at(i));
if (param.isEmpty())
unnamedParam = true;
else if (unnamedParam)
QString RewriteSignalHandler::operator()(QQmlJS::AST::Node *node, const QString &code, const QString &name,
const QString ¶meterString,
const QList<QByteArray> ¶meterNameList,
- const QStringHash<bool> &illegalNames)
+ const QV4::IdentifierHash<bool> &illegalNames)
{
if (rewriteDump()) {
qWarning() << "=============================================================";
if (!parameterNameList.isEmpty()) {
for (int i = 0; i < parameterNameList.count(); ++i) {
- QHashedString param(QString::fromUtf8(parameterNameList.at(i).constData()));
- _parameterNames.insert(param, i);
+ QString param(QString::fromUtf8(parameterNameList.at(i).constData()));
+ _parameterNames.add(param, i);
if (!hasParameterString)
- _parameterNameList.append(param);
+ _parameterNameList.append(parameterNameList.at(i));
}
//this is set to Unaccessed here, and will be set to Accessed
QString RewriteSignalHandler::operator()(const QString &code, const QString &name, bool *ok,
const QList<QByteArray> ¶meterNameList,
- const QStringHash<bool> &illegalNames)
+ const QV4::IdentifierHash<bool> &illegalNames)
{
Engine engine;
Lexer lexer(&engine);
#include <private/qqmljslexer_p.h>
#include <private/qqmljsparser_p.h>
#include <private/qqmljsmemorypool_p.h>
-#include <private/qhashedstring_p.h>
+#include <private/qv4identifier_p.h>
QT_BEGIN_NAMESPACE
class RewriteSignalHandler: protected AST::Visitor
{
public:
- RewriteSignalHandler();
+ RewriteSignalHandler(QV4::ExecutionEngine *engine);
QString operator()(QQmlJS::AST::Node *node, const QString &code, const QString &name,
const QString ¶meterString = QString(),
const QList<QByteArray> ¶meterNameList = QList<QByteArray>(),
- const QStringHash<bool> &illegalNames = QStringHash<bool>());
+ const QV4::IdentifierHash<bool> &illegalNames = QV4::IdentifierHash<bool>());
QString operator()(const QString &code, const QString &name, bool *ok = 0,
const QList<QByteArray> ¶meterNameList = QList<QByteArray>(),
- const QStringHash<bool> &illegalNames = QStringHash<bool>());
+ const QV4::IdentifierHash<bool> &illegalNames = QV4::IdentifierHash<bool>());
enum ParameterAccess {
ParametersAccessed,
int parameterCountForJS() const { return _parameterCountForJS; }
ParameterAccess parameterAccess() const { return _parameterAccess; }
QString createParameterString(const QList<QByteArray> ¶meterNameList,
- const QStringHash<bool> &illegalNames);
+ const QV4::IdentifierHash<bool> &illegalNames);
bool hasParameterError() { return !_error.isEmpty(); }
QString parameterError() const { return _error; }
virtual bool visit(AST::IdentifierExpression *);
private:
- QString createParameterString(const QList<QHashedString> ¶meterNameList,
- const QStringHash<bool> &illegalNames);
-
TextWriter *_writer;
const QString *_code;
int _position;
- QStringHash<int> _parameterNames;
- QList<QHashedString> _parameterNameList;
+ QV4::IdentifierHash<int> _parameterNames;
+ QList<QByteArray> _parameterNameList;
ParameterAccess _parameterAccess;
int _parameterCountForJS;
QString _error;
const IdentifierHashEntry *IdentifierHashBase::lookup(const Identifier *identifier) const
{
+ if (!d)
+ return 0;
assert(d->entries);
uint idx = Identifier::hash(identifier) % d->alloc;
const IdentifierHashEntry *IdentifierHashBase::lookup(const QString &str) const
{
+ if (!d)
+ return 0;
return lookup(d->identifierTable->identifier(str));
}
const IdentifierHashEntry *IdentifierHashBase::lookup(String *str) const
{
+ if (!d)
+ return 0;
return lookup(d->identifierTable->identifier(str));
}
return QQmlEnginePrivate::get(m_engine)->getNetworkAccessManager();
}
-const QStringHash<bool> &QV8Engine::illegalNames() const
+const QV4::IdentifierHash<bool> &QV8Engine::illegalNames() const
{
return m_illegalNames;
}
qt_add_sqlexceptions(m_v4Engine);
{
+ m_illegalNames = QV4::IdentifierHash<bool>(m_v4Engine);
for (uint i = 0; i < m_v4Engine->globalObject->internalClass->size; ++i)
- m_illegalNames.insert(m_v4Engine->globalObject->internalClass->nameMap.at(i)->toQString(), true);
+ m_illegalNames.add(m_v4Engine->globalObject->internalClass->nameMap.at(i)->toQString(), true);
}
{
#include <private/qv4qobjectwrapper_p.h>
#include <private/qv4value_p.h>
#include <private/qv4object_p.h>
+#include <private/qv4identifier_p.h>
QT_BEGIN_NAMESPACE
virtual QNetworkAccessManager *networkAccessManager();
// Return the list of illegal id names (the names of the properties on the global object)
- const QStringHash<bool> &illegalNames() const;
+ const QV4::IdentifierHash<bool> &illegalNames() const;
inline void collectGarbage() { gc(); }
void gc();
QVector<Deletable *> m_extensionData;
Deletable *m_listModelData;
- QStringHash<bool> m_illegalNames;
+ QV4::IdentifierHash<bool> m_illegalNames;
QElapsedTimer m_time;
QHash<QString, qint64> m_startedTimers;