kiten/dict.cpp

   1 /**
   2  This file is part of Kiten, a KDE Japanese Reference Tool...
   3  Copyright (C) 2001  Jason Katz-Brown <jason@katzbrown.com>
   4
   5  This program is free software; you can redistribute it and/or modify
   6  it under the terms of the GNU General Public License as published by
   7  the Free Software Foundation; either version 2 of the License, or
   8  (at your option) any later version.
   9
  10  This program is distributed in the hope that it will be useful,
  11  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  GNU General Public License for more details.
  14
  15  You should have received a copy of the GNU General Public License
  16  along with this program; if not, write to the Free Software
  17  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  18  USA
  19 **/
  20
  21 #include <kdebug.h>
  22 #include <klocale.h>
  23 #include <kmessagebox.h>
  24 #include <kprocess.h>
  25 #include <kstandarddirs.h>
  26
  27 #include <qfileinfo.h>
  28 #include <qregexp.h>
  29 #include <qtextcodec.h>
  30
  31 #include "dict.h"
  32
  33 #include <iostream>
  34 #include <cassert>
  35 #include <sys/mman.h>
  36 #include <stdio.h>
  37
  38 namespace
  39 {
  40 void msgerr(const QString &msg, const QString &dict = QString::null)
  41 {
  42         QString output = msg;
  43         if (!dict.isNull())
  44                 output = msg.arg(dict);
  45         KMessageBox::error(0, output);
  46 }
  47 }
  48
  49 using namespace Dict;
  50
  51 TextType Dict::textType(const QString &text)
  52 {
  53         ushort first = text.at(0).unicode();
  54
  55         if (first < 0x3000)
  56                 return Text_Latin;
  57         // else if (first < 0x3040) // CJK Symbols and Punctuation
  58                         // return Text_Kana;
  59                 // else if (first < 0x30A0) // Hiragana
  60                         // return Text_Kana;
  61         else if (first < 0x3100) // Katakana
  62                 return Text_Kana;
  63
  64         else /*if (first >= 0x3400 && first < 0x4DC0)*/ // CJK Unified Ideographs Extension A
  65                 return Text_Kanji;
  66 }
  67
  68 File::File(QString path, QString n)
  69         : myName(n)
  70         , dictFile(path)
  71         , dictPtr((const unsigned char *)MAP_FAILED)
  72         , indexFile(KGlobal::dirs()->saveLocation("data", "kiten/xjdx/", true) + QFileInfo(path).baseName() + ".xjdx")
  73         , indexPtr((const uint32_t *)MAP_FAILED)
  74         , valid(false)
  75 {
  76         bool forceUpdate = false;
  77
  78         bool indexFileExists = indexFile.exists();
  79         if (indexFileExists)
  80         {
  81                 // ### change this if need be!!
  82                 const int indexFileVersion = 14;
  83
  84                 // this up-to-date code from xjdservcomm.c
  85                 // we need to check if the index needs to
  86                 // remade
  87
  88                 int dictionaryLength;
  89                 QFile dictionary(path);
  90                 dictionaryLength = dictionary.size();
  91                 dictionaryLength++;
  92                 //kdDebug() << "dictionaryLength = " << dictionaryLength << endl;
  93
  94                 int32_t testWord[1];
  95                 fread(&testWord[0], sizeof(int32_t), 1, fopen(indexFile.name().latin1(), "rb"));
  96
  97                 //kdDebug() << "testWord[0] = " << testWord[0] << endl;
  98
  99                 if (testWord[0] != (dictionaryLength + indexFileVersion))
 100                         forceUpdate = true;
 101         }
 102
 103         if (!indexFileExists || forceUpdate)
 104         {
 105                 //kdDebug() << "creating " << indexFile.name() << endl;
 106                 // find the index generator executable
 107                 KProcess proc;
 108                 proc << KStandardDirs::findExe("kitengen") << path << indexFile.name();
 109                 // TODO: put up a status dialog and event loop instead of blocking
 110                 proc.start(KProcess::Block, KProcess::NoCommunication);
 111         }
 112
 113         if (!dictFile.open(IO_ReadOnly))
 114         {
 115                 msgerr(i18n("Could not open dictionary %1."), path);
 116                 return;
 117         }
 118
 119         dictPtr = (const unsigned char *)mmap(0, dictFile.size(), PROT_READ, MAP_SHARED, dictFile.handle(), 0);
 120         if (dictPtr == (unsigned char*) MAP_FAILED)
 121         {
 122                 msgerr(i18n("Memory error when loading dictionary %1."), path);
 123                 return;
 124         }
 125
 126         if (!indexFile.open(IO_ReadOnly))
 127         {
 128                 msgerr(i18n("Could not open index for dictionary %1."), path);
 129                 return;
 130         }
 131
 132         indexPtr = (const uint32_t*)mmap(0, indexFile.size(), PROT_READ, MAP_SHARED, indexFile.handle(), 0);
 133         if (indexPtr == (uint32_t*) MAP_FAILED)
 134         {
 135                 msgerr(i18n("Memory error when loading dictionary %1's index file."), path);
 136                 return;
 137         }
 138
 139         valid = true;
 140 }
 141
 142 File::~File(void)
 143 {
 144         if (dictPtr != (unsigned char*) MAP_FAILED)
 145                 munmap((char *)dictPtr, dictFile.size());
 146         dictFile.close();
 147
 148         if (indexPtr != (uint32_t*) MAP_FAILED)
 149                 munmap((char *)indexPtr, indexFile.size());
 150         indexFile.close();
 151 }
 152
 153 QString File::name(void)
 154 {
 155         return myName;
 156 }
 157
 158 Array<const unsigned char> File::dict(void)
 159 {
 160         assert(valid);
 161         return Array<const unsigned char>(dictPtr, dictFile.size());
 162 }
 163
 164 Array<const uint32_t> File::index(void)
 165 {
 166         assert(valid);
 167         return Array<const uint32_t>(indexPtr, indexFile.size());
 168 }
 169
 170 int File::dictLength(void)
 171 {
 172         return dictFile.size();
 173 }
 174
 175 int File::indexLength(void)
 176 {
 177         return indexFile.size();
 178 }
 179
 180 bool File::isValid(void)
 181 {
 182         return valid;
 183 }
 184
 185 // returns specified character from a dictionary
 186 unsigned char File::lookup(unsigned i, int offset)
 187 {
 188         uint32_t pos = indexPtr[i] + offset - 1;
 189         if (pos > dictFile.size()) return 10;
 190         return dictPtr[pos];
 191 }
 192
 193 QCString File::lookup(unsigned i)
 194 {
 195         uint32_t start = indexPtr[i] - 1;
 196         uint32_t pos = start;
 197         const unsigned size = dictFile.size();
 198         // get the whole word
 199         while(pos <= size && dictPtr[pos] != 0 && dictPtr[pos] != 0x0a)
 200                 ++pos;
 201         // put the word in the QCString
 202         QCString retval((const char *)(dictPtr + start), pos - start);
 203         // tack on a null
 204         char null = 0;
 205         retval.append(&null);
 206         // and away we go
 207         return retval;
 208 }
 209
 210 // And last, Index itself is the API presented to the rest of Kiten
 211 Index::Index()
 212         : QObject()
 213 {
 214         dictFiles.setAutoDelete(true);
 215         kanjiDictFiles.setAutoDelete(true);
 216 }
 217
 218 Index::~Index()
 219 {
 220 }
 221
 222 void Index::setDictList(const QStringList &list, const QStringList &names)
 223 {
 224         loadDictList(dictFiles, list, names);
 225 }
 226
 227 void Index::setKanjiDictList(const QStringList &list, const QStringList &names)
 228 {
 229         loadDictList(kanjiDictFiles, list, names);
 230 }
 231
 232 void Index::loadDictList(QPtrList<File> &fileList, const QStringList &dictList, const QStringList &dictNameList)
 233 {
 234         fileList.clear();
 235
 236         // check if we have a dict
 237         if (dictList.size() < 1)
 238         {
 239                 msgerr(i18n("No dictionaries in list!"));
 240                 return;
 241         }
 242
 243         QStringList::ConstIterator it;
 244         QStringList::ConstIterator dictIt;
 245         for (it = dictList.begin(), dictIt = dictNameList.begin(); it != dictList.end(); ++it, ++dictIt)
 246         {
 247                 File *f = new File(*it, *dictIt);
 248                 // our ugly substitute for exceptions
 249                 if (f->isValid())
 250                         fileList.append(f);
 251                 else
 252                         delete f;
 253         }
 254 }
 255
 256 QStringList Index::doSearch(File &file, const QString &text)
 257 {
 258         // Do a binary search to find an entry that matches text
 259         QTextCodec &codec = *QTextCodec::codecForName("eucJP");
 260         QCString eucString = codec.fromUnicode(text);
 261
 262         QString prevResult;
 263
 264         Array<const uint32_t> index = file.index();
 265         Array<const unsigned char> dict = file.dict();
 266         int lo = 0;
 267         int hi = index.size() - 1;
 268         unsigned cur;
 269         int comp = 0;
 270
 271         do
 272         {
 273                 cur = (hi + lo) / 2;
 274                 comp = stringCompare(file, cur, eucString);
 275
 276                 if (comp < 0)
 277                         hi = cur - 1;
 278                 else if (comp > 0)
 279                         lo = cur + 1;
 280         }
 281         while(hi >= lo && comp != 0 && !(hi == 0 && lo == 0));
 282         QStringList results;
 283         // A match?
 284         if (comp == 0)
 285         {
 286                 // wheel back to make sure we get the first matching entry
 287                 while(cur - 1 && 0 == stringCompare(file, cur - 1, eucString))
 288                         --cur;
 289
 290                 // output every matching entry
 291                 while(cur < index.size() && 0 == stringCompare(file, cur, eucString))
 292                 {
 293                         // because the index doesn't point
 294                         // to the start of the line, find the
 295                         // start of the line:
 296                         int i = 0;
 297                         while(file.lookup(cur, i - 1) != 0x0a) --i;
 298
 299                         QByteArray bytes(0);
 300                         while(file.lookup(cur, i) != 0x0a) // get to end of our line
 301                         {
 302                                 const char eucchar = file.lookup(cur, i);
 303                                 bytes.resize(bytes.size() + 1);
 304                                 bytes[bytes.size() - 1] = eucchar;
 305                                 ++i;
 306                         }
 307
 308                         QString result = codec.toUnicode(bytes) + QString("\n");
 309                         if (prevResult != result)
 310                         {
 311                                 results.append(result);
 312                                 prevResult = result;
 313                         }
 314
 315                         ++cur;
 316                 }
 317         }
 318
 319         // return all the entries found, or null if no match
 320         return results;
 321 }
 322
 323 SearchResult Index::scanResults(QRegExp regexp, QStringList results, bool common)
 324 {
 325         unsigned int num = 0;
 326         unsigned int fullNum = 0;
 327
 328         SearchResult ret;
 329
 330         //ret.results = results; //not here..
 331
 332         for (QStringList::Iterator itr = results.begin(); itr != results.end(); ++itr)
 333         {
 334                 if ((*itr).left(5) == "DICT " || (*itr).left(8) == "HEADING ")
 335                 {
 336                         ret.list.append(parse(*itr));
 337                         continue;
 338                 }
 339
 340                 int found = regexp.search(*itr);
 341
 342                 if (found >= 0)
 343                 {
 344                         ++fullNum;
 345                         if ((*itr).find(QString("(P)")) >= 0 || !common)
 346                         {
 347                                 // we append HERE, so we get the exact
 348                                 // results we have in ret.list
 349
 350                                 ret.results.append(*itr);
 351                                 ret.list.append(parse(*itr));
 352                                 ++num;
 353                         }
 354                 }
 355         }
 356
 357         ret.count = num;
 358         ret.outOf = fullNum;
 359         ret.common = common;
 360         return ret;
 361 }
 362
 363 SearchResult Index::search(QRegExp regexp, const QString &text, bool common)
 364 {
 365         QStringList results;
 366         for (QPtrListIterator<File> file(dictFiles); *file; ++file)
 367         {
 368                 results.append(QString("DICT ") + (*file)->name());
 369
 370                 results += doSearch(**file, text);
 371         }
 372
 373         SearchResult res = scanResults(regexp, results, common);
 374         res.text = text;
 375         return res;
 376 }
 377
 378 SearchResult Index::scanKanjiResults(QRegExp regexp, QStringList results, bool common)
 379 {
 380         unsigned int num = 0;
 381         unsigned int fullNum = 0;
 382         const bool jmyCount = false; // don't count JinMeiYou as common
 383         SearchResult ret;
 384         ret.results = results;
 385
 386         for (QStringList::Iterator itr = results.begin(); itr != results.end(); ++itr)
 387         {
 388                 if ((*itr).left(5) == "DICT " || (*itr).left(8) == "HEADING ")
 389                 {
 390                         ret.list.append(kanjiParse(*itr));
 391                         continue;
 392                 }
 393
 394                 int found = regexp.search(*itr);
 395
 396                 if (found >= 0)
 397                 {
 398                         ++fullNum;
 399                         // common entries have G[1-8] (jouyou)
 400                         QRegExp comregexp(jmyCount ? "G[1-9]" : "G[1-8]");
 401                         if ((*itr).find(comregexp) >= 0 || !common)
 402                         {
 403                                 ret.list.append(kanjiParse(*itr));
 404                                 ++num;
 405                         }
 406                 }
 407         }
 408
 409         ret.count = num;
 410         ret.outOf = fullNum;
 411         ret.common = common;
 412         return ret;
 413 }
 414
 415 SearchResult Index::searchKanji(QRegExp regexp, const QString &text,  bool common)
 416 {
 417         QStringList results;
 418         for (QPtrListIterator<File> file(kanjiDictFiles); *file; ++file)
 419         {
 420                 results.append(QString("DICT ") + (*file)->name());
 421
 422                 results += doSearch(**file, text);
 423         }
 424
 425         SearchResult res = scanKanjiResults(regexp, results, common);
 426         res.text = text;
 427         return res;
 428 }
 429
 430 SearchResult Index::searchPrevious(QRegExp regexp, const QString &text, SearchResult list, bool common)
 431 {
 432         SearchResult res;
 433
 434         if (firstEntry(list).extendedKanjiInfo())
 435                 res = scanKanjiResults(regexp, list.results, common);
 436         else
 437                 res = scanResults(regexp, list.results, common);
 438
 439         res.text = text;
 440         return res;
 441 }
 442
 443 QRegExp Dict::Index::createRegExp(SearchType type, const QString &text, DictionaryType dictionaryType, bool caseSensitive)
 444 {
 445         QString regExp;
 446         switch (type)
 447         {
 448         case Search_Beginning:
 449                 switch (textType(text))
 450                 {
 451                 case Dict::Text_Latin:
 452                         regExp = "\\W%1";
 453                         break;
 454
 455                 case Dict::Text_Kana:
 456                         if (dictionaryType == Kanjidict)
 457                                 regExp = "\\W%1";
 458                         else // edict
 459                                 regExp = "\\[%1";
 460                         break;
 461
 462                 case Dict::Text_Kanji:
 463                         regExp = "^%1";
 464                 }
 465                 break;
 466
 467         case Search_FullWord:
 468                 switch (textType(text))
 469                 {
 470                 case Dict::Text_Latin:
 471                         regExp = "\\W%1\\W";
 472                         break;
 473
 474                 case Dict::Text_Kana:
 475                         if (dictionaryType == Kanjidict)
 476                                 regExp = " %1 ";
 477                         else // edict
 478                                 regExp = "\\[%1\\]";
 479                         break;
 480
 481                 case Dict::Text_Kanji:
 482                         regExp = "^%1\\W";
 483                 }
 484                 break;
 485
 486         case Search_Anywhere:
 487                 regExp = "%1";
 488         }
 489
 490         return QRegExp(regExp.arg(text), caseSensitive);
 491 }
 492
 493 int Index::stringCompare(File &file, int index, QCString str)
 494 {
 495         return eucStringCompare(file.lookup(index), str);
 496 }
 497
 498 // effectively does a strnicmp on two "strings"
 499 // except it will make katakana and hiragana match (EUC A4 & A5)
 500 int Dict::eucStringCompare(const char *str, const char *str2)
 501 {
 502         for (unsigned i = 0; ; ++i)
 503         {
 504                 unsigned char c = static_cast<unsigned char>(str[i]);
 505                 unsigned char c2 = static_cast<unsigned char>(str2[i]);
 506                 if ((c2 == '\0') || (c == '\0'))
 507                         return 0;
 508
 509                 if ((i % 2) == 0)
 510                 {
 511                         if (c2 == 0xA5)
 512                                 c2 = 0xA4;
 513
 514                         if (c == 0xA5)
 515                                 c = 0xA4;
 516                 }
 517
 518                 if ((c2 >= 'A') && (c2 <= 'Z')) c2 |= 0x20; /*fix ucase*/
 519                 if ((c >= 'A') && (c <= 'Z')) c |= 0x20;
 520
 521                 if (c2 != c)
 522                         return (int)c2 - (int)c;
 523         }
 524
 525         return 0;
 526 }
 527
 528 bool Dict::isEUC(unsigned char c)
 529 {
 530         return (c & 0x80);
 531 }
 532
 533 Entry Dict::parse(const QString &raw)
 534 {
 535         unsigned int length = raw.length();
 536         if (raw.left(5) == "DICT ")
 537                 return Entry(raw.right(length - 5));
 538         if (raw.left(8) == "HEADING ")
 539                 return Entry(raw.right(length - 8), true);
 540
 541         QString reading;
 542         QString kanji;
 543         QStringList meanings;
 544         QString curmeaning;
 545         bool firstmeaning = true;
 546         QCString parsemode("kanji");
 547
 548         unsigned int i;
 549         for (i = 0; i < length; i++)
 550         {
 551                 QChar ichar(raw.at(i));
 552
 553                 if (ichar == '[')
 554                 {
 555                         parsemode = "reading";
 556                 }
 557                 else if (ichar == ']')
 558                 {
 559                         // do nothing
 560                 }
 561                 else if (ichar == '/')
 562                 {
 563                         if (!firstmeaning)
 564                         {
 565                                 meanings.append(curmeaning);
 566                                 curmeaning = "";
 567                         }
 568                         else
 569                         {
 570                                 firstmeaning = false;
 571                                 parsemode = "meaning";
 572                         }
 573                 }
 574                 else if (ichar == ' ')
 575                 {
 576                         if (parsemode == "meaning") // only one that needs the space
 577                                 curmeaning += ' ';
 578                 }
 579                 else if (parsemode == "kanji")
 580                 {
 581                         kanji += ichar;
 582                 }
 583                 else if (parsemode == "meaning")
 584                 {
 585                         curmeaning += ichar;
 586                 }
 587                 else if (parsemode == "reading")
 588                 {
 589                         reading += ichar;
 590                 }
 591         }
 592
 593         return (Entry(kanji, reading, meanings));
 594 }
 595
 596 Entry Dict::kanjiParse(const QString &raw)
 597 {
 598         unsigned int length = raw.length();
 599         if (raw.left(5) == "DICT ")
 600                 return Entry(raw.right(length - 5));
 601         if (raw.left(8) == "HEADING ")
 602                 return Entry(raw.right(length - 8), true);
 603
 604         QStringList readings;
 605         QString kanji;
 606         QStringList meanings;
 607         QString curmeaning;
 608         QString curreading;
 609
 610         QString strfreq;
 611         QString strgrade;
 612         QString strstrokes;
 613         QString strmiscount = "";
 614
 615         bool prevwasspace = true;
 616         QChar detailname;
 617         QCString parsemode("kanji");
 618
 619         // if there are two S entries, second is common miscount
 620         bool strokesset = false;
 621
 622         unsigned int i;
 623         QChar ichar;
 624         for (i = 0; i < length; i++)
 625         {
 626                 ichar = raw.at(i);
 627
 628                 if (ichar == ' ')
 629                 {
 630                         if (parsemode == "reading")
 631                         {
 632                                 readings.append(curreading);
 633                                 curreading = "";
 634                         }
 635                         else if (parsemode == "kanji")
 636                         {
 637                                 parsemode = "misc";
 638                         }
 639                         else if (parsemode == "detail")
 640                         {
 641                                 if (detailname == 'S')
 642                                         strokesset = true;
 643
 644                                 parsemode = "misc";
 645                         }
 646                         else if (parsemode == "meaning")
 647                         {
 648                                 curmeaning += ichar;
 649                         }
 650                         prevwasspace = true;
 651                 }
 652                 else if (ichar == '{')
 653                 {
 654                         parsemode = "meaning";
 655                 }
 656                 else if (ichar == '}')
 657                 {
 658                         meanings.append(curmeaning);
 659                         curmeaning = "";
 660                 }
 661                 else if (parsemode == "detail")
 662                 {
 663                         if (detailname == 'G')
 664                         {
 665                                 strgrade += ichar;
 666                         }
 667                         else if (detailname == 'F')
 668                         {
 669                                 strfreq += ichar;
 670                         }
 671                         else if (detailname == 'S')
 672                         {
 673                                 if (strokesset)
 674                                         strmiscount += ichar;
 675                                 else
 676                                         strstrokes += ichar;
 677                         }
 678                         prevwasspace = false;
 679                 }
 680                 else if (parsemode == "kanji")
 681                 {
 682                         kanji += ichar;
 683                 }
 684                 else if (parsemode == "meaning")
 685                 {
 686                         curmeaning += ichar;
 687                 }
 688                 else if (parsemode == "reading")
 689                 {
 690                         curreading += ichar;
 691                 }
 692                 else if (parsemode == "misc" && prevwasspace)
 693                 {
 694                         if (QRegExp("[A-Za-z0-9]").search(QString(ichar)) >= 0)
 695                                    // is non-japanese?
 696                         {
 697                                 detailname = ichar;
 698                                 parsemode = "detail";
 699                         }
 700                         else
 701                         {
 702                                 curreading = QString(ichar);
 703                                 parsemode = "reading";
 704                         }
 705                 }
 706         }
 707
 708         return (Entry(kanji, readings, meanings, strgrade.toUInt(), strfreq.toUInt(), strstrokes.toUInt(), strmiscount.toUInt()));
 709 }
 710
 711 QString Dict::prettyMeaning(QStringList Meanings)
 712 {
 713         QString meanings;
 714         QStringList::Iterator it;
 715         for (it = Meanings.begin(); it != Meanings.end(); ++it)
 716                 meanings.append((*it).stripWhiteSpace()).append("; ");
 717
 718         meanings.truncate(meanings.length() - 2);
 719         return meanings;
 720 }
 721
 722 QString Dict::prettyKanjiReading(QStringList Readings)
 723 {
 724         QStringList::Iterator it;
 725         QString html;
 726
 727         for (it = Readings.begin(); it != Readings.end(); ++it)
 728         {
 729                 if ((*it) == "T1")
 730                         html += i18n("In names: ");
 731                 else
 732                 {
 733                         if ((*it) == "T2")
 734                                 html += i18n("As radical: ");
 735                         else
 736                         {
 737                                 html += (*it).stripWhiteSpace();
 738                                 html += ", ";
 739                         }
 740                 }
 741         }
 742         html.truncate(html.length() - 2); // get rid of last ,
 743
 744         return html;
 745 }
 746
 747 Dict::Entry Dict::firstEntry(Dict::SearchResult result)
 748 {
 749         for (QValueListIterator<Dict::Entry> it = result.list.begin(); it != result.list.end(); ++it)
 750         {
 751                 if ((*it).dictName() == "__NOTSET" && (*it).header() == "__NOTSET")
 752                         return (*it);
 753         }
 754
 755         return Dict::Entry("__NOTHING");
 756 }
 757
 758 QString Dict::firstEntryText(Dict::SearchResult result)
 759 {
 760         for (QStringList::Iterator it = result.results.begin(); it != result.results.end(); ++it)
 761         {
 762                 if ((*it).left(5) != "DICT " && (*it).left(7) != "HEADER ")
 763                         return (*it);
 764         }
 765
 766         return QString("NONE ");
 767 }
 768
 769 ///////////////////////////////////////////////////////////////
 770
 771 Entry::Entry(const QString & kanji, const QString & reading, const QStringList &meanings)
 772         : DictName(QString::fromLatin1("__NOTSET"))
 773         , Header(QString::fromLatin1("__NOTSET"))
 774         , Meanings(meanings)
 775         , Kanji(kanji)
 776         , KanaOnly(reading.isEmpty())
 777         , Readings(KanaOnly ? kanji : reading)
 778         , ExtendedKanjiInfo(false)
 779         , Grade(0)
 780         , Strokes(0)
 781         , Miscount(0)
 782         , Freq(0)
 783 {
 784 }
 785
 786 Entry::Entry(const QString &kanji, QStringList &readings, QStringList &meanings, unsigned int grade, unsigned int freq, unsigned int strokes, unsigned int miscount)
 787         : DictName(QString::fromLatin1("__NOTSET"))
 788         , Header(QString::fromLatin1("__NOTSET"))
 789         , Meanings(meanings)
 790         , Kanji(kanji)
 791         , KanaOnly(false)
 792         , Readings(readings)
 793         , ExtendedKanjiInfo(true)
 794         , Grade(grade)
 795         , Strokes(strokes)
 796         , Miscount(miscount)
 797         , Freq(freq)
 798 {
 799 }
 800
 801 Entry::Entry(const QString &dictname)
 802         : KanaOnly(true)
 803         , ExtendedKanjiInfo(false)
 804 {
 805         DictName = dictname;
 806 }
 807
 808 Entry::Entry(const QString &headername, bool)
 809         : DictName(QString::fromLatin1("__NOTSET"))
 810         , Header(headername)
 811         , KanaOnly(true)
 812         , ExtendedKanjiInfo(false)
 813 {
 814 }
 815
 816 QString Entry::dictName()
 817 {
 818         return DictName;
 819 }
 820
 821 QString Entry::header()
 822 {
 823         return Header;
 824 }
 825
 826 bool Entry::kanaOnly()
 827 {
 828         return KanaOnly;
 829 }
 830
 831 QString Entry::kanji()
 832 {
 833         return Kanji;
 834 }
 835
 836 QStringList Entry::readings()
 837 {
 838         return Readings;
 839 }
 840
 841 QString Entry::firstReading()
 842 {
 843         return *Readings.at(0);
 844 }
 845
 846 QStringList Entry::meanings()
 847 {
 848         return Meanings;
 849 }
 850
 851 unsigned int Entry::grade()
 852 {
 853         return Grade;
 854 }
 855
 856 unsigned int Entry::freq()
 857 {
 858         return Freq;
 859 }
 860
 861 unsigned int Entry::miscount()
 862 {
 863         return Miscount;
 864 }
 865
 866 unsigned int Entry::strokes()
 867 {
 868         return Strokes;
 869 }
 870
 871 bool Entry::extendedKanjiInfo()
 872 {
 873         return ExtendedKanjiInfo;
 874 }
 875
 876 #include "dict.moc"