Changeset 30 for trunk/pymigemo


Ignore:
Timestamp:
11/06/09 01:15:56 (14 years ago)
Author:
atzm
Message:

modified indentation

Location:
trunk/pymigemo
Files:
1 added
1 edited
1 moved

Legend:

Unmodified
Added
Removed
  • trunk/pymigemo/README.ja_JP.UTF-8

    r28 r30  
    1 PyMigemo 0.1 
    2 ============ 
    3 Atzm WATANABE (10/12/'05) 
     1$Id$ 
    42 
    5 ã“れは䜕 
    6 ---------- 
    7 C/Migemo を Python から䜿うためのラッパヌです 
     3= これは䜕 = 
     4C/Migemo を Python から䜿うための wrapper です 
    85 
    9 å¿ 
    10 èŠãªã‚‚の 
    11 ---------- 
    12 C/Migemo ラむブラリがむンストヌルされおいるこずが 
    13 å‰æãšãªã£ãŠã„たすラむブラリ怜玢パスに migemo.so 
    14 ãŒïŒŒãƒ˜ãƒƒãƒ€æ€œçŽ¢ãƒ‘スに migemo.h が存圚するこずを確認 
    15 ã—お䞋さい 
    166 
    17 ã‚€ãƒ³ã‚¹ãƒˆãƒŒãƒ«æ–¹æ³• 
    18 ---------------- 
    19 åŒæ¢±ã® setup.py を利甚しお䞋さい 
     7= å¿ 
     8芁なもの = 
     9C/Migemo ラむブラリがむンストヌルされおいるこずが前提ずなっおいたす 
     10ラむブラリ怜玢パスに migemo.so がヘッダ怜玢パスに migemo.h が存圚するこずをご確認䞋さい 
    2011 
    21  $ ./setup.py build 
    22  # ./setup.py install 
    2312 
    24 ãƒ©ã‚€ã‚»ãƒ³ã‚¹ 
    25 ---------- 
    26 FreeBSD スタむルラむセンスに準拠したす 
     13= むンストヌル方法 = 
     14同梱の setup.py をご利甚䞋さい 
    2715 
    28 äœ¿ã„æ–¹ 
    29 ------ 
    30 Python むンタプリタ䞊で migemo を import しお䞋さい 
     16{{{ 
     17$ ./setup.py build 
     18# ./setup.py install 
     19}}} 
    3120 
    32 ãƒªãƒ•ã‚¡ãƒ¬ãƒ³ã‚¹ 
    33 - - - - - - - 
    34 ãƒ¢ã‚žãƒ¥ãƒŒãƒ«ã‚³ãƒ³ãƒ†ãƒ³ãƒ„ 
     21 
     22= ラむセンス = 
     23二条頠
     24 BSD ラむセンスに準拠したす 
     25詳现は同梱の LICENSE ファむルをご芧䞋さい 
     26 
     27 
     28= 䜿い方 = 
     29{{{ 
     30>>> import migemo 
     31>>> m = migemo.Migemo("/usr/share/migemo/migemo-dict") 
     32>>> print m.query("hoge") 
     33(hoge|
     34|ほげ|捕鯚|垆桁|補å 
     35ƒ|ホゲ) 
     36}}} 
     37 
     38 
     39== リファレンス == 
     40=== モゞュヌルコンテンツ === 
    3541 * VERSION 
    36     ** MIGEMO_VERSION 
    37         C/Migemo のバヌゞョン 
    38  
    39     ** PYMIGEMO_VERSION 
    40         PyMigemo のバヌゞョン 
     42   * MIGEMO_VERSION 
     43     * C/Migemo のバヌゞョン 
     44   * PYMIGEMO_VERSION 
     45     * PyMigemo のバヌゞョン 
    4146 
    4247 * DICTID 
    43     埌述の load メ゜ッドで䜿う蟞曞 ID 
    44  
    45     ** DICTID_MIGEMO 
    46         migemo-dict 蟞曞 
    47  
    48     ** DICTID_ROMA2HIRA 
    49         ロヌマ字→平仮名倉換衚 
    50  
    51     ** DICTID_HIRA2KATA 
    52         平仮名→カタカナ倉換衚 
    53  
    54     ** DICTID_HAN2ZEN 
    55         半角→å 
     48   * DICTID_MIGEMO 
     49     * migemo-dict 蟞曞 
     50   * DICTID_ROMA2HIRA 
     51     * ロヌマ字→平仮名倉換衚 
     52   * DICTID_HIRA2KATA 
     53     * 平仮名→カタカナ倉換衚 
     54   * DICTID_HAN2ZEN 
     55     * 半角→å 
    5656šè§’倉換衚 
    57  
    58     ** DICTID_ZEN2HAN 
    59         å 
     57   * DICTID_ZEN2HAN 
     58     * å 
    6059šè§’→半角倉換衚 
    61  
    62     ** DICTID_INVALID 
    63         load メ゜ッドで蟞曞の読み蟌みに倱敗した堎合に返る 
     60   * DICTID_INVALID 
     61     * load メ゜ッドで蟞曞の読み蟌みに倱敗した堎合に返る 
    6462 
    6563 * OPINDEX 
    66     埌述の Migemo.set_operatorMigemo.get_operator メ゜ッドで䜿う 
    67     むンデクス 
    68  
    69     ** OPINDEX_OR 
    70         論理和デフォルトは "|" 
    71  
    72     ** OPINDEX_NEST_IN 
    73         グルヌピング時の開き括匧 
    74         Migemo.get_operator() に枡した際のデフォルトは "(" 
    75  
    76     ** OPINDEX_NEST_OUT 
    77         グルヌピング時の閉じ括匧 
    78         Migemo.get_operator() に枡した際のデフォルトは ")" 
    79  
    80     ** OPINDEX_SELECT_IN 
    81         遞択の開始を衚す開き鈎括匧 
    82         Migemo.get_operator() に枡した際のデフォルトは "[" 
    83  
    84     ** OPINDEX_SELECT_OUT 
    85         遞択の終了を衚す閉じ鈎括匧 
    86         Migemo.get_operator() に枡した際のデフォルトは "]" 
    87  
    88     ** OPINDEX_NEWLINE 
    89         各文字の間に挿å 
    90 ¥ã•ã‚Œã‚‹ã€Œ0 個以䞊の空癜もしくは改行にマッチする」 
    91         パタヌン 
    92         Migemo.get_operator() に枡した際のデフォルトは "" (空文字列) 
     64   * OPINDEX_OR 
     65     * 論理和 
     66     * Migemo.get_operator() に枡した際のデフォルトは "|" 
     67   * OPINDEX_NEST_IN 
     68     * グルヌピング時の開き括匧 
     69     * Migemo.get_operator() に枡した際のデフォルトは "(" 
     70   * OPINDEX_NEST_OUT 
     71     * グルヌピング時の閉じ括匧 
     72     * Migemo.get_operator() に枡した際のデフォルトは ")" 
     73   * OPINDEX_SELECT_IN 
     74     * 遞択の開始を衚す開き鈎括匧 
     75     * Migemo.get_operator() に枡した際のデフォルトは "[" 
     76   * OPINDEX_SELECT_OUT 
     77     * 遞択の終了を衚す閉じ鈎括匧 
     78     * Migemo.get_operator() に枡した際のデフォルトは "]" 
     79   * OPINDEX_NEWLINE 
     80     * 各文字の間に挿å 
     81¥ã•ã‚Œã‚‹ã€Œ0 個以䞊の空癜もしくは改行にマッチする」パタヌン 
     82     * Migemo.get_operator() に枡した際のデフォルトは "" (空文字列) 
    9383 
    9484 * Migemo クラス 
    95     ** __init__(dictionary) 
    96         Migemo クラスのコンストラクタ 
    97         *** 匕数 
    98              dictionary: migemo-dict 蟞曞ファむルのパス (str) 
     85   * __init__(dictionary) 
     86     * Migemo クラスのコンストラクタ 
     87     * 匕数 
     88       * dictionary: migemo-dict 蟞曞ファむルのパス (str) 
     89   * get_encoding() 
     90     * migemo-dict 蟞曞の゚ンコヌディングを str で返す 
     91       äŸ‹ãˆã° EUC-JP で曞かれた蟞曞であれば "euc_jp" が返る 
     92       cp932euc_jputf8 のいずれかを返すが 
     93       èŸžæ›žã®ã‚šãƒ³ã‚³ãƒŒãƒ‡ã‚£ãƒ³ã‚°ãŒã“れらに該圓しなかった堎合は "ascii" を返す 
     94     * 匕数 
     95       * なし 
     96     * 返り倀 
     97       * ゚ンコヌディング文字列 (str) 
     98   * get_operator(index) 
     99     * index で指定された正芏衚珟に䜿甚するメタ文字を返す (str) 
     100     * 匕数 
     101       * index: 前述の OPINDEX のいずれか 
     102     * 返り倀 
     103       * メタ文字列 (str) 
     104   * is_enable() 
     105     * Migemo 冠
     106郚に正垞に蟞曞が読み蟌めおいるかどうかをチェックする 
     107     * 匕数 
     108       * なし 
     109     * 返り倀 
     110       * 真停倀 (int) : 正垞に読み蟌めおいる堎合に真 
     111   * load(dict_id, dict_file) 
     112     * Migemo オブゞェクトに蟞曞を远加で読み蟌む 
     113     * 匕数 
     114       * dict_id: 前述の DICTID のいずれか 
     115       * dict_file: 蟞曞ファむルのパス 
     116     * 返り倀 
     117       * 読み蟌んだ蟞曞の DICTID 
     118         èª­ã¿èŸŒã¿ã«å€±æ•—した堎合 DICTID_INVALID が返る 
     119   * query(query) 
     120     * query で䞎えられた文字列から日本語怜玢のための正芏衚珟を返す 
     121     * 匕数 
     122       * query: 問い合わせる文字列 (Unicode or str) 
     123         str で ascii 以倖の文字列を枡す堎合 
     124         èŸžæ›žãšåŒã˜ã‚šãƒ³ã‚³ãƒŒãƒ‡ã‚£ãƒ³ã‚°ã®æ–‡å­—列でないず゚ラヌになる可胜性がある 
     125     * 返り倀 
     126       * 正芏衚珟文字列 (Unicode) 
     127   * set_operator(index, op) 
     128     * index で指定された正芏衚珟に䜿甚するメタ文字を op に倉曎する 
     129     * 匕数 
     130       * index: 前述の OPINDEX のいずれか 
     131       * op: メタ文字列 (str) 
     132     * 返り倀 
     133       * 真停倀 (int) : 成功時に真 
    99134 
    100     ** get_encoding() 
    101         migemo-dict 蟞曞の゚ンコヌディングを str で返す 
    102         䟋えば EUC-JP で曞かれた蟞曞であれば "euc_jp" が返る 
    103         cp932euc_jputf8 のいずれかを返すが蟞曞の゚ンコヌディングがこ 
    104         れらに該圓しなかった堎合はファむルシステムのデフォルト゚ンコヌディ 
    105         ングを返す 
    106         *** 匕数 
    107              ãªã— 
    108         *** 返り倀 
    109              ã‚šãƒ³ã‚³ãƒŒãƒ‡ã‚£ãƒ³ã‚°æ–‡å­—列 (str) 
    110135 
    111     ** get_operator(index) 
    112         index で指定された正芏衚珟に䜿甚するメタ文字を返す (str) 
    113         *** 匕数 
    114              index: 前述の OPINDEX のいずれか 
    115         *** 返り倀 
    116              ãƒ¡ã‚¿æ–‡å­—列 (str) 
     136= その他 = 
     137本゜フトりェアに察するコメントバグ報告パッチなどは倧いに歓迎したす 
     138䞋蚘メヌルアドレスたでお気軜にお寄せ䞋さい 
    117139 
    118     ** is_enable() 
    119         Migemo 冠
    120 éƒšã«ïŒŒæ­£åžžã«èŸžæ›žãŒèª­ã¿èŸŒã‚ãŠã„るかどうかをチェックする 
    121         *** 匕数 
    122              ãªã— 
    123         *** 返り倀 
    124              çœŸåœå€€ (int) : 正垞に読み蟌めおいる堎合に真 
    125  
    126     ** load(dict_id, dict_file) 
    127         Migemo オブゞェクトに蟞曞を远加で読み蟌む 
    128         *** 匕数 
    129              dict_id: 前述の DICTID のいずれか 
    130              dict_file: 蟞曞ファむルのパス 
    131         *** 返り倀 
    132              èª­ã¿èŸŒã‚“だ蟞曞の DICTID 
    133              èª­ã¿èŸŒã¿ã«å€±æ•—した堎合 DICTID_INVALID が返る 
    134  
    135     ** query(query) 
    136         query で䞎えられた文字列から日本語怜玢のための正芏衚珟を返す 
    137         *** 匕数 
    138              query: 問い合わせる文字列 (Unicode or str) 
    139                     str で ascii 以倖の文字列を枡す堎合蟞曞ず同じ゚ン 
    140                     コヌディングの文字列でないず゚ラヌになる可胜性がある 
    141         *** 返り倀 
    142              æ­£èŠè¡šçŸæ–‡å­—列 (Unicode) 
    143  
    144     ** set_operator(index, op) 
    145         index で指定された正芏衚珟に䜿甚するメタ文字を op に倉曎する 
    146         *** 匕数 
    147              index: 前述の OPINDEX のいずれか 
    148              op: メタ文字列 (str) 
    149         *** 返り倀 
    150              çœŸåœå€€ (int) : 成功時に真 
    151  
    152 äœœè€ 
    153  
    154 ---- 
    155140Atzm WATANABE <atzm@atzm.org> 
    156  
    157 æœ¬ã‚œãƒ•ãƒˆã‚Šã‚§ã‚¢ã«å¯Ÿã™ã‚‹ã‚³ãƒ¡ãƒ³ãƒˆïŒŒãƒã‚°å ±å‘ŠïŒŒãƒ‘ッチなどは倧いに歓迎 
    158 ã—たす䞊蚘のメヌルアドレスたでお気軜にお寄せ䞋さい 
    159  
    160 $Id$ 
  • trunk/pymigemo/pymigemo.c

    r29 r30  
    11/* 
    22 * pymigemo.c - C/Migemo wrapper for Python 
    3  * Copyright(C) 2005, Atzm WATANABE <atzm@atzm.org> 
    4  * License: BSD-style 
     3 * Copyright(C) 2005-2009, Atzm WATANABE <atzm@atzm.org> 
    54 * 
    65 * $Id$ 
     
    87 
    98#include <Python.h> 
    10 #include "structmember.h" 
    11 #include "migemo.h" 
    12  
    13 #define PYMIGEMO_VERSION "0.1" 
     9#include <structmember.h> 
     10#include <migemo.h> 
     11#include <string.h> 
     12 
     13#define PYMIGEMO_VERSION "0.2" 
    1414 
    1515/* for dereference migemo object members */ 
    16 struct _migemo 
    17 { 
    18   int enable; 
    19   void *mtree; 
    20   int charset; 
    21   void *roma2hira; 
    22   void *hira2kata; 
    23   void *han2zen; 
    24   void *zen2han; 
    25   void *rx; 
    26   void *addword; 
    27   void *char2int; 
     16struct _migemo { 
     17    int   enable; 
     18    void *mtree; 
     19    int   charset; 
     20    void *roma2hira; 
     21    void *hira2kata; 
     22    void *han2zen; 
     23    void *zen2han; 
     24    void *rx; 
     25    void *addword; 
     26    void *char2int; 
    2827}; 
    2928 
    3029typedef struct { 
    31   PyObject_HEAD 
    32   migemo *migemo_obj; 
     30    PyObject_HEAD 
     31    migemo *migemo_obj; 
    3332} Migemo; 
    3433 
     
    3635Migemo_dealloc(Migemo *self) 
    3736{ 
    38   if (self->migemo_obj) 
    39     migemo_close(self->migemo_obj); 
    40  
    41   self->ob_type->tp_free((PyObject *)self); 
     37    if (self->migemo_obj) { 
     38        migemo_close(self->migemo_obj); 
     39    } 
     40 
     41    self->ob_type->tp_free((PyObject *)self); 
    4242} 
    4343 
     
    4545Migemo_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 
    4646{ 
    47   Migemo *self; 
    48  
    49   self = (Migemo *)type->tp_alloc(type, 0); 
    50   if (self != NULL) 
    51     self->migemo_obj = NULL; 
    52  
    53   return (PyObject *)self; 
     47    Migemo *self; 
     48 
     49    self = (Migemo *)type->tp_alloc(type, 0); 
     50 
     51    if (self != NULL) { 
     52        self->migemo_obj = NULL; 
     53    } 
     54 
     55    return (PyObject *)self; 
    5456} 
    5557 
     
    5759Migemo_init(Migemo *self, PyObject *args, PyObject *kwds) 
    5860{ 
    59   migemo *migemo_obj; 
    60   char *dictionary; 
    61   static char *kwlist[] = {"dictionary", NULL}; 
    62  
    63   if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &dictionary)) 
    64     return -1; 
    65  
    66   if (dictionary) { 
    67     if (self->migemo_obj) 
    68       migemo_close(self->migemo_obj); 
    69  
    70     migemo_obj = migemo_open(dictionary); 
    71  
    72     if (migemo_obj) 
    73       self->migemo_obj = migemo_obj; 
    74     else 
    75       return -1; 
    76   } 
    77  
    78   return 0; 
    79 } 
    80  
    81 const char * 
    82 get_encoding(int charset) 
    83 { 
    84   const char *encoding; 
    85  
    86   switch(charset) { 
    87   case 1: 
    88     encoding = "cp932"; 
    89     break; 
    90   case 2: 
    91     encoding = "euc_jp"; 
    92     break; 
    93   case 3: 
    94     encoding = "utf8"; 
    95     break; 
    96   default: 
    97     encoding = Py_FileSystemDefaultEncoding; 
    98   } 
    99  
    100   return encoding; 
     61    migemo *migemo_obj; 
     62    char   *dictionary; 
     63 
     64    static char *kwlist[] = {"dictionary", NULL}; 
     65 
     66    if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &dictionary)) { 
     67        return -1; 
     68    } 
     69 
     70    if (dictionary) { 
     71        if (self->migemo_obj) { 
     72            migemo_close(self->migemo_obj); 
     73        } 
     74 
     75        migemo_obj = migemo_open(dictionary); 
     76 
     77        if (migemo_obj) { 
     78            self->migemo_obj = migemo_obj; 
     79        } 
     80        else { 
     81            return -1; 
     82        } 
     83    } 
     84 
     85    return 0; 
     86} 
     87 
     88static int 
     89get_encoding(char *encoding, size_t size, int charset) 
     90{ 
     91    char *enc; 
     92 
     93    switch(charset) { 
     94    case 1: 
     95        enc = "cp932"; 
     96        break; 
     97    case 2: 
     98        enc = "euc_jp"; 
     99        break; 
     100    case 3: 
     101        enc = "utf_8"; 
     102        break; 
     103    default: 
     104        enc = "ascii"; 
     105    } 
     106 
     107    if (strlen(enc) < size) { 
     108        strcpy(encoding, enc); 
     109        return 1; 
     110    } 
     111 
     112    return 0; 
    101113} 
    102114 
     
    104116Migemo_get_encoding(Migemo *self) 
    105117{ 
    106   return Py_BuildValue("s", get_encoding(self->migemo_obj->charset)); 
     118    char encoding[7]; 
     119 
     120    if (!get_encoding(encoding, sizeof(encoding), self->migemo_obj->charset)) { 
     121        return NULL; 
     122    } 
     123 
     124    return PyString_FromString(encoding); 
    107125} 
    108126 
     
    110128Migemo_query(Migemo *self, PyObject *args, PyObject *kwds) 
    111129{ 
    112   PyObject *result, *query_obj; 
    113   static char *kwlist[] = {"query", NULL}; 
    114  
    115   const char *query, *encoding; 
    116   unsigned char *regex; 
    117   PyObject *query_str = NULL, *regex_strobj = NULL; 
    118  
    119   if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &query_obj)) 
    120     return NULL; 
    121  
    122   encoding = get_encoding(self->migemo_obj->charset); 
    123  
    124   if (PyUnicode_Check(query_obj)) { 
    125     query_str = PyUnicode_AsEncodedString(query_obj, encoding, "strict"); 
    126     query = PyString_AS_STRING(query_str); 
    127   } 
    128   else if (PyString_Check(query_obj)) 
    129     query = PyString_AS_STRING(query_obj); 
    130   else 
    131     return NULL; 
    132  
    133   if (query) { 
    134     regex = migemo_query(self->migemo_obj, query); 
    135  
    136     if (regex) { 
    137       regex_strobj = PyString_FromString(regex); 
    138  
    139       if (regex_strobj) 
    140         result = PyUnicode_FromEncodedObject(regex_strobj, encoding, "strict"); 
    141  
    142       migemo_release(self->migemo_obj, regex); 
    143     } 
    144   } 
    145  
    146   Py_XDECREF(regex_strobj); 
    147   Py_XDECREF(query_str); 
    148  
    149   if (!result) 
    150     return NULL; 
    151  
    152   return result; 
     130    PyObject      *result, *query_obj, *query_str = NULL, *regex_strobj = NULL; 
     131    char          *query, encoding[7]; 
     132    unsigned char *regex; 
     133 
     134    static char *kwlist[] = {"query", NULL}; 
     135 
     136    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &query_obj)) { 
     137        return NULL; 
     138    } 
     139 
     140    if (!get_encoding(encoding, sizeof(encoding), self->migemo_obj->charset)) { 
     141        return NULL; 
     142    } 
     143 
     144    if (PyUnicode_Check(query_obj)) { 
     145        query_str = PyUnicode_AsEncodedString(query_obj, encoding, "strict"); 
     146        query     = PyString_AS_STRING(query_str); 
     147    } 
     148    else if (PyString_Check(query_obj)) { 
     149        query = PyString_AS_STRING(query_obj); 
     150    } 
     151    else { 
     152        return NULL; 
     153    } 
     154 
     155    if (query) { 
     156        regex = migemo_query(self->migemo_obj, query); 
     157 
     158        if (regex) { 
     159            regex_strobj = PyString_FromString(regex); 
     160 
     161            if (regex_strobj) { 
     162                result = PyUnicode_FromEncodedObject(regex_strobj, encoding, "strict"); 
     163            } 
     164 
     165            migemo_release(self->migemo_obj, regex); 
     166        } 
     167    } 
     168 
     169    Py_XDECREF(regex_strobj); 
     170    Py_XDECREF(query_str); 
     171 
     172    if (!result) { 
     173        return NULL; 
     174    } 
     175 
     176    return result; 
    153177} 
    154178 
     
    156180Migemo_set_operator(Migemo *self, PyObject *args, PyObject *kwds) 
    157181{ 
    158   PyObject *result; 
    159   static char *kwlist[] = {"index", "op", NULL}; 
    160  
    161   int index; 
    162   char *op; 
     182    PyObject *result; 
     183    char     *op; 
     184    int       index; 
    163185   
    164   if (!PyArg_ParseTupleAndKeywords(args, kwds, "is", kwlist, &index, &op)) 
    165     return NULL; 
    166  
    167   if (op) 
    168     result = Py_BuildValue("i", migemo_set_operator(self->migemo_obj, index, op)); 
    169  
    170   if (!result) 
    171     return NULL; 
    172  
    173   return result; 
     186    static char *kwlist[] = {"index", "op", NULL}; 
     187 
     188    if (!PyArg_ParseTupleAndKeywords(args, kwds, "is", kwlist, &index, &op)) { 
     189        return NULL; 
     190    } 
     191 
     192    if (op) { 
     193        result = PyInt_FromLong((long)migemo_set_operator(self->migemo_obj, index, op)); 
     194    } 
     195 
     196    if (!result) { 
     197        return NULL; 
     198    } 
     199 
     200    return result; 
    174201} 
    175202 
     
    177204Migemo_get_operator(Migemo *self, PyObject *args, PyObject *kwds) 
    178205{ 
    179   PyObject *result; 
    180   static char *kwlist[] = {"index", NULL}; 
    181  
    182   int index; 
    183   const unsigned char *op; 
     206    PyObject      *result; 
     207    unsigned char *op; 
     208    int            index; 
    184209   
    185   if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &index)) 
    186     return NULL; 
    187  
    188   op = migemo_get_operator(self->migemo_obj, index); 
    189   result = Py_BuildValue("s", op); 
    190  
    191   if (!result) 
    192     return NULL; 
    193  
    194   return result; 
     210    static char *kwlist[] = {"index", NULL}; 
     211 
     212    if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &index)) { 
     213        return NULL; 
     214    } 
     215 
     216    if (op = migemo_get_operator(self->migemo_obj, index)) { 
     217        result = PyString_FromString(op); 
     218    } 
     219 
     220    if (!result) { 
     221        return NULL; 
     222    } 
     223 
     224    return result; 
    195225} 
    196226 
     
    198228Migemo_load(Migemo *self, PyObject *args, PyObject *kwds) 
    199229{ 
    200   PyObject *result; 
    201   static char *kwlist[] = {"dict_id", "dict_file", NULL}; 
    202  
    203   int dict_id; 
    204   const char *dict_file; 
     230    PyObject *result; 
     231    char     *dict_file; 
     232    int       dict_id; 
    205233   
    206   if (!PyArg_ParseTupleAndKeywords(args, kwds, "is", kwlist, &dict_id, &dict_file)) 
    207     return NULL; 
    208  
    209   if (dict_file) 
    210     result = Py_BuildValue("i", migemo_load(self->migemo_obj, dict_id, dict_file)); 
    211  
    212   if (!result) 
    213     return NULL; 
    214  
    215   return result; 
     234    static char *kwlist[] = {"dict_id", "dict_file", NULL}; 
     235 
     236    if (!PyArg_ParseTupleAndKeywords(args, kwds, "is", kwlist, &dict_id, &dict_file)) { 
     237        return NULL; 
     238    } 
     239 
     240    if (dict_file) { 
     241        result = PyInt_FromLong((long)migemo_load(self->migemo_obj, dict_id, dict_file)); 
     242    } 
     243 
     244    if (!result) { 
     245        return NULL; 
     246    } 
     247 
     248    return result; 
    216249} 
    217250 
     
    219252Migemo_is_enable(Migemo *self) 
    220253{ 
    221   return Py_BuildValue("i", migemo_is_enable(self->migemo_obj)); 
     254    return PyInt_FromLong((long)migemo_is_enable(self->migemo_obj)); 
    222255} 
    223256 
    224257static PyMethodDef Migemo_methods[] = { 
    225   {"query", (PyCFunction)Migemo_query, METH_KEYWORDS, 
    226    "return regex from romaji string\n\ 
     258    {"query", (PyCFunction)Migemo_query, METH_KEYWORDS, 
     259     "return regex from romaji string\n\ 
    227260\n\ 
    228261def query(query)\n\ 
     
    230263\n\ 
    231264  returns: regex string as Unicode object"}, 
    232   {"set_operator", (PyCFunction)Migemo_set_operator, METH_KEYWORDS, 
    233    "set operator string as the meta character of regex\n\ 
     265    {"set_operator", (PyCFunction)Migemo_set_operator, METH_KEYWORDS, 
     266     "set operator string as the meta character of regex\n\ 
    234267\n\ 
    235268def set_operator(index, op):\n\ 
     
    239272\n\ 
    240273  returns: boolean value"}, 
    241   {"get_operator", (PyCFunction)Migemo_get_operator, METH_KEYWORDS, 
    242    "get operator string as the meta character of regex\n\ 
     274    {"get_operator", (PyCFunction)Migemo_get_operator, METH_KEYWORDS, 
     275     "get operator string as the meta character of regex\n\ 
    243276\n\ 
    244277def get_operator(index)\n\ 
     
    247280\n\ 
    248281  returns: operator string (str)"}, 
    249   {"load", (PyCFunction)Migemo_load, METH_KEYWORDS, 
    250    "add dictionary to Migemo object\n\ 
     282    {"load", (PyCFunction)Migemo_load, METH_KEYWORDS, 
     283     "add dictionary to Migemo object\n\ 
    251284\n\ 
    252285def load(dict_id, dict_file)\n\ 
     
    256289\n\ 
    257290  returns: boolean value"}, 
    258   {"is_enable", (PyCFunction)Migemo_is_enable, METH_NOARGS, 
    259    "check internal migemo_dict\n\ 
     291    {"is_enable", (PyCFunction)Migemo_is_enable, METH_NOARGS, 
     292     "check internal migemo_dict\n\ 
    260293\n\ 
    261294def is_enable()\n\ 
    262295  returns: boolean value"}, 
    263   {"get_encoding", (PyCFunction)Migemo_get_encoding, METH_NOARGS, 
    264    "get dictionary encoding\n\ 
     296    {"get_encoding", (PyCFunction)Migemo_get_encoding, METH_NOARGS, 
     297     "get dictionary encoding\n\ 
    265298\n\ 
    266299def get_encoding()\n\ 
    267300  returns: encoding string (str)"}, 
    268   {NULL} /* Sentinel */ 
     301    {NULL} /* Sentinel */ 
    269302}; 
    270303 
    271304static PyMemberDef Migemo_members[] = { 
    272   {NULL} /* Sentinel */ 
     305    {NULL} /* Sentinel */ 
    273306}; 
    274307 
    275308static PyTypeObject MigemoType = { 
    276   PyObject_HEAD_INIT(NULL) 
    277   0,                          /*ob_size*/ 
    278   "migemo.Migemo",            /*tp_name*/ 
    279   sizeof(Migemo),             /*tp_basicsize*/ 
    280   0,                          /*tp_itemsize*/ 
    281   (destructor)Migemo_dealloc, /*tp_dealloc*/ 
    282   0,                          /*tp_print*/ 
    283   0,                          /*tp_getattr*/ 
    284   0,                          /*tp_setattr*/ 
    285   0,                          /*tp_compare*/ 
    286   0,                          /*tp_repr*/ 
    287   0,                          /*tp_as_number*/ 
    288   0,                          /*tp_as_sequence*/ 
    289   0,                          /*tp_as_mapping*/ 
    290   0,                          /*tp_hash */ 
    291   0,                          /*tp_call*/ 
    292   0,                          /*tp_str*/ 
    293   0,                          /*tp_getattro*/ 
    294   0,                          /*tp_setattro*/ 
    295   0,                          /*tp_as_buffer*/ 
    296   Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ 
    297   "Migemo wrapper object",    /* tp_doc */ 
    298   0,                          /* tp_traverse */ 
    299   0,                          /* tp_clear */ 
    300   0,                          /* tp_richcompare */ 
    301   0,                          /* tp_weaklistoffset */ 
    302   0,                          /* tp_iter */ 
    303   0,                          /* tp_iternext */ 
    304   Migemo_methods,             /* tp_methods */ 
    305   Migemo_members,             /* tp_members */ 
    306   0,                          /* tp_getset */ 
    307   0,                          /* tp_base */ 
    308   0,                          /* tp_dict */ 
    309   0,                          /* tp_descr_get */ 
    310   0,                          /* tp_descr_set */ 
    311   0,                          /* tp_dictoffset */ 
    312   (initproc)Migemo_init,      /* tp_init */ 
    313   0,                          /* tp_alloc */ 
    314   Migemo_new,                 /* tp_new */ 
     309    PyObject_HEAD_INIT(NULL) 
     310    0,                          /*ob_size*/ 
     311    "migemo.Migemo",            /*tp_name*/ 
     312    sizeof(Migemo),             /*tp_basicsize*/ 
     313    0,                          /*tp_itemsize*/ 
     314    (destructor)Migemo_dealloc, /*tp_dealloc*/ 
     315    0,                          /*tp_print*/ 
     316    0,                          /*tp_getattr*/ 
     317    0,                          /*tp_setattr*/ 
     318    0,                          /*tp_compare*/ 
     319    0,                          /*tp_repr*/ 
     320    0,                          /*tp_as_number*/ 
     321    0,                          /*tp_as_sequence*/ 
     322    0,                          /*tp_as_mapping*/ 
     323    0,                          /*tp_hash */ 
     324    0,                          /*tp_call*/ 
     325    0,                          /*tp_str*/ 
     326    0,                          /*tp_getattro*/ 
     327    0,                          /*tp_setattro*/ 
     328    0,                          /*tp_as_buffer*/ 
     329    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ 
     330    "Migemo wrapper object",    /* tp_doc */ 
     331    0,                          /* tp_traverse */ 
     332    0,                          /* tp_clear */ 
     333    0,                          /* tp_richcompare */ 
     334    0,                          /* tp_weaklistoffset */ 
     335    0,                          /* tp_iter */ 
     336    0,                          /* tp_iternext */ 
     337    Migemo_methods,             /* tp_methods */ 
     338    Migemo_members,             /* tp_members */ 
     339    0,                          /* tp_getset */ 
     340    0,                          /* tp_base */ 
     341    0,                          /* tp_dict */ 
     342    0,                          /* tp_descr_get */ 
     343    0,                          /* tp_descr_set */ 
     344    0,                          /* tp_dictoffset */ 
     345    (initproc)Migemo_init,      /* tp_init */ 
     346    0,                          /* tp_alloc */ 
     347    Migemo_new,                 /* tp_new */ 
    315348}; 
    316349 
    317350static PyMethodDef module_methods[] = { 
    318   {NULL} /* Sentinel */ 
     351    {NULL} /* Sentinel */ 
    319352}; 
    320353 
     
    325358initmigemo(void)  
    326359{ 
    327   PyObject* m; 
    328  
    329   if (PyType_Ready(&MigemoType) < 0) 
    330     return; 
    331  
    332   m = Py_InitModule3("migemo", module_methods, "C/Migemo wrapper"); 
    333  
    334   Py_INCREF(&MigemoType); 
    335   PyModule_AddObject(m, "Migemo", (PyObject *)&MigemoType); 
    336   PyModule_AddObject(m, "PYMIGEMO_VERSION", Py_BuildValue("s", PYMIGEMO_VERSION)); 
    337  
    338   PyModule_AddObject(m, "MIGEMO_VERSION", Py_BuildValue("s", MIGEMO_VERSION)); 
    339  
    340   PyModule_AddObject(m, "DICTID_INVALID", Py_BuildValue("i", MIGEMO_DICTID_INVALID)); 
    341   PyModule_AddObject(m, "DICTID_MIGEMO", Py_BuildValue("i", MIGEMO_DICTID_MIGEMO)); 
    342   PyModule_AddObject(m, "DICTID_ROMA2HIRA", Py_BuildValue("i", MIGEMO_DICTID_ROMA2HIRA)); 
    343   PyModule_AddObject(m, "DICTID_HIRA2KATA", Py_BuildValue("i", MIGEMO_DICTID_HIRA2KATA)); 
    344   PyModule_AddObject(m, "DICTID_HAN2ZEN", Py_BuildValue("i", MIGEMO_DICTID_HAN2ZEN)); 
    345   PyModule_AddObject(m, "DICTID_ZEN2HAN", Py_BuildValue("i", MIGEMO_DICTID_ZEN2HAN)); 
    346  
    347   PyModule_AddObject(m, "OPINDEX_OR", Py_BuildValue("i", MIGEMO_OPINDEX_OR)); 
    348   PyModule_AddObject(m, "OPINDEX_NEST_IN", Py_BuildValue("i", MIGEMO_OPINDEX_NEST_IN)); 
    349   PyModule_AddObject(m, "OPINDEX_NEST_OUT", Py_BuildValue("i", MIGEMO_OPINDEX_NEST_OUT)); 
    350   PyModule_AddObject(m, "OPINDEX_SELECT_IN", Py_BuildValue("i", MIGEMO_OPINDEX_SELECT_IN)); 
    351   PyModule_AddObject(m, "OPINDEX_SELECT_OUT", Py_BuildValue("i", MIGEMO_OPINDEX_SELECT_OUT)); 
    352   PyModule_AddObject(m, "OPINDEX_NEWLINE", Py_BuildValue("i", MIGEMO_OPINDEX_NEWLINE)); 
    353 } 
     360    PyObject* m; 
     361 
     362    if (PyType_Ready(&MigemoType) < 0) 
     363        return; 
     364 
     365    m = Py_InitModule3("migemo", module_methods, "C/Migemo wrapper"); 
     366 
     367    Py_INCREF(&MigemoType); 
     368    PyModule_AddObject(m, "Migemo", (PyObject *)&MigemoType); 
     369    PyModule_AddObject(m, "PYMIGEMO_VERSION", Py_BuildValue("s", PYMIGEMO_VERSION)); 
     370 
     371    PyModule_AddObject(m, "MIGEMO_VERSION", Py_BuildValue("s", MIGEMO_VERSION)); 
     372 
     373    PyModule_AddObject(m, "DICTID_INVALID", Py_BuildValue("i", MIGEMO_DICTID_INVALID)); 
     374    PyModule_AddObject(m, "DICTID_MIGEMO", Py_BuildValue("i", MIGEMO_DICTID_MIGEMO)); 
     375    PyModule_AddObject(m, "DICTID_ROMA2HIRA", Py_BuildValue("i", MIGEMO_DICTID_ROMA2HIRA)); 
     376    PyModule_AddObject(m, "DICTID_HIRA2KATA", Py_BuildValue("i", MIGEMO_DICTID_HIRA2KATA)); 
     377    PyModule_AddObject(m, "DICTID_HAN2ZEN", Py_BuildValue("i", MIGEMO_DICTID_HAN2ZEN)); 
     378    PyModule_AddObject(m, "DICTID_ZEN2HAN", Py_BuildValue("i", MIGEMO_DICTID_ZEN2HAN)); 
     379 
     380    PyModule_AddObject(m, "OPINDEX_OR", Py_BuildValue("i", MIGEMO_OPINDEX_OR)); 
     381    PyModule_AddObject(m, "OPINDEX_NEST_IN", Py_BuildValue("i", MIGEMO_OPINDEX_NEST_IN)); 
     382    PyModule_AddObject(m, "OPINDEX_NEST_OUT", Py_BuildValue("i", MIGEMO_OPINDEX_NEST_OUT)); 
     383    PyModule_AddObject(m, "OPINDEX_SELECT_IN", Py_BuildValue("i", MIGEMO_OPINDEX_SELECT_IN)); 
     384    PyModule_AddObject(m, "OPINDEX_SELECT_OUT", Py_BuildValue("i", MIGEMO_OPINDEX_SELECT_OUT)); 
     385    PyModule_AddObject(m, "OPINDEX_NEWLINE", Py_BuildValue("i", MIGEMO_OPINDEX_NEWLINE)); 
     386} 
Note: See TracChangeset for help on using the changeset viewer.