| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| #include "sal/config.h" | |
| #include <climits> | |
| #include <cstddef> | |
| #include "com/sun/star/container/NoSuchElementException.hpp" | |
| #include "com/sun/star/uno/Reference.hxx" | |
| #include "com/sun/star/uno/RuntimeException.hpp" | |
| #include "com/sun/star/uno/XInterface.hpp" | |
| #include "osl/diagnose.h" | |
| #include "osl/file.h" | |
| #include "rtl/string.h" | |
| #include "rtl/ustring.h" | |
| #include "rtl/ustring.hxx" | |
| #include "sal/types.h" | |
| #include "xmlreader/pad.hxx" | |
| #include "xmlreader/span.hxx" | |
| #include "xmlreader/xmlreader.hxx" | |
| namespace xmlreader { | |
| namespace { | |
| namespace css = com::sun::star; | |
| bool isSpace(char c) { | |
| switch (c) { | |
| case '\x09': | |
| case '\x0A': | |
| case '\x0D': | |
| case ' ': | |
| return true; | |
| default: | |
| return false; | |
| } | |
| } | |
| } | |
| XmlReader::XmlReader(rtl::OUString const & fileUrl): | |
| fileUrl_(fileUrl) | |
| { | |
| switch (osl_openFile(fileUrl_.pData, &fileHandle_, osl_File_OpenFlag_Read)) | |
| { | |
| case osl_File_E_None: | |
| break; | |
| case osl_File_E_NOENT: | |
| throw css::container::NoSuchElementException( | |
| fileUrl_, css::uno::Reference< css::uno::XInterface >()); | |
| default: | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("cannot open ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| oslFileError e = osl_getFileSize(fileHandle_, &fileSize_); | |
| if (e == osl_File_E_None) { | |
| e = osl_mapFile( | |
| fileHandle_, &fileAddress_, fileSize_, 0, | |
| osl_File_MapFlag_WillNeed); | |
| } | |
| if (e != osl_File_E_None) { | |
| e = osl_closeFile(fileHandle_); | |
| if (e != osl_File_E_None) { | |
| OSL_TRACE("osl_closeFile failed with %ld", static_cast< long >(e)); | |
| } | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("cannot mmap ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| namespaceIris_.push_back( | |
| Span( | |
| RTL_CONSTASCII_STRINGPARAM( | |
| "http://www.w3.org/XML/1998/namespace"))); | |
| namespaces_.push_back( | |
| NamespaceData(Span(RTL_CONSTASCII_STRINGPARAM("xml")), NAMESPACE_XML)); | |
| pos_ = static_cast< char * >(fileAddress_); | |
| end_ = pos_ + fileSize_; | |
| state_ = STATE_CONTENT; | |
| } | |
| XmlReader::~XmlReader() { | |
| oslFileError e = osl_unmapFile(fileAddress_, fileSize_); | |
| if (e != osl_File_E_None) { | |
| OSL_TRACE("osl_unmapFile failed with %ld", static_cast< long >(e)); | |
| } | |
| e = osl_closeFile(fileHandle_); | |
| if (e != osl_File_E_None) { | |
| OSL_TRACE("osl_closeFile failed with %ld", static_cast< long >(e)); | |
| } | |
| } | |
| int XmlReader::registerNamespaceIri(Span const & iri) { | |
| int id = toNamespaceId(namespaceIris_.size()); | |
| namespaceIris_.push_back(iri); | |
| if (iri.equals( | |
| Span( | |
| RTL_CONSTASCII_STRINGPARAM( | |
| "http://www.w3.org/2001/XMLSchema-instance")))) | |
| { | |
| // Old user layer .xcu files used the xsi namespace prefix without | |
| // declaring a corresponding namespace binding, see issue 77174; reading | |
| // those files during migration would fail without this hack that can be | |
| // removed once migration is no longer relevant (see | |
| // configmgr::Components::parseModificationLayer): | |
| namespaces_.push_back( | |
| NamespaceData(Span(RTL_CONSTASCII_STRINGPARAM("xsi")), id)); | |
| } | |
| return id; | |
| } | |
| XmlReader::Result XmlReader::nextItem(Text reportText, Span * data, int * nsId) | |
| { | |
| switch (state_) { | |
| case STATE_CONTENT: | |
| switch (reportText) { | |
| case TEXT_NONE: | |
| return handleSkippedText(data, nsId); | |
| case TEXT_RAW: | |
| return handleRawText(data); | |
| case TEXT_NORMALIZED: | |
| return handleNormalizedText(data); | |
| } | |
| case STATE_START_TAG: | |
| return handleStartTag(nsId, data); | |
| case STATE_END_TAG: | |
| return handleEndTag(); | |
| case STATE_EMPTY_ELEMENT_TAG: | |
| handleElementEnd(); | |
| return RESULT_END; | |
| default: // STATE_DONE | |
| return RESULT_DONE; | |
| } | |
| } | |
| bool XmlReader::nextAttribute(int * nsId, Span * localName) { | |
| OSL_ASSERT(nsId != 0 && localName != 0); | |
| if (firstAttribute_) { | |
| currentAttribute_ = attributes_.begin(); | |
| firstAttribute_ = false; | |
| } else { | |
| ++currentAttribute_; | |
| } | |
| if (currentAttribute_ == attributes_.end()) { | |
| return false; | |
| } | |
| if (currentAttribute_->nameColon == 0) { | |
| *nsId = NAMESPACE_NONE; | |
| *localName = Span( | |
| currentAttribute_->nameBegin, | |
| currentAttribute_->nameEnd - currentAttribute_->nameBegin); | |
| } else { | |
| *nsId = getNamespaceId( | |
| Span( | |
| currentAttribute_->nameBegin, | |
| currentAttribute_->nameColon - currentAttribute_->nameBegin)); | |
| *localName = Span( | |
| currentAttribute_->nameColon + 1, | |
| currentAttribute_->nameEnd - (currentAttribute_->nameColon + 1)); | |
| } | |
| return true; | |
| } | |
| Span XmlReader::getAttributeValue(bool fullyNormalize) { | |
| return handleAttributeValue( | |
| currentAttribute_->valueBegin, currentAttribute_->valueEnd, | |
| fullyNormalize); | |
| } | |
| int XmlReader::getNamespaceId(Span const & prefix) const { | |
| for (NamespaceList::const_reverse_iterator i(namespaces_.rbegin()); | |
| i != namespaces_.rend(); ++i) | |
| { | |
| if (prefix.equals(i->prefix)) { | |
| return i->nsId; | |
| } | |
| } | |
| return NAMESPACE_UNKNOWN; | |
| } | |
| rtl::OUString XmlReader::getUrl() const { | |
| return fileUrl_; | |
| } | |
| void XmlReader::normalizeLineEnds(Span const & text) { | |
| char const * p = text.begin; | |
| sal_Int32 n = text.length; | |
| for (;;) { | |
| sal_Int32 i = rtl_str_indexOfChar_WithLength(p, n, '\x0D'); | |
| if (i < 0) { | |
| break; | |
| } | |
| pad_.add(p, i); | |
| p += i + 1; | |
| n -= i + 1; | |
| if (n == 0 || *p != '\x0A') { | |
| pad_.add(RTL_CONSTASCII_STRINGPARAM("\x0A")); | |
| } | |
| } | |
| pad_.add(p, n); | |
| } | |
| void XmlReader::skipSpace() { | |
| while (isSpace(peek())) { | |
| ++pos_; | |
| } | |
| } | |
| bool XmlReader::skipComment() { | |
| if (rtl_str_shortenedCompare_WithLength( | |
| pos_, end_ - pos_, RTL_CONSTASCII_STRINGPARAM("--"), | |
| RTL_CONSTASCII_LENGTH("--")) != | |
| 0) | |
| { | |
| return false; | |
| } | |
| pos_ += RTL_CONSTASCII_LENGTH("--"); | |
| sal_Int32 i = rtl_str_indexOfStr_WithLength( | |
| pos_, end_ - pos_, RTL_CONSTASCII_STRINGPARAM("--")); | |
| if (i < 0) { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "premature end (within comment) of ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| pos_ += i + RTL_CONSTASCII_LENGTH("--"); | |
| if (read() != '>') { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "illegal \"--\" within comment in ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| return true; | |
| } | |
| void XmlReader::skipProcessingInstruction() { | |
| sal_Int32 i = rtl_str_indexOfStr_WithLength( | |
| pos_, end_ - pos_, RTL_CONSTASCII_STRINGPARAM("?>")); | |
| if (i < 0) { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("bad '<?' in ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| pos_ += i + RTL_CONSTASCII_LENGTH("?>"); | |
| } | |
| void XmlReader::skipDocumentTypeDeclaration() { | |
| // Neither is it checked that the doctypedecl is at the correct position in | |
| // the document, nor that it is well-formed: | |
| for (;;) { | |
| char c = read(); | |
| switch (c) { | |
| case '\0': // i.e., EOF | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "premature end (within DTD) of ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| case '"': | |
| case '\'': | |
| { | |
| sal_Int32 i = rtl_str_indexOfChar_WithLength( | |
| pos_, end_ - pos_, c); | |
| if (i < 0) { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "premature end (within DTD) of ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| pos_ += i + 1; | |
| } | |
| break; | |
| case '>': | |
| return; | |
| case '[': | |
| for (;;) { | |
| c = read(); | |
| switch (c) { | |
| case '\0': // i.e., EOF | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "premature end (within DTD) of ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| case '"': | |
| case '\'': | |
| { | |
| sal_Int32 i = rtl_str_indexOfChar_WithLength( | |
| pos_, end_ - pos_, c); | |
| if (i < 0) { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "premature end (within DTD) of ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| pos_ += i + 1; | |
| } | |
| break; | |
| case '<': | |
| switch (read()) { | |
| case '\0': // i.e., EOF | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "premature end (within DTD) of ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| case '!': | |
| skipComment(); | |
| break; | |
| case '?': | |
| skipProcessingInstruction(); | |
| break; | |
| default: | |
| break; | |
| } | |
| break; | |
| case ']': | |
| skipSpace(); | |
| if (read() != '>') { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "missing \">\" of DTD in ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| return; | |
| default: | |
| break; | |
| } | |
| } | |
| default: | |
| break; | |
| } | |
| } | |
| } | |
| Span XmlReader::scanCdataSection() { | |
| if (rtl_str_shortenedCompare_WithLength( | |
| pos_, end_ - pos_, RTL_CONSTASCII_STRINGPARAM("[CDATA["), | |
| RTL_CONSTASCII_LENGTH("[CDATA[")) != | |
| 0) | |
| { | |
| return Span(); | |
| } | |
| pos_ += RTL_CONSTASCII_LENGTH("[CDATA["); | |
| char const * begin = pos_; | |
| sal_Int32 i = rtl_str_indexOfStr_WithLength( | |
| pos_, end_ - pos_, RTL_CONSTASCII_STRINGPARAM("]]>")); | |
| if (i < 0) { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "premature end (within CDATA section) of ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| pos_ += i + RTL_CONSTASCII_LENGTH("]]>"); | |
| return Span(begin, i); | |
| } | |
| bool XmlReader::scanName(char const ** nameColon) { | |
| OSL_ASSERT(nameColon != 0 && *nameColon == 0); | |
| for (char const * begin = pos_;; ++pos_) { | |
| switch (peek()) { | |
| case '\0': // i.e., EOF | |
| case '\x09': | |
| case '\x0A': | |
| case '\x0D': | |
| case ' ': | |
| case '/': | |
| case '=': | |
| case '>': | |
| return pos_ != begin; | |
| case ':': | |
| *nameColon = pos_; | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| } | |
| int XmlReader::scanNamespaceIri(char const * begin, char const * end) { | |
| OSL_ASSERT(begin != 0 && begin <= end); | |
| Span iri(handleAttributeValue(begin, end, false)); | |
| for (NamespaceIris::size_type i = 0; i < namespaceIris_.size(); ++i) { | |
| if (namespaceIris_[i].equals(iri)) { | |
| return toNamespaceId(i); | |
| } | |
| } | |
| return XmlReader::NAMESPACE_UNKNOWN; | |
| } | |
| char const * XmlReader::handleReference(char const * position, char const * end) | |
| { | |
| OSL_ASSERT(position != 0 && *position == '&' && position < end); | |
| ++position; | |
| if (*position == '#') { | |
| ++position; | |
| sal_Int32 val = 0; | |
| char const * p; | |
| if (*position == 'x') { | |
| ++position; | |
| p = position; | |
| for (;; ++position) { | |
| char c = *position; | |
| if (c >= '0' && c <= '9') { | |
| val = 16 * val + (c - '0'); | |
| } else if (c >= 'A' && c <= 'F') { | |
| val = 16 * val + (c - 'A') + 10; | |
| } else if (c >= 'a' && c <= 'f') { | |
| val = 16 * val + (c - 'a') + 10; | |
| } else { | |
| break; | |
| } | |
| if (val > 0x10FFFF) { // avoid overflow | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "'&#x...' too large in ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| } | |
| } else { | |
| p = position; | |
| for (;; ++position) { | |
| char c = *position; | |
| if (c >= '0' && c <= '9') { | |
| val = 10 * val + (c - '0'); | |
| } else { | |
| break; | |
| } | |
| if (val > 0x10FFFF) { // avoid overflow | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "'&#...' too large in ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| } | |
| } | |
| if (position == p || *position++ != ';') { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM("'&#...' missing ';' in ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| OSL_ASSERT(val >= 0 && val <= 0x10FFFF); | |
| if ((val < 0x20 && val != 0x9 && val != 0xA && val != 0xD) || | |
| (val >= 0xD800 && val <= 0xDFFF) || val == 0xFFFE || val == 0xFFFF) | |
| { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "character reference denoting invalid character in ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| char buf[4]; | |
| sal_Int32 len; | |
| if (val < 0x80) { | |
| buf[0] = static_cast< char >(val); | |
| len = 1; | |
| } else if (val < 0x800) { | |
| buf[0] = static_cast< char >((val >> 6) | 0xC0); | |
| buf[1] = static_cast< char >((val & 0x3F) | 0x80); | |
| len = 2; | |
| } else if (val < 0x10000) { | |
| buf[0] = static_cast< char >((val >> 12) | 0xE0); | |
| buf[1] = static_cast< char >(((val >> 6) & 0x3F) | 0x80); | |
| buf[2] = static_cast< char >((val & 0x3F) | 0x80); | |
| len = 3; | |
| } else { | |
| buf[0] = static_cast< char >((val >> 18) | 0xF0); | |
| buf[1] = static_cast< char >(((val >> 12) & 0x3F) | 0x80); | |
| buf[2] = static_cast< char >(((val >> 6) & 0x3F) | 0x80); | |
| buf[3] = static_cast< char >((val & 0x3F) | 0x80); | |
| len = 4; | |
| } | |
| pad_.addEphemeral(buf, len); | |
| return position; | |
| } else { | |
| struct EntityRef { | |
| char const * inBegin; | |
| sal_Int32 inLength; | |
| char const * outBegin; | |
| sal_Int32 outLength; | |
| }; | |
| static EntityRef const refs[] = { | |
| { RTL_CONSTASCII_STRINGPARAM("amp;"), | |
| RTL_CONSTASCII_STRINGPARAM("&") }, | |
| { RTL_CONSTASCII_STRINGPARAM("lt;"), | |
| RTL_CONSTASCII_STRINGPARAM("<") }, | |
| { RTL_CONSTASCII_STRINGPARAM("gt;"), | |
| RTL_CONSTASCII_STRINGPARAM(">") }, | |
| { RTL_CONSTASCII_STRINGPARAM("apos;"), | |
| RTL_CONSTASCII_STRINGPARAM("'") }, | |
| { RTL_CONSTASCII_STRINGPARAM("quot;"), | |
| RTL_CONSTASCII_STRINGPARAM("\"") } }; | |
| for (std::size_t i = 0; i < sizeof refs / sizeof refs[0]; ++i) { | |
| if (rtl_str_shortenedCompare_WithLength( | |
| position, end - position, refs[i].inBegin, refs[i].inLength, | |
| refs[i].inLength) == | |
| 0) | |
| { | |
| position += refs[i].inLength; | |
| pad_.add(refs[i].outBegin, refs[i].outLength); | |
| return position; | |
| } | |
| } | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM("unknown entity reference in ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| } | |
| Span XmlReader::handleAttributeValue( | |
| char const * begin, char const * end, bool fullyNormalize) | |
| { | |
| pad_.clear(); | |
| if (fullyNormalize) { | |
| while (begin != end && isSpace(*begin)) { | |
| ++begin; | |
| } | |
| while (end != begin && isSpace(end[-1])) { | |
| --end; | |
| } | |
| char const * p = begin; | |
| enum Space { SPACE_NONE, SPACE_SPAN, SPACE_BREAK }; | |
| // a single true space character can go into the current span, | |
| // everything else breaks the span | |
| Space space = SPACE_NONE; | |
| while (p != end) { | |
| switch (*p) { | |
| case '\x09': | |
| case '\x0A': | |
| case '\x0D': | |
| switch (space) { | |
| case SPACE_NONE: | |
| pad_.add(begin, p - begin); | |
| pad_.add(RTL_CONSTASCII_STRINGPARAM(" ")); | |
| space = SPACE_BREAK; | |
| break; | |
| case SPACE_SPAN: | |
| pad_.add(begin, p - begin); | |
| space = SPACE_BREAK; | |
| break; | |
| case SPACE_BREAK: | |
| break; | |
| } | |
| begin = ++p; | |
| break; | |
| case ' ': | |
| switch (space) { | |
| case SPACE_NONE: | |
| ++p; | |
| space = SPACE_SPAN; | |
| break; | |
| case SPACE_SPAN: | |
| pad_.add(begin, p - begin); | |
| begin = ++p; | |
| space = SPACE_BREAK; | |
| break; | |
| case SPACE_BREAK: | |
| begin = ++p; | |
| break; | |
| } | |
| break; | |
| case '&': | |
| pad_.add(begin, p - begin); | |
| p = handleReference(p, end); | |
| begin = p; | |
| space = SPACE_NONE; | |
| break; | |
| default: | |
| ++p; | |
| space = SPACE_NONE; | |
| break; | |
| } | |
| } | |
| pad_.add(begin, p - begin); | |
| } else { | |
| char const * p = begin; | |
| while (p != end) { | |
| switch (*p) { | |
| case '\x09': | |
| case '\x0A': | |
| pad_.add(begin, p - begin); | |
| begin = ++p; | |
| pad_.add(RTL_CONSTASCII_STRINGPARAM(" ")); | |
| break; | |
| case '\x0D': | |
| pad_.add(begin, p - begin); | |
| ++p; | |
| if (peek() == '\x0A') { | |
| ++p; | |
| } | |
| begin = p; | |
| pad_.add(RTL_CONSTASCII_STRINGPARAM(" ")); | |
| break; | |
| case '&': | |
| pad_.add(begin, p - begin); | |
| p = handleReference(p, end); | |
| begin = p; | |
| break; | |
| default: | |
| ++p; | |
| break; | |
| } | |
| } | |
| pad_.add(begin, p - begin); | |
| } | |
| return pad_.get(); | |
| } | |
| XmlReader::Result XmlReader::handleStartTag(int * nsId, Span * localName) { | |
| OSL_ASSERT(nsId != 0 && localName); | |
| char const * nameBegin = pos_; | |
| char const * nameColon = 0; | |
| if (!scanName(&nameColon)) { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("bad tag name in ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| char const * nameEnd = pos_; | |
| NamespaceList::size_type inheritedNamespaces = namespaces_.size(); | |
| bool hasDefaultNs = false; | |
| int defaultNsId = NAMESPACE_NONE; | |
| attributes_.clear(); | |
| for (;;) { | |
| char const * p = pos_; | |
| skipSpace(); | |
| if (peek() == '/' || peek() == '>') { | |
| break; | |
| } | |
| if (pos_ == p) { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "missing whitespace before attribute in ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| char const * attrNameBegin = pos_; | |
| char const * attrNameColon = 0; | |
| if (!scanName(&attrNameColon)) { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM("bad attribute name in ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| char const * attrNameEnd = pos_; | |
| skipSpace(); | |
| if (read() != '=') { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("missing '=' in ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| skipSpace(); | |
| char del = read(); | |
| if (del != '\'' && del != '"') { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM("bad attribute value in ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| char const * valueBegin = pos_; | |
| sal_Int32 i = rtl_str_indexOfChar_WithLength(pos_, end_ - pos_, del); | |
| if (i < 0) { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM( | |
| "unterminated attribute value in ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| char const * valueEnd = pos_ + i; | |
| pos_ += i + 1; | |
| if (attrNameColon == 0 && | |
| Span(attrNameBegin, attrNameEnd - attrNameBegin).equals( | |
| RTL_CONSTASCII_STRINGPARAM("xmlns"))) | |
| { | |
| hasDefaultNs = true; | |
| defaultNsId = scanNamespaceIri(valueBegin, valueEnd); | |
| } else if (attrNameColon != 0 && | |
| Span(attrNameBegin, attrNameColon - attrNameBegin).equals( | |
| RTL_CONSTASCII_STRINGPARAM("xmlns"))) | |
| { | |
| namespaces_.push_back( | |
| NamespaceData( | |
| Span(attrNameColon + 1, attrNameEnd - (attrNameColon + 1)), | |
| scanNamespaceIri(valueBegin, valueEnd))); | |
| } else { | |
| attributes_.push_back( | |
| AttributeData( | |
| attrNameBegin, attrNameEnd, attrNameColon, valueBegin, | |
| valueEnd)); | |
| } | |
| } | |
| if (!hasDefaultNs && !elements_.empty()) { | |
| defaultNsId = elements_.top().defaultNamespaceId; | |
| } | |
| firstAttribute_ = true; | |
| if (peek() == '/') { | |
| state_ = STATE_EMPTY_ELEMENT_TAG; | |
| ++pos_; | |
| } else { | |
| state_ = STATE_CONTENT; | |
| } | |
| if (peek() != '>') { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("missing '>' in ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| ++pos_; | |
| elements_.push( | |
| ElementData( | |
| Span(nameBegin, nameEnd - nameBegin), inheritedNamespaces, | |
| defaultNsId)); | |
| if (nameColon == 0) { | |
| *nsId = defaultNsId; | |
| *localName = Span(nameBegin, nameEnd - nameBegin); | |
| } else { | |
| *nsId = getNamespaceId(Span(nameBegin, nameColon - nameBegin)); | |
| *localName = Span(nameColon + 1, nameEnd - (nameColon + 1)); | |
| } | |
| return RESULT_BEGIN; | |
| } | |
| XmlReader::Result XmlReader::handleEndTag() { | |
| if (elements_.empty()) { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM("spurious end tag in ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| char const * nameBegin = pos_; | |
| char const * nameColon = 0; | |
| if (!scanName(&nameColon) || | |
| !elements_.top().name.equals(nameBegin, pos_ - nameBegin)) | |
| { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("tag mismatch in ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| handleElementEnd(); | |
| skipSpace(); | |
| if (peek() != '>') { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("missing '>' in ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| ++pos_; | |
| return RESULT_END; | |
| } | |
| void XmlReader::handleElementEnd() { | |
| OSL_ASSERT(!elements_.empty()); | |
| namespaces_.resize(elements_.top().inheritedNamespaces); | |
| elements_.pop(); | |
| state_ = elements_.empty() ? STATE_DONE : STATE_CONTENT; | |
| } | |
| XmlReader::Result XmlReader::handleSkippedText(Span * data, int * nsId) { | |
| for (;;) { | |
| sal_Int32 i = rtl_str_indexOfChar_WithLength(pos_, end_ - pos_, '<'); | |
| if (i < 0) { | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM("premature end of ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| } | |
| pos_ += i + 1; | |
| switch (peek()) { | |
| case '!': | |
| ++pos_; | |
| if (!skipComment() && !scanCdataSection().is()) { | |
| skipDocumentTypeDeclaration(); | |
| } | |
| break; | |
| case '/': | |
| ++pos_; | |
| return handleEndTag(); | |
| case '?': | |
| ++pos_; | |
| skipProcessingInstruction(); | |
| break; | |
| default: | |
| return handleStartTag(nsId, data); | |
| } | |
| } | |
| } | |
| XmlReader::Result XmlReader::handleRawText(Span * text) { | |
| pad_.clear(); | |
| for (char const * begin = pos_;;) { | |
| switch (peek()) { | |
| case '\0': // i.e., EOF | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM("premature end of ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| case '\x0D': | |
| pad_.add(begin, pos_ - begin); | |
| ++pos_; | |
| if (peek() != '\x0A') { | |
| pad_.add(RTL_CONSTASCII_STRINGPARAM("\x0A")); | |
| } | |
| begin = pos_; | |
| break; | |
| case '&': | |
| pad_.add(begin, pos_ - begin); | |
| pos_ = handleReference(pos_, end_); | |
| begin = pos_; | |
| break; | |
| case '<': | |
| pad_.add(begin, pos_ - begin); | |
| ++pos_; | |
| switch (peek()) { | |
| case '!': | |
| ++pos_; | |
| if (!skipComment()) { | |
| Span cdata(scanCdataSection()); | |
| if (cdata.is()) { | |
| normalizeLineEnds(cdata); | |
| } else { | |
| skipDocumentTypeDeclaration(); | |
| } | |
| } | |
| begin = pos_; | |
| break; | |
| case '/': | |
| *text = pad_.get(); | |
| ++pos_; | |
| state_ = STATE_END_TAG; | |
| return RESULT_TEXT; | |
| case '?': | |
| ++pos_; | |
| skipProcessingInstruction(); | |
| begin = pos_; | |
| break; | |
| default: | |
| *text = pad_.get(); | |
| state_ = STATE_START_TAG; | |
| return RESULT_TEXT; | |
| } | |
| break; | |
| default: | |
| ++pos_; | |
| break; | |
| } | |
| } | |
| } | |
| XmlReader::Result XmlReader::handleNormalizedText(Span * text) { | |
| pad_.clear(); | |
| char const * flowBegin = pos_; | |
| char const * flowEnd = pos_; | |
| enum Space { SPACE_START, SPACE_NONE, SPACE_SPAN, SPACE_BREAK }; | |
| // a single true space character can go into the current flow, | |
| // everything else breaks the flow | |
| Space space = SPACE_START; | |
| for (;;) { | |
| switch (peek()) { | |
| case '\0': // i.e., EOF | |
| throw css::uno::RuntimeException( | |
| (rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM("premature end of ")) + | |
| fileUrl_), | |
| css::uno::Reference< css::uno::XInterface >()); | |
| case '\x09': | |
| case '\x0A': | |
| case '\x0D': | |
| switch (space) { | |
| case SPACE_START: | |
| case SPACE_BREAK: | |
| break; | |
| case SPACE_NONE: | |
| case SPACE_SPAN: | |
| space = SPACE_BREAK; | |
| break; | |
| } | |
| ++pos_; | |
| break; | |
| case ' ': | |
| switch (space) { | |
| case SPACE_START: | |
| case SPACE_BREAK: | |
| break; | |
| case SPACE_NONE: | |
| space = SPACE_SPAN; | |
| break; | |
| case SPACE_SPAN: | |
| space = SPACE_BREAK; | |
| break; | |
| } | |
| ++pos_; | |
| break; | |
| case '&': | |
| switch (space) { | |
| case SPACE_START: | |
| break; | |
| case SPACE_NONE: | |
| case SPACE_SPAN: | |
| pad_.add(flowBegin, pos_ - flowBegin); | |
| break; | |
| case SPACE_BREAK: | |
| pad_.add(flowBegin, flowEnd - flowBegin); | |
| pad_.add(RTL_CONSTASCII_STRINGPARAM(" ")); | |
| break; | |
| } | |
| pos_ = handleReference(pos_, end_); | |
| flowBegin = pos_; | |
| flowEnd = pos_; | |
| space = SPACE_NONE; | |
| break; | |
| case '<': | |
| ++pos_; | |
| switch (peek()) { | |
| case '!': | |
| ++pos_; | |
| if (skipComment()) { | |
| space = SPACE_BREAK; | |
| } else { | |
| Span cdata(scanCdataSection()); | |
| if (cdata.is()) { | |
| // CDATA is not normalized (similar to character | |
| // references; it keeps the code simple), but it might | |
| // arguably be better to normalize it: | |
| switch (space) { | |
| case SPACE_START: | |
| break; | |
| case SPACE_NONE: | |
| case SPACE_SPAN: | |
| pad_.add(flowBegin, pos_ - flowBegin); | |
| break; | |
| case SPACE_BREAK: | |
| pad_.add(flowBegin, flowEnd - flowBegin); | |
| pad_.add(RTL_CONSTASCII_STRINGPARAM(" ")); | |
| break; | |
| } | |
| normalizeLineEnds(cdata); | |
| flowBegin = pos_; | |
| flowEnd = pos_; | |
| space = SPACE_NONE; | |
| } else { | |
| skipDocumentTypeDeclaration(); | |
| } | |
| } | |
| break; | |
| case '/': | |
| ++pos_; | |
| pad_.add(flowBegin, flowEnd - flowBegin); | |
| *text = pad_.get(); | |
| state_ = STATE_END_TAG; | |
| return RESULT_TEXT; | |
| case '?': | |
| ++pos_; | |
| skipProcessingInstruction(); | |
| space = SPACE_BREAK; | |
| break; | |
| default: | |
| pad_.add(flowBegin, flowEnd - flowBegin); | |
| *text = pad_.get(); | |
| state_ = STATE_START_TAG; | |
| return RESULT_TEXT; | |
| } | |
| break; | |
| default: | |
| switch (space) { | |
| case SPACE_START: | |
| flowBegin = pos_; | |
| break; | |
| case SPACE_NONE: | |
| case SPACE_SPAN: | |
| break; | |
| case SPACE_BREAK: | |
| pad_.add(flowBegin, flowEnd - flowBegin); | |
| pad_.add(RTL_CONSTASCII_STRINGPARAM(" ")); | |
| flowBegin = pos_; | |
| break; | |
| } | |
| flowEnd = ++pos_; | |
| space = SPACE_NONE; | |
| break; | |
| } | |
| } | |
| } | |
| int XmlReader::toNamespaceId(NamespaceIris::size_type pos) { | |
| OSL_ASSERT(pos <= INT_MAX); | |
| return static_cast< int >(pos); | |
| } | |
| } |