1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/textandloc/charconvfw/charconvplugins/src/plugins/EucJpDirectmap.CPP Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,2150 @@
1.4 +/*
1.5 +* Copyright (c) 2002-2004 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 "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: This file is a source code file for a charconv plug-in.
1.18 +* This plug-in supports EUC-JP with direct mapped pictograph.
1.19 +*
1.20 +*/
1.21 +
1.22 +
1.23 +
1.24 +
1.25 +
1.26 +
1.27 +
1.28 +// INCLUDE FILES
1.29 +
1.30 +#include <e32std.h>
1.31 +
1.32 +#include <charconv.h>
1.33 +
1.34 +
1.35 +
1.36 +#ifndef EKA2
1.37 +
1.38 +#include <CONVPLUG.H>
1.39 +
1.40 +#else
1.41 +
1.42 +#include <convgeneratedcpp.h>
1.43 +
1.44 +#include <ecom/implementationproxy.h>
1.45 +
1.46 +#include "charactersetconverter.h"
1.47 +
1.48 +#endif // !EKA2
1.49 +
1.50 +
1.51 +
1.52 +#include <convutils.h>
1.53 +
1.54 +#include "jisx0201.h"
1.55 +
1.56 +#include "jisx0208.h"
1.57 +
1.58 +#include "jisx0212.h"
1.59 +
1.60 +#include "CnvShiftJisDirectmap.h"
1.61 +
1.62 +// LOCAL CONSTANTS AND MACROS
1.63 +
1.64 +const TUint KSingleShift2=0x8e;
1.65 +
1.66 +const TUint KSingleShift3=0x8f;
1.67 +
1.68 +const TUint KFirstByteRangeFirstBlockStart = 0xF5;
1.69 +
1.70 +const TUint KFirstByteRangeFirstBlockEnd = 0xFE;
1.71 +
1.72 +const TUint KSecondByteRangeSecondBlockStart = 0xA1;
1.73 +
1.74 +const TUint KSecondByteRangeSecondBlockEnd = 0xFE;
1.75 +
1.76 +const TUint KPictographStartFirstByte = 0xF0;
1.77 +
1.78 +const TUint KPictographStartSecondByte = 0x40;
1.79 +
1.80 +const TUint KEUCJPSecondBlockStart = 0xF5;
1.81 +
1.82 +const TUint KEUCJPBlockSize = 0x5D;
1.83 +
1.84 +const TUint KShiftJisTrailByteIllegal = 0x7F;
1.85 +
1.86 +
1.87 +
1.88 +// SecureID for Brower app
1.89 +
1.90 +const TUint32 KBrowserSecureId = 0x10008D39;
1.91 +
1.92 +// Define for converting from YenSign to BackSlash
1.93 +
1.94 +const TUint KCharacterCodeForYenSign = 0x00A5;
1.95 +
1.96 +const TUint KCharacterCodeForBackSlash = 0x005C;
1.97 +
1.98 +
1.99 +
1.100 +// fullwidth question mark
1.101 +
1.102 +_LIT8(KLit8EucJpPackedReplacementForUnconvertibleUnicodeCharacters, "\xa1\xa9");
1.103 +
1.104 +#if defined(_DEBUG)
1.105 +
1.106 +_LIT(KLitPanicText, "EucJpDirectmap");
1.107 +
1.108 +enum TPanic
1.109 +
1.110 + {
1.111 +
1.112 + EPanicNothingToConvert1=1,
1.113 +
1.114 + EPanicNothingToConvert2,
1.115 +
1.116 + EPanicNothingToConvert3,
1.117 +
1.118 + EPanicNothingToConvert4,
1.119 +
1.120 + EPanicNothingToConvert5,
1.121 +
1.122 + EPanicNothingToConvert6,
1.123 +
1.124 + EPanicOddNumberOfBytes1,
1.125 +
1.126 + EPanicOddNumberOfBytes2,
1.127 +
1.128 + EPanicOddNumberOfBytes3,
1.129 +
1.130 + EPanicOddNumberOfBytes4,
1.131 +
1.132 + EPanicOddNumberOfBytes5,
1.133 +
1.134 + EPanicOddNumberOfBytes6,
1.135 +
1.136 + EPanicBadHighBit1,
1.137 +
1.138 + EPanicBadHighBit2,
1.139 +
1.140 + EPanicBadHighBit3,
1.141 +
1.142 + EPanicBadHighBit4,
1.143 +
1.144 + EPanicBadHighBit5,
1.145 +
1.146 + EPanicBadHighBit6,
1.147 +
1.148 + EPanicBadHighBit7,
1.149 +
1.150 + EPanicBadPointers1,
1.151 +
1.152 + EPanicBadPointers2,
1.153 +
1.154 + EPanicBadPointers3,
1.155 +
1.156 + EPanicBadPointers4,
1.157 +
1.158 + EPanicBadPointers5,
1.159 +
1.160 + EPanicBadPointers6,
1.161 +
1.162 + EPanicBadPointers7,
1.163 +
1.164 + EPanicBadPointers8,
1.165 +
1.166 + EPanicBadPointers9,
1.167 +
1.168 + EPanicBadPointers10,
1.169 +
1.170 + EPanicBadPointers11,
1.171 +
1.172 + EPanicBadPointers12,
1.173 +
1.174 + EPanicBadPointers13,
1.175 +
1.176 + EPanicBadPointers14,
1.177 +
1.178 + EPanicBadPointers15,
1.179 +
1.180 + EPanicBadPointers16,
1.181 +
1.182 + EPanicBadPointers17,
1.183 +
1.184 + EPanicBadPointers18,
1.185 +
1.186 + EPanicBadPointers19,
1.187 +
1.188 + EPanicBadPointers20,
1.189 +
1.190 + EPanicBadPointers21,
1.191 +
1.192 + EPanicBadPointers22,
1.193 +
1.194 + EPanicBadPointers23,
1.195 +
1.196 + EPanicBadPointers24,
1.197 +
1.198 + EPanicBadPointers25,
1.199 +
1.200 + EPanicBadPointers26,
1.201 +
1.202 + EPanicBadPointers27,
1.203 +
1.204 + EPanicBadPointers28,
1.205 +
1.206 + EPanicBadPointers29,
1.207 +
1.208 + EPanicBadPointers30,
1.209 +
1.210 + EPanicBadPointers31,
1.211 +
1.212 + EPanicBadPointers32,
1.213 +
1.214 + EPanicBadPointers33,
1.215 +
1.216 + EPanicBadPointers34,
1.217 +
1.218 + EPanicBadPointers35,
1.219 +
1.220 + EPanicBadPointers36,
1.221 +
1.222 + EPanicBadCalculation1,
1.223 +
1.224 + EPanicBadCalculation2,
1.225 +
1.226 + EPanicNumberOfBytesIsNotMultipleOfThree1,
1.227 +
1.228 + EPanicNumberOfBytesIsNotMultipleOfThree2,
1.229 +
1.230 + EPanicSingleShift2Expected,
1.231 +
1.232 + EPanicSingleShift3Expected
1.233 +
1.234 + };
1.235 +
1.236 +
1.237 +
1.238 +LOCAL_C void Panic(TPanic aPanic)
1.239 +
1.240 + {
1.241 +
1.242 + User::Panic(KLitPanicText, aPanic);
1.243 +
1.244 + }
1.245 +
1.246 +#endif
1.247 +
1.248 +
1.249 +
1.250 +// -----------------------------------------------------------------------------
1.251 +
1.252 +// DummyConvertFromIntermediateBufferInPlace
1.253 +
1.254 +//
1.255 +
1.256 +// -----------------------------------------------------------------------------
1.257 +
1.258 +//
1.259 +
1.260 +LOCAL_C void DummyConvertFromIntermediateBufferInPlace(TInt, TDes8&,
1.261 +
1.262 + TInt& aNumberOfCharactersThatDroppedOut)
1.263 +
1.264 + {
1.265 +
1.266 + aNumberOfCharactersThatDroppedOut = 0;
1.267 +
1.268 + }
1.269 +
1.270 +
1.271 +
1.272 +// -----------------------------------------------------------------------------
1.273 +
1.274 +// ConvertFromJisX0208ToEucJpPackedInPlace
1.275 +
1.276 +// Converts from JIS code to EUC-JP
1.277 +
1.278 +// -----------------------------------------------------------------------------
1.279 +
1.280 +//
1.281 +
1.282 +LOCAL_C void ConvertFromJisX0208ToEucJpPackedInPlace(
1.283 +
1.284 + TInt aStartPositionInDescriptor, TDes8& aDescriptor,
1.285 +
1.286 + TInt& aNumberOfCharactersThatDroppedOut)
1.287 +
1.288 + {
1.289 +
1.290 + aNumberOfCharactersThatDroppedOut = 0;
1.291 +
1.292 + const TInt descriptorLength = aDescriptor.Length();
1.293 +
1.294 + __ASSERT_DEBUG(descriptorLength > aStartPositionInDescriptor,
1.295 +
1.296 + Panic(EPanicNothingToConvert1));
1.297 +
1.298 + __ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) % 2 == 0,
1.299 +
1.300 + Panic(EPanicOddNumberOfBytes1));
1.301 +
1.302 + TUint8* pointerToCurrentByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
1.303 +
1.304 + const TUint8* const pointerToLastByte =
1.305 +
1.306 + pointerToCurrentByte + (descriptorLength - 1);
1.307 +
1.308 + pointerToCurrentByte += aStartPositionInDescriptor;
1.309 +
1.310 + FOREVER
1.311 +
1.312 + {
1.313 +
1.314 + const TUint currentByte = *pointerToCurrentByte;
1.315 +
1.316 + __ASSERT_DEBUG((currentByte & 0x80) == 0, Panic(EPanicBadHighBit1));
1.317 +
1.318 + *pointerToCurrentByte = STATIC_CAST(TUint8, currentByte | 0x80);
1.319 +
1.320 + __ASSERT_DEBUG(pointerToCurrentByte <= pointerToLastByte,
1.321 +
1.322 + Panic(EPanicBadPointers1));
1.323 +
1.324 + if (pointerToCurrentByte >= pointerToLastByte)
1.325 +
1.326 + {
1.327 +
1.328 + break;
1.329 +
1.330 + }
1.331 +
1.332 + ++pointerToCurrentByte;
1.333 +
1.334 + }
1.335 +
1.336 + }
1.337 +
1.338 +
1.339 +
1.340 +// -----------------------------------------------------------------------------
1.341 +
1.342 +// ConvertFromHalfWidthKatakana8ToEucJpPackedInPlace
1.343 +
1.344 +// Converts from half width Katakana code to EUC-JP
1.345 +
1.346 +// -----------------------------------------------------------------------------
1.347 +
1.348 +//
1.349 +
1.350 +LOCAL_C void ConvertFromHalfWidthKatakana8ToEucJpPackedInPlace(
1.351 +
1.352 + TInt aStartPositionInDescriptor, TDes8& aDescriptor,
1.353 +
1.354 + TInt& aNumberOfCharactersThatDroppedOut)
1.355 +
1.356 + {
1.357 +
1.358 + TInt descriptorLength = aDescriptor.Length();
1.359 +
1.360 + __ASSERT_DEBUG(descriptorLength > aStartPositionInDescriptor,
1.361 +
1.362 + Panic(EPanicNothingToConvert2));
1.363 +
1.364 + aNumberOfCharactersThatDroppedOut = Max(0, (descriptorLength -
1.365 +
1.366 + aStartPositionInDescriptor) - ((aDescriptor.MaxLength() -
1.367 +
1.368 + aStartPositionInDescriptor) / 2));
1.369 +
1.370 + descriptorLength -= aNumberOfCharactersThatDroppedOut;
1.371 +
1.372 + __ASSERT_DEBUG(descriptorLength >= aStartPositionInDescriptor,
1.373 +
1.374 + Panic(EPanicBadCalculation1));
1.375 +
1.376 + if (descriptorLength <= aStartPositionInDescriptor)
1.377 +
1.378 + {
1.379 +
1.380 + aDescriptor.SetLength(descriptorLength);
1.381 +
1.382 + }
1.383 +
1.384 + else
1.385 +
1.386 + {
1.387 +
1.388 + // pointerToTargetByte is initialized properly when descriptorLength
1.389 +
1.390 + // has been offset to the actual final length of aDescriptor
1.391 +
1.392 + TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
1.393 +
1.394 + const TUint8* const pointerToFirstByte =
1.395 +
1.396 + pointerToTargetByte + aStartPositionInDescriptor;
1.397 +
1.398 + const TUint8* pointerToSourceByte =
1.399 +
1.400 + pointerToTargetByte + (descriptorLength - 1);
1.401 +
1.402 + descriptorLength =
1.403 +
1.404 + ((descriptorLength - aStartPositionInDescriptor) * 2) +
1.405 +
1.406 + aStartPositionInDescriptor;
1.407 +
1.408 + __ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) % 2 == 0,
1.409 +
1.410 + Panic(EPanicOddNumberOfBytes2));
1.411 +
1.412 + aDescriptor.SetLength(descriptorLength);
1.413 +
1.414 + // pointerToTargetByte is is initialized properly here
1.415 +
1.416 + pointerToTargetByte += descriptorLength - 1;
1.417 +
1.418 + FOREVER
1.419 +
1.420 + {
1.421 +
1.422 + *pointerToTargetByte = *pointerToSourceByte;
1.423 +
1.424 + __ASSERT_DEBUG(pointerToTargetByte>pointerToFirstByte,
1.425 +
1.426 + Panic(EPanicBadPointers2));
1.427 +
1.428 + --pointerToTargetByte;
1.429 +
1.430 + *pointerToTargetByte = KSingleShift2;
1.431 +
1.432 + __ASSERT_DEBUG(pointerToTargetByte >= pointerToFirstByte,
1.433 +
1.434 + Panic(EPanicBadPointers3));
1.435 +
1.436 + if (pointerToTargetByte <= pointerToFirstByte)
1.437 +
1.438 + {
1.439 +
1.440 + break;
1.441 +
1.442 + }
1.443 +
1.444 + --pointerToTargetByte;
1.445 +
1.446 + __ASSERT_DEBUG(pointerToSourceByte > pointerToFirstByte,
1.447 +
1.448 + Panic(EPanicBadPointers4));
1.449 +
1.450 + --pointerToSourceByte;
1.451 +
1.452 + }
1.453 +
1.454 + __ASSERT_DEBUG(pointerToTargetByte == pointerToFirstByte,
1.455 +
1.456 + Panic(EPanicBadPointers5));
1.457 +
1.458 + __ASSERT_DEBUG(pointerToSourceByte == pointerToFirstByte,
1.459 +
1.460 + Panic(EPanicBadPointers6));
1.461 +
1.462 + }
1.463 +
1.464 + }
1.465 +
1.466 +
1.467 +
1.468 +// -----------------------------------------------------------------------------
1.469 +
1.470 +// ConvertFromJisX0212ToEucJpPackedInPlace
1.471 +
1.472 +// Converts from JIS code to EUC-JP
1.473 +
1.474 +// -----------------------------------------------------------------------------
1.475 +
1.476 +//
1.477 +
1.478 +LOCAL_C void ConvertFromJisX0212ToEucJpPackedInPlace(
1.479 +
1.480 + TInt aStartPositionInDescriptor, TDes8& aDescriptor,
1.481 +
1.482 + TInt& aNumberOfCharactersThatDroppedOut)
1.483 +
1.484 + {
1.485 +
1.486 + TInt descriptorLength=aDescriptor.Length();
1.487 +
1.488 + __ASSERT_DEBUG(descriptorLength > aStartPositionInDescriptor,
1.489 +
1.490 + Panic(EPanicNothingToConvert3));
1.491 +
1.492 + __ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) % 2 == 0,
1.493 +
1.494 + Panic(EPanicOddNumberOfBytes3));
1.495 +
1.496 + aNumberOfCharactersThatDroppedOut =
1.497 +
1.498 + Max(0, ((descriptorLength - aStartPositionInDescriptor) / 2) -
1.499 +
1.500 + ((aDescriptor.MaxLength() - aStartPositionInDescriptor) / 3));
1.501 +
1.502 + descriptorLength -= aNumberOfCharactersThatDroppedOut * 2;
1.503 +
1.504 + __ASSERT_DEBUG(descriptorLength >= aStartPositionInDescriptor,
1.505 +
1.506 + Panic(EPanicBadCalculation2));
1.507 +
1.508 + if (descriptorLength <= aStartPositionInDescriptor)
1.509 +
1.510 + {
1.511 +
1.512 + aDescriptor.SetLength(descriptorLength);
1.513 +
1.514 + }
1.515 +
1.516 + else
1.517 +
1.518 + {
1.519 +
1.520 + __ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) % 2 == 0,
1.521 +
1.522 + Panic(EPanicOddNumberOfBytes4));
1.523 +
1.524 + // pointerToTargetByte is initialized properly when descriptorLength
1.525 +
1.526 + // has been offset to the actual final length of aDescriptor
1.527 +
1.528 + TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
1.529 +
1.530 + const TUint8* const pointerToFirstByte =
1.531 +
1.532 + pointerToTargetByte + aStartPositionInDescriptor;
1.533 +
1.534 + const TUint8* pointerToSourceByte =
1.535 +
1.536 + pointerToTargetByte + (descriptorLength - 1);
1.537 +
1.538 + descriptorLength = (((descriptorLength - aStartPositionInDescriptor)
1.539 +
1.540 + * 3) / 2) + aStartPositionInDescriptor;
1.541 +
1.542 + __ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) % 3 ==0,
1.543 +
1.544 + Panic(EPanicNumberOfBytesIsNotMultipleOfThree1));
1.545 +
1.546 + aDescriptor.SetLength(descriptorLength);
1.547 +
1.548 + // pointerToTargetByte is is initialized properly here
1.549 +
1.550 + pointerToTargetByte += descriptorLength - 1;
1.551 +
1.552 + FOREVER
1.553 +
1.554 + {
1.555 +
1.556 + __ASSERT_DEBUG((*pointerToSourceByte & 0x80) == 0,
1.557 +
1.558 + Panic(EPanicBadHighBit2));
1.559 +
1.560 + *pointerToTargetByte =
1.561 +
1.562 + STATIC_CAST(TUint8, *pointerToSourceByte | 0x80);
1.563 +
1.564 + __ASSERT_DEBUG(pointerToTargetByte > pointerToFirstByte,
1.565 +
1.566 + Panic(EPanicBadPointers7));
1.567 +
1.568 + --pointerToTargetByte;
1.569 +
1.570 + __ASSERT_DEBUG(pointerToSourceByte > pointerToFirstByte,
1.571 +
1.572 + Panic(EPanicBadPointers8));
1.573 +
1.574 + --pointerToSourceByte;
1.575 +
1.576 + __ASSERT_DEBUG((*pointerToSourceByte & 0x80) == 0,
1.577 +
1.578 + Panic(EPanicBadHighBit3));
1.579 +
1.580 + *pointerToTargetByte =
1.581 +
1.582 + STATIC_CAST(TUint8, *pointerToSourceByte | 0x80);
1.583 +
1.584 + __ASSERT_DEBUG(pointerToTargetByte > pointerToFirstByte,
1.585 +
1.586 + Panic(EPanicBadPointers9));
1.587 +
1.588 + --pointerToTargetByte;
1.589 +
1.590 + *pointerToTargetByte = KSingleShift3;
1.591 +
1.592 + __ASSERT_DEBUG(pointerToTargetByte >= pointerToFirstByte,
1.593 +
1.594 + Panic(EPanicBadPointers10));
1.595 +
1.596 + if (pointerToTargetByte <= pointerToFirstByte)
1.597 +
1.598 + {
1.599 +
1.600 + break;
1.601 +
1.602 + }
1.603 +
1.604 + --pointerToTargetByte;
1.605 +
1.606 + __ASSERT_DEBUG(pointerToSourceByte > pointerToFirstByte,
1.607 +
1.608 + Panic(EPanicBadPointers11));
1.609 +
1.610 + --pointerToSourceByte;
1.611 +
1.612 + }
1.613 +
1.614 + __ASSERT_DEBUG(pointerToTargetByte == pointerToFirstByte,
1.615 +
1.616 + Panic(EPanicBadPointers12));
1.617 +
1.618 + __ASSERT_DEBUG(pointerToSourceByte == pointerToFirstByte,
1.619 +
1.620 + Panic(EPanicBadPointers13));
1.621 +
1.622 + }
1.623 +
1.624 + }
1.625 +
1.626 +
1.627 +
1.628 +// -----------------------------------------------------------------------------
1.629 +
1.630 +// NumberOfBytesAbleToConvertToJisRoman
1.631 +
1.632 +// Counts the bytes of be able to convert to JIS
1.633 +
1.634 +// -----------------------------------------------------------------------------
1.635 +
1.636 +//
1.637 +
1.638 +LOCAL_C TInt NumberOfBytesAbleToConvertToJisRoman(const TDesC8& aDescriptor)
1.639 +
1.640 + {
1.641 +
1.642 + const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;
1.643 +
1.644 + const TUint8* const pointerToLastByte =
1.645 +
1.646 + pointerToPreviousByte + aDescriptor.Length();
1.647 +
1.648 + if (pointerToPreviousByte == pointerToLastByte)
1.649 +
1.650 + {
1.651 +
1.652 + return 0;
1.653 +
1.654 + }
1.655 +
1.656 + FOREVER
1.657 +
1.658 + {
1.659 +
1.660 + __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
1.661 +
1.662 + Panic(EPanicBadPointers14));
1.663 +
1.664 + const TUint currentByte = *(pointerToPreviousByte + 1);
1.665 +
1.666 + if (currentByte & 0x80)
1.667 +
1.668 + {
1.669 +
1.670 + break;
1.671 +
1.672 + }
1.673 +
1.674 + __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
1.675 +
1.676 + Panic(EPanicBadPointers15));
1.677 +
1.678 + ++pointerToPreviousByte;
1.679 +
1.680 + __ASSERT_DEBUG(pointerToPreviousByte <= pointerToLastByte,
1.681 +
1.682 + Panic(EPanicBadPointers16));
1.683 +
1.684 + if (pointerToPreviousByte >= pointerToLastByte)
1.685 +
1.686 + {
1.687 +
1.688 + break;
1.689 +
1.690 + }
1.691 +
1.692 + }
1.693 +
1.694 + return (pointerToPreviousByte + 1) - aDescriptor.Ptr();
1.695 +
1.696 + }
1.697 +
1.698 +
1.699 +
1.700 +// -----------------------------------------------------------------------------
1.701 +
1.702 +// NumberOfBytesAbleToConvertToJisX0208
1.703 +
1.704 +// Counts the bytes of be able to convert to JIS
1.705 +
1.706 +// -----------------------------------------------------------------------------
1.707 +
1.708 +//
1.709 +
1.710 +LOCAL_C TInt NumberOfBytesAbleToConvertToJisX0208(const TDesC8& aDescriptor)
1.711 +
1.712 + {
1.713 +
1.714 + const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;
1.715 +
1.716 + const TUint8* const pointerToLastByte =
1.717 +
1.718 + pointerToPreviousByte + aDescriptor.Length();
1.719 +
1.720 + if (pointerToPreviousByte == pointerToLastByte)
1.721 +
1.722 + {
1.723 +
1.724 + return 0;
1.725 +
1.726 + }
1.727 +
1.728 + FOREVER
1.729 +
1.730 + {
1.731 +
1.732 + __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
1.733 +
1.734 + Panic(EPanicBadPointers17));
1.735 +
1.736 + TUint currentByte = *(pointerToPreviousByte + 1);
1.737 +
1.738 + if (currentByte < 0xa0)
1.739 +
1.740 + {
1.741 +
1.742 + break;
1.743 +
1.744 + }
1.745 +
1.746 + __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
1.747 +
1.748 + Panic(EPanicBadPointers18));
1.749 +
1.750 + if (pointerToLastByte - pointerToPreviousByte < 2)
1.751 +
1.752 + {
1.753 +
1.754 + break;
1.755 +
1.756 + }
1.757 +
1.758 + ++pointerToPreviousByte;
1.759 +
1.760 + currentByte = *(pointerToPreviousByte + 1);
1.761 +
1.762 + if (currentByte < 0xa0)
1.763 +
1.764 + {
1.765 +
1.766 + return CCnvCharacterSetConverter::EErrorIllFormedInput;
1.767 +
1.768 + }
1.769 +
1.770 + __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
1.771 +
1.772 + Panic(EPanicBadPointers19));
1.773 +
1.774 + ++pointerToPreviousByte;
1.775 +
1.776 + __ASSERT_DEBUG(pointerToPreviousByte <= pointerToLastByte,
1.777 +
1.778 + Panic(EPanicBadPointers20));
1.779 +
1.780 + if (pointerToPreviousByte >= pointerToLastByte)
1.781 +
1.782 + {
1.783 +
1.784 + break;
1.785 +
1.786 + }
1.787 +
1.788 + }
1.789 +
1.790 + return (pointerToPreviousByte + 1) - aDescriptor.Ptr();
1.791 +
1.792 + }
1.793 +
1.794 +
1.795 +
1.796 +// -----------------------------------------------------------------------------
1.797 +
1.798 +// NumberOfBytesAbleToConvertToHalfWidthKatakana8
1.799 +
1.800 +// Counts the bytes of be able to convert to half width Katakana
1.801 +
1.802 +// -----------------------------------------------------------------------------
1.803 +
1.804 +//
1.805 +
1.806 +LOCAL_C TInt NumberOfBytesAbleToConvertToHalfWidthKatakana8(const TDesC8& aDescriptor)
1.807 +
1.808 + {
1.809 +
1.810 + const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;
1.811 +
1.812 + const TUint8* const pointerToLastByte =
1.813 +
1.814 + pointerToPreviousByte + aDescriptor.Length();
1.815 +
1.816 + if (pointerToPreviousByte == pointerToLastByte)
1.817 +
1.818 + {
1.819 +
1.820 + return 0;
1.821 +
1.822 + }
1.823 +
1.824 + FOREVER
1.825 +
1.826 + {
1.827 +
1.828 + __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
1.829 +
1.830 + Panic(EPanicBadPointers21));
1.831 +
1.832 + TUint currentByte = *(pointerToPreviousByte + 1);
1.833 +
1.834 + if (currentByte != KSingleShift2)
1.835 +
1.836 + {
1.837 +
1.838 + break;
1.839 +
1.840 + }
1.841 +
1.842 + __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
1.843 +
1.844 + Panic(EPanicBadPointers22));
1.845 +
1.846 + if (pointerToLastByte - pointerToPreviousByte < 2)
1.847 +
1.848 + {
1.849 +
1.850 + break;
1.851 +
1.852 + }
1.853 +
1.854 + ++pointerToPreviousByte;
1.855 +
1.856 + currentByte = *(pointerToPreviousByte + 1);
1.857 +
1.858 + if (currentByte < 0xa0)
1.859 +
1.860 + {
1.861 +
1.862 + return CCnvCharacterSetConverter::EErrorIllFormedInput;
1.863 +
1.864 + }
1.865 +
1.866 + __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
1.867 +
1.868 + Panic(EPanicBadPointers23));
1.869 +
1.870 + ++pointerToPreviousByte;
1.871 +
1.872 + __ASSERT_DEBUG(pointerToPreviousByte <= pointerToLastByte,
1.873 +
1.874 + Panic(EPanicBadPointers24));
1.875 +
1.876 + if (pointerToPreviousByte >= pointerToLastByte)
1.877 +
1.878 + {
1.879 +
1.880 + break;
1.881 +
1.882 + }
1.883 +
1.884 + }
1.885 +
1.886 + return (pointerToPreviousByte + 1) - aDescriptor.Ptr();
1.887 +
1.888 + }
1.889 +
1.890 +
1.891 +
1.892 +// -----------------------------------------------------------------------------
1.893 +
1.894 +// NumberOfBytesAbleToConvertToJisX0212
1.895 +
1.896 +// Counts the bytes of be able to convert to JIS
1.897 +
1.898 +// -----------------------------------------------------------------------------
1.899 +
1.900 +//
1.901 +
1.902 +LOCAL_C TInt NumberOfBytesAbleToConvertToJisX0212(const TDesC8& aDescriptor)
1.903 +
1.904 + {
1.905 +
1.906 + const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;
1.907 +
1.908 + const TUint8* const pointerToLastByte =
1.909 +
1.910 + pointerToPreviousByte + aDescriptor.Length();
1.911 +
1.912 + if (pointerToPreviousByte == pointerToLastByte)
1.913 +
1.914 + {
1.915 +
1.916 + return 0;
1.917 +
1.918 + }
1.919 +
1.920 + FOREVER
1.921 +
1.922 + {
1.923 +
1.924 + __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
1.925 +
1.926 + Panic(EPanicBadPointers25));
1.927 +
1.928 + TUint currentByte = *(pointerToPreviousByte + 1);
1.929 +
1.930 + if (currentByte != KSingleShift3)
1.931 +
1.932 + {
1.933 +
1.934 + break;
1.935 +
1.936 + }
1.937 +
1.938 + __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
1.939 +
1.940 + Panic(EPanicBadPointers26));
1.941 +
1.942 + if (pointerToLastByte - pointerToPreviousByte < 3)
1.943 +
1.944 + {
1.945 +
1.946 + break;
1.947 +
1.948 + }
1.949 +
1.950 + ++pointerToPreviousByte;
1.951 +
1.952 + currentByte = *(pointerToPreviousByte + 1);
1.953 +
1.954 + if (currentByte < 0xa0)
1.955 +
1.956 + {
1.957 +
1.958 + return CCnvCharacterSetConverter::EErrorIllFormedInput;
1.959 +
1.960 + }
1.961 +
1.962 + __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
1.963 +
1.964 + Panic(EPanicBadPointers27));
1.965 +
1.966 + ++pointerToPreviousByte;
1.967 +
1.968 + currentByte = *(pointerToPreviousByte + 1);
1.969 +
1.970 + if (currentByte < 0xa0)
1.971 +
1.972 + {
1.973 +
1.974 + return CCnvCharacterSetConverter::EErrorIllFormedInput;
1.975 +
1.976 + }
1.977 +
1.978 + __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
1.979 +
1.980 + Panic(EPanicBadPointers28));
1.981 +
1.982 + ++pointerToPreviousByte;
1.983 +
1.984 + __ASSERT_DEBUG(pointerToPreviousByte <= pointerToLastByte,
1.985 +
1.986 + Panic(EPanicBadPointers29));
1.987 +
1.988 + if (pointerToPreviousByte >= pointerToLastByte)
1.989 +
1.990 + {
1.991 +
1.992 + break;
1.993 +
1.994 + }
1.995 +
1.996 + }
1.997 +
1.998 + return (pointerToPreviousByte + 1) - aDescriptor.Ptr();
1.999 +
1.1000 + }
1.1001 +
1.1002 +
1.1003 +
1.1004 +// -----------------------------------------------------------------------------
1.1005 +
1.1006 +// DummyConvertToIntermediateBufferInPlace
1.1007 +
1.1008 +//
1.1009 +
1.1010 +// -----------------------------------------------------------------------------
1.1011 +
1.1012 +//
1.1013 +
1.1014 +LOCAL_C void DummyConvertToIntermediateBufferInPlace(TDes8&)
1.1015 +
1.1016 + {
1.1017 +
1.1018 + }
1.1019 +
1.1020 +
1.1021 +
1.1022 +// -----------------------------------------------------------------------------
1.1023 +
1.1024 +// ConvertToJisX0208FromEucJpPackedInPlace
1.1025 +
1.1026 +// Converts from EUC-JP to JIS code
1.1027 +
1.1028 +// -----------------------------------------------------------------------------
1.1029 +
1.1030 +//
1.1031 +
1.1032 +LOCAL_C void ConvertToJisX0208FromEucJpPackedInPlace(TDes8& aDescriptor)
1.1033 +
1.1034 + {
1.1035 +
1.1036 + const TInt descriptorLength = aDescriptor.Length();
1.1037 +
1.1038 + __ASSERT_DEBUG(descriptorLength > 0, Panic(EPanicNothingToConvert4));
1.1039 +
1.1040 + __ASSERT_DEBUG(descriptorLength % 2 == 0, Panic(EPanicOddNumberOfBytes5));
1.1041 +
1.1042 + TUint8* pointerToCurrentByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
1.1043 +
1.1044 + const TUint8* const pointerToLastByte =
1.1045 +
1.1046 + pointerToCurrentByte + (descriptorLength - 1);
1.1047 +
1.1048 + FOREVER
1.1049 +
1.1050 + {
1.1051 +
1.1052 + const TUint currentByte = *pointerToCurrentByte;
1.1053 +
1.1054 + __ASSERT_DEBUG(currentByte & 0x80, Panic(EPanicBadHighBit4));
1.1055 +
1.1056 + *pointerToCurrentByte = STATIC_CAST(TUint8, currentByte & ~0x80);
1.1057 +
1.1058 + __ASSERT_DEBUG(pointerToCurrentByte <= pointerToLastByte,
1.1059 +
1.1060 + Panic(EPanicBadPointers30));
1.1061 +
1.1062 + if (pointerToCurrentByte >= pointerToLastByte)
1.1063 +
1.1064 + {
1.1065 +
1.1066 + break;
1.1067 +
1.1068 + }
1.1069 +
1.1070 + ++pointerToCurrentByte;
1.1071 +
1.1072 + }
1.1073 +
1.1074 + }
1.1075 +
1.1076 +
1.1077 +
1.1078 +// -----------------------------------------------------------------------------
1.1079 +
1.1080 +// ConvertToHalfWidthKatakana8FromEucJpPackedInPlace
1.1081 +
1.1082 +// Converts from EUC-JP to half width Katakana
1.1083 +
1.1084 +// -----------------------------------------------------------------------------
1.1085 +
1.1086 +//
1.1087 +
1.1088 +LOCAL_C void ConvertToHalfWidthKatakana8FromEucJpPackedInPlace(
1.1089 +
1.1090 + TDes8& aDescriptor)
1.1091 +
1.1092 + {
1.1093 +
1.1094 + const TInt descriptorLength = aDescriptor.Length();
1.1095 +
1.1096 + __ASSERT_DEBUG(descriptorLength > 0, Panic(EPanicNothingToConvert5));
1.1097 +
1.1098 + __ASSERT_DEBUG(descriptorLength % 2 == 0, Panic(EPanicOddNumberOfBytes6));
1.1099 +
1.1100 + TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
1.1101 +
1.1102 + const TUint8* pointerToSourceByte = pointerToTargetByte;
1.1103 +
1.1104 + const TUint8* const pointerToLastByte = pointerToSourceByte +
1.1105 +
1.1106 + (descriptorLength - 1);
1.1107 +
1.1108 + FOREVER
1.1109 +
1.1110 + {
1.1111 +
1.1112 + __ASSERT_DEBUG(*pointerToSourceByte == KSingleShift2,
1.1113 +
1.1114 + Panic(EPanicSingleShift2Expected));
1.1115 +
1.1116 + __ASSERT_DEBUG(pointerToSourceByte < pointerToLastByte,
1.1117 +
1.1118 + Panic(EPanicBadPointers31));
1.1119 +
1.1120 + ++pointerToSourceByte;
1.1121 +
1.1122 + const TUint sourceByte = *pointerToSourceByte;
1.1123 +
1.1124 + __ASSERT_DEBUG(sourceByte & 0x80, Panic(EPanicBadHighBit5));
1.1125 +
1.1126 + *pointerToTargetByte = STATIC_CAST(TUint8, sourceByte);
1.1127 +
1.1128 + __ASSERT_DEBUG(pointerToSourceByte <= pointerToLastByte,
1.1129 +
1.1130 + Panic(EPanicBadPointers32));
1.1131 +
1.1132 + if (pointerToSourceByte >= pointerToLastByte)
1.1133 +
1.1134 + {
1.1135 +
1.1136 + break;
1.1137 +
1.1138 + }
1.1139 +
1.1140 + ++pointerToSourceByte;
1.1141 +
1.1142 + ++pointerToTargetByte;
1.1143 +
1.1144 + }
1.1145 +
1.1146 + aDescriptor.SetLength(descriptorLength / 2);
1.1147 +
1.1148 + }
1.1149 +
1.1150 +
1.1151 +
1.1152 +// -----------------------------------------------------------------------------
1.1153 +
1.1154 +// ConvertToJisX0212FromEucJpPackedInPlace
1.1155 +
1.1156 +// Converts from EUC-JP to JIS
1.1157 +
1.1158 +// -----------------------------------------------------------------------------
1.1159 +
1.1160 +//
1.1161 +
1.1162 +LOCAL_C void ConvertToJisX0212FromEucJpPackedInPlace(TDes8& aDescriptor)
1.1163 +
1.1164 + {
1.1165 +
1.1166 + const TInt descriptorLength = aDescriptor.Length();
1.1167 +
1.1168 + __ASSERT_DEBUG(descriptorLength > 0, Panic(EPanicNothingToConvert6));
1.1169 +
1.1170 + __ASSERT_DEBUG(descriptorLength % 3 == 0,
1.1171 +
1.1172 + Panic(EPanicNumberOfBytesIsNotMultipleOfThree2));
1.1173 +
1.1174 + TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
1.1175 +
1.1176 + const TUint8* pointerToSourceByte = pointerToTargetByte;
1.1177 +
1.1178 + const TUint8* const pointerToLastByte =
1.1179 +
1.1180 + pointerToSourceByte + (descriptorLength - 1);
1.1181 +
1.1182 + FOREVER
1.1183 +
1.1184 + {
1.1185 +
1.1186 + __ASSERT_DEBUG(*pointerToSourceByte == KSingleShift3,
1.1187 +
1.1188 + Panic(EPanicSingleShift3Expected));
1.1189 +
1.1190 + __ASSERT_DEBUG(pointerToSourceByte < pointerToLastByte,
1.1191 +
1.1192 + Panic(EPanicBadPointers33));
1.1193 +
1.1194 + ++pointerToSourceByte;
1.1195 +
1.1196 + TUint sourceByte = *pointerToSourceByte;
1.1197 +
1.1198 + __ASSERT_DEBUG(sourceByte & 0x80, Panic(EPanicBadHighBit6));
1.1199 +
1.1200 + *pointerToTargetByte = STATIC_CAST(TUint8, sourceByte & ~0x80);
1.1201 +
1.1202 + __ASSERT_DEBUG(pointerToSourceByte<pointerToLastByte,
1.1203 +
1.1204 + Panic(EPanicBadPointers34));
1.1205 +
1.1206 + ++pointerToSourceByte;
1.1207 +
1.1208 + sourceByte = *pointerToSourceByte;
1.1209 +
1.1210 + __ASSERT_DEBUG(sourceByte&0x80, Panic(EPanicBadHighBit7));
1.1211 +
1.1212 + __ASSERT_DEBUG(pointerToTargetByte < pointerToLastByte,
1.1213 +
1.1214 + Panic(EPanicBadPointers35));
1.1215 +
1.1216 + ++pointerToTargetByte;
1.1217 +
1.1218 + *pointerToTargetByte = STATIC_CAST(TUint8, sourceByte & ~0x80);
1.1219 +
1.1220 + __ASSERT_DEBUG(pointerToSourceByte <= pointerToLastByte,
1.1221 +
1.1222 + Panic(EPanicBadPointers36));
1.1223 +
1.1224 + if (pointerToSourceByte >= pointerToLastByte)
1.1225 +
1.1226 + {
1.1227 +
1.1228 + break;
1.1229 +
1.1230 + }
1.1231 +
1.1232 + ++pointerToSourceByte;
1.1233 +
1.1234 + ++pointerToTargetByte;
1.1235 +
1.1236 + }
1.1237 +
1.1238 + aDescriptor.SetLength((descriptorLength / 3) * 2);
1.1239 +
1.1240 + }
1.1241 +
1.1242 +
1.1243 +
1.1244 +// -----------------------------------------------------------------------------
1.1245 +
1.1246 +// NumberOfBytesAbleToConvertToPictograph
1.1247 +
1.1248 +//
1.1249 +
1.1250 +// -----------------------------------------------------------------------------
1.1251 +
1.1252 +//
1.1253 +
1.1254 +LOCAL_C TInt NumberOfBytesAbleToConvertToPictograph1(const TDesC8& aDescriptor)
1.1255 +
1.1256 + {
1.1257 +
1.1258 + const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;
1.1259 +
1.1260 + const TUint8* const pointerToLastByte =
1.1261 +
1.1262 + pointerToPreviousByte + aDescriptor.Length();
1.1263 +
1.1264 + if (pointerToPreviousByte == pointerToLastByte)
1.1265 +
1.1266 + {
1.1267 +
1.1268 + return 0;
1.1269 +
1.1270 + }
1.1271 +
1.1272 + for (;pointerToPreviousByte < pointerToLastByte;)
1.1273 +
1.1274 + {
1.1275 +
1.1276 + __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
1.1277 +
1.1278 + Panic(EPanicBadPointers14));
1.1279 +
1.1280 + TUint currentByte = *(pointerToPreviousByte + 1);
1.1281 +
1.1282 + const TUint nextByte = *(pointerToPreviousByte + 2);
1.1283 +
1.1284 + if (((currentByte < KFirstByteRangeFirstBlockStart) ||
1.1285 +
1.1286 + (currentByte > KFirstByteRangeFirstBlockEnd)) ||
1.1287 +
1.1288 + ((nextByte < KSecondByteRangeSecondBlockStart) ||
1.1289 +
1.1290 + (nextByte > KSecondByteRangeSecondBlockEnd)))
1.1291 +
1.1292 + {
1.1293 +
1.1294 + break;
1.1295 +
1.1296 + }
1.1297 +
1.1298 + __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
1.1299 +
1.1300 + Panic(EPanicBadPointers15));
1.1301 +
1.1302 + pointerToPreviousByte += 2;
1.1303 +
1.1304 + }
1.1305 +
1.1306 + return (pointerToPreviousByte + 1) - aDescriptor.Ptr();
1.1307 +
1.1308 + }
1.1309 +
1.1310 +
1.1311 +
1.1312 +// -----------------------------------------------------------------------------
1.1313 +
1.1314 +// NumberOfBytesAbleToConvertToPictograph
1.1315 +
1.1316 +//
1.1317 +
1.1318 +// -----------------------------------------------------------------------------
1.1319 +
1.1320 +//
1.1321 +
1.1322 +LOCAL_C TInt NumberOfBytesAbleToConvertToPictograph2(const TDesC8& aDescriptor)
1.1323 +
1.1324 + {
1.1325 +
1.1326 + const TUint8* pointerToPreviousByte = aDescriptor.Ptr() - 1;
1.1327 +
1.1328 + const TUint8* const pointerToLastByte =
1.1329 +
1.1330 + pointerToPreviousByte + aDescriptor.Length();
1.1331 +
1.1332 + if (pointerToPreviousByte == pointerToLastByte)
1.1333 +
1.1334 + {
1.1335 +
1.1336 + return 0;
1.1337 +
1.1338 + }
1.1339 +
1.1340 + for (;pointerToPreviousByte < pointerToLastByte;)
1.1341 +
1.1342 + {
1.1343 +
1.1344 + __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
1.1345 +
1.1346 + Panic(EPanicBadPointers14));
1.1347 +
1.1348 + TUint currentByte = *(pointerToPreviousByte + 1);
1.1349 +
1.1350 + if (currentByte == KSingleShift3)
1.1351 +
1.1352 + {
1.1353 +
1.1354 + pointerToPreviousByte++;
1.1355 +
1.1356 + currentByte = *(pointerToPreviousByte + 1);
1.1357 +
1.1358 + }
1.1359 +
1.1360 + else
1.1361 +
1.1362 + {
1.1363 +
1.1364 + break;
1.1365 +
1.1366 + }
1.1367 +
1.1368 + if (currentByte < 0xa0)
1.1369 +
1.1370 + {
1.1371 +
1.1372 + return CCnvCharacterSetConverter::EErrorIllFormedInput;
1.1373 +
1.1374 + }
1.1375 +
1.1376 + const TUint nextByte = *(pointerToPreviousByte + 2);
1.1377 +
1.1378 + if (nextByte < 0xa0)
1.1379 +
1.1380 + {
1.1381 +
1.1382 + return CCnvCharacterSetConverter::EErrorIllFormedInput;
1.1383 +
1.1384 + }
1.1385 +
1.1386 + if (((currentByte < KFirstByteRangeFirstBlockStart) ||
1.1387 +
1.1388 + (currentByte > KFirstByteRangeFirstBlockEnd)) ||
1.1389 +
1.1390 + ((nextByte < KSecondByteRangeSecondBlockStart) ||
1.1391 +
1.1392 + (nextByte > KSecondByteRangeSecondBlockEnd)))
1.1393 +
1.1394 + {
1.1395 +
1.1396 + // return the previous byte to the beginning of loop.
1.1397 +
1.1398 + pointerToPreviousByte--;
1.1399 +
1.1400 + break;
1.1401 +
1.1402 + }
1.1403 +
1.1404 + __ASSERT_DEBUG(pointerToPreviousByte < pointerToLastByte,
1.1405 +
1.1406 + Panic(EPanicBadPointers15));
1.1407 +
1.1408 + pointerToPreviousByte += 2;
1.1409 +
1.1410 + }
1.1411 +
1.1412 + return (pointerToPreviousByte + 1) - aDescriptor.Ptr();
1.1413 +
1.1414 + }
1.1415 +
1.1416 +
1.1417 +
1.1418 +// -----------------------------------------------------------------------------
1.1419 +
1.1420 +// ConvertFromPictogaphToEucJpDirectmapInPlace
1.1421 +
1.1422 +// Converts from EucJp packed Pictograph to Unicode
1.1423 +
1.1424 +// -----------------------------------------------------------------------------
1.1425 +
1.1426 +//
1.1427 +
1.1428 +LOCAL_C void ConvertFromPictogaphToEucJpDirectmapInPlace(
1.1429 +
1.1430 + TInt aStartPositionInDescriptor, TDes8& aDescriptor,
1.1431 +
1.1432 + TInt& aNumberOfCharactersThatDroppedOut)
1.1433 +
1.1434 + {
1.1435 +
1.1436 + TInt descriptorLength=aDescriptor.Length();
1.1437 +
1.1438 + __ASSERT_DEBUG(descriptorLength > aStartPositionInDescriptor,
1.1439 +
1.1440 + Panic(EPanicNothingToConvert3));
1.1441 +
1.1442 + __ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) % 2 == 0,
1.1443 +
1.1444 + Panic(EPanicOddNumberOfBytes3));
1.1445 +
1.1446 + TInt bytesPerCharacter = 2;
1.1447 +
1.1448 + if (aDescriptor[0] >= KEUCJPSecondBlockStart)
1.1449 +
1.1450 + {
1.1451 +
1.1452 + bytesPerCharacter = 3;
1.1453 +
1.1454 + }
1.1455 +
1.1456 +
1.1457 +
1.1458 + aNumberOfCharactersThatDroppedOut =
1.1459 +
1.1460 + Max(0, ((descriptorLength - aStartPositionInDescriptor) / 2) -
1.1461 +
1.1462 + ((aDescriptor.MaxLength() - aStartPositionInDescriptor) /
1.1463 +
1.1464 + bytesPerCharacter));
1.1465 +
1.1466 + descriptorLength -= aNumberOfCharactersThatDroppedOut * 2;
1.1467 +
1.1468 + __ASSERT_DEBUG(descriptorLength >= aStartPositionInDescriptor,
1.1469 +
1.1470 + Panic(EPanicBadCalculation2));
1.1471 +
1.1472 + if (descriptorLength <= aStartPositionInDescriptor)
1.1473 +
1.1474 + {
1.1475 +
1.1476 + aDescriptor.SetLength(descriptorLength);
1.1477 +
1.1478 + }
1.1479 +
1.1480 + else
1.1481 +
1.1482 + {
1.1483 +
1.1484 + __ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) % 2 == 0,
1.1485 +
1.1486 + Panic(EPanicOddNumberOfBytes4));
1.1487 +
1.1488 + // pointerToTargetByte is initialized properly when descriptorLength
1.1489 +
1.1490 + // has been offset to the actual final length of aDescriptor
1.1491 +
1.1492 + TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
1.1493 +
1.1494 + const TUint8* const pointerToFirstByte =
1.1495 +
1.1496 + pointerToTargetByte + aStartPositionInDescriptor;
1.1497 +
1.1498 + const TUint8* pointerToSourceByte =
1.1499 +
1.1500 + pointerToTargetByte + (descriptorLength - 1);
1.1501 +
1.1502 + descriptorLength = (((descriptorLength - aStartPositionInDescriptor)
1.1503 +
1.1504 + * bytesPerCharacter) / 2) + aStartPositionInDescriptor;
1.1505 +
1.1506 + __ASSERT_DEBUG((descriptorLength - aStartPositionInDescriptor) %
1.1507 +
1.1508 + bytesPerCharacter == 0, Panic(EPanicNumberOfBytesIsNotMultipleOfThree1));
1.1509 +
1.1510 + aDescriptor.SetLength(descriptorLength);
1.1511 +
1.1512 + // pointerToTargetByte is is initialized properly here
1.1513 +
1.1514 + pointerToTargetByte += descriptorLength - 1;
1.1515 +
1.1516 + for (;pointerToTargetByte > pointerToFirstByte; )
1.1517 +
1.1518 + {
1.1519 +
1.1520 + TInt secondByte = *pointerToSourceByte;
1.1521 +
1.1522 + TInt firstByte = *(pointerToSourceByte - 1);
1.1523 +
1.1524 +
1.1525 +
1.1526 + if (bytesPerCharacter == 3)
1.1527 +
1.1528 + {
1.1529 +
1.1530 + firstByte = (firstByte - KEUCJPSecondBlockStart) * 2 +
1.1531 +
1.1532 + KFirstByteRangeFirstBlockStart;
1.1533 +
1.1534 + }
1.1535 +
1.1536 + else
1.1537 +
1.1538 + {
1.1539 +
1.1540 + firstByte = (firstByte - KPictographStartFirstByte) * 2 +
1.1541 +
1.1542 + KFirstByteRangeFirstBlockStart;
1.1543 +
1.1544 + }
1.1545 +
1.1546 + if (static_cast<TInt>(KEUCJPBlockSize + KPictographStartSecondByte + 1)
1.1547 +
1.1548 + < secondByte)
1.1549 +
1.1550 + {
1.1551 +
1.1552 + if (secondByte > KShiftJisTrailByteIllegal)
1.1553 +
1.1554 + secondByte -= 1;
1.1555 +
1.1556 + secondByte = secondByte -(KPictographStartSecondByte +
1.1557 +
1.1558 + KEUCJPBlockSize + 1) + KSecondByteRangeSecondBlockStart;
1.1559 +
1.1560 + firstByte++;
1.1561 +
1.1562 + }
1.1563 +
1.1564 + else
1.1565 +
1.1566 + {
1.1567 +
1.1568 + if (secondByte > KShiftJisTrailByteIllegal)
1.1569 +
1.1570 + secondByte -= 1;
1.1571 +
1.1572 + secondByte += KSecondByteRangeSecondBlockStart - KPictographStartSecondByte;
1.1573 +
1.1574 + }
1.1575 +
1.1576 + *pointerToTargetByte = static_cast<TUint8>(secondByte);
1.1577 +
1.1578 + --pointerToTargetByte;
1.1579 +
1.1580 + *pointerToTargetByte = static_cast<TUint8>(firstByte);
1.1581 +
1.1582 + if (bytesPerCharacter == 3)
1.1583 +
1.1584 + {
1.1585 +
1.1586 + --pointerToTargetByte;
1.1587 +
1.1588 + *pointerToTargetByte = KSingleShift3;
1.1589 +
1.1590 + }
1.1591 +
1.1592 + __ASSERT_DEBUG(pointerToTargetByte >= pointerToFirstByte,
1.1593 +
1.1594 + Panic(EPanicBadPointers10));
1.1595 +
1.1596 + --pointerToTargetByte;
1.1597 +
1.1598 + pointerToSourceByte -= 2;
1.1599 +
1.1600 + }
1.1601 +
1.1602 + }
1.1603 +
1.1604 + }
1.1605 +
1.1606 +
1.1607 +
1.1608 +// -----------------------------------------------------------------------------
1.1609 +
1.1610 +// ConvertToPictographFromEucJpPackedInPlace1
1.1611 +
1.1612 +// Converts from EucJp packed Pictograph to Unicode
1.1613 +
1.1614 +// -----------------------------------------------------------------------------
1.1615 +
1.1616 +//
1.1617 +
1.1618 +LOCAL_C void ConvertToPictographFromEucJpPackedInPlace(TDes8& aDescriptor)
1.1619 +
1.1620 + {
1.1621 +
1.1622 + const TInt descriptorLength = aDescriptor.Length();
1.1623 +
1.1624 + __ASSERT_DEBUG(descriptorLength > 0, Panic(EPanicNothingToConvert6));
1.1625 +
1.1626 + TUint8* pointerToTargetByte = CONST_CAST(TUint8*, aDescriptor.Ptr());
1.1627 +
1.1628 + const TUint8* pointerToSourceByte = pointerToTargetByte;
1.1629 +
1.1630 + const TUint8* const pointerToLastByte =
1.1631 +
1.1632 + pointerToSourceByte + (descriptorLength - 1);
1.1633 +
1.1634 + TInt bytesPerCharacter = 2;
1.1635 +
1.1636 + TInt sjisStartbyte = KPictographStartFirstByte;
1.1637 +
1.1638 + if (*pointerToSourceByte == KSingleShift3)
1.1639 +
1.1640 + {
1.1641 +
1.1642 + ++pointerToSourceByte;
1.1643 +
1.1644 + bytesPerCharacter = 3;
1.1645 +
1.1646 + sjisStartbyte = KEUCJPSecondBlockStart;
1.1647 +
1.1648 + }
1.1649 +
1.1650 + for (;pointerToSourceByte < pointerToLastByte; )
1.1651 +
1.1652 + {
1.1653 +
1.1654 + __ASSERT_DEBUG(pointerToSourceByte < pointerToLastByte,
1.1655 +
1.1656 + Panic(EPanicBadPointers33));
1.1657 +
1.1658 + TUint firstByte = (*pointerToSourceByte
1.1659 +
1.1660 + - KFirstByteRangeFirstBlockStart) / 2 + sjisStartbyte;
1.1661 +
1.1662 + TUint secondByte = *(pointerToSourceByte + 1);
1.1663 +
1.1664 + if ((*pointerToSourceByte % 2) == 0)
1.1665 +
1.1666 + {
1.1667 +
1.1668 + secondByte += KPictographStartSecondByte -
1.1669 +
1.1670 + KSecondByteRangeSecondBlockStart + KEUCJPBlockSize + 1;
1.1671 +
1.1672 + if (secondByte >= KShiftJisTrailByteIllegal)
1.1673 +
1.1674 + secondByte++;
1.1675 +
1.1676 + }
1.1677 +
1.1678 + else
1.1679 +
1.1680 + {
1.1681 +
1.1682 + secondByte += KPictographStartSecondByte - KSecondByteRangeSecondBlockStart;
1.1683 +
1.1684 + if (secondByte >= KShiftJisTrailByteIllegal)
1.1685 +
1.1686 + secondByte++;
1.1687 +
1.1688 + }
1.1689 +
1.1690 + *pointerToTargetByte = static_cast<TUint8>(firstByte);
1.1691 +
1.1692 +
1.1693 +
1.1694 + __ASSERT_DEBUG(pointerToTargetByte < pointerToLastByte,
1.1695 +
1.1696 + Panic(EPanicBadPointers35));
1.1697 +
1.1698 + ++pointerToTargetByte;
1.1699 +
1.1700 + *pointerToTargetByte = static_cast<TUint8>(secondByte);
1.1701 +
1.1702 + __ASSERT_DEBUG(pointerToSourceByte <= pointerToLastByte,
1.1703 +
1.1704 + Panic(EPanicBadPointers36));
1.1705 +
1.1706 + pointerToSourceByte += 2;
1.1707 +
1.1708 + ++pointerToTargetByte;
1.1709 +
1.1710 + }
1.1711 +
1.1712 + aDescriptor.SetLength((descriptorLength / bytesPerCharacter) * 2);
1.1713 +
1.1714 + }
1.1715 +
1.1716 +
1.1717 +
1.1718 +// New Interface class
1.1719 +
1.1720 +class CEucJpDirectmapImplementation : public CCharacterSetConverterPluginInterface
1.1721 +
1.1722 +{
1.1723 +
1.1724 + public:
1.1725 +
1.1726 + virtual const TDesC8& ReplacementForUnconvertibleUnicodeCharacters();
1.1727 +
1.1728 +
1.1729 +
1.1730 + virtual TInt ConvertFromUnicode(
1.1731 +
1.1732 + CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters,
1.1733 +
1.1734 + const TDesC8& aReplacementForUnconvertibleUnicodeCharacters,
1.1735 +
1.1736 + TDes8& aForeign,
1.1737 +
1.1738 + const TDesC16& aUnicode,
1.1739 +
1.1740 + CCnvCharacterSetConverter::TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters );
1.1741 +
1.1742 +
1.1743 +
1.1744 + virtual TInt ConvertToUnicode(
1.1745 +
1.1746 + CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters,
1.1747 +
1.1748 + TDes16& aUnicode,
1.1749 +
1.1750 + const TDesC8& aForeign,
1.1751 +
1.1752 + TInt&,
1.1753 +
1.1754 + TInt& aNumberOfUnconvertibleCharacters,
1.1755 +
1.1756 + TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter );
1.1757 +
1.1758 +
1.1759 +
1.1760 + virtual TBool IsInThisCharacterSetL(
1.1761 +
1.1762 + TBool& aSetToTrue,
1.1763 +
1.1764 + TInt& aConfidenceLevel,
1.1765 +
1.1766 + const TDesC8& );
1.1767 +
1.1768 +
1.1769 +
1.1770 + static CEucJpDirectmapImplementation* NewL();
1.1771 +
1.1772 +
1.1773 +
1.1774 + virtual ~CEucJpDirectmapImplementation();
1.1775 +
1.1776 + private:
1.1777 +
1.1778 + CEucJpDirectmapImplementation();
1.1779 +
1.1780 +};
1.1781 +
1.1782 +
1.1783 +
1.1784 +// -----------------------------------------------------------------------------
1.1785 +
1.1786 +// ReplacementForUnconvertibleUnicodeCharacters
1.1787 +
1.1788 +// Retruns the character to replacement for unconvertible unicode character.
1.1789 +
1.1790 +// Returns: '?':
1.1791 +
1.1792 +// -----------------------------------------------------------------------------
1.1793 +
1.1794 +//
1.1795 +
1.1796 +const TDesC8& CEucJpDirectmapImplementation::ReplacementForUnconvertibleUnicodeCharacters()
1.1797 +
1.1798 + {
1.1799 +
1.1800 + return KLit8EucJpPackedReplacementForUnconvertibleUnicodeCharacters;
1.1801 +
1.1802 + }
1.1803 +
1.1804 +
1.1805 +
1.1806 +// -----------------------------------------------------------------------------
1.1807 +
1.1808 +// ConvertFromUnicode
1.1809 +
1.1810 +// Converts from Unicode to EUC-JP
1.1811 +
1.1812 +// Returns: The number of unconverted characters
1.1813 +
1.1814 +// -----------------------------------------------------------------------------
1.1815 +
1.1816 +//
1.1817 +
1.1818 +TInt CEucJpDirectmapImplementation::ConvertFromUnicode(
1.1819 +
1.1820 + CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters,
1.1821 +
1.1822 + const TDesC8& aReplacementForUnconvertibleUnicodeCharacters,
1.1823 +
1.1824 + TDes8& aForeign, const TDesC16& aUnicode,
1.1825 +
1.1826 + CCnvCharacterSetConverter::TArrayOfAscendingIndices& aIndicesOfUnconvertibleCharacters)
1.1827 +
1.1828 + {
1.1829 +
1.1830 + TFixedArray<CnvUtilities::SCharacterSet, 6> characterSets;
1.1831 +
1.1832 + characterSets[0].iConversionData = &CnvJisRoman::ConversionData();
1.1833 +
1.1834 + characterSets[0].iConvertFromIntermediateBufferInPlace =
1.1835 +
1.1836 + DummyConvertFromIntermediateBufferInPlace;
1.1837 +
1.1838 + characterSets[0].iEscapeSequence = &KNullDesC8;
1.1839 +
1.1840 + characterSets[1].iConversionData = &CnvJisX0208::ConversionData();
1.1841 +
1.1842 + characterSets[1].iConvertFromIntermediateBufferInPlace =
1.1843 +
1.1844 + ConvertFromJisX0208ToEucJpPackedInPlace;
1.1845 +
1.1846 + characterSets[1].iEscapeSequence = &KNullDesC8;
1.1847 +
1.1848 + characterSets[2].iConversionData = &CnvHalfWidthKatakana8::ConversionData();
1.1849 +
1.1850 + characterSets[2].iConvertFromIntermediateBufferInPlace =
1.1851 +
1.1852 + ConvertFromHalfWidthKatakana8ToEucJpPackedInPlace;
1.1853 +
1.1854 + characterSets[2].iEscapeSequence = &KNullDesC8;
1.1855 +
1.1856 + characterSets[3].iConversionData = &CnvJisX0212::ConversionData();
1.1857 +
1.1858 + characterSets[3].iConvertFromIntermediateBufferInPlace =
1.1859 +
1.1860 + ConvertFromJisX0212ToEucJpPackedInPlace;
1.1861 +
1.1862 + characterSets[3].iEscapeSequence = &KNullDesC8;
1.1863 +
1.1864 + characterSets[4].iConversionData = &CnvShiftJisDirectmap::ConversionData();
1.1865 +
1.1866 + characterSets[4].iConvertFromIntermediateBufferInPlace =
1.1867 +
1.1868 + ConvertFromPictogaphToEucJpDirectmapInPlace;
1.1869 +
1.1870 + characterSets[4].iEscapeSequence = &KNullDesC8;
1.1871 +
1.1872 + characterSets[5].iConversionData = &CnvShiftJisDirectmap::ConversionData();
1.1873 +
1.1874 + characterSets[5].iConvertFromIntermediateBufferInPlace =
1.1875 +
1.1876 + ConvertFromPictogaphToEucJpDirectmapInPlace;
1.1877 +
1.1878 + characterSets[5].iEscapeSequence = &KNullDesC8;
1.1879 +
1.1880 +
1.1881 +
1.1882 + TInt unconvert = CnvUtilities::ConvertFromUnicode(
1.1883 +
1.1884 + aDefaultEndiannessOfForeignCharacters,
1.1885 +
1.1886 + aReplacementForUnconvertibleUnicodeCharacters,
1.1887 +
1.1888 + aForeign, aUnicode, aIndicesOfUnconvertibleCharacters,
1.1889 +
1.1890 + characterSets.Array());
1.1891 +
1.1892 +
1.1893 +
1.1894 + return unconvert;
1.1895 +
1.1896 + }
1.1897 +
1.1898 +
1.1899 +
1.1900 +// -----------------------------------------------------------------------------
1.1901 +
1.1902 +// ConvertToUnicode
1.1903 +
1.1904 +// Converts from EUC-JP to Unicode.
1.1905 +
1.1906 +// Returns: The number of unconverted bytes
1.1907 +
1.1908 +// -----------------------------------------------------------------------------
1.1909 +
1.1910 +//
1.1911 +
1.1912 +TInt CEucJpDirectmapImplementation::ConvertToUnicode(
1.1913 +
1.1914 + CCnvCharacterSetConverter::TEndianness aDefaultEndiannessOfForeignCharacters,
1.1915 +
1.1916 + TDes16& aUnicode, const TDesC8& aForeign, TInt&,
1.1917 +
1.1918 + TInt& aNumberOfUnconvertibleCharacters,
1.1919 +
1.1920 + TInt& aIndexOfFirstByteOfFirstUnconvertibleCharacter)
1.1921 +
1.1922 + {
1.1923 +
1.1924 + TFixedArray<CnvUtilities::SMethod, 6> methods;
1.1925 +
1.1926 +
1.1927 +
1.1928 + methods[0].iNumberOfBytesAbleToConvert =
1.1929 +
1.1930 + NumberOfBytesAbleToConvertToPictograph1;
1.1931 +
1.1932 + methods[0].iConvertToIntermediateBufferInPlace =
1.1933 +
1.1934 + ConvertToPictographFromEucJpPackedInPlace;
1.1935 +
1.1936 + methods[0].iConversionData = &CnvShiftJisDirectmap::ConversionData();
1.1937 +
1.1938 + methods[0].iNumberOfBytesPerCharacter = 2;
1.1939 +
1.1940 + methods[0].iNumberOfCoreBytesPerCharacter = 2;
1.1941 +
1.1942 + methods[1].iNumberOfBytesAbleToConvert =
1.1943 +
1.1944 + NumberOfBytesAbleToConvertToPictograph2;
1.1945 +
1.1946 + methods[1].iConvertToIntermediateBufferInPlace =
1.1947 +
1.1948 + ConvertToPictographFromEucJpPackedInPlace;
1.1949 +
1.1950 + methods[1].iConversionData = &CnvShiftJisDirectmap::ConversionData();
1.1951 +
1.1952 + methods[1].iNumberOfBytesPerCharacter = 3;
1.1953 +
1.1954 + methods[1].iNumberOfCoreBytesPerCharacter = 2;
1.1955 +
1.1956 +
1.1957 +
1.1958 + methods[2].iNumberOfBytesAbleToConvert = NumberOfBytesAbleToConvertToJisRoman;
1.1959 +
1.1960 + methods[2].iConvertToIntermediateBufferInPlace =
1.1961 +
1.1962 + DummyConvertToIntermediateBufferInPlace;
1.1963 +
1.1964 + methods[2].iConversionData = &CnvJisRoman::ConversionData();
1.1965 +
1.1966 + methods[2].iNumberOfBytesPerCharacter = 1;
1.1967 +
1.1968 + methods[2].iNumberOfCoreBytesPerCharacter = 1;
1.1969 +
1.1970 + methods[3].iNumberOfBytesAbleToConvert = NumberOfBytesAbleToConvertToJisX0208;
1.1971 +
1.1972 + methods[3].iConvertToIntermediateBufferInPlace =
1.1973 +
1.1974 + ConvertToJisX0208FromEucJpPackedInPlace;
1.1975 +
1.1976 + methods[3].iConversionData = &CnvJisX0208::ConversionData();
1.1977 +
1.1978 + methods[3].iNumberOfBytesPerCharacter = 2;
1.1979 +
1.1980 + methods[3].iNumberOfCoreBytesPerCharacter = 2;
1.1981 +
1.1982 + methods[4].iNumberOfBytesAbleToConvert =
1.1983 +
1.1984 + NumberOfBytesAbleToConvertToHalfWidthKatakana8;
1.1985 +
1.1986 + methods[4].iConvertToIntermediateBufferInPlace =
1.1987 +
1.1988 + ConvertToHalfWidthKatakana8FromEucJpPackedInPlace;
1.1989 +
1.1990 + methods[4].iConversionData = &CnvHalfWidthKatakana8::ConversionData();
1.1991 +
1.1992 + methods[4].iNumberOfBytesPerCharacter = 2;
1.1993 +
1.1994 + methods[4].iNumberOfCoreBytesPerCharacter = 1;
1.1995 +
1.1996 + methods[5].iNumberOfBytesAbleToConvert =
1.1997 +
1.1998 + NumberOfBytesAbleToConvertToJisX0212;
1.1999 +
1.2000 + methods[5].iConvertToIntermediateBufferInPlace =
1.2001 +
1.2002 + ConvertToJisX0212FromEucJpPackedInPlace;
1.2003 +
1.2004 + methods[5].iConversionData = &CnvJisX0212::ConversionData();
1.2005 +
1.2006 + methods[5].iNumberOfBytesPerCharacter = 3;
1.2007 +
1.2008 + methods[5].iNumberOfCoreBytesPerCharacter = 2;
1.2009 +
1.2010 +
1.2011 +
1.2012 + TInt unconvert = CnvUtilities::ConvertToUnicodeFromHeterogeneousForeign(
1.2013 +
1.2014 + aDefaultEndiannessOfForeignCharacters, aUnicode, aForeign,
1.2015 +
1.2016 + aNumberOfUnconvertibleCharacters,
1.2017 +
1.2018 + aIndexOfFirstByteOfFirstUnconvertibleCharacter, methods.Array());
1.2019 +
1.2020 +
1.2021 +
1.2022 + // The following is specific impelementation for brower.
1.2023 +
1.2024 + // If brower app calls this API, the yen sign code(0xA5)
1.2025 +
1.2026 + // must be converted to backslash code(0x5C).
1.2027 +
1.2028 + // Becasue Javascript supports backslash code ony.
1.2029 +
1.2030 + TBool browserProcess = (RProcess().SecureId().iId == KBrowserSecureId);
1.2031 +
1.2032 + if (browserProcess && aUnicode.Length() > 0)
1.2033 +
1.2034 + {
1.2035 +
1.2036 + const TUint16* pB = aUnicode.Ptr();
1.2037 +
1.2038 + const TUint16* pbase = pB;
1.2039 +
1.2040 + const TUint16* pE = pB + aUnicode.Length() -1;
1.2041 +
1.2042 + while (pE>=pbase)
1.2043 +
1.2044 + {
1.2045 +
1.2046 + if (*pbase == KCharacterCodeForYenSign)
1.2047 +
1.2048 + {
1.2049 +
1.2050 + aUnicode[pbase - pB] = KCharacterCodeForBackSlash;
1.2051 +
1.2052 + }
1.2053 +
1.2054 + pbase++;
1.2055 +
1.2056 + }
1.2057 +
1.2058 + }
1.2059 +
1.2060 +
1.2061 +
1.2062 + return unconvert;
1.2063 +
1.2064 + }
1.2065 +
1.2066 +
1.2067 +
1.2068 +// -----------------------------------------------------------------------------
1.2069 +
1.2070 +// IsInThisCharacterSetL
1.2071 +
1.2072 +// Detects whether the text is the character code or not.
1.2073 +
1.2074 +// Returns: ETrue:
1.2075 +
1.2076 +// -----------------------------------------------------------------------------
1.2077 +
1.2078 +//
1.2079 +
1.2080 +TBool CEucJpDirectmapImplementation::IsInThisCharacterSetL(TBool& /*aSetToTrue*/, TInt& /*aConfidenceLevel*/,
1.2081 +
1.2082 + const TDesC8& /*aSample*/)
1.2083 +
1.2084 + {
1.2085 +
1.2086 + return EFalse;
1.2087 +
1.2088 + }
1.2089 +
1.2090 +
1.2091 +
1.2092 +CEucJpDirectmapImplementation* CEucJpDirectmapImplementation::NewL()
1.2093 +
1.2094 + {
1.2095 +
1.2096 + CEucJpDirectmapImplementation* self = new(ELeave) CEucJpDirectmapImplementation;
1.2097 +
1.2098 + return self;
1.2099 +
1.2100 + }
1.2101 +
1.2102 +
1.2103 +
1.2104 +CEucJpDirectmapImplementation::CEucJpDirectmapImplementation()
1.2105 +
1.2106 + {
1.2107 +
1.2108 + //default constructor.. do nothing
1.2109 +
1.2110 + }
1.2111 +
1.2112 +
1.2113 +
1.2114 +CEucJpDirectmapImplementation::~CEucJpDirectmapImplementation()
1.2115 +
1.2116 + {
1.2117 +
1.2118 + //default destructor .. do nothing
1.2119 +
1.2120 + }
1.2121 +
1.2122 +
1.2123 +
1.2124 +// ECOM CREATION FUNCTION
1.2125 +
1.2126 +const TImplementationProxy ImplementationTable[] =
1.2127 +
1.2128 + {
1.2129 +
1.2130 + // Note: This is the same UID as defined in old mmp-file
1.2131 +
1.2132 + // Used also in 12221212.rss ( implementation_uid )
1.2133 +
1.2134 + IMPLEMENTATION_PROXY_ENTRY( 0x101F86A6, CEucJpDirectmapImplementation::NewL )
1.2135 +
1.2136 + };
1.2137 +
1.2138 +
1.2139 +
1.2140 +EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount )
1.2141 +
1.2142 + {
1.2143 +
1.2144 + aTableCount = sizeof( ImplementationTable ) / sizeof(TImplementationProxy);
1.2145 +
1.2146 + return ImplementationTable;
1.2147 +
1.2148 + }
1.2149 +
1.2150 +
1.2151 +
1.2152 +// End of file
1.2153 +