QSourceLocation AccelTreeBuilder<FromDocument>::sourceLocation() const
{
if(m_documentURI.isEmpty())
return QSourceLocation(QUrl(QLatin1String("AnonymousNodeTree")));
else
return QSourceLocation(m_documentURI);
}
void CSVAtlasWindow::fileSave()
{
if(_filename.isEmpty())
{
fileSaveAs();
if(_filename.isEmpty())
return;
}
sMapChanged(_map->currentIndex());
QDomDocument doc = QDomDocument("openCSVAtlasDef");
doc.appendChild(_atlas->createElement(doc));
QFile file(_filename);
if(file.open(QIODevice::WriteOnly))
{
QTextStream ts(&file);
ts << doc.toString();
file.close();
}
else
_msghandler->message(QtWarningMsg, tr("Error Opening File"),
tr("<p>Could not open the file %1 for writing: %2")
.arg(_filename, file.errorString()),
QUrl::fromLocalFile(_filename), QSourceLocation());
}
void tst_QAbstractMessageHandler::message() const
{
TestMessageHandler handler;
/* Check that the arguments comes out as expected. */
handler.message(QtDebugMsg,
QLatin1String("A description"),
QUrl(QLatin1String("http://example.com/ID")),
QSourceLocation(QUrl(QLatin1String("http://example.com/Location")), 4, 5));
Received expected;
expected.type = QtDebugMsg;
expected.description = QLatin1String("A description");
expected.identifier = QUrl(QLatin1String("http://example.com/ID"));
expected.sourceLocation = QSourceLocation(QUrl(QLatin1String("http://example.com/Location")), 4, 5);
QCOMPARE(expected, handler.received.first());
}
void tst_QAbstractMessageHandler::messageDefaultArguments() const
{
TestMessageHandler handler;
/* The three last arguments in message() are optional. Check that they are what we promise. */
handler.message(QtDebugMsg, QLatin1String("A description"));
Received expected;
expected.type = QtDebugMsg;
expected.description = QLatin1String("A description");
expected.identifier = QUrl();
expected.sourceLocation = QSourceLocation();
QCOMPARE(expected, handler.received.first());
}
void tst_QSourceLocation::equalnessOperator_data() const
{
QTest::addColumn<QSourceLocation>("v1");
QTest::addColumn<QSourceLocation>("v2");
QTest::addColumn<bool>("True");
{
QTest::newRow("Default constructed values")
<< QSourceLocation()
<< QSourceLocation()
<< true;
}
{
QSourceLocation modified;
modified.setColumn(4);
QTest::newRow("Default constructed, against column-modified")
<< QSourceLocation()
<< modified
<< false;
}
{
QSourceLocation modified;
modified.setLine(5);
QTest::newRow("Default constructed, against line-modified")
<< QSourceLocation()
<< modified
<< false;
}
{
QSourceLocation modified;
modified.setUri(QUrl(QLatin1String("http://example.com/")));
QTest::newRow("Default constructed, against line-modified")
<< QSourceLocation()
<< modified
<< false;
}
{
QSourceLocation modified;
modified.setUri(QUrl(QLatin1String("http://example.com/")));
modified.setLine(5);
modified.setColumn(4);
QTest::newRow("Default constructed, against all-modified")
<< QSourceLocation()
<< modified
<< false;
}
}
void tst_QSourceLocation::debugStream_data() const
{
QTest::addColumn<QSourceLocation>("location");
QTest::addColumn<QString>("expected");
{
QTest::newRow("Default constructed instance")
<< QSourceLocation()
<< QString::fromLatin1("QSourceLocation( QUrl( \"\" ) , line: -1 , column: -1 ) ");
}
{
QSourceLocation location(QUrl(QLatin1String("http://example.com/")), 4, 5);
QTest::newRow("Properties set")
<< location
<< QString::fromLatin1("QSourceLocation( QUrl( \"http://example.com/\" ) , line: 4 , column: 5 ) ");
}
}
static PyObject *meth_QAbstractMessageHandler_message(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
PyObject *sipParseErr = NULL;
{
QtMsgType a0;
const QString* a1;
int a1State = 0;
const QUrl& a2def = QUrl();
const QUrl* a2 = &a2def;
const QSourceLocation& a3def = QSourceLocation();
const QSourceLocation* a3 = &a3def;
QAbstractMessageHandler *sipCpp;
static const char *sipKwdList[] = {
NULL,
NULL,
sipName_identifier,
sipName_sourceLocation,
};
if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BEJ1|J9J9", &sipSelf, sipType_QAbstractMessageHandler, &sipCpp, sipType_QtMsgType, &a0, sipType_QString,&a1, &a1State, sipType_QUrl, &a2, sipType_QSourceLocation, &a3))
{
Py_BEGIN_ALLOW_THREADS
sipCpp->message(a0,*a1,*a2,*a3);
Py_END_ALLOW_THREADS
sipReleaseType(const_cast<QString *>(a1),sipType_QString,a1State);
Py_INCREF(Py_None);
return Py_None;
}
}
/* Raise an exception if the arguments couldn't be parsed. */
sipNoMethod(sipParseErr, sipName_QAbstractMessageHandler, sipName_message, doc_QAbstractMessageHandler_message);
return NULL;
}
void tst_QSourceLocation::withQHash() const
{
QCOMPARE(qHash(QSourceLocation()), qHash(QSourceLocation()));
}
Expression::Ptr ExpressionFactory::createExpression(const Tokenizer::Ptr &tokenizer,
const StaticContext::Ptr &context,
const QXmlQuery::QueryLanguage lang,
const SequenceType::Ptr &requiredType,
const QUrl &queryURI,
const QXmlName &initialTemplateName)
{
Q_ASSERT(context);
Q_ASSERT(requiredType);
Q_ASSERT(queryURI.isValid());
Tokenizer::Ptr effectiveTokenizer(tokenizer);
#ifdef Patternist_DEBUG
effectiveTokenizer = Tokenizer::Ptr(new TokenRevealer(queryURI, tokenizer));
#endif
OptimizationPasses::Coordinator::init();
const ParserContext::Ptr info(new ParserContext(context, lang, effectiveTokenizer.data()));
info->initialTemplateName = initialTemplateName;
effectiveTokenizer->setParserContext(info);
const int bisonRetval = QPatternist::XPathparse(info.data());
Q_ASSERT_X(bisonRetval == 0, Q_FUNC_INFO,
"We shouldn't be able to get an error, because we throw exceptions.");
Q_UNUSED(bisonRetval); /* Needed when not compiled in debug mode, since bisonRetval won't
* be used in the Q_ASSERT_X above. */
Expression::Ptr result(info->queryBody);
if(!result)
{
context->error(QtXmlPatterns::tr("A library module cannot be evaluated "
"directly. It must be imported from a "
"main module."),
ReportContext::XPST0003,
QSourceLocation(queryURI, 1, 1));
}
/* Optimization: I think many things are done in the wrong order below. We
* probably want everything typechecked before compressing, since we can
* have references all over the place(variable references, template
* invocations, function callsites). This could even be a source to bugs.
*/
/* Here, we type check user declared functions and global variables. This
* means that variables and functions that are not used are type
* checked(which they otherwise wouldn't have been), and those which are
* used, are type-checked twice, unfortunately. */
const bool hasExternalFocus = context->contextItemType();
if(lang == QXmlQuery::XSLT20)
{
/* Bind xsl:call-template instructions to their template bodies.
*
* We do this before type checking and compressing them, because a
* CallTemplate obviously needs its template before being compressed.
*
* Also, we do this before type checking and compressing user
* functions, since they can contain template call sites.
*/
for(int i = 0; i < info->templateCalls.count(); ++i)
{
CallTemplate *const site = info->templateCalls.at(i)->as<CallTemplate>();
const QXmlName targetName(site->name());
const Template::Ptr t(info->namedTemplates.value(targetName));
if(t)
site->setTemplate(t);
else
{
context->error(QtXmlPatterns::tr("No template by name %1 exists.").arg(formatKeyword(context->namePool(), targetName)),
ReportContext::XTSE0650,
site);
}
}
}
/* Type check and compress user functions. */
{
const UserFunction::List::const_iterator end(info->userFunctions.constEnd());
UserFunction::List::const_iterator it(info->userFunctions.constBegin());
/* If the query has a focus(which is common, in the case of a
* stylesheet), we must ensure that the focus isn't visible in the
* function body. */
StaticContext::Ptr effectiveContext;
if(hasExternalFocus)
{
effectiveContext = StaticContext::Ptr(new StaticFocusContext(ItemType::Ptr(),
context));
}
else
effectiveContext = context;
for(; it != end; ++it)
{
pDebug() << "----- User Function Typecheck -----";
registerLastPath((*it)->body());
/* We will most likely call body()->typeCheck() again, once for
* each callsite. That is, it will be called from
* UserFunctionCallsite::typeCheck(), which will be called
* indirectly when we check the query body. */
const Expression::Ptr typeCheck((*it)->body()->typeCheck(effectiveContext,
(*it)->signature()->returnType()));
/* We don't have to call (*it)->setBody(typeCheck) here since it's
* only used directly below. */
processTreePass(typeCheck, UserFunctionTypeCheck);
pDebug() << "------------------------------";
pDebug() << "----- User Function Compress -----";
const Expression::Ptr comp(typeCheck->compress(effectiveContext));
(*it)->setBody(comp);
processTreePass(comp, UserFunctionCompression);
pDebug() << "------------------------------";
}
}
/* Type check and compress global variables. */
{
const VariableDeclaration::Stack::const_iterator vend(info->variables.constEnd());
VariableDeclaration::Stack::const_iterator vit(info->variables.constBegin());
for(; vit != vend; ++vit)
{
Q_ASSERT(*vit);
/* This is a bit murky, the global variable will have it
* Expression::typeCheck() function called from all its references,
* but we also want to check it here globally, so we do
* typechecking using a proper focus. */
if((*vit)->type == VariableDeclaration::ExternalVariable)
continue;
pDebug() << "----- Global Variable Typecheck -----";
Q_ASSERT((*vit)->expression());
/* We supply ZeroOrMoreItems, meaning the variable can evaluate to anything. */
// FIXME which is a source to bugs
// TODO What about compressing variables?
const Expression::Ptr
nev((*vit)->expression()->typeCheck(context, CommonSequenceTypes::ZeroOrMoreItems));
processTreePass(nev, GlobalVariableTypeCheck);
pDebug() << "------------------------------";
}
}
/* Do all tests specific to XSL-T. */
if(lang == QXmlQuery::XSLT20)
{
/* Type check and compress named templates. */
{
pDebug() << "Have " << info->namedTemplates.count() << "named templates";
QMutableHashIterator<QXmlName, Template::Ptr> it(info->namedTemplates);
while(it.hasNext())
{
it.next();
processNamedTemplate(it.key(), it.value()->body, TemplateInitial);
it.value()->body = it.value()->body->typeCheck(context, CommonSequenceTypes::ZeroOrMoreItems);
processNamedTemplate(it.key(), it.value()->body, TemplateTypeCheck);
it.value()->body = it.value()->body->compress(context);
processNamedTemplate(it.key(), it.value()->body, TemplateCompress);
it.value()->compileParameters(context);
}
}
/* Type check and compress template rules. */
{
QHashIterator<QXmlName, TemplateMode::Ptr> it(info->templateRules);
/* Since a pattern can exist of AxisStep, its typeCheck() stage
* requires a focus. In the case that we're invoked with a name but
* no focus, this will yield a compile error, unless we declare a
* focus manually. This only needs to be done for the pattern
* expression, since the static type of the pattern is used as the
* static type for the focus of the template body. */
StaticContext::Ptr patternContext;
if(hasExternalFocus)
patternContext = context;
else
patternContext = StaticContext::Ptr(new StaticFocusContext(BuiltinTypes::node, context));
/* For each template pattern. */
while(it.hasNext())
{
it.next();
const TemplateMode::Ptr &mode = it.value();
const int len = mode->templatePatterns.count();
TemplatePattern::ID currentTemplateID = -1;
bool hasDoneItOnce = false;
/* For each template pattern. */
for(int i = 0; i < len; ++i)
{
/* We can't use references for these two members, since we
* assign to them. */
const TemplatePattern::Ptr &pattern = mode->templatePatterns.at(i);
Expression::Ptr matchPattern(pattern->matchPattern());
processTemplateRule(pattern->templateTarget()->body,
pattern, mode->name(), TemplateInitial);
matchPattern = matchPattern->typeCheck(patternContext, CommonSequenceTypes::ZeroOrMoreItems);
matchPattern = matchPattern->compress(patternContext);
pattern->setMatchPattern(matchPattern);
if(currentTemplateID == -1 && hasDoneItOnce)
{
currentTemplateID = pattern->id();
continue;
}
else if(currentTemplateID == pattern->id() && hasDoneItOnce)
{
hasDoneItOnce = false;
continue;
}
hasDoneItOnce = true;
currentTemplateID = pattern->id();
Expression::Ptr body(pattern->templateTarget()->body);
/* Patterns for a new template has started, we must
* deal with the body & parameters. */
{
/* TODO type is wrong, it has to be the union of all
* patterns. */
const StaticContext::Ptr focusContext(new StaticFocusContext(matchPattern->staticType()->itemType(),
context));
body = body->typeCheck(focusContext, CommonSequenceTypes::ZeroOrMoreItems);
pattern->templateTarget()->compileParameters(focusContext);
}
processTemplateRule(body, pattern, mode->name(), TemplateTypeCheck);
body = body->compress(context);
pattern->templateTarget()->body = body;
processTemplateRule(body, pattern, mode->name(), TemplateCompress);
}
mode->finalize();
}
}
/* Add templates in mode #all to all other modes.
*
* We do this after the templates has been typechecked and compressed,
* since otherwise it will be done N times for the built-in templates,
* where N is the count of different templates, instead of once. */
{
const QXmlName nameModeAll(QXmlName(StandardNamespaces::InternalXSLT,
StandardLocalNames::all));
const TemplateMode::Ptr &modeAll = info->templateRules[nameModeAll];
Q_ASSERT_X(modeAll, Q_FUNC_INFO,
"We should at least have the builtin templates.");
QHashIterator<QXmlName, TemplateMode::Ptr> it(info->templateRules);
while(it.hasNext())
{
it.next();
/* Don't add mode #all to mode #all. */
if(it.key() == nameModeAll)
continue;
it.value()->addMode(modeAll);
}
}
}
/* Type check and compress the query body. */
{
pDebug() << "----- Initial AST build. -----";
processTreePass(result, QueryBodyInitial);
pDebug() << "------------------------------";
pDebug() << "----- Type Check -----";
registerLastPath(result);
result->rewrite(result, result->typeCheck(context, requiredType), context);
processTreePass(result, QueryBodyTypeCheck);
pDebug() << "------------------------------";
pDebug() << "----- Compress -----";
result->rewrite(result, result->compress(context), context);
processTreePass(result, QueryBodyCompression);
pDebug() << "------------------------------";
}
return result;
}
void CSVAtlasWindow::fileOpen(QString filename)
{
if (DEBUG)
qDebug("CSVAtlasWindow::fileOpen(%s) entered with old _filename [%s]",
qPrintable(filename), qPrintable(_filename));
if (! filename.isEmpty())
{
if (! QFile::exists(filename))
{
QString fullpath = _currentDir + QDir::separator() + filename;
if (DEBUG)
qDebug("CSVAtlasWindow::fileOpen() retrying with [%s]",
qPrintable(fullpath));
if (QFile::exists(fullpath))
filename = fullpath;
else
filename = QString::null;
}
}
if (filename.isEmpty())
filename = QFileDialog::getOpenFileName(this, tr("Open Atlas File"),
_currentDir,
QString("XML Files (*.xml);;All files (*)"));
if (filename.isEmpty())
return;
_map->clear();
sMapChanged(0);
if(_atlas)
{
delete _atlas;
_atlas = 0;
}
QFile file(filename);
QDomDocument doc = QDomDocument();
QString errMsg;
int errLine, errCol;
if(doc.setContent(&file, &errMsg, &errLine, &errCol))
{
_atlas = new CSVAtlas(doc.documentElement());
_map->addItems(_atlas->mapList());
sMapChanged(0);
_filename = filename;
_currentDir = QFileInfo(_filename).absoluteDir().absolutePath();
}
else
_msghandler->message(QtWarningMsg, tr("Error Reading File"),
tr("<p>An error was encountered while trying to read "
"the Atlas file: %1.").arg(errMsg),
QUrl::fromLocalFile(filename),
QSourceLocation(QUrl::fromLocalFile(filename),
errLine, errCol));
if(!_atlas)
_atlas = new CSVAtlas();
}
void CSVAtlasWindow::sMapChanged( int )
{
CSVMap map;
if(!_selectedMap.isEmpty())
{
map = _atlas->map(_selectedMap);
if(tr("Insert") == _action->currentText())
map.setAction(CSVMap::Insert);
else if(tr("Update") == _action->currentText())
map.setAction(CSVMap::Update);
else if(tr("Append") == _action->currentText())
map.setAction(CSVMap::Append);
map.setDescription(_description->toPlainText());
map.setSqlPre(_preSql->toPlainText().trimmed());
map.setSqlPreContinueOnError(_sqlPreContinueOnError->isChecked());
map.setSqlPost(_postSql->toPlainText().trimmed());
for(int r = 0; r < _fields->rowCount(); r++)
{
CSVMapField field = map.field(_fields->item(r, 1)->data(Qt::EditRole).toString());
field.setName(_fields->item(r, 1)->data(Qt::EditRole).toString());
if (qobject_cast<QCheckBox*>(_fields->cellWidget(r, 0)))
field.setIsKey(qobject_cast<QCheckBox*>(_fields->cellWidget(r,0))->isChecked());
else
field.setIsKey(FALSE);
field.setType(QVariant::nameToType(_fields->item(r, 2)->data(Qt::EditRole).toString().toAscii().data()));
if (qobject_cast<QComboBox*>(_fields->cellWidget(r, 4)))
field.setAction(CSVMapField::nameToAction(qobject_cast<QComboBox*>(_fields->cellWidget(r, 4))->currentText()));
else
field.setAction(CSVMapField::Action_Default);
if (qobject_cast<QSpinBox*>(_fields->cellWidget(r, 5)))
field.setColumn(qobject_cast<QSpinBox*>(_fields->cellWidget(r,5))->value());
else
field.setColumn(0);
if (qobject_cast<QComboBox*>(_fields->cellWidget(r, 6)))
field.setIfNullAction(CSVMapField::nameToIfNull(qobject_cast<QComboBox*>(_fields->cellWidget(r, 6))->currentText()));
else
field.setIfNullAction(CSVMapField::Nothing);
if (qobject_cast<QSpinBox*>(_fields->cellWidget(r, 7)))
field.setColumnAlt(qobject_cast<QSpinBox*>(_fields->cellWidget(r, 7))->value());
else
field.setColumnAlt(1);
if (qobject_cast<QComboBox*>(_fields->cellWidget(r, 8)))
field.setIfNullActionAlt(CSVMapField::nameToIfNull(qobject_cast<QComboBox*>(_fields->cellWidget(r, 8))->currentText()));
else
field.setIfNullActionAlt(CSVMapField::Nothing);
field.setValueAlt(_fields->item(r, 9)->data(Qt::EditRole).toString());
map.setField(field);
}
map.simplify();
_atlas->setMap(map);
}
QSqlDatabase db = QSqlDatabase::database();
if (db.isValid())
{
_fields->setRowCount(0);
if(_map->count() && ! _map->currentText().isEmpty())
{
// CODE TO SELECT MAP
_selectedMap = _map->currentText();
map = _atlas->map(_selectedMap);
_table->setTitle(tr("Table: ") + map.table());
_table->setEnabled(TRUE);
_action->setCurrentIndex(map.action());
_description->setText(map.description());
_preSql->setText(map.sqlPre());
_sqlPreContinueOnError->setChecked(map.sqlPreContinueOnError());
_postSql->setText(map.sqlPost());
QSqlRecord record = db.record(map.table());
QStringList fieldnames;
if (record.isEmpty())
{
_msghandler->message(QtWarningMsg, tr("No Existing Table"),
tr("<p>The table %1 does not exist in this "
"database. You may continue to use and edit "
"this map but only those fields that are known "
"will be shown.").arg(map.table()),
QUrl(), QSourceLocation());
fieldnames = map.fieldList();
}
else
{
QStringList fList = map.fieldList();
for(int i = 0; i < fList.size(); ++i)
{
CSVMapField f = map.field(fList.at(i));
if(!record.contains(fList.at(i)))
{
map.removeField(fList.at(i));
MissingField diag(this, f.name(), record);
if(diag.exec() == QDialog::Accepted)
{
f.setName(diag._fields->currentText());
map.setField(f);
}
_atlas->setMap(map);
}
}
for (int i = 0; i < record.count(); i++)
fieldnames.append(record.fieldName(i));
}
_fields->setRowCount(fieldnames.size());
for(int row = 0; row < fieldnames.size(); ++row)
{
CSVMapField mf = map.field(fieldnames.at(row));
QCheckBox *check = new QCheckBox(_fields);
if(!mf.isEmpty())
check->setChecked(mf.isKey());
_fields->setCellWidget(row, 0, check);
_fields->setItem(row, 1, new QTableWidgetItem(fieldnames.at(row)));
if (record.isEmpty())
{
_fields->setItem(row, 2,
new QTableWidgetItem(QVariant::typeToName(mf.type())));
_fields->setItem(row, 3, new QTableWidgetItem(tr("Unknown")));
}
else
{
_fields->setItem(row, 2,
new QTableWidgetItem(QVariant::typeToName(record.field(row).type())));
_fields->setItem(row, 3, new QTableWidgetItem(
(record.field(row).requiredStatus() == QSqlField::Required) ? tr("Yes") :
(record.field(row).requiredStatus() == QSqlField::Optional) ? tr("No") :
tr("Unknown")));
}
QComboBox *actcombo = new QComboBox(_fields);
actcombo->addItems(CSVMapField::actionList());
if (! mf.isEmpty())
actcombo->setCurrentIndex(mf.action());
_fields->setCellWidget(row, 4, actcombo);
QSpinBox *colspinner = new QSpinBox(_fields);
colspinner->setRange(1, 999);
colspinner->setPrefix(tr("Column "));
if(!mf.isEmpty())
colspinner->setValue(mf.column());
_fields->setCellWidget(row, 5, colspinner);
QComboBox *nullcombo = new QComboBox(_fields);
nullcombo->addItems(CSVMapField::ifNullList());
if (! mf.isEmpty())
nullcombo->setCurrentIndex(mf.ifNullAction());
_fields->setCellWidget(row, 6, nullcombo);
QSpinBox *altspinner = new QSpinBox(_fields);
altspinner->setRange(1, 999);
altspinner->setPrefix(tr("Column "));
if (! mf.isEmpty())
altspinner->setValue(mf.columnAlt());
_fields->setCellWidget(row, 7, altspinner);
QComboBox *altnullcombo = new QComboBox(_fields);
altnullcombo->addItems(CSVMapField::ifNullList(TRUE));
if (! mf.isEmpty())
altnullcombo->setCurrentIndex(mf.ifNullActionAlt());
_fields->setCellWidget(row, 8, altnullcombo);
_fields->setItem(row, 9, new QTableWidgetItem(mf.valueAlt()));
RowController *control = new RowController(_fields, row, colspinner);
control->setAction(actcombo);
control->setColumn(colspinner);
control->setIfNull(nullcombo);
control->setAltColumn(altspinner);
control->setAltIfNull(altnullcombo);
control->setAltValue(_fields->item(row, 9));
control->finishSetup();
}
}
else
{
_selectedMap = QString::null;
_table->setTitle(tr("Table: "));
_table->setEnabled(FALSE);
}
}
else
_msghandler->message(QtCriticalMsg, tr("No Database"),
tr("Could not get the database connection."));
}
QSourceLocation MaintainingReader<TokenLookupClass, LookupKey>::currentLocation() const
{
return QSourceLocation(documentURI(),
lineNumber(),
columnNumber());
}
Expression::Ptr ExpressionFactory::createExpression(const QString &expr,
const StaticContext::Ptr &context,
const LanguageAccent lang,
const SequenceType::Ptr &requiredType,
const QUrl &queryURI)
{
pDebug() << Q_FUNC_INFO << queryURI;
Q_ASSERT(context);
Q_ASSERT(requiredType);
Q_ASSERT(queryURI.isValid());
OptimizationPasses::Coordinator::init();
ParserContext::Ptr info(new ParserContext(context, lang,
Tokenizer::Ptr(new XQueryTokenizer(expr, queryURI))));
const int bisonRetval = XPathparse(info.data());
Q_ASSERT_X(bisonRetval == 0, Q_FUNC_INFO,
"We shouldn't be able to get an error, because we throw exceptions.");
Q_UNUSED(bisonRetval); /* Needed when not compiled in debug mode, since bisonRetval won't
* be used in the Q_ASSERT_X above. */
Expression::Ptr result(info->queryBody);
if(!result)
{
context->error(QtXmlPatterns::tr("A library module cannot be evaluated "
"directly. It must be imported from a "
"main module."),
ReportContext::XPST0003,
QSourceLocation(queryURI, 1, 1));
}
/* Here, we type check user declared functions and global variables. This means
* that variables and functions that are not used are type checked(which they otherwise
* wouldn't have been), and those which are used, are type-checked twice, unfortunately. */
const UserFunction::List::const_iterator end(info->userFunctions.constEnd());
UserFunction::List::const_iterator it(info->userFunctions.constBegin());
for(; it != end; ++it)
{
pDebug() << "----- User Function Typecheck -----";
registerLastPath((*it)->body());
/* We will most likely call body()->typeCheck() again, once for each callsite. That is, it will
* be called from UserFunctionCallsite::typeCheck(), which will be called indirectly when
* we check the query body. */
const Expression::Ptr typeCheck((*it)->body()->typeCheck(context, (*it)->signature()->returnType()));
/* We don't have to call (*it)->setBody(typeCheck) here since it's only used directly below. */
processTreePass(typeCheck, UserFunctionTypeCheck);
pDebug() << "------------------------------";
pDebug() << "----- User Function Compress -----";
const Expression::Ptr comp(typeCheck->compress(context));
(*it)->setBody(comp);
processTreePass(comp, UserFunctionCompression);
pDebug() << "------------------------------";
}
const VariableDeclaration::Stack::const_iterator vend(info->variables.constEnd());
VariableDeclaration::Stack::const_iterator vit(info->variables.constBegin());
for(; vit != vend; ++vit)
{
Q_ASSERT(*vit);
/* If it's already used, it will be typeChecked later on. */
if((*vit)->isUsed() || (*vit)->type == VariableDeclaration::ExternalVariable)
continue;
pDebug() << "----- Global Variable Typecheck -----";
Q_ASSERT((*vit)->expression());
/* We supply ZeroOrMoreItems, meaning the variable can evaluate to anything. */
// FIXME which is a source to bugs
// TODO What about compressing variables?
const Expression::Ptr
nev((*vit)->expression()->typeCheck(context, CommonSequenceTypes::ZeroOrMoreItems));
processTreePass(nev, GlobalVariableTypeCheck);
pDebug() << "------------------------------";
}
pDebug() << "----- Initial AST build. -----";
processTreePass(result, QueryBodyInitial);
pDebug() << "------------------------------";
pDebug() << "----- Type Check -----";
registerLastPath(result);
result->rewrite(result, result->typeCheck(context, requiredType), context);
processTreePass(result, QueryBodyTypeCheck);
pDebug() << "------------------------------";
pDebug() << "----- Compress -----";
result->rewrite(result, result->compress(context), context);
processTreePass(result, QueryBodyCompression);
pDebug() << "------------------------------";
return result;
}