final commit to branch issue/270/tdelibs-V3. It includes the following files that were mistakenly omitted in that commit: tdecore/CMakeLists.txt tdecore/README.tdestringmatcher tdecore/tdeglobal.cpp tdecore/tdeglobal.h tdecore/tdestringmatcher.cpp tdecore/tdestringmatcher.h tdeio/tdeio/tdefileitem.cpp tdeio/tdeio/tdefileitem.h It also includes updates to the following files, some of which are based on recent feedback from @MicheleC: tdecore/tequivchars-mapping.h tdecore/tequivchars.cpp tdecore/tequivchars.h Signed-off-by: Vincent Reher <tde@4reher.org>issue/270/tdelibs-V4
Vincent Reher
1 year ago
parent
4c0dae60b2
commit
a39403fb8b
@ -0,0 +1,649 @@
|
||||
#include "tdestringmatcher.h"
|
||||
#include "tequivchars.h"
|
||||
|
||||
#include <tdeglobal.h>
|
||||
#include <tqregexp.h>
|
||||
#include <kdebug.h>
|
||||
|
||||
#include <features.h>
|
||||
#ifdef __GLIBC__
|
||||
#include <fnmatch.h>
|
||||
#pragma message "TSM using GLIBC fnmatch() for wildcard matching"
|
||||
#endif
|
||||
|
||||
//================================================================================================
|
||||
|
||||
namespace TSM {
|
||||
|
||||
class AuxData
|
||||
{
|
||||
public:
|
||||
AuxData();
|
||||
TQString patternConverted; // Pattern converted from original (e.g ANCHandling::EQUIVALENCE)
|
||||
TQRegExp* matchEngine; // Used when PatternType::REGEX
|
||||
#ifdef __GLIBC__
|
||||
int fnmatchFlags; // Used by fnmatch() when PatternType::WILDCARD
|
||||
#endif
|
||||
bool isCaseSensitive; // PatternType::SUBSTRING
|
||||
};
|
||||
|
||||
AuxData::AuxData()
|
||||
{
|
||||
isCaseSensitive = true;
|
||||
#ifdef __GLIBC__
|
||||
fnmatchFlags = FNM_EXTMATCH; // Bash shell option 'extglob'
|
||||
#endif
|
||||
matchEngine = nullptr;
|
||||
patternConverted = "";
|
||||
}
|
||||
|
||||
} // End of namespace TSM
|
||||
|
||||
//================================================================================================
|
||||
|
||||
using namespace TSM;
|
||||
|
||||
typedef TQValueVector<AuxData> AuxDataList;
|
||||
|
||||
class TDEStringMatcher::TDEStringMatcherPrivate {
|
||||
public:
|
||||
|
||||
// Properties that may be set / accessed through the TSM interface
|
||||
TQString m_matchSpecString;
|
||||
MatchSpecList m_matchSpecList;
|
||||
|
||||
// Properties that are internal implementation only
|
||||
AuxDataList m_auxData;
|
||||
void clearAll();
|
||||
};
|
||||
|
||||
void TDEStringMatcher::TDEStringMatcherPrivate::clearAll()
|
||||
{
|
||||
m_matchSpecString = "";
|
||||
m_matchSpecList.clear();
|
||||
for ( size_t index = 0 ; index < m_auxData.count() ; index++ ) {
|
||||
if ( m_auxData[index].matchEngine != nullptr ) {
|
||||
TSMTRACE << "Freeing match engine " << m_auxData[index].matchEngine << endl;
|
||||
delete m_auxData[index].matchEngine;
|
||||
}
|
||||
}
|
||||
m_auxData.clear();
|
||||
}
|
||||
|
||||
//================================================================================================
|
||||
|
||||
TDEStringMatcher::TDEStringMatcher()
|
||||
{
|
||||
TSMTRACE << "TSM::TDEStringMatcher(): New instance created: " << this << endl;
|
||||
d = new TDEStringMatcherPrivate;
|
||||
}
|
||||
|
||||
TDEStringMatcher::~TDEStringMatcher()
|
||||
{
|
||||
d->clearAll();
|
||||
delete d;
|
||||
TSMTRACE << "TSM::~TDEStringMatcher(): Instance destroyed: " << this << endl;
|
||||
}
|
||||
|
||||
|
||||
//================================================================================================
|
||||
// Match specification output functions
|
||||
//================================================================================================
|
||||
|
||||
const TQString TDEStringMatcher::getMatchSpecString() const
|
||||
{
|
||||
return d->m_matchSpecString;
|
||||
}
|
||||
|
||||
const MatchSpecList TDEStringMatcher::getMatchSpecs() const
|
||||
{
|
||||
return d->m_matchSpecList;
|
||||
}
|
||||
|
||||
|
||||
//================================================================================================
|
||||
// Match specification input functions
|
||||
//================================================================================================
|
||||
|
||||
bool TDEStringMatcher::setMatchSpecs( MatchSpecList newMatchSpecList )
|
||||
{
|
||||
TDEStringMatcherPrivate workArea;
|
||||
|
||||
TQStringList newMatchSpecs;
|
||||
|
||||
TSMTRACE << "TSM::setPatterns(): validating match specification list" << endl;
|
||||
|
||||
for ( MatchSpec matchSpec : newMatchSpecList ) {
|
||||
|
||||
if ( matchSpec.pattern.isEmpty() ) {
|
||||
TSMTRACE << " Error: empty pattern!" << endl;
|
||||
workArea.clearAll();
|
||||
return false;
|
||||
}
|
||||
if ( matchSpec.pattern.find( TQChar(PatterStringDivider) ) >= 0 ) {
|
||||
TSMTRACE << " Error: pattern contains reserved separator character" << endl;
|
||||
workArea.clearAll();
|
||||
return false;
|
||||
}
|
||||
|
||||
AuxData auxWork;
|
||||
TQString inferredOptionString;
|
||||
|
||||
// Validate / process PatternType
|
||||
|
||||
auxWork.patternConverted = matchSpec.pattern;
|
||||
switch ( matchSpec.patternType ) {
|
||||
case PatternType::WILDCARD :
|
||||
inferredOptionString += TQChar('w');
|
||||
#ifndef __GLIBC__
|
||||
auxWork.patternConverted = wildcardToRegex( auxWork.patternConverted );
|
||||
TSMTRACE << " Converted wildcard expression '" << matchSpec.pattern << "' to regex '" << auxWork.patternConverted << "'" << endl;
|
||||
#endif
|
||||
break;
|
||||
case PatternType::REGEX :
|
||||
inferredOptionString += TQChar('r');
|
||||
break;
|
||||
case PatternType::SUBSTRING :
|
||||
inferredOptionString += TQChar('s');
|
||||
break;
|
||||
default:
|
||||
TSMTRACE << " Error: pattern type out of range" << endl;
|
||||
workArea.clearAll();
|
||||
return false;
|
||||
}
|
||||
|
||||
// Validate / process ANCHandling
|
||||
|
||||
TQString before = auxWork.patternConverted;
|
||||
switch ( matchSpec.ancHandling ) {
|
||||
case ANCHandling::CASE_SENSITIVE :
|
||||
inferredOptionString += TQChar('c');
|
||||
auxWork.isCaseSensitive = true;
|
||||
break;
|
||||
case ANCHandling::CASE_INSENSITIVE :
|
||||
inferredOptionString += TQChar('i');
|
||||
auxWork.isCaseSensitive = false;
|
||||
#ifdef __GLIBC__
|
||||
auxWork.fnmatchFlags |= FNM_CASEFOLD;
|
||||
#endif
|
||||
break;
|
||||
case ANCHandling::EQUIVALENCE :
|
||||
inferredOptionString += TQChar('e');
|
||||
auxWork.isCaseSensitive = true;
|
||||
auxWork.patternConverted = TDEGlobal::equivChars()->replaceChars( auxWork.patternConverted, true );
|
||||
TSMTRACE << " Converted match pattern '" << before << "' to equivalent '" << auxWork.patternConverted << "'" << endl;
|
||||
break;
|
||||
default:
|
||||
TSMTRACE << " Error: alphabetic character handling specification out of range" << endl;
|
||||
workArea.clearAll();
|
||||
return false;
|
||||
}
|
||||
|
||||
if ( matchSpec.expectMatch )
|
||||
inferredOptionString += TQChar('=');
|
||||
else
|
||||
inferredOptionString += TQChar('!');
|
||||
|
||||
// Test validity of pattern
|
||||
|
||||
TQRegExp rxWork;
|
||||
int result;
|
||||
|
||||
switch ( matchSpec.patternType ) {
|
||||
case PatternType::WILDCARD :
|
||||
#ifdef __GLIBC__ // Test wildcard expression using a subject matter expert
|
||||
result = fnmatch(
|
||||
auxWork.patternConverted.local8Bit().data(),
|
||||
auxWork.patternConverted.local8Bit().data(),
|
||||
auxWork.fnmatchFlags
|
||||
); // Comparison should fail
|
||||
switch ( result ) {
|
||||
case 0: // matched
|
||||
case FNM_NOMATCH: // not matched
|
||||
break;
|
||||
default:
|
||||
TSMTRACE << " Error: invalid wildcard syntax" << endl;
|
||||
workArea.clearAll();
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
#endif // Otherwise we will test wildcard expression as one converted to a regex
|
||||
case PatternType::REGEX :
|
||||
// Prepare regex
|
||||
rxWork.setPattern( auxWork.patternConverted );
|
||||
rxWork.setCaseSensitive( auxWork.isCaseSensitive );
|
||||
// Test regex
|
||||
if ( rxWork.isValid() ) {
|
||||
auxWork.matchEngine = new TQRegExp;
|
||||
*auxWork.matchEngine = rxWork;
|
||||
TSMTRACE << "AuxData: Allocated regex engine for matching '" << auxWork.matchEngine->pattern() << "'" << endl;
|
||||
}
|
||||
else {
|
||||
TSMTRACE << " Error: invalid regex syntax'" << endl;
|
||||
workArea.clearAll();
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
// if (! rxWork.isReallyWhatUserIntended() ) { HA HA
|
||||
}
|
||||
|
||||
// This particular match specification is good
|
||||
|
||||
newMatchSpecs.append( inferredOptionString );
|
||||
newMatchSpecs.append( matchSpec.pattern );
|
||||
workArea.m_auxData.append( auxWork );
|
||||
}
|
||||
|
||||
// All proposed match specifications are good, update everything accordingly
|
||||
|
||||
workArea.m_matchSpecList = newMatchSpecList;
|
||||
workArea.m_matchSpecString = newMatchSpecs.join( TQChar(PatterStringDivider) );
|
||||
d->clearAll();
|
||||
*d = workArea;
|
||||
//-Debug: TSMTRACE << " Notifying slots of pattern change" << endl;
|
||||
emit patternsChanged();
|
||||
//-Debug: TSMTRACE << " All slots have been notified" << endl;
|
||||
TSMTRACE << "TSM::setPatterns(): Patterns were successfully regenerated from list" << endl << endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
//=================================================================================================
|
||||
|
||||
bool TDEStringMatcher::setMatchSpecs( TQString newMatchSpecString )
|
||||
{
|
||||
if ( newMatchSpecString == d->m_matchSpecString )
|
||||
return true;
|
||||
|
||||
TDEStringMatcherPrivate workArea;
|
||||
|
||||
MatchSpec matchSpec = {
|
||||
PatternType::DEFAULT,
|
||||
ANCHandling::DEFAULT,
|
||||
true, // seeking matches, not non-matches
|
||||
""
|
||||
};
|
||||
|
||||
TSMTRACE << "TSM::setPatterns: Proposed match specification string: <" << newMatchSpecString << ">" << endl;
|
||||
|
||||
if ( newMatchSpecString.isEmpty() ) {
|
||||
TSMTRACE << " Empty pattern string => match specifications will be cleared" << endl;
|
||||
d->m_matchSpecList.clear();
|
||||
d->m_matchSpecString = "";
|
||||
emit patternsChanged();
|
||||
return true;
|
||||
}
|
||||
|
||||
TQStringList newMatchSpecs = TQStringList::split( PatterStringDivider, newMatchSpecString, true );
|
||||
|
||||
if ( newMatchSpecs.count() % 2 != 0 ) {
|
||||
TSMTRACE << " Error: match specification string must contain an even number of components" << endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
bool processingOptionString = true; // expected format: option string , pattern string, ...
|
||||
|
||||
for ( TQString &specification : newMatchSpecs ) {
|
||||
|
||||
if ( processingOptionString ) {
|
||||
specification = specification.lower();
|
||||
TSMTRACE << " Processing match option string: '" << specification << "'" << endl;
|
||||
for ( int i = 0 ; i < specification.length() ; i++ ) {
|
||||
|
||||
TQChar optionChar = specification[i];
|
||||
//Debug: TSMTRACE << " Option character: '" << optionChar << "'" << endl;
|
||||
|
||||
switch ( optionChar ) {
|
||||
case 'r' : matchSpec.patternType = PatternType::REGEX ; break;
|
||||
case 'w' : matchSpec.patternType = PatternType::WILDCARD ; break;
|
||||
case 's' : matchSpec.patternType = PatternType::SUBSTRING ; break;
|
||||
case 'c' : matchSpec.ancHandling = ANCHandling::CASE_SENSITIVE ; break;
|
||||
case 'i' : matchSpec.ancHandling = ANCHandling::CASE_INSENSITIVE; break;
|
||||
case 'e' : matchSpec.ancHandling = ANCHandling::EQUIVALENCE ; break;
|
||||
case '=' : matchSpec.expectMatch = true ; break;
|
||||
case '!' : matchSpec.expectMatch = false ; break;
|
||||
default:
|
||||
// We reserve ALL other possible option characters for future use!
|
||||
TSMTRACE << " Error: invalid option character" << endl;
|
||||
workArea.clearAll();
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
processingOptionString = false; // next spec should be a pattern string
|
||||
} // processingOptionString
|
||||
|
||||
else { // ! processingOptionString
|
||||
|
||||
TSMTRACE << " Processing match pattern string: '" << specification << "'" << endl;
|
||||
|
||||
if ( specification.isEmpty() ) {
|
||||
TSMTRACE << " Error: empty pattern!" << endl;
|
||||
workArea.clearAll();
|
||||
return false;
|
||||
}
|
||||
|
||||
AuxData auxWork;
|
||||
|
||||
// Validate / process PatternType
|
||||
|
||||
auxWork.patternConverted = specification;
|
||||
switch ( matchSpec.patternType ) {
|
||||
case PatternType::WILDCARD :
|
||||
#ifndef __GLIBC__
|
||||
auxWork.patternConverted = wildcardToRegex( specification );
|
||||
TSMTRACE << " Converted wildcard expression '" << specification << "' to regex '" << auxWork.patternConverted << "'" << endl;
|
||||
break;
|
||||
#endif
|
||||
case PatternType::REGEX :
|
||||
case PatternType::SUBSTRING :
|
||||
break;
|
||||
default :
|
||||
// This should never arise since the content of this field was set within this function
|
||||
kdWarning() << "Error while processing '" << specification
|
||||
<< "' pattern type out of range: " << (uchar) matchSpec.patternType
|
||||
<< endl;
|
||||
workArea.clearAll();
|
||||
return false;
|
||||
}
|
||||
|
||||
// Validate / process ANCHandling
|
||||
|
||||
TQString before = auxWork.patternConverted;
|
||||
switch ( matchSpec.ancHandling ) {
|
||||
case ANCHandling::CASE_SENSITIVE :
|
||||
auxWork.isCaseSensitive = true;
|
||||
break;
|
||||
case ANCHandling::CASE_INSENSITIVE :
|
||||
auxWork.isCaseSensitive = false;
|
||||
#ifdef __GLIBC__
|
||||
auxWork.fnmatchFlags |= FNM_CASEFOLD;
|
||||
#endif
|
||||
break;
|
||||
case ANCHandling::EQUIVALENCE :
|
||||
auxWork.isCaseSensitive = true;
|
||||
auxWork.patternConverted = TDEGlobal::equivChars()->replaceChars( auxWork.patternConverted, true );
|
||||
TSMTRACE << " Converted match pattern '" << before << "' to equivalent '" << auxWork.patternConverted << "'" << endl;
|
||||
break;
|
||||
default: break;
|
||||
kdWarning() << "Error while processing '" << specification
|
||||
<< "' alphabetic character handling specification out of range: " << (uchar) matchSpec.ancHandling
|
||||
<< endl;
|
||||
workArea.clearAll();
|
||||
return false;
|
||||
}
|
||||
|
||||
// Test validity of pattern
|
||||
|
||||
TQRegExp rxWork; // single working copy == each pattern inherits previous options
|
||||
int result;
|
||||
|
||||
switch ( matchSpec.patternType ) {
|
||||
case PatternType::WILDCARD :
|
||||
#ifdef __GLIBC__ // Test wildcard expression using a subject matter expert
|
||||
result = fnmatch(
|
||||
auxWork.patternConverted.local8Bit().data(),
|
||||
auxWork.patternConverted.local8Bit().data(),
|
||||
auxWork.fnmatchFlags
|
||||
); // Comparison should fail
|
||||
switch ( result ) {
|
||||
case 0: // matched
|
||||
case FNM_NOMATCH: // not matched
|
||||
break;
|
||||
default:
|
||||
TSMTRACE << " Error: invalid wildcard syntax" << endl;
|
||||
workArea.clearAll();
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
#endif // Otherwise we will test wildcard expression as one converted to x regex
|
||||
case PatternType::REGEX :
|
||||
// Prepare regex
|
||||
rxWork.setPattern( auxWork.patternConverted );
|
||||
rxWork.setCaseSensitive( auxWork.isCaseSensitive );
|
||||
// Test regex
|
||||
if ( rxWork.isValid() ) {
|
||||
auxWork.matchEngine = new TQRegExp;
|
||||
*auxWork.matchEngine = rxWork;
|
||||
TSMTRACE << " AuxData: Allocated regex engine " << auxWork.matchEngine << "for pattern: " << auxWork.matchEngine->pattern() << endl;
|
||||
}
|
||||
else {
|
||||
TSMTRACE << " Error: invalid regex syntax" << endl;
|
||||
workArea.clearAll();
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
// if (! rxWork.isReallyWhatUserIntended() ) { HA HA
|
||||
}
|
||||
|
||||
matchSpec.pattern = specification;
|
||||
workArea.m_matchSpecList.push_back( matchSpec );
|
||||
workArea.m_auxData.append( auxWork );
|
||||
|
||||
processingOptionString = true; // next spec should be an option string
|
||||
} // ! processingOptionString completed
|
||||
}
|
||||
|
||||
workArea.m_matchSpecString = newMatchSpecString;
|
||||
d->clearAll();
|
||||
*d = workArea;
|
||||
TSMTRACE << " Final patternString: '" << d->m_matchSpecString << "'" << endl;
|
||||
TSMTRACE << " Number of match patterns in list: '" << d->m_matchSpecList.count() << "'" << endl;
|
||||
//-Debug: TSMTRACE << " Notifying slots of pattern change" << endl;
|
||||
emit patternsChanged();
|
||||
//-Debug: TSMTRACE << " All slots have been notified" << endl;
|
||||
TSMTRACE << "TSM::setPatterns(): Patterns were successfully regenerated from string" << endl << endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
//================================================================================================
|
||||
// Match functions
|
||||
//================================================================================================
|
||||
|
||||
bool TDEStringMatcher::matchAny( const TQString& stringToMatch ) const
|
||||
{
|
||||
/* DEBUG
|
||||
TSMTRACE << "TSM:matchAny(): Attempting to match string '" << stringToMatch << "' against stored patterns" << endl;
|
||||
if ( d->m_matchSpecList.isEmpty() ) {
|
||||
//-Debug: TSMTRACE << "Match failed on empty pattern list!" << endl;
|
||||
return false;
|
||||
}
|
||||
*/
|
||||
TQString equivalentString;
|
||||
|
||||
for ( size_t index = 0 ; index < d->m_matchSpecList.count() ; index++ )
|
||||
{
|
||||
TQString matchWhat = stringToMatch;
|
||||
TQString matchThis = d->m_auxData[index].patternConverted;
|
||||
|
||||
if ( d->m_matchSpecList[index].ancHandling == ANCHandling::EQUIVALENCE ) {
|
||||
if ( equivalentString.isEmpty() ) {
|
||||
equivalentString = TDEGlobal::equivChars()->replaceChars( stringToMatch, false ) ;
|
||||
}
|
||||
matchWhat = equivalentString;
|
||||
}
|
||||
|
||||
bool matchFound = false;
|
||||
switch ( d->m_matchSpecList[index].patternType ) {
|
||||
case PatternType::WILDCARD :
|
||||
#ifdef __GLIBC__
|
||||
matchFound = ( fnmatch(
|
||||
matchThis.local8Bit().data(),
|
||||
matchWhat.local8Bit().data(),
|
||||
d->m_auxData[index].fnmatchFlags
|
||||
) == 0 );
|
||||
break;
|
||||
#endif
|
||||
case PatternType::REGEX :
|
||||
matchFound = ( d->m_auxData[index].matchEngine->search( matchWhat ) >= 0 );
|
||||
break;
|
||||
case PatternType::SUBSTRING :
|
||||
matchFound = ( matchWhat.find( matchThis, 0, d->m_auxData[index].isCaseSensitive ) >= 0 );
|
||||
break;
|
||||
}
|
||||
|
||||
if ( matchFound == d->m_matchSpecList[index].expectMatch ) {
|
||||
TSMTRACE << " Success! match of pattern '" << matchThis << "' against '" << matchWhat << "' turned out as expected" << endl;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
TSMTRACE << " Match failed, there were no pattern matches against '" << stringToMatch << "' that turned out as expected" << endl;
|
||||
return false ;
|
||||
}
|
||||
|
||||
bool TDEStringMatcher::matchAll( const TQString& stringToMatch ) const
|
||||
{
|
||||
TSMTRACE << "TSM:matchAll(): Attempting to match string '" << stringToMatch << "' against stored patterns" << endl;
|
||||
if ( d->m_matchSpecList.isEmpty() ) {
|
||||
//-Debug: TSMTRACE << "Match failed on empty pattern list!" << endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
TQString equivalentString;
|
||||
|
||||
for ( size_t index = 0 ; index < d->m_matchSpecList.count() ; index++ )
|
||||
{
|
||||
TQString matchWhat = stringToMatch;
|
||||
TQString matchThis = d->m_auxData[index].patternConverted;
|
||||
|
||||
if ( d->m_matchSpecList[index].ancHandling == ANCHandling::EQUIVALENCE ) {
|
||||
if ( equivalentString.isEmpty() ) {
|
||||
equivalentString = TDEGlobal::equivChars()->replaceChars( stringToMatch, false ) ;
|
||||
}
|
||||
matchWhat = equivalentString;
|
||||
}
|
||||
|
||||
bool matchFound = false;
|
||||
switch ( d->m_matchSpecList[index].patternType ) {
|
||||
case PatternType::WILDCARD :
|
||||
#ifdef __GLIBC__
|
||||
matchFound = ( fnmatch(
|
||||
matchThis.local8Bit().data(),
|
||||
matchWhat.local8Bit().data(),
|
||||
d->m_auxData[index].fnmatchFlags
|
||||
) == 0 );
|
||||
break;
|
||||
#endif
|
||||
case PatternType::REGEX :
|
||||
matchFound = ( d->m_auxData[index].matchEngine->search( matchWhat ) >= 0 );
|
||||
break;
|
||||
case PatternType::SUBSTRING :
|
||||
matchFound = ( matchWhat.find( matchThis, 0, d->m_auxData[index].isCaseSensitive ) >= 0 );
|
||||
break;
|
||||
}
|
||||
|
||||
if ( matchFound != d->m_matchSpecList[index].expectMatch ) {
|
||||
TSMTRACE << " Match of pattern '" << matchThis << "' against '" << matchWhat << "' did not turn out as expected" << endl;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
TSMTRACE << " Expected pattern matching succeeded" << endl;
|
||||
return true;
|
||||
}
|
||||
|
||||
//================================================================================================
|
||||
// Utility functions
|
||||
//================================================================================================
|
||||
|
||||
/*
|
||||
The following code is a modified copy of that found in tqt3/src/tools/qregexp.cpp.
|
||||
We export this as utility function for applications that wish to convert a basic
|
||||
wildcard expression into a basic regular expression. TSM will not use this unless
|
||||
GLIBC fnmatch() is not available.
|
||||
*/
|
||||
TQString TDEStringMatcher::wildcardToRegex( const TQString& wildcardPattern )
|
||||
{
|
||||
int wclen = wildcardPattern.length();
|
||||
TQString rx = TQString::fromLatin1( "" );
|
||||
int i = 0;
|
||||
const TQChar *wc = wildcardPattern.unicode();
|
||||
while ( i < wclen ) {
|
||||
TQChar c = wc[i++];
|
||||
switch ( c.unicode() ) {
|
||||
case '*':
|
||||
rx += TQString::fromLatin1( ".*" );
|
||||
break;
|
||||
case '?':
|
||||
rx += TQChar( '.' );
|
||||
break;
|
||||
case '$':
|
||||
case '(':
|
||||
case ')':
|
||||
case '+':
|
||||
case '.':
|
||||
case '\\':
|
||||
case '^':
|
||||
case '{':
|
||||
case '|':
|
||||
case '}':
|
||||
rx += TQChar( '\\' );
|
||||
rx += c;
|
||||
break;
|
||||
case '[':
|
||||
rx += c;
|
||||
/* This is not correct, POSIX states that negation character is '!'
|
||||
if ( wc[i] == TQChar('^') )
|
||||
rx += wc[i++];
|
||||
*/
|
||||
if ( wc[i] == TQChar('!') ) {
|
||||
rx += TQChar('^');
|
||||
i++;
|
||||
} else if ( wc[i] == TQChar('^') ) {
|
||||
rx += TQChar( '\\' );
|
||||
rx += wc[i++];
|
||||
}
|
||||
if ( i < wclen ) {
|
||||
if ( rx[i] == ']' )
|
||||
rx += wc[i++];
|
||||
while ( i < wclen && wc[i] != TQChar(']') ) {
|
||||
if ( wc[i] == '\\' )
|
||||
rx += TQChar( '\\' );
|
||||
rx += wc[i++];
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
rx += c;
|
||||
}
|
||||
}
|
||||
/* Wildcard patterns must match entire string */
|
||||
return TQChar('^') + rx + TQChar('$');
|
||||
/* TBD: Add support for extglob */
|
||||
}
|
||||
static TQString escapeRegexChars( const TQString& basicString )
|
||||
{
|
||||
int wclen = basicString.length();
|
||||
TQString outputString = TQString::fromLatin1( "" );
|
||||
int i = 0;
|
||||
const TQChar *wc = basicString.unicode();
|
||||
while ( i < wclen ) {
|
||||
TQChar c = wc[i++];
|
||||
switch ( c.unicode() ) {
|
||||
case '+':
|
||||
case '.':
|
||||
case '^':
|
||||
case '(':
|
||||
case ')':
|
||||
case '[':
|
||||
case ']':
|
||||
case '{':
|
||||
case '}':
|
||||
case '|':
|
||||
case '$':
|
||||
case '?':
|
||||
case '*':
|
||||
case '\\':
|
||||
outputString += TQChar( '\\' );
|
||||
outputString += c;
|
||||
break;
|
||||
default:
|
||||
outputString += c;
|
||||
}
|
||||
}
|
||||
return outputString;
|
||||
}
|
||||
|
||||
//================================================================================================
|
||||
|
||||
#include "tdestringmatcher.moc"
|
||||
@ -0,0 +1,134 @@
|
||||
#ifndef TDESTRINGMATCHER_H
|
||||
#define TDESTRINGMATCHER_H
|
||||
|
||||
#include "tdelibs_export.h"
|
||||
|
||||
#include <tqobject.h>
|
||||
#include <tqvaluevector.h>
|
||||
|
||||
#define TSMTRACE kdWarning() << "<TSMTRACE> "
|
||||
|
||||
namespace TSM
|
||||
{
|
||||
/**
|
||||
* Enumeration used by the TDEStringMatcher class
|
||||
* defining types of patterns to be matched
|
||||
*/
|
||||
enum class PatternType: uchar
|
||||
{
|
||||
REGEX,
|
||||
WILDCARD,
|
||||
SUBSTRING,
|
||||
//OTHER,
|
||||
DEFAULT = REGEX
|
||||
};
|
||||
|
||||
/**
|
||||
* Enumeration used by the TDEStringMatcher class
|
||||
* defining special handling of alphanumeric characters
|
||||
*/
|
||||
enum class ANCHandling: uchar
|
||||
{
|
||||
CASE_SENSITIVE = 0, // No handling, each character distinct
|
||||
CASE_INSENSITIVE = 1, // Alphabetic case variants are same
|
||||
EQUIVALENCE = 2, // Alphanumeric equivalents are same
|
||||
DEFAULT = CASE_SENSITIVE
|
||||
};
|
||||
|
||||
/**
|
||||
* Structure used by the TDEStringMatcher class
|
||||
* representing properties of a single match specification.
|
||||
*/
|
||||
struct MatchSpec
|
||||
{
|
||||
PatternType patternType;
|
||||
ANCHandling ancHandling;
|
||||
bool expectMatch; // "matching" vs. "not matching"
|
||||
TQString pattern;
|
||||
};
|
||||
|
||||
/**
|
||||
* Container used in a TDEStringMatcher object
|
||||
* representing multiple match specifications.
|
||||
*/
|
||||
typedef TQValueVector<MatchSpec> MatchSpecList;
|
||||
|
||||
// Use horizontal tab as m_patternString separator
|
||||
inline constexpr char PatterStringDivider { '\t' };
|
||||
|
||||
} // End of namespace TSM
|
||||
|
||||
|
||||
/**
|
||||
* Generic string matcher class.
|
||||
*/
|
||||
class TDECORE_EXPORT TDEStringMatcher : public TQObject
|
||||
{
|
||||
Q_OBJECT
|
||||
public:
|
||||
|
||||
TDEStringMatcher();
|
||||
~TDEStringMatcher();
|
||||
|
||||
/**
|
||||
@return list of currently defined match specifications.
|
||||
*/
|
||||
const TSM::MatchSpecList getMatchSpecs() const;
|
||||
|
||||
/**
|
||||
@return string encoding list of currently defined match specifications.
|
||||
*/
|
||||
const TQString getMatchSpecString() const;
|
||||
|
||||
/**
|
||||
Use @param newMatchSpecList to generate the internal list of match
|
||||
specifications to be used for pattern matching.
|
||||
*/
|
||||
bool setMatchSpecs( TSM::MatchSpecList newMatchSpecList );
|
||||
|
||||
/**
|
||||
Use specially encoded @param newPatternString to generate the internal
|
||||
list of match specifications to be used for pattern matching. Refer
|
||||
to file README.tdestringmatcher in tdelibs/tdecore source code for
|
||||
more information on how the input string should be formatted.
|
||||
*/
|
||||
bool setMatchSpecs( TQString newMatchSpecString );
|
||||
|
||||
/**
|
||||
@return whether or not @param stringToMatch matches any of
|
||||
the current match specifications.
|
||||
*/
|
||||
bool matchAny( const TQString& stringToMatch ) const;
|
||||
|
||||
/**
|
||||
@return whether or not @param stringToMatch matches all of
|
||||
the current match specifications.
|
||||
*/
|
||||
bool matchAll( const TQString& stringToMatch ) const;
|
||||
|
||||
/**
|
||||
@return a basic regular expression formed by converting the basic
|
||||
wildcard expression in @param wildcardPattern.
|
||||
*/
|
||||
TQString wildcardToRegex( const TQString& wildcardPattern );
|
||||
|
||||
/**
|
||||
@return a string that is @param basicString with all special regular
|
||||
expression characters escaped. Useful for regular expression engines
|
||||
that do not support /Q.../E.
|
||||
*/
|
||||
TQString escapeRegexChars( const TQString& basicString );
|
||||
|
||||
|
||||
signals:
|
||||
|
||||
void patternsChanged();
|
||||
|
||||
private:
|
||||
|
||||
class TDEStringMatcherPrivate;
|
||||
TDEStringMatcherPrivate *d;
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,241 @@
|
||||
#undef REGEX_IS_PCRE2
|
||||
#define OPTIMIZE_ASCII_LOOKUP
|
||||
|
||||
#ifdef REGEXP_IS_PCRE2
|
||||
#pragma message "############ Assuming regular expressions are PCRE2 ############"
|
||||
#endif
|
||||
|
||||
#ifdef OPTIMIZE_ASCII_LOOKUP
|
||||
#pragma message "############ ASCII characters will be processed separately ############"
|
||||
#endif
|
||||
|
||||
#include "tequivchars.h"
|
||||
|
||||
//typedef wchar_t CHAR16;
|
||||
//typedef unsigned short CHAR16;
|
||||
typedef TQChar CHAR16;
|
||||
|
||||
class TEquivChars_Private
|
||||
{
|
||||
public:
|
||||
|
||||
struct defaultCollation {
|
||||
CHAR16 character;
|
||||
CHAR16 collatesTo;
|
||||
};
|
||||
|
||||
const defaultCollation EquivalentsTable // terminating ';' is provided in include file
|
||||
#include "tequivchars-mapping.h"
|
||||
uint EquivTableROWS = sizeof(EquivalentsTable)/sizeof(EquivalentsTable[0]);
|
||||
};
|
||||
|
||||
TEquivChars::TEquivChars()
|
||||
{
|
||||
p = new TEquivChars_Private;
|
||||
}
|
||||
|
||||
TEquivChars::~TEquivChars()
|
||||
{
|
||||
delete p;
|
||||
}
|
||||
|
||||
TQString TEquivChars::replaceChars( const TQString &inputString, bool isRegex )
|
||||
{
|
||||
int inStrLen = inputString.length();
|
||||
TQString outString = TQString::fromLatin1( "" );
|
||||
outString.reserve( inStrLen );
|
||||
const TQChar *char16 = inputString.unicode();
|
||||
|
||||
bool backSlashed = false; // \_
|
||||
bool startedCharClass = false; // Previous character was starting '[' of character class
|
||||
bool inCharacterClass = false; // [___]
|
||||
bool inPosixBracketExpr = false; // [:___:]
|
||||
#ifdef REGEXP_IS_PCRE2
|
||||
bool quoteLiteral = false; // \Q___\E
|
||||
bool inBraceExpr = false; // \c{___} where 'c' is any of: 'x' 'o' 'p' 'P' 'N' 'g'
|
||||
bool inDirective = false; // (*___)
|
||||
bool inGroupName = false; // (?<___>
|
||||
#endif // REGEXP_IS_PCRE2
|
||||
CHAR16 currChar = 0;
|
||||
CHAR16 prevChar = 0;
|
||||
CHAR16 nextChar = 0;
|
||||
|
||||
for ( int i = 0 ; i < inStrLen ; outString[i] = CHAR16(currChar), i++ ) {
|
||||
|
||||
prevChar = currChar;
|
||||
currChar = char16[i].unicode();
|
||||
|
||||
if ( isRegex ) {
|
||||
|
||||
/*
|
||||
Look for regex characters and character sequences
|
||||
that should never be converted to an equivalent.
|
||||
*/
|
||||
|
||||
if ( i < ( inStrLen - 1 ) )
|
||||
nextChar = char16[i+1].unicode();
|
||||
else
|
||||
nextChar = 0;
|
||||
|
||||
if ( currChar == '\\' ) {
|
||||
backSlashed = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
// Don't convert backSlashed characters
|
||||
if ( backSlashed ) {
|
||||
#ifdef REGEXP_IS_PCRE2
|
||||
switch (currChar) {
|
||||
case 'Q' : quoteLiteral = true; break; // Entering literal \Q___\E
|
||||
case 'E' : quoteLiteral = false; break; // Leaving literal \Q___\E
|
||||
case 'N' : // Entering Unicode codepoint specification \N{U+___} ?
|
||||
case 'P' : // Entering (negated) Unicode property specification \p{} ?
|
||||
case 'p' : // Entering Unicode property specification \p{} ?
|
||||
case 'g' : // Entering a named backreference \g{___} ?
|
||||
if ( nextChar == '{' ) inBraceExpr = true;
|
||||
break;
|
||||
}
|
||||
#endif // REGEXP_IS_PCRE2
|
||||
backSlashed = false;
|
||||
continue;
|
||||
}
|
||||
|
||||
#ifdef REGEXP_IS_PCRE2
|
||||
if ( quoteLiteral )
|
||||
continue;
|
||||
|
||||
if ( inBraceExpr ) {
|
||||
// Is it time to leave brace expression {___} ?
|
||||
if ( nextChar == '}' ) inBraceExpr = true;
|
||||
continue;
|
||||
}
|
||||
#endif // REGEXP_IS_PCRE2
|
||||
|
||||
if ( startedCharClass ) {
|
||||
switch (currChar) {
|
||||
case '^' : // Negated character class, proceed to next character
|
||||
continue; // Bypass converting this special character
|
||||
case ']' : // Treat as part of character class, not as a closure
|
||||
case ':' : // Treat as part of character class, not as start of bracket expression
|
||||
startedCharClass = false;
|
||||
continue; // Bypass converting these special characters
|
||||
}
|
||||
startedCharClass = false;
|
||||
} // startedCharClass
|
||||
|
||||
if ( inCharacterClass ) {
|
||||
|
||||
if ( inPosixBracketExpr ) {
|
||||
// Is it time to leave POSIX bracket expression [:___:] ?
|
||||
if ( currChar == ':' && nextChar == ']' ) inPosixBracketExpr = false;
|
||||
continue;
|
||||
} // inPosixBracketExpr
|
||||
|
||||
else { // ! inPosixBracketExpr
|
||||
|
||||
if ( prevChar == '[' && currChar == ':' ) {
|
||||
// Enter POSIX bracket expression [:___:]
|
||||
inPosixBracketExpr = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
if ( currChar == ']' ) {
|
||||
// Leaving character class [___]
|
||||
inCharacterClass = false;
|
||||
continue;
|
||||
}
|
||||
|
||||
} // ! inPosixBracketExpr
|
||||
|
||||
} // inCharacterClass
|
||||
|
||||
else { // ! inCharacterClass
|
||||
|
||||
switch (currChar) {
|
||||
|
||||
case '[' :
|
||||
// Entering a character class [___]
|
||||
startedCharClass = true;
|
||||
inCharacterClass = true;
|
||||
continue;
|
||||
break;
|
||||
#ifdef REGEXP_IS_PCRE2
|
||||
case '*' :
|
||||
if ( prevChar != '(' ) continue;
|
||||
// Entering a PCRE2 directive (*___)
|
||||
inDirective = true;
|
||||
continue;
|
||||
break;
|
||||
|
||||
case '?' :
|
||||
if ( prevChar != '(' ) continue;
|
||||
if ( nextChar != '<' ) continue;
|
||||
// Entering PCRE2 group name (?<___>)
|
||||
inGroupName = true;
|
||||
continue;
|
||||
break;
|
||||
#endif // REGEXP_IS_PCRE2
|
||||
}
|
||||
#ifdef REGEXP_IS_PCRE2
|
||||
if ( inDirective ) {
|
||||
// Is it time to leave PCRE2 directive (*___) ?
|
||||
if (currChar == ')' ) inDirective = false;
|
||||
continue;
|
||||
}
|
||||
|
||||
if ( inGroupName ) {
|
||||
// Is it time to leave PCRE2 group name (?<___>) ?
|
||||
if (currChar == '>' ) inGroupName = false;
|
||||
continue;
|
||||
}
|
||||
#endif // REGEXP_IS_PCRE2
|
||||
} // ! inCharacterClass
|
||||
|
||||
/*
|
||||
If we have reached here, this regex character is a
|
||||
candidate for potential conversion to an equivalent.
|
||||
*/
|
||||
|
||||
} // isRegex
|
||||
|
||||
//-Debug: std::cerr << "Converting '" << TQString(currChar).utf8().data() << "' to '";
|
||||
|
||||
#ifdef OPTIMIZE_ASCII_LOOKUP
|
||||
// We can process ASCII quickly without using lookup table
|
||||
unsigned short codepoint = currChar.unicode();
|
||||
if ( codepoint < 128 ) {
|
||||
if ( codepoint > 64 && codepoint < 91 ) // convert upper case ASCII
|
||||
currChar = TQChar(codepoint + 32 ); // to corresponding lower case
|
||||
// All other ASCII characters are equivalent to themselves
|
||||
//-Debug: std::cerr << TQString(currChar).utf8().data() << "' (ascii)" << std::endl;
|
||||
continue;
|
||||
}
|
||||
#endif
|
||||
|
||||
// Use a simple binary search to look up an equivalent character
|
||||
int low = 0;
|
||||
int high = p->EquivTableROWS - 1;
|
||||
while (low <= high) {
|
||||
int mid = low + (high - low) / 2;
|
||||
if ( currChar == p->EquivalentsTable[mid].character ) {
|
||||
// Found equivalent character, use it instead
|
||||
currChar = p->EquivalentsTable[mid].collatesTo;
|
||||
break;
|
||||
}
|
||||
if ( p->EquivalentsTable[mid].character < currChar )
|
||||
low = mid + 1;
|
||||
else
|
||||
high = mid - 1;
|
||||
}
|
||||
//-Debug: std::cerr << TQString(currChar).utf8().data() << "'" << std::endl;
|
||||
|
||||
/* FIXME: Possible ideas for optimizing table lookup speed
|
||||
(1) Detect & handle ASCII (<128) characters separately. *DONE*
|
||||
(2) Split table into multiple lookup tables and search each
|
||||
in order of descending likelihood of character match.
|
||||
*/
|
||||
|
||||
}
|
||||
|
||||
return outString;
|
||||
}
|
||||
@ -0,0 +1,34 @@
|
||||
#ifndef TEQUIVCHARS_H
|
||||
#define TEQUIVCHARS_H
|
||||
|
||||
#include "tdelibs_export.h"
|
||||
|
||||
#include <tqstring.h>
|
||||
|
||||
/**
|
||||
* Class representing a mapping of each alphanumeric character to its "collating
|
||||
* equivalent" as defined by the Default Unicode Collation Entity Table (DUCET).
|
||||
* The mapping is limited to single-codepoint characters <= U+FFFF.
|
||||
*/
|
||||
class TDECORE_EXPORT TEquivChars
|
||||
{
|
||||
public:
|
||||
TEquivChars();
|
||||
~TEquivChars();
|
||||
|
||||
/**
|
||||
@return copy of @param inputString modified such that each alphanumeric
|
||||
character is replaced with it's collating character equivalent. If the
|
||||
value @param isRegex is true, the input string is treated as a regular
|
||||
expression and the alphabetical characters inside Posix bracket [::]
|
||||
expressions are left as-is
|
||||
*/
|
||||
TQString replaceChars( const TQString &inputString, bool isRegex = false );
|
||||
|
||||
|
||||
private:
|
||||
|
||||
class TEquivChars_Private *p;
|
||||
};
|
||||
|
||||
#endif // TEQUIVCHARS_H
|
||||
Loading…
Reference in new issue