NS_IMETHODIMP
nsDirIndexParser::OnDataAvailable(nsIRequest *aRequest, nsISupports *aCtxt,
nsIInputStream *aStream,
PRUint32 aSourceOffset,
PRUint32 aCount) {
if (aCount < 1)
return NS_OK;
PRInt32 len = mBuf.Length();
// Ensure that our mBuf has capacity to hold the data we're about to
// read.
if (!EnsureStringLength(mBuf, len + aCount))
return NS_ERROR_OUT_OF_MEMORY;
// Now read the data into our buffer.
nsresult rv;
PRUint32 count;
rv = aStream->Read(mBuf.BeginWriting() + len, aCount, &count);
if (NS_FAILED(rv)) return rv;
// Set the string's length according to the amount of data we've read.
// Note: we know this to work on nsCString. This isn't guaranteed to
// work on other strings.
mBuf.SetLength(len + count);
return ProcessData(aRequest, aCtxt);
}
static void
MorkUnescape(const nsCSubstring &aString, nsCString &aResult)
{
PRUint32 len = aString.Length();
// We optimize for speed over space here -- size the result buffer to
// the size of the source, which is an upper bound on the size of the
// unescaped string.
// FIXME: Mork assume there will never be errors
if (!EnsureStringLength(aResult, len)) {
aResult.Truncate();
return; // out of memory.
}
char *result = aResult.BeginWriting();
const char *source = aString.BeginReading();
const char *sourceEnd = source + len;
const char *startPos = nsnull;
PRUint32 bytes;
for (; source < sourceEnd; ++source) {
char c = *source;
if (c == '\\') {
if (startPos) {
bytes = source - startPos;
memcpy(result, startPos, bytes);
result += bytes;
startPos = nsnull;
}
if (source < sourceEnd - 1) {
*(result++) = *(++source);
}
} else if (c == '$') {
if (startPos) {
bytes = source - startPos;
memcpy(result, startPos, bytes);
result += bytes;
startPos = nsnull;
}
if (source < sourceEnd - 2) {
// Would be nice to use ToInteger() here, but it currently
// requires a null-terminated string.
char c2 = *(++source);
char c3 = *(++source);
if (ConvertChar(&c2) && ConvertChar(&c3)) {
*(result++) = ((c2 << 4) | c3);
}
}
} else if (!startPos) {
startPos = source;
}
}
if (startPos) {
bytes = source - startPos;
memcpy(result, startPos, bytes);
result += bytes;
}
aResult.SetLength(result - aResult.BeginReading());
}
void TX_ToLowerCase(const nsAString& aSource, nsAString& aDest)
{
nsAString::const_iterator fromBegin, fromEnd;
nsAString::iterator toBegin;
if (!EnsureStringLength(aDest, aSource.Length()))
return; // XXX no way to signal out-of-memory
CopyToLowerCase converter(aDest.BeginWriting(toBegin));
copy_string(aSource.BeginReading(fromBegin), aSource.EndReading(fromEnd),
converter);
}
NS_IMETHODIMP
nsBinaryInputStream::ReadString(nsAString& aString)
{
nsresult rv;
PRUint32 length, bytesRead;
rv = Read32(&length);
if (NS_FAILED(rv)) return rv;
if (length == 0) {
aString.Truncate();
return NS_OK;
}
// pre-allocate output buffer, and get direct access to buffer...
if (!EnsureStringLength(aString, length))
return NS_ERROR_OUT_OF_MEMORY;
nsAString::iterator start;
aString.BeginWriting(start);
WriteStringClosure closure;
closure.mWriteCursor = start.get();
closure.mHasCarryoverByte = PR_FALSE;
rv = ReadSegments(WriteSegmentToString, &closure,
length*sizeof(PRUnichar), &bytesRead);
if (NS_FAILED(rv)) return rv;
NS_ASSERTION(!closure.mHasCarryoverByte, "some strange stream corruption!");
if (bytesRead != length*sizeof(PRUnichar))
return NS_ERROR_FAILURE;
return NS_OK;
}
/*
* Converts the value of the given double to a String, and places
* The result into the destination String.
* @return the given dest string
*/
void txDouble::toString(double aValue, nsAString& aDest)
{
// check for special cases
if (MOZ_DOUBLE_IS_NaN(aValue)) {
aDest.AppendLiteral("NaN");
return;
}
if (MOZ_DOUBLE_IS_INFINITE(aValue)) {
if (aValue < 0)
aDest.Append(PRUnichar('-'));
aDest.AppendLiteral("Infinity");
return;
}
// Mantissa length is 17, so this is plenty
const int buflen = 20;
char buf[buflen];
int intDigits, sign;
char* endp;
PR_dtoa(aValue, 0, 0, &intDigits, &sign, &endp, buf, buflen - 1);
// compute length
int32_t length = endp - buf;
if (length > intDigits) {
// decimal point needed
++length;
if (intDigits < 1) {
// leading zeros, -intDigits + 1
length += 1 - intDigits;
}
}
else {
// trailing zeros, total length given by intDigits
length = intDigits;
}
if (aValue < 0)
++length;
// grow the string
uint32_t oldlength = aDest.Length();
if (!EnsureStringLength(aDest, oldlength + length))
return; // out of memory
nsAString::iterator dest;
aDest.BeginWriting(dest).advance(int32_t(oldlength));
if (aValue < 0) {
*dest = '-'; ++dest;
}
int i;
// leading zeros
if (intDigits < 1) {
*dest = '0'; ++dest;
*dest = '.'; ++dest;
for (i = 0; i > intDigits; --i) {
*dest = '0'; ++dest;
}
}
// mantissa
int firstlen = std::min<size_t>(intDigits, endp - buf);
for (i = 0; i < firstlen; i++) {
*dest = buf[i]; ++dest;
}
if (i < endp - buf) {
if (i > 0) {
*dest = '.'; ++dest;
}
for (; i < endp - buf; i++) {
*dest = buf[i]; ++dest;
}
}
// trailing zeros
for (; i < intDigits; i++) {
*dest = '0'; ++dest;
}
}
/* static */ nsresult
nsScriptLoader::ConvertToUTF16(nsIChannel* aChannel, const PRUint8* aData,
PRUint32 aLength, const nsString& aHintCharset,
nsIDocument* aDocument, nsString& aString)
{
if (!aLength) {
aString.Truncate();
return NS_OK;
}
nsCAutoString characterSet;
nsresult rv = NS_OK;
if (aChannel) {
rv = aChannel->GetContentCharset(characterSet);
}
if (!aHintCharset.IsEmpty() && (NS_FAILED(rv) || characterSet.IsEmpty())) {
// charset name is always ASCII.
LossyCopyUTF16toASCII(aHintCharset, characterSet);
}
if (NS_FAILED(rv) || characterSet.IsEmpty()) {
DetectByteOrderMark(aData, aLength, characterSet);
}
if (characterSet.IsEmpty()) {
// charset from document default
characterSet = aDocument->GetDocumentCharacterSet();
}
if (characterSet.IsEmpty()) {
// fall back to ISO-8859-1, see bug 118404
characterSet.AssignLiteral("ISO-8859-1");
}
nsCOMPtr<nsICharsetConverterManager> charsetConv =
do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv);
nsCOMPtr<nsIUnicodeDecoder> unicodeDecoder;
if (NS_SUCCEEDED(rv) && charsetConv) {
rv = charsetConv->GetUnicodeDecoder(characterSet.get(),
getter_AddRefs(unicodeDecoder));
if (NS_FAILED(rv)) {
// fall back to ISO-8859-1 if charset is not supported. (bug 230104)
rv = charsetConv->GetUnicodeDecoderRaw("ISO-8859-1",
getter_AddRefs(unicodeDecoder));
}
}
// converts from the charset to unicode
if (NS_SUCCEEDED(rv)) {
PRInt32 unicodeLength = 0;
rv = unicodeDecoder->GetMaxLength(reinterpret_cast<const char*>(aData),
aLength, &unicodeLength);
if (NS_SUCCEEDED(rv)) {
if (!EnsureStringLength(aString, unicodeLength))
return NS_ERROR_OUT_OF_MEMORY;
PRUnichar *ustr = aString.BeginWriting();
PRInt32 consumedLength = 0;
PRInt32 originalLength = aLength;
PRInt32 convertedLength = 0;
PRInt32 bufferLength = unicodeLength;
do {
rv = unicodeDecoder->Convert(reinterpret_cast<const char*>(aData),
(PRInt32 *) &aLength, ustr,
&unicodeLength);
if (NS_FAILED(rv)) {
// if we failed, we consume one byte, replace it with U+FFFD
// and try the conversion again.
ustr[unicodeLength++] = (PRUnichar)0xFFFD;
ustr += unicodeLength;
unicodeDecoder->Reset();
}
aData += ++aLength;
consumedLength += aLength;
aLength = originalLength - consumedLength;
convertedLength += unicodeLength;
unicodeLength = bufferLength - convertedLength;
} while (NS_FAILED(rv) && (originalLength > consumedLength) && (bufferLength > convertedLength));
aString.SetLength(convertedLength);
}
}
return rv;
}
static nsresult
DeserializeResult(ipcMessageReader &reader, const nsXPTType &t, nsXPTCMiniVariant &v)
{
if (v.val.p == nsnull)
return NS_OK;
switch (t.TagPart())
{
case nsXPTType::T_I8:
case nsXPTType::T_U8:
*((PRUint8 *) v.val.p) = reader.GetInt8();
break;
case nsXPTType::T_I16:
case nsXPTType::T_U16:
*((PRUint16 *) v.val.p) = reader.GetInt16();
break;
case nsXPTType::T_I32:
case nsXPTType::T_U32:
*((PRUint32 *) v.val.p) = reader.GetInt32();
break;
case nsXPTType::T_I64:
case nsXPTType::T_U64:
reader.GetBytes(v.val.p, sizeof(PRUint64));
break;
case nsXPTType::T_FLOAT:
reader.GetBytes(v.val.p, sizeof(float));
break;
case nsXPTType::T_DOUBLE:
reader.GetBytes(v.val.p, sizeof(double));
break;
case nsXPTType::T_BOOL:
reader.GetBytes(v.val.p, sizeof(PRBool));
break;
case nsXPTType::T_CHAR:
reader.GetBytes(v.val.p, sizeof(char));
break;
case nsXPTType::T_WCHAR:
reader.GetBytes(v.val.p, sizeof(PRUnichar));
break;
case nsXPTType::T_IID:
{
nsID *buf = (nsID *) nsMemory::Alloc(sizeof(nsID));
reader.GetBytes(buf, sizeof(nsID));
*((nsID **) v.val.p) = buf;
}
break;
case nsXPTType::T_CHAR_STR:
{
PRUint32 len = reader.GetInt32();
char *buf = (char *) nsMemory::Alloc(len + 1);
reader.GetBytes(buf, len);
buf[len] = char(0);
*((char **) v.val.p) = buf;
}
break;
case nsXPTType::T_WCHAR_STR:
{
PRUint32 len = reader.GetInt32();
PRUnichar *buf = (PRUnichar *) nsMemory::Alloc(len + 2);
reader.GetBytes(buf, len);
buf[len] = PRUnichar(0);
*((PRUnichar **) v.val.p) = buf;
}
break;
case nsXPTType::T_INTERFACE:
case nsXPTType::T_INTERFACE_IS:
{
// stub creation will be handled outside this routine. we only
// deserialize the DConAddr into v.val.p temporarily.
void *ptr;
reader.GetBytes(&ptr, sizeof(void *));
*((void **) v.val.p) = ptr;
}
break;
case nsXPTType::T_ASTRING:
case nsXPTType::T_DOMSTRING:
{
PRUint32 len = reader.GetInt32();
nsAString *str = (nsAString *) v.val.p;
if (!str || !(EnsureStringLength(*str, len/2)))
return NS_ERROR_OUT_OF_MEMORY;
nsAString::iterator begin;
str->BeginWriting(begin);
reader.GetBytes(begin.get(), len);
}
break;
case nsXPTType::T_UTF8STRING:
case nsXPTType::T_CSTRING:
{
PRUint32 len = reader.GetInt32();
nsACString *str = (nsACString *) v.val.p;
if (!str || !(EnsureStringLength(*str, len)))
return NS_ERROR_OUT_OF_MEMORY;
nsACString::iterator begin;
str->BeginWriting(begin);
reader.GetBytes(begin.get(), len);
}
break;
case nsXPTType::T_ARRAY:
LOG(("array types are not yet supported\n"));
return NS_ERROR_NOT_IMPLEMENTED;
case nsXPTType::T_VOID:
case nsXPTType::T_PSTRING_SIZE_IS:
case nsXPTType::T_PWSTRING_SIZE_IS:
default:
LOG(("unexpected parameter type\n"));
return NS_ERROR_UNEXPECTED;
}
return NS_OK;
}
static nsresult
DeserializeParam(ipcMessageReader &reader, const nsXPTType &t, nsXPTCVariant &v)
{
// defaults
v.ptr = nsnull;
v.type = t;
v.flags = 0;
switch (t.TagPart())
{
case nsXPTType::T_I8:
case nsXPTType::T_U8:
v.val.u8 = reader.GetInt8();
break;
case nsXPTType::T_I16:
case nsXPTType::T_U16:
v.val.u16 = reader.GetInt16();
break;
case nsXPTType::T_I32:
case nsXPTType::T_U32:
v.val.u32 = reader.GetInt32();
break;
case nsXPTType::T_I64:
case nsXPTType::T_U64:
reader.GetBytes(&v.val.u64, sizeof(v.val.u64));
break;
case nsXPTType::T_FLOAT:
reader.GetBytes(&v.val.f, sizeof(v.val.f));
break;
case nsXPTType::T_DOUBLE:
reader.GetBytes(&v.val.d, sizeof(v.val.d));
break;
case nsXPTType::T_BOOL:
reader.GetBytes(&v.val.b, sizeof(v.val.b));
break;
case nsXPTType::T_CHAR:
reader.GetBytes(&v.val.c, sizeof(v.val.c));
break;
case nsXPTType::T_WCHAR:
reader.GetBytes(&v.val.wc, sizeof(v.val.wc));
break;
case nsXPTType::T_IID:
{
nsID *buf = (nsID *) malloc(sizeof(nsID));
NS_ENSURE_TRUE(buf, NS_ERROR_OUT_OF_MEMORY);
reader.GetBytes(buf, sizeof(nsID));
v.val.p = v.ptr = buf;
v.flags = nsXPTCVariant::PTR_IS_DATA | nsXPTCVariant::VAL_IS_ALLOCD;
}
break;
case nsXPTType::T_CHAR_STR:
{
PRUint32 len = reader.GetInt32();
char *buf = (char *) malloc(len + 1);
NS_ENSURE_TRUE(buf, NS_ERROR_OUT_OF_MEMORY);
reader.GetBytes(buf, len);
buf[len] = char(0);
v.val.p = v.ptr = buf;
v.flags = nsXPTCVariant::PTR_IS_DATA | nsXPTCVariant::VAL_IS_ALLOCD;
}
break;
case nsXPTType::T_WCHAR_STR:
{
PRUint32 len = reader.GetInt32();
PRUnichar *buf = (PRUnichar *) malloc(len + 2);
NS_ENSURE_TRUE(buf, NS_ERROR_OUT_OF_MEMORY);
reader.GetBytes(buf, len);
buf[len] = PRUnichar(0);
v.val.p = v.ptr = buf;
v.flags = nsXPTCVariant::PTR_IS_DATA | nsXPTCVariant::VAL_IS_ALLOCD;
}
break;
case nsXPTType::T_INTERFACE:
case nsXPTType::T_INTERFACE_IS:
{
reader.GetBytes(&v.ptr, sizeof(void *));
v.val.p = nsnull;
v.flags = nsXPTCVariant::PTR_IS_DATA;
}
break;
case nsXPTType::T_ASTRING:
case nsXPTType::T_DOMSTRING:
{
PRUint32 len = reader.GetInt32();
nsString *str = new nsString();
if (!str || !(EnsureStringLength(*str, len/2)))
return NS_ERROR_OUT_OF_MEMORY;
PRUnichar *buf = str->BeginWriting();
reader.GetBytes(buf, len);
v.val.p = v.ptr = str;
v.flags = nsXPTCVariant::PTR_IS_DATA | nsXPTCVariant::VAL_IS_DOMSTR;
}
break;
case nsXPTType::T_UTF8STRING:
case nsXPTType::T_CSTRING:
{
PRUint32 len = reader.GetInt32();
nsCString *str = new nsCString();
if (!str || !(EnsureStringLength(*str, len)))
return NS_ERROR_OUT_OF_MEMORY;
char *buf = str->BeginWriting();
reader.GetBytes(buf, len);
v.val.p = v.ptr = str;
v.flags = nsXPTCVariant::PTR_IS_DATA;
// this distinction here is pretty pointless
if (t.TagPart() == nsXPTType::T_CSTRING)
v.flags |= nsXPTCVariant::VAL_IS_CSTR;
else
v.flags |= nsXPTCVariant::VAL_IS_UTF8STR;
}
break;
case nsXPTType::T_ARRAY:
LOG(("array types are not yet supported\n"));
return NS_ERROR_NOT_IMPLEMENTED;
case nsXPTType::T_VOID:
case nsXPTType::T_PSTRING_SIZE_IS:
case nsXPTType::T_PWSTRING_SIZE_IS:
default:
LOG(("unexpected parameter type\n"));
return NS_ERROR_UNEXPECTED;
}
return NS_OK;
}
