Annotation of embedaddon/php/ext/enchant/enchant.c, revision 1.1.1.5

1.1       misho       1: /*
                      2:   +----------------------------------------------------------------------+
                      3:   | PHP Version 5                                                        |
                      4:   +----------------------------------------------------------------------+
1.1.1.5 ! misho       5:   | Copyright (c) 1997-2014 The PHP Group                                |
1.1       misho       6:   +----------------------------------------------------------------------+
                      7:   | This source file is subject to version 3.0 of the PHP license,       |
                      8:   | that is bundled with this package in the file LICENSE, and is        |
                      9:   | available at through the world-wide-web at                           |
                     10:   | http://www.php.net/license/3_0.txt.                                  |
                     11:   | If you did not receive a copy of the PHP license and are unable to   |
                     12:   | obtain it through the world-wide-web, please send a note to          |
                     13:   | license@php.net so we can mail you a copy immediately.               |
                     14:   +----------------------------------------------------------------------+
                     15:   | Author: Pierre-Alain Joye <paj@pearfr.org>                           |
                     16:   |         Ilia Alshanetsky <ilia@prohost.org>                          |
                     17:   +----------------------------------------------------------------------+
                     18: 
1.1.1.5 ! misho      19:   $Id: 6de2feac8047059326b85565067ecdba8fb4f363 $
1.1       misho      20: */
                     21: 
                     22: #ifdef HAVE_CONFIG_H
                     23: #include "config.h"
                     24: #endif
                     25: 
                     26: #include "php.h"
                     27: #include "php_ini.h"
                     28: #include "ext/standard/info.h"
1.1.1.3   misho      29: #include <enchant.h>
1.1       misho      30: #include "php_enchant.h"
                     31: 
                     32: typedef EnchantBroker * EnchantBrokerPtr;
                     33: typedef struct _broker_struct enchant_broker;
                     34: typedef struct _dict_struct enchant_dict;
                     35: 
                     36: typedef enchant_broker * enchant_brokerPtr;
                     37: typedef enchant_dict * enchant_dictPtr;
                     38: 
                     39: typedef struct _broker_struct {
                     40:        EnchantBroker   *pbroker;
                     41:        enchant_dict    **dict;
                     42:        unsigned int    dictcnt;
                     43:        long                    rsrc_id;
                     44: } _enchant_broker;
                     45: 
                     46: typedef struct _dict_struct {
                     47:        unsigned int    id;
                     48:        EnchantDict             *pdict;
                     49:        enchant_broker  *pbroker;
                     50:        long                    rsrc_id;
                     51:        enchant_dict    *next;
                     52:        enchant_dict    *prev;
                     53: } _enchant_dict;
                     54: 
                     55: 
                     56: /* True global resources - no need for thread safety here */
                     57: static int le_enchant_broker;
                     58: static int le_enchant_dict;
                     59: 
                     60: /* If you declare any globals in php_enchant.h uncomment this:*/
                     61: /*ZEND_DECLARE_MODULE_GLOBALS(enchant)*/
                     62: 
                     63: #define PHP_ENCHANT_MYSPELL 1
                     64: #define PHP_ENCHANT_ISPELL 2
                     65: 
                     66: /* {{{ arginfo */
                     67: ZEND_BEGIN_ARG_INFO(arginfo_enchant_broker_init, 0)
                     68: ZEND_END_ARG_INFO()
                     69: 
                     70: ZEND_BEGIN_ARG_INFO_EX(arginfo_enchant_broker_free, 0, 0, 1)
                     71:        ZEND_ARG_INFO(0, broker)
                     72: ZEND_END_ARG_INFO()
                     73: 
                     74: ZEND_BEGIN_ARG_INFO_EX(arginfo_enchant_broker_set_dict_path, 0, 0, 3)
                     75:        ZEND_ARG_INFO(0, broker)
                     76:        ZEND_ARG_INFO(0, name)
                     77:        ZEND_ARG_INFO(0, value)
                     78: ZEND_END_ARG_INFO()
                     79: 
                     80: ZEND_BEGIN_ARG_INFO_EX(arginfo_enchant_broker_get_dict_path, 0, 0, 2)
                     81:        ZEND_ARG_INFO(0, broker)
                     82:        ZEND_ARG_INFO(0, name)
                     83: ZEND_END_ARG_INFO()
                     84: 
                     85: ZEND_BEGIN_ARG_INFO_EX(arginfo_enchant_broker_request_dict, 0, 0, 2)
                     86:        ZEND_ARG_INFO(0, broker)
                     87:        ZEND_ARG_INFO(0, tag)
                     88: ZEND_END_ARG_INFO()
                     89: 
                     90: ZEND_BEGIN_ARG_INFO_EX(arginfo_enchant_broker_request_pwl_dict, 0, 0, 2)
                     91:        ZEND_ARG_INFO(0, broker)
                     92:        ZEND_ARG_INFO(0, filename)
                     93: ZEND_END_ARG_INFO()
                     94: 
                     95: ZEND_BEGIN_ARG_INFO_EX(arginfo_enchant_broker_free_dict, 0, 0, 1)
                     96:        ZEND_ARG_INFO(0, dict)
                     97: ZEND_END_ARG_INFO()
                     98: 
                     99: ZEND_BEGIN_ARG_INFO_EX(arginfo_enchant_broker_set_ordering, 0, 0, 3)
                    100:        ZEND_ARG_INFO(0, broker)
                    101:        ZEND_ARG_INFO(0, tag)
                    102:        ZEND_ARG_INFO(0, ordering)
                    103: ZEND_END_ARG_INFO()
                    104: 
                    105: ZEND_BEGIN_ARG_INFO_EX(arginfo_enchant_dict_quick_check, 0, 0, 2)
                    106:        ZEND_ARG_INFO(0, dict)
                    107:        ZEND_ARG_INFO(0, word)
                    108:        ZEND_ARG_INFO(1, suggestions)
                    109: ZEND_END_ARG_INFO()
                    110: 
                    111: ZEND_BEGIN_ARG_INFO_EX(arginfo_enchant_dict_check, 0, 0, 2)
                    112:        ZEND_ARG_INFO(0, dict)
                    113:        ZEND_ARG_INFO(0, word)
                    114: ZEND_END_ARG_INFO()
                    115: 
                    116: ZEND_BEGIN_ARG_INFO_EX(arginfo_enchant_dict_store_replacement, 0, 0, 3)
                    117:        ZEND_ARG_INFO(0, dict)
                    118:        ZEND_ARG_INFO(0, mis)
                    119:        ZEND_ARG_INFO(0, cor)
                    120: ZEND_END_ARG_INFO()
                    121: /* }}} */
                    122: 
                    123: /* {{{ enchant_functions[]
                    124:  *
                    125:  * Every user visible function must have an entry in enchant_functions[].
                    126:  */
