C++ Macro_Parser::eof方法代码示例

void TrCompilationContext::LoadTxt( PM_Automat &pm, lem::Iridium::Macro_Parser & txtfile, int BrokerToken )
{
 int nvar=0;
 while( !txtfile.eof() )
  {
   if( txtfile.pick().GetToken()==BrokerToken )
    break;

   if( nvar>0 )
    txtfile.read_it( B_COMMA );

   const lem::Iridium::BethToken &t = txtfile.read();
   if( IsVariable(t.string()) )
    {
     lem::Iridium::Print_Error( t, txtfile );
     lem::UFString msg( lem::format_str( L"Variable [%s] is already declared", t.c_str() ) );
     throw E_ParserError(msg.c_str());
    }

   RegisterVariable(t.string());
   nvar++;
  }

 txtfile.read_it( BrokerToken );
 return;
}

void PredicateTemplate::LoadTxt(Dictionary & dict, lem::Iridium::Macro_Parser & txtfile, const PredicateTemplateParams & param_list)
{
    int open_paren = 1; // инициализируем 1-цей, чтобы считать начало предиката вида xxx( ....

    while (!txtfile.eof())
    {
        lem::Iridium::BethToken t = txtfile.read();

        src += L' ';
        src += t.string().c_str();

        if (t == B_OROUNDPAREN)
            open_paren++;
        else if (t == B_CROUNDPAREN)
        {
            open_paren--;
            if (open_paren == 1)
                break;
        }
        else
        {
            if (param_list.IsParam(t.string()))
                params.push_back(t.string());
        }
    }

    return;
}

void LEMM_Compiler::LoadNGram( lem::Iridium::Macro_Parser & txtfile, Dictionary & dict, lem::MCollect<int> & terms, int order ) const
{
 lem::Iridium::BSourceState beg = txtfile.tellp();

 while( !txtfile.eof() )
 {
  lem::Iridium::BethToken t = txtfile.read();
  if( lem::is_int(t.string()) )
   terms.push_back( lem::to_int(t.string()) );
  else
   {
    txtfile.seekp(t);
    break;
   }
 }

 if( terms.size() != order+1 )
  {
   dict.GetIO().merr().printf( "%vfDInvalid ngram%vn\n" );
   lem::Iridium::Print_Error( beg, txtfile );
   throw lem::E_ParserError();
  }

 return;
}

void TreeScorerResult::LoadTxt( Dictionary & dict, lem::Iridium::Macro_Parser & txtfile, const TreeScorerMarkers & markers )
{
 // ќценка может быть отрицательной.
 if( txtfile.probe( B_SUB ) )
  {
   type=0;
   score = -txtfile.read_int();
  }
 else
  {
   if( lem::is_int( txtfile.pick().string() ) )
    {
     type=0;
     score = txtfile.read_int();
    }
   else
    {
     const lem::Iridium::BethToken & t = txtfile.read();
     id_fact = dict.GetLexAuto().GetKnowledgeBase().FindFacts( t.string() );
     if( id_fact==UNKNOWN )
      {
       // todo - тут могут быть другие варианты вызываемых вычислений.
       lem::Iridium::Print_Error(t,txtfile);
       dict.GetIO().merr().printf( "Unknown scoring expression starts with %us\n", t.string().c_str() );
       throw lem::E_BaseException();
      }

     txtfile.read_it( B_OROUNDPAREN );
     while( !txtfile.eof() )
     {
      if( txtfile.probe( B_CROUNDPAREN ) )
       break;

      if( !args.empty() )
       txtfile.read_it( B_COMMA );

      const lem::Iridium::BethToken & var = txtfile.read();
      lem::UCString upper_var = lem::to_upper(var.string());
      if( !markers.IsAlreadyBound(upper_var) )
       {
        lem::Iridium::Print_Error(var,txtfile);
        dict.GetIO().merr().printf( "variable %us not bound\n", var.string().c_str() );
        throw lem::E_BaseException();
       }

      args.push_back( upper_var );
     }

     type=1;
    }
  }

 return;
}

