C++ SynGram类代码示例

// Проверяем, что в теле паттерна на самом деле экспортированы все координаты и именованные узлы, которые объявлены
// в секции export. В случае неуспеха проверки возвращается false.
bool SynPatternCompilation::PatternHasBeenCompiled( SynGram &sg ) const
{
 bool ok=true;

 for( lem::Container::size_type i=0; i<export_coords.size(); ++i )
  if( actually_exported_coords.find( export_coords[i] )==UNKNOWN && null_export_coords.find(export_coords[i])==UNKNOWN )
   {
    sg.GetIO().merr().printf( "Coordinate [%us] is declared as exportable but was not actually exported\n"
     , sg.coords()[export_coords[i]].GetName().string().c_str() );
    ok=false;
   }

 for( lem::Container::size_type i=0; i<export_nodes.size(); ++i )
  {
   lem::UCString uname = lem::to_upper(export_nodes[i]);

   if( actually_exported_nodes.find( uname )==UNKNOWN && null_export_nodes.find(uname)==UNKNOWN )
    {
     sg.GetIO().merr().printf( "Node [%us] is declared as exportable but was not actually exported\n", export_nodes[i].c_str() );
     ok=false;
    }
  }

 return ok;
}

void SG_NetLink::SaveTagsTxt( OFormatter &txtfile, SynGram &gram ) const
{
 if( tags!=0 )
  {
   txtfile.printf( " tags { " );

   SG_TagsList tags_ptr = gram.Get_Net().tag_sets->operator [](tags);

   for( lem::Container::size_type i=0; i<tags_ptr->size(); ++i )
    {
     const int itag = (*tags_ptr)[i].first;
     const int ival = (*tags_ptr)[i].second;

     const ThesaurusTag &tag = gram.Get_Net().GetTagDefs()[itag];

     txtfile.printf( " \"%us\"", tag.GetName().c_str() );

     if( ival!=UNKNOWN )
      {
       const lem::UCString &val = tag[ival];
       txtfile.printf( "=\"%us\"", val.c_str() );        
      }

     txtfile.printf( " }" );     
    }
  }

 return;
}

void SG_CoordContext::SaveTxt( OFormatter &txt, SynGram &sg ) const
{
 const UCString &class_name = sg.classes()[iclass].GetName();

 txt.printf(
            " %us:\"???\" { "
            , class_name.c_str()
           );

 for( Container::size_type k=0; k<coords.size(); k++ )
  {
   const int icoord = coords[k].GetCoord().GetIndex();
   const int istate = coords[k].GetState();

   const UCString &coord_name = sg.coords()[ icoord ].GetName().front();

   if( !sg.coords()[icoord].states().size() )
    {
     if( istate!=0 )
      txt.printf( " %us", coord_name.c_str() );
     else
      txt.printf( " ~%us", coord_name.c_str() );
    }
   else
    {
     const UCString &state_name = sg.coords()[ icoord ].GetStateName( istate );
     txt.printf( " %us:%us", coord_name.c_str(), state_name.c_str() );
    }
  }

 txt.printf( " }" );

 return;
}

void SG_EntryForm::Reattach_To_Refs( SynGram &sg )
{
 // Название формы.
 content = sg.GetEntries().ReattachLexeme(content);

 // Координаты
 dim = sg.GetEntries().ReattachCoordPairs(dim);

 return;
}

void Tree_Node::PrintXML(OFormatter &xml, SynGram &gram) const
{
    xml.printf("<node>");

    xml.printf("<wordform>");
    if (!node.IsNull())
        node->PrintXML(xml, gram);
    xml.printf("</wordform>");

    if (!child.Empty())
    {
        xml.printf("<leaves count=\"%d\">", CastSizeToInt(child.size()));
        for (Container::size_type i = 0; i < child.size(); i++)
        {
            int link_type_id = child[i].GetLink().GetState();
            lem::UCString link_name = link_type_id == UNKNOWN ? L"" : gram.GetLink(link_type_id);
            xml.printf("<leaf n=\"%d\" arc_type=\"%d\" arc_name=\"%us\">\n", CastSizeToInt(i), link_type_id, link_name.c_str());
            child[i].PrintXML(xml, gram);
            xml.printf("</leaf>\n");
        }
        xml.printf("</leaves>");
    }

    if (!dims.empty())
    {
        xml.printf("<dims count=\"%d\">", CastSizeToInt(dims.size()));
        for (lem::Container::size_type i = 0; i < dims.size(); ++i)
        {
            const TreeDimension &d = *dims[i];
            xml.printf("<dim n=\"%d\" name=\"%us\">\n", CastSizeToInt(i), d.GetName().c_str());
            d.PrintXML(xml, gram.GetDict());
            xml.printf("</dim>\n");
        }
        xml.printf("</dims>");
    }

    if (!marks.empty())
    {
        xml.printf("<marks count=\"%d\">", CastSizeToInt(marks.size()));
        for (lem::Container::size_type i = 0; i < marks.size(); ++i)
        {
            xml.printf("<mark n=\"%d\">\n", CastSizeToInt(i));
            marks[i]->PrintXML(xml, gram.GetDict());
            xml.printf("</mark>\n");
        }
        xml.printf("</marks>");
    }

    xml.printf("</node>");

    return;
}

