Changeset 227 for pymigemo


Ignore:
Timestamp:
11/10/12 21:20:12 (10 years ago)
Author:
atzm
Message:
  • fixed handle value bytes to unicode
Location:
pymigemo/trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • pymigemo/trunk/ChangeLog

    r226 r227  
     1*pymigemo-0.4 (10 Nov 2012) 
    122012-11-10  Atzm WATANABE  <atzm@atzm.org> 
    23 
    3         * pymigemo.c: Python3 API support 
     4        * pymigemo.c: Python3 support 
    45 
    56*pymigemo-0.3 (07 Nov 2010) 
  • pymigemo/trunk/README.rst

    r226 r227  
    3434ƒ|ホゲ) 
    3535 
    36 :meth:`Migemo.query` メ゜ッドに文字列を枡すず正芏衚珟が unicode で返りたす 
     36migemo-dict 蟞曞ファむルずå 
     37±ã« :class:`Migemo` クラスのオブゞェクトを生成し 
     38:meth:`Migemo.query` メ゜ッドに文字列を枡すず正芏衚珟が返りたす 
    3739この正芏衚珟を :mod:`re` ず組み合わせれば怜玢等の甚途に利甚するこずができたす 
    3840 
     
    5557   .. method:: query(query) 
    5658 
    57       *query* から正芏衚珟を unicode で返したす 
     59      *query* から正芏衚珟を返したす 
    5860      *query* は unicode でも゚ンコヌドされた文字列でも構いたせん 
    59       ただし *query* が文字列の堎合 
     61      ただし *query* が゚ンコヌドされた文字列の堎合 
    6062      その゚ンコヌディングが蟞曞の゚ンコヌディングず異なるず 
    6163      ゚ラヌずなる可胜性がありたす 
     
    9092   .. method:: get_encoding() 
    9193 
    92       読み蟌んだ蟞曞の゚ンコヌディングを文字列で返したす 
     94      読み蟌んだ蟞曞の゚ンコヌディングを返したす 
    9395      䟋えば EUC-JP で曞かれた蟞曞であれば ``'euc_jp'`` が返りたす 
    9496      ``'cp932'`` か ``'euc_jp'`` か ``'utf8'`` か ``'ascii'`` 
  • pymigemo/trunk/pymigemo.c

    r225 r227  
    4848 
    4949static bool 
    50 get_encoding(char *encoding, size_t size, int charset) 
    51 { 
    52     char *enc; 
     50get_encoding(unsigned char *encoding, size_t size, int charset) 
     51{ 
     52    unsigned char *enc; 
    5353 
    5454    switch(charset) { 
     
    7474} 
    7575 
     76static unsigned char * 
     77trans_string(PyObject *pystr, const unsigned char *encoding) 
     78{ 
     79    unsigned char *str; 
     80 
     81    if (PyUnicode_Check(pystr)) { 
     82        PyObject *tmp = PyUnicode_AsEncodedString(pystr, encoding, "strict"); 
     83 
     84        if (tmp == NULL) { 
     85            return NULL; 
     86        } 
     87 
     88        str = strdup(PyBytes_AS_STRING(tmp)); 
     89        Py_DECREF(tmp); 
     90 
     91        if (str == NULL) { 
     92            PyErr_NoMemory(); 
     93            return NULL; 
     94        } 
     95        return str; 
     96    } 
     97 
     98    if (PyBytes_Check(pystr)) { 
     99        if ((str = strdup(PyBytes_AS_STRING(pystr))) == NULL) { 
     100            PyErr_NoMemory(); 
     101            return NULL; 
     102        } 
     103        return str; 
     104    } 
     105 
     106    PyErr_SetString(PyExc_TypeError, "argument must be string"); 
     107    return NULL; 
     108} 
     109 
    76110static int 
    77 isloadable(const char *path) 
     111isloadable(const unsigned char *path) 
    78112{ 
    79113    struct stat st; 
     114 
    80115    int ret = 0; 
    81116    int fd  = open(path, O_RDONLY); 
     
    114149Migemo_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 
    115150{ 
    116     Migemo *self; 
    117  
    118     self = (Migemo *)type->tp_alloc(type, 0); 
     151    Migemo *self = (Migemo *)type->tp_alloc(type, 0); 
    119152 
    120153    if (self != NULL) { 
     
    128161Migemo_init(Migemo *self, PyObject *args, PyObject *kwds) 
    129162{ 
    130     migemo *migemo_obj; 
    131     char  *dictionary; 
     163    migemo        *migemo_obj; 
     164    unsigned char *dictionary; 
    132165 
    133166    static char *kwlist[] = {"dictionary", NULL}; 
     
    141174 
    142175        if (ret != 0) { 
    143             PyErr_SetString(PyExc_ValueError, strerror(ret)); 
     176            PyErr_SetString(PyExc_OSError, strerror(ret)); 
    144177            return -1; 
    145178        } 
     
    166199Migemo_get_encoding(Migemo *self) 
    167200{ 
    168     char encoding[7]; 
     201    unsigned char encoding[7]; 
    169202 
    170203    if (!get_encoding(encoding, sizeof(encoding), self->migemo_obj->charset)) { 
     
    173206    } 
    174207 
    175     return PyBytes_FromString(encoding); 
     208    return PyUnicode_FromString(encoding); 
    176209} 
    177210 
     
    180213{ 
    181214    PyObject      *result, *pyquery, *pyrestr; 
    182     char          encoding[7], *query = NULL; 
    183     unsigned char *regex; 
     215    unsigned char *query, *regex, encoding[7]; 
    184216 
    185217    static char *kwlist[] = {"query", NULL}; 
     
    194226    } 
    195227 
    196     if (PyUnicode_Check(pyquery)) { 
    197         PyObject *q = PyUnicode_AsEncodedString(pyquery, encoding, "strict"); 
    198  
    199         if (q == NULL) { 
    200             return NULL; 
    201         } 
    202  
    203         query = strdup(PyBytes_AS_STRING(q)); 
    204         Py_DECREF(q); 
    205  
    206         if (query == NULL) { 
    207             return PyErr_NoMemory(); 
    208         } 
    209     } 
    210     else if (PyBytes_Check(pyquery)) { 
    211         query = strdup(PyBytes_AS_STRING(pyquery)); 
    212  
    213         if (query == NULL) { 
    214             return PyErr_NoMemory(); 
    215         } 
    216     } 
    217     else { 
    218         PyErr_SetString(PyExc_ValueError, "argument must be string"); 
     228    if ((query = trans_string(pyquery, encoding)) == NULL) { 
    219229        return NULL; 
    220230    } 
     
    241251Migemo_set_operator(Migemo *self, PyObject *args, PyObject *kwds) 
    242252{ 
    243     PyObject *result = NULL; 
    244     char     *op; 
    245     int       index; 
     253    PyObject      *result, *pyop; 
     254    unsigned char *op, encoding[7]; 
     255    int            index; 
    246256   
    247257    static char *kwlist[] = {"index", "op", NULL}; 
    248258 
    249     if (!PyArg_ParseTupleAndKeywords(args, kwds, "is", kwlist, &index, &op)) { 
    250         return NULL; 
    251     } 
    252  
    253     if (op) { 
    254         result = PyBool_FromLong((long)migemo_set_operator(self->migemo_obj, index, op)); 
    255     } 
    256  
     259    if (!PyArg_ParseTupleAndKeywords(args, kwds, "iO", kwlist, &index, &pyop)) { 
     260        return NULL; 
     261    } 
     262 
     263    if (!get_encoding(encoding, sizeof(encoding), self->migemo_obj->charset)) { 
     264        PyErr_SetString(PyExc_AssertionError, "get_encoding() failed"); 
     265        return NULL; 
     266    } 
     267 
     268    if ((op = trans_string(pyop, encoding)) == NULL) { 
     269        return NULL; 
     270    } 
     271 
     272    result = PyBool_FromLong((long)migemo_set_operator(self->migemo_obj, index, op)); 
     273    free(op); 
    257274    return result; 
    258275} 
     
    261278Migemo_get_operator(Migemo *self, PyObject *args, PyObject *kwds) 
    262279{ 
    263     PyObject            *result = NULL; 
     280    PyObject            *result; 
    264281    const unsigned char *op; 
     282    unsigned char        encoding[7]; 
    265283    int                  index; 
    266284   
     
    271289    } 
    272290 
     291    if (!get_encoding(encoding, sizeof(encoding), self->migemo_obj->charset)) { 
     292        PyErr_SetString(PyExc_AssertionError, "get_encoding() failed"); 
     293        return NULL; 
     294    } 
     295 
    273296    if (op = migemo_get_operator(self->migemo_obj, index)) { 
    274         result = PyBytes_FromString(op); 
    275     } 
    276     else { 
    277         PyErr_SetString(PyExc_ValueError, "invalid opindex"); 
    278     } 
    279  
    280     return result; 
     297        PyObject *tmp = PyBytes_FromString(op); 
     298 
     299        if (tmp == NULL) { 
     300            return NULL; 
     301        } 
     302 
     303        result = PyUnicode_FromEncodedObject(tmp, encoding, "strict"); 
     304        Py_DECREF(tmp); 
     305        return result; 
     306    } 
     307 
     308    PyErr_SetString(PyExc_ValueError, "invalid opindex"); 
     309    return NULL; 
    281310} 
    282311 
     
    284313Migemo_load(Migemo *self, PyObject *args, PyObject *kwds) 
    285314{ 
    286     PyObject *result = NULL; 
    287     char     *dict_file; 
    288     int       dict_id; 
     315    unsigned char *dict_file; 
     316    int            dict_id; 
    289317   
    290318    static char *kwlist[] = {"dict_id", "dict_file", NULL}; 
     
    298326 
    299327        if (ret != 0) { 
    300             PyErr_SetString(PyExc_ValueError, strerror(ret)); 
     328            PyErr_SetString(PyExc_OSError, strerror(ret)); 
    301329            return NULL; 
    302330        } 
    303331 
    304         result = PyLong_FromLong((long)migemo_load(self->migemo_obj, dict_id, dict_file)); 
    305     } 
    306  
    307     return result; 
     332        return PyLong_FromLong((long)migemo_load(self->migemo_obj, dict_id, dict_file)); 
     333    } 
     334 
     335    PyErr_SetString(PyExc_AssertionError, "dict_file is NULL"); 
     336    return NULL; 
    308337} 
    309338 
     
    316345static PyMethodDef Migemo_methods[] = { 
    317346    {"query", (PyCFunction)Migemo_query, METH_VARARGS | METH_KEYWORDS, 
    318      "return regex from romaji string\n\ 
     347     "return regex from string\n\ 
    319348\n\ 
    320349def query(query)\n\ 
    321   query: romaji string (str or unicode)\n\ 
    322 \n\ 
    323   returns: regex string as Unicode object"}, 
     350  query: string\n\ 
     351\n\ 
     352  returns: regex string"}, 
    324353    {"set_operator", (PyCFunction)Migemo_set_operator, METH_VARARGS | METH_KEYWORDS, 
    325354     "set operator string as the meta character of regex\n\ 
     
    328357  index: (OPINDEX_NEST_IN|OPINDEX_NEST_OUT|OPINDEX_NEWLINE|\n\ 
    329358          OPINDEX_OR|OPINDEX_SELECT_IN|OPINDEX_SELECT_OUT)\n\ 
    330   op: operator string (str)\n\ 
     359  op: operator string\n\ 
    331360\n\ 
    332361  returns: boolean value"}, 
     
    338367          OPINDEX_OR|OPINDEX_SELECT_IN|OPINDEX_SELECT_OUT)\n\ 
    339368\n\ 
    340   returns: operator string (str)"}, 
     369  returns: operator string"}, 
    341370    {"load", (PyCFunction)Migemo_load, METH_VARARGS | METH_KEYWORDS, 
    342371     "add dictionary to Migemo object\n\ 
     
    345374  dict_id: (DICTID_HAN2ZEN|DICTID_HIRA2KATA|DICTID_MIGEMO|\n\ 
    346375            DICTID_ROMA2HIRA|DICTID_ZEN2HAN)\n\ 
    347   dict_file: path to dictionary file (str)\n\ 
     376  dict_file: path to dictionary file\n\ 
    348377\n\ 
    349378  returns: ID of loaded dictionary"}, 
     
    357386\n\ 
    358387def get_encoding()\n\ 
    359   returns: encoding string (str)"}, 
     388  returns: encoding string"}, 
    360389    {NULL} /* Sentinel */ 
    361390}; 
  • pymigemo/trunk/setup.py

    r42 r227  
    55from distutils.core import setup, Extension 
    66setup(name="migemo", 
    7       version="0.3", 
     7      version="0.4", 
    88      description="C/Migemo Python binding", 
    99      author="Atzm WATANABE", 
Note: See TracChangeset for help on using the changeset viewer.