Imported Upstream version 2.99.6upstream/2.99.6

1 files changed, 184 insertions, 0 deletions

diff --git a/SQLiteStudio3/coreSQLiteStudio/parser/parsercontext.cpp b/SQLiteStudio3/coreSQLiteStudio/parser/parsercontext.cpp
new file mode 100644
index 0000000..7394e75
--- /dev/null
+++ b/SQLiteStudio3/coreSQLiteStudio/parser/parsercontext.cpp
@@ -0,0 +1,184 @@
+#include "parsercontext.h"
+#include "parsererror.h"
+#include "lexer.h"
+#include <QDebug>
+
+ParserContext::~ParserContext()
+{
+    cleanUp();
+}
+
+void ParserContext::addQuery(SqliteQuery *query)
+{
+    parsedQueries << SqliteQueryPtr(query);
+}
+
+void ParserContext::error(TokenPtr token, const QString &text)
+{
+    if (token->start > -1 && token->end > -1)
+        errors << new ParserError(token, text);
+    else if (managedTokens.size() > 0)
+        errors << new ParserError(managedTokens.last()->start, managedTokens.last()->end + 1, text);
+    else
+        errors << new ParserError(text);
+
+    successful = false;
+}
+
+void ParserContext::error(Token* token, const QString& text)
+{
+    error(getTokenPtr(token), text);
+}
+
+void ParserContext::error(const QString &text)
+{
+    errors << new ParserError(text);
+    successful = false;
+}
+
+void ParserContext::minorErrorAfterLastToken(const QString &text)
+{
+    if (ignoreMinorErrors)
+        return;
+
+    if (managedTokens.isEmpty())
+    {
+        qCritical() << "Tried to report minor error after last token, but there's no tokens!";
+        return;
+    }
+
+    error(managedTokens.last(), text);
+}
+
+void ParserContext::minorErrorBeforeNextToken(const QString &text)
+{
+    if (ignoreMinorErrors)
+        return;
+
+    raiseErrorBeforeNextToken = true;
+    nextTokenError = text;
+}
+
+void ParserContext::errorAfterLastToken(const QString& text)
+{
+    if (managedTokens.isEmpty())
+    {
+        qCritical() << "Tried to report error after last token, but there's no tokens!";
+        return;
+    }
+
+    error(managedTokens.last(), text);
+}
+
+void ParserContext::errorBeforeNextToken(const QString& text)
+{
+    raiseErrorBeforeNextToken = true;
+    nextTokenError = text;
+}
+
+void ParserContext::errorAtToken(const QString& text, int pos)
+{
+    if (managedTokens.isEmpty())
+    {
+        qCritical() << "Tried to report error at token" << pos << ", but there's no tokens!";
+        return;
+    }
+
+    int idx = managedTokens.size() - 1 + pos;
+    if (idx < 0 && idx >= managedTokens.size())
+    {
+        qCritical() << "Tried to report error at token" << pos << ", calculated idx was out of range:" << idx
+                    << "(manages tokens size:" << managedTokens.size() << ").";
+        return;
+    }
+
+    error(managedTokens[idx], text);
+}
+
+void ParserContext::flushErrors()
+{
+    if (raiseErrorBeforeNextToken && !ignoreMinorErrors)
+    {
+        if (managedTokens.size() > 0)
+            error(managedTokens.last(), QObject::tr("Incomplete query."));
+        else
+            error(QObject::tr("Incomplete query."));
+
+        nextTokenError = QString::null;
+        raiseErrorBeforeNextToken = false;
+    }
+}
+
+TokenPtr ParserContext::getTokenPtr(Token* token)
+{
+    if (tokenPtrMap.contains(token))
+        return tokenPtrMap[token];
+
+    TokenPtr tokenPtr = Lexer::getEveryTokenTypePtr(token);
+    if (!tokenPtr.isNull())
+        return tokenPtr;
+
+    qWarning() << "No TokenPtr for Token*. Token asked:" << token->toString();
+    return TokenPtr();
+}
+
+TokenList ParserContext::getTokenPtrList(const QList<Token*>& tokens)
+{
+    TokenList resList;
+    foreach (Token* token, tokens)
+        resList << getTokenPtr(token);
+
+    return resList;
+}
+
+void ParserContext::addManagedToken(TokenPtr token)
+{
+    managedTokens << token;
+    tokenPtrMap[token.data()] = token;
+
+    if (raiseErrorBeforeNextToken)
+    {
+        error(token, nextTokenError);
+        nextTokenError = QString::null;
+        raiseErrorBeforeNextToken = false;
+    }
+}
+
+bool ParserContext::isSuccessful() const
+{
+    return successful;
+}
+
+const QList<SqliteQueryPtr>& ParserContext::getQueries()
+{
+    return parsedQueries;
+}
+
+const QList<ParserError *> &ParserContext::getErrors()
+{
+    return errors;
+}
+
+void ParserContext::cleanUp()
+{
+    foreach (ParserError* err, errors)
+        delete err;
+
+    parsedQueries.clear();
+    errors.clear();
+    managedTokens.clear();
+    nextTokenError.clear();
+    tokenPtrMap.clear();
+    raiseErrorBeforeNextToken = false;
+    successful = true;
+}
+
+bool ParserContext::isManagedToken(Token* token)
+{
+    return tokenPtrMap.contains(token);
+}
+
+TokenList ParserContext::getManagedTokens()
+{
+    return managedTokens;
+}