summaryrefslogtreecommitdiffstats
path: root/intl/uconv/nsConverterInputStream.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /intl/uconv/nsConverterInputStream.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'intl/uconv/nsConverterInputStream.cpp')
-rw-r--r--intl/uconv/nsConverterInputStream.cpp245
1 files changed, 245 insertions, 0 deletions
diff --git a/intl/uconv/nsConverterInputStream.cpp b/intl/uconv/nsConverterInputStream.cpp
new file mode 100644
index 000000000..11d0142c0
--- /dev/null
+++ b/intl/uconv/nsConverterInputStream.cpp
@@ -0,0 +1,245 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsConverterInputStream.h"
+#include "nsIInputStream.h"
+#include "nsReadLine.h"
+#include "nsStreamUtils.h"
+#include <algorithm>
+#include "mozilla/dom/EncodingUtils.h"
+
+using mozilla::dom::EncodingUtils;
+
+#define CONVERTER_BUFFER_SIZE 8192
+
+NS_IMPL_ISUPPORTS(nsConverterInputStream, nsIConverterInputStream,
+ nsIUnicharInputStream, nsIUnicharLineInputStream)
+
+
+NS_IMETHODIMP
+nsConverterInputStream::Init(nsIInputStream* aStream,
+ const char *aCharset,
+ int32_t aBufferSize,
+ char16_t aReplacementChar)
+{
+ nsAutoCString label;
+ if (!aCharset) {
+ label.AssignLiteral("UTF-8");
+ } else {
+ label = aCharset;
+ }
+
+ if (aBufferSize <=0) aBufferSize=CONVERTER_BUFFER_SIZE;
+
+ // get the decoder
+ nsAutoCString encoding;
+ if (label.EqualsLiteral("UTF-16")) {
+ // Compat with old test cases. Unclear if any extensions really care.
+ encoding.Assign(label);
+ } else if (!EncodingUtils::FindEncodingForLabelNoReplacement(label,
+ encoding)) {
+ return NS_ERROR_UCONV_NOCONV;
+ }
+ mConverter = EncodingUtils::DecoderForEncoding(encoding);
+
+ // set up our buffers
+ if (!mByteData.SetCapacity(aBufferSize, mozilla::fallible) ||
+ !mUnicharData.SetCapacity(aBufferSize, mozilla::fallible)) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ mInput = aStream;
+ mReplacementChar = aReplacementChar;
+ if (!aReplacementChar ||
+ aReplacementChar != mConverter->GetCharacterForUnMapped()) {
+ mConverter->SetInputErrorBehavior(nsIUnicodeDecoder::kOnError_Signal);
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsConverterInputStream::Close()
+{
+ nsresult rv = mInput ? mInput->Close() : NS_OK;
+ mLineBuffer = nullptr;
+ mInput = nullptr;
+ mConverter = nullptr;
+ mByteData.Clear();
+ mUnicharData.Clear();
+ return rv;
+}
+
+NS_IMETHODIMP
+nsConverterInputStream::Read(char16_t* aBuf,
+ uint32_t aCount,
+ uint32_t *aReadCount)
+{
+ NS_ASSERTION(mUnicharDataLength >= mUnicharDataOffset, "unsigned madness");
+ uint32_t readCount = mUnicharDataLength - mUnicharDataOffset;
+ if (0 == readCount) {
+ // Fill the unichar buffer
+ readCount = Fill(&mLastErrorCode);
+ if (readCount == 0) {
+ *aReadCount = 0;
+ return mLastErrorCode;
+ }
+ }
+ if (readCount > aCount) {
+ readCount = aCount;
+ }
+ memcpy(aBuf, mUnicharData.Elements() + mUnicharDataOffset,
+ readCount * sizeof(char16_t));
+ mUnicharDataOffset += readCount;
+ *aReadCount = readCount;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsConverterInputStream::ReadSegments(nsWriteUnicharSegmentFun aWriter,
+ void* aClosure,
+ uint32_t aCount, uint32_t *aReadCount)
+{
+ NS_ASSERTION(mUnicharDataLength >= mUnicharDataOffset, "unsigned madness");
+ uint32_t bytesToWrite = mUnicharDataLength - mUnicharDataOffset;
+ nsresult rv;
+ if (0 == bytesToWrite) {
+ // Fill the unichar buffer
+ bytesToWrite = Fill(&rv);
+ if (bytesToWrite <= 0) {
+ *aReadCount = 0;
+ return rv;
+ }
+ }
+
+ if (bytesToWrite > aCount)
+ bytesToWrite = aCount;
+
+ uint32_t bytesWritten;
+ uint32_t totalBytesWritten = 0;
+
+ while (bytesToWrite) {
+ rv = aWriter(this, aClosure,
+ mUnicharData.Elements() + mUnicharDataOffset,
+ totalBytesWritten, bytesToWrite, &bytesWritten);
+ if (NS_FAILED(rv)) {
+ // don't propagate errors to the caller
+ break;
+ }
+
+ bytesToWrite -= bytesWritten;
+ totalBytesWritten += bytesWritten;
+ mUnicharDataOffset += bytesWritten;
+
+ }
+
+ *aReadCount = totalBytesWritten;
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsConverterInputStream::ReadString(uint32_t aCount, nsAString& aString,
+ uint32_t* aReadCount)
+{
+ NS_ASSERTION(mUnicharDataLength >= mUnicharDataOffset, "unsigned madness");
+ uint32_t readCount = mUnicharDataLength - mUnicharDataOffset;
+ if (0 == readCount) {
+ // Fill the unichar buffer
+ readCount = Fill(&mLastErrorCode);
+ if (readCount == 0) {
+ *aReadCount = 0;
+ return mLastErrorCode;
+ }
+ }
+ if (readCount > aCount) {
+ readCount = aCount;
+ }
+ const char16_t* buf = mUnicharData.Elements() + mUnicharDataOffset;
+ aString.Assign(buf, readCount);
+ mUnicharDataOffset += readCount;
+ *aReadCount = readCount;
+ return NS_OK;
+}
+
+uint32_t
+nsConverterInputStream::Fill(nsresult * aErrorCode)
+{
+ if (nullptr == mInput) {
+ // We already closed the stream!
+ *aErrorCode = NS_BASE_STREAM_CLOSED;
+ return 0;
+ }
+
+ if (NS_FAILED(mLastErrorCode)) {
+ // We failed to completely convert last time, and error-recovery
+ // is disabled. We will fare no better this time, so...
+ *aErrorCode = mLastErrorCode;
+ return 0;
+ }
+
+ // We assume a many to one conversion and are using equal sizes for
+ // the two buffers. However if an error happens at the very start
+ // of a byte buffer we may end up in a situation where n bytes lead
+ // to n+1 unicode chars. Thus we need to keep track of the leftover
+ // bytes as we convert.
+
+ uint32_t nb;
+ *aErrorCode = NS_FillArray(mByteData, mInput, mLeftOverBytes, &nb);
+ if (nb == 0 && mLeftOverBytes == 0) {
+ // No more data
+ *aErrorCode = NS_OK;
+ return 0;
+ }
+
+ NS_ASSERTION(uint32_t(nb) + mLeftOverBytes == mByteData.Length(),
+ "mByteData is lying to us somewhere");
+
+ // Now convert as much of the byte buffer to unicode as possible
+ mUnicharDataOffset = 0;
+ mUnicharDataLength = 0;
+ uint32_t srcConsumed = 0;
+ do {
+ int32_t srcLen = mByteData.Length() - srcConsumed;
+ int32_t dstLen = mUnicharData.Capacity() - mUnicharDataLength;
+ *aErrorCode = mConverter->Convert(mByteData.Elements()+srcConsumed,
+ &srcLen,
+ mUnicharData.Elements()+mUnicharDataLength,
+ &dstLen);
+ mUnicharDataLength += dstLen;
+ // XXX if srcLen is negative, we want to drop the _first_ byte in
+ // the erroneous byte sequence and try again. This is not quite
+ // possible right now -- see bug 160784
+ srcConsumed += srcLen;
+ if (NS_FAILED(*aErrorCode) && mReplacementChar) {
+ NS_ASSERTION(0 < mUnicharData.Capacity() - mUnicharDataLength,
+ "Decoder returned an error but filled the output buffer! "
+ "Should not happen.");
+ mUnicharData.Elements()[mUnicharDataLength++] = mReplacementChar;
+ ++srcConsumed;
+ // XXX this is needed to make sure we don't underrun our buffer;
+ // bug 160784 again
+ srcConsumed = std::max<uint32_t>(srcConsumed, 0);
+ mConverter->Reset();
+ }
+ NS_ASSERTION(srcConsumed <= mByteData.Length(),
+ "Whoa. The converter should have returned NS_OK_UDEC_MOREINPUT before this point!");
+ } while (mReplacementChar &&
+ NS_FAILED(*aErrorCode) &&
+ mUnicharData.Capacity() > mUnicharDataLength);
+
+ mLeftOverBytes = mByteData.Length() - srcConsumed;
+
+ return mUnicharDataLength;
+}
+
+NS_IMETHODIMP
+nsConverterInputStream::ReadLine(nsAString& aLine, bool* aResult)
+{
+ if (!mLineBuffer) {
+ mLineBuffer = new nsLineBuffer<char16_t>;
+ }
+ return NS_ReadLine(this, mLineBuffer.get(), aLine, aResult);
+}