home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 6 / AACD06.ISO / AACD / Programming / ICU / include / ucnv_err.h < prev    next >
C/C++ Source or Header  |  1999-11-12  |  6KB  |  157 lines
  1. /*
  2.  ********************************************************************************
  3.  *                                                                              *
  4.  * COPYRIGHT:                                                                   *
  5.  *   (C) Copyright International Business Machines Corporation, 1999            *
  6.  *   Licensed Material - Program-Property of IBM - All Rights Reserved.         *
  7.  *   US Government Users Restricted Rights - Use, duplication, or disclosure    *
  8.  *   restricted by GSA ADP Schedule Contract with IBM Corp.                     *
  9.  *                                                                              *
  10.  ********************************************************************************
  11.  *
  12.  *
  13.  *   ucnv_err.h:
  14.  *   defines error behaviour functions called by T_UConverter_{from,to}Unicode
  15.  *
  16.  *   These Functions, although public, should NEVER be called directly, they should be used as parameters to
  17.  *   the T_UConverter_setMissing{Char,Unicode}Action API, to set the behaviour of a converter
  18.  *   when it encounters ILLEGAL/UNMAPPED/INVALID sequences.
  19.  *
  20.  *   usage example:
  21.  *
  22.  *        ...
  23.  *        UErrorCode err = U_ZERO_ERROR;
  24.  *        UConverter* myConverter = T_UConverter_create("ibm-949", &err);
  25.  *
  26.  *        if (U_SUCCESS(err))
  27.  *        {
  28.  *       T_UConverter_setMissingUnicodeAction(myConverter, (MissingUnicodeAction)UCNV_FROM_U_CALLBACK_STOP, &err);
  29.  *       T_UConverter_setMissingCharAction(myConverter, (MissingCharAction)UCNV_TO_U_CALLBACK_SUBSTITUTE, &err);
  30.  *        }
  31.  *        ...
  32.  *
  33.  *   The code above tells "myConverter" to stop when it encounters a ILLEGAL/TRUNCATED/INVALID sequences when it is used to
  34.  *   convert from Unicode -> Codepage.
  35.  *   and to substitute with a codepage specific substitutions sequence when converting from Codepage -> Unicode
  36.  */
  37.  
  38.  
  39. #ifndef UCNV_ERR_H
  40. #define UCNV_ERR_H
  41.  
  42.  
  43. #include "utypes.h"
  44.  
  45.  
  46. /*Functor STOPS at the ILLEGAL_SEQUENCE */
  47. U_CAPI void U_EXPORT2 UCNV_FROM_U_CALLBACK_STOP (UConverter * _this,
  48.                      char **target,
  49.                      const char *targetLimit,
  50.                      const UChar ** source,
  51.                      const UChar * sourceLimit,
  52.                      int32_t* offsets,
  53.                      bool_t flush,
  54.                      UErrorCode * err);
  55.  
  56.  
  57. /*Functor STOPS at the ILLEGAL_SEQUENCE */
  58. U_CAPI void U_EXPORT2 UCNV_TO_U_CALLBACK_STOP (UConverter * _this,
  59.                   UChar ** target,
  60.                   const UChar * targetLimit,
  61.                   const char **source,
  62.                   const char *sourceLimit,
  63.                   int32_t* offsets,
  64.                   bool_t flush,
  65.                   UErrorCode * err);
  66.  
  67.  
  68.  
  69.  
  70. /*Functor SKIPs the ILLEGAL_SEQUENCE */
  71. U_CAPI void U_EXPORT2 UCNV_FROM_U_CALLBACK_SKIP (UConverter * _this,
  72.                      char **target,
  73.                      const char *targetLimit,
  74.                      const UChar ** source,
  75.                      const UChar * sourceLimit,
  76.                      int32_t* offsets,
  77.                      bool_t flush,
  78.                      UErrorCode * err);
  79.  
  80. /* Functor Substitute the ILLEGAL SEQUENCE with the current substitution string assiciated with _this,
  81.  * in the event target buffer is too small, it will store the extra info in the UConverter, and err
  82.  * will be set to U_INDEX_OUTOFBOUNDS_ERROR. The next time T_UConverter_fromUnicode is called, it will
  83.  * store the left over data in target, before transcoding the "source Stream"
  84.  */
  85.  
  86. U_CAPI void U_EXPORT2 UCNV_FROM_U_CALLBACK_SUBSTITUTE (UConverter * _this,
  87.                        char **target,
  88.                        const char *targetLimit,
  89.                        const UChar ** source,
  90.                        const UChar * sourceLimit,
  91.                        int32_t* offsets,
  92.                        bool_t flush,
  93.                        UErrorCode * err);
  94.  
  95. /* Functor Substitute the ILLEGAL SEQUENCE with a sequence escaped codepoints corresponding to the ILLEGAL
  96.  * SEQUENCE (format  %UXXXX, e.g. "%uFFFE%u00AC%uC8FE"). In the Event the Converter doesn't support the
  97.  * characters {u,%}[A-F][0-9], it will substitute  the illegal sequence with the substitution characters
  98.  * (it will behave like the above functor).
  99.  * in the event target buffer is too small, it will store the extra info in the UConverter, and err
  100.  * will be set to U_INDEX_OUTOFBOUNDS_ERROR. The next time T_UConverter_fromUnicode is called, it will
  101.  * store the left over data in target, before transcoding the "source Stream"
  102.  */
  103.  
  104. U_CAPI void U_EXPORT2 UCNV_FROM_U_CALLBACK_ESCAPE (UConverter * _this,
  105.                             char **target,
  106.                             const char *targetLimit,
  107.                             const UChar ** source,
  108.                           const UChar * sourceLimit,
  109.                             int32_t* offsets,
  110.                             bool_t flush,
  111.                             UErrorCode * err);
  112.  
  113.  
  114. /*Functor SKIPs the ILLEGAL_SEQUENCE */
  115. U_CAPI void U_EXPORT2 UCNV_TO_U_CALLBACK_SKIP (UConverter * _this,
  116.                   UChar ** target,
  117.                   const UChar * targetLimit,
  118.                   const char **source,
  119.                   const char *sourceLimit,
  120.                   int32_t* offsets,
  121.                   bool_t flush,
  122.                   UErrorCode * err);
  123.  
  124.  
  125. /* Functor Substitute the ILLEGAL SEQUENCE with the current substitution string assiciated with _this,
  126.  * in the event target buffer is too small, it will store the extra info in the UConverter, and err
  127.  * will be set to U_INDEX_OUTOFBOUNDS_ERROR. The next time T_UConverter_fromUnicode is called, it will
  128.  * store the left over data in target, before transcoding the "source Stream"
  129.  */
  130. U_CAPI void U_EXPORT2 UCNV_TO_U_CALLBACK_SUBSTITUTE (UConverter * _this,
  131.                     UChar ** target,
  132.                     const UChar * targetLimit,
  133.                     const char **source,
  134.                     const char *sourceLimit,
  135.                     int32_t* offsets,
  136.                     bool_t flush,
  137.                     UErrorCode * err);
  138.  
  139. /* Functor Substitute the ILLEGAL SEQUENCE with a sequence escaped codepoints corresponding to the
  140.  * ILLEGAL SEQUENCE (format  %XNN, e.g. "%XFF%X0A%XC8%X03").
  141.  * in the event target buffer is too small, it will store the extra info in the UConverter, and err
  142.  * will be set to U_INDEX_OUTOFBOUNDS_ERROR. The next time T_UConverter_fromUnicode is called, it will
  143.  * store the left over data in target, before transcoding the "source Stream"
  144.  */
  145.  
  146. U_CAPI void U_EXPORT2 UCNV_TO_U_CALLBACK_ESCAPE (UConverter * _this,
  147.                          UChar ** target,
  148.                          const UChar * targetLimit,
  149.                          const char **source,
  150.                          const char *sourceLimit,
  151.                          int32_t* offsets,
  152.                          bool_t flush,
  153.                          UErrorCode * err);
  154.  
  155.  
  156. #endif/*UCNV_ERR_H*/ 
  157.