1.1.1.2   misho     127: zend_function_entry enchant_functions[] = {
1.1       misho     128:        PHP_FE(enchant_broker_init,                     arginfo_enchant_broker_init)
                    129:        PHP_FE(enchant_broker_free,                     arginfo_enchant_broker_free)
                    130:        PHP_FE(enchant_broker_get_error,                arginfo_enchant_broker_free)
                    131:        PHP_FE(enchant_broker_set_dict_path,    arginfo_enchant_broker_set_dict_path)
                    132:        PHP_FE(enchant_broker_get_dict_path,    arginfo_enchant_broker_get_dict_path)
                    133:        PHP_FE(enchant_broker_list_dicts,               arginfo_enchant_broker_free)
                    134:        PHP_FE(enchant_broker_request_dict,             arginfo_enchant_broker_request_dict)
                    135:        PHP_FE(enchant_broker_request_pwl_dict, arginfo_enchant_broker_request_pwl_dict)
                    136:        PHP_FE(enchant_broker_free_dict,                arginfo_enchant_broker_free_dict)
                    137:        PHP_FE(enchant_broker_dict_exists,              arginfo_enchant_broker_request_dict)
                    138:        PHP_FE(enchant_broker_set_ordering,     arginfo_enchant_broker_set_ordering)
                    139:        PHP_FE(enchant_broker_describe,                 arginfo_enchant_broker_free)
                    140:        PHP_FE(enchant_dict_check,                              arginfo_enchant_dict_check)
                    141:        PHP_FE(enchant_dict_suggest,                    arginfo_enchant_dict_check)
                    142:        PHP_FE(enchant_dict_add_to_personal,    arginfo_enchant_dict_check)
                    143:        PHP_FE(enchant_dict_add_to_session,     arginfo_enchant_dict_check)
                    144:        PHP_FE(enchant_dict_is_in_session,              arginfo_enchant_dict_check)
                    145:        PHP_FE(enchant_dict_store_replacement,  arginfo_enchant_dict_store_replacement)
                    146:        PHP_FE(enchant_dict_get_error,                  arginfo_enchant_broker_free_dict)
                    147:        PHP_FE(enchant_dict_describe,                   arginfo_enchant_broker_free_dict)
                    148:        PHP_FE(enchant_dict_quick_check,                arginfo_enchant_dict_quick_check)
                    149:        PHP_FE_END
                    150: };
                    151: /* }}} */
                    152: 
                    153: /* {{{ enchant_module_entry
                    154:  */
                    155: zend_module_entry enchant_module_entry = {
                    156: #if ZEND_MODULE_API_NO >= 20010901
                    157:        STANDARD_MODULE_HEADER,
                    158: #endif
                    159:        "enchant",
                    160:        enchant_functions,
                    161:        PHP_MINIT(enchant),
                    162:        PHP_MSHUTDOWN(enchant),
                    163:        NULL,   /* Replace with NULL if there's nothing to do at request start */
                    164:        NULL,   /* Replace with NULL if there's nothing to do at request end */
                    165:        PHP_MINFO(enchant),
                    166: #if ZEND_MODULE_API_NO >= 20010901
                    167:        PHP_ENCHANT_VERSION,
                    168: #endif
                    169:        STANDARD_MODULE_PROPERTIES
                    170: };
                    171: /* }}} */
                    172: 
                    173: #ifdef COMPILE_DL_ENCHANT
                    174: ZEND_GET_MODULE(enchant)
                    175: #endif
                    176: 
                    177: static void
                    178: enumerate_providers_fn (const char * const name,
                    179:                         const char * const desc,
                    180:                         const char * const file,
                    181:                         void * ud) /* {{{ */
                    182: {
                    183:        zval *zdesc = (zval *) ud;
                    184:        zval *tmp_array;
                    185: 
                    186:        MAKE_STD_ZVAL(tmp_array);
                    187:        array_init(tmp_array);
                    188: 
                    189:        add_assoc_string(tmp_array, "name", (char *)name, 1);
                    190:        add_assoc_string(tmp_array, "desc", (char *)desc, 1);
                    191:        add_assoc_string(tmp_array, "file", (char *)file, 1);
                    192: 
                    193:        if (Z_TYPE_P(zdesc)!=IS_ARRAY) {
                    194:                array_init(zdesc);
                    195:        }
                    196: 
                    197:        add_next_index_zval(zdesc, tmp_array);
                    198: }
                    199: /* }}} */
                    200: 
                    201: static void
                    202: describe_dict_fn (const char * const lang,
                    203:                   const char * const name,
                    204:                   const char * const desc,
                    205:                   const char * const file,
                    206:                   void * ud) /* {{{ */
                    207: {
                    208:        zval *zdesc = (zval *) ud;
                    209:        array_init(zdesc);
                    210:        add_assoc_string(zdesc, "lang", (char *)lang, 1);
                    211:        add_assoc_string(zdesc, "name", (char *)name, 1);
                    212:        add_assoc_string(zdesc, "desc", (char *)desc, 1);
                    213:        add_assoc_string(zdesc, "file", (char *)file, 1);
                    214: }
                    215: /* }}} */
                    216: 
                    217: static void php_enchant_list_dicts_fn( const char * const lang_tag,
                    218:                const char * const provider_name, const char * const provider_desc,
                    219:                const char * const provider_file, void * ud) /* {{{ */
                    220: {
                    221:        zval *zdesc = (zval *) ud;
                    222:        zval *tmp_array;
                    223: 
                    224:        MAKE_STD_ZVAL(tmp_array);
                    225:        array_init(tmp_array);
                    226:        add_assoc_string(tmp_array, "lang_tag", (char *)lang_tag, 1);
                    227:        add_assoc_string(tmp_array, "provider_name", (char *)provider_name, 1);
                    228:        add_assoc_string(tmp_array, "provider_desc", (char *)provider_desc, 1);
                    229:        add_assoc_string(tmp_array, "provider_file", (char *)provider_file, 1);
                    230: 
                    231:        if (Z_TYPE_P(zdesc) != IS_ARRAY) {
                    232:                array_init(zdesc);
                    233:        }
                    234:        add_next_index_zval(zdesc, tmp_array);
                    235: 
                    236: }
                    237: /* }}} */
                    238: 
                    239: static void php_enchant_broker_free(zend_rsrc_list_entry *rsrc TSRMLS_DC) /* {{{ */
                    240: {
                    241:        if (rsrc->ptr) {
                    242:                enchant_broker *broker = (enchant_broker *)rsrc->ptr;
                    243:                if (broker) {
                    244:                        if (broker->pbroker) {
                    245:                                if (broker->dictcnt && broker->dict) {
                    246:                                        if (broker->dict) {
1.1.1.2   misho     247:                                                int total;
                    248:                                                total = broker->dictcnt-1;
1.1       misho     249:                                                do {
                    250:                                                        zend_list_delete(broker->dict[total]->rsrc_id);
                    251:                                                        efree(broker->dict[total]);
                    252:                                                        total--;
                    253:                                                } while (total>=0);
                    254:                                        }
                    255:                                        efree(broker->dict);
                    256:                                        broker->dict = NULL;
                    257:                                }
                    258:                                enchant_broker_free(broker->pbroker);
                    259:                        }
                    260:                        efree(broker);
                    261:                }
                    262:        }
                    263: }
                    264: /* }}} */
                    265: 
                    266: static void php_enchant_dict_free(zend_rsrc_list_entry *rsrc TSRMLS_DC) /* {{{ */
                    267: 
                    268: {
                    269:        if (rsrc->ptr) {
                    270:                enchant_dict *pdict = (enchant_dict *)rsrc->ptr;
                    271:                if (pdict) {
                    272:                        if (pdict->pdict && pdict->pbroker) {
                    273:                                enchant_broker_free_dict(pdict->pbroker->pbroker, pdict->pdict);
                    274:                                if (pdict->id) {
                    275:                                        pdict->pbroker->dict[pdict->id-1]->next = NULL;
                    276:                                }
                    277:                                zend_list_delete(pdict->pbroker->rsrc_id);
                    278:                        }
                    279: 
                    280:                }
                    281:        }
                    282: }
                    283: /* }}} */
                    284: 
                    285: /* {{{ PHP_MINIT_FUNCTION
                    286:  */
                    287: PHP_MINIT_FUNCTION(enchant)
                    288: {
                    289:        le_enchant_broker = zend_register_list_destructors_ex(php_enchant_broker_free, NULL, "enchant_broker", module_number);
                    290:        le_enchant_dict = zend_register_list_destructors_ex(php_enchant_dict_free, NULL, "enchant_dict", module_number);
                    291:        REGISTER_LONG_CONSTANT("ENCHANT_MYSPELL", PHP_ENCHANT_MYSPELL, CONST_CS | CONST_PERSISTENT);
                    292:        REGISTER_LONG_CONSTANT("ENCHANT_ISPELL", PHP_ENCHANT_ISPELL, CONST_CS | CONST_PERSISTENT);
                    293:        return SUCCESS;
                    294: }
                    295: /* }}} */
                    296: 
                    297: /* {{{ PHP_MSHUTDOWN_FUNCTION
                    298:  */
                    299: PHP_MSHUTDOWN_FUNCTION(enchant)
                    300: {
                    301:        return SUCCESS;
                    302: }
                    303: /* }}} */
                    304: 
                    305: static void __enumerate_providers_fn (const char * const name,
                    306:                         const char * const desc,
                    307:                         const char * const file,
                    308:                         void * ud) /* {{{ */
                    309: {
                    310:        php_info_print_table_row(3, name, desc, file);
                    311: }
                    312: /* }}} */
                    313: 
                    314: /* {{{ PHP_MINFO_FUNCTION
                    315:  */
                    316: PHP_MINFO_FUNCTION(enchant)
                    317: {
                    318:        EnchantBroker *pbroker;
                    319: 
                    320:        pbroker = enchant_broker_init();
                    321:        php_info_print_table_start();
                    322:        php_info_print_table_header(2, "enchant support", "enabled");
                    323:        php_info_print_table_row(2, "Version", PHP_ENCHANT_VERSION);
                    324: #ifdef ENCHANT_VERSION_STRING
                    325:        php_info_print_table_row(2, "Libenchant Version", ENCHANT_VERSION_STRING);
                    326: #elif defined(HAVE_ENCHANT_BROKER_SET_PARAM)
                    327:        php_info_print_table_row(2, "Libenchant Version", "1.5.0 or later");
                    328: #endif
1.1.1.5 ! misho     329:        php_info_print_table_row(2, "Revision", "$Id: 6de2feac8047059326b85565067ecdba8fb4f363 $");
1.1       misho     330:        php_info_print_table_end();
                    331: 
                    332:        php_info_print_table_start();
                    333:        enchant_broker_describe(pbroker, __enumerate_providers_fn, NULL);
                    334:        php_info_print_table_end();
                    335:        enchant_broker_free(pbroker);
                    336: }
                    337: /* }}} */
                    338: 
                    339: #define PHP_ENCHANT_GET_BROKER \
                    340:        ZEND_FETCH_RESOURCE(pbroker, enchant_broker *, &broker, -1, "enchant_broker", le_enchant_broker);       \
                    341:        if (!pbroker || !pbroker->pbroker) {    \
                    342:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", "Resource broker invalid");   \
                    343:                RETURN_FALSE;   \
                    344:        }
                    345: 
                    346: #define PHP_ENCHANT_GET_DICT   \
                    347:        ZEND_FETCH_RESOURCE(pdict, enchant_dict *, &dict, -1, "enchant_dict", le_enchant_dict); \
                    348:        if (!pdict || !pdict->pdict) {  \
                    349:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", "Invalid dictionary resource.");      \
                    350:                RETURN_FALSE;   \
                    351:        }
                    352: 
                    353: /* {{{ proto resource enchant_broker_init()
                    354:    create a new broker object capable of requesting */
                    355: PHP_FUNCTION(enchant_broker_init)
                    356: {
                    357:        enchant_broker *broker;
                    358:        EnchantBroker *pbroker;
                    359: 
1.1.1.2   misho     360:        if (zend_parse_parameters_none() == FAILURE) {
                    361:                return;
1.1       misho     362:        }
                    363: 
                    364:        pbroker = enchant_broker_init();
                    365: 
                    366:        if (pbroker) {
                    367:                broker = (enchant_broker *) emalloc(sizeof(enchant_broker));
                    368:                broker->pbroker = pbroker;
                    369:                broker->dict = NULL;
                    370:                broker->dictcnt = 0;
                    371:                broker->rsrc_id = ZEND_REGISTER_RESOURCE(return_value, broker, le_enchant_broker);
                    372:        } else {
                    373:                RETURN_FALSE;
                    374:        }
                    375: }
                    376: /* }}} */
                    377: 
                    378: /* {{{ proto boolean enchant_broker_free(resource broker)
                    379:    Destroys the broker object and its dictionnaries */
                    380: PHP_FUNCTION(enchant_broker_free)
                    381: {
                    382:        zval *broker;
                    383:        enchant_broker *pbroker;
                    384: 
                    385:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &broker) == FAILURE) {
                    386:                RETURN_FALSE;
                    387:        }
                    388:        PHP_ENCHANT_GET_BROKER;
                    389: 
                    390:        zend_list_delete(Z_RESVAL_P(broker));
                    391:        RETURN_TRUE;
                    392: }
                    393: /* }}} */
                    394: 
                    395: /* {{{ proto string enchant_broker_get_error(resource broker)
                    396:    Returns the last error of the broker */
                    397: PHP_FUNCTION(enchant_broker_get_error)
                    398: {
                    399:        zval *broker;
                    400:        enchant_broker *pbroker;
                    401:        char *msg;
                    402: 
                    403:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &broker) == FAILURE) {
                    404:                RETURN_FALSE;
                    405:        }
                    406: 
                    407:        PHP_ENCHANT_GET_BROKER;
                    408: 
                    409:        msg = enchant_broker_get_error(pbroker->pbroker);
                    410:        if (msg) {
                    411:                RETURN_STRING((char *)msg, 1);
                    412:        }
                    413:        RETURN_FALSE;
                    414: }
                    415: /* }}} */
                    416: 
                    417: #if HAVE_ENCHANT_BROKER_SET_PARAM
                    418: /* {{{ proto bool enchant_broker_set_dict_path(resource broker, int dict_type, string value)
                    419:        Set the directory path for a given backend, works with ispell and myspell */
                    420: PHP_FUNCTION(enchant_broker_set_dict_path)
                    421: {
                    422:        zval *broker;
                    423:        enchant_broker *pbroker;
                    424:        long dict_type;
                    425:        char *value;
                    426:        int value_len;
                    427: 
                    428:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rls", &broker, &dict_type, &value, &value_len) == FAILURE) {
                    429:                RETURN_FALSE;
                    430:        }
                    431: 
                    432:        if (!value_len) {
                    433:                RETURN_FALSE;
                    434:        }
                    435:        
                    436:        PHP_ENCHANT_GET_BROKER;
                    437: 
                    438:        switch (dict_type) {
                    439:                case PHP_ENCHANT_MYSPELL:
                    440:                        PHP_ENCHANT_GET_BROKER;
                    441:                        enchant_broker_set_param(pbroker->pbroker, "enchant.myspell.dictionary.path", (const char *)value);
                    442:                        RETURN_TRUE;
                    443:                        break;
                    444: 
                    445:                case PHP_ENCHANT_ISPELL:
                    446:                        PHP_ENCHANT_GET_BROKER;
                    447:                        enchant_broker_set_param(pbroker->pbroker, "enchant.ispell.dictionary.path", (const char *)value);
                    448:                        RETURN_TRUE;
                    449:                        break;
                    450: 
                    451:                default:
                    452:                        RETURN_FALSE;
                    453:        }
                    454: }
                    455: /* }}} */
                    456: 
                    457: 
                    458: /* {{{ proto string enchant_broker_get_dict_path(resource broker, int dict_type)
                    459:        Get the directory path for a given backend, works with ispell and myspell */
                    460: PHP_FUNCTION(enchant_broker_get_dict_path)
                    461: {
                    462:        zval *broker;
                    463:        enchant_broker *pbroker;
                    464:        long dict_type;
                    465:        char *value;
                    466: 
                    467:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &broker, &dict_type) == FAILURE) {
                    468:                RETURN_FALSE;
                    469:        }
                    470:        
                    471:        PHP_ENCHANT_GET_BROKER;
                    472: 
                    473:        switch (dict_type) {
                    474:                case PHP_ENCHANT_MYSPELL:
                    475:                        PHP_ENCHANT_GET_BROKER;
                    476:                        value = enchant_broker_get_param(pbroker->pbroker, "enchant.myspell.dictionary.path");
                    477:                        break;
                    478: 
                    479:                case PHP_ENCHANT_ISPELL:
                    480:                        PHP_ENCHANT_GET_BROKER;
                    481:                        value = enchant_broker_get_param(pbroker->pbroker, "enchant.ispell.dictionary.path");
                    482:                        break;
                    483: 
                    484:                default:
                    485:                        RETURN_FALSE;
                    486:        }
                    487: 
                    488:        RETURN_STRING(value, 1);
                    489: }
                    490: /* }}} */
                    491: #else
                    492: /* {{{ proto bool enchant_broker_set_dict_path(resource broker, int dict_type, string value)
                    493:        Set the directory path for a given backend, works with ispell and myspell */
                    494: PHP_FUNCTION(enchant_broker_set_dict_path)
                    495: {
                    496:        RETURN_FALSE;
                    497: }
                    498: /* }}} */
                    499: 
                    500: 
                    501: /* {{{ proto string enchant_broker_get_dict_path(resource broker, int dict_type)
                    502:        Get the directory path for a given backend, works with ispell and myspell */
                    503: PHP_FUNCTION(enchant_broker_get_dict_path)
                    504: {
                    505:        RETURN_FALSE;
                    506: }
                    507: /* }}} */
                    508: #endif
                    509: 
                    510: /* {{{ proto string enchant_broker_list_dicts(resource broker)
                    511:    Lists the dictionaries available for the given broker */
                    512: PHP_FUNCTION(enchant_broker_list_dicts)
                    513: {
                    514:        zval *broker;
                    515:        enchant_broker *pbroker;
                    516: 
                    517:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &broker) == FAILURE) {
                    518:                RETURN_FALSE;
                    519:        }
                    520: 
                    521:        PHP_ENCHANT_GET_BROKER;
                    522: 
                    523:        enchant_broker_list_dicts(pbroker->pbroker, php_enchant_list_dicts_fn, (void *)return_value);
                    524: }
                    525: /* }}} */
                    526: 
                    527: /* {{{ proto resource enchant_broker_request_dict(resource broker, string tag)
                    528:        create a new dictionary using tag, the non-empty language tag you wish to request
                    529:        a dictionary for ("en_US", "de_DE", ...) */
                    530: PHP_FUNCTION(enchant_broker_request_dict)
                    531: {
                    532:        zval *broker;
                    533:        enchant_broker *pbroker;
                    534:        enchant_dict *dict;
                    535:        EnchantDict *d;
                    536:        char *tag;
                    537:        int taglen;
                    538:        int pos;
                    539: 
                    540:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &broker, &tag, &taglen) == FAILURE) {
                    541:                RETURN_FALSE;
                    542:        }
                    543: 
                    544:        PHP_ENCHANT_GET_BROKER;
