home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 6 / AACD06.ISO / AACD / Programming / ICU / src / icu / source / common / ucnv_cnv.h < prev    next >
Encoding:
C/C++ Source or Header  |  1999-10-19  |  9.1 KB  |  307 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.    *   uconv_cnv.h:
  14.    *   defines all the low level conversion functions
  15.    *   T_UnicodeConverter_{to,from}Unicode_$ConversionType
  16.  */
  17.  
  18. #ifndef UCNV_CNV_H
  19. #define UCNV_CNV_H
  20.  
  21. #include "utypes.h"
  22. #include "ucnv_bld.h"
  23.  
  24. bool_t CONVERSION_U_SUCCESS (UErrorCode err);
  25.  
  26. void T_UConverter_toUnicode_SBCS (UConverter * converter,
  27.                   UChar ** target,
  28.                   const UChar * targetLimit,
  29.                   const char **source,
  30.                   const char *sourceLimit,
  31.                   int32_t* offsets,
  32.                   bool_t flush,
  33.                   UErrorCode * err);
  34.  
  35. void T_UConverter_fromUnicode_SBCS (UConverter * converter,
  36.                     char **target,
  37.                     const char *targetLimit,
  38.                     const UChar ** source,
  39.                     const UChar * sourceLimit,
  40.                     int32_t* offsets,
  41.                     bool_t flush,
  42.                     UErrorCode * err);
  43.  
  44. void T_UConverter_toUnicode_MBCS (UConverter * converter,
  45.                   UChar ** target,
  46.                   const UChar * targetLimit,
  47.                   const char **source,
  48.                   const char *sourceLimit,
  49.                   int32_t* offsets,
  50.                   bool_t flush,
  51.                   UErrorCode * err);
  52.  
  53. void T_UConverter_fromUnicode_MBCS (UConverter * converter,
  54.                     char **target,
  55.                     const char *targetLimit,
  56.                     const UChar ** source,
  57.                     const UChar * sourceLimit,
  58.                     int32_t* offsets,
  59.                     bool_t flush,
  60.                     UErrorCode * err);
  61. void T_UConverter_toUnicode_MBCS_OFFSETS_LOGIC (UConverter * converter,
  62.                   UChar ** target,
  63.                   const UChar * targetLimit,
  64.                   const char **source,
  65.                   const char *sourceLimit,
  66.                   int32_t* offsets,
  67.                   bool_t flush,
  68.                   UErrorCode * err);
  69.  
  70. void T_UConverter_fromUnicode_MBCS_OFFSETS_LOGIC (UConverter * converter,
  71.                     char **target,
  72.                     const char *targetLimit,
  73.                     const UChar ** source,
  74.                     const UChar * sourceLimit,
  75.                     int32_t* offsets,
  76.                     bool_t flush,
  77.                     UErrorCode * err);
  78.  
  79. void T_UConverter_toUnicode_DBCS (UConverter * converter,
  80.                   UChar ** target,
  81.                   const UChar * targetLimit,
  82.                   const char **source,
  83.                   const char *sourceLimit,
  84.                   int32_t* offsets,
  85.                   bool_t flush,
  86.                   UErrorCode * err);
  87.  
  88. void T_UConverter_fromUnicode_DBCS (UConverter * converter,
  89.                     char **target,
  90.                     const char *targetLimit,
  91.                     const UChar ** source,
  92.                     const UChar * sourceLimit,
  93.                     int32_t* offsets,
  94.                     bool_t flush,
  95.                     UErrorCode * err);
  96.  
  97. void T_UConverter_fromUnicode_UTF16_BE (UConverter * converter,
  98.                     char **target,
  99.                     const char *targetLimit,
  100.                     const UChar ** source,
  101.                     const UChar * sourceLimit,
  102.                     int32_t* offsets,
  103.                     bool_t flush,
  104.                     UErrorCode * err);
  105.  
  106. void T_UConverter_toUnicode_UTF16_BE (UConverter * converter,
  107.                       UChar ** target,
  108.                       const UChar * targetLimit,
  109.                       const char **source,
  110.                       const char *sourceLimit,
  111.                       int32_t* offsets,
  112.                       bool_t flush,
  113.                       UErrorCode * err);
  114.  
  115. void T_UConverter_fromUnicode_UTF16_LE (UConverter * converter,
  116.                     char **target,
  117.                     const char *targetLimit,
  118.                     const UChar ** source,
  119.                     const UChar * sourceLimit,
  120.                     int32_t* offsets,
  121.                     bool_t flush,
  122.                     UErrorCode * err);
  123.  
  124. void T_UConverter_toUnicode_EBCDIC_STATEFUL(UConverter * converter,
  125.                         UChar ** target,
  126.                         const UChar * targetLimit,
  127.                         const char **source,
  128.                         const char *sourceLimit,
  129.                         int32_t* offsets,
  130.                         bool_t flush,
  131.                         UErrorCode * err);
  132.  
  133. void T_UConverter_fromUnicode_EBCDIC_STATEFUL(UConverter * converter,
  134.                           char **target,
  135.                           const char *targetLimit,
  136.                           const UChar ** source,
  137.                           const UChar * sourceLimit,
  138.                           int32_t* offsets,
  139.                           bool_t flush,
  140.                           UErrorCode * err);
  141.  
  142. void T_UConverter_toUnicode_EBCDIC_STATEFUL_OFFSETS_LOGIC(UConverter * converter,
  143.                               UChar ** target,
  144.                               const UChar * targetLimit,
  145.                               const char **source,
  146.                               const char *sourceLimit,
  147.                               int32_t* offsets,
  148.                               bool_t flush,
  149.                               UErrorCode * err);
  150.  
  151. void T_UConverter_fromUnicode_EBCDIC_STATEFUL_OFFSETS_LOGIC(UConverter * converter,
  152.                                 char **target,
  153.                                 const char *targetLimit,
  154.                                 const UChar ** source,
  155.                                 const UChar * sourceLimit,
  156.                                 int32_t* offsets,
  157.                                 bool_t flush,
  158.                                 UErrorCode * err);
  159.  
  160. void T_UConverter_toUnicode_ISO_2022(UConverter * converter,
  161.                      UChar ** target,
  162.                      const UChar * targetLimit,
  163.                      const char **source,
  164.                      const char *sourceLimit,
  165.                      int32_t* offsets,
  166.                      bool_t flush,
  167.                      UErrorCode * err);
  168.  
  169. void T_UConverter_fromUnicode_ISO_2022(UConverter * converter,
  170.                        char **target,
  171.                        const char *targetLimit,
  172.                        const UChar ** source,
  173.                        const UChar * sourceLimit,
  174.                        int32_t* offsets,
  175.                        bool_t flush,
  176.                        UErrorCode * err);
  177.  
  178. void T_UConverter_toUnicode_ISO_2022_OFFSETS_LOGIC(UConverter * converter,
  179.                      UChar ** target,
  180.                      const UChar * targetLimit,
  181.                      const char **source,
  182.                      const char *sourceLimit,
  183.                      int32_t* offsets,
  184.                      bool_t flush,
  185.                      UErrorCode * err);
  186.  
  187. void T_UConverter_fromUnicode_ISO_2022_OFFSETS_LOGIC(UConverter * converter,
  188.                        char **target,
  189.                        const char *targetLimit,
  190.                        const UChar ** source,
  191.                        const UChar * sourceLimit,
  192.                        int32_t* offsets,
  193.                        bool_t flush,
  194.                        UErrorCode * err);
  195.  
  196.  
  197. void T_UConverter_toUnicode_UTF16_LE (UConverter * converter,
  198.                       UChar ** target,
  199.                       const UChar * targetLimit,
  200.                       const char **source,
  201.                       const char *sourceLimit,
  202.                       int32_t* offsets,
  203.                       bool_t flush,
  204.                       UErrorCode * err);
  205.  
  206. void T_UConverter_fromUnicode_UTF8 (UConverter * converter,
  207.                     char **target,
  208.                     const char *targetLimit,
  209.                     const UChar ** source,
  210.                     const UChar * sourceLimit,
  211.                     int32_t* offsets,
  212.                     bool_t flush,
  213.                     UErrorCode * err);
  214.  
  215. void T_UConverter_toUnicode_UTF8 (UConverter * converter,
  216.                   UChar ** target,
  217.                   const UChar * targetLimit,
  218.                   const char **source,
  219.                   const char *sourceLimit,
  220.                   int32_t* offsets,
  221.                   bool_t flush,
  222.                   UErrorCode * err);
  223.  
  224. void T_UConverter_fromUnicode_UTF8_OFFSETS_LOGIC (UConverter * converter,
  225.                     char **target,
  226.                     const char *targetLimit,
  227.                     const UChar ** source,
  228.                     const UChar * sourceLimit,
  229.                     int32_t* offsets,
  230.                     bool_t flush,
  231.                     UErrorCode * err);
  232.  
  233. void T_UConverter_toUnicode_UTF8_OFFSETS_LOGIC (UConverter * converter,
  234.                   UChar ** target,
  235.                   const UChar * targetLimit,
  236.                   const char **source,
  237.                   const char *sourceLimit,
  238.                   int32_t* offsets,
  239.                   bool_t flush,
  240.                   UErrorCode * err);
  241.  
  242. void T_UConverter_fromUnicode_LATIN_1 (UConverter * converter,
  243.                        char **target,
  244.                        const char *targetLimit,
  245.                        const UChar ** source,
  246.                        const UChar * sourceLimit,
  247.                        int32_t* offsets,
  248.                        bool_t flush,
  249.                        UErrorCode * err);
  250.  
  251. void T_UConverter_toUnicode_LATIN_1 (UConverter * converter,
  252.                      UChar ** target,
  253.                      const UChar * targetLimit,
  254.                      const char **source,
  255.                      const char *sourceLimit,
  256.                      int32_t* offsets,
  257.                      bool_t flush,
  258.                      UErrorCode * err);
  259.  
  260. UChar T_UConverter_getNextUChar_LATIN_1 (UConverter * converter,
  261.                      const char **source,
  262.                      const char *sourceLimit,
  263.                      UErrorCode * err);
  264.  
  265. UChar T_UConverter_getNextUChar_SBCS (UConverter * converter,
  266.                       const char **source,
  267.                       const char *sourceLimit,
  268.                       UErrorCode * err);
  269.  
  270. UChar T_UConverter_getNextUChar_DBCS (UConverter * converter,
  271.                       const char **source,
  272.                       const char *sourceLimit,
  273.                       UErrorCode * err);
  274.  
  275. UChar T_UConverter_getNextUChar_MBCS (UConverter * converter,
  276.                       const char **source,
  277.                       const char *sourceLimit,
  278.                       UErrorCode * err);
  279.  
  280. UChar T_UConverter_getNextUChar_UTF8 (UConverter * converter,
  281.                       const char **source,
  282.                       const char *sourceLimit,
  283.                       UErrorCode * err);
  284.  
  285. UChar T_UConverter_getNextUChar_UTF16_BE (UConverter * converter,
  286.                       const char **source,
  287.                       const char *sourceLimit,
  288.                       UErrorCode * err);
  289.  
  290. UChar T_UConverter_getNextUChar_UTF16_LE (UConverter * converter,
  291.                       const char **source,
  292.                       const char *sourceLimit,
  293.                       UErrorCode * err);
  294.  
  295.  
  296. UChar T_UConverter_getNextUChar_EBCDIC_STATEFUL (UConverter * converter,
  297.                          const char **source,
  298.                          const char *sourceLimit,
  299.                          UErrorCode * err);
  300.  
  301. UChar T_UConverter_getNextUChar_ISO_2022 (UConverter * converter,
  302.                       const char **source,
  303.                       const char *sourceLimit,
  304.                       UErrorCode * err);
  305.  
  306. #endif /* UCNV_CNV */
  307.