os/security/securityanddataprivacytools/securitytools/certapp/store--/us_ucmp.cpp
1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/security/securityanddataprivacytools/securitytools/certapp/store--/us_ucmp.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,753 @@
1.4 +/*
1.5 +* Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
1.6 +* All rights reserved.
1.7 +* This component and the accompanying materials are made available
1.8 +* under the terms of the License "Eclipse Public License v1.0"
1.9 +* which accompanies this distribution, and is available
1.10 +* at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.11 +*
1.12 +* Initial Contributors:
1.13 +* Nokia Corporation - initial contribution.
1.14 +*
1.15 +* Contributors:
1.16 +*
1.17 +* Description:
1.18 +* Implementation of the Standard Compression Scheme for Unicode.
1.19 +* This code is compiled only in the Unicode build.
1.20 +*
1.21 +*/
1.22 +
1.23 +
1.24 +#ifdef _UNICODE
1.25 +
1.26 +#include <s32ucmp.h>
1.27 +#include <e32err.h>
1.28 +
1.29 +const TUint32 TUnicodeCompressionState::iStaticWindow[EStaticWindows] =
1.30 + {
1.31 + 0x0000, // tags
1.32 + 0x0080, // Latin-1 supplement
1.33 + 0x0100, // Latin Extended-A
1.34 + 0x0300, // Combining Diacritics
1.35 + 0x2000, // General Punctuation
1.36 + 0x2080, // Currency Symbols
1.37 + 0x2100, // Letterlike Symbols and Number Forms
1.38 + 0x3000 // CJK Symbols and Punctuation
1.39 + };
1.40 +
1.41 +const TUint32 TUnicodeCompressionState::iDynamicWindowDefault[EDynamicWindows] =
1.42 + {
1.43 + 0x0080, // Latin-1 supplement
1.44 + 0x00C0, // parts of Latin-1 supplement and Latin Extended-A
1.45 + 0x0400, // Cyrillic
1.46 + 0x0600, // Arabic
1.47 + 0x0900, // Devanagari
1.48 + 0x3040, // Hiragana
1.49 + 0x30A0, // Katakana
1.50 + 0xFF00 // Fullwidth ASCII
1.51 + };
1.52 +
1.53 +const TUint16 TUnicodeCompressionState::iSpecialBase[ESpecialBases] =
1.54 + {
1.55 + 0x00C0, // Latin 1 letters (not symbols) and some of Extended-A
1.56 + 0x0250, // IPA extensions
1.57 + 0x0370, // Greek
1.58 + 0x0530, // Armenian
1.59 + 0x3040, // Hiragana
1.60 + 0x30A0, // Katakana
1.61 + 0xFF60 // Halfwidth katakana
1.62 + };
1.63 +
1.64 +// Single-byte mode tag values
1.65 +const TUint8 SQ0 = 0x01; // <byte> quote from window 0
1.66 +const TUint8 SDX = 0x0B; // <hbyte> <lbyte> define window in expansion area
1.67 +const TUint8 SQU = 0x0E; // <hbyte> <lbyte> quote Unicode value
1.68 +const TUint8 SCU = 0x0F; // switch to Unicode mode
1.69 +const TUint8 SC0 = 0x10; // select dynamic window 0
1.70 +const TUint8 SD0 = 0x18; // <byte> set dynamic window 0 index to <byte> and select it
1.71 +
1.72 +// Unicode mode tag values
1.73 +const TUint8 UC0 = 0xE0; // select dynamic window 0 and switch to single-byte mode
1.74 +const TUint8 UD0 = 0xE8; // <byte> set dynamic window 0 index to <byte>, select it and switch to
1.75 + // single-byte mode
1.76 +const TUint8 UQU = 0xF0; // <hbyte>, <lbyte> quote Unicode value
1.77 +const TUint8 UDX = 0xF1; // <hbyte>, <lbyte> define window in expansion area and switch to single-byte mode
1.78 +
1.79 +TUnicodeCompressionState::TUnicodeCompressionState():
1.80 + iUnicodeWords(0),
1.81 + iMaxUnicodeWords(0),
1.82 + iCompressedBytes(0),
1.83 + iMaxCompressedBytes(0)
1.84 + {
1.85 + Reset();
1.86 + }
1.87 +
1.88 +void TUnicodeCompressionState::Reset()
1.89 + {
1.90 + iUnicodeMode = FALSE;
1.91 + iActiveWindowBase = 0x0080;
1.92 + for (int i = 0; i < EDynamicWindows; i++)
1.93 + iDynamicWindow[i] = iDynamicWindowDefault[i];
1.94 + }
1.95 +
1.96 +
1.97 +// Return the index of the static window that contains this code, if any, or -1 if there is none.
1.98 +TInt TUnicodeCompressionState::StaticWindowIndex(TUint16 aCode)
1.99 + {
1.100 + for (TInt i = 0; i < EStaticWindows; i++)
1.101 + if (aCode >= iStaticWindow[i] && aCode < iStaticWindow[i] + 128)
1.102 + return i;
1.103 + return -1;
1.104 + }
1.105 +
1.106 +/*
1.107 +If aCode can be accommodated in one of the legal dynamic windows, return the index of that window
1.108 +in the offset table. If not return KErrNotFound.
1.109 +*/
1.110 +TInt TUnicodeCompressionState::DynamicWindowOffsetIndex(TUint16 aCode)
1.111 + {
1.112 + if (aCode < 0x0080)
1.113 + return KErrNotFound;
1.114 + if (aCode >= 0x3400 && aCode <= 0xDFFF)
1.115 + return KErrNotFound;
1.116 +
1.117 + /*
1.118 + Prefer sections that cross half-block boundaries. These are better adapted to actual text.
1.119 + They are represented by offset indices 0xf9..0xff.
1.120 + */
1.121 + for (int i = 0; i < ESpecialBases; i++)
1.122 + if (aCode >= iSpecialBase[i] && aCode < iSpecialBase[i] + 128)
1.123 + return 0xF9 + i;
1.124 +
1.125 + /*
1.126 + Offset indices 0x01..0x67 represent half blocks from 0x0080 to 0x3380 and
1.127 + 0x68..0xA7 represent half blocks from 0xE000 to 0xFF80.
1.128 + */
1.129 + if (aCode >= 0xE000)
1.130 + aCode -= 0xAC00;
1.131 + return aCode / 0x80;
1.132 + }
1.133 +
1.134 +// Return the base of the window represented by offset index <n>. Return 0 if the offset index is illegal.
1.135 +TUint32 TUnicodeCompressionState::DynamicWindowBase(TInt aOffsetIndex)
1.136 + {
1.137 + if (aOffsetIndex >= 0xF9 && aOffsetIndex <= 0xFF)
1.138 + {
1.139 + /*
1.140 + WARNING: don't optimise the following two lines by replacing them with
1.141 + 'return iSpecialBase[aOffsetIndex - 0xF9];'. To do so would re-introduce an error
1.142 + in ARM builds caused by optimisation and consequent erroneous fixing up
1.143 + of the array base: see defect EDNGASR-4AGJQX in ER5U defects.
1.144 + */
1.145 + int special_base_index = aOffsetIndex - 0xF9;
1.146 + return iSpecialBase[special_base_index];
1.147 + }
1.148 + if (aOffsetIndex >= 0x01 && aOffsetIndex <= 0x67)
1.149 + return aOffsetIndex * 0x80;
1.150 + if (aOffsetIndex >= 0x68 && aOffsetIndex <= 0xA7)
1.151 + return aOffsetIndex * 0x80 + 0xAC00;
1.152 + return 0;
1.153 + }
1.154 +
1.155 +TBool TUnicodeCompressionState::EncodeAsIs(TUint16 aCode)
1.156 + {
1.157 + return aCode == 0x0000 || aCode == 0x0009 || aCode == 0x000A || aCode == 0x000D ||
1.158 + (aCode >= 0x0020 && aCode <= 0x007F);
1.159 + }
1.160 +
1.161 +void TUnicodeCompressionState::Panic(TPanic aPanic)
1.162 + {
1.163 + User::Panic(_L16("ucmp"),(TInt)aPanic);
1.164 + }
1.165 +
1.166 +EXPORT_C TUnicodeCompressor::TUnicodeCompressor():
1.167 + iInputBufferStart(0),
1.168 + iInputBufferSize(0),
1.169 + iOutputBufferStart(0),
1.170 + iOutputBufferSize(0),
1.171 + iDynamicWindowIndex(0),
1.172 + iOutputStream(NULL),
1.173 + iOutputPointer(NULL),
1.174 + iInput(NULL)
1.175 + {
1.176 + // Clear coverity warning
1.177 + memset(iOutputBuffer, 0, sizeof(iOutputBuffer));
1.178 + }
1.179 +
1.180 +EXPORT_C void TUnicodeCompressor::CompressL(RWriteStream& aOutput,MUnicodeSource& aInput,
1.181 + TInt aMaxOutputBytes,TInt aMaxInputWords,
1.182 + TInt* aOutputBytes,TInt* aInputWords)
1.183 + {
1.184 + DoCompressL(&aOutput,NULL,&aInput,aMaxOutputBytes,aMaxInputWords,aOutputBytes,aInputWords);
1.185 + }
1.186 +
1.187 +EXPORT_C void TUnicodeCompressor::CompressL(TUint8* aOutput,MUnicodeSource& aInput,
1.188 + TInt aMaxOutputBytes,TInt aMaxInputWords,
1.189 + TInt* aOutputBytes,TInt* aInputWords)
1.190 + {
1.191 + DoCompressL(NULL,aOutput,&aInput,aMaxOutputBytes,aMaxInputWords,aOutputBytes,aInputWords);
1.192 + }
1.193 +
1.194 +EXPORT_C TInt TUnicodeCompressor::FlushL(RWriteStream& aOutput,TInt aMaxOutputBytes,TInt& aOutputBytes)
1.195 + {
1.196 + DoCompressL(&aOutput,NULL,NULL,aMaxOutputBytes,0,&aOutputBytes,NULL);
1.197 + return iOutputBufferSize;
1.198 + }
1.199 +
1.200 +EXPORT_C TInt TUnicodeCompressor::FlushL(TUint8* aOutput,TInt aMaxOutputBytes,TInt& aOutputBytes)
1.201 + {
1.202 + DoCompressL(NULL,aOutput,NULL,aMaxOutputBytes,0,&aOutputBytes,NULL);
1.203 + return iOutputBufferSize;
1.204 + }
1.205 +
1.206 +EXPORT_C TInt TUnicodeCompressor::CompressedSizeL(MUnicodeSource& aInput,TInt aInputWords)
1.207 + {
1.208 + TInt bytes;
1.209 + TUnicodeCompressor c;
1.210 + c.DoCompressL(NULL,NULL,&aInput,KMaxTInt,aInputWords,&bytes,NULL);
1.211 + return bytes;
1.212 + }
1.213 +
1.214 +// Compress until input or output is exhausted or an exception occurs.
1.215 +void TUnicodeCompressor::DoCompressL(RWriteStream* aOutputStream,TUint8* aOutputPointer,MUnicodeSource* aInput,
1.216 + TInt aMaxOutputBytes,TInt aMaxInputWords,
1.217 + TInt* aOutputBytes,TInt* aInputWords)
1.218 + {
1.219 + iOutputStream = aOutputStream;
1.220 + iOutputPointer = aOutputPointer;
1.221 + iInput = aInput;
1.222 + iMaxCompressedBytes = aMaxOutputBytes;
1.223 + iMaxUnicodeWords = aMaxInputWords;
1.224 + iCompressedBytes = iUnicodeWords = 0;
1.225 + FlushOutputBufferL();
1.226 + if (iInput)
1.227 + {
1.228 + while (iUnicodeWords < iMaxUnicodeWords && iCompressedBytes < iMaxCompressedBytes)
1.229 + {
1.230 + TUint16 x = iInput->ReadUnicodeValueL();
1.231 + TAction action(x);
1.232 + iInputBuffer[(iInputBufferStart + iInputBufferSize) % EMaxInputBufferSize] = action;
1.233 + iInputBufferSize++;
1.234 + iUnicodeWords++;
1.235 + if (iInputBufferSize == EMaxInputBufferSize)
1.236 + WriteRunL();
1.237 + }
1.238 + }
1.239 + FlushInputBufferL();
1.240 + if (aOutputBytes)
1.241 + *aOutputBytes = iCompressedBytes;
1.242 + if (aInputWords)
1.243 + *aInputWords = iUnicodeWords;
1.244 + }
1.245 +
1.246 +TUnicodeCompressor::TAction::TAction(TUint16 aCode):
1.247 + iCode(aCode)
1.248 + {
1.249 + if (TUnicodeCompressionState::EncodeAsIs(aCode))
1.250 + iTreatment = EPlainASCII;
1.251 + else
1.252 + {
1.253 + iTreatment = TUnicodeCompressionState::DynamicWindowOffsetIndex(aCode);
1.254 + if (iTreatment == -1)
1.255 + {
1.256 + iTreatment = TUnicodeCompressionState::StaticWindowIndex(aCode);
1.257 + if (iTreatment == -1)
1.258 + iTreatment = EPlainUnicode;
1.259 + else
1.260 + iTreatment += EFirstStatic;
1.261 + }
1.262 + }
1.263 + }
1.264 +
1.265 +void TUnicodeCompressor::WriteCharacterFromBuffer()
1.266 + {
1.267 + const TAction& action = iInputBuffer[iInputBufferStart];
1.268 + iInputBufferSize--;
1.269 + iInputBufferStart = (iInputBufferStart + 1) % EMaxInputBufferSize;
1.270 + WriteCharacter(action);
1.271 + }
1.272 +
1.273 +void TUnicodeCompressor::FlushInputBufferL()
1.274 + {
1.275 + while (iInputBufferSize > 0 && iCompressedBytes < iMaxCompressedBytes)
1.276 + WriteRunL();
1.277 + }
1.278 +
1.279 +void TUnicodeCompressor::WriteRunL()
1.280 + {
1.281 + // Write out any leading characters that can be passed through.
1.282 + if (!iUnicodeMode)
1.283 + while (iInputBufferSize > 0)
1.284 + {
1.285 + const TAction& action = iInputBuffer[iInputBufferStart];
1.286 + if (action.iTreatment == TAction::EPlainASCII ||
1.287 + (action.iCode >= iActiveWindowBase && action.iCode < iActiveWindowBase + 128))
1.288 + WriteCharacterFromBuffer();
1.289 + else
1.290 + break;
1.291 + }
1.292 +
1.293 + // Write a run of characters that cannot be passed through.
1.294 + int i;
1.295 + if (iInputBufferSize > 0)
1.296 + {
1.297 + /*
1.298 + Find a run of characters with the same treatment and select that treatment
1.299 + if the run has more than one character.
1.300 + */
1.301 + int treatment = iInputBuffer[iInputBufferStart].iTreatment;
1.302 + int next_treatment = treatment;
1.303 + int run_size = 1;
1.304 + for (i = 1; i < iInputBufferSize; i++)
1.305 + {
1.306 + int index = (iInputBufferStart + i) % EMaxInputBufferSize;
1.307 + next_treatment = iInputBuffer[index].iTreatment;
1.308 + if (next_treatment != treatment)
1.309 + break;
1.310 + run_size++;
1.311 + }
1.312 + if (run_size > 1)
1.313 + SelectTreatment(treatment);
1.314 + for (i = 0; i < run_size; i++)
1.315 + WriteCharacterFromBuffer();
1.316 + }
1.317 +
1.318 + FlushOutputBufferL();
1.319 + }
1.320 +
1.321 +void TUnicodeCompressor::FlushOutputBufferL()
1.322 + {
1.323 + while (iOutputBufferSize > 0 && iCompressedBytes < iMaxCompressedBytes)
1.324 + {
1.325 + TUint8 byte = iOutputBuffer[iOutputBufferStart];
1.326 + if (iOutputPointer)
1.327 + *iOutputPointer++ = byte;
1.328 + else if (iOutputStream)
1.329 + iOutputStream->WriteUint8L(byte);
1.330 + iCompressedBytes++;
1.331 + iOutputBufferSize--;
1.332 + iOutputBufferStart = (iOutputBufferStart + 1) % EMaxOutputBufferSize;
1.333 + }
1.334 + }
1.335 +
1.336 +void TUnicodeCompressor::SelectTreatment(TInt aTreatment)
1.337 + {
1.338 + if (aTreatment == TAction::EPlainUnicode)
1.339 + {
1.340 + // Switch to Unicode mode if not there already.
1.341 + if (!iUnicodeMode)
1.342 + {
1.343 + WriteByte(SCU);
1.344 + iUnicodeMode = TRUE;
1.345 + }
1.346 + return;
1.347 + }
1.348 +
1.349 + if (aTreatment == TAction::EPlainASCII)
1.350 + {
1.351 + // Switch to single-byte mode, using the current dynamic window, if not there already.
1.352 + if (iUnicodeMode)
1.353 + {
1.354 + WriteByte(UC0 + iDynamicWindowIndex);
1.355 + iUnicodeMode = FALSE;
1.356 + }
1.357 + return;
1.358 + }
1.359 +
1.360 + if (aTreatment >= TAction::EFirstDynamic && aTreatment <= TAction::ELastDynamic)
1.361 + {
1.362 + TUint32 base = DynamicWindowBase(aTreatment);
1.363 +
1.364 + // Switch to the appropriate dynamic window if it is available; if not, redefine and select dynamic window 4.
1.365 + for (int i = 0; i < EDynamicWindows; i++)
1.366 + if (base == iDynamicWindow[i])
1.367 + {
1.368 + if (iUnicodeMode)
1.369 + WriteByte(UC0 + i);
1.370 + else if (i != iDynamicWindowIndex)
1.371 + WriteByte(SC0 + i);
1.372 + iUnicodeMode = FALSE;
1.373 + iDynamicWindowIndex = i;
1.374 + iActiveWindowBase = base;
1.375 + return;
1.376 + }
1.377 + if (iUnicodeMode)
1.378 + WriteByte(UD0 + 4);
1.379 + else
1.380 + WriteByte(SD0 + 4);
1.381 + iDynamicWindowIndex = 4;
1.382 + iUnicodeMode = FALSE;
1.383 + WriteByte(aTreatment);
1.384 + iDynamicWindow[4] = base;
1.385 + iActiveWindowBase = base;
1.386 + return;
1.387 + }
1.388 + }
1.389 +
1.390 +// Write a character without changing mode or window.
1.391 +void TUnicodeCompressor::WriteCharacter(const TAction& aAction)
1.392 + {
1.393 + if (iUnicodeMode)
1.394 + WriteUCharacter(aAction.iCode);
1.395 + else
1.396 + WriteSCharacter(aAction);
1.397 + }
1.398 +
1.399 +void TUnicodeCompressor::WriteUCharacter(TUint16 aCode)
1.400 + {
1.401 + // Emit the 'quote Unicode' tag if the character would conflict with a tag.
1.402 + if (aCode >= 0xE000 && aCode <= 0xF2FF)
1.403 + WriteByte(UQU);
1.404 +
1.405 + // Write the Unicode value big-end first.
1.406 + WriteByte((aCode >> 8) & 0xFF);
1.407 + WriteByte(aCode & 0xFF);
1.408 + }
1.409 +
1.410 +void TUnicodeCompressor::WriteByte(TUint aByte)
1.411 + {
1.412 + if (iOutputBufferSize >= EMaxOutputBufferSize)
1.413 + Panic(EOutputBufferOverflow); //Panic here is ok as this is a programming error
1.414 + iOutputBuffer[(iOutputBufferStart + iOutputBufferSize) % EMaxOutputBufferSize] = (TUint8)aByte;
1.415 + iOutputBufferSize++;
1.416 + }
1.417 +
1.418 +void TUnicodeCompressor::WriteSCharacter(const TAction& aAction)
1.419 + {
1.420 + // Characters in the range 0x0020..0x007F, plus nul, tab, cr, and lf, can be emitted as their low bytes.
1.421 + if (aAction.iTreatment == TAction::EPlainASCII)
1.422 + {
1.423 + WriteByte(aAction.iCode);
1.424 + return;
1.425 + }
1.426 +
1.427 + // Characters in a static window can be written using SQ<n> plus a byte in the range 0x00-0x7F
1.428 + if (aAction.iTreatment >= TAction::EFirstStatic && aAction.iTreatment <= TAction::ELastStatic)
1.429 + {
1.430 + int window = aAction.iTreatment - TAction::EFirstStatic;
1.431 + WriteByte(SQ0 + window);
1.432 + WriteByte(aAction.iCode);
1.433 + return;
1.434 + }
1.435 +
1.436 + // Characters in the current dynamic window can be written as a byte in the range 0x80-0xFF.
1.437 + if (aAction.iCode >= iActiveWindowBase && aAction.iCode < iActiveWindowBase + 128)
1.438 + {
1.439 + WriteByte(aAction.iCode - iActiveWindowBase + 0x80);
1.440 + return;
1.441 + }
1.442 +
1.443 + // Characters in another dynamic window can be written using SQ<n> plus a byte in the range 0x80-0xFF
1.444 + int i;
1.445 + for (i = 0; i < EDynamicWindows; i++)
1.446 + if (aAction.iCode >= iDynamicWindow[i] && aAction.iCode < iDynamicWindow[i] + 128)
1.447 + {
1.448 + WriteByte(SQ0 + i);
1.449 + WriteByte(aAction.iCode - iDynamicWindow[i] + 0x80);
1.450 + return;
1.451 + }
1.452 +
1.453 + // Other characters can be quoted.
1.454 + WriteByte(SQU);
1.455 + WriteByte((aAction.iCode >> 8) & 0xFF);
1.456 + WriteByte(aAction.iCode & 0xFF);
1.457 + return;
1.458 + }
1.459 +
1.460 +EXPORT_C TUnicodeExpander::TUnicodeExpander():
1.461 + iInputBufferStart(0),
1.462 + iInputBufferSize(0),
1.463 + iOutputBufferStart(0),
1.464 + iOutputBufferSize(0),
1.465 + iOutput(NULL),
1.466 + iInputStream(NULL),
1.467 + iInputPointer(NULL)
1.468 + {
1.469 + // Clear coverity warnings
1.470 + memset(iInputBuffer, 0, sizeof(iInputBuffer));
1.471 + memset(iOutputBuffer, 0, sizeof(iOutputBuffer));
1.472 + }
1.473 +
1.474 +EXPORT_C void TUnicodeExpander::ExpandL(MUnicodeSink& aOutput,RReadStream& aInput,
1.475 + TInt aMaxOutputWords,TInt aMaxInputBytes,
1.476 + TInt* aOutputWords,TInt* aInputBytes)
1.477 + {
1.478 + DoExpandL(&aOutput,&aInput,NULL,aMaxOutputWords,aMaxInputBytes,aOutputWords,aInputBytes);
1.479 + }
1.480 +
1.481 +EXPORT_C void TUnicodeExpander::ExpandL(MUnicodeSink& aOutput,const TUint8* aInput,
1.482 + TInt aMaxOutputWords,TInt aMaxInputBytes,
1.483 + TInt* aOutputWords,TInt* aInputBytes)
1.484 + {
1.485 + DoExpandL(&aOutput,NULL,aInput,aMaxOutputWords,aMaxInputBytes,aOutputWords,aInputBytes);
1.486 + }
1.487 +
1.488 +EXPORT_C TInt TUnicodeExpander::FlushL(MUnicodeSink& aOutput,TInt aMaxOutputWords,TInt& aOutputWords)
1.489 + {
1.490 + DoExpandL(&aOutput,NULL,NULL,aMaxOutputWords,0,&aOutputWords,NULL);
1.491 + return iOutputBufferSize;
1.492 + }
1.493 +
1.494 +EXPORT_C TInt TUnicodeExpander::ExpandedSizeL(RReadStream& aInput,TInt aInputBytes)
1.495 + {
1.496 + TInt words;
1.497 + TUnicodeExpander e;
1.498 + e.DoExpandL(NULL,&aInput,NULL,KMaxTInt,aInputBytes,&words,NULL);
1.499 + return words;
1.500 + }
1.501 +
1.502 +EXPORT_C TInt TUnicodeExpander::ExpandedSizeL(const TUint8* aInput,TInt aInputBytes)
1.503 + {
1.504 + TInt words;
1.505 + TUnicodeExpander e;
1.506 + e.DoExpandL(NULL,NULL,aInput,KMaxTInt,aInputBytes,&words,NULL);
1.507 + return words;
1.508 + }
1.509 +
1.510 +// Expand until input or output is exhausted or an exception occurs.
1.511 +void TUnicodeExpander::DoExpandL(MUnicodeSink* aOutput,RReadStream* aInputStream,const TUint8* aInputPointer,
1.512 + TInt aMaxOutputWords,TInt aMaxInputBytes,
1.513 + TInt* aOutputWords,TInt* aInputBytes)
1.514 + {
1.515 + iOutput = aOutput;
1.516 + iInputStream = aInputStream;
1.517 + iInputPointer = aInputPointer;
1.518 + iMaxUnicodeWords = aMaxOutputWords;
1.519 + iMaxCompressedBytes = aMaxInputBytes;
1.520 + iUnicodeWords = iCompressedBytes = 0;
1.521 + iInputBufferStart = 0;
1.522 + FlushOutputBufferL();
1.523 + if (iInputPointer || iInputStream)
1.524 + {
1.525 + while (iUnicodeWords + iOutputBufferSize < iMaxUnicodeWords && iCompressedBytes < iMaxCompressedBytes)
1.526 + HandleByteL();
1.527 + }
1.528 + if (aOutputWords)
1.529 + *aOutputWords = iUnicodeWords;
1.530 + if (aInputBytes)
1.531 + *aInputBytes = iCompressedBytes;
1.532 + }
1.533 +
1.534 +void TUnicodeExpander::HandleByteL()
1.535 + {
1.536 + TUint8 byte;
1.537 + TBool handled = FALSE;
1.538 + if (ReadByteL(byte))
1.539 + {
1.540 + if (iUnicodeMode)
1.541 + handled = HandleUByteL(byte);
1.542 + else
1.543 + handled = HandleSByteL(byte);
1.544 + }
1.545 + iInputBufferStart = 0;
1.546 + if (handled)
1.547 + iInputBufferSize = 0;
1.548 + FlushOutputBufferL();
1.549 + }
1.550 +
1.551 +void TUnicodeExpander::FlushOutputBufferL()
1.552 + {
1.553 + while (iOutputBufferSize > 0 && iUnicodeWords < iMaxUnicodeWords)
1.554 + {
1.555 + if (iOutput)
1.556 + iOutput->WriteUnicodeValueL(iOutputBuffer[iOutputBufferStart]);
1.557 + iUnicodeWords++;
1.558 + iOutputBufferSize--;
1.559 + iOutputBufferStart = (iOutputBufferStart + 1) % EMaxOutputBufferSize;
1.560 + }
1.561 + }
1.562 +
1.563 +TBool TUnicodeExpander::HandleSByteL(TUint8 aByte)
1.564 + {
1.565 + // 'Pass-through' codes.
1.566 + if (TUnicodeCompressionState::EncodeAsIs(aByte))
1.567 + {
1.568 + WriteChar(aByte);
1.569 + return TRUE;
1.570 + }
1.571 +
1.572 + // Codes 0x80-0xFF select a character from the active window.
1.573 + if (aByte >= 0x80)
1.574 + {
1.575 + WriteChar32(iActiveWindowBase + aByte - 0x80);
1.576 + return TRUE;
1.577 + }
1.578 +
1.579 + // SQU: quote a Unicode character.
1.580 + if (aByte == SQU)
1.581 + return QuoteUnicodeL();
1.582 +
1.583 + // SCU: switch to Unicode mode.
1.584 + if (aByte == SCU)
1.585 + {
1.586 + iUnicodeMode = TRUE;
1.587 + return TRUE;
1.588 + }
1.589 +
1.590 + // SQn: quote from window n.
1.591 + if (aByte >= SQ0 && aByte <= SQ0 + 7)
1.592 + {
1.593 + int window = aByte - SQ0;
1.594 + TUint8 byte;
1.595 + if (ReadByteL(byte))
1.596 + {
1.597 + TUint32 c = byte;
1.598 + if (c <= 0x7F)
1.599 + c += iStaticWindow[window];
1.600 + else
1.601 + c += iDynamicWindow[window] - 0x80;
1.602 + WriteChar32(c);
1.603 + return TRUE;
1.604 + }
1.605 + else
1.606 + return FALSE;
1.607 + }
1.608 +
1.609 + // SCn: switch to dynamic window n.
1.610 + if (aByte >= SC0 && aByte <= SC0 + 7)
1.611 + {
1.612 + iActiveWindowBase = iDynamicWindow[aByte - SC0];
1.613 + return TRUE;
1.614 + }
1.615 +
1.616 + // SDn: define dynamic window n and switch to it.
1.617 + if (aByte >= SD0 && aByte <= SD0 + 7)
1.618 + return DefineWindowL(aByte - SD0);
1.619 +
1.620 + // SDX: define window in the expansion space.
1.621 + if (aByte == SDX)
1.622 + return DefineExpansionWindowL();
1.623 +
1.624 + User::Leave(KErrCorrupt);
1.625 + return FALSE;
1.626 + }
1.627 +
1.628 +TBool TUnicodeExpander::HandleUByteL(TUint8 aByte)
1.629 + {
1.630 + // Plain Unicode; get the low byte and emit the Unicode value.
1.631 + if (aByte <= 0xDF || aByte >= 0xF3)
1.632 + {
1.633 + TUint8 lo;
1.634 + if (ReadByteL(lo))
1.635 + {
1.636 + TUint16 c = (TUint16)((aByte << 8) | lo);
1.637 + WriteChar(c);
1.638 + return TRUE;
1.639 + }
1.640 + else
1.641 + return FALSE;
1.642 + }
1.643 +
1.644 + // Quote a Unicode character that would otherwise conflict with a tag.
1.645 + if (aByte == UQU)
1.646 + return QuoteUnicodeL();
1.647 +
1.648 + // UCn: change to single byte mode and select window n.
1.649 + if (aByte >= UC0 && aByte <= UC0 + 7)
1.650 + {
1.651 + iUnicodeMode = FALSE;
1.652 + iActiveWindowBase = iDynamicWindow[aByte - UC0];
1.653 + return TRUE;
1.654 + }
1.655 +
1.656 + // UDn: define dynamic window n and switch to it.
1.657 + if (aByte >= UD0 && aByte <= UD0 + 7)
1.658 + return DefineWindowL(aByte - UD0);
1.659 +
1.660 + // UDX: define window in the expansion space.
1.661 + if (aByte == UDX)
1.662 + return DefineExpansionWindowL();
1.663 +
1.664 + User::Leave(KErrCorrupt);
1.665 + return FALSE;
1.666 + }
1.667 +
1.668 +TBool TUnicodeExpander::QuoteUnicodeL()
1.669 + {
1.670 + TUint8 hi, lo;
1.671 + if (ReadByteL(hi) && ReadByteL(lo))
1.672 + {
1.673 + TUint16 c = (TUint16)((hi << 8) | lo);
1.674 + WriteChar(c);
1.675 + return TRUE;
1.676 + }
1.677 + else
1.678 + return FALSE;
1.679 + }
1.680 +
1.681 +TBool TUnicodeExpander::DefineWindowL(TInt aIndex)
1.682 + {
1.683 + TUint8 window;
1.684 + if (ReadByteL(window))
1.685 + {
1.686 + iUnicodeMode = FALSE;
1.687 + iActiveWindowBase = DynamicWindowBase(window);
1.688 + iDynamicWindow[aIndex] = iActiveWindowBase;
1.689 + return TRUE;
1.690 + }
1.691 + else
1.692 + return FALSE;
1.693 + }
1.694 +
1.695 +TBool TUnicodeExpander::DefineExpansionWindowL()
1.696 + {
1.697 + TUint8 hi, lo;
1.698 + if (ReadByteL(hi) && ReadByteL(lo))
1.699 + {
1.700 + iUnicodeMode = FALSE;
1.701 + iActiveWindowBase = 0x10000 + (0x80 * ((hi & 0x1F) * 0x100 + lo));
1.702 + iDynamicWindow[hi >> 5] = iActiveWindowBase;
1.703 + return TRUE;
1.704 + }
1.705 + else
1.706 + return FALSE;
1.707 + }
1.708 +
1.709 +// Read either from the buffer (in the case of restarting after source finished in mid-operation) or from the source.
1.710 +TBool TUnicodeExpander::ReadByteL(TUint8& aByte)
1.711 + {
1.712 + if (iInputBufferStart < iInputBufferSize)
1.713 + {
1.714 + aByte = iInputBuffer[iInputBufferStart++];
1.715 + return TRUE;
1.716 + }
1.717 + else if (iCompressedBytes < iMaxCompressedBytes)
1.718 + {
1.719 + if (iInputPointer)
1.720 + aByte = *iInputPointer++;
1.721 + else
1.722 + aByte = iInputStream->ReadUint8L();
1.723 + iInputBuffer[iInputBufferStart++] = aByte;
1.724 + iInputBufferSize = iInputBufferStart;
1.725 + iCompressedBytes++;
1.726 + return TRUE;
1.727 + }
1.728 + else
1.729 + return FALSE;
1.730 + }
1.731 +
1.732 +void TUnicodeExpander::WriteChar(TUint16 aChar)
1.733 + {
1.734 + if (iOutputBufferSize >= EMaxOutputBufferSize)
1.735 + Panic(EOutputBufferOverflow); //Panic here is ok since this is a programming error
1.736 + iOutputBuffer[(iOutputBufferStart + iOutputBufferSize) % EMaxOutputBufferSize] = aChar;
1.737 + iOutputBufferSize++;
1.738 + }
1.739 +
1.740 +// Write a Unicode character; write using surrogates if in the range 0x10000..0x10FFFF.
1.741 +void TUnicodeExpander::WriteChar32(TUint aChar)
1.742 + {
1.743 + if (aChar <= 0xFFFF)
1.744 + WriteChar((TUint16)aChar);
1.745 + else if (aChar <= 0x10FFFF)
1.746 + {
1.747 + aChar -= 0x10000; // reduce to 20-bit value in the range 0x0..0xFFFFF
1.748 + WriteChar((TUint16)(0xD800 + (aChar >> 10))); // first high surrogate + high 10 bits
1.749 + WriteChar((TUint16)(0xDC00 + (aChar & 0x03FF))); // first low surrogate + low 10 bits
1.750 + }
1.751 + else
1.752 + //Panic to be kept here as impossible to test this case (nor the one before). Biggest value that can be passed is 0xFFFFF
1.753 + Panic(ENotUnicode);
1.754 + }
1.755 +
1.756 +#endif // _UNICODE