C++ Dictionary::GetSynGram方法代码示例

void ModelTagMatcher::Print( lem::OFormatter & to, Dictionary & dict ) const
{
 if( !lexeme.empty() )
  to.printf( "\"%us\" ", lexeme.c_str() );

 for( lem::Container::size_type i=0; i<id_lemma.size(); ++i )
  {
   int id_entry = id_lemma[i];
   const SG_Entry & e = dict.GetSynGram().GetEntry(id_entry);
   int id_class = e.GetClass();
   const SG_Class & c = dict.GetSynGram().GetClass( id_class );
   to.printf( "%us:%us ", c.GetName().c_str(), e.GetName().c_str() );
  }

 for( lem::Container::size_type i=0; i<pos.size(); ++i )
  {
   const SG_Class & c = dict.GetSynGram().GetClass( pos[i] );
   lem::mout->printf( "%us ", c.GetName().c_str() );
  }

 for( lem::Container::size_type i=0; i<pairs.size(); ++i )
  {
   const Solarix::GramCoordPair & p = pairs[i];
   p.SaveTxt( to, dict.GetSynGram() );
   to.printf( " " );
  }

 return;
}

void ExportCoordFunction_IfContains::LoadTxt(
                                             Dictionary &dict,
                                             lem::Iridium::Macro_Parser & txtfile,
                                             const SynPatterns & pattern_declarations,
                                             SynPatternCompilation & compilation_context,
                                             const SynPatternPoint & point
                                            )
{
 txtfile.read_it( B_OROUNDPAREN );
 pair.LoadTxt( txtfile, dict.GetSynGram() );
 txtfile.read_it( B_CROUNDPAREN );
 return;
}

int TF_ClassFilter::Score( const Word_Form &wf, const Dictionary &dict ) const
{
 if( allowed_classes.empty() )
  return 0;

 const int ekey = wf.GetEntryKey();
 if( lem::is_quantor(ekey) )
  return 0;

 const int iclass = dict.GetSynGram().GetEntry(ekey).GetClass();

 return (iclass==UNKNOWN || allowed_classes.find(iclass)!=UNKNOWN) ? 0 : -100;
}

void TreeScorerCall::PrintContext( Dictionary & dict, OFormatter & out ) const
{
 out.printf( "Edges count=%d:\n", edges.size() );
 for( int i=0; i<edges.size(); ++i )
  {
   edges[i].from->Print( out, & dict.GetSynGram(), true );
   const int lt = edges[i].link_type;
   out.printf( " --" );
   if( lt==UNKNOWN )
    out.printf( "<<UNKNOWN>>" );
   else
    out.printf( "%us", dict.GetSynGram().GetLink(lt).c_str() );

   out.printf( "--> " );

   edges[i].to->Print( out, & dict.GetSynGram(), true );
   out.eol();
  }

 out.eol();

 return;
}

void SyllabRule::LoadTxt( lem::Iridium::Macro_Parser &txtfile, Dictionary &dict )
{
 lem::Iridium::BSourceState point_begin = txtfile.tellp();
 id_src = dict.GetDebugSymbols().RegisterLocation( txtfile, point_begin );

 // шапка: syllab_rule XXXX language=YYY
 name = txtfile.read().string();
 txtfile.read_it( B_LANGUAGE );
 txtfile.read_it( B_EQUAL );
 lem::Iridium::BethToken lang = txtfile.read();
 id_language = dict.GetSynGram().Find_Language(lang.string());
 if( id_language==UNKNOWN )
  {
   lem::Iridium::Print_Error(lang,txtfile);
   dict.GetIO().merr().printf( "Unknown language name %us\n", lang.c_str() );
   throw lem::E_BaseException();
  }     

 txtfile.read_it( B_OFIGPAREN );

 txtfile.read_it( B_IF );
 txtfile.read_it( B_CONTEXT );

 condition.LoadTxt( txtfile, dict );

 txtfile.read_it( B_THEN );
 txtfile.read_it( B_OFIGPAREN );
 txtfile.read_it( B_CONTEXT );

 result.LoadTxt( txtfile, dict, condition );
 
 txtfile.read_it( B_CFIGPAREN ); // закрываем блок then { ... }
 
 txtfile.read_it( B_CFIGPAREN ); // закрываем тело правила

 return; 
}

