Exemple #1
0
/****************************************************************************
  Возвращается строка, состоящая из символов строки-аргумента s, начина
  с первого (индекс 0) и длиной nch. Если длина исходной строки недостаточна,
  то результат будет содержать соответственно меньшее количество символов.
*****************************************************************************/
const UCString lem::left( const UCString &s, int NCH )
{
 LEM_CHECKIT_Z(NCH>=0);

 const int l=s.length();

 if( l==NCH )
  {
   return s;
  }
 else if( NCH<=0 )
  {
   return UCString();
  }
 else
  {
   UCString res;
   const int nch = NCH>l ? l : NCH;

   for( int i=0; i<nch; i++ )
    res.set_dir( i, s[i] );

   res.set_dir( nch, '\0' );
   res.calc_hash();
   return res;
  }
}
Exemple #2
0
void SG_EntryForm::SaveTxt(
                           OFormatter& txtfile,
                           Grammar &gram,
                           const SG_Entry &entry
                          ) const
{
 const GramClass &c = gram.classes()[ entry.GetClass() ];
 txtfile.printf( "  " );

 for( Container::size_type i=0; i<coords().size(); i++ )
  {
   const GramCoordPair cp = coords()[i];

   if( find( c.attrs(), cp.GetCoord() )!=UNKNOWN )
    continue;

   const GramCoord& c = gram.coords()[cp.GetCoord().GetIndex()];
   const UCString& dim_name = c.GetName()[cp.GetCoord().GetVar()];

   if( !c.states().empty() )
    {
     const UCString &state_name = c.GetStateName(cp.GetState());

     if( c.IsDefState(cp.GetState()) && c.IsHeadState(cp.GetState() ) )
      txtfile.printf(
                     "%us%us%us%us%us ",
                     dim_name.c_str(),
                     sol_get_token(B_COLON).c_str(),
                     sol_get_token(B_OROUNDPAREN).c_str(),
                     state_name.c_str(),
                     sol_get_token(B_CROUNDPAREN).c_str()
                    );
     else
      txtfile.printf(
                     "%us%us%us ",
                     dim_name.c_str(),
                     sol_get_token(B_COLON).c_str(),
                     state_name.c_str()
                    );
    }
   else
    {
     UCString prefix;

     if(!cp.GetState())
      prefix=sol_get_token(B_NEGATIVE);

     txtfile.printf( "%us%us ", prefix.c_str(), dim_name.c_str() );
    }
  }

 txtfile.printf(
                " %us %us %us\n",
                sol_get_token(B_OFIGPAREN).c_str(),
                content->c_str(),
                sol_get_token(B_CFIGPAREN).c_str()
               );
 return;
}
Exemple #3
0
const UCString lem::to_unicode( const lem::CString &src, const CodeConverter *cp )
{
 UCString res;
 lem_ascii_to_unicode( res.ptr(), src.c_str(), cp ? cp : &lem::UI::get_UI().GetSessionCp() );
 res.ptr()[src.length()] = 0;
 res.calc_hash();
 return res;
}
Exemple #4
0
bool SG_Stemmer::Stem( const UCString &org, UCString &stem ) const
{
 if( hStemmer==NULL || org.length()<3 )
  return false;

 stem = org;
 if( sol_Stem( hStemmer, (wchar_t*)stem.c_str() )==0 )
  {
   stem.calc_hash(); 
   return true;
  }

 return false;
}
Exemple #5
0
bool TrFunctions::IsType( const UCString &t ) const
{
 return t.eqi(L"const") ||
        t.eqi(L"bool") ||
        t.eqi(L"int") ||
        t.eqi(L"string") ||
        t.eqi(L"tree") ||
        t.eqi(L"trees") ||
        t.eqi(L"variant") ||
        t.eqi(L"fun") ||
        t.eqi(L"tuple");
}
void TrContextInvokation::AddVar( const UCString &name, lem::Ptr<TrValue> value )
{
 LEM_CHECKIT_Z(!name.empty());

 arg_name.push_back(name);
 arg_value.push_back( new TrValue(*value) );
 return;
}
Exemple #7
0
/****************************************************************
 Если каждому символу слова можно поставить в соответствие
 статью графической грамматики, то слово считаем корректной
 словоформой.
*****************************************************************/
bool LexicalAutomat::IsCorrectWord( const UCString& word ) const
{
 for( UCString::size_type i=0; i<word.length(); i++ )
  if( GG->FindSymbol(word[i]).GetEntry()==UNKNOWN )
   return false;

 return true;
}
lem::Ptr<TrValue> TrContextInvokation::GetVar( const UCString &name )
{
 LEM_CHECKIT_Z(!name.empty());

 for( lem::Container::size_type i=0; i<arg_name.size(); ++i )
  if( arg_name[i].eqi(name) )
   return lem::Ptr<TrValue>( arg_value[i], null_deleter() );

 return TrFunContext::GetVar(name);
}
Exemple #9
0
/*****************************************************************************
  Возвращается строка, состоящая из последних nch символов строки-аргумента s.
  Если длина исходной строки недостаточна, то результат будет содержать
  соответственно меньшее количество символов.
******************************************************************************/
const UCString lem::right( const UCString &s, int NCH )
{
 LEM_CHECKIT_Z(NCH>=0);
 UCString res;

 if( NCH<=0 )
  return res;

 const int l=s.length();
 const int nch = NCH>l ? l : NCH;

 int i0=l-nch;
 for( int i=0; i<nch; i++ )
  res.set_dir( i, s[i+i0] );

 res.set_dir( nch, '\0' );
 res.calc_hash();
 return res;
}
bool LA_PhoneticCondictor::Can_Subst( const UCString &lex ) const
{
 if( context.length() > lex.length() )
  return false;

 switch( loc )
 {
  case PREFIX:
   // Начало слова lex должно содержать condictor
   return !memcmp(
                  lex.c_str(),
                  context.c_str(),
                  context.length()*sizeof(*lex.c_str())
                 );

  case AFFIX:
   // Конец слова lex должен содержать condictor
   return !memcmp(
                  lex.c_str()+lex.length()-context.length(),
                  context.c_str(),
                  context.length()*sizeof(*lex.c_str())
                 );

  case UNLOCATED: LEM_STOPIT;
 }

 return false;
}
Exemple #11
0
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;
}
Exemple #12
0
// **************************************************************************
// Из строки, начиная с позиции i0, вырезается nch символов и возвращаются
// как строка. Если i0<0, то подразумевается i0=0. Если (i0+nch) больше,
// чем длина строки s, что в результатную строку будет занесено
// соответственно меньше символов.
// **************************************************************************
const UCString lem::mid( const UCString& s, int i0, int nch )
{
 LEM_CHECKIT_Z(nch>=0);

 if( nch<=0 || i0<0 || i0>=s.length() )
  return lem::UCString();

 wchar_t res[ LEM_CSTRING_LEN + 1 ];

 const int I0 = i0<0 ? 0 : i0;

 const int l=s.length();
 if( I0>=l )
  return UCString(res);

 const int NCH = nch>(l-I0) ? l-I0 : nch;

 lem_strncpy( res, s.c_str()+I0, NCH );

 res[NCH]=0;
 return UCString(res);
}
void TrCompilationContext::RegisterVariable( const UCString &name )
{
 lem::UCString uname( lem::to_upper(name) );

 if( vars.find(uname)!=UNKNOWN )
  {
   lem::UFString msg( lem::format_str( L"Variable [%s] is already declared", name.c_str() ) );
   throw E_ParserError(msg.c_str());
  }

 vars.push_back(uname);
 return;
}
Exemple #14
0
void SyntaxShell::SetLanguage( const UCString &lang_name )
{
 if( lang_name.eqi(L"autodetect") || lang_name.eqi(L"auto") )
  {
   // Язык нужно определять для каждой вводимой фразы.
   default_language = UNKNOWN;
   guess_language = true;
  }
 else
  {
   default_language = sol_id->GetSynGram().Find_Language(lang_name);

   // Проверим, что этот язык есть среди определенных в лексиконе
   lem::MCollect<int> langs;
   sol_id->GetLanguages(langs);
   if( langs.find(default_language)==UNKNOWN )
    {
     merr->printf( "\n%vfCError:%vn target language %vfE%us%vn is not available in lexicon", lang_name.c_str() );
     throw E_BaseException();
    }
  }

 return;
}
Exemple #15
0
void Word_Form::SaveTxtPreciser(
                                OFormatter &txtfile,
                                const SynGram *gram
                               ) const
{
 if( !gram )
  return;

 const int npair = GetnPair();
 for( int ipair=0; ipair<npair; ipair++ )
  {
   if(ipair) txtfile.uprintf(L' ');

   const GramCoordAdr icoord = GetPair(ipair).GetCoord();
   const int istate          = GetPair(ipair).GetState();
   const UCString dim_name     = gram->coords()[icoord.GetIndex()].GetName().front();

   if( gram->coords()[icoord.GetIndex()].states().empty() )
    {
     if( istate==ANY_STATE )
      txtfile.printf(
                     "%us%us%us"
                     , dim_name.c_str()
                     , sol_get_token(B_COLON).c_str()
                     , sol_get_token(B_ANY).c_str()
                    );
     else
      {
       // Бистабильные координаты выводим особым образом
       const UCString prefix = istate ?
                                        UCString("") :
                                        sol_get_token(B_NEGATIVE);
       txtfile.printf( "%us%us", prefix.c_str(), dim_name.c_str() );
      }
    }
   else
    {
     UCString state_name;

     if( istate!=ANY_STATE )
      state_name = gram->coords()[icoord.GetIndex()].GetStateName(istate);
     else
      state_name = sol_get_token(B_ANY);

     txtfile.printf(
                    "%us%us%us"
                    , dim_name.c_str()
                    , sol_get_token(B_COLON).c_str()
                    , state_name.c_str()
                   );
    }
  }

 return;
}
Exemple #16
0
int PM_Automat::GetSequenceValue( const UCString &name, int step ) const
{
 #if defined LEM_THREADS
 lem::Process::CritSecLocker locker(const_cast<lem::Process::CriticalSection*>(&cs_sequence));
 #endif

 std::map<UCString,int> &mutable_sequence = const_cast< std::map<UCString,int>& >(sequence);

 std::map<UCString,int>::iterator it = mutable_sequence.find( to_lower(name) );
 if( it!=sequence.end() )
  {
   return it->second += step;
  }
 else
  {
   throw E_BaseException( lem::format_str( L"Can not find sequence [%us]", name.c_str() ) );
  }
}
Exemple #17
0
bool SG_DeclensionForm::MatchCondition( const UCString &str, const UFString &entry_flexer_flags ) const
{
 #if !defined FAIND_NO_BOOST_REGEX
 if(
    (!valid_condition || condition.empty()) &&
    (!valid_flexer_flags || flexer_flags.empty())
   ) 
  return true;

 if( valid_condition && !boost::regex_match( str.c_str(), condition ) )
  return false;

 if( valid_flexer_flags && !boost::regex_search( entry_flexer_flags.c_str(), flexer_flags ) )
  return false;

 return true;
 #else
 return false;
 #endif
}
Exemple #18
0
bool lem::is_int( const UCString &s )
{ 
 return lem::is_int(s.c_str());
}
Exemple #19
0
bool TrFunction::CorrectName( const UCString &x )
{
 return lem::is_name(x.c_str());
}
void Resource_List::LoadTxt( WideStream &txt )
{
 // Формат ресурсов: NNN  LANG  string
 //
 // Допускаются директивы:
 // $include filename language                     

 int last_good_id=0;
 
 const lem::UCString INCLUDE(L"$include");

 const UFString cur_lang( lem::to_unicode( lem::UI::get_UI().GetCurrLang() ) );
 const UFString english(L"en");

 UCString nnn;
 std::string lang;
 UFString string;

 while( !txt.eof() )
  {
   txt.skip_white();

   nnn.clear();
   lang.clear();
   string.clear();

   // read the number identifier (primary key) of the string record.
   while( !txt.eof() )
    {
     const wchar_t u = txt.wget();
     if( u==WEOF )
      break;

     if( nnn.front()==L'#' ) 
      {
       // Commentary string - read until EOL.
       while( !txt.eof() )
        {
         const wchar_t u = txt.wget();
         if( u == L'\n' || u==L'\r' || u==WEOF )
          break;
        }

       break;
      }

     if( is_uspace(u) ) 
      {
       txt.unget(u);
       break; 
      }

     nnn += u;
    }
    
   if( nnn.empty() )
    continue;

   if( nnn == INCLUDE )
    {
     // Next fields are: 1) filename and 2) language
     UFString filename, language;
     filename.reserve(64);
     language.reserve(4);

     txt.skip_white();
     while( !txt.eof() )
      {
       const wchar_t u = txt.wget();
       if( u==WEOF )
        break;

       if( is_uspace(u) || u==L'\n' || u==L'\r' ) 
        {
         txt.unget(u);
         break; 
        }

       filename.Add_Dirty(u);
      }

     txt.skip_white();
     while( !txt.eof() )
      {
       const wchar_t u = txt.wget();
       if( u==WEOF )
        break;

       if( is_uspace(u) || u==L'\n' || u==L'\r' ) 
        {
         txt.unget(u);
         break; 
        }

       language.Add_Dirty(u);
      }

     language.calc_hash();
     filename.calc_hash();
     
     // Recursively load the file
     if( load_all_languages || language == cur_lang || language==english )
      {
       // Если задан файл без указания пути, то путь берем из исходного файла
       lem::Path inc(filename);  
       inc.RemoveLastLeaf();
       if( inc.empty() )
        {
         inc = txt.GetName();
         inc.RemoveLastLeaf();
         inc.ConcateLeaf(lem::Path(filename));
         LoadTxt( inc );
        } 
       else 
        {
         LoadTxt( lem::Path(filename) );
        } 
      }  

     continue;
    }

   int iname = 0;
   if( lem::to_int( nnn.c_str(), &iname )==false || iname<=0 )
    throw E_BaseException( lem::format_str( L"Incorrect format of string resource file: id is not a number [%ls]", nnn.c_str() ).c_str() );

   last_good_id = iname;

   // метка языка

   txt.skip_white();

   while( !txt.eof() )
    {
     wchar_t u = txt.wget();
     if( u==WEOF )
      break;

     if( is_uspace(u) ) 
      {
       txt.unget(u);
       break; 
      }

     lang += static_cast<char>(u);
    }
  
   // Ведем список языков, для которых есть локализация ресурсов.
   // ищем такой язык в справочнике
   int ilang = FindLang(lang,NULL);
   int il=0;
   for( std::vector<std::string>::const_iterator j=langs.begin(); j!=langs.end(); j++, il++ )
    if( *j == lang )
     {
      ilang = il;
      break;
     }

   if( ilang==UNKNOWN && !lang.empty() )
    {
     ilang = langs.size();
     langs.push_back( lang );
    }

   txt.skip_white();

   bool apostrophed=true;
   // теперь сама строка ресурсов 
   while( !txt.eof() )
    {
     wchar_t u = txt.wget();
     if( u==WEOF /*EOF fixed 17.09.2009 */ )
      break;

     if( u==L'\r' || u=='\n' ) 
      {
       break; 
      }

     if( u==L'"' && string.empty() )
      {
       // Начало строки в апострофах
       apostrophed = true;
       continue;
      }

     if( u==L'"' && !string.empty() )
      {
       // Конец строки в апострофах
       // Если далее идет символ +, то будет продолжение на следующей строке.
       wchar_t next = txt.wget();
       if( next==L'+' )
        {
         // Это продолжение.
         txt.skip_white();

         next = txt.wget();

         if( next==WEOF || next==0 )
          continue;

         LEM_CHECKIT_Z( next==L'"' );
         continue;
        }

       break;
      }

     if( u==L'\\' )
      {
       // спецсимволы
       wchar_t u2 = txt.wget();
       if( u2==WEOF )
        break;

       if( u2==L'\r' || u2=='\n' ) 
        break; 

       if( u2==L'r' || u2==L'n' )
        u = L'\n';
       else if( u2==L'"' )
        u = L'"';
       else
        u = u2;          
      }

     string.Add_Dirty(u);
    }

   string.calc_hash();

   if( !nnn.empty() && !string.empty() )
    {
     // Сохраняем ресурс. 
     // Ветка ресурса для этого nnn уже есть?
     string.trim();  
     string.strip_quotes();

     Resource *r = NULL;

     std::map<int,Resource*>::iterator it = iname_2_res.find(iname);
     if( it!=iname_2_res.end() )
      {
       r = it->second;
      }
     else
      { 
       r = new Resource;
       r->name = iname;
       list.push_back(r);  
       iname_2_res.insert( std::make_pair(iname,r) );
      }

     r->list.push_back( make_pair( ilang, string ) ); 
    }
  }

 return;
}