equal
deleted
inserted
replaced
1 /**************************************************************************** |
1 /**************************************************************************** |
2 ** |
2 ** |
3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). |
3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). |
4 ** All rights reserved. |
4 ** All rights reserved. |
5 ** Contact: Nokia Corporation (qt-info@nokia.com) |
5 ** Contact: Nokia Corporation (qt-info@nokia.com) |
6 ** |
6 ** |
7 ** This file is part of the QtXmlPatterns module of the Qt Toolkit. |
7 ** This file is part of the QtXmlPatterns module of the Qt Toolkit. |
8 ** |
8 ** |
262 |
262 |
263 setupStateMachines(); |
263 setupStateMachines(); |
264 setupBuiltinTypeNames(); |
264 setupBuiltinTypeNames(); |
265 } |
265 } |
266 |
266 |
|
267 void XsdSchemaParser::addIncludedSchemas(const NamespaceSet &schemas) |
|
268 { |
|
269 m_includedSchemas += schemas; |
|
270 } |
|
271 |
267 void XsdSchemaParser::setIncludedSchemas(const NamespaceSet &schemas) |
272 void XsdSchemaParser::setIncludedSchemas(const NamespaceSet &schemas) |
268 { |
273 { |
269 m_includedSchemas = schemas; |
274 m_includedSchemas = schemas; |
270 } |
275 } |
271 |
276 |
|
277 void XsdSchemaParser::addImportedSchemas(const NamespaceSet &schemas) |
|
278 { |
|
279 m_importedSchemas += schemas; |
|
280 } |
|
281 |
272 void XsdSchemaParser::setImportedSchemas(const NamespaceSet &schemas) |
282 void XsdSchemaParser::setImportedSchemas(const NamespaceSet &schemas) |
273 { |
283 { |
274 m_importedSchemas = schemas; |
284 m_importedSchemas = schemas; |
|
285 } |
|
286 |
|
287 void XsdSchemaParser::addRedefinedSchemas(const NamespaceSet &schemas) |
|
288 { |
|
289 m_redefinedSchemas += schemas; |
275 } |
290 } |
276 |
291 |
277 void XsdSchemaParser::setRedefinedSchemas(const NamespaceSet &schemas) |
292 void XsdSchemaParser::setRedefinedSchemas(const NamespaceSet &schemas) |
278 { |
293 { |
279 m_redefinedSchemas = schemas; |
294 m_redefinedSchemas = schemas; |
295 m_documentURI = uri; |
310 m_documentURI = uri; |
296 |
311 |
297 // prevent to get included/imported/redefined twice |
312 // prevent to get included/imported/redefined twice |
298 m_includedSchemas.insert(uri); |
313 m_includedSchemas.insert(uri); |
299 m_importedSchemas.insert(uri); |
314 m_importedSchemas.insert(uri); |
|
315 m_redefinedSchemas.insert(uri); |
300 } |
316 } |
301 |
317 |
302 QUrl XsdSchemaParser::documentURI() const |
318 QUrl XsdSchemaParser::documentURI() const |
303 { |
319 { |
304 return m_documentURI; |
320 return m_documentURI; |
592 parser.setDocumentURI(url); |
608 parser.setDocumentURI(url); |
593 parser.setTargetNamespaceExtended(m_targetNamespace); |
609 parser.setTargetNamespaceExtended(m_targetNamespace); |
594 parser.setIncludedSchemas(m_includedSchemas); |
610 parser.setIncludedSchemas(m_includedSchemas); |
595 parser.setImportedSchemas(m_importedSchemas); |
611 parser.setImportedSchemas(m_importedSchemas); |
596 parser.setRedefinedSchemas(m_redefinedSchemas); |
612 parser.setRedefinedSchemas(m_redefinedSchemas); |
597 if (!parser.parse(XsdSchemaParser::IncludeParser)) |
613 if (!parser.parse(XsdSchemaParser::IncludeParser)) { |
598 return; |
614 return; |
|
615 } else { |
|
616 // add indirectly loaded schemas to the list of already loaded ones |
|
617 addIncludedSchemas(parser.m_includedSchemas); |
|
618 addImportedSchemas(parser.m_importedSchemas); |
|
619 addRedefinedSchemas(parser.m_redefinedSchemas); |
|
620 } |
599 } |
621 } |
600 } |
622 } |
601 |
623 |
602 validateIdAttribute("include"); |
624 validateIdAttribute("include"); |
603 |
625 |
682 parser.setDocumentURI(url); |
704 parser.setDocumentURI(url); |
683 parser.setTargetNamespace(importNamespace); |
705 parser.setTargetNamespace(importNamespace); |
684 parser.setIncludedSchemas(m_includedSchemas); |
706 parser.setIncludedSchemas(m_includedSchemas); |
685 parser.setImportedSchemas(m_importedSchemas); |
707 parser.setImportedSchemas(m_importedSchemas); |
686 parser.setRedefinedSchemas(m_redefinedSchemas); |
708 parser.setRedefinedSchemas(m_redefinedSchemas); |
687 if (!parser.parse(XsdSchemaParser::ImportParser)) |
709 if (!parser.parse(XsdSchemaParser::ImportParser)) { |
688 return; |
710 return; |
|
711 } else { |
|
712 // add indirectly loaded schemas to the list of already loaded ones |
|
713 addIncludedSchemas(parser.m_includedSchemas); |
|
714 addImportedSchemas(parser.m_importedSchemas); |
|
715 addRedefinedSchemas(parser.m_redefinedSchemas); |
|
716 } |
689 } |
717 } |
690 } |
718 } |
691 } else { |
719 } else { |
692 // check whether it is a known namespace we have a builtin schema for |
720 // check whether it is a known namespace we have a builtin schema for |
693 if (!importNamespace.isEmpty()) { |
721 if (!importNamespace.isEmpty()) { |
700 parser.setDocumentURI(importNamespace); |
728 parser.setDocumentURI(importNamespace); |
701 parser.setTargetNamespace(importNamespace); |
729 parser.setTargetNamespace(importNamespace); |
702 parser.setIncludedSchemas(m_includedSchemas); |
730 parser.setIncludedSchemas(m_includedSchemas); |
703 parser.setImportedSchemas(m_importedSchemas); |
731 parser.setImportedSchemas(m_importedSchemas); |
704 parser.setRedefinedSchemas(m_redefinedSchemas); |
732 parser.setRedefinedSchemas(m_redefinedSchemas); |
705 if (!parser.parse(XsdSchemaParser::ImportParser)) |
733 if (!parser.parse(XsdSchemaParser::ImportParser)) { |
706 return; |
734 return; |
|
735 } else { |
|
736 // add indirectly loaded schemas to the list of already loaded ones |
|
737 addIncludedSchemas(parser.m_includedSchemas); |
|
738 addImportedSchemas(parser.m_importedSchemas); |
|
739 addRedefinedSchemas(parser.m_redefinedSchemas); |
|
740 } |
707 } |
741 } |
708 } |
742 } |
709 } else { |
743 } else { |
710 // we don't import anything... that is valid according to the schema |
744 // we don't import anything... that is valid according to the schema |
711 } |
745 } |
837 parser.setDocumentURI(url); |
871 parser.setDocumentURI(url); |
838 parser.setTargetNamespaceExtended(m_targetNamespace); |
872 parser.setTargetNamespaceExtended(m_targetNamespace); |
839 parser.setIncludedSchemas(m_includedSchemas); |
873 parser.setIncludedSchemas(m_includedSchemas); |
840 parser.setImportedSchemas(m_importedSchemas); |
874 parser.setImportedSchemas(m_importedSchemas); |
841 parser.setRedefinedSchemas(m_redefinedSchemas); |
875 parser.setRedefinedSchemas(m_redefinedSchemas); |
842 if (!parser.parse(XsdSchemaParser::RedefineParser)) |
876 if (!parser.parse(XsdSchemaParser::RedefineParser)) { |
843 return; |
877 return; |
|
878 } else { |
|
879 // add indirectly loaded schemas to the list of already loaded ones |
|
880 addIncludedSchemas(parser.m_includedSchemas); |
|
881 addImportedSchemas(parser.m_importedSchemas); |
|
882 addRedefinedSchemas(parser.m_redefinedSchemas); |
|
883 } |
844 |
884 |
845 delete reply; |
885 delete reply; |
846 } |
886 } |
847 } |
887 } |
848 |
888 |
4830 |
4870 |
4831 tagValidator.validate(token); |
4871 tagValidator.validate(token); |
4832 |
4872 |
4833 if (isSchemaTag(XsdSchemaToken::Annotation, token, namespaceToken)) { |
4873 if (isSchemaTag(XsdSchemaToken::Annotation, token, namespaceToken)) { |
4834 const XsdAnnotation::Ptr annotation = parseAnnotation(); |
4874 const XsdAnnotation::Ptr annotation = parseAnnotation(); |
4835 element->addAnnotation(annotation); |
4875 term->addAnnotation(annotation); |
4836 } else if (isSchemaTag(XsdSchemaToken::SimpleType, token, namespaceToken)) { |
4876 } else if (isSchemaTag(XsdSchemaToken::SimpleType, token, namespaceToken)) { |
4837 if (hasRefAttribute) { |
4877 if (hasRefAttribute) { |
4838 error(QtXmlPatterns::tr("%1 element with %2 child element must not have a %3 attribute.") |
4878 error(QtXmlPatterns::tr("%1 element with %2 child element must not have a %3 attribute.") |
4839 .arg(formatElement("element")) |
4879 .arg(formatElement("element")) |
4840 .arg(formatElement("simpleType")) |
4880 .arg(formatElement("simpleType")) |