MLNetNode::MLNetNode(
    const MLNetNode* prev,
    int ifrom,
    int nword,
    int tot_len,
    const MCollect<MLProjJob*> &proj,
    const MCollect<MLProjList*> &job_list,
    const MCollect<int> &word_job,
    const MCollect<Lexem> &words,
    Dictionary &dict
)
{
    // Наш узел описывает мультилексемы, начнающиеся с позиции ifrom и
    // содержащие nword лексем.
    previous = prev;
    from = ifrom;
    n = nword;

    const int njob = CastSizeToInt(job_list.size());

    // Собираем пробные мультилексемы, начиная с позиции from предложения.
    // Общая длина предложения задана как tot_len, максимальная длина
    // создаваемых мультилексем равна max_ml_len. Информация о пробных
    // мультилексемах будет хранится в подключаемых узлах.
    const int iFrom = ifrom + nword; // Индекс начала следующих мультилексем.

    if (iFrom == tot_len)
        return;

    int IPROJ_found = UNKNOWN;
    bool PROJ_found = false;

    int max_ml_len = dict.GetSynGram().IsMultiLexemBegin(words[iFrom]);
    if (max_ml_len <= 0)
        max_ml_len = 1;

    Lexem ml;

    SynGram &sg = dict.GetSynGram();

    for (int len = 1; len <= max_ml_len && (iFrom + len) <= tot_len; len++)
    {
        if (len == 1)
        {
            PROJ_found = true;

            const int m0 = tot_len - iFrom;
            const int m1 = std::min(m0, max_ml_len);
            if (m1 == 2)
            {
                if (!sg.IsWordForm(words[iFrom]))
                {
                    ml = words[iFrom];
                    ml.Add(words[iFrom + 1]);
                    if (sg.IsMultiLexem(ml))
                        continue;
                }
                else if (!sg.IsWordForm(words[iFrom + 1]))
                {
                    ml = words[iFrom];
                    ml.Add(words[iFrom + 1]);
                    if (sg.IsMultiLexem(ml))
                        continue;
                }
            }
            else if (m1 == 3)
            {
                ml = words[iFrom];
                ml.Add(words[iFrom + 1]);
                ml.Add(words[iFrom + 2]);
                if (sg.IsMultiLexem(ml))
                {
                    ml = words[iFrom + 1];
                    ml.Add(words[iFrom + 2]);
                    if (!sg.IsMultiLexem(ml))
                    {
                        if (!sg.IsWordForm(words[iFrom + 1]) || !sg.IsWordForm(words[iFrom + 2]))
                            continue;
                    }
                }
            }
        }
        else
        {
            PROJ_found = false;
            IPROJ_found = UNKNOWN;

            ml.clear();
            for (int ii = 0; ii < len; ii++)
                ml.Add(words[iFrom + ii]);

            if (dict.GetSynGram().IsMultiLexem(ml))
            {
                // Если в списке job_list заданий на проекцию мультилексем фразоблока
                // удастся найти задание для нашей мультилексемы и эта мультилексема
                // хоть раз спроецирована, то имеет смысл продолжать построение сети
                // далее.
                for (int ijob = 0; ijob < njob; ijob++)
                {
                    if (
//.........这里部分代码省略.........

void SynPattern::LoadTxt(
                         Dictionary &dict,
                         lem::Iridium::Macro_Parser & txtfile,
                         const SynPatterns &patterns,
                         WordEntrySet &wordentry_set,
                         const TrProcedureDeclaration &procs,
                         TrFunctions &functions
                        )
{
 lem::Iridium::BSourceState pattern_beginning = txtfile.tellp();

 id_src = dict.GetDebugSymbols().RegisterLocation( txtfile, txtfile.tellp() );

 if( dict.GetDebugLevel_ir()>=3 )
  {
   dict.GetIO().mecho().printf( "pattern " );
  }

 // ќпционально могут быть заданы целевой ¤зык и опции.

 while( !txtfile.eof() )
 {
  if( txtfile.probe( B_OFIGPAREN ) )
   break;

  if( txtfile.probe( B_LANGUAGE ) )
   {
    txtfile.read_it( B_EQUAL );
   
    lem::Iridium::BethToken lang = txtfile.read();
    id_language = dict.GetSynGram().Find_Language(lang.string());
    if( id_language==UNKNOWN )
     {
      lem::Iridium::Print_Error(lang,txtfile);
      dict.GetIO().merr().printf( "Unknown language name %us\n", lang.c_str() );
      throw lem::E_BaseException();
     }     
   }
  else if( txtfile.probe( L"incomplete" ) )
   {
    incomplete=true;
   }
  else
   {
    lem::Iridium::BethToken tname = txtfile.read();
    name = tname.string();
  
    if( dict.GetDebugLevel_ir()>=3 )
     {
      dict.GetIO().mecho().printf( "%vfE%us%vn ", name.c_str() );
     }
  
    if( !patterns.IsPatternName(name) )
     {
      dict.GetIO().merr().printf( "Patterns group [%us] is not declared\n", name.c_str() );
      lem::Iridium::Print_Error(tname,txtfile);
      throw lem::E_BaseException();
     }
  
    const SynPatternOptions & group_options = patterns.GetOptions(name);
    id_language = group_options.GetLanguageId();
  
    // —екци¤ export { ... } содержит объ¤влени¤ координат, которые паттерн выдает наружу
    // —начала попробуем вз¤ть содержимое экспорта по умолчанию, зарегистрированное в объ¤влении
    // группы паттернов.
  
    if( txtfile.probe(L"export") )
     {
      export_info.LoadTxt( dict, txtfile );
     }
    else
     {
      const SynPatternOptions & p_options = patterns.GetOptions(name);
      export_info = p_options.GetExport();
     }
  
    export_info.RegisterExport( *compilation_context );
  
    if( txtfile.probe( B_LANGUAGE ) )
     {
      txtfile.read_it( B_EQUAL );
      
      lem::Iridium::BethToken lang = txtfile.read();
      id_language = dict.GetSynGram().Find_Language(lang.string());
      if( id_language==UNKNOWN )
       {
        lem::Iridium::Print_Error(lang,txtfile);
        dict.GetIO().merr().printf( "Unknown language name %us\n", lang.c_str() );
        throw lem::E_BaseException();
       }     
     }
  
    txtfile.read_it( B_OFIGPAREN );
    break;
   }
 }

 // —писок опорных точек в фигурных скобочках
 lem::Iridium::BSourceState beg = txtfile.tellp();

//.........这里部分代码省略.........

void SynPatternExport::LoadTxt(
                               Dictionary &dict,
                               lem::Iridium::Macro_Parser & txtfile
                              )
{
 txtfile.read_it( B_OFIGPAREN );

 while( !txtfile.eof() )
  {
   bool null_export = txtfile.probe( B_OROUNDPAREN );
   lem::Iridium::BethToken coord_name = txtfile.read();
 
   if( coord_name.GetToken()==B_CFIGPAREN )
    break;

   if( coord_name.string().eqi( L"node" ) )
    {
     txtfile.read_it( B_COLON );
     lem::Iridium::BethToken t_node_name = txtfile.read();
     lem::UCString node_name = t_node_name.string();
     node_name.to_upper();

     if( export_nodes.find(node_name)!=UNKNOWN )
      {
       dict.GetIO().merr().printf( "Wordform %us is already mentioned in export section\n", t_node_name.string().c_str() );
       lem::Iridium::Print_Error(t_node_name,txtfile);
       throw lem::E_BaseException();
      }

     export_nodes.push_back( node_name );
     null_export_nodes.push_back( null_export ? 1 : 0 );

     if( null_export )
      txtfile.read_it( B_CROUNDPAREN );

     continue;
    }

   const GramCoordAdr iglob_coord = dict.GetSynGram().FindCoord(coord_name.string());
 
   if( !iglob_coord.IsDefined() )
    {
     dict.GetIO().merr().printf( "Unknown coordinate %us\n", coord_name.c_str() );
     lem::Iridium::Print_Error(coord_name,txtfile);
     throw lem::E_BaseException();
    }
 
   if( export_coords.find( iglob_coord.GetIndex() )!=UNKNOWN )
    {
     dict.GetIO().merr().printf( "Coordinate %us is already mentioned in export section\n", coord_name.c_str() );
     lem::Iridium::Print_Error(coord_name,txtfile);
     throw lem::E_BaseException();
    }
 
   export_coords.push_back(iglob_coord.GetIndex());
   null_export_coords.push_back( null_export ? 1 : 0 );

   if( null_export )
    txtfile.read_it( B_CROUNDPAREN );
  }

 return;
}

void PatternConstraint::LoadTxt( 
                                Dictionary &dict,
                                lem::Iridium::Macro_Parser & txtfile,
                                SynPatternCompilation & compilation_context
                               )
{
 lem::Iridium::BethToken marker_name = txtfile.read();

 if( compilation_context.Find(marker_name)==UNKNOWN )
  {
   dict.GetIO().merr().printf( "Marker [%us] is not declared in this pattern", marker_name.c_str() );
   lem::Iridium::Print_Error(marker_name,txtfile);
   throw lem::E_BaseException();
  }

 // ---------------------------

 from_marker = marker_name.string();
 from_marker.to_upper();

 // ---------------------------

 txtfile.read_it( B_COLON );

 lem::Iridium::BethToken coord_name1 = txtfile.read();
 //if( for_group ) txtfile.read_it( B_CSPAREN );

 Solarix::GramCoordAdr iglob_coord1 = dict.GetSynGram().FindCoord(coord_name1.string());

 if( !iglob_coord1.IsDefined() )
  {
   dict.GetSynGram().GetIO().merr().printf( "Unknown coordinate %us\n", coord_name1.c_str() );
   lem::Iridium::Print_Error(coord_name1,txtfile);
   throw lem::E_BaseException();
  }

 from_coord_id = iglob_coord1.GetIndex();

 // ---------------------------

 lem::Iridium::BethToken func = txtfile.read();

 if( func.GetToken()==B_EQUAL )
  constraint_func = EqualFunc;
 else if( func.GetToken()==B_LOGNE )
  constraint_func = NotEqualFunc;
 else
  {
   dict.GetIO().merr().printf( "Unknown constraint [%us]", func.string().c_str() );
   lem::Iridium::Print_Error(func,txtfile);
   throw lem::E_BaseException();
  }

 marker_name = txtfile.read();

 if( compilation_context.Find(marker_name)==UNKNOWN )
  {
   dict.GetIO().merr().printf( "Marker [%us] is not declared in this pattern", marker_name.c_str() );
   lem::Iridium::Print_Error(marker_name,txtfile);
   throw lem::E_BaseException();
  }

 to_marker = marker_name.string();
 to_marker.to_upper();

 // ---------------------------

 txtfile.read_it( B_COLON );

 lem::Iridium::BethToken coord_name2 = txtfile.read();
 //if( for_group ) txtfile.read_it( B_CSPAREN );

 Solarix::GramCoordAdr iglob_coord2 = dict.GetSynGram().FindCoord(coord_name2.string());

 if( !iglob_coord2.IsDefined() )
  {
   dict.GetSynGram().GetIO().merr().printf( "Unknown coordinate %us\n", coord_name2.c_str() );
   lem::Iridium::Print_Error(coord_name2,txtfile);
   throw lem::E_BaseException();
  }

 to_coord_id = iglob_coord2.GetIndex();

 return;
}