/*!
\reimp
*/
void QXmlSerializer::attribute(const QXmlName &name,
const QStringRef &value)
{
Q_D(QXmlSerializer);
Q_ASSERT(!name.isNull());
/* Ensure that the namespace URI used in the name gets outputted. */
{
/* Since attributes doesn't pick up the default namespace, a
* namespace declaration would cause trouble if we output it. */
if(name.prefix() != StandardPrefixes::empty)
namespaceBinding(name);
}
if(atDocumentRoot())
{
Q_UNUSED(d);
d->query.d->staticContext()->error(QtXmlPatterns::tr(
"Attribute %1 can't be serialized because it appears at "
"the top level.").arg(formatKeyword(d->np, name)),
ReportContext::SENR0001,
d->query.d->expression().data());
}
else
{
d->write(' ');
write(name);
write("=\"");
writeEscapedAttribute(value.toString());
d->write('"');
}
}
QString ExternalEnvironment::retrieveProperty(const QXmlName name)
{
if(name.namespaceURI() != StandardNamespaces::xslt)
return QString();
switch(name.localName())
{
case StandardLocalNames::version:
return QString::number(ExternalEnvironment::XSLVersion);
case StandardLocalNames::vendor:
return ExternalEnvironment::Vendor;
case StandardLocalNames::vendor_url:
return QString(ExternalEnvironment::VendorURL.toString());
case StandardLocalNames::product_name:
return ExternalEnvironment::ProductName;
case StandardLocalNames::product_version:
return ExternalEnvironment::ProductVersion;
case StandardLocalNames::is_schema_aware:
return toString(ExternalEnvironment::IsSchemaAware);
case StandardLocalNames::supports_serialization:
return toString(ExternalEnvironment::SupportsSerialization);
case StandardLocalNames::supports_backwards_compatibility:
return toString(ExternalEnvironment::SupportsBackwardsCompatibility);
default:
return QString();
}
}
void GenericNamespaceResolver::addBinding(const QXmlName nb)
{
if(nb.namespaceURI() == StandardNamespaces::UndeclarePrefix)
m_bindings.remove(nb.prefix());
else
m_bindings.insert(nb.prefix(), nb.namespaceURI());
}
QString SystemPropertyFN::retrieveProperty(const QXmlName name)
{
if(name.namespaceURI() != StandardNamespaces::xslt)
return QString();
switch(name.localName())
{
case StandardLocalNames::version:
/*
* The supported XSL-T version.
*
* @see <a href="http://www.w3.org/TR/xslt20/#system-property">The Note paragraph
* at the very end of XSL Transformations (XSLT) Version 2.0,
* 16.6.5 system-property</a>
*/
return QString::number(1.20);
case StandardLocalNames::vendor:
return QLatin1String("Digia Plc and/or its subsidiary(-ies), a Digia Company");
case StandardLocalNames::vendor_url:
return QLatin1String("http://qt.digia.com/");
case StandardLocalNames::product_name:
return QLatin1String("QtXmlPatterns");
case StandardLocalNames::product_version:
return QLatin1String("0.1");
case StandardLocalNames::is_schema_aware:
/* Fallthrough. */
case StandardLocalNames::supports_backwards_compatibility:
/* Fallthrough. */
case StandardLocalNames::supports_serialization:
/* Fallthrough. */
return QLatin1String("no");
default:
return QString();
}
}
FunctionSignature::Ptr XSLT10CoreFunctions::retrieveFunctionSignature(const NamePool::Ptr &np, const QXmlName name)
{
if(StandardNamespaces::fn != name.namespaceURI())
return FunctionSignature::Ptr();
FunctionSignature::Ptr s(functionSignatures().value(name));
if(!s)
{
/* Alphabetic order. */
if(name.localName() == StandardLocalNames::function_available)
{
s = addFunction(StandardLocalNames::function_available, 1, 2, CommonSequenceTypes::ExactlyOneBoolean);
s->appendArgument(argument(np, "function_name"), CommonSequenceTypes::ExactlyOneString);
s->appendArgument(argument(np, "arity"), CommonSequenceTypes::ExactlyOneInteger);
}
else if(name.localName() == StandardLocalNames::system_property)
{
s = addFunction(StandardLocalNames::system_property, 1, 1, CommonSequenceTypes::ExactlyOneString);
s->appendArgument(argument(np, "property_name"), CommonSequenceTypes::ExactlyOneString);
}
}
return s;
}
void AccelTreeBuilder<FromDocument>::startElement(const QXmlName &name, qint64 line, qint64 column)
{
startStructure();
AccelTree::BasicNodeData data(currentDepth(), currentParent(), QXmlNodeModelIndex::Element, -1, name);
m_document->basicData.append(data);
if (m_features & SourceLocationsFeature)
m_document->sourcePositions.insert(m_document->maximumPreNumber(), qMakePair(line, column));
++m_preNumber;
m_ancestors.push(m_preNumber);
++m_size.top();
m_size.push(0);
/* With node constructors, we can receive names for which we have no namespace
* constructors, such as in the query '<xs:space/>'. Since the 'xs' prefix has no
* NamespaceConstructor in this case, we synthesize the namespace.
*
* In case we're constructing from an XML document we avoid the call because
* although it's redundant, it's on extra virtual call for each element. */
if(!FromDocument)
namespaceBinding(QXmlName(name.namespaceURI(), 0, name.prefix()));
m_isPreviousAtomic = false;
}
void AccelTreeBuilder<FromDocument>::namespaceBinding(const QXmlName &nb)
{
/* Note, because attribute() sometimes generate namespaceBinding() calls, this function
* can be called after attributes, in contrast to what the class documentation says. This is ok,
* as long as we're not dealing with public API. */
/* If we've received attributes, it means the element's size have changed and m_preNumber have advanced,
* so "reverse back" to the actual element. */
const AccelTree::PreNumber pn = m_preNumber - m_size.top();
QVector<QXmlName> &nss = m_document->namespaces[pn];
/* "xml" hasn't been declared for each node, AccelTree::namespaceBindings() adds it, so avoid it
* such that we don't get duplicates. */
if(nb.prefix() == StandardPrefixes::xml)
return;
/* If we already have the binding, skip it. */
const int len = nss.count();
for(int i = 0; i < len; ++i)
{
if(nss.at(i).prefix() == nb.prefix())
return;
}
nss.append(nb);
}
/*!
Ensure that the three last arguments have default values, and that they are null strings.
*/
void tst_QXmlName::argumentConstructorDefaultArguments() const
{
QXmlNamePool np;
const QXmlName n1(np, QLatin1String("localName"));
const QXmlName n2(np, QLatin1String("localName"), QString(), QString());
QCOMPARE(n1, n2);
QCOMPARE(n1.toClarkName(np), QString::fromLatin1("localName"));
}
void ReportContext::error(const QString &msg,
const QXmlName qname,
const SourceLocationReflection *const reflection)
{
Q_ASSERT(!qname.isNull());
createError(msg, QtFatalMsg,
QUrl(namePool()->stringForNamespace(qname.namespaceURI()) + QLatin1Char('#') + namePool()->stringForLocalName(qname.localName())),
lookupSourceLocation(reflection));
}
Item AttributeNameValidator::evaluateSingleton(const DynamicContext::Ptr &context) const
{
const Item name(m_operand->evaluateSingleton(context));
const QXmlName qName(name.as<QNameValue>()->qName());
if(qName.namespaceURI() == StandardNamespaces::xmlns)
{
context->error(QtXmlPatterns::tr("The namespace URI in the name for a "
"computed attribute cannot be %1.")
.arg(formatURI(CommonNamespaces::XMLNS)),
ReportContext::XQDY0044, this);
return Item(); /* Silence warning. */
}
else if(qName.namespaceURI() == StandardNamespaces::empty &&
qName.localName() == StandardLocalNames::xmlns)
{
context->error(QtXmlPatterns::tr("The name for a computed attribute "
"cannot have the namespace URI %1 "
"with the local name %2.")
.arg(formatURI(CommonNamespaces::XMLNS))
.arg(formatKeyword("xmlns")),
ReportContext::XQDY0044, this);
return Item(); /* Silence warning. */
}
else if(!qName.hasPrefix() && qName.hasNamespace())
{
return Item(QNameValue::fromValue(context->namePool(),
QXmlName(qName.namespaceURI(), qName.localName(), StandardPrefixes::ns0)));
}
else
return name;
}
void tst_QXmlSchemaValidator::resetSchemaNamePool() const
{
QXmlSchema schema1;
QXmlNamePool np1 = schema1.namePool();
const QXmlName name1(np1, QLatin1String("localName"),
QLatin1String("http://example.com/"),
QLatin1String("prefix"));
QXmlSchemaValidator validator(schema1);
{
QXmlNamePool compNamePool(validator.namePool());
QCOMPARE(name1.namespaceUri(compNamePool), QString::fromLatin1("http://example.com/"));
QCOMPARE(name1.localName(compNamePool), QString::fromLatin1("localName"));
QCOMPARE(name1.prefix(compNamePool), QString::fromLatin1("prefix"));
}
QXmlSchema schema2;
QXmlNamePool np2 = schema2.namePool();
const QXmlName name2(np2, QLatin1String("remoteName"),
QLatin1String("http://example.com/"),
QLatin1String("suffix"));
// make sure that after re-setting the schema, the new namepool is used
validator.setSchema(schema2);
{
QXmlNamePool compNamePool(validator.namePool());
QCOMPARE(name2.namespaceUri(compNamePool), QString::fromLatin1("http://example.com/"));
QCOMPARE(name2.localName(compNamePool), QString::fromLatin1("remoteName"));
QCOMPARE(name2.prefix(compNamePool), QString::fromLatin1("suffix"));
}
}
void GeogebraTransformer::startElement( const QXmlName& name )
{
if( name.localName( m_np ) == "Section" )
{
m_nsections++;
m_sections.push_back( GeogebraSection() );
// Clear stacks
m_inputObjectLabels.clear();
m_outputObjectLabels.clear();
m_currentArgStack.clear();
m_objectMap.clear();
return;
}
switch( m_currentState )
{
case GeogebraTransformer::ReadingObject:
if( m_currentObject )
{
// We are already building an object
m_currentState = GeogebraTransformer::ReadingArguments;
startElement( name );
return;
}
{
resetDrawerVars();
const QByteArray nameData = name.localName( m_np ).toLatin1();
m_currentObject = ObjectTypeFactory::instance()->find( nameData );
if ( !m_currentObject )
{
qWarning() << name.localName( m_np ) << " object not found!";
}
}
break;
case GeogebraTransformer::ReadingArguments:
if ( name.localName( m_np ) == QLatin1String( "Double" ) )
{
m_currentState = GeogebraTransformer::ReadingDouble;
}
break;
default:
break;
}
}
void tst_QSimpleXmlNodeModel::namePool() const
{
/* Check that the name pool we pass in, is what actually is returned. */
QXmlNamePool np;
const QXmlName name(np, QLatin1String("localName"),
QLatin1String("http://example.com/XYZ"),
QLatin1String("prefix432"));
TestSimpleNodeModel model(np);
const QXmlNamePool np2(model.namePool());
/* If it's a bug, this will more or less crash. */
QCOMPARE(name.namespaceUri(np2), QString::fromLatin1("http://example.com/XYZ"));
QCOMPARE(name.localName(np2), QString::fromLatin1("localName"));
QCOMPARE(name.prefix(np2), QString::fromLatin1("prefix432"));
}
Item LocalNameFN::evaluateSingleton(const DynamicContext::Ptr &context) const
{
const Item node(m_operands.first()->evaluateSingleton(context));
if(node)
{
const QXmlName name(node.asNode().name());
if(name.isNull())
return CommonValues::EmptyString;
else
return AtomicString::fromValue(context->namePool()->stringForLocalName(name.localName()));
}
else
return CommonValues::EmptyString;
}
FunctionArgument::FunctionArgument(const QXmlName nameP,
const SequenceType::Ptr &typeP) : m_name(nameP),
m_type(typeP)
{
Q_ASSERT(!nameP.isNull());
Q_ASSERT(typeP);
}
ItemType::Ptr QNameTest::create(const ItemType::Ptr &primaryType, const QXmlName qName)
{
Q_ASSERT(!qName.isNull());
Q_ASSERT(primaryType);
return ItemType::Ptr(new QNameTest(primaryType, qName));
}
/*!
\reimp
*/
void QXmlSerializer::startElement(const QXmlName &name)
{
Q_D(QXmlSerializer);
Q_ASSERT(d->device);
Q_ASSERT(d->device->isWritable());
Q_ASSERT(d->codec);
Q_ASSERT(!name.isNull());
d->namespaces.push(QVector<QXmlName>());
if(atDocumentRoot())
{
if(d->state == BeforeDocumentElement)
d->state = InsideDocumentElement;
else if(d->state != InsideDocumentElement)
{
d->query.d->staticContext()->error(QtXmlPatterns::tr(
"Element %1 can't be serialized because it appears outside "
"the document element.").arg(formatKeyword(d->np, name)),
ReportContext::SENR0001,
d->query.d->expression().data());
}
}
startContent();
d->write('<');
write(name);
/* Ensure that the namespace URI used in the name gets outputted. */
namespaceBinding(name);
d->hasClosedElement.push(qMakePair(name, false));
d->isPreviousAtomic = false;
}
QString NamePool::displayName(const QXmlName qName) const
{
QReadLocker l(mutableLock());
if(qName.hasNamespace())
{
const QString &p = displayPrefix(qName.namespaceURI());
if(p.isEmpty())
return QLatin1Char('{') + m_namespaces.at(qName.namespaceURI()) + QLatin1Char('}') + toLexical(qName);
else
return p + QLatin1Char(':') + m_localNames.at(qName.localName());
}
else
return m_localNames.at(qName.localName());
}
QPatternist::Item
ExternalSourceLoader::evaluateSingleton(const QXmlName name,
const QPatternist::DynamicContext::Ptr &context)
{
Q_ASSERT(!name.isNull());
const VariableValue variable(m_variableMap.value(Global::namePool()->stringForLocalName(name.localName())));
if(variable.second == Document)
{
Q_ASSERT_X(QFile::exists(variable.first.toLocalFile()), Q_FUNC_INFO,
qPrintable(QString::fromLatin1("The file %1 doesn't exist").arg(variable.first.toLocalFile())));
Q_ASSERT_X(m_resourceLoader->openDocument(variable.first, context), Q_FUNC_INFO,
"We're supposed to have the value. If not, an error should have been issued at query compile time.");
return m_resourceLoader->openDocument(variable.first, context);
}
else if(variable.second == Query)
{
/* Well, here we open the file and execute it. */
m_query.setQuery(QUrl::fromLocalFile(variable.first.toLocalFile()));
Q_ASSERT(m_query.isValid());
QXmlResultItems result;
m_query.evaluateTo(&result);
return QPatternist::Item::fromPublic(result.next());
}
else
{
Q_ASSERT(variable.second == URI);
return QPatternist::AtomicString::fromValue(variable.first.toString());
}
}
void DirectoryScanner::attribute(const QXmlName &name, const QStringRef &value)
{
QString localName(name.localName(namePool));
if(localName == "name") {
this->name = value.toString();
} else if(localName == "title") {
title = value.toString();
} else if(localName == "type") {
type = value.toString();
fsBaseFinder.setShortcutMode(type == "shortcut");
} else if(localName == "ev") {
fsBaseFinder.setEV(value.toString());
} else if(localName == "path") {
fsBaseFinder.setPath(value.toString());
regBaseFinder.setPath(value.toString());
} else if(localName == "key") {
regBaseFinder.setKey(value.toString());
} else if(localName == "root") {
regBaseFinder.setRoot(value.toString());
} else if(localName == "includepath") {
include << value.toString();
} else if(localName == "excludepath") {
exclude << value.toString();
}
}
Item NamespaceURIFN::evaluateSingleton(const DynamicContext::Ptr &context) const
{
const Item node(m_operands.first()->evaluateSingleton(context));
if(node)
{
const QXmlName name(node.asNode().name());
if(name.isNull())
return CommonValues::EmptyAnyURI;
else
return toItem(AnyURI::fromValue(context->namePool()->stringForNamespace(name.namespaceURI())));
}
else
return CommonValues::EmptyAnyURI;
}
Item NodeNameFN::evaluateSingleton(const DynamicContext::Ptr &context) const
{
const Item item(m_operands.first()->evaluateSingleton(context));
if(item)
{
const QXmlName name(item.asNode().name());
if(name.isNull())
return Item();
else
return toItem(QNameValue::fromValue(context->namePool(), name));
}
else
return Item();
}
QXmlNodeModelIndex AccelTree::elementById(const QXmlName &id) const
{
const PreNumber pre = m_IDs.value(id.localName(), -1);
if(pre == -1)
return QXmlNodeModelIndex();
else
return createIndex(pre);
}
/*!
Check that functions have the correct const qualification.
*/
void tst_QXmlName::constCorrectness() const
{
const QXmlName name;
/* isNull() */
QVERIFY(name.isNull());
/* operator==() */
QVERIFY(name == name);
/* operator!=() */
QVERIFY(!(name != name));
QXmlNamePool namePool;
const QXmlName name2(namePool, QLatin1String("localName"), QLatin1String("http://example.com/"), QLatin1String("prefix"));
/* namespaceUri(). */
QCOMPARE(name2.namespaceUri(namePool), QLatin1String("http://example.com/"));
/* localName(). */
QCOMPARE(name2.localName(namePool), QLatin1String("localName"));
/* prefix(). */
QCOMPARE(name2.prefix(namePool), QLatin1String("prefix"));
/* toClarkname(). */
QCOMPARE(name2.toClarkName(namePool), QLatin1String("{http://example.com/}prefix:localName"));
}
/*!
\internal
*/
void QXmlSerializer::write(const QXmlName &name)
{
Q_D(QXmlSerializer);
const QByteArray &cell = d->nameCache[name.code()];
if(cell.isNull())
{
QByteArray &mutableCell = d->nameCache[name.code()];
const QString content(d->np->toLexical(name));
mutableCell = d->codec->fromUnicode(content.constData(),
content.length(),
&d->converterState);
d->device->write(mutableCell);
}
else
d->device->write(cell);
}
void tst_QXmlSchema::constructorQXmlNamePool() const
{
QXmlSchema schema;
QXmlNamePool np = schema.namePool();
const QXmlName name(np, QLatin1String("localName"),
QLatin1String("http://example.com/"),
QLatin1String("prefix"));
QXmlNamePool np2(schema.namePool());
QCOMPARE(name.namespaceUri(np2), QString::fromLatin1("http://example.com/"));
QCOMPARE(name.localName(np2), QString::fromLatin1("localName"));
QCOMPARE(name.prefix(np2), QString::fromLatin1("prefix"));
// make sure namePool() is const
const QXmlSchema constSchema;
np = constSchema.namePool();
}
static PyObject *meth_QXmlName_namespaceUri(PyObject *sipSelf, PyObject *sipArgs)
{
PyObject *sipParseErr = NULL;
{
const QXmlNamePool * a0;
QXmlName *sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QXmlName, &sipCpp, sipType_QXmlNamePool, &a0))
{
QString *sipRes;
Py_BEGIN_ALLOW_THREADS
sipRes = new QString(sipCpp->namespaceUri(*a0));
Py_END_ALLOW_THREADS
return sipConvertFromNewType(sipRes,sipType_QString,NULL);
}
}
SequenceType::Ptr ExternalVariableLoader::announceExternalVariable(const QXmlName name,
const SequenceType::Ptr &declaredType)
{
Q_ASSERT(!name.isNull());
Q_ASSERT(declaredType);
Q_UNUSED(name); /* Needed when compiling in release mode. */
Q_UNUSED(declaredType); /* Needed when compiling in release mode. */
return SequenceType::Ptr();
}
Item::Iterator::Ptr ExternalVariableLoader::evaluateSequence(const QXmlName name,
const DynamicContext::Ptr &context)
{
Q_ASSERT(!name.isNull());
const Item item(evaluateSingleton(name, context));
if(item)
return makeSingletonIterator(item);
else
return CommonValues::emptyIterator;
}
void XsdSchema::addAnonymousType(const SchemaType::Ptr &type)
{
const QWriteLocker locker(&m_lock);
// search for not used anonymous type name
QXmlName typeName = type->name(m_namePool);
while (m_anonymousTypes.contains(typeName)) {
typeName = m_namePool->allocateQName(QString(), QLatin1String("merged_") + m_namePool->stringForLocalName(typeName.localName()), QString());
}
m_anonymousTypes.insert(typeName, type);
}