void Solarix::PrintTags( SG_TagsList tags, lem::UFString &str, SynGram &sg )
{
 str.clear();

 if( tags!=NULL )
  {
   for( lem::Container::size_type i=0; i<tags->size(); ++i )
    {
     const int itag = (*tags)[i].first;
     const int ival = (*tags)[i].second;

     const ThesaurusTag &tag = sg.Get_Net().GetTagDefs()[itag];

     if( !str.empty() ) str += L' ';
     str += tag.GetName().c_str();

     if( ival!=UNKNOWN )
      {
       const lem::UCString &val = tag[ival];
       str += L'=';
       str += val.c_str();
      }
    }
  }

 return;
}

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)
          )
{}

void SG_NetLink::PrintTagsTxt( lem::UFString &res, SynGram &gram ) const
{
 if( tags!=0 )
  {
   SG_TagsList tags_ptr = (*gram.Get_Net().tag_sets)[tags];
   PrintTags( tags_ptr, res, gram );
  }

 return;
}

void Tree_Link::SaveTxt(OFormatter &txtfile, const SynGram &gram) const
{
    if (icoord == UNKNOWN || icoord == UNKNOWN_STATE || icoord == ANY_STATE)
        return;

    txtfile << sol_get_token(B_OTRIPAREN);

    switch (icoord)
    {
    case ANY_STATE:
        txtfile << sol_get_token(B_ANY);
        break;

    case I_NET:
        txtfile << gram.coords()[icoord].GetStateName(istate);
        break;

    default:
    {
        txtfile << gram.coords()[icoord].GetName().front() << sol_get_token(B_COLON);

        switch (istate)
        {
        case ANY_STATE:     txtfile << sol_get_token(B_ANY);     break;
        case UNKNOWN_STATE: txtfile << sol_get_token(B_UNKNOWN); break;
        default:
            txtfile << gram.coords()[icoord].GetStateName(istate);
            break;
        }

        break;
    }
    }

    txtfile << sol_get_token(B_CTRIPAREN);
    return;
}

void LA_WordProjBuffer::PrintMap(
                                 OFormatter &txtfile,
                                 SynGram &gram
                                ) const
{
 Report(txtfile,gram.GetDict().GetLexAuto());

 txtfile.printf(
                "There are %d item(s) in word projection cache:\n",
                list.size()
               );

 for( Container::size_type i=0; i<list.size(); i++ )
  {
   list[i].PrintInfo(txtfile,gram);
  }

 txtfile.printf( "The end of word projection cache map.\n" );

 return;
}

void SynPatternResult::PrintLinks(lem::OFormatter &out, SynGram &sg) const
{
    lem::mout->printf("\nThere are %d edges:\n", CastSizeToInt(linkage_edges.size()));
    for (lem::Container::size_type k = 0; k < linkage_edges.size(); ++k)
    {
        const PatternLinkEdge & edge = linkage_edges[k];

        Solarix::Word_Form wf0(*edge.from, false);
        Solarix::Word_Form wf1(*edge.to, false);

        lem::UCString link_name;
        if (edge.link_type == UNKNOWN)
            link_name = L"((unknown))";
        else
            link_name = sg.coords()[0].GetStateName(edge.link_type);

        wf0.Print(out, &sg, true);
        out.printf(" --(%us)--> ", link_name.c_str());
        wf1.Print(out, &sg, true);
        out.eol();
    }

    return;
}

// ***************************************************************
// Лексическое содержимое словоформы приводим в соответствие с
// координатами.
// ***************************************************************
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;
}

