//__________________________________________________________________________ void Speller::Aspell::Suggest::init(const std::string& lang, const std::string& jargon, const std::string& encoding) throw( std::invalid_argument, std::runtime_error ) { // Save aspell configuration values flang = lang; fjargon = jargon; fencoding = encoding; fconfig = new_aspell_config(); try { setConfig(); } catch( const std::invalid_argument& err ) { throw err; } AspellCanHaveError* ret = new_aspell_speller( fconfig ); delete_aspell_config( fconfig ); if( aspell_error_number( ret ) != 0 ) { delete_aspell_can_have_error( ret ); throw std::runtime_error( "(Aspell::Speller::Suggest::init" "): Error in creating speller." ); } else { fspeller = to_aspell_speller( ret ); fconfig = aspell_speller_config( fspeller ); } }
/** * Ctor for aspell objects. * This is a custom constructor and takes a hash of config options: key, value pairs. * Common use: * * a = Aspell.new({"lang"=>"de", "jargon"=>"berlin"}) * * For a list of config options, see aspell manual. * @param options hash of options */ static VALUE aspell_s_new1(VALUE klass, VALUE options) { //aspell values AspellCanHaveError * ret; AspellSpeller * speller; AspellConfig * config; //create new config config = new_aspell_config(); //set options set_options(config, options); //create speller: ret = new_aspell_speller(config); delete_aspell_config(config); if (aspell_error(ret) != 0) { const char *tmp = strdup(aspell_error_message(ret)); delete_aspell_can_have_error(ret); rb_raise(cAspellError, "%s", tmp); } speller = to_aspell_speller(ret); //wrap pointer return Data_Wrap_Struct(klass, 0, aspell_free, speller); }
struct spelling * spelling_init(char *lang) { AspellConfig *config; AspellCanHaveError *ret; struct spelling *spelling = malloc(sizeof(struct spelling)); if (spelling == NULL) { warn("malloc(spelling)"); return NULL; } config = new_aspell_config(); aspell_config_replace(config, "lang", spelling_lookup_lang(lang)); aspell_config_replace(config, "dict-dir", bfile("data/dict/")); aspell_config_replace(config, "encoding", "iso-8859-1"); ret = new_aspell_speller(config); delete_aspell_config(config); spelling->speller = to_aspell_speller(ret); if (aspell_error(ret) != 0) { printf("Error: %s\n", aspell_speller_error_message(spelling->speller)); delete_aspell_can_have_error(ret); return NULL; } spelling->conv = iconv_open("iso-8859-1", "utf-8"); spelling->conv_out = iconv_open("utf-8", "iso-8859-1"); return spelling; }
//__________________________________________________________________________ void Speller::Aspell::Suggest::resetConfig() throw( std::invalid_argument, std::runtime_error ) { delete_aspell_config( fconfig ); fconfig = new_aspell_config(); try { setConfig(); } catch( const std::invalid_argument& err ) { throw err; } AspellCanHaveError* ret = new_aspell_speller( fconfig ); if( aspell_error_number( ret ) != 0 ) { delete_aspell_can_have_error( ret ); throw std::runtime_error( "(Aspell::Speller::Suggest::Reset" "Config): Error in creating " "speller." ); } else { // Following statement causes a crash, hence commented out //delete_aspell_speller( fspeller ); fspeller = to_aspell_speller( ret ); delete_aspell_config( fconfig ); fconfig = aspell_speller_config( fspeller ); } }
bool KAspellChecker::init() { QString locale = QString(QLocale::system().name()).left(2); if (locale.length() < 2) locale = "en"; AspellConfig * config = new_aspell_config(); aspell_config_replace(config, "lang", locale.toLocal8Bit().data()); AspellCanHaveError * ret = new_aspell_speller(config); delete_aspell_config(config); if (aspell_error(ret) != 0) { qDebug("Error: %s\n",aspell_error_message(ret)); delete_aspell_can_have_error(ret); return false; } m_speller = to_aspell_speller(ret); config = aspell_speller_config(m_speller); qDebug() << "USING LANG= " << aspell_config_retrieve(config, "lang"); return true; }
AspellSpeller * weechat_aspell_speller_new (const char *lang) { AspellConfig *config; AspellCanHaveError *ret; AspellSpeller *new_speller; struct t_infolist *infolist; if (!lang) return NULL; if (weechat_aspell_plugin->debug) { weechat_printf (NULL, "%s: creating new speller for lang \"%s\"", ASPELL_PLUGIN_NAME, lang); } /* create a speller instance for the newly created cell */ config = new_aspell_config(); aspell_config_replace (config, "lang", lang); /* apply all options on speller */ infolist = weechat_infolist_get ("option", NULL, "aspell.option.*"); if (infolist) { while (weechat_infolist_next (infolist)) { aspell_config_replace (config, weechat_infolist_string (infolist, "option_name"), weechat_infolist_string (infolist, "value")); } weechat_infolist_free (infolist); } ret = new_aspell_speller (config); if (aspell_error (ret) != 0) { weechat_printf (NULL, "%s%s: error: %s", weechat_prefix ("error"), ASPELL_PLUGIN_NAME, aspell_error_message (ret)); delete_aspell_config (config); delete_aspell_can_have_error (ret); return NULL; } new_speller = to_aspell_speller (ret); weechat_hashtable_set (weechat_aspell_spellers, lang, new_speller); /* free configuration */ delete_aspell_config (config); return new_speller; }
Speller::Speller(SpellerConfig *cfg) : m_base(cfg->m_base) { speller = NULL; if (cfg->cfg){ AspellCanHaveError *ret = new_aspell_speller(cfg->cfg); if (aspell_error(ret) != 0){ log(L_WARN, "Spell: %s", aspell_error_message(ret)); delete_aspell_can_have_error(ret); return; } speller = to_aspell_speller(ret); } }
/** * create a neew spell-checker for the language 'lang' */ void * spellcheck_create(const char * lang) { struct linkgrammar_aspell *aspell = NULL; size_t i = 0; AspellCanHaveError *spell_err = NULL; for (i = 0; i < sizeof(spellcheck_lang_mapping)/sizeof(char *); i += 2) { if (0 != strcmp(lang, spellcheck_lang_mapping[i])) continue; aspell = (struct linkgrammar_aspell *)malloc(sizeof(struct linkgrammar_aspell)); if (!aspell) { prt_error("Error: out of memory. Aspell not used.\n"); aspell = NULL; break; } aspell->config = NULL; aspell->speller = NULL; aspell->config = new_aspell_config(); if (aspell_config_replace(aspell->config, ASPELL_LANG_KEY, spellcheck_lang_mapping[i]) == 0) { prt_error("Error: failed to set language in aspell: %s\n", lang); delete_aspell_config(aspell->config); free(aspell); aspell = NULL; break; } spell_err = new_aspell_speller(aspell->config); if (aspell_error_number(spell_err) != 0) { prt_error("Error: Aspell: %s\n", aspell_error_message(spell_err)); delete_aspell_can_have_error(spell_err); delete_aspell_config(aspell->config); free(aspell); aspell = NULL; break; } aspell->speller = to_aspell_speller(spell_err); break; } return aspell; }
/** * Ctor for aspell objects: * Aspell.new(language, jargon, size, encoding) * Please note: All parameters are optional. If a parameter is omitted, a default value is assumed from * the environment (eg lang from $LANG). To retain default values, you can use nil * as value: to set only size: Aspell.new(nil, nil, "80") * @param language ISO639 language code plus optional ISO 3166 counry code as string (eg: "de" or "us_US") * @param jargon a special jargon of the selected language * @param size the size of the dictionary to chose (if there are options) * @param encoding the encoding to use * @exception Exception if the specified dictionary is not found. */ static VALUE aspell_s_new(int argc, VALUE *argv, VALUE klass) { VALUE vlang, vjargon, vsize, vencoding; const char *tmp; //aspell values AspellCanHaveError * ret; AspellSpeller * speller; AspellConfig * config; //create new config config = new_aspell_config(); //extract values rb_scan_args(argc, argv, "04", &vlang, &vjargon, &vsize, &vencoding); //language: if (RTEST(vlang)) set_option(config, "lang", STR2CSTR(vlang)); //jargon: if (RTEST(vjargon)) set_option(config, "jargon", STR2CSTR(vjargon)); //size: if (RTEST(vsize)) set_option(config, "size", STR2CSTR(vsize)); //encoding: if (RTEST(vencoding)) set_option(config, "encoding", STR2CSTR(vencoding)); //create speller: ret = new_aspell_speller(config); delete_aspell_config(config); if (aspell_error(ret) != 0) { tmp = strdup(aspell_error_message(ret)); delete_aspell_can_have_error(ret); rb_raise(cAspellError, "%s", tmp); } speller = to_aspell_speller(ret); //wrap pointer return Data_Wrap_Struct(klass, 0, aspell_free, speller); }
/* Create a new speller *******************************************************/ static PyObject* new_speller(PyObject* self, PyObject* args) { aspell_AspellObject* newobj; AspellSpeller* speller = 0; AspellConfig* config; AspellCanHaveError* possible_error; int i; int n; /* arg count */ char *key, *value; config = new_aspell_config(); if (config == NULL) { PyErr_SetString(_AspellModuleException, "can't create config"); return NULL; } /* check constructor arguments */ n = PyTuple_Size(args); switch (n) { case 0: /* no arguments passed */ break; case 2: /* constructor is called with single pair: key & value */ if (PyArg_ParseTuple(args, "ss", &key, &value)) { if (!aspell_config_replace(config, key, value)) { PyErr_SetString(_AspellConfigException, aspell_config_error_message(config)); goto arg_error; } break; } PyErr_Clear(); default: /* list of tuples key&value */ for (i=0; i<n; i++) { if (!PyArg_ParseTuple(PyTuple_GetItem(args, i), "ss", &key, &value)) { PyErr_Format(PyExc_TypeError, "argument %d: tuple of two strings (key, value) expeced", i); goto arg_error; } if (!aspell_config_replace(config, key, value)) { PyErr_SetString(_AspellConfigException, aspell_config_error_message(config)); goto arg_error; } } Py_DECREF(args); break; } /* try to create a new speller */ possible_error = new_aspell_speller(config); delete_aspell_config(config); if (aspell_error_number(possible_error) == 0) /* save a speller */ speller = to_aspell_speller(possible_error); else { /* or raise an exception */ PyErr_SetString(_AspellSpellerException, aspell_error_message(possible_error)); delete_aspell_can_have_error(possible_error); return NULL; } /* create a new py-object */ newobj = (aspell_AspellObject*)PyObject_New(aspell_AspellObject, &aspell_AspellType); newobj->speller = speller; return (PyObject*)newobj; /* argument error: before return NULL we need to delete speller's config we've created */ arg_error: delete_aspell_config(config); return NULL; }
AspellSpeller * #endif /* USE_ENCHANT */ weechat_aspell_speller_new (const char *lang) { #ifdef USE_ENCHANT EnchantDict *new_speller; #else AspellConfig *config; AspellCanHaveError *ret; AspellSpeller *new_speller; #endif /* USE_ENCHANT */ struct t_infolist *infolist; if (!lang) return NULL; if (weechat_aspell_plugin->debug) { weechat_printf (NULL, "%s: creating new speller for lang \"%s\"", ASPELL_PLUGIN_NAME, lang); } #ifdef USE_ENCHANT new_speller = enchant_broker_request_dict (broker, lang); if (!new_speller) { weechat_printf (NULL, _("%s%s: error: unable to create speller for lang \"%s\""), weechat_prefix ("error"), ASPELL_PLUGIN_NAME, lang); return NULL; } #else /* create a speller instance for the newly created cell */ config = new_aspell_config (); aspell_config_replace (config, "lang", lang); #endif /* USE_ENCHANT */ /* apply all options */ infolist = weechat_infolist_get ("option", NULL, "aspell.option.*"); if (infolist) { while (weechat_infolist_next (infolist)) { #ifdef USE_ENCHANT /* TODO: set option with enchant */ #else aspell_config_replace (config, weechat_infolist_string (infolist, "option_name"), weechat_infolist_string (infolist, "value")); #endif /* USE_ENCHANT */ } weechat_infolist_free (infolist); } #ifndef USE_ENCHANT ret = new_aspell_speller (config); if (aspell_error (ret) != 0) { weechat_printf (NULL, "%s%s: error: %s", weechat_prefix ("error"), ASPELL_PLUGIN_NAME, aspell_error_message (ret)); delete_aspell_config (config); delete_aspell_can_have_error (ret); return NULL; } new_speller = to_aspell_speller (ret); #endif /* USE_ENCHANT */ weechat_hashtable_set (weechat_aspell_spellers, lang, new_speller); #ifndef USE_ENCHANT /* free configuration */ delete_aspell_config (config); #endif /* USE_ENCHANT */ return new_speller; }
void SpellChecker::setLanguage(const QString &lang) { if (lang.isEmpty()) return; delete_aspell_speller(spell_checker1); delete_aspell_speller(spell_checker2); bad_language.clear(); m_lang2 = "en"; m_lang1 = m_map->value(lang, QString("en")); if (lang.contains("+")) { QStringList sl = lang.split("+"); m_lang1 = m_map->value(sl[0], QString("en")); m_lang2 = m_map->value(sl[1], QString("en")); if ((m_lang1 == "deu")||(lang == "ger")) { m_lang1 = "de_DE"; } if ((m_lang2 == "deu")||(lang == "ger")) { m_lang2 = "de_DE"; } } if (lang == "rus_fra") { m_lang1 = "ru"; m_lang2 = "fr"; } else if (lang == "rus_ger") { m_lang1 = "ru"; m_lang2 = "de"; } else if (lang == "rus_spa") { m_lang1 = "ru"; m_lang2 = "es"; } if ((lang == "deu")||(lang == "ger")) { m_lang1 = "de_DE"; m_lang2 = "de_AT"; } if (lang == "ruseng") { m_lang1 = "ru"; m_lang2 = "en"; } aspell_config_replace(spell_config1, "lang", m_lang1.toAscii()); aspell_config_replace(spell_config2, "lang", m_lang2.toAscii()); AspellCanHaveError *possible_err = new_aspell_speller(spell_config1); spell_checker1 = 0; if (aspell_error_number(possible_err) == 0) spell_checker1 = to_aspell_speller(possible_err); else delete_aspell_can_have_error(possible_err); possible_err = new_aspell_speller(spell_config2); spell_checker2 = 0; if (aspell_error_number(possible_err) == 0) spell_checker2 = to_aspell_speller(possible_err); else delete_aspell_can_have_error(possible_err); // Check absent dictionary if (spell_checker1 == 0) bad_language = m_lang1; if (spell_checker2 == 0) bad_language = m_lang2; }
int main(int argc, const char *argv[]) { AspellCanHaveError * ret; AspellSpeller * speller; int have; char word[81]; char * p; char * word_end; AspellConfig * config; if (argc < 2) { printf("Usage: %s <language> [<size>|- [[<jargon>|- [<encoding>]]]\n", argv[0]); return 1; } config = new_aspell_config(); aspell_config_replace(config, "lang", argv[1]); if (argc >= 3 && argv[2][0] != '-' && argv[2][1] != '\0') aspell_config_replace(config, "size", argv[2]); if (argc >= 4 && argv[3][0] != '-') aspell_config_replace(config, "jargon", argv[3]); if (argc >= 5 && argv[4][0] != '-') aspell_config_replace(config, "encoding", argv[4]); ret = new_aspell_speller(config); delete_aspell_config(config); if (aspell_error(ret) != 0) { printf("Error: %s\n",aspell_error_message(ret)); delete_aspell_can_have_error(ret); return 2; } speller = to_aspell_speller(ret); config = aspell_speller_config(speller); fputs("Using: ", stdout); fputs(aspell_config_retrieve(config, "lang"), stdout); fputs("-", stdout); fputs(aspell_config_retrieve(config, "jargon"), stdout); fputs("-", stdout); fputs(aspell_config_retrieve(config, "size"), stdout); fputs("-", stdout); fputs(aspell_config_retrieve(config, "module"), stdout); fputs("\n\n", stdout); puts("Type \"h\" for help.\n"); while (fgets(word, 80, stdin) != 0) { /* remove trailing spaces */ word_end = strchr(word, '\0') - 1; while (word_end != word && (*word_end == '\n' || *word_end == ' ')) --word_end; ++word_end; *word_end = '\0'; putchar('\n'); switch (word[0]) { case '\0': break; case 'h': puts( "Usage: \n" " h(elp) help\n" " c <word> check if a word is the correct spelling\n" " s <word> print out a list of suggestions for a word\n" " a <word> add a word to the personal word list\n" " i <word> ignore a word for the rest of the session\n" " d <file> spell checks a document\n" " p dumps the personal word list\n" " P dumps the session word list\n" " m dumps the main word list\n" " o <option> <value> sets a config option\n" " r <option> retrieves a config option\n" " l <option> retrieves a config option as a list\n" " S saves all word lists\n" " C clear the curent sesstion word list\n" " x quite\n" ); break; case 'p': print_word_list(speller, aspell_speller_personal_word_list(speller), '\n'); break; case 'P': print_word_list(speller, aspell_speller_session_word_list(speller), '\n'); break; case 'm': print_word_list(speller, aspell_speller_main_word_list(speller), '\n'); break; case 'S': aspell_speller_save_all_word_lists(speller); check_for_error(speller); break; case 'C': aspell_speller_clear_session(speller); check_for_error(speller); break; case 'x': goto END; case 'c': if (strlen(word) < 3) { printf("Usage: %c <word>\n", word[0]); } else { have = aspell_speller_check(speller, word + 2, -1); if (have == 1) puts("correct"); else if (have == 0) puts("incorrect"); else printf("Error: %s\n", aspell_speller_error_message(speller)); } break; case 's': if (strlen(word) < 3) { printf("Usage: %c <word>\n", word[0]); } else { print_word_list(speller, aspell_speller_suggest(speller, word + 2, -1), '\n'); } break; case 'a': if (strlen(word) < 3) { printf("Usage: %c <word>\n", word[0]); } else { aspell_speller_add_to_personal(speller, word + 2, -1); check_for_error(speller); } break; case 'i': if (strlen(word) < 3) { printf("Usage: %c <word>\n", word[0]); } else { aspell_speller_add_to_session(speller, word + 2, -1); check_for_error(speller); } break; case 'o': word[80] = '\0'; /* to make sure strchr doesn't run off end of string */ p = strchr(word + 3, ' '); if (strlen(word) < 3 || p == 0) { printf("Usage: %c <option> <value>\n", word[0]); } else { *p = '\0'; ++p; aspell_config_replace(config, word + 2, p); check_for_config_error(config); } break; case 'r': if (strlen(word) < 3) { printf("Usage: %c <option>\n", word[0]); } else { const char * val = aspell_config_retrieve(config, word + 2); check_for_config_error(config); if (val) printf("%s = \"%s\"\n", word + 2, val); } break; case 'l': if (strlen(word) < 3) { printf("Usage: %c <option>\n", word[0]); } else { AspellStringList * lst = new_aspell_string_list(); AspellMutableContainer * lst0 = aspell_string_list_to_mutable_container(lst); AspellStringEnumeration * els; const char * val; aspell_config_retrieve_list(config, word + 2, lst0); check_for_config_error(config); els = aspell_string_list_elements(lst); printf("%s:\n", word + 2); while ( (val = aspell_string_enumeration_next(els)) != 0) printf(" %s\n", val); delete_aspell_string_enumeration(els); delete_aspell_string_list(lst); } break; case 'd': if (strlen(word) < 3) { printf("Usage: %c <file>\n", word[0]); } else { check_document(speller, word + 2); printf("\n"); } break; default: printf("Unknown Command: %s\n", word); } putchar('\n'); } END: delete_aspell_speller(speller); return 0; }