660 lines
15 KiB
C++
Executable File
660 lines
15 KiB
C++
Executable File
#include <applicat.h>
|
|
#include <assoc.h>
|
|
#include <automask.h>
|
|
#include <config.h>
|
|
#include <defmask.h>
|
|
#include <diction.h>
|
|
#include <progind.h>
|
|
#include <scanner.h>
|
|
#include <utility.h>
|
|
|
|
#include "ba2.h"
|
|
#include "ba2700.h"
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TDictionary_entry
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TDictionary_entry : public TSortable
|
|
{
|
|
public:
|
|
TString _ita, _eng;
|
|
TToken_string _src;
|
|
int _max_length;
|
|
|
|
virtual int compare(const TSortable& obj) const;
|
|
virtual void print_on(ostream& out) const;
|
|
|
|
void set_translation(const char* eng) { _eng = eng; }
|
|
void add_source(const char* orig);
|
|
void set_sources(const char* orig);
|
|
void update_max_length(int len);
|
|
TDictionary_entry(const char* ita) : _ita(ita), _eng("???"), _src(12, ','), _max_length(0) { }
|
|
};
|
|
|
|
void TDictionary_entry::add_source(const char* orig)
|
|
{
|
|
if (_src.items() < 8)
|
|
{
|
|
TFilename n(orig); n.lower();
|
|
const char* src = n.name();
|
|
if (_src.get_pos(src))
|
|
_src.add(src);
|
|
}
|
|
}
|
|
|
|
void TDictionary_entry::set_sources(const char* orig)
|
|
{
|
|
_src = orig;
|
|
}
|
|
|
|
void TDictionary_entry::update_max_length(int len)
|
|
{
|
|
if (len > 0 && (_max_length <= 0 || len < _max_length))
|
|
_max_length = len;
|
|
}
|
|
|
|
int TDictionary_entry::compare(const TSortable& obj) const
|
|
{
|
|
const TDictionary_entry& e = (const TDictionary_entry&)obj;
|
|
return _ita.compare(e._ita, -1, true);
|
|
}
|
|
|
|
void TDictionary_entry::print_on(ostream& out) const
|
|
{
|
|
out << " <entry>" << endl;
|
|
out << " <ita>" << txt2xml(_ita) << "</ita>" << endl;
|
|
out << " <eng>" << txt2xml(_eng) << "</eng>" << endl;
|
|
if (_max_length > 0)
|
|
out << " <max>" << _max_length << "</max>" << endl;
|
|
out << " <src>" << txt2xml(_src) << "</src>" << endl;
|
|
out << " </entry>" << endl;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TDictionary
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TDictionary : public TAssoc_array
|
|
{
|
|
TFilename _filename;
|
|
TPointer_array _sort;
|
|
bool _sort_needed, _save_needed;
|
|
|
|
public:
|
|
TDictionary_entry& get_entry(const char* ita);
|
|
TPointer_array& sorted();
|
|
|
|
void set_translation(const char* ita, const char* eng);
|
|
void update_max_length(const char* ita, int len);
|
|
|
|
bool read(const char* fname);
|
|
bool write();
|
|
bool write_if_needed();
|
|
TDictionary() : _sort_needed(false), _save_needed(false) { }
|
|
};
|
|
|
|
TDictionary_entry& TDictionary::get_entry(const char* ita)
|
|
{
|
|
TDictionary_entry* entry = (TDictionary_entry*)objptr(ita);
|
|
if (entry == NULL)
|
|
{
|
|
entry = new TDictionary_entry(ita);
|
|
add(ita, entry);
|
|
_sort_needed = _save_needed = true;
|
|
}
|
|
return *entry;
|
|
}
|
|
|
|
void TDictionary::set_translation(const char* ita, const char* eng)
|
|
{
|
|
TDictionary_entry& entry = get_entry(ita);
|
|
entry.set_translation(eng);
|
|
_save_needed = true;
|
|
}
|
|
|
|
void TDictionary::update_max_length(const char* ita, int len)
|
|
{
|
|
TDictionary_entry& entry = get_entry(ita);
|
|
entry.update_max_length(len);
|
|
_save_needed = true;
|
|
}
|
|
|
|
|
|
bool TDictionary::read(const char* fname)
|
|
{
|
|
_filename = fname;
|
|
bool ok = _filename.exist();
|
|
if (ok)
|
|
{
|
|
TProgind pi(fsize(_filename), "Lettura dizionario", false, true);
|
|
destroy();
|
|
TScanner scan(_filename);
|
|
TString ita;
|
|
while (scan.ok())
|
|
{
|
|
TString& line = scan.line();
|
|
if (line.empty())
|
|
break;
|
|
pi.setstatus(scan.tellg());
|
|
line.trim();
|
|
if (line.starts_with("<ita>"))
|
|
{
|
|
const int eoi = line.find("</ita>");
|
|
ita = xml2txt(line.sub(5, eoi));
|
|
} else
|
|
if (line.starts_with("<eng>") && ita.not_empty())
|
|
{
|
|
const int eoe = line.find("</eng>");
|
|
const TString& eng = xml2txt(line.sub(5, eoe));
|
|
set_translation(ita, eng);
|
|
}
|
|
if (line.starts_with("<max>") && ita.not_empty())
|
|
{
|
|
const int eom = line.find("</max>");
|
|
const int len = atoi(line.sub(5, eom));
|
|
update_max_length(ita, len);
|
|
}
|
|
if (line.starts_with("<src>") && ita.not_empty())
|
|
{
|
|
TDictionary_entry& entry = get_entry(ita);
|
|
const int eos = line.find("</src>");
|
|
entry.set_sources(xml2txt(line.sub(5, eos)));
|
|
}
|
|
}
|
|
_save_needed = false;
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
bool TDictionary::write()
|
|
{
|
|
TProgind pi(items(), "Salvataggio dizionario", false, true);
|
|
TPointer_array& ref = sorted();
|
|
|
|
ofstream outf(_filename);
|
|
outf << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" << endl;
|
|
outf << "<dictionary>" << endl;
|
|
for (int i = 0; i < ref.items(); i++)
|
|
{
|
|
pi.addstatus(1);
|
|
const TDictionary_entry& e = (const TDictionary_entry&)ref[i];
|
|
outf << e;
|
|
}
|
|
outf << "</dictionary>" << endl;
|
|
_save_needed = false;
|
|
return true;
|
|
}
|
|
|
|
bool TDictionary::write_if_needed()
|
|
{
|
|
bool ok = _save_needed;
|
|
if (ok)
|
|
{
|
|
ok = yesno_box("Si desidera registrare le modifiche al dizionario %s?", (const char*)_filename);
|
|
if (ok)
|
|
ok = write();
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
static int sort_entries(const TObject** o1, const TObject** o2)
|
|
{
|
|
const TDictionary_entry* e1 = (const TDictionary_entry*)*o1;
|
|
const TDictionary_entry* e2 = (const TDictionary_entry*)*o2;
|
|
return e1->compare(*e2);
|
|
}
|
|
|
|
TPointer_array& TDictionary::sorted()
|
|
{
|
|
if (_sort_needed)
|
|
{
|
|
_sort.destroy();
|
|
FOR_EACH_ASSOC_OBJECT((*this), h, k, o)
|
|
_sort.add(o);
|
|
_sort.sort(sort_entries);
|
|
_sort_needed = false;
|
|
}
|
|
return _sort;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TDictionary_mask
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TDictionary_mask : public TAutomask
|
|
{
|
|
TDictionary _dictionary;
|
|
|
|
protected:
|
|
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
|
|
|
|
const TString& get_dictionary_name() const;
|
|
void set_dictionary_name(const char* name);
|
|
|
|
bool is_a_word(const TString& ita) const;
|
|
void add_line(const TString& ita, const char* origin);
|
|
void read_txt_file(const char* fname, int filetype);
|
|
bool read_txt_files(const char* msk);
|
|
bool read_bin_file(const char* fname);
|
|
bool read_bin_files(const char* msk);
|
|
void build_dictionary();
|
|
|
|
bool read_dictionary();
|
|
void fill_index();
|
|
void fill_chapter();
|
|
|
|
public:
|
|
TDictionary_mask();
|
|
~TDictionary_mask();
|
|
};
|
|
|
|
const TString& TDictionary_mask::get_dictionary_name() const
|
|
{
|
|
TConfig ini("servers/servers.ini", "Dictionary");
|
|
TFilename n = ini.get("Dictionary");
|
|
if (n.is_relative_path())
|
|
n.insert("servers/");
|
|
TString& tmp = get_tmp_string();
|
|
tmp = n;
|
|
return tmp;
|
|
}
|
|
|
|
void TDictionary_mask::set_dictionary_name(const char* name)
|
|
{
|
|
TFilename n(name);
|
|
if (n.starts_with("servers"))
|
|
n.ltrim();
|
|
|
|
TConfig ini("servers/servers.ini", "Dictionary");
|
|
ini.set("Dictionary", n);
|
|
}
|
|
|
|
bool TDictionary_mask::read_dictionary()
|
|
{
|
|
_dictionary.write_if_needed();
|
|
const TFilename fname = get_dictionary_name();
|
|
const bool ok = _dictionary.read(fname);
|
|
fill_index();
|
|
fill_chapter();
|
|
return ok;
|
|
}
|
|
|
|
bool TDictionary_mask::is_a_word(const TString& ita) const
|
|
{
|
|
for (int i = 0; ita[i]; i++)
|
|
{
|
|
if (isalpha(ita[i]))
|
|
{
|
|
if (i == 0 || ita[i-1] != '@')
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
inline bool valid_char(char c)
|
|
{
|
|
return isalnum(c) || strchr("@%'", c);
|
|
}
|
|
|
|
void TDictionary_mask::add_line(const TString& ita, const char* origin)
|
|
{
|
|
int prefix = 0, suffix = 0;
|
|
for (prefix = 0; ita[prefix] != '\0' && !valid_char(ita[prefix]); prefix++);
|
|
for (suffix = ita.len()-1; suffix > prefix && !valid_char(ita[suffix]); suffix--);
|
|
const TString& text = ita.sub(prefix, suffix+1);
|
|
|
|
if (is_a_word(text))
|
|
{
|
|
TDictionary_entry& entry = _dictionary.get_entry(text);
|
|
entry.add_source(origin);
|
|
|
|
int spaces = 0;
|
|
for (int i = ita.len()-1; i > 0 && ita[i] == ' '; i--, spaces++);
|
|
if (spaces > 0)
|
|
entry.update_max_length(text.len() + spaces);
|
|
}
|
|
}
|
|
|
|
void TDictionary_mask::read_txt_file(const char* fname, int filetype)
|
|
{
|
|
TScanner scan(fname);
|
|
|
|
TString ita;
|
|
while (scan.ok())
|
|
{
|
|
TString& line = scan.line();
|
|
if (line.empty())
|
|
break;
|
|
line.trim();
|
|
|
|
bool good = false;
|
|
switch (filetype)
|
|
{
|
|
case 1:
|
|
good = line.starts_with("IT") || line.starts_with("PA") ||
|
|
line.starts_with("PR") || line.starts_with("WA") ||
|
|
line.starts_with("DI");
|
|
break;
|
|
case 2:
|
|
good = line.starts_with("IT") || line.starts_with("PR");
|
|
break;
|
|
case 3:
|
|
good = line.starts_with("Caption ") || line.starts_with("Item_");
|
|
break;
|
|
case 4:
|
|
good = line.starts_with("Item_");
|
|
if (good)
|
|
{
|
|
TToken_string str(line);
|
|
line.cut(0);
|
|
line << "PR \"" << str.get(1) << '"';
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (good)
|
|
{
|
|
int apicia = 0, apicic = 0;
|
|
if (filetype == 1 && line.starts_with("DI"))
|
|
{
|
|
const int at = line.find('@');
|
|
if (at > 0)
|
|
line[at] = '"';
|
|
}
|
|
if (filetype <= 2 && line.starts_with("IT"))
|
|
{
|
|
apicia = line.find('|');
|
|
if (apicia < 0)
|
|
apicia = line.find('"');
|
|
const int at = line.find('@', apicia+1);
|
|
const int ap = line.find('"', apicia+1);
|
|
apicic = (at > 0 && at < ap) ? at : ap;
|
|
}
|
|
else
|
|
{
|
|
apicia = line.find('"');
|
|
apicic = line.find('"', apicia+1);
|
|
}
|
|
if (apicic > apicia)
|
|
{
|
|
ita = line.sub(apicia+1, apicic);
|
|
if (filetype <= 2 && line.starts_with("PR"))
|
|
{
|
|
if (ita[0] == '@')
|
|
ita.ltrim(2);
|
|
if (ita[0] == '$')
|
|
{
|
|
const int closed = ita.find(']');
|
|
ita.ltrim(closed+1);
|
|
}
|
|
if (filetype == 1 || filetype == 4)
|
|
ita.strip("~&");
|
|
}
|
|
add_line(ita, fname);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool TDictionary_mask::read_txt_files(const char* msk)
|
|
{
|
|
TString_array arr;
|
|
list_files(msk, arr);
|
|
|
|
TString msg;
|
|
msg << "Scansione files " << msk;
|
|
TProgind pi(arr.items(), msg, true, true);
|
|
|
|
TString strmsk(msk); strmsk.upper();
|
|
int filetype = 0;
|
|
if (strmsk.find(".MSK") > 0)
|
|
filetype = 1; else
|
|
if (strmsk.find(".FRM") > 0)
|
|
filetype = 2; else
|
|
if (strmsk.find(".MEN") > 0)
|
|
filetype = 3;
|
|
if (strmsk.find(".INI") > 0)
|
|
filetype = 4;
|
|
|
|
bool finished = true;
|
|
|
|
FOR_EACH_ARRAY_ROW(arr, i, row)
|
|
{
|
|
pi.addstatus(1);
|
|
if (pi.iscancelled())
|
|
{
|
|
finished = false;
|
|
break;
|
|
}
|
|
|
|
TFilename n = *row;
|
|
read_txt_file(n, filetype);
|
|
|
|
n.custom_path();
|
|
if (n != *row)
|
|
read_txt_file(n, filetype);
|
|
}
|
|
|
|
return finished;
|
|
}
|
|
|
|
bool TDictionary_mask::read_bin_file(const char* fname)
|
|
{
|
|
TProgind bi(fsize(fname), fname, true, true);
|
|
|
|
const int match[4] = { 3, 2, 1, 0 };
|
|
int counter = 0;
|
|
bool finished = true;
|
|
TString ita(1024);
|
|
|
|
ifstream scan(fname, ios::binary);
|
|
while (!scan.eof())
|
|
{
|
|
bi.addstatus(1);
|
|
|
|
const int ch = scan.get();
|
|
if (ch == EOF)
|
|
break;
|
|
if (counter < 4)
|
|
{
|
|
if (ch == match[counter])
|
|
counter++;
|
|
else
|
|
counter = 0;
|
|
}
|
|
else
|
|
{
|
|
const int index = counter-4;
|
|
if (index == 0)
|
|
{
|
|
ita.cut(0);
|
|
if (bi.iscancelled())
|
|
{
|
|
finished = false;
|
|
break;
|
|
}
|
|
}
|
|
ita << char(ch);
|
|
if (ch == 0)
|
|
{
|
|
if (index > 0)
|
|
add_line(ita, fname);
|
|
counter = 0;
|
|
}
|
|
else
|
|
counter++;
|
|
}
|
|
}
|
|
return finished;
|
|
}
|
|
|
|
bool TDictionary_mask::read_bin_files(const char* msk)
|
|
{
|
|
TString_array arr;
|
|
list_files(msk, arr);
|
|
|
|
TString msg;
|
|
msg << "Scansione programmi " << msk;
|
|
TProgind pi(arr.items(), msg, false, true);
|
|
|
|
FOR_EACH_ARRAY_ROW(arr, i, row)
|
|
{
|
|
pi.addstatus(1);
|
|
if (!read_bin_file(*row))
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void TDictionary_mask::build_dictionary()
|
|
{
|
|
bool go = read_txt_files("*.msk");
|
|
if (go) go = read_txt_files("*.frm");
|
|
if (go) go = read_txt_files("*.men");
|
|
if (go) go = read_txt_files("res/resource.ini");
|
|
if (go) go = read_bin_files("???.exe");
|
|
|
|
fill_index();
|
|
fill_chapter();
|
|
}
|
|
|
|
void TDictionary_mask::fill_index()
|
|
{
|
|
TToken_string letters = " ";
|
|
char last_letter = ' ';
|
|
TPointer_array& ref = _dictionary.sorted();
|
|
for (int i = 0; i < ref.items(); i++)
|
|
{
|
|
const TDictionary_entry& entry = (const TDictionary_entry&)ref[i];
|
|
const char letter = toupper(entry._ita[0]);
|
|
if (letter != last_letter)
|
|
{
|
|
last_letter = letter;
|
|
letters.add(letter);
|
|
}
|
|
}
|
|
set(F_TOTAL, ref.items());
|
|
TList_field& alfabeto = (TList_field&)field(F_ALFABETO);
|
|
alfabeto.replace_items(letters, letters);
|
|
alfabeto.set("A");
|
|
}
|
|
|
|
void TDictionary_mask::fill_chapter()
|
|
{
|
|
const char letter = get(F_ALFABETO)[0];
|
|
|
|
TSheet_field& s = sfield(F_CAPITOLO);
|
|
s.destroy();
|
|
TPointer_array& ref = _dictionary.sorted();
|
|
|
|
for (int i = 0; i < ref.items(); i++)
|
|
{
|
|
const TDictionary_entry& e = (const TDictionary_entry&)ref[i];
|
|
if (toupper(e._ita[0]) == letter)
|
|
{
|
|
TToken_string& row = s.row(-1);
|
|
row = e._ita;
|
|
row.add(e._eng);
|
|
row.add(e._max_length);
|
|
row.add(e._src);
|
|
}
|
|
}
|
|
s.force_update();
|
|
set(F_ENTRIES, s.items());
|
|
enable(DLG_SAVEREC, ref.items() > 0);
|
|
}
|
|
|
|
bool TDictionary_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
|
|
{
|
|
switch (o.dlg())
|
|
{
|
|
case F_FILENAME:
|
|
if (e == fe_init)
|
|
{
|
|
o.set(get_dictionary_name());
|
|
read_dictionary();
|
|
}
|
|
if (e == fe_modify)
|
|
{
|
|
const TFilename n = o.get();
|
|
if (n.exist())
|
|
{
|
|
set_dictionary_name(n);
|
|
o.set(get_dictionary_name());
|
|
read_dictionary();
|
|
}
|
|
else
|
|
return error_box("File assente");
|
|
}
|
|
break;
|
|
case F_ALFABETO:
|
|
if (e == fe_modify)
|
|
fill_chapter();
|
|
break;
|
|
case DLG_SAVEREC:
|
|
if (e == fe_button)
|
|
_dictionary.write();
|
|
break;
|
|
case DLG_ELABORA:
|
|
if (e == fe_button)
|
|
build_dictionary();
|
|
break;
|
|
case F_CAPITOLO:
|
|
if (e == se_query_add)
|
|
return false;
|
|
if (e == se_notify_modify)
|
|
{
|
|
TSheet_field& s = (TSheet_field&)o;
|
|
TToken_string& row = s.row(jolly);
|
|
const TString& ita = row.get(0);
|
|
const TString& eng = row.get(1);
|
|
const int len = row.get_int(2);
|
|
_dictionary.set_translation(ita, eng);
|
|
if (len > 0 && eng.len() > len)
|
|
warning_box("La traduzione e' lunga %d caratteri (max. %d)!", eng.len(), len);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
TDictionary_mask::TDictionary_mask()
|
|
{
|
|
// Allarga numero di riga degli spreadsheet
|
|
TSheet_field::set_line_number_width(4);
|
|
// Simula lettura ed inizilizzazione della Automak
|
|
read_mask("ba2700", 0, MAX_PAGES);
|
|
set_handlers();
|
|
}
|
|
|
|
TDictionary_mask::~TDictionary_mask()
|
|
{
|
|
_dictionary.write_if_needed();
|
|
}
|
|
|
|
class TDictionary_manager : public TSkeleton_application
|
|
{
|
|
public:
|
|
virtual void main_loop();
|
|
};
|
|
|
|
void TDictionary_manager::main_loop()
|
|
{
|
|
TDictionary_mask dm;
|
|
dm.run();
|
|
}
|
|
|
|
int ba2700(int argc, char* argv[])
|
|
{
|
|
TDictionary_manager a;
|
|
a.run(argc, argv, TR("Creazione dizionario"));
|
|
return 0;
|
|
}
|