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"));
}
}
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 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;
}
}
/*!
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"));
}
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());
}
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();
}
}
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();
}
}
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();
}
}
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);
}
QString NamePool::displayName(const QXmlName qName) const
{
QReadLocker l(&lock);
if(qName.hasNamespace())
{
if(qName.namespaceURI() == StandardNamespaces::InternalXSLT)
return QLatin1Char('#') + m_localNames.at(qName.localName());
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());
}
QString NamePool::toClarkName(const QXmlName &name) const
{
if(name.isNull())
return QLatin1String("QXmlName(null)");
else
{
if(name.hasNamespace())
{
const QString ns(stringForNamespace(name.namespaceURI()));
const QString p(stringForPrefix(name.prefix()));
const QString l(stringForLocalName(name.localName()));
return QChar::fromLatin1('{')
+ ns
+ QChar::fromLatin1('}')
+ (p.isEmpty() ? l : p + QChar::fromLatin1(':') + l);
}
else
return stringForLocalName(name.localName());
}
}
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;
}
void FeedEntryListModel::attribute(const QXmlName &name, const QStringRef &value)
{
QString tagName = name.localName(this->namePool);
QString tagValue = value.toString();
if(tagName == "title")
this->current.title = tagValue;
else if(tagName == "summary")
this->current.summary = tagValue;
else if(tagName == "id")
this->current.id = tagValue;
else if(tagName == "read") {
if(tagValue == "true")
this->current.read = true;
else
this->current.read = false;
}
}
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();
}
void tst_QXmlSchemaValidator::constructorQXmlNamePool() const
{
// test that the name pool from the schema is used by
// the schema validator as well
QXmlSchema schema;
QXmlNamePool np = schema.namePool();
const QXmlName name(np, QLatin1String("localName"),
QLatin1String("http://example.com/"),
QLatin1String("prefix"));
QXmlSchemaValidator validator(schema);
QXmlNamePool np2(validator.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 QXmlSchemaValidator constValidator(schema);
np = constValidator.namePool();
}
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);
}
void XmlQueryToWriter::attribute(const QXmlName & name, const QStringRef & value)
{
_writer->writeAttribute(name.localName(_query->namePool()), value.toString());
}
FunctionSignature::Ptr XPath10CoreFunctions::retrieveFunctionSignature(const NamePool::Ptr &np, const QXmlName name)
{
if(StandardNamespaces::fn != name.namespaceURI())
return FunctionSignature::Ptr();
FunctionSignature::Ptr s(functionSignatures().value(name));
if(!s)
{
const QXmlName::LocalNameCode localName(name.localName());
/* Alphabetic order. */
if(StandardLocalNames::boolean == localName)
{
s = addFunction(StandardLocalNames::boolean, 1, 1, CommonSequenceTypes::ExactlyOneBoolean);
s->appendArgument(argument(np, "arg"), CommonSequenceTypes::EBV);
}
else if(StandardLocalNames::ceiling == localName)
{
s = addFunction(StandardLocalNames::ceiling, 1, 1, CommonSequenceTypes::ZeroOrOneNumeric,
Expression::EmptynessFollowsChild | Expression::RewriteToEmptyOnEmpty);
s->appendArgument(argument(np, "arg"), CommonSequenceTypes::ZeroOrOneNumeric);
}
else if(StandardLocalNames::concat == localName)
{
s = addFunction(StandardLocalNames::concat, 2, FunctionSignature::UnlimitedArity,
CommonSequenceTypes::ExactlyOneString);
s->appendArgument(argument(np, "arg1"), CommonSequenceTypes::ZeroOrOneAtomicType);
s->appendArgument(argument(np, "arg2"), CommonSequenceTypes::ZeroOrOneAtomicType);
}
else if(StandardLocalNames::contains == localName)
{
s = addFunction(StandardLocalNames::contains, 2, 3, CommonSequenceTypes::ExactlyOneBoolean,
Expression::LastOperandIsCollation);
s->appendArgument(argument(np, "arg1"), CommonSequenceTypes::ZeroOrOneString);
s->appendArgument(argument(np, "arg2"), CommonSequenceTypes::ZeroOrOneString);
s->appendArgument(argument(np, "collation"), CommonSequenceTypes::ExactlyOneString);
}
else if(StandardLocalNames::count == localName)
{
s = addFunction(StandardLocalNames::count, 1, 1, CommonSequenceTypes::ExactlyOneInteger, Expression::IDCountFN);
s->appendArgument(argument(np, "arg"), CommonSequenceTypes::ZeroOrMoreItems);
}
else if(StandardLocalNames::False == localName)
{
s = addFunction(StandardLocalNames::False, 0, 0, CommonSequenceTypes::ExactlyOneBoolean);
}
else if(StandardLocalNames::floor == localName)
{
s = addFunction(StandardLocalNames::floor, 1, 1, CommonSequenceTypes::ZeroOrOneNumeric,
Expression::EmptynessFollowsChild | Expression::RewriteToEmptyOnEmpty);
s->appendArgument(argument(np, "arg"), CommonSequenceTypes::ZeroOrOneNumeric);
}
else if(StandardLocalNames::id == localName)
{
s = addFunction(StandardLocalNames::id, 1, 2, CommonSequenceTypes::ZeroOrMoreElements,
Expression::UseContextItem);
s->appendArgument(argument(np, "idrefs"), CommonSequenceTypes::ZeroOrMoreStrings);
s->appendArgument(argument(np, "node"), CommonSequenceTypes::ExactlyOneNode);
}
else if(StandardLocalNames::lang == localName)
{
s = addFunction(StandardLocalNames::lang, 1, 2, CommonSequenceTypes::ExactlyOneBoolean,
Expression::UseContextItem);
s->appendArgument(argument(np, "testLang"), CommonSequenceTypes::ZeroOrOneString);
s->appendArgument(argument(np, "node"), CommonSequenceTypes::ExactlyOneNode);
}
else if(StandardLocalNames::last == localName)
{
s = addFunction(StandardLocalNames::last, 0, 0, CommonSequenceTypes::ExactlyOneInteger,
Expression::DisableElimination | Expression::RequiresFocus);
}
else if(StandardLocalNames::local_name == localName)
{
s = addFunction(StandardLocalNames::local_name, 0, 1, CommonSequenceTypes::ExactlyOneString,
Expression::UseContextItem);
s->appendArgument(argument(np, "arg"), CommonSequenceTypes::ZeroOrOneNode);
}
else if(StandardLocalNames::name == localName)
{
s = addFunction(StandardLocalNames::name, 0, 1, CommonSequenceTypes::ExactlyOneString,
Expression::UseContextItem);
s->appendArgument(argument(np, "arg"), CommonSequenceTypes::ZeroOrOneNode);
}
else if(StandardLocalNames::namespace_uri == localName)
{
s = addFunction(StandardLocalNames::namespace_uri, 0, 1, CommonSequenceTypes::ExactlyOneAnyURI,
Expression::UseContextItem);
s->appendArgument(argument(np, "arg"), CommonSequenceTypes::ZeroOrOneNode);
}
else if(StandardLocalNames::normalize_space == localName)
{
s = addFunction(StandardLocalNames::normalize_space, 0, 1, CommonSequenceTypes::ExactlyOneString,
Expression::UseContextItem);
s->appendArgument(argument(np, "arg"), CommonSequenceTypes::ZeroOrOneString);
}
else if(StandardLocalNames::Not == localName)
{
s = addFunction(StandardLocalNames::Not, 1, 1, CommonSequenceTypes::ExactlyOneBoolean);
s->appendArgument(argument(np, "arg"), CommonSequenceTypes::EBV);
}
else if(StandardLocalNames::number == localName)
{
s = addFunction(StandardLocalNames::number, 0, 1, CommonSequenceTypes::ExactlyOneDouble,
Expression::UseContextItem);
s->appendArgument(argument(np, "arg"), CommonSequenceTypes::ZeroOrOneAtomicType);
}
else if(StandardLocalNames::position == localName)
{
s = addFunction(StandardLocalNames::position, 0, 0, CommonSequenceTypes::ExactlyOneInteger,
Expression::DisableElimination | Expression::RequiresFocus);
}
else if(StandardLocalNames::round == localName)
{
s = addFunction(StandardLocalNames::round, 1, 1, CommonSequenceTypes::ZeroOrOneNumeric,
Expression::EmptynessFollowsChild | Expression::RewriteToEmptyOnEmpty);
s->appendArgument(argument(np, "arg"), CommonSequenceTypes::ZeroOrOneNumeric);
}
else if(StandardLocalNames::starts_with == localName)
{
s = addFunction(StandardLocalNames::starts_with, 2, 3, CommonSequenceTypes::ExactlyOneBoolean,
Expression::LastOperandIsCollation);
s->appendArgument(argument(np, "arg1"), CommonSequenceTypes::ZeroOrOneString);
s->appendArgument(argument(np, "arg2"), CommonSequenceTypes::ZeroOrOneString);
s->appendArgument(argument(np, "collation"), CommonSequenceTypes::ExactlyOneString);
}
else if(StandardLocalNames::string == localName)
{
s = addFunction(StandardLocalNames::string, 0, 1, CommonSequenceTypes::ExactlyOneString,
Expression::UseContextItem);
s->appendArgument(argument(np, "arg"), CommonSequenceTypes::ZeroOrOneItem);
}
else if(StandardLocalNames::string_length == localName)
{
s = addFunction(StandardLocalNames::string_length, 0, 1,
CommonSequenceTypes::ExactlyOneInteger,
Expression::UseContextItem);
s->appendArgument(argument(np, "arg"), CommonSequenceTypes::ZeroOrOneString);
}
else if(StandardLocalNames::substring == localName)
{
s = addFunction(StandardLocalNames::substring, 2, 3, CommonSequenceTypes::ExactlyOneString);
s->appendArgument(argument(np, "sourceString"), CommonSequenceTypes::ZeroOrOneString);
s->appendArgument(argument(np, "startingLoc"), CommonSequenceTypes::ExactlyOneDouble);
s->appendArgument(argument(np, "length"), CommonSequenceTypes::ExactlyOneDouble);
}
else if(StandardLocalNames::substring_after == localName)
{
s = addFunction(StandardLocalNames::substring_after, 2, 3, CommonSequenceTypes::ExactlyOneString,
Expression::LastOperandIsCollation);
s->appendArgument(argument(np, "arg1"), CommonSequenceTypes::ZeroOrOneString);
s->appendArgument(argument(np, "arg2"), CommonSequenceTypes::ZeroOrOneString);
s->appendArgument(argument(np, "collation"), CommonSequenceTypes::ExactlyOneString);
}
else if(StandardLocalNames::substring_before == localName)
{
s = addFunction(StandardLocalNames::substring_before, 2, 3, CommonSequenceTypes::ExactlyOneString,
Expression::LastOperandIsCollation);
s->appendArgument(argument(np, "arg1"), CommonSequenceTypes::ZeroOrOneString);
s->appendArgument(argument(np, "arg2"), CommonSequenceTypes::ZeroOrOneString);
s->appendArgument(argument(np, "collation"), CommonSequenceTypes::ExactlyOneString);
}
else if(StandardLocalNames::sum == localName)
{
s = addFunction(StandardLocalNames::sum, 1, 2, CommonSequenceTypes::ZeroOrOneAtomicType);
s->appendArgument(argument(np, "arg"), CommonSequenceTypes::ZeroOrMoreAtomicTypes);
s->appendArgument(argument(np, "zero"), CommonSequenceTypes::ZeroOrOneAtomicType);
}
else if(StandardLocalNames::translate == localName)
{
s = addFunction(StandardLocalNames::translate, 3, 3, CommonSequenceTypes::ExactlyOneString);
s->appendArgument(argument(np, "arg"), CommonSequenceTypes::ZeroOrOneString);
s->appendArgument(argument(np, "mapString"), CommonSequenceTypes::ExactlyOneString);
s->appendArgument(argument(np, "transString"), CommonSequenceTypes::ExactlyOneString);
}
else if(StandardLocalNames::True == localName)
{
s = addFunction(StandardLocalNames::True, 0, 0, CommonSequenceTypes::ExactlyOneBoolean);
}
}
return s;
}
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));
}
void GeogebraTransformer::attribute( const QXmlName& name, const QStringRef& value )
{
if( name.localName( m_np ) == QLatin1String( "label" ) )
{
const QByteArray objectLabel = value.toLatin1();
bool isDoubleValue;
const double dblval = value.toString().toDouble( &isDoubleValue );
switch( m_currentState )
{
case GeogebraTransformer::ReadingObject:
m_currentObjectLabel = value.toLatin1();
// There must be a better place for this
m_currentState = GeogebraTransformer::ReadingArguments;
break;
case GeogebraTransformer::ReadingArguments:
if( isDoubleValue )
{
/* This is to handle the circle-point-radius, dilate (and similar) type of Geogebra objects.
* <command name="Circle">
* <input a0="A" a1="3"/>
* <output a0="c"/>
*
* Notice the attribute 'a1' of the 'input' element. The value - '3' is the radius of the circle.
* First, we try to convert that value to Double. If the conversion suceeds, we stack a DoubleImp (Calcer)
* in the m_currentArgStack and break. Otherwise, we check the m_objectMap for that label entry.
*/
DoubleImp * doubleImp = new DoubleImp( dblval );
m_currentArgStack.push_back( new ObjectConstCalcer( doubleImp ) );
}
else if( m_objectMap.contains( objectLabel ) )
{
m_currentArgStack.push_back( m_objectMap[objectLabel] );
}
else
{
//TODO Figure out error reporting
}
break;
default:
break;
}
}
else if ( name.localName( m_np ) == QLatin1String( "value" ) )
{
Q_ASSERT( m_currentState == ReadingDouble );
DoubleImp * doubleImp = new DoubleImp( value.toString().toDouble() );
m_currentArgStack.push_back( new ObjectConstCalcer( doubleImp ) );
}
else if ( name.localName( m_np ) == QLatin1String( "Name" ) )
{
m_sections[m_nsections - 1].setName( value.toString() );
}
else if ( name.localName( m_np ) == QLatin1String( "Description" ) )
{
m_sections[m_nsections - 1].setDescription( value.toString() );
}
else if ( name.localName( m_np ) == QLatin1String( "Input" ) )
{
m_inputObjectLabels.insert( value.toLatin1() );
}
else if ( name.localName( m_np ) == QLatin1String( "Output" ) )
{
m_outputObjectLabels.insert( value.toLatin1() );
}
else if( name.localName( m_np ) == QLatin1String( "show" ) )
{
m_show = ( ( value.toString()=="true" ) ? true:false );
}
else if( name.localName( m_np ) == QLatin1String( "thickness" ) )
{
m_thickness = value.toString().toInt();
}
else if( name.localName( m_np ) == QLatin1String( "thickness_point" ) )
{
m_thickness = value.toString().toInt();
m_thickness += 6;
}
else if( name.localName( m_np ) == QLatin1String( "type" ) )
{
int penType = value.toString().toInt() ;
switch( penType )
{
case SOLIDLINE:
m_type = Qt::SolidLine;
break;
case DASHDOTDOTLINE:
m_type = Qt::DashDotDotLine;
break;
case DASHLINE:
m_type = Qt::DashLine;
break;
case DOTLINE:
m_type = Qt::DotLine;
break;
case DASHDOTLINE:
m_type = Qt::DashDotLine;
break;
default:
m_type = Qt::SolidLine;
};
}
else if( name.localName( m_np ) == QLatin1String( "pointType" ) )
{
int pt = value.toString().toInt();
if( pt == SOLIDCIRCLEPOINT )
m_pointType = Kig::pointStyleFromString( "Round" );
else if( pt == SOLIDDIAMONDPOINT || pt == UPARROWPOINT || pt == DOWNARROWPOINT || pt == RIGHTARROWPOINT || pt == LEFTARROWPOINT )
m_pointType = Kig::pointStyleFromString( "Rectangular" );
else if( pt == HOLLOWCIRCLEPOINT )
m_pointType = Kig::pointStyleFromString( "Round" );//TODO should be mapped to RoundEmpty ( i.e. 1) but for some reason it is not drawing in KIG
else if( pt == HOLLOWDIAMONDPOINT )
m_pointType = Kig::pointStyleFromString( "Rectangular" );//TODO should be mapped to RectangularEmpty ( i.e. 3) but for some reason it is not drawing in KIG
else if( pt == CROSSPOINT || pt == PLUSPOINT )
m_pointType = Kig::pointStyleFromString( "Cross" );
else
m_pointType = Kig::Round;
}
else if( name.localName( m_np ) == QLatin1String( "r" ) )
{
m_r = value.toString().toInt();
}
else if( name.localName( m_np ) == QLatin1String( "g" ) )
{
m_g = value.toString().toInt();
}
else if( name.localName( m_np ) == QLatin1String( "b" ) )
{
m_b = value.toString().toInt();
}
else if( name.localName( m_np ) == QLatin1String( "alpha" ) )
{
m_alpha = value.toString().toInt();
}
else if( name.localName( m_np ) == QLatin1String( "axes" ) )
{
bool showAxes = value.toString() == "true" ? true:false;
m_document->setAxes( showAxes );
}
else if( name.localName( m_np ) == QLatin1String( "grid" ) )
{
bool showGrid = value.toString() == "true" ? true:false;
m_document->setGrid( showGrid );
}
}
FunctionSignature::Ptr XSLT20CoreFunctions::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::element_available)
{
s = addFunction(StandardLocalNames::element_available, 1, 1, CommonSequenceTypes::ExactlyOneBoolean);
s->appendArgument(argument(np, "element-name"), CommonSequenceTypes::ExactlyOneString);
}
else 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::type_available)
{
s = addFunction(StandardLocalNames::type_available, 1, 1, CommonSequenceTypes::ExactlyOneBoolean);
s->appendArgument(argument(np, "type_name"), CommonSequenceTypes::ExactlyOneString);
}
else if(name.localName() == StandardLocalNames::system_property)
{
s = addFunction(StandardLocalNames::system_property, 1, 1, CommonSequenceTypes::ExactlyOneString);
s->appendArgument(argument(np, "property_name"), CommonSequenceTypes::ExactlyOneString);
}
else if(name.localName() == StandardLocalNames::generate_id)
{
s = addFunction(StandardLocalNames::generate_id, 0, 1, CommonSequenceTypes::ExactlyOneString,
Expression::UseContextItem);
s->appendArgument(argument(np, "node"), CommonSequenceTypes::ZeroOrOneNode);
}
else if(name.localName() == StandardLocalNames::unparsed_text)
{
s = addFunction(StandardLocalNames::unparsed_text, 1, 2, CommonSequenceTypes::ZeroOrOneString,
Expression::DisableElimination);
s->appendArgument(argument(np, "href"), CommonSequenceTypes::ZeroOrOneString);
s->appendArgument(argument(np, "encoding"), CommonSequenceTypes::ExactlyOneString);
}
else if(name.localName() == StandardLocalNames::unparsed_text_available)
{
s = addFunction(StandardLocalNames::unparsed_text_available, 1, 2, CommonSequenceTypes::ExactlyOneBoolean,
Expression::DisableElimination);
s->appendArgument(argument(np, "href"), CommonSequenceTypes::ZeroOrOneString);
s->appendArgument(argument(np, "encoding"), CommonSequenceTypes::ZeroOrOneString);
}
else if(name.localName() == StandardLocalNames::current)
{
s = addFunction(StandardLocalNames::current, 0, 0, CommonSequenceTypes::ExactlyOneItem,
Expression::DisableElimination | Expression::RequiresCurrentItem);
}
else if(name.localName() == StandardLocalNames::document)
{
s = addFunction(StandardLocalNames::document, 1, 2, CommonSequenceTypes::OneOrMoreDocumentNodes,
Expression::DisableElimination);
s->appendArgument(argument(np, "uri-sequence"), CommonSequenceTypes::ZeroOrMoreStrings);
s->appendArgument(argument(np, "base-uri-node"), CommonSequenceTypes::ExactlyOneNode);
}
else if(name.localName() == StandardLocalNames::unparsed_entity_uri)
{
s = addFunction(StandardLocalNames::unparsed_entity_uri, 1, 1, CommonSequenceTypes::ExactlyOneAnyURI,
Expression::RequiresFocus | Expression::DisableElimination);
s->appendArgument(argument(np, "entity-name"), CommonSequenceTypes::ExactlyOneString);
}
else if(name.localName() == StandardLocalNames::unparsed_entity_public_id)
{
s = addFunction(StandardLocalNames::unparsed_entity_public_id, 1, 1, CommonSequenceTypes::ExactlyOneString,
Expression::RequiresFocus | Expression::DisableElimination);
s->appendArgument(argument(np, "entity-name"), CommonSequenceTypes::ExactlyOneString);
}
}
return s;
}
/*!
Binds the variable \a name to the \a device so that $\a name can be
used from within the query to refer to the \a device. The QIODevice
\a device is exposed to the query as a URI of type \c{xs:anyURI},
which can be passed to the \c{fn:doc()} function to be read. E.g.,
this function can be used to pass an XML document in memory to
\c{fn:doc}.
\snippet doc/src/snippets/code/src_xmlpatterns_api_qxmlquery.cpp 1
The caller must ensure that \a device has been opened with at least
QIODevice::ReadOnly prior to this binding. Otherwise, behavior is
undefined.
If the query will access an XML document contained in a QString, use
a QBuffer as shown in the following snippet. Suppose \e myQString
contains \c{<document>content</document>}
\snippet doc/src/snippets/qxmlquery/bindingExample.cpp 0
\a name must not be \e null. \a {name}.isNull() must return false.
If \a name has already been bound, its previous binding will be
overridden. The URI that \a name evaluates to is arbitrary and may
change.
If the type of the variable binding changes (e.g., if a previous
binding by the same name was a QVariant, or if there was no previous
binding), isValid() will return \c{false}, and recompilation of the
query text is required. To recompile the query, call setQuery(). For
this reason, bindVariable() should be called before setQuery(), if
possible.
\note \a device must not be deleted while this QXmlQuery exists.
*/
void QXmlQuery::bindVariable(const QXmlName &name, QIODevice *device)
{
if(device && !device->isReadable())
{
qWarning("A null, or readable QIODevice must be passed.");
return;
}
if(name.isNull())
{
qWarning("The variable name cannot be null.");
return;
}
const QPatternist::VariableLoader::Ptr vl(d->variableLoader());
if(device)
{
const QVariant variant(QVariant::fromValue(device));
if(vl->invalidationRequired(name, variant))
d->recompileRequired();
vl->addBinding(name, variant);
/* We need to tell the resource loader to discard its document, because
* the underlying QIODevice has changed, but the variable name is the
* same which means that the URI is the same, and hence the resource
* loader will return the document for the old QIODevice.
*/
d->resourceLoader()->clear(QUrl(QLatin1String("tag:trolltech.com,2007:QtXmlPatterns:QIODeviceVariable:") + d->namePool.d->stringForLocalName(name.localName())));
}
else
{
vl->removeBinding(name);
d->recompileRequired();
}
}
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());
}
}
QPatternist::SequenceType::Ptr
ExternalSourceLoader::announceExternalVariable(const QXmlName name,
const QPatternist::SequenceType::Ptr &declaredType)
{
pDebug() << "ExternalSourceLoader::announceExternalVariable()";
Q_ASSERT(!name.isNull());
Q_ASSERT(declaredType);
Q_UNUSED(declaredType); /* Needed when bulding in release mode. */
if(name.namespaceURI() == QPatternist::StandardNamespaces::empty)
{
const VariableValue variable(m_variableMap.value(Global::namePool()->stringForLocalName(name.localName())));
if(variable.first.isEmpty())
return QPatternist::SequenceType::Ptr();
else
{
/* If announceDocument() can't load a document for uriForVar, it will return
* null, which we will too, which is fine, since we can't supply a value for
* this variable then. */
if(variable.second == Document)
return m_resourceLoader->announceDocument(variable.first, QPatternist::ResourceLoader::WillUse);
else if(variable.second == URI)
{
return QPatternist::CommonSequenceTypes::ExactlyOneString;
}
else
{
/* The type is Query, and we don't pre-load
* them. No particular reason, just not worth it. */
return QPatternist::CommonSequenceTypes::ZeroOrMoreItems;
}
}
}
else
return QPatternist::SequenceType::Ptr();
}
void AccelTreeBuilder<FromDocument>::attribute(const QXmlName &name, const QStringRef &value)
{
/* Attributes adds a namespace binding, so lets synthesize one.
*
* We optimize by checking whether we have a namespace for which a binding would
* be generated. Happens relatively rarely. */
if(name.hasPrefix())
namespaceBinding(QXmlName(name.namespaceURI(), 0, name.prefix()));
m_document->basicData.append(AccelTree::BasicNodeData(currentDepth(), currentParent(), QXmlNodeModelIndex::Attribute, 0, name));
++m_preNumber;
++m_size.top();
m_isPreviousAtomic = false;
if(name.namespaceURI() == StandardNamespaces::xml && name.localName() == StandardLocalNames::id)
{
const QString normalized(value.toString().simplified());
if(QXmlUtils::isNCName(normalized))
{
const QXmlName::LocalNameCode id = m_namePool->allocateLocalName(normalized);
const int oldSize = m_document->m_IDs.count();
m_document->m_IDs.insert(id, currentParent());
/* We don't run the value through m_attributeCompress here, because
* the likelyhood of it deing identical to another attribute is
* very small. */
m_document->data.insert(m_preNumber, normalized);
/**
* In the case that we're called for doc-available(), m_context is
* null, and we need to flag somehow that we failed to load this
* document.
*/
if(oldSize == m_document->m_IDs.count() && m_context) // TODO
{
Q_ASSERT(m_context);
m_context->error(QtXmlPatterns::tr("An %1-attribute with value %2 has already been declared.")
.arg(formatKeyword("xml:id"),
formatData(normalized)),
FromDocument ? ReportContext::FODC0002 : ReportContext::XQDY0091,
this);
}
}
else if(m_context) // TODO
{
Q_ASSERT(m_context);
/* If we're building from an XML Document(e.g, we're fed from QXmlStreamReader, we raise FODC0002,
* otherwise XQDY0091. */
m_context->error(QtXmlPatterns::tr("An %1-attribute must have a "
"valid %2 as value, which %3 isn't.").arg(formatKeyword("xml:id"),
formatType(m_namePool, BuiltinTypes::xsNCName),
formatData(value.toString())),
FromDocument ? ReportContext::FODC0002 : ReportContext::XQDY0091,
this);
}
}
else
m_document->data.insert(m_preNumber, *m_attributeCompress.insert(value.toString()));
}
void XmlQueryToWriter::startElement(const QXmlName & name)
{
_writer->writeStartElement(name.localName(_query->namePool()));
}
Item VariableLoader::itemForName(const QXmlName &name) const
{
const QVariant &variant = m_bindingHash.value(name);
if(variant.userType() == qMetaTypeId<QIODevice *>())
return Item(AnyURI::fromValue(QLatin1String("tag:trolltech.com,2007:QtXmlPatterns:QIODeviceVariable:") + m_namePool->stringForLocalName(name.localName())));
const QXmlItem item(qVariantValue<QXmlItem>(variant));
if(item.isNode())
return Item::fromPublic(item);
else
{
const QVariant atomicValue(item.toAtomicValue());
/* If the atomicValue is null it means it doesn't exist in m_bindingHash, and therefore it must
* be a QIODevice, since Patternist guarantees to only ask for variables that announceExternalVariable()
* has accepted. */
if(atomicValue.isNull())
return Item(AnyURI::fromValue(QLatin1String("tag:trolltech.com,2007:QtXmlPatterns:QIODeviceVariable:") + m_namePool->stringForLocalName(name.localName())));
else
return AtomicValue::toXDM(atomicValue);
}
}