void NGRAMS2DCT::LoeTekstifailist(
const TAGS2DCT& tags
)
{
float f;
int i1, i2, i3, ret;
char tagBuf1[512], tagBuf2[512], tagBuf3[512];
CFSAString tagStr1, tagStr2, tagStr3;
tabel.Start(UKAPROBMAX, tags.idxLast, tags.idxLast, tags.idxLast);
FILE* in=fopen("3grammid.txt", "rb");
if(in==NULL)
throw VEAD( ERR_X_TYKK, ERR_OPN, __FILE__, __LINE__," ",
"Ei suuda avada andmefaili 3grammid.txt");
while((ret=fscanf(in, "%s %s %s %e\n", tagBuf1, tagBuf2, tagBuf3, &f))==4)
{
tagStr1=tagBuf1;
tagStr2=tagBuf2;
tagStr3=tagBuf3;
i1=tags.GetIdx(&tagStr1);
i2=tags.GetIdx(&tagStr2);
i3=tags.GetIdx(&tagStr3);
if(i1<0 || i2<0 || i3<0)
throw VEAD( ERR_HMM_MOOTOR, ERR_ROTTEN, __FILE__, __LINE__,
" ", "Jama andmefailist lugemisega 3grammid.txt");
tabel.Obj(i1,i2,i3)=f;
printf("%03d:%03d:%03d\r", i1,i2,i3);
}
printf("\n");
if(ret!=EOF)
throw VEAD( ERR_X_TYKK, ERR_RD, __FILE__, __LINE__,
" ", "Jama andmefailist lugemisega 3grammid.txt");
fclose(in);
}
LYLI *ETMRFAS::Flush(void)
{
if(mrfFlags->ChkB(MF_GENE)==false)
return ETMRFA::Flush(); //analüüs
// läheb sünteesiks
FSXSTRING gTyvi, gKigi, gSl, gVormid;
FSXSTRING gnaidis; // sõna, mis peaks genetavas paradigmas olema, nt palk puhul palgi või palga
int pos3;
int pos1, pos2;
MRFTULEMUSED geneOut;
int idx;
LYLI* tmpGeneLyliPtr=aGene.Lyli(0,A2_SUVALINE_LYLI,&idx);
if(tmpGeneLyliPtr==NULL)
return NULL; // ei saanud ahelast midagi
// saime ahelast midagi...
if((tmpGeneLyliPtr->lipp & PRMS_SONA)!=PRMS_SONA)// Kui pole lemme+vorm (on TAG vms)...
return aGene.LyliPtrOut(idx); //...tõstame mälu vabastamata ahelast välja
// ja anname genemata tagasi
// lemma+vorm, tuleb geneda
// jätame ta esialgu sünteesiahelasse ja teeme seal mida vaja
geneStr=*(tmpGeneLyliPtr->ptr.pStr); //seda hakkame genema: 'tüvi' //_sl_ vormid//kigi'
if(geneStr.GetLength() <= 0)
throw(VEAD(ERR_GEN_MOOTOR,ERR_ARGVAL,__FILE__,__LINE__));
geneStr.Trim();
if((pos1=geneStr.Find(FSxSTR(" //_"))) <= 0)
throw(VEAD(ERR_GEN_MOOTOR,ERR_ARGVAL,__FILE__,__LINE__));
gTyvi=geneStr.Left(pos1);
// näidise olemasolu puhuks
pos2 = gTyvi.Find(FSxSTR(" ("));
pos3 = gTyvi.Find(FSxSTR(")"));
if (pos2 != -1 && pos3 > pos2+4 && pos3==gTyvi.GetLength()-1) // näidis leitigi
{
gnaidis = gTyvi.Mid(pos2+2, pos3-pos2-2);
gTyvi=geneStr.Left(pos2);
}
if(geneStr.GetLength() < pos1+5 || geneStr[pos1+5]!=(FSxCHAR)'_')
throw(VEAD(ERR_GEN_MOOTOR,ERR_ARGVAL,__FILE__,__LINE__));
gSl=geneStr.Mid(pos1+4,1);
if((pos2=geneStr.Find(FSxSTR(" //"), pos1+5))<=0)
throw(VEAD(ERR_GEN_MOOTOR,ERR_ARGVAL,__FILE__,__LINE__));
if(pos1+5 < pos2)
{
gVormid=geneStr.Mid(pos1+6, pos2-pos1-6);
gVormid.Trim();
}
// else vormid==""
gKigi=geneStr.Mid(pos2+3, geneStr.GetLength()-pos2-3);
gKigi.Trim();
//if(Synt1(geneOut, &gTyvi, &gSl, &gVormid, &gKigi)==false)
if(SyntDetailne(geneOut, &gTyvi, &gnaidis, &gSl, &gVormid, &gKigi)==false)
{
// jama või ei õnnestunud sünteesida
}
tmpGeneLyliPtr->Start(geneOut, PRMS_MRF);
geneStr=FSxSTR("\0");
return aGene.LyliPtrOut(idx); // tõstame genetud asjaga lüli
// mälu vabastamata ahelast välja
}
void DCTRD::open_d2(void)
{
register int i;
readeel();
readends(); // teeb loppude mass.
readgrs(); // teeb lgr mass.
readfms(); // teeb vormide mass.
readfgrs(); // teeb lgr mass.
readsuf(); // teeb suf mass.
readprf(); // teeb pref mass.
// teeb loend[i] mass.
for (i=0; i < LOENDEID-1; i++) // tegelik loendite arv <= LOENDEID-1
{
readloe(i);
}
sg_g = vormnr(FSxSTR("sg g"));
sg_n = vormnr(FSxSTR("sg n"));
sg_p = vormnr(FSxSTR("sg p"));
adt = vormnr(FSxSTR("adt"));
pl_n = vormnr(FSxSTR("pl n"));
pl_g = vormnr(FSxSTR("pl g"));
pl_p = vormnr(FSxSTR("pl p"));
da = vormnr(FSxSTR("da"));
ma = vormnr(FSxSTR("ma"));
suva_vrm = SUVA_VRM;
if(sg_g == -1||sg_n == -1 ||ma == -1) // valikuline test
{
throw(VEAD(ERR_MORFI_PS6N,ERR_ROTTEN,__FILE__,__LINE__, "$Revision: 521 $"));
}
lopp_a = lpnr(FSxSTR("a"));
lopp_d = lpnr(FSxSTR("d"));
lopp_da = lpnr(FSxSTR("da"));
lopp_dama = lpnr(FSxSTR("dama"));
lopp_dav = lpnr(FSxSTR("dav"));
lopp_des = lpnr(FSxSTR("des"));
lopp_dud = lpnr(FSxSTR("dud"));
lopp_es = lpnr(FSxSTR("es"));
lopp_ma = lpnr(FSxSTR("ma"));
lopp_mata = lpnr(FSxSTR("mata"));
lopp_nud = lpnr(FSxSTR("nud"));
lopp_t = lpnr(FSxSTR("t"));
lopp_ta = lpnr(FSxSTR("ta"));
lopp_tama = lpnr(FSxSTR("tama"));
lopp_tav = lpnr(FSxSTR("tav"));
lopp_te = lpnr(FSxSTR("te"));
lopp_tes = lpnr(FSxSTR("tes"));
lopp_tud = lpnr(FSxSTR("tud"));
lopp_v = lpnr(FSxSTR("v"));
lopp_0 = null_lopp;
suva_lp = SUVA_LP;
if((signed char)lopp_d == (signed char)-1 ||
(signed char)lopp_ma == (signed char)-1) // valikuline test
{
throw(VEAD(ERR_MORFI_PS6N,ERR_ROTTEN,__FILE__,__LINE__, "$Revision: 521 $"));
}
}
void T3TAGSPRE::TagsFromCooked(
const CFSFileName& fileName,
const PFSCODEPAGE codePage)
{
VOTAFAILIST in(fileName, FSTSTR("rb"), codePage);
FSXSTRING rida, sona;
FSXSTRING margend, *rec;
int algus, lopp, idx, i, nRida=0;
TMPLPTRARRAYBIN<FSXSTRING,CFSWString> mrgndid(130,50);
margend=FSWSTR("***VAHE***"); //lausevahe iga märgendite loend peab sisaldama seda
rec=mrgndid.AddClone(margend);
assert(rec!=NULL); // märgendi lisamine äpardus
margend=FSWSTR("X"); //iga märgendite loend peab sisaldama seda
rec=mrgndid.AddClone(margend);
assert(rec!=NULL); // märgendi lisamine äpardus
//printf("%10d/%3d -- reast/märgendit\r", nRida, mrgndid.idxLast);
for(nRida=0; in.Rida(rida)==true; nRida++)
{
//printf("%10d/%3d\r", nRida, mrgndid.idxLast);
rida.Trim();
rida += FSWSTR(" ");
for(algus=0; (lopp=(int)(rida.Find((FSWCHAR)' ', algus)))>0; algus=lopp+1)
{
sona=rida.Mid(algus, lopp-algus);
algus=lopp+1;
lopp=(int)(rida.Find((FSWCHAR)' ', algus));
//assert(lopp > 0);
if(lopp <= 0)
throw VEAD(__FILE__, __LINE__, "Vigane COOKED-fail");
margend=(rida.Mid(algus, lopp-algus));
rec=mrgndid.Get(&margend, &idx);
if(rec==NULL) // sellist veel polnud, tuleb lisada idx-indaks
{
rec=mrgndid.AddClone(margend, idx);
assert(rec!=NULL); // märgendi lisamine apardus
}
}
}
//printf("%10d/%3d -- reast/märgendit\n", nRida, mrgndid.idxLast);
// Tõstame märgendid ümber
for(i=1; i<mrgndid.idxLast; i++)
{
if(*(mrgndid[i-1]) >= *(mrgndid[i]))
throw VEAD( ERR_HMM_MOOTOR, ERR_OPN, __FILE__, __LINE__," ",
"jama märgendite järjestusega");
}
for(i=0; i<mrgndid.idxLast; i++)
{
margendid.AddClone(*(mrgndid[i]));
}
margendid.Sort();
}
void HJK_LOEND::Start(
const CMPFUNBS _cmpbs_, // v�rdleb(v�ti, kirje)
const int _len_, // _ptr_==NULL: _xstrArr_ pikkus; _ptr_!=NULL: _ptr_massiivi pikkus BAITIDES
FSxCHAR *_xstrArr_,
FSxCHAR **_ptr_) // massiivi viit
{
int len;
assert(xstrArr==NULL);
if(_ptr_==NULL)
{
int i, pos, strCnt;
const unsigned char *tmp2=(unsigned char *)_xstrArr_;
assert( (_len_%dctsizeofFSxCHAR) == 0 );
len = _len_ / dctsizeofFSxCHAR;
// _ptr_ massiivi pikkus ja sisu tuleb v�lja arvutada
if((xstrArr=(FSxCHAR *)malloc(len*sizeof(FSxCHAR)))==NULL) // see malloc on ok
{
free(_xstrArr_); // seda pole enam vaja, tuleb vabastada
throw(VEAD(ERR_X_TYKK,ERR_NOMEM,__FILE__,__LINE__,"$Revision: 521 $"));
}
//xstrArr=tmp4;
// teisendame baidij�rje&pikkuse
for(pos=i=0; i < len; pos+=2,i++)
{
xstrArr[i]=(FSxCHAR)((tmp2[pos]|((tmp2[pos+1])<<8))&0xFFFF);
}
free(_xstrArr_); // seda pole enam vaja, tuleb vabastada
// arvutame v�lja stringide arvu
for (pos=strCnt=0; pos < len; strCnt++)
{
pos += FSxSTRLEN( xstrArr + pos )+1;
assert( pos <= len );
}
// reserveerime l�puviitade massiivi
if((_ptr_=(FSxCHAR **)malloc(sizeof(FSxCHAR *)*strCnt))==NULL) // see malloc on ok
{
free(xstrArr);
xstrArr=NULL;
throw(VEAD(ERR_X_TYKK,ERR_NOMEM,__FILE__,__LINE__,"$Revision: 521 $"));
}
// kirjutame l�puviitade massiivi viidad sisse
for (pos=strCnt=0; pos < len; strCnt++)
{
_ptr_[strCnt] = xstrArr + pos;
pos += FSxSTRLEN( xstrArr + pos )+1;
assert( pos <= _len_ );
}
LOEND<FSxCHAR *,FSxCHAR *>::Start(_ptr_, strCnt, NULL, _cmpbs_, false);
}
else
{
// pistame need loendiklassi sisse
assert( (_len_%sizeof(FSxCHAR)) == 0 );
len = _len_ / sizeof(FSxCHAR);
LOEND<FSxCHAR*,FSxCHAR*>::Start(_ptr_, _len_, NULL, _cmpbs_, false);
}
}
void DCTRD::readeel(void)
{
if(taandliik.Start(this, file_info.taandsl,
file_info.tyvelp-file_info.taandsl, TAANDL_MAX_PIK+1)==false)
{
throw(VEAD(ERR_MORFI_PS6N,ERR_NOMEM,__FILE__,__LINE__, "$Revision: 521 $"));
}
// tyvelopud
if(tyvelp.Start(this, file_info.tyvelp,
file_info.sonaliik - file_info.tyvelp,TYVELP_MAX_PIK+1)==false)
{
throw(VEAD(ERR_MORFI_PS6N,ERR_NOMEM,__FILE__,__LINE__, "$Revision: 521 $"));
}
}
void T3NGRAM::NGramsToFile(
const TMPLPTRARRAYBIN2<FSXSTRING,CFSWString> &margendid
)
{
FILE* out=fopen("3grammid.txt", "wb");
if(out==NULL)
throw VEAD( ERR_HMM_MOOTOR, ERR_OPN, __FILE__, __LINE__," ",
"Ei suuda luua andmefaili", "3grammid.txt");
CFSAString idx1AStr, idx2AStr, idx3AStr;
CFSWString idx1WStr, idx2WStr, idx3WStr;
printf("3grammid tekstifaili \"3grammid.txt\" ...");
for(int i1=0; i1<tabel.maxIdx1; i1++)
{
idx1WStr = *(margendid[i1]);
idx1AStr = FSStrWtoA(idx1WStr, FSCP_UTF8);
for(int i2=0;i2<tabel.maxIdx2; i2++)
{
idx2WStr = *(margendid[i2]);
idx2AStr = FSStrWtoA(idx2WStr, FSCP_UTF8);
for(int i3=0;i3<tabel.maxIdx3; i3++)
{
idx3WStr = *(margendid[i3]);
idx3AStr = FSStrWtoA(idx3WStr, FSCP_UTF8);
//fprintf(out, "%3d %3d %3d %e\n",
// i1, i2, i3, tabel.Obj(i1,i2,i3));
fprintf(out, "%10s %10s %10s %e\n",
(const char*)idx1AStr, (const char*)idx2AStr, (const char*)idx3AStr,
tabel.Obj(i1,i2,i3));
}
}
}
printf(" ok\n");
fclose(out);
}
void MORF0::arvamin(
const FSXSTRING *sisse, // sisends6na
MRFTULEMUSED *tul)
{
if (!mrfFlags.Chk(MF_OLETA)) // ei tulegi oletada
return;
int res;
FSXSTRING sona= *sisse;
TaheHulgad::AsendaMitu(&sona, TaheHulgad::uni_kriipsud, TaheHulgad::amor_kriipsud);
tul->tagasiTasand=0;
tul->mitmeS6naline = 1; // s.t. oletame 1 s�na, mitte v�ljendeid
tul->keeraYmber = false;
tul->eKustTulemused=eMRF_AO; // anal��sid oletajast
tul->DelAll();
if (sisse->GetLength() >= STEMLEN) // tegelt seda juba chkmin() kontrollis
{
tul->Add((const FSxCHAR *)*sisse, FSxSTR(""), FSxSTR(""), FSxSTR("Z"), FSxSTR("")); // parema puudusel
return;
}
res = arvax( tul, &sona );
if (res != ALL_RIGHT)
{
tul->eKustTulemused=eMRF_XX;
tul->s6na = FSxSTR("");
throw(VEAD(ERR_MG_MOOTOR, ERR_MINGIJAMA, __FILE__, __LINE__, "$Revision: 542 $")); //jama!
}
}
void CONV_HTML_UC2::Start(
const FSTCHAR* path,
const bool _ignoramp_,
const bool _autosgml_
)
{
ignoramp=_ignoramp_;
autosgml=_autosgml_;
if(path!=NULL) // v�tame loendi failist
{
CFSString tabeliFailiNimi(FSTSTR("sgml-uc-cnv.txt"));
CFSString tabeliFailiPikkNimi;
CFSString p(path);
// Otsime �les, millises kataloogis teisendustabel
if(Which(&tabeliFailiPikkNimi, &p, &tabeliFailiNimi)==false)
throw VEAD(ERR_X_TYKK, ERR_OPN, __FILE__,__LINE__, "$Revision: 557 $",
"Ei leia SGML olemite faili sgml-uc-cnv.txt");
// Avame teisenustabelit sisaldaa faili
CPFSFile tabeliFail;
if(tabeliFail.Open(tabeliFailiPikkNimi, FSTSTR("rb"))==false)
throw VEAD(ERR_X_TYKK, ERR_OPN, __FILE__,__LINE__, "$Revision: 557 $"
"Ei suuda avada SGML olemite faili"
#if !defined( _UNICODE )
,(const char*)tabeliFailiPikkNimi
#endif
);
// Loeme failist teisendustabeli m�llu
SGML_UC* rec;
sgml2uc.Start(100,10);
uc2sgml.Start(100,10);
sgml_stringi_max_pikkus=0;
int n;
while((rec=sgml2uc.AddPlaceHolder())->Start(tabeliFail)==true)
{
uc2sgml.AddPtr(rec); // sellesse massiivi panema ainult viida
if((n=(int)strlen(rec->sgml))>sgml_stringi_max_pikkus)
sgml_stringi_max_pikkus=n;
}
sgml2uc.Del(); // kustutame viimase, sest sinna ei �nnestunud lugeda
sgml2uc.Sort(SGML_UC::sortBySGMLStr); // selle massiivi j�rjestame SGML olemite j�rgi
uc2sgml.Sort(SGML_UC::sortByUCchar); // selle massiivi j�rjestame UNICODEi s�mbolite j�rgi
}
}
void TAGS2DCT::LoeTekstifailist(void)
{
CFSFileName fileName(FSTSTR("taglist.txt"));
CPFSFile in;
if(in.Open(fileName, FSTSTR("rb"))==false)
throw VEAD(ERR_X_TYKK, ERR_OPN, __FILE__, __LINE__," ", "Ei suuda avada faili taglist.txt");
TMPLPTRARRAYBIN<PCFSAString,CFSAString>::Start(100,10);
CFSAString rida;
PCFSAString tagStr;
// Loeme märgendite loendi mällu
while(in.ReadLine(&rida)==true)
{
tagStr=rida.Mid(4);
tagStr.Trim();
if(TMPLPTRARRAYBIN<PCFSAString,CFSAString>::AddClone(tagStr)==NULL)
throw VEAD(ERR_HMM_MOOTOR, ERR_NOMEM, __FILE__, __LINE__," ");
}
in.Close();
printf("Märgendite järjestamine...");
// Garanteerime järjestatuse
TMPLPTRARRAYBIN<PCFSAString,CFSAString>::Sort();
// Kontrollime veel üle, et ikka tõesti järjestatud
for(int i=1; i<idxLast; i++)
{
if(*(operator[](i-1)) >= *(operator[](i)))
throw VEAD(ERR_X_TYKK, ERR_ROTTEN, __FILE__, __LINE__," ",
"Jama märgendite järjekorraga andmefailis taglist.txt");
}
printf("OK\n");
gramm1.Start(idxLast);
CFSFileName fileName2(FSTSTR("margcnt.txt"));
if(in.Open(fileName2, FSTSTR("rb"))==false)
throw VEAD(ERR_X_TYKK, ERR_OPN, __FILE__, __LINE__," ", "Ei suuda avada faili margcnt.txt");
for(int i=0; i<idxLast; i++)
{
if(in.ReadLine(&rida)==false)
throw VEAD(ERR_HMM_MOOTOR, ERR_RD, __FILE__, __LINE__," ");
int tyhikuPos=rida.Find(' ');
if(tyhikuPos<=0)
throw VEAD(ERR_HMM_MOOTOR, ERR_RD, __FILE__, __LINE__," ");
CFSAString tag(rida.Left(tyhikuPos));
if(tag!=*(operator[](i)))
throw VEAD(ERR_HMM_MOOTOR, ERR_RD, __FILE__, __LINE__," ");
int nKorda;
if(sscanf(((const char*)rida)+tyhikuPos, "%d", &nKorda)!=1)
throw VEAD(ERR_HMM_MOOTOR, ERR_RD, __FILE__, __LINE__," ");
gramm1.Obj(i)=nKorda;
}
}
void SISSEVALJA::Start(FILE* pfile, const PFSCODEPAGE _codePage_,
const FSTCHAR* path, const bool _ignoramp_, const bool _autosgml_)
{
assert(EmptyClassInvariant());
assert(pfile == stdin || pfile == stdout || pfile == stderr);
#if defined(WIN32) || defined(WIN64)
if (_setmode(_fileno(pfile), _O_BINARY) == -1)
throw (VEAD(ERR_IO,
ERR_OPN,
__FILE__, __LINE__, "$Revision: 1097 $"));
#endif
if (Open(pfile) == false)
throw (VEAD(ERR_IO,
ERR_OPN,
__FILE__, __LINE__, "$Revision: 1097 $"));
svKoodiTabel = _codePage_;
if (svKoodiTabel == PFSCP_HTMLEXT)
cnv.Start(path, _ignoramp_, _autosgml_);
assert(ClassInvariant());
}
void TAGS2DCT::KirjutaSonastikufaili(
DCTMETASTRCT& meta
)
{
long pos=meta.Tell();
meta.Add(DCTELEMID_T3TAGS, pos);
meta.WriteUnsigned<UB4, int>(idxLast);
for(int i=0; i<idxLast; i++)
{
if(meta.WriteStringB(operator[](i), true)==false) // kirjutame faili koos stringlõputunnusega
throw VEAD(ERR_X_TYKK, ERR_WRITE, __FILE__, __LINE__," ",
"Jama märgendite kirjutamisega andmefaili et3.dct");
}
for(int i=0; i<idxLast; i++)
{
if(meta.WriteUnsigned<UB4, int>(gramm1.Obj(i))==false)
throw VEAD(ERR_X_TYKK, ERR_WRITE, __FILE__, __LINE__," ",
"Jama märgendite esinemisarvu kirjutamisega andmefaili et3.dct");
}
}
void DCTRD::readfgrs(void)
{
//int res;
unsigned size;
/* l�pugruppide vormijadad */
size = (unsigned)(file_info.suf - file_info.fgr); /* l�pugruppide vormijadade mass. pikkus */
homo_form = size/gr_size;
fgr = (char *)malloc(sizeof(char) * size); // see malloc on ok
if (fgr==NULL)
{
throw(VEAD(ERR_MORFI_PS6N,ERR_NOMEM,__FILE__,__LINE__, "$Revision: 521 $"));
}
if(c_read(file_info.fgr, fgr, size) == false)
{
free(fgr);
fgr=NULL;
throw(VEAD(ERR_MORFI_PS6N,ERR_MINGIJAMA,__FILE__,__LINE__, "$Revision: 521 $"));
}
}
void DCTRD::readends(void)
{
unsigned size;
FSxCHAR *endings;
// l�ppude tabel
size = (unsigned)(file_info.groups - file_info.ends); // l�ppude mass. pikkuse
endings = (FSxCHAR *) malloc(sizeof(char) * size); // see malloc on OK
if (endings==NULL)
{
throw(VEAD(ERR_MORFI_PS6N,ERR_ROTTEN,__FILE__,__LINE__,"$Revision: 521 $"));
}
if(c_read(file_info.ends, endings, size) == false) // ok, sealt ei tule throw()-d
{
free(endings);
endings=NULL;
throw(VEAD(ERR_MORFI_PS6N,ERR_ROTTEN,__FILE__,__LINE__,"$Revision: 521 $"));
}
// pistame need loendiklassi sisse
l6ppudeLoend.Start(FSxvrdle, size, endings);
}
void DCTRD::readfms(void)
{
unsigned size;
FSxCHAR *formings;
// vormide tabel
size = (unsigned)(file_info.fgr - file_info.forms); // vormide mass. pikkus
formings = (FSxCHAR *) malloc(sizeof(char) * size); // see malloc on OK
if(formings==NULL)
{
throw(VEAD(ERR_MORFI_PS6N,ERR_NOMEM,__FILE__,__LINE__, "$Revision: 521 $"));
}
if(c_read(file_info.forms, formings, size) == false)
{
free(formings);
formings=NULL;
throw(VEAD(ERR_MORFI_PS6N,ERR_ROTTEN,__FILE__,__LINE__, "$Revision: 521 $"));
}
assert( (size%sizeof(FSxCHAR)) == 0 );
// pistame need loendiklassi sisse
vormideLoend.Start(FSxvrdle, size, formings);
}
void SISSEVALJA::Start(const CFSFileName& fileName, const FSTCHAR* pmode,
const PFSCODEPAGE _codePage_, const FSTCHAR* path,
const bool _ignoramp_, const bool _autosgml_)
{
assert(EmptyClassInvariant());
if (Open(fileName, pmode) == false)
throw VEAD(ERR_IO, ERR_OPN, __FILE__, __LINE__, NULL,
"Ei suuda avada faili:", (const FSTCHAR*) fileName);
svKoodiTabel = _codePage_;
if (svKoodiTabel == PFSCP_HTMLEXT)
cnv.Start(path, _ignoramp_, _autosgml_);
assert(ClassInvariant());
}
void LEX2DCT::LoeTekstifailist(
const TAGS2DCT& tags
)
{
lexArr.Start(500,500);
CPFSFile in;
if(in.Open(FSTSTR("lex.txt"), FSTSTR("rb"))==false)
throw VEAD( ERR_HMM_MOOTOR, ERR_RD, __FILE__, __LINE__,
" ", "Jama andmefaili lex.txt avamisega");
CFSAString rida;
for(int reaNr=1; in.ReadLine(&rida)==true; reaNr++)
{
LEXINF* lexInf=lexArr.AddPlaceHolder();
// sõna [ N] tag1=prob1 ... tagN=probN
rida.Trim();// white space eest-tagant maha
rida+=' '; // tühik lõppu
int pos1=(int)rida.Find(' '), pos2, pos3;
if(pos1<=0)
throw VEAD( ERR_X_TYKK, ERR_ROTTEN, __FILE__, __LINE__,
" ", "Jamane rida andmefailis lex.txt", (const char*)rida);
if(rida[pos1+5]!=']' || rida[pos1+6]!=' ' || rida[pos1+7]=='\0')
throw VEAD( ERR_X_TYKK, ERR_ROTTEN, __FILE__, __LINE__,
" ", "Jamane rida andmefailis lex.txt", (const char*)rida);
CFSAString tagStr, probStr;
//CFSWString wTagStr;
lexInf->str=rida.Mid(0,pos1);
sscanf(((const char*)rida)+pos1+2, "%d", &(lexInf->n));
lexInf->tagIdxProb=new LEXINF::LEXINFEL[lexInf->n];
pos1+=7;
for(int i=0; i<lexInf->n; i++)
{
if((pos2=(int)rida.Find('=', pos1))<=0)
throw VEAD( ERR_X_TYKK, ERR_ROTTEN, __FILE__, __LINE__,
" ", "Jamane rida andmefailis lex.txt", (const char*)rida);
if((pos3=(int)rida.Find(' ',pos2))<=0)
throw VEAD( ERR_X_TYKK, ERR_ROTTEN, __FILE__, __LINE__,
" ", "Jamane rida andmefailis lex.txt", (const char*)rida);
tagStr=rida.Mid(pos1, pos2-pos1);
if((lexInf->tagIdxProb[i].tagIdx=tags.GetIdx(&tagStr))<0)
throw VEAD( ERR_X_TYKK, ERR_ROTTEN, __FILE__, __LINE__,
" ", "Tundmatu ühestamismärgendandmefailis lex.txt", (const char*)rida);
sscanf((const char*)rida+pos2+1, "%e", &(lexInf->tagIdxProb[i].tagProb));
pos1=pos3+1;
}
for(int i=1; i<lexInf->n; i++)
{
assert(lexInf->tagIdxProb[i-1].tagIdx<lexInf->tagIdxProb[i].tagIdx);
}
printf("%d\r", lexArr.idxLast);
}
printf("%d\n", lexArr.idxLast);
printf("Leksikoni järjestamine...");
lexArr.Sort();
printf("OK\n");
}
void DCTRD::readloe(int i)
{
unsigned size;
FSxCHAR* tmpPtr;
size = (unsigned)(file_info.loend[i+1] - file_info.loend[i]); //loendi mass. pikkus
if (size == 0L) // loendit polegi
{
return;
}
tmpPtr=(FSxCHAR *)(malloc(size)); // see malloc on OK
if(tmpPtr==NULL) // reserveerime loendile m�lu
{
throw(VEAD(ERR_MORFI_PS6N,ERR_NOMEM,__FILE__,__LINE__,"$Revision: 521 $"));
}
if(c_read(file_info.loend[i], tmpPtr, size) == false) // t�mbame loendi sisse
{
free(tmpPtr);
throw(VEAD(ERR_MORFI_PS6N,ERR_ROTTEN,__FILE__,__LINE__,"$Revision: 521 $"));
}
// dctLoend[i] asi on free(tmpPtr)
dctLoend[i].Start(FSxvrdle, size, tmpPtr);
}
void CONV_HTML_UC2::ConvFromTo(
CFSAString& vStr,
const PFSCODEPAGE vKoodiTabel,
const CFSAString& sStr,
const PFSCODEPAGE sKoodiTabel
)
{
if(sgml2uc.idxLast<=0 && (vKoodiTabel==PFSCP_HTMLEXT || sKoodiTabel==PFSCP_HTMLEXT))
throw VEAD(ERR_X_TYKK, ERR_ARGVAL, __FILE__,__LINE__, "$Revision: 557 $",
"SGML olemite tabel mallu lugemata");
CFSWString wStr;
ConvToUc(wStr,sStr, sKoodiTabel);
ConvFromUc(vStr,vKoodiTabel,wStr);
}
void DCTRD::readprf(void)
{
unsigned size;
int i;
KETTA_PREFINFO* ketta_prfix; /* suf. seot. info kettal*/
FSxCHAR* prffixes;
/* prefiksite massiiv */
size = (unsigned)(file_info.prfix - file_info.pref); // pref mass. pikkus
prffixes = (FSxCHAR *) malloc(sizeof(char) * size); // see malloc on ok
if (prffixes==NULL)
{
throw(VEAD(ERR_MORFI_PS6N,ERR_NOMEM,__FILE__,__LINE__,"$Revision: 521 $"));
}
if(c_read(file_info.pref, prffixes, size) == false)
{
free(prffixes);
throw(VEAD(ERR_MORFI_PS6N,ERR_ROTTEN,__FILE__,__LINE__,"$Revision: 521 $"));
}
assert((size%dctsizeofFSxCHAR)==0);
prefiksiteLoend.Start(FSxvrdle, size, prffixes); // prefiksiteLoend'i asi on free(prffixes)
// pref seot. info
size = (unsigned)(file_info.taandsl - file_info.prfix); // pref. infot sisald. mass. pikkus
if (sizeof(KETTA_PREFINFO) * prefiksiteLoend.len != size) // ei saa olla
{
throw(VEAD(ERR_MORFI_PS6N,ERR_MINGIJAMA,__FILE__,__LINE__,"$Revision: 521 $"));
}
ketta_prfix = (KETTA_PREFINFO*)malloc(sizeof(KETTA_PREFINFO)*prefiksiteLoend.len); // see malloc on OK
if (ketta_prfix==NULL)
{
throw(VEAD(ERR_MORFI_PS6N,ERR_NOMEM,__FILE__,__LINE__,"$Revision: 521 $"));
}
if(c_read(file_info.prfix, ketta_prfix, size) == false)
{
free(ketta_prfix);
throw(VEAD(ERR_MORFI_PS6N,ERR_ROTTEN,__FILE__,__LINE__,"$Revision: 521 $"));
}
prfix = (PREFINFO *) malloc(sizeof(PREFINFO) * prefiksiteLoend.len); // see malloc on ok
if (prfix == NULL)
{
free(ketta_prfix);
throw(VEAD(ERR_MORFI_PS6N,ERR_NOMEM,__FILE__,__LINE__,"$Revision: 521 $"));
}
for (i=0; i < prefiksiteLoend.len; i++) /* kopeeri prefiksiga seotud info paremale kujule*/
{
prfix[i].sl = ketta_prfix[i].sl;
prfix[i].piiriKr6nksud = (ketta_prfix[i].piiriKr6nksud0 & 0xFF) | ((ketta_prfix[i].piiriKr6nksud1 & 0xFF)<<8);
prfix[i].lisaKr6nksud = (ketta_prfix[i].lisaKr6nksud0 & 0xFF) | ((ketta_prfix[i].lisaKr6nksud1 & 0xFF)<<8);
}
free(ketta_prfix);
}
void T3TAGSPRE::TagsToFile(void)
{
FILE *out=fopen("taglist.txt", "wb");
if(out==NULL)
throw VEAD( ERR_HMM_MOOTOR, ERR_OPN, __FILE__, __LINE__," ",
"Ei suuda luua andmefaili", "taglist.txt");
CFSAString aTagStr;
int i;
printf("märgendid tekstifaili \"taglist.txt\" ...");
for(i=0; i<margendid.idxLast; i++)
{
aTagStr = FSStrWtoA(*(margendid[i]), FSCP_UTF8);
fprintf(out, "%03d %s\n", i, (const char*)aTagStr);
}
printf(" ok\n");
fclose(out);
}
void NGRAMS2DCT::KirjutaSonastikufaili(
DCTMETASTRCT& meta,
const TAGS2DCT& tags
)
{
long pos=meta.Tell();
meta.Add(DCTELEMID_T3GRAMS, pos);
for(int i1=0; i1<tags.idxLast; i1++)
{
for(int i2=0; i2<tags.idxLast; i2++)
{
for(int i3=0; i3<tags.idxLast; i3++)
{
if(meta.WriteBuffer(&(tabel.Obj(i1, i2, i3)),sizeof(UKAPROB))==false)
throw VEAD( ERR_X_TYKK, ERR_WRITE, __FILE__, __LINE__,
" ", "Jama pakitud sõnastikku kirjutamisega andmefaili et3.dct");
}
}
}
}
void PANEFAILI::PaneX(const LYLI_TMPL<S_TYYP, C_TYYP>& lyli,
const MRF_FLAGS& mrfFlags)
{
S_TYYP str;
if((lyli.lipp & PRMS_SARV) == PRMS_SARV)
str.Format(EritiSobiViit(C_TYYP, "<%d/>\n"), lyli.ptr.arv);
else if ((lyli.lipp & PRMS_STRKLASS) == PRMS_STRKLASS)
str = *lyli.ptr.pStr + EritiSobiViit(C_TYYP, "\n");
else if ((lyli.lipp & PRMS_STRID) == PRMS_STRID)
//str.Format(EritiSobiViit(C_TYYP, "%s <%d/>\n"),
// (const C_TYYP *)lyli.ptr.strid->str, lyli.ptr.strid->id);
str.Format(EritiSobiViit(C_TYYP, "%s\n"),
(const C_TYYP *)lyli.ptr.strid->str);
else if ((lyli.lipp & PRMS_MRF) == PRMS_MRF)
lyli.ptr.pMrfAnal->Strct2Strng(&str, &mrfFlags);
else
throw VEAD(ERR_X_TYKK, ERR_MINGIJAMA, __FILE__, __LINE__,
"Ei oska sellist LYLI tekstina faili kirjutada");
Pane(str);
}
void LEX2DCT::KirjutaSonastikufaili(
DCTMETASTRCT& meta,
const TAGS2DCT& tags
)
{
long* mrfInfPos=new long[lexArr.idxLast];
for(int i=0; i<lexArr.idxLast; i++)
{
mrfInfPos[i]=meta.Tell();
// massiivi elementide arv=1bait
if(meta.WriteUnsigned<UB1,int>(lexArr[i]->n)==false)
throw VEAD( ERR_HMM_MOOTOR, ERR_WRITE, __FILE__, __LINE__,
" ", "Jama pakitud sõnastikku kirjutamisega");
for(int j=0; j<lexArr[i]->n; j++)
{
// tagIdx[j]=1bait tagProb[j]=sizeof(UKAPROB)
if(meta.WriteUnsigned<UB1,int>(lexArr[i]->tagIdxProb[j].tagIdx)==false)
throw VEAD( ERR_HMM_MOOTOR, ERR_WRITE, __FILE__, __LINE__,
" ", "Jama pakitud sõnastikku kirjutamisega");
if(meta.WriteBuffer(&(lexArr[i]->tagIdxProb[j].tagProb),sizeof(UKAPROB))==false)
throw VEAD( ERR_HMM_MOOTOR, ERR_WRITE, __FILE__, __LINE__,
" ", "Jama pakitud sõnastikku kirjutamisega");
}
printf("%d\r", i);
}
printf("\n");
meta.Add(DCTELEMID_T3LEX_WLST, meta.Tell());
// sõnavormide arv=4baiti
if(meta.WriteUnsigned<UB4,int>(lexArr.idxLast)==false)
throw VEAD( ERR_HMM_MOOTOR, ERR_WRITE, __FILE__, __LINE__,
" ", "Jama pakitud sõnastikku kirjutamisega");
for(int i=0; i<lexArr.idxLast; i++)
{
// i-nda sõna morf info alguspos=4baiti
if(meta.WriteUnsigned<UB4,long>(mrfInfPos[i])==false)
throw VEAD( ERR_HMM_MOOTOR, ERR_WRITE, __FILE__, __LINE__,
" ", "Jama pakitud sõnastikku kirjutamisega");
// i-s sõnavorm ise koos stringilõputunnusega
if(meta.WriteStringB(&(lexArr[i]->str), true)==false)
throw VEAD( ERR_HMM_MOOTOR, ERR_WRITE, __FILE__, __LINE__,
" ", "Jama pakitud sõnastikku kirjutamisega");
printf("%d\r", i);
}
printf("\n");
delete [] mrfInfPos;
}
void ConvFile(
CPFSFile &out, ///< V�ljundfail
const PFSCODEPAGE outKoodiTabel,///< V�ljundfaili kooditabel
CPFSFile &in, ///< Sisendfail
const PFSCODEPAGE inKoodiTabel, ///< Sisendfaili kooditabel
CONV_HTML_UC2 &cnv, ///< Stringiteisendaja
const bool feff, ///< UNICODE'i korral m��rab BOMi k�sitlemise viidi
PROGRESSIMOOTJA progr ///< M��rab edenemise kuvamise viisi
)
{
CFSAString aStr;
CFSWString wStr;
PROGRESS p(progr, in);
if(outKoodiTabel==inKoodiTabel)
throw VEAD(ERR_X_TYKK, ERR_ARGVAL, __FILE__,__LINE__, "$Revision: 557 $",
"Sisendfaili kooditabel == Valjundfaili kooditabel");
if(outKoodiTabel==PFSCP_UC) // mitteUNICODE --> UNICODE
{
if(feff) // BOM tuleb failip�isesse lisada
out.WriteStringB(FSWSTR("\xFEFF"));
while(in.ReadLine(&aStr)==true)
{
cnv.ConvToUc(wStr, aStr, inKoodiTabel);
out.WriteStringB(&wStr);
p.Progress();
}
return;
}
if(inKoodiTabel==PFSCP_UC) // UNICODE --> mitteUNICODE
{
if(feff) // BOMi olemasolul kontrolli baidij�rge
{
FSWCHAR wc;
if(in.ReadChar(&wc)==true)
{
if(wc==0xFFFE)
throw VEAD(ERR_X_TYKK, ERR_ARGVAL, __FILE__,__LINE__, "$Revision: 557 $",
"Sisendfailis vale baidijarjega UNICODE");
if(wc!=0xFEFF)
in.Seek(0L); // polnud BOM, kerime faili algusesse tagasi
// ok, sobilik baidij�rjekord
}
}
while(in.ReadLine(&wStr)==true)
{
cnv.ConvFromUc(aStr, outKoodiTabel, wStr);
out.WriteStringB(&aStr);
p.Progress();
}
return;
}
CFSAString bStr;
while(in.ReadLine(&aStr)==true) // mitteUNICODE --> mitteUNICODE
{
cnv.ConvFromTo(bStr,outKoodiTabel,aStr,inKoodiTabel);
out.WriteStringB(&bStr);
p.Progress();
}
}
bool ETMRFAS::Set1(LYLI *pLyli)
{
if(mrfFlags->ChkB(MF_GENE)==true)
throw(VEAD(ERR_GEN_MOOTOR,ERR_ARGVAL,__FILE__,__LINE__));
return ETMRFA::Set1(pLyli);
}
/*
* uus variant; hjk 02.05.01
* return mitu sobivat sõnaliiki oli, s.t. mitu 1-e on massiivis sobivad
* nt haige puhul võib olla sl=SA, sobivad=11
* kasutatakse m.h. selleks, et filtreerida välja liitsõna/tuletise komponendiks mittesobivaid tüvesid,
* nt. kääri SV puhul sobivad=10 või 01, sõltuvalt muude komponentide poolt esitatavatest nõuetest
* (kääri_terad või kääri=mine)
*/
int MORF0::ssobivus(
TYVE_INF *grupid, // sisend; lõpugrupid
const FSxCHAR *sl, // sisend; lõpugrupi sõnaliigid (stringina))
const int sl_pik, // sisend; massiivi sl pikkus
const char lopunr, // sisend; lubatav lõpp (õigemini jrk nr lõppude loendis)
const FSxCHAR *sonalk, // sisend; lubatavad sõnaliigid (stringina))
const int vorminr, // sisend; lubatav vorm (õigemini jrk nr vormide loendis)
char *sobivad, // väljund; 0 ja 1 joru
const int sobivatePikkus // sisend; massiivi 'sobivad' pikkus
)
{
if(sobivatePikkus<sl_pik)
throw VEAD(ERR_MORFI_MOOTOR,ERR_MINGIJAMA,__FILE__,__LINE__,"$Revision: 855 $");
register int i;
int j=0;
int k=0, llnr, ffnr, ok;
unsigned l;
FSxCHAR s;
FSXSTRING csonalk;
//FSXSTRING slsonalk;
csonalk = sonalk;
//slsonalk = sl;
memset(sobivad, 0, sobivatePikkus);
for (i=0; i < sl_pik; i++)
{
if ( csonalk != SUVA_LIIK )
{ /* kontr. sonaliigi sobivust */
s = sl[i];
if (csonalk.Find(s)==-1)
continue; // lopugrupp ei esinda sellist sonaliiki
}
if ((signed char)lopunr != SUVA_LP)
{ /* kontr. lopu olemasolu */
k = endingr( GetLgNr(grupid, i), lopunr );
if (k == -1) /* seda loppu pole selles lopugrupis */
continue; /* vt teisi lopugruppe */
}
if (vorminr == SUVA_VRM)
ok = 1;
else
{
ok = 0;
if ((signed char)lopunr != SUVA_LP)
{
llnr = KaksYheks(groups[GetLgNr(grupid, i)].gr_algus, groups[GetLgNr(grupid, i)].gr_lopp);
llnr = homo_form * (llnr + k);
for (l=0; l < homo_form; l++) /*vt lopu vormihomonyyme*/
{
ffnr = (unsigned char)(fgr[llnr + l]); /* vormi nr */
if (!ffnr)
break;
if (vorminr == ffnr)
{
ok = 1;
break;
}
}
}
}
if (!ok)
continue;
// HJK 5.05.2003; HJK 02.03.2005
if (mrfFlags.Chk(MF_EILUBATABU)) // nt soovitaja puhul tabus�nad pole lubatud
{
if (on_paha_sl(grupid, GetLgNr(grupid, i), sl, TABU_SL))
continue;
}
/* hjk 04.2015: las need mitmesõnaliste nimede osad olla alati lubatud
if (!mrfFlags.Chk(MF_SPELL)) // aint spelleri puhul on m�ned s�nad lubatud, nt. Aires
{
if (on_paha_sl(grupid, GetLgNr(grupid, i), sl, SPELL_SL))
continue;
}
*/
if (!mrfFlags.Chk(MF_LUBATESA)) // normaalse morfi puhul tesauruse algvormide staatuses s�navormid (aukudega) pole lubatud
{
if (on_paha_sl(grupid, GetLgNr(grupid, i), sl, TESA_SL))
continue;
}
if(i>sobivatePikkus)
throw VEAD(ERR_MORFI_MOOTOR,ERR_MINGIJAMA,__FILE__,__LINE__,"$Revision: 855 $");
sobivad[i] = 1;
j++;
}
return(j);
}
void CONV_HTML_UC2::ConvFromUc(
CFSAString& aStr,
const PFSCODEPAGE koodiTabel,
const CFSWString& wStr
)
{
aStr.Empty();
if(koodiTabel!=PFSCP_HTMLEXT) // Krutime Renee algoritmi j�rgi
{
aStr = FSStrWtoA(wStr, koodiTabel); // Kui teisendus k�ib Rene tabelite j�rgi, siis teeme �ra ja valmis
return;
}
assert(koodiTabel==PFSCP_HTMLEXT); // Kasutame teisendamiseks failist loetud tabelit
if(sgml2uc.idxLast<=0)
throw VEAD(ERR_X_TYKK, ERR_ARGVAL, __FILE__,__LINE__, "$Revision: 557 $",
"SGML olemite tabel mallu lugemata");
FSWCHAR wc;
for(int i=0; (wc=wStr[i])!=0; i++)
{
if((wc & (~0x7F))==0) // Oli ASCII (7bitine) kood
{
if(ignoramp==false && wc==(FSWCHAR)'&') // Ampersand SGML olemiks
aStr += "&";
else
aStr += (char)(wc & 0x7F); // Muud ASCII koodid niisama �le
continue;
}
// Polnud ASCII kood, peab olema SGML olemite loendis
SGML_UC* rec;
if((rec=uc2sgml.Get((const FSWCHAR*)wStr+i))!=NULL) // leidsime loendist
{
aStr += rec->sgml;
continue;
}
int olemiAlgusPos=aStr.GetLength();
aStr+="&#";
STRSOUP::UnsignedNum2Str<int, CFSAString, char, 10>((unsigned int)(wStr[i]), aStr);
aStr+=';';
if(autosgml==false)
{
throw VEAD(ERR_X_TYKK, ERR_ARGVAL, __FILE__,__LINE__, "$Revision: 557 $",
"UniCode'i kood programmi SGML olemite tabelist puudu, 10ndkood",
(const char*)aStr+olemiAlgusPos);
}
/*
if(autosgml==false)
{
char tmpBuf[128];
sprintf(tmpBuf, "%d", (unsigned int)(wStr[i]));
throw VEAD(ERR_X_TYKK, ERR_ARGVAL, __FILE__,__LINE__, "$Revision: 557 $",
"UniCode s�mbol programmi SGML olemite tabelist puudu, kood", tmpBuf);
}
//autosgml==true;
CFSAString revSgml;
int j=-1;
assert(wc > 0);
do
{
revSgml[++j] = (unsigned)(wc%10)+(unsigned)'0';
wc /= 10;
} while(wc > 0);
aStr += "&#";
while(j>=0)
aStr+=revSgml[j--];
aStr += ';';
*/
}
}
void MKLASSID2DCT::Run(
DCTMETASTRCT& meta, ///< Sõnastiku struktuurihoidla
const TAGS2DCT& tags ///< Ühestamismärgendite massiiv
)
{
CPFSFile in;
if(in.Open(FSTSTR("klassid.txt"), FSTSTR("rb"))==false)
throw VEAD( ERR_HMM_MOOTOR, ERR_RD, __FILE__, __LINE__,
" ", "Jama andmefaili klassid.txt avamisega");
CFSAString rida;
// tõsta kohe sõnastikku ümber...
int n, reaNr, kokkuRidu;
long pos=meta.Tell();
meta.Add(DCTELEMID_T3M_KLASSID, pos);
if(in.ReadLine(&rida)==false)
throw VEAD( ERR_HMM_MOOTOR, ERR_RD, __FILE__, __LINE__,
" ", "Jama andmefaili klassid.txt lugemisega");
sscanf((const char*)rida, "%d", &kokkuRidu);
if(meta.WriteUnsigned<UB4, int>(kokkuRidu)==false) // mitmsusklasside arv
throw VEAD( ERR_HMM_MOOTOR, ERR_WRITE, __FILE__, __LINE__,
" ", "Jama pakitud sõnastikku kirjutamisega");
for(reaNr=1; in.ReadLine(&rida)==true; reaNr++)
{
printf("%06d:%06d\r", kokkuRidu, reaNr);
int tyhik, vordus;
rida += " ";
if((tyhik=(int)rida.Find(' '))<0)
throw VEAD( ERR_HMM_MOOTOR, ERR_RD, __FILE__, __LINE__,
" ", "Jama andmefaili klassid.txt lugemisega");
if(sscanf((const char*)rida, "%d", &n)!=1)
throw VEAD( ERR_HMM_MOOTOR, ERR_RD, __FILE__, __LINE__,
" ", "Jama andmefaili klassid.txt lugemisega");
meta.WriteUnsigned<UB1, int>(n); // jooksva mitmesusklassi suurus
for(int i=0; i<n; i++)
{
if((vordus=(int)rida.Find('=', tyhik+1))<=tyhik+1)
throw VEAD( ERR_HMM_MOOTOR, ERR_RD, __FILE__, __LINE__,
" ", "Jama andmefaili klassid.txt lugemisega", (const char*)rida);
CFSAString tagStr=rida.Mid(tyhik+1, vordus-tyhik-1);
int tagIdx=tags.GetIdx(&tagStr);
if(tagIdx<0)
throw VEAD( ERR_X_TYKK, ERR_ROTTEN, __FILE__, __LINE__,
" ", "Tundmatu ühestamismärgend andmefailis klassid.txt ",
(const char*)rida);
if(meta.WriteUnsigned<UB1,int>(tagIdx)==false)
throw VEAD( ERR_HMM_MOOTOR, ERR_WRITE, __FILE__, __LINE__,
" ", "Jama pakitud sõnastikku kirjutamisega");
UKAPROB tagProb;
if(sscanf(((const char*)rida)+vordus+1, "%e", &tagProb)!=1)
throw VEAD( ERR_X_TYKK, ERR_ROTTEN, __FILE__, __LINE__,
" ", "Puuduv tõenäosus failis klassid.txt ",
(const char*)rida);
if(meta.WriteBuffer(&tagProb,sizeof(UKAPROB))==false)
throw VEAD( ERR_HMM_MOOTOR, ERR_WRITE, __FILE__, __LINE__,
" ", "Jama pakitud sõnastikku kirjutamisega");
if((tyhik=(int)rida.Find(' ', tyhik+1))<=0)
throw VEAD( ERR_HMM_MOOTOR, ERR_RD, __FILE__, __LINE__,
" ", "Jama andmefaili klassid.txt lugemisega");
if(vordus >= tyhik)
throw VEAD( ERR_HMM_MOOTOR, ERR_RD, __FILE__, __LINE__,
" ", "Jama andmefaili klassid.txt lugemisega");
}
}
printf("\n");
}
void CONV_HTML_UC2::ConvToUc(
CFSWString& wStr,
const CFSAString& aStr,
const PFSCODEPAGE koodiTabel
)
{
wStr.Empty();
if(koodiTabel!=PFSCP_HTMLEXT) // Krutime Renee algoritmi j�rgi
{
wStr = FSStrAtoW(aStr, koodiTabel); // Kui teisendus k�ib Rene tabelite j�rgi, siis teeme �ra ja valmis
return;
}
assert(koodiTabel==PFSCP_HTMLEXT); // Kasutame teisendamiseks failist loetud tabelit
if(sgml2uc.idxLast<=0)
throw VEAD(ERR_X_TYKK, ERR_ARGVAL, __FILE__,__LINE__, "$Revision: 557 $",
"SGML olemite tabel mallu lugemata");
int l, n=aStr.GetLength();
for(l=0; l < n; l++)
{
if((aStr[l] & (~0x7F))!=0) // peab olema 7bitine ascii
throw VEAD(ERR_X_TYKK, ERR_ARGVAL, __FILE__,__LINE__, "$Revision: 557 $",
"String peab koosnema ASCII (7bitistest) koodidest", (const char*)aStr+l);
if(aStr[l]!='&') // ei alusta SGML olemit...
{
tryki:
wStr += ((FSWCHAR)(aStr[l])) & 0x7F; // ...l�heb niisama
continue;
}
// V�ib alustada mingit SGML olemit - &blah;
int lSemiPos=(int)aStr.Find(";", l+1);
if(lSemiPos<0) // see ampersand ilma l�petava semita
{
if(ignoramp==true)
goto tryki;
throw VEAD(ERR_X_TYKK, ERR_ARGVAL, __FILE__,__LINE__, "$Revision: 557 $",
"Ampersandi tagant semi puudu", (const char*)aStr+l);
}
if(autosgml==true && aStr[l+1]=='#') // teisenda &#[{x|X}]12345; s�mbolid
{
int tmp=0, j=l+2;
if(aStr[j]=='x' || aStr[j]=='X') // teisenda 𒍅 ja 𒍅 hexakoodid
{
j++;
//if(sscanf(((const char*)aStr)+j, "%x", &tmp)!=1)
// throw VEAD(ERR_X_TYKK, ERR_ARGVAL, __FILE__,__LINE__, "$Revision: 557 $",
// "Vigane SGML olem", (const char*)aStr+l);
//for(; j<lSemiPos; j++)
// {
// if(strchr("0123456789aAbBcCdDeEfF", aStr[j])==NULL)
// throw VEAD(ERR_X_TYKK, ERR_ARGVAL, __FILE__,__LINE__, "$Revision: 557 $",
// "Vigane SGML olem", (const char*)aStr+l);
// }
j+=STRSOUP::UnsignedStr2Hex<int, char>(&tmp, ((const char*)aStr)+j);
if(j<=0 || aStr[j]!=';')
throw VEAD(ERR_X_TYKK, ERR_ARGVAL, __FILE__,__LINE__, "$Revision: 557 $",
"Vigane SGML olem", (const char*)aStr+l);
if(tmp>0xFFFF)
throw VEAD(ERR_X_TYKK, ERR_ARGVAL, __FILE__,__LINE__, "$Revision: 557 $",
"Vigane SGML olem (peab mahtuma 2 baidi peale)", (const char*)aStr+l);
}
else // teisenda 〹 ja 〹 k�mnendkoodid
{
//for(; j<lSemiPos; j++)
// {
// if(aStr[j]<'0' || aStr[j]>'9')
// throw VEAD(ERR_X_TYKK, ERR_ARGVAL, __FILE__,__LINE__, "$Revision: 557 $",
// "Vigane SGML olem (lubatud 0-9)", (const char*)aStr+l);
// if((tmp=10*tmp+aStr[j]-'0')>0xFFFF)
// throw VEAD(ERR_X_TYKK, ERR_ARGVAL, __FILE__,__LINE__, "$Revision: 557 $",
// "Vigane SGML olem (peab mahtuma 2 baidi peale)", (const char*)aStr+l);
// }
j+=STRSOUP::UnsignedStr2Num<int, char>(&tmp, ((const char*)aStr)+j);
if(j<=0 || aStr[j]!=';')
throw VEAD(ERR_X_TYKK, ERR_ARGVAL, __FILE__,__LINE__, "$Revision: 557 $",
"Vigane SGML olem", (const char*)aStr+l);
if(tmp>0xFFFF)
throw VEAD(ERR_X_TYKK, ERR_ARGVAL, __FILE__,__LINE__, "$Revision: 557 $",
"Vigane SGML olem (peab mahtuma 2 baidi peale)", (const char*)aStr+l);
}
wStr += (WCHAR)tmp;
l=lSemiPos;
continue;
}
if(lSemiPos-l+1 > sgml_stringi_max_pikkus) // nii pikk ei saa olla tabelis
{
if(ignoramp==true)
goto tryki;
throw VEAD(ERR_X_TYKK, ERR_ARGVAL, __FILE__,__LINE__, "$Revision: 557 $",
"Puudub SGML olemite tabelist", (const char*)aStr+l);
}
CFSAString szSymbol=aStr.Mid(l, lSemiPos-l+1); // l�ikame &bla; sisendstringist v�lja
SGML_UC* rec;
if((rec=sgml2uc.Get(&szSymbol))==NULL) // ei leidnud kahendtabelist - jama lahti
{
if(ignoramp==true)
goto tryki;
throw VEAD(ERR_X_TYKK, ERR_ARGVAL, __FILE__,__LINE__, "$Revision: 557 $",
"Puudub SGML olemite tabelist", (const char*)szSymbol);
}
wStr += rec->uc;
l=lSemiPos;
}
}