1.1.1.2   misho     545:        
                    546:        if (taglen == 0) {
                    547:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Tag cannot be empty");
                    548:                RETURN_FALSE;
                    549:        }
1.1       misho     550: 
                    551:        d = enchant_broker_request_dict(pbroker->pbroker, (const char *)tag);
                    552:        if (d) {
                    553:                if (pbroker->dictcnt) {
                    554:                        pbroker->dict = (enchant_dict **)erealloc(pbroker->dict, sizeof(enchant_dict *) * pbroker->dictcnt);
                    555:                        pos = pbroker->dictcnt++;
                    556:                } else {
                    557:                        pbroker->dict = (enchant_dict **)emalloc(sizeof(enchant_dict *));
                    558:                        pos = 0;
                    559:                        pbroker->dictcnt++;
                    560:                }
                    561: 
                    562:                dict = pbroker->dict[pos] = (enchant_dict *)emalloc(sizeof(enchant_dict));
                    563:                dict->id = pos;
                    564:                dict->pbroker = pbroker;
                    565:                dict->pdict = d;
                    566:                dict->prev = pos ? pbroker->dict[pos-1] : NULL;
                    567:                dict->next = NULL;
                    568:                pbroker->dict[pos] = dict;
                    569: 
                    570:                if (pos) {
                    571:                        pbroker->dict[pos-1]->next = dict;
                    572:                }
                    573: 
                    574:                dict->rsrc_id = ZEND_REGISTER_RESOURCE(return_value, dict, le_enchant_dict);
                    575:                zend_list_addref(pbroker->rsrc_id);
                    576:        } else {
                    577:                RETURN_FALSE;
                    578:        }
                    579: }
                    580: /* }}} */
                    581: 
                    582: /* {{{ proto resource enchant_broker_request_pwl_dict(resource broker, string filename)
                    583:    creates a dictionary using a PWL file. A PWL file is personal word file one word per line. It must exist before the call.*/
                    584: PHP_FUNCTION(enchant_broker_request_pwl_dict)
                    585: {
                    586:        zval *broker;
                    587:        enchant_broker *pbroker;
                    588:        enchant_dict *dict;
                    589:        EnchantDict *d;
                    590:        char *pwl;
                    591:        int pwllen;
                    592:        int pos;
                    593: 
1.1.1.2   misho     594:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rp", &broker, &pwl, &pwllen) == FAILURE) {
1.1       misho     595:                RETURN_FALSE;
                    596:        }
                    597: 
                    598: #if PHP_API_VERSION < 20100412
                    599:        if ((PG(safe_mode) && (!php_checkuid(pwl, NULL, CHECKUID_CHECK_FILE_AND_DIR))) || php_check_open_basedir(pwl TSRMLS_CC)) {
                    600: #else
                    601:        if (php_check_open_basedir(pwl TSRMLS_CC)) {
                    602: #endif
                    603:                RETURN_FALSE;
                    604:        }
                    605: 
                    606:        PHP_ENCHANT_GET_BROKER;
                    607: 
                    608:        d = enchant_broker_request_pwl_dict(pbroker->pbroker, (const char *)pwl);
                    609:        if (d) {
                    610:                if (pbroker->dictcnt) {
                    611:                        pos = pbroker->dictcnt++;
                    612:                        pbroker->dict = (enchant_dict **)erealloc(pbroker->dict, sizeof(enchant_dict *) * pbroker->dictcnt);
                    613:                } else {
                    614:                        pbroker->dict = (enchant_dict **)emalloc(sizeof(enchant_dict *));
                    615:                        pos = 0;
                    616:                        pbroker->dictcnt++;
                    617:                }
                    618:                dict = pbroker->dict[pos] = (enchant_dict *)emalloc(sizeof(enchant_dict));
                    619:                dict->id = pos;
                    620:                dict->pbroker = pbroker;
                    621:                dict->pdict = d;
                    622:                dict->prev = pos?pbroker->dict[pos-1]:NULL;
                    623:                dict->next = NULL;
                    624:                pbroker->dict[pos] = dict;
                    625:                if (pos) {
                    626:                        pbroker->dict[pos-1]->next = dict;
                    627:                }
                    628:                dict->rsrc_id = ZEND_REGISTER_RESOURCE(return_value, dict, le_enchant_dict);
                    629:        } else {
                    630:                RETURN_FALSE;
                    631:        }
                    632: }
                    633: /* }}} */
                    634: 
                    635: /* {{{ proto resource enchant_broker_free_dict(resource dict)
                    636:    Free the dictionary resource */
                    637: PHP_FUNCTION(enchant_broker_free_dict)
                    638: {
                    639:        zval *dict;
                    640:        enchant_dict *pdict;
                    641: 
                    642:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &dict) == FAILURE) {
                    643:                RETURN_FALSE;
                    644:        }
                    645: 
                    646:        PHP_ENCHANT_GET_DICT;
                    647: 
                    648:        zend_list_delete(Z_RESVAL_P(dict));
                    649:        RETURN_TRUE;
                    650: }
                    651: /* }}} */
                    652: 
                    653: /* {{{ proto bool enchant_broker_dict_exists(resource broker, string tag)
1.1.1.3   misho     654:    Whether a dictionary exists or not. Using non-empty tag */
1.1       misho     655: PHP_FUNCTION(enchant_broker_dict_exists)
                    656: {
                    657:        zval *broker;
                    658:        char *tag;
                    659:        int taglen;
                    660:        enchant_broker * pbroker;
                    661: 
                    662:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &broker, &tag, &taglen) == FAILURE) {
                    663:                RETURN_FALSE;
                    664:        }
                    665: 
                    666:        PHP_ENCHANT_GET_BROKER;
                    667: 
                    668:        RETURN_BOOL(enchant_broker_dict_exists(pbroker->pbroker, tag));
                    669: }
                    670: /* }}} */
                    671: 
                    672: /* {{{ proto bool enchant_broker_set_ordering(resource broker, string tag, string ordering)
                    673:        Declares a preference of dictionaries to use for the language
                    674:        described/referred to by 'tag'. The ordering is a comma delimited
                    675:        list of provider names. As a special exception, the "*" tag can
                    676:        be used as a language tag to declare a default ordering for any
1.1.1.4   misho     677:        language that does not explicitly declare an ordering. */
1.1       misho     678: 
                    679: PHP_FUNCTION(enchant_broker_set_ordering)
                    680: {
                    681:        zval *broker;
                    682:        char *pordering;
                    683:        int porderinglen;
                    684:        char *ptag;
                    685:        int ptaglen;
                    686:        enchant_broker * pbroker;
                    687: 
                    688:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &broker, &ptag, &ptaglen, &pordering, &porderinglen) == FAILURE) {
                    689:                RETURN_FALSE;
                    690:        }
                    691: 
                    692:        PHP_ENCHANT_GET_BROKER;
                    693: 
                    694:        enchant_broker_set_ordering(pbroker->pbroker, ptag, pordering);
                    695:        RETURN_TRUE;
                    696: }
                    697: /* }}} */
                    698: 
                    699: /* {{{ proto array enchant_broker_describe(resource broker)
                    700:        Enumerates the Enchant providers and tells you some rudimentary information about them. The same info is provided through phpinfo() */
                    701: PHP_FUNCTION(enchant_broker_describe)
                    702: {
                    703:        EnchantBrokerDescribeFn describetozval = enumerate_providers_fn;
                    704:        zval *broker;
                    705:        enchant_broker * pbroker;
                    706: 
                    707:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &broker) == FAILURE) {
                    708:                RETURN_FALSE;
                    709:        }
                    710: 
                    711:        PHP_ENCHANT_GET_BROKER;
                    712: 
                    713:        enchant_broker_describe(pbroker->pbroker, describetozval, (void *)return_value);
                    714: }
                    715: /* }}} */
                    716: 
                    717: /* {{{ proto bool enchant_dict_quick_check(resource dict, string word [, array &suggestions])
                    718:     If the word is correctly spelled return true, otherwise return false, if suggestions variable
                    719:     is provided, fill it with spelling alternatives. */
                    720: PHP_FUNCTION(enchant_dict_quick_check)
                    721: {
                    722:        zval *dict, *sugg = NULL;
                    723:        char *word;
                    724:        int wordlen;
                    725:        enchant_dict *pdict;
                    726: 
                    727:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|z/", &dict, &word, &wordlen, &sugg) == FAILURE) {
                    728:                RETURN_FALSE;
                    729:        }
                    730: 
                    731:        if (sugg) {
                    732:                zval_dtor(sugg);
1.1.1.3   misho     733:                array_init(sugg);
1.1       misho     734:        }
                    735: 
                    736:        PHP_ENCHANT_GET_DICT;
                    737: 
                    738:        if (enchant_dict_check(pdict->pdict, word, wordlen) > 0) {
                    739:                int n_sugg;
                    740:                size_t n_sugg_st;
                    741:                char **suggs;
                    742: 
                    743:                if (!sugg && ZEND_NUM_ARGS() == 2) {
                    744:                        RETURN_FALSE;
                    745:                }
                    746: 
                    747:                suggs = enchant_dict_suggest(pdict->pdict, word, wordlen, &n_sugg_st);
                    748:                memcpy(&n_sugg, &n_sugg_st, sizeof(n_sugg));
                    749:                if (suggs && n_sugg) {
                    750:                        int i;
                    751:                        for (i = 0; i < n_sugg; i++) {
                    752:                                add_next_index_string(sugg, suggs[i], 1);
                    753:                        }
                    754:                        enchant_dict_free_suggestions(pdict->pdict, suggs);
                    755:                }
                    756: 
                    757: 
                    758:                RETURN_FALSE;
                    759:        }
                    760:        RETURN_TRUE;
                    761: }
                    762: /* }}} */
                    763: 
                    764: /* {{{ proto bool enchant_dict_check(resource dict, string word)
                    765:     If the word is correctly spelled return true, otherwise return false */
                    766: PHP_FUNCTION(enchant_dict_check)
                    767: {
                    768:        zval *dict;
                    769:        char *word;
                    770:        int wordlen;
                    771:        enchant_dict *pdict;
                    772: 
                    773:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &dict, &word, &wordlen) == FAILURE) {
                    774:                RETURN_FALSE;
                    775:        }
                    776: 
                    777:        PHP_ENCHANT_GET_DICT;
                    778: 
                    779:        RETURN_BOOL(!enchant_dict_check(pdict->pdict, word, wordlen));
                    780: }
                    781: /* }}} */
                    782: 
                    783: /* {{{ proto array enchant_dict_suggest(resource dict, string word)
                    784:     Will return a list of values if any of those pre-conditions are not met.*/
                    785: PHP_FUNCTION(enchant_dict_suggest)
                    786: {
                    787:        zval *dict;
                    788:        char *word;
                    789:        int wordlen;
                    790:        char **suggs;
                    791:        enchant_dict *pdict;
                    792:        int n_sugg;
                    793:        size_t n_sugg_st;
                    794: 
                    795:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &dict, &word, &wordlen) == FAILURE) {
                    796:                RETURN_FALSE;
                    797:        }
                    798: 
                    799:        PHP_ENCHANT_GET_DICT;
                    800: 
                    801:        suggs = enchant_dict_suggest(pdict->pdict, word, wordlen, &n_sugg_st);
                    802:        memcpy(&n_sugg, &n_sugg_st, sizeof(n_sugg));
                    803:        if (suggs && n_sugg) {
                    804:                int i;
                    805: 
                    806:                array_init(return_value);
                    807:                for (i = 0; i < n_sugg; i++) {
                    808:                        add_next_index_string(return_value, suggs[i], 1);
                    809:                }
                    810: 
                    811:                enchant_dict_free_suggestions(pdict->pdict, suggs);
                    812:        }
                    813: }
                    814: /* }}} */
                    815: 
                    816: /* {{{ proto void enchant_dict_add_to_personal(resource dict, string word)
                    817:      add 'word' to personal word list */
                    818: PHP_FUNCTION(enchant_dict_add_to_personal)
                    819: {
                    820:        zval *dict;
                    821:        char *word;
                    822:        int wordlen;
                    823:        enchant_dict *pdict;
                    824: 
                    825:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &dict, &word, &wordlen) == FAILURE) {
                    826:                RETURN_FALSE;
                    827:        }
                    828: 
                    829:        PHP_ENCHANT_GET_DICT;
                    830: 
                    831:        enchant_dict_add_to_personal(pdict->pdict, word, wordlen);
                    832: }
                    833: /* }}} */
                    834: 
                    835: /* {{{ proto void enchant_dict_add_to_session(resource dict, string word)
                    836:    add 'word' to this spell-checking session */
                    837: PHP_FUNCTION(enchant_dict_add_to_session)
                    838: {
                    839:        zval *dict;
                    840:        char *word;
                    841:        int wordlen;
                    842:        enchant_dict *pdict;
                    843: 
                    844:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &dict, &word, &wordlen) == FAILURE) {
                    845:                RETURN_FALSE;
                    846:        }
                    847: 
                    848:        PHP_ENCHANT_GET_DICT;
                    849: 
                    850:        enchant_dict_add_to_session(pdict->pdict, word, wordlen);
                    851: }
                    852: /* }}} */
                    853: 
                    854: /* {{{ proto bool enchant_dict_is_in_session(resource dict, string word)
                    855:    whether or not 'word' exists in this spelling-session */
                    856: PHP_FUNCTION(enchant_dict_is_in_session)
                    857: {
                    858:        zval *dict;
                    859:        char *word;
                    860:        int wordlen;
                    861:        enchant_dict *pdict;
                    862: 
                    863:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &dict, &word, &wordlen) == FAILURE) {
                    864:                RETURN_FALSE;
                    865:        }
                    866: 
                    867:        PHP_ENCHANT_GET_DICT;
                    868: 
                    869:        RETURN_BOOL(enchant_dict_is_in_session(pdict->pdict, word, wordlen));
                    870: }
                    871: /* }}} */
                    872: 
                    873: /* {{{ proto void enchant_dict_store_replacement(resource dict, string mis, string cor)
                    874:        add a correction for 'mis' using 'cor'.
                    875:        Notes that you replaced @mis with @cor, so it's possibly more likely
                    876:        that future occurrences of @mis will be replaced with @cor. So it might
                    877:        bump @cor up in the suggestion list.*/
                    878: PHP_FUNCTION(enchant_dict_store_replacement)
                    879: {
                    880:        zval *dict;
                    881:        char *mis, *cor;
                    882:        int mislen, corlen;
                    883: 
                    884:        enchant_dict *pdict;
                    885: 
                    886:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &dict, &mis, &mislen, &cor, &corlen) == FAILURE) {
                    887:                RETURN_FALSE;
                    888:        }
                    889: 
                    890:        PHP_ENCHANT_GET_DICT;
                    891: 
                    892:        enchant_dict_store_replacement(pdict->pdict, mis, mislen, cor, corlen);
                    893: }
                    894: /* }}} */
                    895: 
                    896: /* {{{ proto string enchant_dict_get_error(resource dict)
                    897:    Returns the last error of the current spelling-session */
                    898: PHP_FUNCTION(enchant_dict_get_error)
                    899: {
                    900:        zval *dict;
                    901:        enchant_dict *pdict;
                    902:        char *msg;
                    903: 
                    904:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &dict) == FAILURE) {
                    905:                RETURN_FALSE;
                    906:        }
                    907: 
                    908:        PHP_ENCHANT_GET_DICT;
                    909: 
                    910:        msg = enchant_dict_get_error(pdict->pdict);
                    911:        if (msg) {
                    912:                RETURN_STRING((char *)msg, 1);
                    913:        }
                    914: 
                    915:        RETURN_FALSE;
                    916: }
                    917: /* }}} */
                    918: 
                    919: /* {{{ proto array enchant_dict_describe(resource dict)
                    920:    Describes an individual dictionary 'dict' */
                    921: PHP_FUNCTION(enchant_dict_describe)
                    922: {
                    923:        zval *dict;
                    924:        enchant_dict *pdict;
                    925: 
                    926:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &dict) == FAILURE) {
                    927:                RETURN_FALSE;
                    928:        }
                    929: 
                    930:        PHP_ENCHANT_GET_DICT;
                    931: 
                    932:        enchant_dict_describe(pdict->pdict, describe_dict_fn, (void *)return_value);
                    933: }
                    934: /* }}} */
                    935: 
                    936: /*
                    937:  * Local variables:
                    938:  * tab-width: 4
                    939:  * c-basic-offset: 4
                    940:  * End:
                    941:  * vim600: noet sw=4 ts=4 fdm=marker
                    942:  * vim<600: noet sw=4 ts=4
                    943:  */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>