LCOV - code coverage report
Current view: top level - Modules/cjkcodecs - cjkcodecs.h (source / functions) Hit Total Coverage
Test: CPython lcov report Lines: 59 76 77.6 %
Date: 2022-07-07 18:19:46 Functions: 6 6 100.0 %

          Line data    Source code
       1             : /*
       2             :  * cjkcodecs.h: common header for cjkcodecs
       3             :  *
       4             :  * Written by Hye-Shik Chang <perky@FreeBSD.org>
       5             :  */
       6             : 
       7             : #ifndef _CJKCODECS_H_
       8             : #define _CJKCODECS_H_
       9             : 
      10             : #define PY_SSIZE_T_CLEAN
      11             : #include "Python.h"
      12             : #include "multibytecodec.h"
      13             : 
      14             : 
      15             : /* a unicode "undefined" code point */
      16             : #define UNIINV  0xFFFE
      17             : 
      18             : /* internal-use DBCS code points which aren't used by any charsets */
      19             : #define NOCHAR  0xFFFF
      20             : #define MULTIC  0xFFFE
      21             : #define DBCINV  0xFFFD
      22             : 
      23             : /* shorter macros to save source size of mapping tables */
      24             : #define U UNIINV
      25             : #define N NOCHAR
      26             : #define M MULTIC
      27             : #define D DBCINV
      28             : 
      29             : struct dbcs_index {
      30             :     const ucs2_t *map;
      31             :     unsigned char bottom, top;
      32             : };
      33             : typedef struct dbcs_index decode_map;
      34             : 
      35             : struct widedbcs_index {
      36             :     const Py_UCS4 *map;
      37             :     unsigned char bottom, top;
      38             : };
      39             : typedef struct widedbcs_index widedecode_map;
      40             : 
      41             : struct unim_index {
      42             :     const DBCHAR *map;
      43             :     unsigned char bottom, top;
      44             : };
      45             : typedef struct unim_index encode_map;
      46             : 
      47             : struct unim_index_bytebased {
      48             :     const unsigned char *map;
      49             :     unsigned char bottom, top;
      50             : };
      51             : 
      52             : struct dbcs_map {
      53             :     const char *charset;
      54             :     const struct unim_index *encmap;
      55             :     const struct dbcs_index *decmap;
      56             : };
      57             : 
      58             : struct pair_encodemap {
      59             :     Py_UCS4 uniseq;
      60             :     DBCHAR code;
      61             : };
      62             : 
      63             : static const MultibyteCodec *codec_list;
      64             : static const struct dbcs_map *mapping_list;
      65             : 
      66             : #define CODEC_INIT(encoding)                                            \
      67             :     static int encoding##_codec_init(const void *config)
      68             : 
      69             : #define ENCODER_INIT(encoding)                                          \
      70             :     static int encoding##_encode_init(                                  \
      71             :         MultibyteCodec_State *state, const void *config)
      72             : #define ENCODER(encoding)                                               \
      73             :     static Py_ssize_t encoding##_encode(                                \
      74             :         MultibyteCodec_State *state, const void *config,                \
      75             :         int kind, const void *data,                                     \
      76             :         Py_ssize_t *inpos, Py_ssize_t inlen,                            \
      77             :         unsigned char **outbuf, Py_ssize_t outleft, int flags)
      78             : #define ENCODER_RESET(encoding)                                         \
      79             :     static Py_ssize_t encoding##_encode_reset(                          \
      80             :         MultibyteCodec_State *state, const void *config,                \
      81             :         unsigned char **outbuf, Py_ssize_t outleft)
      82             : 
      83             : #define DECODER_INIT(encoding)                                          \
      84             :     static int encoding##_decode_init(                                  \
      85             :         MultibyteCodec_State *state, const void *config)
      86             : #define DECODER(encoding)                                               \
      87             :     static Py_ssize_t encoding##_decode(                                \
      88             :         MultibyteCodec_State *state, const void *config,                \
      89             :         const unsigned char **inbuf, Py_ssize_t inleft,                 \
      90             :         _PyUnicodeWriter *writer)
      91             : #define DECODER_RESET(encoding)                                         \
      92             :     static Py_ssize_t encoding##_decode_reset(                          \
      93             :         MultibyteCodec_State *state, const void *config)
      94             : 
      95             : #define NEXT_IN(i)                              \
      96             :     do {                                        \
      97             :         (*inbuf) += (i);                        \
      98             :         (inleft) -= (i);                        \
      99             :     } while (0)
     100             : #define NEXT_INCHAR(i)                          \
     101             :     do {                                        \
     102             :         (*inpos) += (i);                        \
     103             :     } while (0)
     104             : #define NEXT_OUT(o)                             \
     105             :     do {                                        \
     106             :         (*outbuf) += (o);                       \
     107             :         (outleft) -= (o);                       \
     108             :     } while (0)
     109             : #define NEXT(i, o)                              \
     110             :     do {                                        \
     111             :         NEXT_INCHAR(i);                         \
     112             :         NEXT_OUT(o);                            \
     113             :     } while (0)
     114             : 
     115             : #define REQUIRE_INBUF(n)                        \
     116             :     do {                                        \
     117             :         if (inleft < (n))                       \
     118             :             return MBERR_TOOFEW;                \
     119             :     } while (0)
     120             : 
     121             : #define REQUIRE_OUTBUF(n)                       \
     122             :     do {                                        \
     123             :         if (outleft < (n))                      \
     124             :             return MBERR_TOOSMALL;              \
     125             :     } while (0)
     126             : 
     127             : #define INBYTE1 ((*inbuf)[0])
     128             : #define INBYTE2 ((*inbuf)[1])
     129             : #define INBYTE3 ((*inbuf)[2])
     130             : #define INBYTE4 ((*inbuf)[3])
     131             : 
     132             : #define INCHAR1 (PyUnicode_READ(kind, data, *inpos))
     133             : #define INCHAR2 (PyUnicode_READ(kind, data, *inpos + 1))
     134             : 
     135             : #define OUTCHAR(c)                                                         \
     136             :     do {                                                                   \
     137             :         if (_PyUnicodeWriter_WriteChar(writer, (c)) < 0)                   \
     138             :             return MBERR_EXCEPTION;                                         \
     139             :     } while (0)
     140             : 
     141             : #define OUTCHAR2(c1, c2)                                                   \
     142             :     do {                                                                   \
     143             :         Py_UCS4 _c1 = (c1);                                                \
     144             :         Py_UCS4 _c2 = (c2);                                                \
     145             :         if (_PyUnicodeWriter_Prepare(writer, 2, Py_MAX(_c1, c2)) < 0)      \
     146             :             return MBERR_EXCEPTION;                                        \
     147             :         PyUnicode_WRITE(writer->kind, writer->data, writer->pos, _c1);     \
     148             :         PyUnicode_WRITE(writer->kind, writer->data, writer->pos + 1, _c2); \
     149             :         writer->pos += 2;                                                  \
     150             :     } while (0)
     151             : 
     152             : #define OUTBYTEI(c, i)                     \
     153             :     do {                                   \
     154             :         assert((unsigned char)(c) == (c)); \
     155             :         ((*outbuf)[i]) = (c);              \
     156             :     } while (0)
     157             : 
     158             : #define OUTBYTE1(c) OUTBYTEI(c, 0)
     159             : #define OUTBYTE2(c) OUTBYTEI(c, 1)
     160             : #define OUTBYTE3(c) OUTBYTEI(c, 2)
     161             : #define OUTBYTE4(c) OUTBYTEI(c, 3)
     162             : 
     163             : #define WRITEBYTE1(c1)              \
     164             :     do {                            \
     165             :         REQUIRE_OUTBUF(1);          \
     166             :         OUTBYTE1(c1);               \
     167             :     } while (0)
     168             : #define WRITEBYTE2(c1, c2)          \
     169             :     do {                            \
     170             :         REQUIRE_OUTBUF(2);          \
     171             :         OUTBYTE1(c1);               \
     172             :         OUTBYTE2(c2);               \
     173             :     } while (0)
     174             : #define WRITEBYTE3(c1, c2, c3)      \
     175             :     do {                            \
     176             :         REQUIRE_OUTBUF(3);          \
     177             :         OUTBYTE1(c1);               \
     178             :         OUTBYTE2(c2);               \
     179             :         OUTBYTE3(c3);               \
     180             :     } while (0)
     181             : #define WRITEBYTE4(c1, c2, c3, c4)  \
     182             :     do {                            \
     183             :         REQUIRE_OUTBUF(4);          \
     184             :         OUTBYTE1(c1);               \
     185             :         OUTBYTE2(c2);               \
     186             :         OUTBYTE3(c3);               \
     187             :         OUTBYTE4(c4);               \
     188             :     } while (0)
     189             : 
     190             : #define _TRYMAP_ENC(m, assi, val)                               \
     191             :     ((m)->map != NULL && (val) >= (m)->bottom &&                \
     192             :         (val)<= (m)->top && ((assi) = (m)->map[(val) -          \
     193             :         (m)->bottom]) != NOCHAR)
     194             : #define TRYMAP_ENC(charset, assi, uni)                     \
     195             :     _TRYMAP_ENC(&charset##_encmap[(uni) >> 8], assi, (uni) & 0xff)
     196             : 
     197             : #define _TRYMAP_DEC(m, assi, val)                             \
     198             :     ((m)->map != NULL &&                                        \
     199             :      (val) >= (m)->bottom &&                                    \
     200             :      (val)<= (m)->top &&                                        \
     201             :      ((assi) = (m)->map[(val) - (m)->bottom]) != UNIINV)
     202             : #define TRYMAP_DEC(charset, assi, c1, c2)                     \
     203             :     _TRYMAP_DEC(&charset##_decmap[c1], assi, c2)
     204             : 
     205             : #define BEGIN_MAPPINGS_LIST static const struct dbcs_map _mapping_list[] = {
     206             : #define MAPPING_ENCONLY(enc) {#enc, (void*)enc##_encmap, NULL},
     207             : #define MAPPING_DECONLY(enc) {#enc, NULL, (void*)enc##_decmap},
     208             : #define MAPPING_ENCDEC(enc) {#enc, (void*)enc##_encmap, (void*)enc##_decmap},
     209             : #define END_MAPPINGS_LIST                               \
     210             :     {"", NULL, NULL} };                                 \
     211             :     static const struct dbcs_map *mapping_list =        \
     212             :         (const struct dbcs_map *)_mapping_list;
     213             : 
     214             : #define BEGIN_CODECS_LIST static const MultibyteCodec _codec_list[] = {
     215             : #define _STATEFUL_METHODS(enc)          \
     216             :     enc##_encode,                       \
     217             :     enc##_encode_init,                  \
     218             :     enc##_encode_reset,                 \
     219             :     enc##_decode,                       \
     220             :     enc##_decode_init,                  \
     221             :     enc##_decode_reset,
     222             : #define _STATELESS_METHODS(enc)         \
     223             :     enc##_encode, NULL, NULL,           \
     224             :     enc##_decode, NULL, NULL,
     225             : #define CODEC_STATEFUL(enc) {           \
     226             :     #enc, NULL, NULL,                   \
     227             :     _STATEFUL_METHODS(enc)              \
     228             : },
     229             : #define CODEC_STATELESS(enc) {          \
     230             :     #enc, NULL, NULL,                   \
     231             :     _STATELESS_METHODS(enc)             \
     232             : },
     233             : #define CODEC_STATELESS_WINIT(enc) {    \
     234             :     #enc, NULL,                         \
     235             :     enc##_codec_init,                   \
     236             :     _STATELESS_METHODS(enc)             \
     237             : },
     238             : #define END_CODECS_LIST                                 \
     239             :     {"", NULL,} };                                      \
     240             :     static const MultibyteCodec *codec_list =           \
     241             :         (const MultibyteCodec *)_codec_list;
     242             : 
     243             : 
     244             : 
     245             : static PyObject *
     246         142 : getmultibytecodec(void)
     247             : {
     248         142 :     return _PyImport_GetModuleAttrString("_multibytecodec", "__create_codec");
     249             : }
     250             : 
     251             : static PyObject *
     252         142 : getcodec(PyObject *self, PyObject *encoding)
     253             : {
     254             :     PyObject *codecobj, *r, *cofunc;
     255             :     const MultibyteCodec *codec;
     256             :     const char *enc;
     257             : 
     258         142 :     if (!PyUnicode_Check(encoding)) {
     259           0 :         PyErr_SetString(PyExc_TypeError,
     260             :                         "encoding name must be a string.");
     261           0 :         return NULL;
     262             :     }
     263         142 :     enc = PyUnicode_AsUTF8(encoding);
     264         142 :     if (enc == NULL)
     265           0 :         return NULL;
     266             : 
     267         142 :     cofunc = getmultibytecodec();
     268         142 :     if (cofunc == NULL)
     269           0 :         return NULL;
     270             : 
     271         421 :     for (codec = codec_list; codec->encoding[0]; codec++)
     272         421 :         if (strcmp(codec->encoding, enc) == 0)
     273         142 :             break;
     274             : 
     275         142 :     if (codec->encoding[0] == '\0') {
     276           0 :         PyErr_SetString(PyExc_LookupError,
     277             :                         "no such codec is supported.");
     278           0 :         return NULL;
     279             :     }
     280             : 
     281         142 :     codecobj = PyCapsule_New((void *)codec, PyMultibyteCodec_CAPSULE_NAME, NULL);
     282         142 :     if (codecobj == NULL)
     283           0 :         return NULL;
     284             : 
     285         142 :     r = PyObject_CallOneArg(cofunc, codecobj);
     286         142 :     Py_DECREF(codecobj);
     287         142 :     Py_DECREF(cofunc);
     288             : 
     289         142 :     return r;
     290             : }
     291             : 
     292             : 
     293             : static int
     294          58 : register_maps(PyObject *module)
     295             : {
     296             :     const struct dbcs_map *h;
     297             : 
     298         319 :     for (h = mapping_list; h->charset[0] != '\0'; h++) {
     299         261 :         char mhname[256] = "__map_";
     300         261 :         strcpy(mhname + sizeof("__map_") - 1, h->charset);
     301             : 
     302         261 :         PyObject *capsule = PyCapsule_New((void *)h,
     303             :                                           PyMultibyteCodec_CAPSULE_NAME, NULL);
     304         261 :         if (capsule == NULL) {
     305           0 :             return -1;
     306             :         }
     307         261 :         if (PyModule_AddObject(module, mhname, capsule) < 0) {
     308           0 :             Py_DECREF(capsule);
     309           0 :             return -1;
     310             :         }
     311             :     }
     312          58 :     return 0;
     313             : }
     314             : 
     315             : #ifdef USING_BINARY_PAIR_SEARCH
     316             : static DBCHAR
     317       17503 : find_pairencmap(ucs2_t body, ucs2_t modifier,
     318             :                 const struct pair_encodemap *haystack, int haystacksize)
     319             : {
     320             :     int pos, min, max;
     321       17503 :     Py_UCS4 value = body << 16 | modifier;
     322             : 
     323       17503 :     min = 0;
     324       17503 :     max = haystacksize;
     325             : 
     326      104028 :     for (pos = haystacksize >> 1; min != max; pos = (min + max) >> 1) {
     327      104028 :         if (value < haystack[pos].uniseq) {
     328       35037 :             if (max != pos) {
     329       35037 :                 max = pos;
     330       35037 :                 continue;
     331             :             }
     332             :         }
     333       68991 :         else if (value > haystack[pos].uniseq) {
     334       59753 :             if (min != pos) {
     335       51488 :                 min = pos;
     336       51488 :                 continue;
     337             :             }
     338             :         }
     339       17503 :         break;
     340             :     }
     341             : 
     342       17503 :     if (value == haystack[pos].uniseq) {
     343        9238 :         return haystack[pos].code;
     344             :     }
     345        8265 :     return DBCINV;
     346             : }
     347             : #endif
     348             : 
     349             : #ifdef USING_IMPORTED_MAPS
     350             : #define IMPORT_MAP(locale, charset, encmap, decmap) \
     351             :     importmap("_codecs_" #locale, "__map_" #charset, \
     352             :               (const void**)encmap, (const void**)decmap)
     353             : 
     354             : static int
     355          76 : importmap(const char *modname, const char *symbol,
     356             :           const void **encmap, const void **decmap)
     357             : {
     358             :     PyObject *o, *mod;
     359             : 
     360          76 :     mod = PyImport_ImportModule(modname);
     361          76 :     if (mod == NULL)
     362           0 :         return -1;
     363             : 
     364          76 :     o = PyObject_GetAttrString(mod, symbol);
     365          76 :     if (o == NULL)
     366           0 :         goto errorexit;
     367          76 :     else if (!PyCapsule_IsValid(o, PyMultibyteCodec_CAPSULE_NAME)) {
     368           0 :         PyErr_SetString(PyExc_ValueError,
     369             :                         "map data must be a Capsule.");
     370           0 :         goto errorexit;
     371             :     }
     372             :     else {
     373             :         struct dbcs_map *map;
     374          76 :         map = PyCapsule_GetPointer(o, PyMultibyteCodec_CAPSULE_NAME);
     375          76 :         if (encmap != NULL)
     376          39 :             *encmap = map->encmap;
     377          76 :         if (decmap != NULL)
     378          47 :             *decmap = map->decmap;
     379          76 :         Py_DECREF(o);
     380             :     }
     381             : 
     382          76 :     Py_DECREF(mod);
     383          76 :     return 0;
     384             : 
     385           0 : errorexit:
     386           0 :     Py_DECREF(mod);
     387           0 :     return -1;
     388             : }
     389             : #endif
     390             : 
     391             : static int
     392          58 : _cjk_exec(PyObject *module)
     393             : {
     394          58 :     return register_maps(module);
     395             : }
     396             : 
     397             : 
     398             : static struct PyMethodDef _cjk_methods[] = {
     399             :     {"getcodec", (PyCFunction)getcodec, METH_O, ""},
     400             :     {NULL, NULL},
     401             : };
     402             : 
     403             : static PyModuleDef_Slot _cjk_slots[] = {
     404             :     {Py_mod_exec, _cjk_exec},
     405             :     {0, NULL}
     406             : };
     407             : 
     408             : #define I_AM_A_MODULE_FOR(loc)                                          \
     409             :     static struct PyModuleDef _cjk_module = {                           \
     410             :         PyModuleDef_HEAD_INIT,                                          \
     411             :         .m_name = "_codecs_"#loc,                                       \
     412             :         .m_size = 0,                                                    \
     413             :         .m_methods = _cjk_methods,                                      \
     414             :         .m_slots = _cjk_slots,                                          \
     415             :     };                                                                  \
     416             :                                                                         \
     417             :     PyMODINIT_FUNC                                                      \
     418             :     PyInit__codecs_##loc(void)                                          \
     419             :     {                                                                   \
     420             :         return PyModuleDef_Init(&_cjk_module);                          \
     421             :     }
     422             : 
     423             : #endif

Generated by: LCOV version 1.14