/*************************************************************************

 Загрузка дескриптора ребра из текстового файла. Распознаются форматы:

 1. <имя_коорд:имя_связки>

   Расширенный формат, явно задано имя координаты имя_коорд, одно из
   состояний которой имя_связки признается за имя связки. Угловые скобки
   обязательны. Частные случаи этого формата:

 1.1 <имя_коорд:*>

   То есть имя связки (состояния координаты имя_коорд) задается квантором
   производьности, и в дальнейших проверках игнорируется.

 1.2 <имя_коорд:?>

   Имя связки задано как квантор UNKNOWN.

 2. <имя_связки>

   Сокращенный формат, имя связки должно быть объявлено как имя
   состояния координаты с предопределенным именем net.

 3. <*>

   Связка задана как квантор всеобщности, так что в операциях сравнения
   она будет подходить для любой другой связки.

 4. <?>

   Особое задание связки - через квантор UNKNOWN.

***************************************************************************/
bool Tree_Link::LoadTxt(Macro_Parser &txtfile, const SynGram &gram)
{
    const BSourceState back = txtfile.tellp();
    BethToken coord_name = txtfile.read();
    if (coord_name.GetToken() == B_OTRIPAREN)
    {
        coord_name = txtfile.read();

        switch (coord_name.GetToken())
        {
        case ANY_STATE:     icoord = ANY_STATE;     break;
        case UNKNOWN_STATE: icoord = UNKNOWN_STATE; break;

        default:
        {
            const BethToken t = txtfile.read();

            if (t.GetToken() == B_COLON)
            {
                // Полный, расширенный формат с указанием имени координаты.
                if ((icoord = gram.FindCoord(coord_name.string()).GetIndex()) == UNKNOWN)
                {
                    lem::Iridium::Print_Error(coord_name, txtfile);

                    gram.GetIO().merr().printf(
                        "The coordinate [%us] is not previously declared in grammar\n"
                        , coord_name.c_str()
                    );
                    throw E_ParserError();
                }
            }
            else
            {
                icoord = I_NET;
                txtfile.seekp(coord_name);
            }

            const BethToken state_name = txtfile.read();
            switch (state_name.GetToken())
            {
            case B_ANY:     istate = ANY_STATE;     break;
            case B_UNKNOWN: istate = UNKNOWN_STATE; break;
            default:
                if ((istate = gram.coords()[icoord].FindState(state_name.string())) == UNKNOWN)
                {
                    lem::Iridium::Print_Error(state_name, txtfile);
                    gram.GetIO().merr().printf(
                        "State [%us] is not declared for coordinate [%us]\n"
                        , state_name.c_str(), gram.coords()[icoord].GetName().string().c_str()
                    );

                    throw E_ParserError();
                }
                break;
            }

            break;
        }
        }

        txtfile.read_it(B_CTRIPAREN);
        return true;
    }
    else
    {
        txtfile.seekp(back);
//.........这里部分代码省略.........

void SynPattern::CheckBeforeMerge( const SynPattern &x, SynGram &sg ) const
{
 try
  {
   compilation_context->CheckThatVariablesTheSame( * x.compilation_context );
  }
 catch( const E_BaseException &e )
  {
   lem::MemFormatter mem;

   mem.printf( "Error %us\n", e.what() );
   mem.printf( "Two contexts have different variables set:\nFirst: " );
   this->Print( mem, sg );
   mem.printf( "\nSecond: " );
   x.Print( mem, sg );
   throw lem::E_BaseException( mem.string() );
  }

 // проверим, что экспортируютс¤ одни и те же координаты
 lem::MCollect<int> mismatched_coords;
 for( lem::Container::size_type i=0; i<export_info.export_coords.size(); ++i )
  if( x.export_info.export_coords.find( export_info.export_coords[i] )==UNKNOWN )
   mismatched_coords.push_back( export_info.export_coords[i] );

 for( lem::Container::size_type i=0; i<x.export_info.export_coords.size(); ++i )
  if( export_info.export_coords.find( x.export_info.export_coords[i] )==UNKNOWN )
   mismatched_coords.push_back( x.export_info.export_coords[i] );

 if( !mismatched_coords.empty() )
  {
   lem::MemFormatter mem;

   mem.printf( "Mismatching coordinates in pattern %us:", name.c_str() );

   for( lem::Container::size_type i=0; i<mismatched_coords.size(); ++i )
    {
     const lem::UCString &cname = sg.coords()[ mismatched_coords[i] ].GetName()[0];
     mem.printf( " %us", cname.c_str() );
    }

   throw lem::E_BaseException( mem.string() );
  }

 lem::MCollect<lem::UCString> mismatched_nodes;
 for( lem::Container::size_type i=0; i<export_info.export_nodes.size(); ++i )
  if( x.export_info.export_nodes.find( export_info.export_nodes[i] )==UNKNOWN )
   mismatched_nodes.push_back( export_info.export_nodes[i] );

 for( lem::Container::size_type i=0; i<x.export_info.export_nodes.size(); ++i )
  if( export_info.export_nodes.find( x.export_info.export_nodes[i] )==UNKNOWN )
   mismatched_nodes.push_back( x.export_info.export_nodes[i] );


 if( !mismatched_nodes.empty() )
  {
   lem::MemFormatter mem;

   mem.printf( "Mismatching nodes in pattern %us:", name.c_str() );

   for( lem::Container::size_type i=0; i<mismatched_nodes.size(); ++i )
    {
     mem.printf( " %us", mismatched_nodes[i].c_str() );
    }

   throw lem::E_BaseException( mem.string() );
  }

 return;
}

void Word_Form::LoadPreciser(
                             CompilationContext &context,
                             Macro_Parser& txtfile,
                             SynGram& gram,
                             int iclass
                            )
{
 // Тапереча в {} могет быть идти список уточняющих координат.
 //
 // Каждая уточняющая координата должна следовать такому формату:
 //
 //  [~]имя_координаты:имя_состояния
 //
 // Причем, только если вместо имени статьи указан квантор всеобщности,
 // то разрешается задавать АТРИБУТЫ как координаты.
 //
 // Особо обрабатываются координаты с неявно объявленными состояниями
 // TRUE/FALSE. Следует учесть, что само упоминание имени такой координаты
 // равносильно упоминанию также и имени состояния TRUE, а для объявлени
 // состояния FALSE необходимо использовать конструкцию с оператором
 // отрицания НЕ.

 while(!txtfile.eof())
  {
   // Считываем имя координаты.
   BethToken coord_name = txtfile.read();

   // Может, список закончился, то есть встретилась '{' ?
   if( coord_name.GetToken()==B_CFIGPAREN )
    break;


   // В двойных апострофах может идти имя формы, которую надо использовать вместо
   // имени словарной статьи.
   if( lem::in_quotes(coord_name.string()) )
    {
     Lexem *mname = new Lexem( strip_quotes(coord_name) );

     gram.GetDict().GetLexAuto().TranslateLexem(*mname,false);
     mname->Translate( gram.GetDict().GetGraphGram(), 2 );
     name = RC_Lexem( mname );
    }
   else 
    {
     bool AFFIRM=true;

     if( coord_name.GetToken()==B_NEGATIVE )
      {
       // Оператор отрицания перед определением координаты!
       AFFIRM=false;
       coord_name = txtfile.read();
      }

     const GramCoordAdr iglob_coord = gram.FindCoord(coord_name.string());

     // Попытаемся найти координату среди списка атрибутов и тэгов.
     int iloc_coord = gram.classes()[iclass].attrs().find(iglob_coord);
   
     // Нашли?
     if( iloc_coord!=UNKNOWN )
      {
       // Да! Примем к сведению, что если для опорной точки задано
       // имя словарной статьи, то мы не имеем право по логике вещей
       // определять также и атрибуты, так как само определение словарной
       // статьи определяет необходимые атрибуты.
       if( entry_key!=ANY_STATE )
        {
         lem::Iridium::Print_Error(coord_name,txtfile);
         gram.GetIO().merr().printf(
                "The attribute can not be declared here, because entry is already declared\n"
                                   );
         throw E_ParserError();
        }
      }
     else
      {
       // Попробуем найти координату среди списка измерений.
       iloc_coord = gram.classes()[iclass].dims().find(iglob_coord);

       if( iloc_coord==UNKNOWN )
        iloc_coord = gram.classes()[iclass].tags().find(iglob_coord);

       // Нашли?
       if( iloc_coord==UNKNOWN && iclass!=SOL_EQUIL_INDEX )
        {
         // Нет. Таким образом, имя координаты не определяет
         // ни тэг, ни измерение. Генерируем сообщение
         // об ошибке.

         lem::Iridium::Print_Error(coord_name,txtfile);
         gram.GetIO().merr()
          .printf(
                  "Coordinate [%us] is neither tag"
                  " nor dimention for the class [%us]\n"
                  , coord_name.string().c_str()
                  , gram.classes()[ iclass ].GetName().c_str()
                 );

         throw E_ParserError();
        }
//.........这里部分代码省略.........