bool TRoss::InsertDomItem (const char* ItemStr, BYTE DomNo, long& ItemNo)
{
if (DomNo == TitleDomNo)
if (!IsTitle (ItemStr))
{
m_LastError = Format("Warning! Cannot add \"%s\" to title domen!",ItemStr);
return false;
};
if (DomNo == LexDomNo)
if (!IsStandardRusLexeme (ItemStr))
{
m_LastError = Format("Warning! Cannot add \"%s\" to lexeme domen!",ItemStr);
return false;
};
if (DomNo == LexPlusDomNo)
{
DomNo = GetDomNoForLePlus (ItemStr);
if (DomNo == ErrUChar)
{
m_LastError = Format("Warning! Cannot add \"%s\" to the extended lexeme domen!",ItemStr);
return false;
};
};
TDomItem D;
D.SetDomNo (DomNo);
D.SetItemStrLen ( strlen(ItemStr) );
D.SetItemStrNo ( m_Domens[D.GetDomNo() ].AddItem(ItemStr, D.GetItemStrLen() ) );
vector<TDomItem>::iterator It = lower_bound (m_DomItems.begin(), m_DomItems.end(), D, IsLessByItemStrNew(this));
ItemNo = (long)(It-m_DomItems.begin());
if (m_Domens[DomNo].IsEmpty())
{
m_Domens[DomNo].m_StartDomItem = ItemNo;
m_Domens[DomNo].m_EndDomItem = ItemNo+1;
}
else
m_Domens[DomNo].m_EndDomItem++;
size_t i=0;
for (; i<m_Domens.size(); i++)
if (m_Domens[i].m_StartDomItem > ItemNo)
{
m_Domens[i].m_StartDomItem++;
m_Domens[i].m_EndDomItem++;
};
m_DomItems.insert(It, D);
for (i=0; i<_GetCortegesSize(); i++)
for (size_t k=0; k < m_MaxNumDom; k++)
if (GetCortege(i)->GetItem(k) >= ItemNo)
GetCortege(i)->SetItem(k, GetCortege(i)->GetItem(k)+1);
return true;;
};
bool TRoss::UpdateSignatsOfTheFieldInCorteges (BYTE FieldNo, vector<CSignat>& Signats)
{
for (size_t j=0; j < _GetCortegesSize(); j++)
if (GetCortege(j)->m_FieldNo == FieldNo)
{
vector<CSignat>::iterator it = find(Signats.begin(), Signats.end(), Fields[FieldNo].m_Signats[GetCortege(j)->GetSignatNo()]);
GetCortege(j)->SetSignatNo(it - Signats.begin());
if (GetCortege(j)->GetSignatNo() == Fields[FieldNo].m_Signats.size())
return false;
};
return true;
};
STDMETHODIMP CComDictionary::GetCortegeLevelId(LONG CortegeNo, BYTE *result)
{
// TODO: Add your implementation code here
*result = GetCortege(CortegeNo)->m_LevelId;
return S_OK;
}
// создает индекс RusEquivs по словарю type
bool CSemanticsHolder::CreateEngDictIndex(DictTypeEnum type, vector<CEngUnitNoToRusUnit>& RusEquivs)
{
RusEquivs.clear();
long UnitsCount = GetRoss(type)->GetUnitsSize();
BYTE RusFieldNo = GetRoss(type)->GetFieldNoByFieldStr("RUS");
if (RusFieldNo == ErrUChar) return false;
for(long i = 0 ; i < UnitsCount ; i++ )
{
long EndPos = GetRoss(type)->GetUnitEndPos(i);
for(long j = GetRoss(type)->GetUnitStartPos(i) ; j <= EndPos ; j++ )
if( RusFieldNo == GetRoss(type)->GetCortegeFieldNo(j) )
{
CEngUnitNoToRusUnit Item;
TCortege C = GetCortege (GetRoss(type), j);
if( C.m_DomItemNos[0] == -1 )
continue;
Item.m_RusUnitStr = GetRossHolder(type)->GetDomItemStrInner(C.m_DomItemNos[0]);
if(C.m_DomItemNos[1] != -1)
{
string buf = GetRossHolder(type)->GetDomItemStrInner(C.m_DomItemNos[1]);
assert(buf.length() == 1);
Item.m_RusMeanNum = buf[0] - '0';
}
Item.m_EngUnitNo = i;
RusEquivs.push_back(Item);
}
}
sort(RusEquivs.begin(), RusEquivs.end());
return true;
}
// this function can be called more than once for one instance of CSemPattern
// that's why we do not clear it at the beginning
bool CSemPattern::LoadGramFromDict()
{
size_t ActantsCount = 0;
bool IsFound = false;
assert (m_PatternValency.m_RossHolder != 0);
const CDictionary* Ross = m_PatternValency.m_RossHolder->GetRoss();
WORD UnitNo = m_PatternValency.m_UnitNo;
assert (UnitNo != ErrUnitNo);
if (UnitNo == ErrUnitNo)
return false;
if (Ross->IsEmptyArticle(UnitNo)) return false;
//rml_TRACE ("Load pattern of %s\n", Ross->GetEntryStr(UnitNo).c_str());
long EnfCortegeNo = Ross->GetUnitEndPos(UnitNo);
for (size_t i = Ross->GetUnitStartPos(UnitNo); i<= EnfCortegeNo; i++)
{
TCortege C = GetCortege(Ross,i);
if ( (C.m_LeafId != m_PatternValency.m_LeafId)
|| (C.m_BracketLeafId != m_PatternValency.m_BracketLeafId)
)
continue;
if (C.m_FieldNo == m_PatternValency.m_RossHolder->GramFetFieldNo)
{
m_GramCorteges.push_back(C);
IsFound = true;
}
else
if (C.m_FieldNo == m_PatternValency.m_RossHolder->LexFetFieldNo)
{
string S = m_PatternValency.m_RossHolder->GetDomItemStrInner(C.m_DomItemNos[0]);
EngRusMakeUpper(S);
m_LexFets.push_back(S);
IsFound = true;
}
else
if (C.m_FieldNo == m_PatternValency.m_RossHolder->ObligLexFetFieldNo)
{
string S = m_PatternValency.m_RossHolder->GetDomItemStrInner(C.m_DomItemNos[0]);
EngRusMakeUpper(S);
m_ObligLexFets.push_back(S);
IsFound = true;
}
else
if (C.m_FieldNo == m_PatternValency.m_RossHolder->ArticleFieldNo)
{
m_ArticleCorteges.push_back(C);
}
};
return IsFound;
};
string GetPO (const CDictionary* Ross, WORD UnitNo, long POFieldNo)
{
if (UnitNo != ErrUnitNo)
for (size_t i = Ross->GetUnitStartPos(UnitNo); i<= Ross->GetUnitEndPos(UnitNo); i++)
if ( (Ross->GetCortegeFieldNo(i) == POFieldNo)
)
return (const char*)Ross->GetDomItemStr(GetCortege(Ross,i).m_DomItemNos[0]);
return string("общ");
};
bool CRusSemStructure::ReadAuxiliaryArticles()
{
if ( GetRoss(Ross) == NULL) return false;
WORD UnitNo = GetRossHolder(Ross)->LocateUnit("_коэф",1);
if (UnitNo == ErrUnitNo) return false;
if (!GetRoss(Ross)->IsEmptyArticle(UnitNo))
for (size_t i = GetRoss(Ross)->GetUnitStartPos(UnitNo); i<= GetRoss(Ross)->GetUnitEndPos(UnitNo); i++)
{
TCortege C = GetCortege(GetRoss(Ross), i);
string S = WriteToString(GetRoss(Ross), (char*)(GetRoss(Ross)->Fields[C.m_FieldNo].m_Signats[C.GetSignatNo()].sFrmt), C);
Trim(S);
if (!m_SemCoefs.ReadOneCoef (S.c_str()))
{
ErrorMessage (string(S) + string(" is not recognized as a semantic coefficient"));
};
};
UnitNo = GetRossHolder(Ross)->LocateUnit("_weak_syn_rel",1);
if (UnitNo == ErrUnitNo) return false;
m_WeakSynRels.clear();
if (!GetRoss(Ross)->IsEmptyArticle(UnitNo))
for (size_t i = GetRoss(Ross)->GetUnitStartPos(UnitNo); i<= GetRoss(Ross)->GetUnitEndPos(UnitNo); i++)
{
long ItemNo = GetCortege(GetRoss(Ross),i).m_DomItemNos[0];
if (ItemNo != -1)
{
string OneSynRel = GetRossHolder(Ross)->GetDomItemStrInner(ItemNo);
m_WeakSynRels.push_back(OneSynRel);
};
};
sort(m_WeakSynRels.begin(), m_WeakSynRels.end());
return true;
};
bool CSemPattern::LoadSemFromDict()
{
size_t ActantsCount = 0;
bool IsFound = false;
assert (m_PatternValency.m_RossHolder != 0);
const CDictionary* Ross = m_PatternValency.m_RossHolder->GetRoss();
m_ActantSemFets.clear ();
WORD UnitNo = m_PatternValency.m_UnitNo;
//assert (UnitNo != ErrUnitNo);
if (UnitNo == ErrUnitNo)
return false;
if (Ross->IsEmptyArticle(UnitNo)) return false;
//rml_TRACE ("Load pattern of %s\n", Ross->GetEntryStr(UnitNo).c_str());
long EnfCortegeNo = Ross->GetUnitEndPos(UnitNo);
for (size_t i = Ross->GetUnitStartPos(UnitNo); i<= EnfCortegeNo; i++)
{
TCortege C = GetCortege(Ross,i);
if ( (C.m_FieldNo == m_PatternValency.m_RossHolder->SemFetFieldNo)
&& (C.m_LeafId == m_PatternValency.m_LeafId)
&& (C.m_BracketLeafId == m_PatternValency.m_BracketLeafId)
&& (C.m_LevelId > 0)
)
{
if (C.m_LevelId > m_ActantSemFets.size())
m_ActantSemFets.push_back(vector<string>());
string s = m_PatternValency.m_RossHolder->GetDomItemStrInner(C.m_DomItemNos[0]);
if (C.m_LevelId - 1 >= m_ActantSemFets.size())
{
string mess = "ќшибка нумерации SF в статье ";
mess += Ross->GetEntryStr(UnitNo);
ErrorMessage (mess);
}
else
{
m_ActantSemFets[C.m_LevelId - 1].push_back (s );
IsFound = true;
};
}
};
return IsFound;
};
bool CSemanticsHolder::BuildCollocs()
{
long UnitsCount = GetRoss(CollocRoss)->GetUnitsSize();
m_RusCollocs.clear();
BYTE ContentsFieldNo = GetRoss(CollocRoss)->GetFieldNoByFieldStr("CONTENT");
for (long UnitNo=0; UnitNo < UnitsCount; UnitNo++)
if (!GetRoss(CollocRoss)->IsEmptyArticle(UnitNo))
for (size_t i = GetRoss(CollocRoss)->GetUnitStartPos(UnitNo); i<= GetRoss(CollocRoss)->GetUnitEndPos(UnitNo); i++)
if ( (GetRoss(CollocRoss)->GetCortegeFieldNo(i) == ContentsFieldNo)
&& (GetRoss(CollocRoss)->GetCortegeLeafId(i) == 0)
)
{
if (!BuildColloc (GetRossHolder(CollocRoss)->GetDomItemStrInner(GetCortege(GetRoss(CollocRoss), i).m_DomItemNos[0]), UnitNo) )
return false;
break;
};
m_RusCollocItemRefs.clear();
for (long i=0; i < m_RusCollocs.size(); i++)
for (long k=0; k < m_RusCollocs[i].Items.size(); k++)
if (!m_RusCollocs[i].Items[k].IsHole())
{
string S = m_RusCollocs[i].Items[k].Item;
EngRusMakeUpper(S);
CCollocItemRefCollect* It = InsertRusCollocItemRef(S);
It->Refs.push_back(CCollocItemRef(i,k));
// Добавление совершенного вида
StringVector Vec = GetAspVerb(m_RusCollocs[i].Items[k].Item, false);
for (long j=0; j <Vec.size(); j++)
if (Vec[j] != S) // почему-то такое бывает? (двувидовые?)
{
CCollocItemRefCollect* It = InsertRusCollocItemRef(Vec[j]);
It->Refs.push_back(CCollocItemRef(i,k));
};
};
return true;
};
void CEngSemStructure::RefineEngCollocPreps()
{
for( int i=0; i<m_Nodes.size(); i++ )
{
DictTypeEnum type = m_Nodes[i].GetType();
if( type!=EngCollocRoss )
continue;
int unit = m_Nodes[i].GetUnitNo();
vector<TCortege> vec;
for( int j=GetRoss(type)->GetUnitStartPos(unit); j<=GetRoss(type)->GetUnitEndPos(unit); j++ )
{
TCortege C = GetCortege(GetRoss(type),j);
if (C.m_BracketLeafId > 0) continue;
if (C.m_LeafId > 0) continue;
string field = (const char*)GetRoss(type)->Fields[C.m_FieldNo].FieldStr;
if( field == "PREP" )
{
vec.push_back(C);
break;
}
}
if( vec.size()<1 )
continue;
string value = GetCortegeStr(type,vec[0]);
if (value == "-")
m_Nodes[i].m_SynReal.m_Preps.clear();
else
SetSimpleEngPrep(value,i,-1);
vector<long> inRels;
GetIncomingRelations(i,inRels,false);
for( int k=0; k<inRels.size(); k++ )
{
if( m_Relations[inRels[k]].m_Valency.m_RelationStr != "THESAME" ) {
if (value == "-")
m_Relations[inRels[k]].m_SynReal.m_Preps.clear();
else
SetSimpleEngPrep(value,-1,inRels[k]);
break;
}
}
}
}
bool BuildContensField(const CDictionary* Dict, vector<CUnitContent>& Vect)
{
Vect.clear();
long size = Dict->GetUnitsSize();
string strField = "CONTENT";
for(long j = 0 ; j < size ; j++ )
{
int iEndPos = Dict->GetUnitEndPos(j);
for(int i = Dict->GetUnitStartPos(j) ; i <= iEndPos ; i++ )
{
long FieldNo = Dict->GetCortegeFieldNo(i);
if( Dict->Fields[FieldNo].FieldStr == strField )
{
TCortege cortege;
cortege = GetCortege(Dict, i);
string s = (const char*)Dict->GetDomItemStr(cortege.m_DomItemNos[0]);
if (!BuildByFieldContents(s, j, Vect) )
return false;
}
}
}
return true;
};
void TRoss::DelDomItem (long ItemNo)
{
// константы системных доменов не могут встречаться в словарных статьях
if (m_Domens[ m_DomItems[ItemNo].GetDomNo() ].Source != dsSystem)
for (size_t i=0; i<m_Units.size(); i++)
if (!m_Units[i].HasEmptyArticle())
{
for (size_t k = m_Units[i].m_StartCortegeNo; k <= m_Units[i].m_LastCortegeNo; k++)
{
for (size_t j=0; j < m_MaxNumDom; j++)
if (GetCortege(k)->GetItem(j) == ItemNo)
{
if (GetCortege(k)->m_LevelId > 0)
for (size_t l = m_Units[i].m_StartCortegeNo; l <= m_Units[i].m_LastCortegeNo; l++)
if ( (GetCortege(l)->m_FieldNo == GetCortege(k)->m_FieldNo)
&& (GetCortege(l)->m_LeafId == GetCortege(k)->m_LeafId)
&& (GetCortege(l)->m_LevelId > GetCortege(k)->m_LevelId)
)
GetCortege(l)->m_LevelId--;
DelCorteges(k, k+1);
if (m_Units[i].m_StartCortegeNo == m_Units[i].m_LastCortegeNo)
{
m_Units[i].m_StartCortegeNo = InitialStartPos;
m_Units[i].m_LastCortegeNo = InitialEndPos;
goto EmptyArticle;
};
m_Units[i].m_LastCortegeNo--;
k--;
break;
};
};
EmptyArticle:;
};
int ItemStrLen = m_DomItems[ItemNo].GetItemStrLen();
m_Domens[m_DomItems[ItemNo].GetDomNo() ].DelItem(m_DomItems[ItemNo].GetItemStrNo(), ItemStrLen);
int i=0;
for (; i<m_Domens.size(); i++)
if (m_Domens[i].m_StartDomItem > ItemNo)
{
m_Domens[i].m_StartDomItem--;
m_Domens[i].m_EndDomItem--;
};
for (i=0; i<m_DomItems.size(); i++)
if ( m_DomItems[i].GetDomNo() == m_DomItems[ItemNo].GetDomNo() )
if ( m_DomItems[i].GetItemStrNo() > m_DomItems[ItemNo].GetItemStrNo() )
{
int uu = m_DomItems[i].GetItemStrNo();
m_DomItems[i].SetItemStrNo( uu - (ItemStrLen + 1) );
};
for (i=0; i < _GetCortegesSize(); i++)
for (size_t j=0; j < m_MaxNumDom; j++)
if ( GetCortege(i)->GetItem(j) != -1
&& GetCortege(i)->GetItem(j) > ItemNo
)
GetCortege(i)->SetItem(j, GetCortege(i)->GetItem(j) - 1);
m_DomItems.erase ( m_DomItems.begin() +ItemNo );
};
STDMETHODIMP CComDictionary::GetCortegeLeafId(LONG CortegeNo, BYTE *result)
{
*result = GetCortege(CortegeNo)->m_LeafId;
return S_OK;
}
bool CSemanticsHolder::ReadAbstractArticles(DictTypeEnum type)
{
vector<CAbstractArticle> Articles;
long UnitNo = GetRoss(type)->UnitsLowerBound("+");
long UnitsCount = GetRoss(type)->GetUnitsSize();
while ( (UnitNo < UnitsCount)
&& (UnitNo != ErrUnitNo)
)
{
CAbstractArticle A;
A.m_UnitStr = GetRoss(type)->GetEntryStr(UnitNo);
if ( (unsigned char)A.m_UnitStr[0] != '+') break;
if (!GetRoss(type)->IsEmptyArticle(UnitNo))
{
for (size_t i = GetRoss(type)->GetUnitStartPos(UnitNo); i<= GetRoss(type)->GetUnitEndPos(UnitNo); i++)
{
TCortege C = GetCortege(GetRoss(type), i);
string FieldStr = (const char*)GetRoss(type)->Fields[C.m_FieldNo].FieldStr;
if ( FieldStr == "TYP" )
{
string S = WriteToString(GetRoss(type), (char*)(GetRoss(type)->Fields[C.m_FieldNo].m_Signats[C.GetSignatNo()].sFrmt), C);
Trim(S);
if (S == "ДОБАВЛЕНИЕ")
A.m_Type = atAdditionArticle;
else
if (S == "ЗАГЛУШКА")
A.m_Type = atArticlePlug;
else
A.m_Type = atEmptyType;
}
if ( FieldStr == "VAL" )
A.m_Vals.push_back(CValency (C, GetRossHolder(type)->MainWordVarNo, GetRossHolder(type)));
if (C.IsEqual())
{
if (FieldStr == "GF" )
{
CGramInfo I;
string GramFet = WriteToString(GetRoss(type), (char*)(GetRoss(type)->Fields[C.m_FieldNo].m_Signats[C.GetSignatNo()].sFrmt), C);
GetCustomGrammems(GramFet, I.m_Grammems, I.m_PartOfSpeechMask);
A.m_GramInfos.push_back(I);
};
if ( FieldStr == "CLAUSE")
{
string S = WriteToString(GetRoss(type), (char*)(GetRoss(type)->Fields[C.m_FieldNo].m_Signats[C.GetSignatNo()].sFrmt), C);
Trim(S);
long Type = GetRusGramTab()->GetClauseTypeByName(S.c_str());
A.m_ClauseTypes.push_back (Type);
};
if ( FieldStr == "CAT" )
{
string S = WriteToString(GetRoss(type), (char*)(GetRoss(type)->Fields[C.m_FieldNo].m_Signats[C.GetSignatNo()].sFrmt), C);
Trim(S);
A.m_SemTypes.push_back(S);
};
if ( FieldStr == "SF" )
{
string S = WriteToString(GetRoss(type), (char*)(GetRoss(type)->Fields[C.m_FieldNo].m_Signats[C.GetSignatNo()].sFrmt), C);
Trim(S);
A.m_SemFets.push_back(S);
};
if ( FieldStr == "LEX" )
{
string S = WriteToString(GetRoss(type), (char*)(GetRoss(type)->Fields[C.m_FieldNo].m_Signats[C.GetSignatNo()].sFrmt), C);
Trim(S);
A.m_LexFets.push_back(S);
};
}
else
A.m_Article.push_back (C);
};
A.m_UnitNo = UnitNo;
Articles.push_back(A);
};
UnitNo++;
};
m_AbstractArticles[type] = Articles;
return true;
};
bool CSemanticsHolder::BuildColloc (string ContentFieldStr, int CollocUnitNo)
{
size_t i = ContentFieldStr.find("(");
if (i == -1)
{
CColloc C;
C.UnitNo = CollocUnitNo;
C.IsBlackBox = !FindField (GetRoss(CollocRoss), CollocUnitNo, "AUX");
C.IsConditional = IsConditional (*GetRossHolder(CollocRoss), CollocUnitNo);
C.m_SemMainWord = GetRossHolder(CollocRoss)->GetSemMainWordFromArticle(CollocUnitNo);
// Build items
string ItemStr = ContentFieldStr;
TrimLeft(ContentFieldStr);
while (!ContentFieldStr.empty())
{
int j = ContentFieldStr.find_first_of(" \t");
string Q = ContentFieldStr.substr (0, j);
ContentFieldStr.erase(0, j);
CCollocItem CollocItem;
if (!CollocItem.InitCollocItem(Q))
{
string mess = "Unbound reloperator in ";
mess += GetRoss(CollocRoss)->GetEntryStr(C.UnitNo);
ErrorMessage(mess);
};
C.Items.push_back(CollocItem);
TrimLeft(ContentFieldStr);
}
if (!GetRoss(CollocRoss)->IsEmptyArticle(CollocUnitNo))
// по словарной статье
for (size_t j = GetRoss(CollocRoss)->GetUnitStartPos(CollocUnitNo); j <= GetRoss(CollocRoss)->GetUnitEndPos(CollocUnitNo); j++)
{
TCortege Cort = GetCortege(GetRoss(CollocRoss), j);
//незаполненное поле?
if (Cort.m_DomItemNos[0] == -1) continue;
// строю массив U.m_Places по полю CONTENT
string FieldStr = (const char*)GetRoss(CollocRoss)->Fields[Cort.m_FieldNo].FieldStr;
// инициализирую перечень всех необходимых синтаксических отношений их поля SYNREP
if ( (FieldStr == "SYNR")
&& (Cort.m_LeafId == 0)
&& (Cort.m_BracketLeafId == 0)
)
{
string F = GetRossHolder(CollocRoss)->GetDomItemStrInner(Cort.m_DomItemNos[1]);
long PlaceNo1 = F[1] - '0' - 1;
F = GetRossHolder(CollocRoss)->GetDomItemStrInner(Cort.m_DomItemNos[2]);
long PlaceNo2 = F[1] - '0' - 1;
string SynGrp = GetRossHolder(CollocRoss)->GetDomItemStrInner(Cort.m_DomItemNos[0]);
rml_TRACE (SynGrp.c_str());
if ( (PlaceNo1 >= C.Items.size())
|| (PlaceNo2 >= C.Items.size())
)
{
string mess = "Error in SYNREP in ";
mess += GetRoss(CollocRoss)->GetEntryStr(C.UnitNo);
ErrorMessage(mess);
return false;
};
C.m_Rels.push_back(CSynRelation(PlaceNo1, PlaceNo2, SynGrp));
};
}
m_RusCollocs.push_back(C);
}
else
{
size_t k = ContentFieldStr.find (")");
if (k == -1)
{
ErrorMessage(Format ("Error in parenthesis in colloc %s", ContentFieldStr.c_str()));
return false;
};
size_t last_j = i;
for (size_t j= i+1; j <= k; j++)
{
if ( (j == k)
|| (ContentFieldStr[j] == '|'))
{
string q;
if (i >0)
q += ContentFieldStr.substr(0, i-1);
q += string(" ");
q += ContentFieldStr.substr(last_j+1, j-last_j-1);
q += string(" ");
if ( k-1 < ContentFieldStr.length() )
q += ContentFieldStr.substr(k+1);
if (!BuildColloc(q, CollocUnitNo) ) return false;
last_j = j;
};
};
};
return true;
};
STDMETHODIMP CComDictionary::GetCortegeFieldNo(LONG CortegeNo, BYTE *result)
{
*result = GetCortege(CortegeNo)->m_FieldNo;
return S_OK;
}
STDMETHODIMP CComDictionary::GetCortegeItem(LONG CortegeNo, BYTE PositionInCortege, LONG* ItemId)
{
*ItemId = GetCortege(CortegeNo)->GetItem(PositionInCortege);
return S_OK;
}
STDMETHODIMP CComDictionary::GetCortegeBracketLeafId(long CortegeNo, long* BracketLeafId)
{
*BracketLeafId = GetCortege(CortegeNo)->m_BracketLeafId;
return S_OK;
}
// преобразование словаря групп времени в удобный для поиска вид
bool CSemanticsHolder::InitTimeUnits()
{
// инициализация констант
BYTE GramFunctDomNo = GetRoss(TimeRoss)->GetDomenNoByDomStr("D_GRAM_FUNCT");
int AbbrFunctName = GetRoss(TimeRoss)->GetItemNoByItemStr("СОКР", GramFunctDomNo);
int AbbrFunctPluralName = GetRoss(TimeRoss)->GetItemNoByItemStr("СОКР_мн", GramFunctDomNo);
m_TimeAbbrPairs.clear();
m_TimeUnits.clear();
// идем по всем статьям словаря групп времени
for (size_t UnitNo =0; UnitNo < GetRoss(TimeRoss)->GetUnitsSize(); UnitNo++)
{
try {
CTimeUnit U;
U.m_UnitNo = UnitNo;
if (!GetRoss(TimeRoss)->IsEmptyArticle(UnitNo))
// по словарной статье
for (size_t i = GetRoss(TimeRoss)->GetUnitStartPos(UnitNo); i<= GetRoss(TimeRoss)->GetUnitEndPos(UnitNo); i++)
{
TCortege C = GetCortege(GetRoss(TimeRoss), i);
//незаполненное поле?
if (C.m_DomItemNos[0] == -1) continue;
// строю массив U.m_Places по полю CONTENT
string FieldStr = (const char*)GetRoss(TimeRoss)->Fields[C.m_FieldNo].FieldStr;
if ( (FieldStr == "CONTENT")
&& (C.m_LeafId == 0)
&& (C.m_BracketLeafId == 0)
)
{
string Lemma;
string Contents = GetRossHolder(TimeRoss)->GetDomItemStrInner(C.m_DomItemNos[0]);
for (BYTE PlaceNo =0; GetLemmaFromTitle(Contents, PlaceNo, Lemma); PlaceNo++)
U.m_Places.push_back(Lemma);
};
if ( (FieldStr == "RESTR")
&& (C.m_LeafId == 0)
&& (C.m_BracketLeafId == 0)
)
{
string Contents = GetRossHolder(TimeRoss)->GetDomItemStrInner(C.m_DomItemNos[0]);
if (Contents == "свобод")
U.m_bCanFillNotTimeValency = true;
};
// инициализирую перечень всех необходимых синтаксических отношений их поля SYNREP
if ( (FieldStr == "SYNREP")
&& (C.m_LeafId == 0)
&& (C.m_BracketLeafId == 0)
)
{
long PlaceNo1 = atoi(GetRossHolder(TimeRoss)->GetDomItemStrInner(C.m_DomItemNos[1]));
long PlaceNo2 = atoi(GetRossHolder(TimeRoss)->GetDomItemStrInner(C.m_DomItemNos[2]));
if (!PlaceNo1 || !PlaceNo2) continue;
string SynGrp = GetRossHolder(TimeRoss)->GetDomItemStrInner(C.m_DomItemNos[0]);
rml_TRACE (SynGrp.c_str());
U.m_Rels.push_back(CSynRelation(PlaceNo1-1, PlaceNo2-1, SynGrp));
};
// инициализирую глобальный перечень наборов (полное временное слово, аббревиатура, аббревиатурная функция),
// который называется m_TimeAbbrPairs
// аббревиатурная функция = АББР_мн, АББР, АББР_ед
// например:(год, гг.,АББР_мн)
// (год, г., АББР_ед)
if ( (FieldStr == "DERIV")
&& (C.m_LeafId == 0)
&& (C.m_BracketLeafId == 0)
)
{
if ( (C.m_DomItemNos[0] != AbbrFunctPluralName)
&& (C.m_DomItemNos[0] != AbbrFunctName)
)
continue;
string FullForm = GetRoss(TimeRoss)->GetEntryStr(UnitNo);
EngRusMakeUpper(FullForm);
string AbbrForm = GetRossHolder(TimeRoss)->GetDomItemStrInner(C.m_DomItemNos[1]);
EngRusMakeUpper(AbbrForm);
m_TimeAbbrPairs.push_back(CAbbrFunct(AbbrForm, FullForm, GetRossHolder(TimeRoss)->GetDomItemStrInner(C.m_DomItemNos[0])));
};
// инициализирую перечень лексического заполнения дырок, который берется из
// полей LEX и PREP
if (FieldStr == "LEX")
{
string S = GetRossHolder(TimeRoss)->GetDomItemStrInner(C.m_DomItemNos[0]);
EngRusMakeUpper(S);
long LexFillingNoNo = U.GetLexicalFillingNo(CTimeLexicalFilling(C.m_LeafId, C.m_BracketLeafId));
U.m_LexicalFillings[LexFillingNoNo].m_LexFets.push_back(stringLong(S,C.m_LevelId));
}
else
if (FieldStr == "PREP")
{
string Prep = GetRossHolder(TimeRoss)->GetDomItemStrInner(C.m_DomItemNos[0]);
WORD PrepNo = GetRossHolder(OborRoss)->LocateUnit(Prep.c_str(),1);
if (PrepNo == ErrUnitNo)
{
string Q =Format ("Предлог %s в статье %s не найден в словаре оборотов", Prep.c_str(), GetRoss(TimeRoss)->GetEntryStr(UnitNo).c_str());
ErrorMessage (Q);
continue;
};
long LexFillingNoNo = U.GetLexicalFillingNo(CTimeLexicalFilling(C.m_LeafId, C.m_BracketLeafId));
U.m_LexicalFillings[LexFillingNoNo].m_Preps.push_back(LongLong(PrepNo,C.m_LevelId));
};
};
m_TimeUnits.push_back(U);
}
catch (...)
{
ErrorMessage (Format("Cannot index article \"%s\"", GetRoss(TimeRoss)->GetEntryStr(UnitNo).c_str()));
return false;
};
};
return true;
};