void TreeScorers::LoadGroup( Dictionary & dict, lem::Iridium::Macro_Parser &txtfile )
{
 lem::Iridium::BethToken t_name = txtfile.read();
 lem::UCString gname = t_name.string();
 gname.to_upper();
 if( name2id.find(gname)!=name2id.end() )
  {
   lem::Iridium::Print_Error( t_name, txtfile );
   dict.GetIO().merr().printf( "Tree scorer group [%us] is already declared\n", t_name.string().c_str() );
   throw lem::E_ParserError();
  }

 TreeScorerGroupParams params;

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

    lem::Iridium::BethToken tparam = txtfile.read();
    if( tparam.string().eqi(L"allow_unmatched_children") )
     {
      txtfile.read_it( B_EQUAL );

      lem::Iridium::BethToken tbool = txtfile.read();
      if( tbool.string().eqi(L"true") )
       params.allow_unmatched_children = true;
      else if( tbool.string().eqi(L"false") )
       params.allow_unmatched_children = false;
      else
       {
        lem::Iridium::Print_Error( tbool, txtfile );
        dict.GetIO().merr().printf( "[%us] is not boolean value\n", tbool.string().c_str() );
        throw lem::E_ParserError();
       }
     }
    else
     {
      lem::Iridium::Print_Error( tparam, txtfile );
      dict.GetIO().merr().printf( "Unknown tree scorer group parameter [%us]\n", tparam.string().c_str() );
      throw lem::E_ParserError();
     }
   }
  }

 const int id = storage->StoreTreeScorerGroup( gname, params );
 name2id.insert( std::make_pair(gname,id) );

 return;
}

void TrFun_Declare::CompileDeclaration(
    PM_Automat &pm,
    lem::Iridium::Macro_Parser &txtfile,
    TrFunctions &functions,
    const TrProcedureDeclaration &procs,
    TrKnownVars &known_vars,
    const TrBuiltInFunSignature *signature
)
{
    src_location = pm.GetDict().GetDebugSymbols().RegisterLocation( txtfile, txtfile.tellp() );
    var_type.LoadTxt(pm,txtfile,functions);

    while( !txtfile.eof() )
    {
        TrFunCall *expr = NULL;
        const lem::Iridium::BethToken &vname = txtfile.read();
        if( txtfile.pick().GetToken()==B_EQUAL )
        {
            txtfile.read();
            expr = functions.CompileCall( pm, txtfile, procs, known_vars );
        }

        if( var_name.find(vname.string())!=UNKNOWN )
        {
            lem::Iridium::Print_Error( vname, txtfile );
            pm.GetIO().merr().printf( "Variable [%us] is already declared", vname.c_str() );
            throw E_ParserError();
        }

        var_name.push_back(vname);
        var_value.push_back(expr);

        known_vars.RegisterVar( var_type, vname );

        if( txtfile.pick().GetToken()!=B_COMMA )
            break;

        txtfile.read_it(B_COMMA);
    }

    txtfile.read_it(B_SEMICOLON);

    return;
}

void ThesaurusTag::LoadTxt(
    lem::Iridium::Macro_Parser & txtfile,
    const lem::Sol_IO &sol_io,
    const Binarization_Options & options
)
{
    lem::Iridium::BethToken t = txtfile.read();
    name = t.string();
    name.strip(L'"');

    int ivalue = 0;
    if (txtfile.pick().GetToken() == B_EQUAL)
    {
        txtfile.read_it(B_EQUAL);
        txtfile.read_it(B_OFIGPAREN);

        while (!txtfile.eof())
        {
            lem::Iridium::BethToken v = txtfile.read();

            if (v.GetToken() == B_CFIGPAREN)
                break;

            UCString vs = v.string();
            vs.strip(L'"');

            if (operator[](vs) != UNKNOWN)
            {
                lem::Iridium::Print_Error(v, txtfile);
                sol_io.err->printf("Thesaurus tag [%us] value [%us] is already declared", name.c_str(), vs.c_str());
                throw E_ParserError();
            }

            values.push_back(vs);
            ivalues.push_back(ivalue++);
        }
    }

    return;
}

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

    lem::Iridium::BSourceState beg = txtfile.tellp();

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

        PatternConstraint * c = new PatternConstraint();
        c->LoadTxt(dict, txtfile, compilation_context);
        constraints.push_back(c);
    }

    return;
}

