mirror of
https://repo.dactyloidae.xyz/Dactyloidae/UXP.git
synced 2026-09-05 07:18:39 +09:00
import FIREFOX_52_6_0esr_RELEASE from mozilla-esr52 hg repo
This commit is contained in:
Roy Tam
commit
dcd9973243
150858 changed files with 23884658 additions and 0 deletions
398
xpcom/io/nsUnicharInputStream.cpp
Normal file
398
xpcom/io/nsUnicharInputStream.cpp
Normal file
|
|
@ -0,0 +1,398 @@
|
|||
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
||||
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
||||
/* 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 "nsUnicharInputStream.h"
|
||||
#include "nsIInputStream.h"
|
||||
#include "nsIServiceManager.h"
|
||||
#include "nsString.h"
|
||||
#include "nsTArray.h"
|
||||
#include "nsAutoPtr.h"
|
||||
#include "nsCRT.h"
|
||||
#include "nsStreamUtils.h"
|
||||
#include "nsUTF8Utils.h"
|
||||
#include "mozilla/Attributes.h"
|
||||
#include <fcntl.h>
|
||||
#if defined(XP_WIN)
|
||||
#include <io.h>
|
||||
#else
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
#define STRING_BUFFER_SIZE 8192
|
||||
|
||||
class StringUnicharInputStream final : public nsIUnicharInputStream
|
||||
{
|
||||
public:
|
||||
explicit StringUnicharInputStream(const nsAString& aString) :
|
||||
mString(aString), mPos(0), mLen(aString.Length()) { }
|
||||
|
||||
NS_DECL_ISUPPORTS
|
||||
NS_DECL_NSIUNICHARINPUTSTREAM
|
||||
|
||||
nsString mString;
|
||||
uint32_t mPos;
|
||||
uint32_t mLen;
|
||||
|
||||
private:
|
||||
~StringUnicharInputStream() { }
|
||||
};
|
||||
|
||||
NS_IMETHODIMP
|
||||
StringUnicharInputStream::Read(char16_t* aBuf,
|
||||
uint32_t aCount,
|
||||
uint32_t* aReadCount)
|
||||
{
|
||||
if (mPos >= mLen) {
|
||||
*aReadCount = 0;
|
||||
return NS_OK;
|
||||
}
|
||||
nsAString::const_iterator iter;
|
||||
mString.BeginReading(iter);
|
||||
const char16_t* us = iter.get();
|
||||
uint32_t amount = mLen - mPos;
|
||||
if (amount > aCount) {
|
||||
amount = aCount;
|
||||
}
|
||||
memcpy(aBuf, us + mPos, sizeof(char16_t) * amount);
|
||||
mPos += amount;
|
||||
*aReadCount = amount;
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
StringUnicharInputStream::ReadSegments(nsWriteUnicharSegmentFun aWriter,
|
||||
void* aClosure,
|
||||
uint32_t aCount, uint32_t* aReadCount)
|
||||
{
|
||||
uint32_t bytesWritten;
|
||||
uint32_t totalBytesWritten = 0;
|
||||
|
||||
nsresult rv;
|
||||
aCount = XPCOM_MIN(mString.Length() - mPos, aCount);
|
||||
|
||||
nsAString::const_iterator iter;
|
||||
mString.BeginReading(iter);
|
||||
|
||||
while (aCount) {
|
||||
rv = aWriter(this, aClosure, iter.get() + mPos,
|
||||
totalBytesWritten, aCount, &bytesWritten);
|
||||
|
||||
if (NS_FAILED(rv)) {
|
||||
// don't propagate errors to the caller
|
||||
break;
|
||||
}
|
||||
|
||||
aCount -= bytesWritten;
|
||||
totalBytesWritten += bytesWritten;
|
||||
mPos += bytesWritten;
|
||||
}
|
||||
|
||||
*aReadCount = totalBytesWritten;
|
||||
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
StringUnicharInputStream::ReadString(uint32_t aCount, nsAString& aString,
|
||||
uint32_t* aReadCount)
|
||||
{
|
||||
if (mPos >= mLen) {
|
||||
*aReadCount = 0;
|
||||
return NS_OK;
|
||||
}
|
||||
uint32_t amount = mLen - mPos;
|
||||
if (amount > aCount) {
|
||||
amount = aCount;
|
||||
}
|
||||
aString = Substring(mString, mPos, amount);
|
||||
mPos += amount;
|
||||
*aReadCount = amount;
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
nsresult
|
||||
StringUnicharInputStream::Close()
|
||||
{
|
||||
mPos = mLen;
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
NS_IMPL_ISUPPORTS(StringUnicharInputStream, nsIUnicharInputStream)
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
class UTF8InputStream final : public nsIUnicharInputStream
|
||||
{
|
||||
public:
|
||||
UTF8InputStream();
|
||||
nsresult Init(nsIInputStream* aStream);
|
||||
|
||||
NS_DECL_ISUPPORTS
|
||||
NS_DECL_NSIUNICHARINPUTSTREAM
|
||||
|
||||
private:
|
||||
~UTF8InputStream();
|
||||
|
||||
protected:
|
||||
int32_t Fill(nsresult* aErrorCode);
|
||||
|
||||
static void CountValidUTF8Bytes(const char* aBuf, uint32_t aMaxBytes,
|
||||
uint32_t& aValidUTF8bytes,
|
||||
uint32_t& aValidUTF16CodeUnits);
|
||||
|
||||
nsCOMPtr<nsIInputStream> mInput;
|
||||
FallibleTArray<char> mByteData;
|
||||
FallibleTArray<char16_t> mUnicharData;
|
||||
|
||||
uint32_t mByteDataOffset;
|
||||
uint32_t mUnicharDataOffset;
|
||||
uint32_t mUnicharDataLength;
|
||||
};
|
||||
|
||||
UTF8InputStream::UTF8InputStream() :
|
||||
mByteDataOffset(0),
|
||||
mUnicharDataOffset(0),
|
||||
mUnicharDataLength(0)
|
||||
{
|
||||
}
|
||||
|
||||
nsresult
|
||||
UTF8InputStream::Init(nsIInputStream* aStream)
|
||||
{
|
||||
if (!mByteData.SetCapacity(STRING_BUFFER_SIZE, mozilla::fallible) ||
|
||||
!mUnicharData.SetCapacity(STRING_BUFFER_SIZE, mozilla::fallible)) {
|
||||
return NS_ERROR_OUT_OF_MEMORY;
|
||||
}
|
||||
mInput = aStream;
|
||||
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
NS_IMPL_ISUPPORTS(UTF8InputStream, nsIUnicharInputStream)
|
||||
|
||||
UTF8InputStream::~UTF8InputStream()
|
||||
{
|
||||
Close();
|
||||
}
|
||||
|
||||
nsresult
|
||||
UTF8InputStream::Close()
|
||||
{
|
||||
mInput = nullptr;
|
||||
mByteData.Clear();
|
||||
mUnicharData.Clear();
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
nsresult
|
||||
UTF8InputStream::Read(char16_t* aBuf, uint32_t aCount, uint32_t* aReadCount)
|
||||
{
|
||||
NS_ASSERTION(mUnicharDataLength >= mUnicharDataOffset, "unsigned madness");
|
||||
uint32_t readCount = mUnicharDataLength - mUnicharDataOffset;
|
||||
nsresult errorCode;
|
||||
if (0 == readCount) {
|
||||
// Fill the unichar buffer
|
||||
int32_t bytesRead = Fill(&errorCode);
|
||||
if (bytesRead <= 0) {
|
||||
*aReadCount = 0;
|
||||
return errorCode;
|
||||
}
|
||||
readCount = bytesRead;
|
||||
}
|
||||
if (readCount > aCount) {
|
||||
readCount = aCount;
|
||||
}
|
||||
memcpy(aBuf, mUnicharData.Elements() + mUnicharDataOffset,
|
||||
readCount * sizeof(char16_t));
|
||||
mUnicharDataOffset += readCount;
|
||||
*aReadCount = readCount;
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
UTF8InputStream::ReadSegments(nsWriteUnicharSegmentFun aWriter,
|
||||
void* aClosure,
|
||||
uint32_t aCount, uint32_t* aReadCount)
|
||||
{
|
||||
NS_ASSERTION(mUnicharDataLength >= mUnicharDataOffset, "unsigned madness");
|
||||
uint32_t bytesToWrite = mUnicharDataLength - mUnicharDataOffset;
|
||||
nsresult rv = NS_OK;
|
||||
if (0 == bytesToWrite) {
|
||||
// Fill the unichar buffer
|
||||
int32_t bytesRead = Fill(&rv);
|
||||
if (bytesRead <= 0) {
|
||||
*aReadCount = 0;
|
||||
return rv;
|
||||
}
|
||||
bytesToWrite = bytesRead;
|
||||
}
|
||||
|
||||
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
|
||||
UTF8InputStream::ReadString(uint32_t aCount, nsAString& aString,
|
||||
uint32_t* aReadCount)
|
||||
{
|
||||
NS_ASSERTION(mUnicharDataLength >= mUnicharDataOffset, "unsigned madness");
|
||||
uint32_t readCount = mUnicharDataLength - mUnicharDataOffset;
|
||||
nsresult errorCode;
|
||||
if (0 == readCount) {
|
||||
// Fill the unichar buffer
|
||||
int32_t bytesRead = Fill(&errorCode);
|
||||
if (bytesRead <= 0) {
|
||||
*aReadCount = 0;
|
||||
return errorCode;
|
||||
}
|
||||
readCount = bytesRead;
|
||||
}
|
||||
if (readCount > aCount) {
|
||||
readCount = aCount;
|
||||
}
|
||||
const char16_t* buf = mUnicharData.Elements() + mUnicharDataOffset;
|
||||
aString.Assign(buf, readCount);
|
||||
|
||||
mUnicharDataOffset += readCount;
|
||||
*aReadCount = readCount;
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
int32_t
|
||||
UTF8InputStream::Fill(nsresult* aErrorCode)
|
||||
{
|
||||
if (!mInput) {
|
||||
// We already closed the stream!
|
||||
*aErrorCode = NS_BASE_STREAM_CLOSED;
|
||||
return -1;
|
||||
}
|
||||
|
||||
NS_ASSERTION(mByteData.Length() >= mByteDataOffset, "unsigned madness");
|
||||
uint32_t remainder = mByteData.Length() - mByteDataOffset;
|
||||
mByteDataOffset = remainder;
|
||||
uint32_t nb;
|
||||
*aErrorCode = NS_FillArray(mByteData, mInput, remainder, &nb);
|
||||
if (nb == 0) {
|
||||
// Because we assume a many to one conversion, the lingering data
|
||||
// in the byte buffer must be a partial conversion
|
||||
// fragment. Because we know that we have received no more new
|
||||
// data to add to it, we can't convert it. Therefore, we discard
|
||||
// it.
|
||||
return nb;
|
||||
}
|
||||
NS_ASSERTION(remainder + nb == mByteData.Length(), "bad nb");
|
||||
|
||||
// Now convert as much of the byte buffer to unicode as possible
|
||||
uint32_t srcLen, dstLen;
|
||||
CountValidUTF8Bytes(mByteData.Elements(), remainder + nb, srcLen, dstLen);
|
||||
|
||||
// the number of UCS2 characters should always be <= the number of
|
||||
// UTF8 chars
|
||||
NS_ASSERTION(remainder + nb >= srcLen, "cannot be longer than out buffer");
|
||||
NS_ASSERTION(dstLen <= mUnicharData.Capacity(),
|
||||
"Ouch. I would overflow my buffer if I wasn't so careful.");
|
||||
if (dstLen > mUnicharData.Capacity()) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
ConvertUTF8toUTF16 converter(mUnicharData.Elements());
|
||||
|
||||
nsASingleFragmentCString::const_char_iterator start = mByteData.Elements();
|
||||
nsASingleFragmentCString::const_char_iterator end = mByteData.Elements() + srcLen;
|
||||
|
||||
copy_string(start, end, converter);
|
||||
if (converter.Length() != dstLen) {
|
||||
*aErrorCode = NS_BASE_STREAM_BAD_CONVERSION;
|
||||
return -1;
|
||||
}
|
||||
|
||||
mUnicharDataOffset = 0;
|
||||
mUnicharDataLength = dstLen;
|
||||
mByteDataOffset = srcLen;
|
||||
|
||||
return dstLen;
|
||||
}
|
||||
|
||||
void
|
||||
UTF8InputStream::CountValidUTF8Bytes(const char* aBuffer, uint32_t aMaxBytes,
|
||||
uint32_t& aValidUTF8bytes,
|
||||
uint32_t& aValidUTF16CodeUnits)
|
||||
{
|
||||
const char* c = aBuffer;
|
||||
const char* end = aBuffer + aMaxBytes;
|
||||
const char* lastchar = c; // pre-initialize in case of 0-length buffer
|
||||
uint32_t utf16length = 0;
|
||||
while (c < end && *c) {
|
||||
lastchar = c;
|
||||
utf16length++;
|
||||
|
||||
if (UTF8traits::isASCII(*c)) {
|
||||
c++;
|
||||
} else if (UTF8traits::is2byte(*c)) {
|
||||
c += 2;
|
||||
} else if (UTF8traits::is3byte(*c)) {
|
||||
c += 3;
|
||||
} else if (UTF8traits::is4byte(*c)) {
|
||||
c += 4;
|
||||
utf16length++; // add 1 more because this will be converted to a
|
||||
// surrogate pair.
|
||||
} else if (UTF8traits::is5byte(*c)) {
|
||||
c += 5;
|
||||
} else if (UTF8traits::is6byte(*c)) {
|
||||
c += 6;
|
||||
} else {
|
||||
NS_WARNING("Unrecognized UTF8 string in UTF8InputStream::CountValidUTF8Bytes()");
|
||||
break; // Otherwise we go into an infinite loop. But what happens now?
|
||||
}
|
||||
}
|
||||
if (c > end) {
|
||||
c = lastchar;
|
||||
utf16length--;
|
||||
}
|
||||
|
||||
aValidUTF8bytes = c - aBuffer;
|
||||
aValidUTF16CodeUnits = utf16length;
|
||||
}
|
||||
|
||||
nsresult
|
||||
NS_NewUnicharInputStream(nsIInputStream* aStreamToWrap,
|
||||
nsIUnicharInputStream** aResult)
|
||||
{
|
||||
*aResult = nullptr;
|
||||
|
||||
// Create converter input stream
|
||||
RefPtr<UTF8InputStream> it = new UTF8InputStream();
|
||||
nsresult rv = it->Init(aStreamToWrap);
|
||||
if (NS_FAILED(rv)) {
|
||||
return rv;
|
||||
}
|
||||
|
||||
it.forget(aResult);
|
||||
return NS_OK;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue