The vbs tools - vbs_ls, vbs_rm, vbs_fs - for listing, removing and mounting vbs and Mark6 format scattered VLBI recordings on FlexBuff and Mark6 systems
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 

119 lines
3.3 KiB

// Implementation of the RegularExpression class
#include <regular_expression.h>
#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <cstring>
using std::cerr;
using std::endl;
using std::flush;
using std::string;
DEFINE_EZEXCEPT(Regular_Expression_Exception)
// support classes
pcintregmatch_t::pcintregmatch_t() {
this->::regmatch_t::rm_so = -1;
this->::regmatch_t::rm_eo = -1;
}
pcintregmatch_t::pcintregmatch_t( const ::regmatch_t& rm ) {
this->::regmatch_t::rm_so = rm.rm_so;
this->::regmatch_t::rm_eo = rm.rm_eo;
}
pcintregmatch_t::operator bool() const {
return (rm_so!=-1 && rm_eo!=-1);
}
matchresult::matchresult()
{}
matchresult::matchresult( size_t nSubExpr, std::string const& os ):
__matches( nSubExpr ), __org_string( os )
{}
matchresult::matchresult( const matchresult::matchvec_t& mv, const std::string& os ):
__matches( mv ), __org_string( os )
{}
matchresult::operator bool() const {
return (__matches.size()!=0);
}
matchresult::matchvec_t::value_type matchresult::operator[]( unsigned int m ) const {
if( m>=__matches.size() ) {
THROW_EZEXCEPT(Regular_Expression_Exception,
"requesting group " << m << ", but only " << __matches.size() << " groups matched");
}
return __matches[m];
}
std::string matchresult::operator[]( const matchvec_t::value_type& m ) const {
if( !m ) {
THROW_EZEXCEPT(Regular_Expression_Exception,
"requesting string from invalid group");
}
return __org_string.substr(m.rm_so, (m.rm_eo-m.rm_so));
}
std::string matchresult::group( unsigned int m ) const {
return (*this)[(*this)[m]];
}
bool operator==( const char* tocheck, const Regular_Expression& against ) {
return against.matches( tocheck );
}
bool operator!=( const char* tocheck, const Regular_Expression& against ) {
return !(against.matches( tocheck ));
}
bool operator==( const string& s, const Regular_Expression& against ) {
return against.matches( s.c_str() );
}
bool operator!=( const string& s, const Regular_Expression& against ) {
return !(against.matches(s.c_str()));
}
Regular_Expression::Regular_Expression( const string& pattern_text, int flags ) :
myOriginalPattern( pattern_text )
{
// Compile the pattern....
int r;
char errbuf[ 512 ];
if( (r=::regcomp(&myCompiledExpression,
myOriginalPattern.c_str(),
flags))!=0 ) {
::regerror(r, &myCompiledExpression, errbuf, sizeof(errbuf));
THROW_EZEXCEPT(Regular_Expression_Exception,
"Failed to compile RegEx(" << myOriginalPattern << "): " << errbuf);
}
}
matchresult Regular_Expression::matches( const string& s ) const {
// After compiling the regexp, the re_nsub member informs how many
// sub expressions/match groups there were. Together with the zeroth
// group (the whole) match, we know how many there are in total
const size_t nSubExpr( 1 + myCompiledExpression.re_nsub );
matchresult mr( nSubExpr, s );
if( ::regexec(&myCompiledExpression, s.c_str(), nSubExpr, &mr.__matches[0], 0)==0 )
return mr;
return matchresult();
}
string Regular_Expression::pattern( void ) const {
return myOriginalPattern;
}
Regular_Expression::~Regular_Expression() {
::regfree( &myCompiledExpression );
}