intl/uconv/util/nsUCSupport.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is Mozilla Communicator client code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Pierre Phaneuf <pp@ludusdesign.com>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either of the GNU General Public License Version 2 or later (the "GPL"),
  27  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 #include "pratom.h"
  40 #include "nsIComponentManager.h"
  41 #include "nsICharRepresentable.h"
  42 #include "nsUCSupport.h"
  43 #include "nsUnicodeDecodeHelper.h"
  44 #include "nsUnicodeEncodeHelper.h"
  45
  46 #define DEFAULT_BUFFER_CAPACITY 16
  47
  48 // XXX review the buffer growth limitation code
  49
  50 //----------------------------------------------------------------------
  51 // Class nsBasicDecoderSupport [implementation]
  52
  53 nsBasicDecoderSupport::nsBasicDecoderSupport()
  54 {
  55 }
  56
  57 nsBasicDecoderSupport::~nsBasicDecoderSupport()
  58 {
  59 }
  60
  61 //----------------------------------------------------------------------
  62 // Interface nsISupports [implementation]
  63
  64 NS_IMPL_ADDREF(nsBasicDecoderSupport)
  65 NS_IMPL_RELEASE(nsBasicDecoderSupport)
  66 #ifdef NS_DEBUG
  67 NS_IMPL_QUERY_INTERFACE2(nsBasicDecoderSupport, nsIUnicodeDecoder, nsIBasicDecoder)
  68 #else
  69 NS_IMPL_QUERY_INTERFACE1(nsBasicDecoderSupport, nsIUnicodeDecoder)
  70 #endif
  71
  72 //----------------------------------------------------------------------
  73 // Interface nsIUnicodeDecoder [implementation]
  74
  75 //----------------------------------------------------------------------
  76 // Class nsBufferDecoderSupport [implementation]
  77
  78 nsBufferDecoderSupport::nsBufferDecoderSupport(PRUint32 aMaxLengthFactor)
  79   : nsBasicDecoderSupport(),
  80     mMaxLengthFactor(aMaxLengthFactor)
  81 {
  82   mBufferCapacity = DEFAULT_BUFFER_CAPACITY;
  83   mBuffer = new char[mBufferCapacity];
  84
  85   Reset();
  86 }
  87
  88 nsBufferDecoderSupport::~nsBufferDecoderSupport()
  89 {
  90   delete [] mBuffer;
  91 }
  92
  93 void nsBufferDecoderSupport::FillBuffer(const char ** aSrc, PRInt32 aSrcLength)
  94 {
  95   PRInt32 bcr = PR_MIN(mBufferCapacity - mBufferLength, aSrcLength);
  96   memcpy(mBuffer + mBufferLength, *aSrc, bcr);
  97   mBufferLength += bcr;
  98   (*aSrc) += bcr;
  99 }
 100
 101 void nsBufferDecoderSupport::DoubleBuffer()
 102 {
 103   mBufferCapacity *= 2;
 104   char * newBuffer = new char [mBufferCapacity];
 105   if (mBufferLength > 0) memcpy(newBuffer, mBuffer, mBufferLength);
 106   delete [] mBuffer;
 107   mBuffer = newBuffer;
 108 }
 109
 110 //----------------------------------------------------------------------
 111 // Subclassing of nsBasicDecoderSupport class [implementation]
 112
 113 NS_IMETHODIMP nsBufferDecoderSupport::Convert(const char * aSrc,
 114                                               PRInt32 * aSrcLength,
 115                                               PRUnichar * aDest,
 116                                               PRInt32 * aDestLength)
 117 {
 118   // we do all operations using pointers internally
 119   const char * src = aSrc;
 120   const char * srcEnd = aSrc + *aSrcLength;
 121   PRUnichar * dest = aDest;
 122   PRUnichar * destEnd = aDest + *aDestLength;
 123
 124   PRInt32 bcr, bcw; // byte counts for read & write;
 125   nsresult res = NS_OK;
 126
 127   // do we have some residual data from the last conversion?
 128   if (mBufferLength > 0) if (dest == destEnd) {
 129     res = NS_OK_UDEC_MOREOUTPUT;
 130   } else for (;;) {
 131     // we need new data to add to the buffer
 132     if (src == srcEnd) {
 133       res = NS_OK_UDEC_MOREINPUT;
 134       break;
 135     }
 136
 137     // fill that buffer
 138     PRInt32 buffLen = mBufferLength;  // initial buffer length
 139     FillBuffer(&src, srcEnd - src);
 140
 141     // convert that buffer
 142     bcr = mBufferLength;
 143     bcw = destEnd - dest;
 144     res = ConvertNoBuff(mBuffer, &bcr, dest, &bcw);
 145     dest += bcw;
 146
 147     if ((res == NS_OK_UDEC_MOREINPUT) && (bcw == 0)) {
 148         res = NS_ERROR_UNEXPECTED;
 149 #if defined(DEBUG_yokoyama) || defined(DEBUG_ftang)
 150         NS_ASSERTION(0, "This should not happen. Internal buffer may be corrupted.");
 151 #endif
 152         break;
 153     } else {
 154       if (bcr < buffLen) {
 155         // we didn't convert that residual data - unfill the buffer
 156         src -= mBufferLength - buffLen;
 157         mBufferLength = buffLen;
 158 #if defined(DEBUG_yokoyama) || defined(DEBUG_ftang)
 159         NS_ASSERTION(0, "This should not happen. Internal buffer may be corrupted.");
 160 #endif
 161       } else {
 162         // the buffer and some extra data was converted - unget the rest
 163         src -= mBufferLength - bcr;
 164         mBufferLength = 0;
 165         res = NS_OK;
 166       }
 167       break;
 168     }
 169   }
 170
 171   if (res == NS_OK) {
 172     bcr = srcEnd - src;
 173     bcw = destEnd - dest;
 174     res = ConvertNoBuff(src, &bcr, dest, &bcw);
 175     src += bcr;
 176     dest += bcw;
 177
 178     // if we have partial input, store it in our internal buffer.
 179     if (res == NS_OK_UDEC_MOREINPUT) {
 180       bcr = srcEnd - src;
 181       // make sure buffer is large enough
 182       if (bcr > mBufferCapacity) {
 183           // somehow we got into an error state and the buffer is growing out of control
 184           res = NS_ERROR_UNEXPECTED;
 185       } else {
 186           FillBuffer(&src, bcr);
 187       }
 188     }
 189   }
 190
 191   *aSrcLength   -= srcEnd - src;
 192   *aDestLength  -= destEnd - dest;
 193   return res;
 194 }
 195
 196 NS_IMETHODIMP nsBufferDecoderSupport::Reset()
 197 {
 198   mBufferLength = 0;
 199   return NS_OK;
 200 }
 201
 202 NS_IMETHODIMP nsBufferDecoderSupport::GetMaxLength(const char* aSrc,
 203                                                    PRInt32 aSrcLength,
 204                                                    PRInt32* aDestLength)
 205 {
 206   NS_ASSERTION(mMaxLengthFactor != 0, "Must override GetMaxLength!");
 207   *aDestLength = aSrcLength * mMaxLengthFactor;
 208   return NS_OK;
 209 }
 210
 211 //----------------------------------------------------------------------
 212 // Class nsTableDecoderSupport [implementation]
 213
 214 nsTableDecoderSupport::nsTableDecoderSupport(uScanClassID aScanClass,
 215                                              uShiftInTable * aShiftInTable,
 216                                              uMappingTable  * aMappingTable,
 217                                              PRUint32 aMaxLengthFactor)
 218 : nsBufferDecoderSupport(aMaxLengthFactor)
 219 {
 220   mScanClass = aScanClass;
 221   mShiftInTable = aShiftInTable;
 222   mMappingTable = aMappingTable;
 223 }
 224
 225 nsTableDecoderSupport::~nsTableDecoderSupport()
 226 {
 227 }
 228
 229 //----------------------------------------------------------------------
 230 // Subclassing of nsBufferDecoderSupport class [implementation]
 231
 232 NS_IMETHODIMP nsTableDecoderSupport::ConvertNoBuff(const char * aSrc,
 233                                                    PRInt32 * aSrcLength,
 234                                                    PRUnichar * aDest,
 235                                                    PRInt32 * aDestLength)
 236 {
 237   return nsUnicodeDecodeHelper::ConvertByTable(aSrc, aSrcLength,
 238                                                aDest, aDestLength,
 239                                                mScanClass,
 240                                                mShiftInTable, mMappingTable);
 241 }
 242
 243 //----------------------------------------------------------------------
 244 // Class nsMultiTableDecoderSupport [implementation]
 245
 246 nsMultiTableDecoderSupport::nsMultiTableDecoderSupport(
 247                             PRInt32 aTableCount,
 248                             const uRange * aRangeArray,
 249                             uScanClassID * aScanClassArray,
 250                             uMappingTable ** aMappingTable,
 251                             PRUint32 aMaxLengthFactor)
 252 : nsBufferDecoderSupport(aMaxLengthFactor)
 253 {
 254   mTableCount = aTableCount;
 255   mRangeArray = aRangeArray;
 256   mScanClassArray = aScanClassArray;
 257   mMappingTable = aMappingTable;
 258 }
 259
 260 nsMultiTableDecoderSupport::~nsMultiTableDecoderSupport()
 261 {
 262 }
 263
 264 //----------------------------------------------------------------------
 265 // Subclassing of nsBufferDecoderSupport class [implementation]
 266
 267 NS_IMETHODIMP nsMultiTableDecoderSupport::ConvertNoBuff(const char * aSrc,
 268                                                         PRInt32 * aSrcLength,
 269                                                         PRUnichar * aDest,
 270                                                         PRInt32 * aDestLength)
 271 {
 272   return nsUnicodeDecodeHelper::ConvertByMultiTable(aSrc, aSrcLength,
 273                                                     aDest, aDestLength,
 274                                                     mTableCount, mRangeArray,
 275                                                     mScanClassArray,
 276                                                     mMappingTable);
 277 }
 278
 279 //----------------------------------------------------------------------
 280 // Class nsOneByteDecoderSupport [implementation]
 281
 282 nsOneByteDecoderSupport::nsOneByteDecoderSupport(
 283                          uMappingTable  * aMappingTable)
 284 : nsBasicDecoderSupport()
 285 {
 286   mMappingTable = aMappingTable;
 287   mFastTableCreated = PR_FALSE;
 288 }
 289
 290 nsOneByteDecoderSupport::~nsOneByteDecoderSupport()
 291 {
 292 }
 293
 294 //----------------------------------------------------------------------
 295 // Subclassing of nsBasicDecoderSupport class [implementation]
 296
 297 NS_IMETHODIMP nsOneByteDecoderSupport::Convert(const char * aSrc,
 298                                               PRInt32 * aSrcLength,
 299                                               PRUnichar * aDest,
 300                                               PRInt32 * aDestLength)
 301 {
 302   if (!mFastTableCreated) {
 303     nsresult res = nsUnicodeDecodeHelper::CreateFastTable(
 304                        mMappingTable, mFastTable, ONE_BYTE_TABLE_SIZE);
 305     if (NS_FAILED(res)) return res;
 306     mFastTableCreated = PR_TRUE;
 307   }
 308
 309   return nsUnicodeDecodeHelper::ConvertByFastTable(aSrc, aSrcLength,
 310                                                    aDest, aDestLength,
 311                                                    mFastTable,
 312                                                    ONE_BYTE_TABLE_SIZE);
 313 }
 314
 315 NS_IMETHODIMP nsOneByteDecoderSupport::GetMaxLength(const char * aSrc,
 316                                                     PRInt32 aSrcLength,
 317                                                     PRInt32 * aDestLength)
 318 {
 319   // single byte to Unicode converter
 320   *aDestLength = aSrcLength;
 321   return NS_OK_UDEC_EXACTLENGTH;
 322 }
 323
 324 NS_IMETHODIMP nsOneByteDecoderSupport::Reset()
 325 {
 326   // nothing to reset, no internal state in this case
 327   return NS_OK;
 328 }
 329
 330 //----------------------------------------------------------------------
 331 // Class nsBasicEncoder [implementation]
 332 nsBasicEncoder::nsBasicEncoder()
 333 {
 334 }
 335
 336 nsBasicEncoder::~nsBasicEncoder()
 337 {
 338 }
 339
 340 //----------------------------------------------------------------------
 341 // Interface nsISupports [implementation]
 342
 343 NS_IMPL_ADDREF(nsBasicEncoder)
 344 NS_IMPL_RELEASE(nsBasicEncoder)
 345 #ifdef NS_DEBUG
 346 NS_IMPL_QUERY_INTERFACE3(nsBasicEncoder,
 347                          nsIUnicodeEncoder,
 348                          nsICharRepresentable, nsIBasicEncoder)
 349 #else
 350 NS_IMPL_QUERY_INTERFACE2(nsBasicEncoder,
 351                          nsIUnicodeEncoder,
 352                          nsICharRepresentable)
 353 #endif
 354 //----------------------------------------------------------------------
 355 // Class nsEncoderSupport [implementation]
 356
 357 nsEncoderSupport::nsEncoderSupport(PRUint32 aMaxLengthFactor) :
 358   mMaxLengthFactor(aMaxLengthFactor)
 359 {
 360   mBufferCapacity = DEFAULT_BUFFER_CAPACITY;
 361   mBuffer = new char[mBufferCapacity];
 362
 363   mErrBehavior = kOnError_Signal;
 364   mErrChar = 0;
 365
 366   Reset();
 367 }
 368
 369 nsEncoderSupport::~nsEncoderSupport()
 370 {
 371   delete [] mBuffer;
 372 }
 373
 374 NS_IMETHODIMP nsEncoderSupport::ConvertNoBuff(const PRUnichar * aSrc,
 375                                               PRInt32 * aSrcLength,
 376                                               char * aDest,
 377                                               PRInt32 * aDestLength)
 378 {
 379   // we do all operations using pointers internally
 380   const PRUnichar * src = aSrc;
 381   const PRUnichar * srcEnd = aSrc + *aSrcLength;
 382   char * dest = aDest;
 383   char * destEnd = aDest + *aDestLength;
 384
 385   PRInt32 bcr, bcw; // byte counts for read & write;
 386   nsresult res;
 387
 388   for (;;) {
 389     bcr = srcEnd - src;
 390     bcw = destEnd - dest;
 391     res = ConvertNoBuffNoErr(src, &bcr, dest, &bcw);
 392     src += bcr;
 393     dest += bcw;
 394
 395     if (res == NS_ERROR_UENC_NOMAPPING) {
 396       if (mErrBehavior == kOnError_Replace) {
 397         const PRUnichar buff[] = {mErrChar};
 398         bcr = 1;
 399         bcw = destEnd - dest;
 400         src--; // back the input: maybe the guy won't consume consume anything.
 401         res = ConvertNoBuffNoErr(buff, &bcr, dest, &bcw);
 402         src += bcr;
 403         dest += bcw;
 404         if (res != NS_OK) break;
 405       } else if (mErrBehavior == kOnError_CallBack) {
 406         bcw = destEnd - dest;
 407         src--;
 408         res = mErrEncoder->Convert(*src, dest, &bcw);
 409         dest += bcw;
 410         // if enought output space then the last char was used
 411         if (res != NS_OK_UENC_MOREOUTPUT) src++;
 412         if (res != NS_OK) break;
 413       } else break;
 414     }
 415     else break;
 416   }
 417
 418   *aSrcLength   -= srcEnd - src;
 419   *aDestLength  -= destEnd - dest;
 420   return res;
 421 }
 422
 423 NS_IMETHODIMP nsEncoderSupport::FinishNoBuff(char * aDest,
 424                                              PRInt32 * aDestLength)
 425 {
 426   *aDestLength = 0;
 427   return NS_OK;
 428 }
 429
 430 nsresult nsEncoderSupport::FlushBuffer(char ** aDest, const char * aDestEnd)
 431 {
 432   PRInt32 bcr, bcw; // byte counts for read & write;
 433   nsresult res = NS_OK;
 434   char * dest = *aDest;
 435
 436   if (mBufferStart < mBufferEnd) {
 437     bcr = mBufferEnd - mBufferStart;
 438     bcw = aDestEnd - dest;
 439     if (bcw < bcr) bcr = bcw;
 440     memcpy(dest, mBufferStart, bcr);
 441     dest += bcr;
 442     mBufferStart += bcr;
 443
 444     if (mBufferStart < mBufferEnd) res = NS_OK_UENC_MOREOUTPUT;
 445   }
 446
 447   *aDest = dest;
 448   return res;
 449 }
 450
 451
 452 //----------------------------------------------------------------------
 453 // Interface nsIUnicodeEncoder [implementation]
 454
 455 NS_IMETHODIMP nsEncoderSupport::Convert(const PRUnichar * aSrc,
 456                                         PRInt32 * aSrcLength,
 457                                         char * aDest,
 458                                         PRInt32 * aDestLength)
 459 {
 460   // we do all operations using pointers internally
 461   const PRUnichar * src = aSrc;
 462   const PRUnichar * srcEnd = aSrc + *aSrcLength;
 463   char * dest = aDest;
 464   char * destEnd = aDest + *aDestLength;
 465
 466   PRInt32 bcr, bcw; // byte counts for read & write;
 467   nsresult res;
 468
 469   res = FlushBuffer(&dest, destEnd);
 470   if (res == NS_OK_UENC_MOREOUTPUT) goto final;
 471
 472   bcr = srcEnd - src;
 473   bcw = destEnd - dest;
 474   res = ConvertNoBuff(src, &bcr, dest, &bcw);
 475   src += bcr;
 476   dest += bcw;
 477   if ((res == NS_OK_UENC_MOREOUTPUT) && (dest < destEnd)) {
 478     // convert exactly one character into the internal buffer
 479     // at this point, there should be at least a char in the input
 480     for (;;) {
 481       bcr = 1;
 482       bcw = mBufferCapacity;
 483       res = ConvertNoBuff(src, &bcr, mBuffer, &bcw);
 484
 485       if (res == NS_OK_UENC_MOREOUTPUT) {
 486         delete [] mBuffer;
 487         mBufferCapacity *= 2;
 488         mBuffer = new char [mBufferCapacity];
 489       } else {
 490         src += bcr;
 491         mBufferStart = mBufferEnd = mBuffer;
 492         mBufferEnd += bcw;
 493         break;
 494       }
 495     }
 496
 497     res = FlushBuffer(&dest, destEnd);
 498   }
 499
 500 final:
 501   *aSrcLength   -= srcEnd - src;
 502   *aDestLength  -= destEnd - dest;
 503   return res;
 504 }
 505
 506 NS_IMETHODIMP nsEncoderSupport::Finish(char * aDest, PRInt32 * aDestLength)
 507 {
 508   // we do all operations using pointers internally
 509   char * dest = aDest;
 510   char * destEnd = aDest + *aDestLength;
 511
 512   PRInt32 bcw; // byte count for write;
 513   nsresult res;
 514
 515   res = FlushBuffer(&dest, destEnd);
 516   if (res == NS_OK_UENC_MOREOUTPUT) goto final;
 517
 518   // do the finish into the internal buffer.
 519   for (;;) {
 520     bcw = mBufferCapacity;
 521     res = FinishNoBuff(mBuffer, &bcw);
 522
 523     if (res == NS_OK_UENC_MOREOUTPUT) {
 524       delete [] mBuffer;
 525       mBufferCapacity *= 2;
 526       mBuffer = new char [mBufferCapacity];
 527     } else {
 528       mBufferStart = mBufferEnd = mBuffer;
 529       mBufferEnd += bcw;
 530       break;
 531     }
 532   }
 533
 534   res = FlushBuffer(&dest, destEnd);
 535
 536 final:
 537   *aDestLength  -= destEnd - dest;
 538   return res;
 539 }
 540
 541 NS_IMETHODIMP nsEncoderSupport::Reset()
 542 {
 543   mBufferStart = mBufferEnd = mBuffer;
 544   return NS_OK;
 545 }
 546
 547 NS_IMETHODIMP nsEncoderSupport::SetOutputErrorBehavior(
 548                                 PRInt32 aBehavior,
 549                                 nsIUnicharEncoder * aEncoder,
 550                                 PRUnichar aChar)
 551 {
 552   if (aBehavior == kOnError_CallBack && aEncoder == nsnull)
 553     return NS_ERROR_NULL_POINTER;
 554
 555   mErrEncoder = aEncoder;
 556   mErrBehavior = aBehavior;
 557   mErrChar = aChar;
 558   return NS_OK;
 559 }
 560
 561 NS_IMETHODIMP
 562 nsEncoderSupport::GetMaxLength(const PRUnichar * aSrc,
 563                                PRInt32 aSrcLength,
 564                                PRInt32 * aDestLength)
 565 {
 566   *aDestLength = aSrcLength * mMaxLengthFactor;
 567   return NS_OK;
 568 }
 569
 570
 571 //----------------------------------------------------------------------
 572 // Class nsTableEncoderSupport [implementation]
 573
 574 nsTableEncoderSupport::nsTableEncoderSupport(uScanClassID aScanClass,
 575                                              uShiftOutTable * aShiftOutTable,
 576                                              uMappingTable  * aMappingTable,
 577                                              PRUint32 aMaxLengthFactor)
 578 : nsEncoderSupport(aMaxLengthFactor)
 579 {
 580   mScanClass = aScanClass;
 581   mShiftOutTable = aShiftOutTable,
 582   mMappingTable = aMappingTable;
 583 }
 584
 585 nsTableEncoderSupport::nsTableEncoderSupport(uScanClassID aScanClass,
 586                                              uMappingTable  * aMappingTable,
 587                                              PRUint32 aMaxLengthFactor)
 588 : nsEncoderSupport(aMaxLengthFactor)
 589 {
 590   mScanClass = aScanClass;
 591   mShiftOutTable = nsnull;
 592   mMappingTable = aMappingTable;
 593 }
 594
 595 nsTableEncoderSupport::~nsTableEncoderSupport()
 596 {
 597 }
 598
 599 NS_IMETHODIMP nsTableEncoderSupport::FillInfo(PRUint32 *aInfo)
 600 {
 601   return nsUnicodeEncodeHelper::FillInfo(aInfo, mMappingTable);
 602 }
 603 //----------------------------------------------------------------------
 604 // Subclassing of nsEncoderSupport class [implementation]
 605
 606 NS_IMETHODIMP nsTableEncoderSupport::ConvertNoBuffNoErr(
 607                                      const PRUnichar * aSrc,
 608                                      PRInt32 * aSrcLength,
 609                                      char * aDest,
 610                                      PRInt32 * aDestLength)
 611 {
 612   return nsUnicodeEncodeHelper::ConvertByTable(aSrc, aSrcLength,
 613                                                aDest, aDestLength,
 614                                                mScanClass,
 615                                                mShiftOutTable, mMappingTable);
 616 }
 617
 618 //----------------------------------------------------------------------
 619 // Class nsMultiTableEncoderSupport [implementation]
 620
 621 nsMultiTableEncoderSupport::nsMultiTableEncoderSupport(
 622                             PRInt32 aTableCount,
 623                             uScanClassID * aScanClassArray,
 624                             uShiftOutTable ** aShiftOutTable,
 625                             uMappingTable  ** aMappingTable,
 626                             PRUint32 aMaxLengthFactor)
 627 : nsEncoderSupport(aMaxLengthFactor)
 628 {
 629   mTableCount = aTableCount;
 630   mScanClassArray = aScanClassArray;
 631   mShiftOutTable = aShiftOutTable;
 632   mMappingTable = aMappingTable;
 633 }
 634
 635 nsMultiTableEncoderSupport::~nsMultiTableEncoderSupport()
 636 {
 637 }
 638
 639 NS_IMETHODIMP nsMultiTableEncoderSupport::FillInfo(PRUint32 *aInfo)
 640 {
 641   return nsUnicodeEncodeHelper::FillInfo(aInfo,mTableCount, mMappingTable);
 642 }
 643 //----------------------------------------------------------------------
 644 // Subclassing of nsEncoderSupport class [implementation]
 645
 646 NS_IMETHODIMP nsMultiTableEncoderSupport::ConvertNoBuffNoErr(
 647                                           const PRUnichar * aSrc,
 648                                           PRInt32 * aSrcLength,
 649                                           char * aDest,
 650                                           PRInt32 * aDestLength)
 651 {
 652   return nsUnicodeEncodeHelper::ConvertByMultiTable(aSrc, aSrcLength,
 653                                                     aDest, aDestLength,
 654                                                     mTableCount,
 655                                                     mScanClassArray,
 656                                                     mShiftOutTable,
 657                                                     mMappingTable);
 658 }