mega_venik/sdcv
1
0
Fork 0
mirror of https://github.com/Dushistov/sdcv.git synced 2025-12-15 17:31:56 +00:00
Code Issues Projects Releases Wiki Activity

Merge branch 'order_dist_list'

Browse Source
This commit is contained in:
Evgeniy A. Dushistov
2017-04-22 21:25:58 +03:00
parent d9f273b858 1667de0650
commit 5c1357840c
5 changed files with 77 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
src/readline.cpp
View File

@@ -34,18 +34,19 @@
#include "readline.hpp" #include "readline.hpp"
#ifndef WITH_READLINE bool stdio_getline(FILE *in, std::string & str)
namespace { {
static bool stdio_getline(FILE *in, std::string & str) assert(in != nullptr);
{
str.clear(); str.clear();
int ch; int ch;
while ((ch=fgetc(in)) != EOF && ch != '\n') while ((ch=fgetc(in)) != EOF && ch != '\n')
str += ch; str += ch;
return EOF != ch; return EOF != ch;
} }
#ifndef WITH_READLINE
namespace {
class dummy_readline : public IReadLine { class dummy_readline : public IReadLine {
public: public:
bool read(const std::string &banner, std::string &line) override { bool read(const std::string &banner, std::string &line) override {

2
src/readline.hpp
View File

@@ -11,4 +11,4 @@ public:
extern std::string sdcv_readline; extern std::string sdcv_readline;
extern IReadLine *create_readline_object(); extern IReadLine *create_readline_object();
extern bool stdio_getline(FILE *in, std::string &str);

90
src/sdcv.cpp
View File

@@ -30,6 +30,8 @@
#include <memory> #include <memory>
#include <string> #include <string>
#include <vector> #include <vector>
#include <algorithm>
#include <map>
#include <glib.h> #include <glib.h>
#include <glib/gi18n.h> #include <glib/gi18n.h>
@@ -54,9 +56,11 @@ static void free_str_array(gchar **arr)
} }
namespace glib namespace glib
{ {
typedef ResourceWrapper<gchar *, gchar *, free_str_array> StrArr; using StrArr = ResourceWrapper<gchar *, gchar *, free_str_array>;
} }
static void list_dicts(const std::list<std::string> &dicts_dir_list);
int main(int argc, char *argv[]) try { int main(int argc, char *argv[]) try {
setlocale(LC_ALL, ""); setlocale(LC_ALL, "");
#if ENABLE_NLS #if ENABLE_NLS
@@ -95,7 +99,7 @@ int main(int argc, char *argv[]) try {
_("path/to/dir") }, _("path/to/dir") },
{ "color", 'c', 0, G_OPTION_ARG_NONE, &colorize, { "color", 'c', 0, G_OPTION_ARG_NONE, &colorize,
_("colorize the output"), nullptr }, _("colorize the output"), nullptr },
{ nullptr }, {},
}; };
glib::Error error; glib::Error error;
@@ -136,52 +140,67 @@ int main(int argc, char *argv[]) try {
}; };
if (show_list_dicts) { if (show_list_dicts) {
printf(_("Dictionary's name Word count\n")); list_dicts(dicts_dir_list);
std::list<std::string> order_list, disable_list;
for_each_file(dicts_dir_list, ".ifo", order_list,
disable_list, [](const std::string &filename, bool) -> void {
DictInfo dict_info;
if (dict_info.load_from_ifo_file(filename, false)) {
const std::string bookname = utf8_to_locale_ign_err(dict_info.bookname);
printf("%s %d\n", bookname.c_str(), dict_info.wordcount);
}
});
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
std::list<std::string> disable_list; std::list<std::string> disable_list;
if (use_dict_list) { std::map<std::string, std::string> bookname_to_ifo;
std::list<std::string> empty_list; for_each_file(dicts_dir_list, ".ifo", std::list<std::string>(), std::list<std::string>(),
[&bookname_to_ifo](const std::string &fname, bool) {
for_each_file(dicts_dir_list, ".ifo", empty_list, empty_list,
[&disable_list, &use_dict_list](const std::string &filename, bool) -> void {
DictInfo dict_info; DictInfo dict_info;
const bool load_ok = dict_info.load_from_ifo_file(filename, false); const bool load_ok = dict_info.load_from_ifo_file(fname, false);
if (!load_ok) if (!load_ok)
return; return;
bookname_to_ifo[dict_info.bookname] = dict_info.ifo_file_name;
for (gchar **p = get_impl(use_dict_list); *p != nullptr; ++p)
if (strcmp(*p, dict_info.bookname.c_str()) == 0)
return;
disable_list.push_back(dict_info.ifo_file_name);
}); });
std::list<std::string> order_list;
if (use_dict_list) {
for (auto &&x : bookname_to_ifo) {
gchar **p = get_impl(use_dict_list);
for (; *p != nullptr; ++p)
if (x.first.compare(*p) == 0) {
break;
}
if (*p == nullptr) {
disable_list.push_back(x.second);
}
}
// add bookname to list
gchar **p = get_impl(use_dict_list);
while (*p) {
order_list.push_back(bookname_to_ifo.at(*p));
++p;
}
} else {
const std::string odering_cfg_file = std::string(homedir) + G_DIR_SEPARATOR_S ".sdcv_ordering";
FILE *ordering_file = fopen(odering_cfg_file.c_str(), "r");
if (ordering_file != nullptr) {
std::string line;
while (stdio_getline(ordering_file, line)) {
order_list.push_back(bookname_to_ifo.at(line));
}
fclose(ordering_file);
}
} }
const std::string conf_dir = std::string(g_get_home_dir()) + G_DIR_SEPARATOR + ".stardict"; const std::string conf_dir = std::string(g_get_home_dir()) + G_DIR_SEPARATOR + ".stardict";
if (g_mkdir(conf_dir.c_str(), S_IRWXU) == -1 && errno != EEXIST) if (g_mkdir(conf_dir.c_str(), S_IRWXU) == -1 && errno != EEXIST) {
fprintf(stderr, _("g_mkdir failed: %s\n"), strerror(errno)); fprintf(stderr, _("g_mkdir failed: %s\n"), strerror(errno));
}
Library lib(utf8_input, utf8_output, colorize); Library lib(utf8_input, utf8_output, colorize);
std::list<std::string> empty_list; lib.load(dicts_dir_list, order_list, disable_list);
lib.load(dicts_dir_list, empty_list, disable_list);
std::unique_ptr<IReadLine> io(create_readline_object()); std::unique_ptr<IReadLine> io(create_readline_object());
if (optind < argc) { if (optind < argc) {
for (int i = optind; i < argc; ++i) for (int i = optind; i < argc; ++i)
if (!lib.process_phrase(argv[i], *io, non_interactive)) if (!lib.process_phrase(argv[i], *io, non_interactive)) {
return EXIT_FAILURE; return EXIT_FAILURE;
}
} else if (!non_interactive) { } else if (!non_interactive) {
std::string phrase; std::string phrase;
@@ -200,3 +219,18 @@ int main(int argc, char *argv[]) try {
fprintf(stderr, "Internal error: %s\n", ex.what()); fprintf(stderr, "Internal error: %s\n", ex.what());
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
static void list_dicts(const std::list<std::string> &dicts_dir_list)
{
printf(_("Dictionary's name Word count\n"));
std::list<std::string> order_list, disable_list;
for_each_file(dicts_dir_list, ".ifo", order_list,
disable_list, [](const std::string &filename, bool) -> void {
DictInfo dict_info;
if (dict_info.load_from_ifo_file(filename, false)) {
const std::string bookname = utf8_to_locale_ign_err(dict_info.bookname);
printf("%s %d\n", bookname.c_str(), dict_info.wordcount);
}
});
}

27
src/stardict_lib.cpp
View File

@@ -909,33 +909,6 @@ void Libs::load(const std::list<std::string>& dicts_dirs,
}); });
} }
void Libs::reload(const std::list<std::string>& dicts_dirs,
const std::list<std::string>& order_list,
const std::list<std::string>& disable_list)
{
std::vector<Dict *> prev(oLib);
oLib.clear();
for_each_file(dicts_dirs, ".ifo", order_list, disable_list,
[&prev, this](const std::string& url, bool disable) -> void {
if (!disable) {
auto it = prev.begin();
for (; it != prev.end(); ++it)
if ((*it)->ifofilename() == url)
break;
if (it != prev.end()) {
Dict *res = *it;
prev.erase(it);
oLib.push_back(res);
} else
load_dict(url);
}
});
for (Dict *p : prev)
delete p;
}
const gchar *Libs::poGetCurrentWord(glong * iCurrent) const gchar *Libs::poGetCurrentWord(glong * iCurrent)
{ {
const gchar *poCurrentWord = nullptr; const gchar *poCurrentWord = nullptr;

4
src/stardict_lib.hpp
View File

@@ -139,10 +139,6 @@ public:
void load(const std::list<std::string>& dicts_dirs, void load(const std::list<std::string>& dicts_dirs,
const std::list<std::string>& order_list, const std::list<std::string>& order_list,
const std::list<std::string>& disable_list); const std::list<std::string>& disable_list);
void reload(const std::list<std::string>& dicts_dirs,
const std::list<std::string>& order_list,
const std::list<std::string>& disable_list);
glong narticles(int idict) const { return oLib[idict]->narticles(); } glong narticles(int idict) const { return oLib[idict]->narticles(); }
const std::string& dict_name(int idict) const { return oLib[idict]->dict_name(); } const std::string& dict_name(int idict) const { return oLib[idict]->dict_name(); }
gint ndicts() const { return oLib.size(); } gint ndicts() const { return oLib.size(); }