Home | History | Annotate | Download | only in charset 
      1 /*
      2  *******************************************************************************
      3  * Copyright (C) 2006-2008, International Business Machines Corporation and    *
      4  * others. All Rights Reserved.                                                *
      5  *******************************************************************************
      6  */
      7 package com.ibm.icu.charset;
      8 
      9 /**
     10  * Defines the UConverterSharedData struct, the immutable, shared part of
     11  * UConverter.
     12  */
     13 final class UConverterSharedData {
     14     // uint32_t structSize; /* Size of this structure */
     15     // int structSize; /* Size of this structure */
     16     /**
     17      * used to count number of clients, 0xffffffff for static SharedData
     18      */
     19     int referenceCounter;
     20 
     21     // agljport:todo const void *dataMemory; /* from udata_openChoice() - for cleanup */
     22     // agljport:todo void *table; /* Unused. This used to be a UConverterTable - Pointer to conversion data - see mbcs below */
     23 
     24     // const UConverterStaticData *staticData; /* pointer to the static (non changing) data. */
     25     /**
     26      * pointer to the static (non changing)
     27      * data.
     28      */
     29     UConverterStaticData staticData;
     30 
     31     // UBool sharedDataCached; /* TRUE: shared data is in cache, don't destroy
     32     // on close() if 0 ref. FALSE: shared data isn't in the cache, do attempt to
     33     // clean it up if the ref is 0 */
     34 
     35     /**
     36      * TRUE: shared data is in cache, don't destroy
     37      * on close() if 0 ref. FALSE: shared data isn't
     38      * in the cache, do attempt to clean it up if
     39      * the ref is 0
     40      */
     41     boolean sharedDataCached;
     42 
     43     /*
     44      * UBool staticDataOwned; TRUE if static data owned by shared data & should
     45      * be freed with it, NEVER true for udata() loaded statics. This ignored
     46      * variable was removed to make space for sharedDataCached.
     47      */
     48 
     49     // const UConverterImpl *impl; /* vtable-style struct of mostly function pointers */
     50     // UConverterImpl impl; /* vtable-style struct of mostly function pointers */
     51     /** initial values of some members of the mutable part of object */
     52     long toUnicodeStatus;
     53 
     54     /**
     55      * Shared data structures currently come in two flavors:
     56      * - readonly for built-in algorithmic converters
     57      * - allocated for MBCS, with a pointer to an allocated UConverterTable
     58      *   which always has a UConverterMBCSTable
     59      *
     60      * To eliminate one allocation, I am making the UConverterMBCSTable a member
     61      * of the shared data. It is the last member so that static definitions of
     62      * UConverterSharedData work as before. The table field above also remains
     63      * to avoid updating all static definitions, but is now unused.
     64      *
     65      */
     66     CharsetMBCS.UConverterMBCSTable mbcs;
     67 
     68     UConverterSharedData() {
     69         mbcs = new CharsetMBCS.UConverterMBCSTable();
     70     }
     71 
     72     UConverterSharedData(int referenceCounter_, UConverterStaticData staticData_, boolean sharedDataCached_, long toUnicodeStatus_)
     73     {
     74         this();
     75         referenceCounter = referenceCounter_;
     76         staticData = staticData_;
     77         sharedDataCached = sharedDataCached_;
     78         // impl = impl_;
     79         toUnicodeStatus = toUnicodeStatus_;
     80     }
     81 
     82     /**
     83      * UConverterImpl contains all the data and functions for a converter type.
     84      * Its function pointers work much like a C++ vtable. Many converter types
     85      * need to define only a subset of the functions; when a function pointer is
     86      * NULL, then a default action will be performed.
     87      *
     88      * Every converter type must implement toUnicode, fromUnicode, and
     89      * getNextUChar, otherwise the converter may crash. Every converter type
     90      * that has variable-length codepage sequences should also implement
     91      * toUnicodeWithOffsets and fromUnicodeWithOffsets for correct offset
     92      * handling. All other functions may or may not be implemented - it depends
     93      * only on whether the converter type needs them.
     94      *
     95      * When open() fails, then close() will be called, if present.
     96      */
     97 /* class UConverterImpl {
     98     UConverterType type;
     99     UConverterToUnicode toUnicode;
    100     protected void doToUnicode(UConverterToUnicodeArgs args, int[] pErrorCode)
    101     {
    102     }
    103 
    104      final void toUnicode(UConverterToUnicodeArgs args, int[] pErrorCode)
    105     {
    106         doToUnicode(args, pErrorCode);
    107     }
    108 
    109     //UConverterFromUnicode fromUnicode;
    110     protected void doFromUnicode(UConverterFromUnicodeArgs args, int[] pErrorCode)
    111     {
    112     }
    113 
    114      final void fromUnicode(UConverterFromUnicodeArgs args, int[] pErrorCode)
    115     {
    116         doFromUnicode(args, pErrorCode);
    117     }
    118 
    119     protected int doGetNextUChar(UConverterToUnicodeArgs args, int[] pErrorCode)
    120     {
    121         return 0;
    122     }
    123 
    124     //UConverterGetNextUChar getNextUChar;
    125      final int getNextUChar(UConverterToUnicodeArgs args, int[] pErrorCode)
    126     {
    127         return doGetNextUChar(args, pErrorCode);
    128     }
    129 
    130     // interface UConverterImplLoadable extends UConverterImpl
    131     protected void doLoad(UConverterLoadArgs pArgs, short[] raw, int[] pErrorCode)
    132     {
    133     }
    134 
    135     protected void doUnload()
    136     {
    137     }
    138 
    139     // interface UConverterImplOpenable extends UConverterImpl
    140     protected void doOpen(UConverter cnv, String name, String locale, long options, int[] pErrorCode)
    141     {
    142     }
    143 
    144     //UConverterOpen open;
    145      final void open(UConverter cnv, String name, String locale, long options, int[] pErrorCode)
    146     {
    147         doOpen(cnv, name, locale, options, pErrorCode);
    148     }
    149 
    150     protected void doClose(UConverter cnv)
    151     {
    152     }
    153 
    154     //UConverterClose close;
    155      final void close(UConverter cnv)
    156     {
    157         doClose(cnv);
    158     }
    159 
    160     protected void doReset(UConverter cnv, int choice)
    161     {
    162     }
    163 
    164     //typedef void (*UConverterReset) (UConverter *cnv, UConverterResetChoice choice);
    165     //UConverterReset reset;
    166      final void reset(UConverter cnv, int choice)
    167     {
    168         doReset(cnv, choice);
    169     }
    170 
    171     // interface UConverterImplVariableLength extends UConverterImpl
    172     protected void doToUnicodeWithOffsets(UConverterToUnicodeArgs args, int[] pErrorCode)
    173     {
    174     }
    175 
    176     //UConverterToUnicode toUnicodeWithOffsets;
    177      final void toUnicodeWithOffsets(UConverterToUnicodeArgs args, int[] pErrorCode)
    178     {
    179         doToUnicodeWithOffsets(args, pErrorCode);
    180     }
    181 
    182     protected void doFromUnicodeWithOffsets(UConverterFromUnicodeArgs args, int[] pErrorCode)
    183     {
    184     }
    185 
    186     //UConverterFromUnicode fromUnicodeWithOffsets;
    187      final void fromUnicodeWithOffsets(UConverterFromUnicodeArgs args, int[] pErrorCode)
    188     {
    189         doFromUnicodeWithOffsets(args, pErrorCode);
    190     }
    191 
    192     // interface UConverterImplMisc extends UConverterImpl
    193     protected void doGetStarters(UConverter converter, boolean starters[], int[] pErrorCode)
    194     {
    195     }
    196 
    197     //UConverterGetStarters getStarters;
    198      final void getStarters(UConverter converter, boolean starters[], int[] pErrorCode)
    199     {
    200         doGetStarters(converter, starters, pErrorCode);
    201     }
    202 
    203     protected String doGetName(UConverter cnv)
    204     {
    205         return "";
    206     }
    207 
    208     //UConverterGetName getName;
    209      final String getName(UConverter cnv)
    210     {
    211         return doGetName(cnv);
    212     }
    213 
    214     protected void doWriteSub(UConverterFromUnicodeArgs pArgs, long offsetIndex, int[] pErrorCode)
    215     {
    216     }
    217 
    218     //UConverterWriteSub writeSub;
    219      final void writeSub(UConverterFromUnicodeArgs pArgs, long offsetIndex, int[] pErrorCode)
    220     {
    221         doWriteSub(pArgs, offsetIndex, pErrorCode);
    222     }
    223 
    224     protected UConverter doSafeClone(UConverter cnv, byte[] stackBuffer, int[] pBufferSize, int[] status)
    225     {
    226         return new UConverter();
    227     }
    228 
    229     //UConverterSafeClone safeClone;
    230      final UConverter  safeClone(UConverter cnv, byte[] stackBuffer, int[] pBufferSize, int[] status)
    231     {
    232         return doSafeClone(cnv, stackBuffer, pBufferSize, status);
    233     }
    234 
    235     protected void doGetUnicodeSet(UConverter cnv, UnicodeSet /*USetAdder* / sa, int /*UConverterUnicodeSet* / which, int[] pErrorCode)
    236     {
    237     }
    238 
    239     //UConverterGetUnicodeSet getUnicodeSet;
    240     // final void getUnicodeSet(UConverter cnv, UnicodeSet /*USetAdder* / sa, int /*UConverterUnicodeSet* / which, int[] pErrorCode)
    241     //{
    242     //  doGetUnicodeSet(cnv, sa, which, pErrorCode);
    243     //}
    244 
    245     //}
    246 
    247     static final String DATA_TYPE = "cnv";
    248     private static final int CNV_DATA_BUFFER_SIZE = 25000;
    249      static final int sizeofUConverterSharedData = 100;
    250 
    251     //static UDataMemoryIsAcceptable isCnvAcceptable;
    252 
    253     /**
    254      * Load a non-algorithmic converter.
    255      * If pkg==NULL, then this function must be called inside umtx_lock(&cnvCacheMutex).
    256 
    257     // UConverterSharedData * load(UConverterLoadArgs *pArgs, UErrorCode *err)
    258      static final UConverterSharedData load(UConverterLoadArgs pArgs, int[] err)
    259     {
    260         UConverterSharedData mySharedConverterData = null;
    261 
    262         if(err == null || ErrorCode.isFailure(err[0])) {
    263             return null;
    264         }
    265 
    266         if(pArgs.pkg != null && pArgs.pkg.length() != 0) {
    267              application-provided converters are not currently cached
    268             return UConverterSharedData.createConverterFromFile(pArgs, err);
    269         }
    270 
    271         //agljport:fix mySharedConverterData = getSharedConverterData(pArgs.name);
    272         if (mySharedConverterData == null)
    273         {
    274             Not cached, we need to stream it in from file
    275             mySharedConverterData = UConverterSharedData.createConverterFromFile(pArgs, err);
    276             if (ErrorCode.isFailure(err[0]) || (mySharedConverterData == null))
    277             {
    278                 return null;
    279             }
    280             else
    281             {
    282                  share it with other library clients
    283                 //agljport:fix shareConverterData(mySharedConverterData);
    284             }
    285         }
    286         else
    287         {
    288              The data for this converter was already in the cache.
    289              Update the reference counter on the shared data: one more client
    290             mySharedConverterData.referenceCounter++;
    291         }
    292 
    293         return mySharedConverterData;
    294     }
    295 
    296     Takes an alias name gets an actual converter file name
    297      *goes to disk and opens it.
    298      *allocates the memory and returns a new UConverter object
    299 
    300     //static UConverterSharedData *createConverterFromFile(UConverterLoadArgs *pArgs, UErrorCode * err)
    301      static final UConverterSharedData createConverterFromFile(UConverterLoadArgs pArgs, int[] err)
    302     {
    303         UDataMemory data = null;
    304         UConverterSharedData sharedData = null;
    305 
    306         //agljport:todo UTRACE_ENTRY_OC(UTRACE_LOAD);
    307 
    308         if (err == null || ErrorCode.isFailure(err[0])) {
    309             //agljport:todo UTRACE_EXIT_STATUS(*err);
    310             return null;
    311         }
    312 
    313         //agljport:todo UTRACE_DATA2(UTRACE_OPEN_CLOSE, "load converter %s from package %s", pArgs->name, pArgs->pkg);
    314 
    315         //agljport:fix data = udata_openChoice(pArgs.pkgArray, DATA_TYPE.getBytes(), pArgs.name, isCnvAcceptable, null, err);
    316         if(ErrorCode.isFailure(err[0]))
    317         {
    318             //agljport:todo UTRACE_EXIT_STATUS(*err);
    319             return null;
    320         }
    321 
    322         sharedData = data_unFlattenClone(pArgs, data, err);
    323         if(ErrorCode.isFailure(err[0]))
    324         {
    325             //agljport:fix udata_close(data);
    326             //agljport:todo UTRACE_EXIT_STATUS(*err);
    327             return null;
    328         }
    329 
    330 
    331          * TODO Store pkg in a field in the shared data so that delta-only converters
    332          * can load base converters from the same package.
    333          * If the pkg name is longer than the field, then either do not load the converter
    334          * in the first place, or just set the pkg field to "".
    335 
    336 
    337         return sharedData;
    338     }
    339 */
    340     UConverterDataReader dataReader = null;
    341 
    342     /*
    343      * returns a converter type from a string
    344      */
    345     /*   static final UConverterSharedData getAlgorithmicTypeFromName(String realName)
    346     {
    347         long mid, start, limit;
    348         long lastMid;
    349         int result;
    350         StringBuffer strippedName = new StringBuffer(UConverterConstants.MAX_CONVERTER_NAME_LENGTH);
    351 
    352         // Lower case and remove ignoreable characters.
    353         UConverterAlias.stripForCompare(strippedName, realName);
    354 
    355         // do a binary search for the alias
    356         start = 0;
    357         limit = cnvNameType.length;
    358         mid = limit;
    359         lastMid = -1;
    360 
    361         for (;;) {
    362             mid = (long)((start + limit) / 2);
    363             if (lastMid == mid) {   // Have we moved?
    364                 break;  // We haven't moved, and it wasn't found.
    365             }
    366             lastMid = mid;
    367             result = strippedName.substring(0).compareTo(cnvNameType[(int)mid].name);
    368 
    369             if (result < 0) {
    370                 limit = mid;
    371             } else if (result > 0) {
    372                 start = mid;
    373             } else {
    374                 return converterData[cnvNameType[(int)mid].type];
    375             }
    376         }
    377 
    378         return null;
    379     }*/
    380 
    381     /*
    382      * Enum for specifying basic types of converters
    383      */
    384     static final class UConverterType {
    385         static final int UNSUPPORTED_CONVERTER = -1;
    386         static final int SBCS = 0;
    387         static final int DBCS = 1;
    388         static final int MBCS = 2;
    389         static final int LATIN_1 = 3;
    390         static final int UTF8 = 4;
    391         static final int UTF16_BigEndian = 5;
    392         static final int UTF16_LittleEndian = 6;
    393         static final int UTF32_BigEndian = 7;
    394         static final int UTF32_LittleEndian = 8;
    395         static final int EBCDIC_STATEFUL = 9;
    396         static final int ISO_2022 = 10;
    397         static final int LMBCS_1 = 11;
    398         static final int LMBCS_2 = LMBCS_1 + 1; // 12
    399         static final int LMBCS_3 = LMBCS_2 + 1; // 13
    400         static final int LMBCS_4 = LMBCS_3 + 1; // 14
    401         static final int LMBCS_5 = LMBCS_4 + 1; // 15
    402         static final int LMBCS_6 = LMBCS_5 + 1; // 16
    403         static final int LMBCS_8 = LMBCS_6 + 1; // 17
    404         static final int LMBCS_11 = LMBCS_8 + 1; // 18
    405         static final int LMBCS_16 = LMBCS_11 + 1; // 19
    406         static final int LMBCS_17 = LMBCS_16 + 1; // 20
    407         static final int LMBCS_18 = LMBCS_17 + 1; // 21
    408         static final int LMBCS_19 = LMBCS_18 + 1; // 22
    409         static final int LMBCS_LAST = LMBCS_19; // 22
    410         static final int HZ = LMBCS_LAST + 1; // 23
    411         static final int SCSU = HZ + 1; // 24
    412         static final int ISCII = SCSU + 1; // 25
    413         static final int US_ASCII = ISCII + 1; // 26
    414         static final int UTF7 = US_ASCII + 1; // 27
    415         static final int BOCU1 = UTF7 + 1; // 28
    416         static final int UTF16 = BOCU1 + 1; // 29
    417         static final int UTF32 = UTF16 + 1; // 30
    418         static final int CESU8 = UTF32 + 1; // 31
    419         static final int IMAP_MAILBOX = CESU8 + 1; // 32
    420 
    421         // Number of converter types for which we have conversion routines.
    422         static final int NUMBER_OF_SUPPORTED_CONVERTER_TYPES = IMAP_MAILBOX + 1;
    423     }
    424 
    425     /**
    426      * Enum for specifying which platform a converter ID refers to. The use of
    427      * platform/CCSID is not recommended. See openCCSID().
    428      */
    429     static final class UConverterPlatform {
    430         static final int UNKNOWN = -1;
    431         static final int IBM = 0;
    432     }
    433 
    434     // static UConverterSharedData[] converterData;
    435     /*  static class cnvNameTypeClass {
    436       String name;
    437         int type;
    438         cnvNameTypeClass(String name_, int type_) { name = name_; type = type_; }
    439     }
    440 
    441     static cnvNameTypeClass cnvNameType[];*/
    442 
    443 
    444     static final String DATA_TYPE = "cnv";
    445     //static final int CNV_DATA_BUFFER_SIZE = 25000;
    446     //static final int SIZE_OF_UCONVERTER_SHARED_DATA = 228;
    447 
    448 }
    449