C++ SynGram::GetEntry方法代码示例

Predef_Word_Form::Predef_Word_Form( int ientry_key, SynGram &gram )
:Word_Form(
           RC_Lexem( const_cast<Lexem*>(&gram.GetEntry( ientry_key ).GetName()), null_deleter() ),
           RC_Lexem( const_cast<Lexem*>(&gram.GetEntry( ientry_key ).GetName()), null_deleter() ),
           ientry_key,
           Real1(100)
          )
{}

/******************************************************************
 Считывание описание узла BETH-дерева из текстового файла Словаря.
*******************************************************************/
void Word_Form::LoadTxt(
                        CompilationContext &context,
                        Macro_Parser &txtfile,
                        SynGram &gram
                       )
{
 val=Real1(100);
 score=0;
 iversion = seq_iversion++;

 // Сначала считываем определение класса и имя словарной статьи.
 const BethToken class_name = txtfile.read();
 entry_key=UNKNOWN_STATE;
 int iclass;

 // Если считанная лексема заключена в апострофы, то имеем дело
 // с сокращенным форматом: ?:строка. Этот формат применяется дл
 // описания лексемы, принадлежность которой к какому-либо классу
 // не очевидна или не важна, а важно лексическое представление.
 if( in_apostrophes(class_name.string()) )
  {
   name = RC_Lexem( new Lexem(strip_quotes(class_name.string())) );
   return;
  }

 if( class_name.string()==SOL_UNKNOWN_ENTRY_NAME )
  {
   // Только одна статья принадлежит особому классу UNKNOWN!
   // Эта статья может быть описана только как "?:?"

   if(
      txtfile.read().string()==sol_get_token(B_COLON) &&
      txtfile.read().string()==sol_get_token(B_UNKNOWN)
     )
    {
     const Word_Coord iuu = gram.FindEntryForm( class_name.string() );
     const SG_Entry& euu = gram.GetEntry(iuu.GetEntry());

     iclass=UNKNOWN_STATE;
     entry_key = euu.GetKey();
     return;
    }
  }

 // Пытаемся найти имя синтаксического класса в списке
 // уже загруженных в Словаре для синтаксической грамматики.
 if( (iclass=gram.FindClass(class_name.string()))==UNKNOWN )
  {
   // Класс не определен.
   //
   // Предполагаем, что задано лексическое содержимое некоторой
   // словоформы. Если такая словоформа лексически уникальна,
   // то мы сами можем восстановить пару класс:статья. В случае
   // множественности вариантов тяжесть ответственности ложитс
   // на пользователя.
   Word_Coord ie = gram.FindEntryForm( class_name.string() );

   if( ie.GetEntry()==UNKNOWN )
    {
     // Выводим сообщение о неверном имени синтаксического класса или
     // ненайденной словоформе.
     lem::Iridium::Print_Error(class_name,txtfile);
     gram.GetIO().merr().printf("Neither a class previously declared in grammar, nor an entry form\n");
     throw E_ParserError();
    }

   if( ie.GetEntry()!=UNKNOWN )
    {
     // Словоформа найдена!
     const SG_Entry& ef = gram.GetEntry(ie.GetEntry());
     entry_key = ef.GetKey();

     // Вероятно, следует также переслать координатные пары.
     const SG_EntryForm& eef = ef.forms()[ ie.GetForm() ];
     const CP_Array& dims = eef.coords();

     for( Container::size_type ii=0; ii<dims.size(); ii++ )
      {
       // Здесь немного наворочено - прямо использовать конструктор без
       // копирования в промежуточные поля нельзя из-за ошибки в
       // кодогенераторе Symantec C++ (появляется General Protection Fault).
       const GramCoordAdr ca = dims[ii].GetCoord();
       const int cs = dims[ii].GetState();
       pair.push_back( GramCoordEx( ca, cs, true ) );
      }

     // И наконец, пересылаем полное имя (лексическое содержимое) статьи.
//     icenter=0;
//     e_list.push_back( entry_key );
     name = RC_Lexem( const_cast<Lexem*>(&ef.GetName()), null_deleter() );
    }

   return;
  }

 const BSourceState back=txtfile.tellp();
 const BethToken t = txtfile.read();
//.........这里部分代码省略.........

// ***************************************************************
// Лексическое содержимое словоформы приводим в соответствие с
// координатами.
// ***************************************************************
void Word_Form::Rename_By_States( SynGram &sg, bool apply_versions )
{
 iversion = seq_iversion++;

 if( entry_key!=UNKNOWN )
  {
   try
    {
     const SG_Entry &E = sg.GetEntry(entry_key);
     const int iclass = E.GetClass();

     const GramClass &C = sg.classes()[ iclass ];

     // Имеем список всех координатных пар. Из него надо выделить только
     // измерения.
     CP_Array dims;
     dims.reserve(16);

     for( Container::size_type ic=0; ic<pair.size(); ic++ )
      {
       if( C.dims().find( pair[ic].GetCoord() ) != UNKNOWN )
        dims.push_back( pair[ic] );
      }

     // Собрали в список dims только измерения.

     // Ищем подходящую по координатам форму.
     const SG_EntryForm &F = E.FindFormAny(dims);

     // Перекачаем ее координаты себе.
     const CP_Array& c = F.coords();

     for( Container::size_type i2=0; i2<c.size(); i2++ )
      SetState( c[i2], false, false );

     #if LEM_DEBUGGING==1
     const int npairs2 = CastSizeToInt(pair.size());
     #endif

     // Нашли наиболее подходящую форму - берем ее лексическое содержание.
     const Lexem &new_name = F.name();

     name = RC_Lexem( new Lexem(new_name) );

/*
     // Просто поменять имя словоформы нельзя, так как мы можем быть результатом
     // свертки. Надо вычленить из списка name те лексемы, которые относятся к
     // обновленной форме (грамматическому центру), и заменить их на новое
     // значение.

     // Начальная позиция в цепочке лексем

     int i_from = lem::find( lexem_owner, icenter );
     int n = std::count( lexem_owner.begin(), lexem_owner.end(), icenter );

     UCStringSet parts;
     new_name.Split(parts);  

     if( n == parts.size() )
      {
       // Число лексем в имени не поменялось
       UCStringSet old_parts;
       name->Split( old_parts );

       for( int i=0; i<n; i++ )
        old_parts[i_from+i] = parts[i];

       name = RC_Lexem( new Lexem(old_parts) );
      }
     else
      {
       // Вряд ли возможная ситуация: у найденной формы имя имеет иное
       // число лексем, чем у прежней формы.
       //LEM_STOPIT;
//       throw E_BaseException( L"Internal syntax engine error" ); 
      }
*/
    }
   catch( const E_SG_NoForm& )
    {
    }
  }

 if( apply_versions )
  for( lem::Container::size_type i=0; i<alt.size(); ++i )
   alt[i]->Rename_By_States( sg, true );

 return;
}

void SG_ComplexLink::LoadPoint( Macro_Parser &txtfile, SynGram &gram, lem::UFString &entry )
{
 BethToken t = txtfile.read();

 if( t.GetToken()==B_ENTRY )
  {
   // Особый формат entry Класс:Статья { уточнение }
   // преобразуется в ключ статьи и возвращается в виде #ключ
   UCString class0 = txtfile.read().string();
   const int ic0 = class0==L"?" ? ANY_STATE : gram.FindClass(class0);
   if( ic0==UNKNOWN ) 
    {
     Print_Error( txtfile );
     gram.GetIO().merr().printf( "Unknown class %us\n", class0.c_str() );
     throw E_BaseException();
    }

   txtfile.read_it( B_COLON );
   UCString entry0 = sol_read_multyname( gram.GetIO(), txtfile, B_OFIGPAREN );
   entry0.strip(L'"');
   entry0.trim();

   // Может быть задана дополнительная фильтрующая координата
   Solarix::CP_Array coords0;
   coords0.LoadTxt( txtfile, gram );
   
   if( gram.IsOmonym(ic0,lem::to_upper(entry0)) && coords0.empty() )
    {
     Print_Error( txtfile );
     gram.GetIO().merr().printf( "Omonym %us:%us requires the coordinate array\n", class0.c_str(), entry0.c_str() );
     throw E_BaseException();
    }

   const int ie0 = coords0.empty() ? gram.FindEntry(entry0,ic0,false) : gram.FindEntryOmonym(entry0,ic0,coords0);
   if( ie0==UNKNOWN ) 
    {
     Print_Error( txtfile );
     gram.GetIO().merr().printf( "Unknown entry %us:%us\n", class0.c_str(), entry0.c_str() );
     throw E_BaseException();
    }

   const int ekey = gram.GetEntry(ie0).GetKey();
   entry = lem::format_str( L"#%d", ekey );

   return;
  }

 bool figparen = t.GetToken()==B_OFIGPAREN;

 if( !figparen )
  txtfile.seekp(t);
 
 entry.reserve(128);

 if( t.string()==L'@' )
  {
   entry = L'@';
   t = txtfile.read();
  }

 while( !txtfile.eof() )
  {
   BethToken t = txtfile.read();
   if( figparen && t.GetToken()==B_CFIGPAREN )
    break;
   
   if( !entry.empty() )
    entry.Add_Dirty(L' ');

   UFString ts( t.GetFullStr() );
   ts.strip(L'"');
   entry.Add_Dirty( ts );

   if( !figparen )
    break;
  }

 entry.calc_hash();

 if( entry.front()==L'@' )
  {
   // Спецсимвол @ заставляет запомнить строку в виде "как есть"
   entry.remove(0);
   entry.trim();
  }
 else
  {
   entry.strip(L'"');
   gram.GetDict().GetLexAuto().TranslateLexem(entry,true);
  }

 return;
}