void TrFunction::CompileDeclaration(
                                    PM_Automat &pm,
                                    lem::Iridium::Macro_Parser &txtfile,
                                    TrFunctions &functions,
                                    const TrProcedureDeclaration &procs,
                                    const TrKnownVars *lambda_caller
                                   )
{
 const bool is_lambda = lambda_caller!=NULL;

 lem::Iridium::BSourceState fun_beg = txtfile.tellp();

 ret_type.LoadTxt( pm, txtfile, functions );

 lem::Iridium::BSourceState ss = txtfile.tellp();

 try
  {
   if( is_lambda )
    {
     // Формируем "невозможное" имя лямбда-функции, которое наверняка не будет
     // пересекаться с пользовательскими и встроенными функциями.
     static int lambda_number=0;
     name = L" $lambda";
     name += to_ustr(lambda_number++);
    }
   else
    {
     name = txtfile.read();
    }

   if( pm.GetDict().GetDebugLevel_ir()>=3 )
    {
     // Печатаем имя транслируемой статьи для контроля за процессом
     // парсинга Словаря.
     pm.GetDict().GetIO().mecho().printf( "function [%vfA%us%vn]->", name.c_str() );
    }

   if( !is_lambda && !CorrectName(name) )
    {
     lem::Iridium::Print_Error( ss, txtfile );
     pm.GetIO().merr().printf( "Invalid function name [%us]\n", name.c_str() );
     throw E_ParserError();
    }

   txtfile.read_it( B_OROUNDPAREN );

   TrKnownVars call_vars( lambda_caller==NULL ? &functions.global_known_vars : lambda_caller );

   // Список формальных аргументов
   while( !txtfile.eof() )
    {
     if( txtfile.pick().GetToken()==B_CROUNDPAREN )
      break;

     if( arg_name.size()>0 )
      txtfile.read_it(B_COMMA);

     TrType at;
     at.LoadTxt(pm,txtfile,functions);

     const lem::Iridium::BethToken &an = txtfile.read();

     if( arg_name.find(an)!=UNKNOWN )
      {
       lem::Iridium::Print_Error( an, txtfile );
       pm.GetIO().merr().printf( "Function [%us] call argument [%us] is already declared\n", name.c_str(), an.string().c_str() );
       throw E_ParserError();
      }
  
     arg_type.push_back(at);
     arg_name.push_back(an.string());

     call_vars.RegisterVar( at, an.string() );
    }

   txtfile.read_it( B_CROUNDPAREN );

   if( txtfile.pick().GetToken()==B_SEMICOLON )
    {
     txtfile.read();
     // Это форвардное объявление функции, без определения тела.
    }
   else
    {
     // Чтобы компилировать рекурсивные функции, мы сейчас добавим в список функций свое форвардное объявление.
     if( !is_lambda && !functions.IsFunction(name) )
      {
       TrFunction *forward = MakeForwardDeclaration();
       functions.AddForwardDeclaration(forward);
      }    

     // В фигурных скобочках - тело функции. Оно компилируется как вызов специальной функции-группы {}
     txtfile.read_it( B_OFIGPAREN );
     txtfile.backward();
     body = functions.CompileCall( pm, txtfile, procs, call_vars );
    }

   if( pm.GetDict().GetDebugLevel_ir()>=3 )
    pm.GetIO().mecho().printf( "%vfAOK%vn\n" );
//.........这里部分代码省略.........

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 LEMM_Compiler::LoadTxt( lem::Iridium::Macro_Parser & txtfile, Dictionary & dict )
{
 txtfile.read_it( B_OFIGPAREN );

 while( !txtfile.eof() )
 {
  lem::Iridium::BethToken t = txtfile.read();
  if( t.eqi( L"suffix" ) )
   {
    int id = txtfile.read_int();
    lem::UCString suffix = txtfile.read();
    if( suffix[0]==L'"' && suffix.back()==L'"' )
     suffix.strip_quotes();

    suffices.push_back( std::make_pair(id,suffix) );
   }
  else if( t.eqi( L"word" ) )
   {
    int id = txtfile.read_int();
    lem::UCString word = txtfile.read();
    if( word[0]==L'"' && word.back()==L'"' )
     word.strip_quotes();

    words.push_back( std::make_pair(id,word) );
   }
  else if( t.eqi(L"ngram2") )
   {
    lem::MCollect<int> terms;
    LoadNGram(txtfile,dict,terms,2);
    LEMM_Ngram2 n2;
    n2.tags.first = terms[0];
    n2.tags.second = terms[1];
    n2.freq = terms[2];
    ngram2.push_back(n2);
   }
  else if( t.eqi(L"ngram2_1") )
   {
    lem::MCollect<int> terms;
    LoadNGram(txtfile,dict,terms,2);
    LEMM_Ngram2 n2;
    n2.tags.first = terms[0];
    n2.tags.second = terms[1];
    n2.freq = terms[2];
    ngram2_1.push_back(n2);
   }
  else if( t.eqi(L"ngram3") )
   {
    lem::MCollect<int> terms;
    LoadNGram(txtfile,dict,terms,3);
    LEMM_Ngram3 n3;
    n3.tags.first = terms[0];
    n3.tags.second = terms[1];
    n3.tags.third = terms[2];
    n3.freq = terms[3];
    ngram3.push_back(n3);
   }
  else if( t.eqi(L"ngram3_1") )
   {
    lem::MCollect<int> terms;
    LoadNGram(txtfile,dict,terms,3);
    LEMM_Ngram3 n3;
    n3.tags.first = terms[0];
    n3.tags.second = terms[1];
    n3.tags.third = terms[2];
    n3.freq = terms[3];
    ngram3_1.push_back(n3);
   }
  else if( t.eqi(L"ngram3_2") )
   {
    lem::MCollect<int> terms;
    LoadNGram(txtfile,dict,terms,3);
    LEMM_Ngram3 n3;
    n3.tags.first = terms[0];
    n3.tags.second = terms[1];
    n3.tags.third = terms[2];
    n3.freq = terms[3];
    ngram3_2.push_back(n3);
   }
  else if( t.eqi(L"ngram4") )
   {
    lem::MCollect<int> terms;
    LoadNGram(txtfile,dict,terms,4);
    LEMM_Ngram4 n4;
    n4.tags.first = terms[0];
    n4.tags.second = terms[1];
    n4.tags.third = terms[2];
    n4.tags.fourth = terms[3];
    n4.freq = terms[4];
    ngram4.push_back(n4);
   }
  else if( t.eqi( L"suffix_len" ) )
   {
    suffix_len = txtfile.read_int();
   }

  else if( t.GetToken()==B_CFIGPAREN )
   break;
  else
   {
    dict.GetIO().merr().printf( "%vfDInvalid statement [%us]%vn\n", t.string().c_str() );
//.........这里部分代码省略.........

void TrFun_CreateWordform::CompileDeclaration(
                                              PM_Automat &pm,
                                              lem::Iridium::Macro_Parser &txtfile,
                                              TrFunctions &functions,
                                              const TrProcedureDeclaration &procs,
                                              TrKnownVars &known_vars,
                                              const TrBuiltInFunSignature *signature  
                                             )
{
 lem::Iridium::BSourceState ebeg = txtfile.tellp();

 SynGram &sg = pm.GetDict().GetSynGram();

 const lem::Iridium::BethToken &class_name = txtfile.read();
 const int iclass = sg.FindClass(class_name);

 txtfile.read_it( B_COLON );
 lem::Iridium::BSourceState ename = txtfile.tellp();

 UCString entry_name = sol_read_multyname( pm.GetIO(), txtfile, B_OFIGPAREN );
     
 const int v_ientry = sg.FindEntry( entry_name, iclass, false );
 if( v_ientry==UNKNOWN )
  {
   lem::Iridium::Print_Error( ename, txtfile );
   pm.GetIO().merr().printf( "Unknown entry [%vfE%us:%us%vn]\n", class_name.c_str(), entry_name.c_str() );
   throw E_ParserError();
  } 

 ientry = new TrFun_Constant( TrIntValue(sg.GetEntry(v_ientry).GetKey()) );

 while( !txtfile.eof() )
  {
   if( txtfile.pick().GetToken()==B_CFIGPAREN )
    {
     break;
    }

   // Координатная пара или имя формы слова в апострофах

   lem::Iridium::BethToken cn = txtfile.read();
   if( lem::in_quotes(cn.string()) )
    {
     form_name = strip_quotes(cn.string());
    }
   else
    {
     bool AFFIRM=true;

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

     // Для бистабильных - просто имя координаты.
     int icoord=UNKNOWN, istate=UNKNOWN;

     icoord = sg.FindCoord(cn).GetIndex();
     if( icoord==UNKNOWN )
      {
       lem::Iridium::Print_Error( cn, txtfile );
       pm.GetIO().merr().printf( "Unknown coordinate [%vfE%us%vn]\n", cn.c_str() );
       throw E_ParserError();
      }

     if( sg.coords()[icoord].IsBistable() )
      {
       istate=AFFIRM ? 1 : 0;
      }
     else
      {
       txtfile.read_it( B_COLON );
       const lem::Iridium::BethToken & sn = txtfile.read();
       istate = sg.coords()[icoord].FindState(sn);

       if( istate==UNKNOWN )
        {
         // Нет такого состояния для этого измерения.
         lem::Iridium::Print_Error(sn,txtfile);
          sg.GetIO().merr().printf(
                                    "State [%vfE%us%vn] is not declared for coordinate [%vfE%us%vn]\n"
                                    , sn.c_str(), cn.c_str()
                                   );
         throw E_ParserError();
        }
      }

     TrIntValue v2( icoord );
     coords.push_back( new TrFun_Constant(v2) );
  
     TrIntValue v3( istate );
     states.push_back( new TrFun_Constant(v3) );
    }
  }

 txtfile.read_it( B_CFIGPAREN );

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

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 KB_Facts::LoadTxt(Solarix::Dictionary &dict, lem::Iridium::Macro_Parser &txtfile)
{
    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);

    n_ret = 0;

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

        lem::Iridium::BethToken t = txtfile.read();
        if (t.string().eqi(L"arity"))
        {
            txtfile.read_it(B_EQUAL);
            n_arg = txtfile.read_int();
        }
        else if (t.string().eqi(L"return"))
        {
            txtfile.read_it(B_EQUAL);

            lem::Iridium::BethToken t_ret = txtfile.read();
            if (t_ret.eqi(L"boolean"))
            {
                n_ret = 1;
                ret_type = 0;
            }
            else if (t_ret.eqi(L"integer"))
            {
                n_ret = 1;
                ret_type = 1;
            }
            else
            {
                lem::Iridium::Print_Error(t_ret, txtfile);
                dict.GetIO().merr().printf("Unknown return type %us\n", t_ret.c_str());
                throw lem::E_BaseException();
            }
        }
        else if (t.string().eqi(L"violation_score"))
        {
            txtfile.read_it(B_EQUAL);

            if (txtfile.probe(B_SUB))
                violation_score = -txtfile.read_int();
            else
                violation_score = txtfile.read_int();
        }
        else if (t.string().eqi(L"violation_handler"))
        {
            txtfile.read_it(B_EQUAL);

            violation_handler = new PredicateTemplate();
            PredicateTemplateParams_KB params(n_arg);
            violation_handler->LoadTxt(dict, txtfile, params);
        }
        else if (t.string().eqi(L"generic"))
        {
            allow_generic = true;
        }
        else
        {
            lem::Iridium::Print_Error(t, txtfile);
            dict.GetIO().merr().printf("Unknown property %us\n", t.c_str());
            throw lem::E_BaseException();
        }
    }

    return;
}