qmimeglobpattern.cpp

Jenkins

Absolute File Name:

/home/qt/qt5_coco/qt5/qtbase/src/corelib/mimetypes/qmimeglobpattern.cpp

Line

Source

Count

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

** Contact: https://www.qt.io/licensing/

** This file is part of the QtCore module of the Qt Toolkit.

** $QT_BEGIN_LICENSE:LGPL$

** Commercial License Usage

** Licensees holding valid commercial Qt licenses may use this file in

** accordance with the commercial license agreement provided with the

** Software or, alternatively, in accordance with the terms contained in

** a written agreement between you and The Qt Company. For licensing terms

** and conditions see https://www.qt.io/terms-conditions. For further

** information use the contact form at https://www.qt.io/contact-us.

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 3 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL3 included in the

** packaging of this file. Please review the following information to

** ensure the GNU Lesser General Public License version 3 requirements

** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.

** GNU General Public License Usage

** Alternatively, this file may be used under the terms of the GNU

** General Public License version 2.0 or (at your option) the GNU General

** Public license version 3 or any later version approved by the KDE Free

** Qt Foundation. The licenses are as published by the Free Software

** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3

** included in the packaging of this file. Please review the following

** information to ensure the GNU General Public License requirements will

** be met: https://www.gnu.org/licenses/gpl-2.0.html and

** https://www.gnu.org/licenses/gpl-3.0.html.

** $QT_END_LICENSE$

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

#include "qmimeglobpattern_p.h"

#ifndef QT_NO_MIMETYPE

#include <QRegExp>

#include <QStringList>

#include <QDebug>

QT_BEGIN_NAMESPACE

/*!

\internal

\class QMimeGlobMatchResult

\inmodule QtCore

\brief The QMimeGlobMatchResult class accumulates results from glob matching.

Handles glob weights, and preferring longer matches over shorter matches.

void QMimeGlobMatchResult::addMatch(const QString &mimeType, int weight, const QString &pattern)

{

// Is this a lower-weight pattern than the last match? Skip this match then.

if (weight < m_weight)

return;

bool replace = weight > m_weight;

if (!replace) {

// Compare the length of the match

if (pattern.length() < m_matchingPatternLength)

return; // too short, ignore

else if (pattern.length() > m_matchingPatternLength) {

// longer: clear any previous match (like *.bz2, when pattern is *.tar.bz2)

replace = true;

}

if (replace) {

m_matchingMimeTypes.clear();

// remember the new "longer" length

m_matchingPatternLength = pattern.length();

m_weight = weight;

}

if (!m_matchingMimeTypes.contains(mimeType)) {

m_matchingMimeTypes.append(mimeType);

if (pattern.startsWith(QLatin1String("*.")))

m_foundSuffix = pattern.mid(2);

}

/*!

\internal

\class QMimeGlobPattern

\inmodule QtCore

\brief The QMimeGlobPattern class contains the glob pattern for file names for MIME type matching.

\sa QMimeType, QMimeDatabase, QMimeMagicRuleMatcher, QMimeMagicRule

bool QMimeGlobPattern::matchFileName(const QString &inputFilename) const

{

// "Applications MUST match globs case-insensitively, except when the case-sensitive

// attribute is set to true."

100

// The constructor takes care of putting case-insensitive patterns in lowercase.

101

const QString filename = m_caseSensitivity == Qt::CaseInsensitive ? inputFilename.toLower() : inputFilename;

102

103

const int pattern_len = m_pattern.length();

104

if (!pattern_len)

105

return false;

106

const int len = filename.length();

107

108

const int starCount = m_pattern.count(QLatin1Char('*'));

109

110

// Patterns like "*~", "*.extension"

111

if (m_pattern[0] == QLatin1Char('*') && m_pattern.indexOf(QLatin1Char('[')) == -1 && starCount == 1)

112

{

113

if (len + 1 < pattern_len) return false;

114

115

const QChar *c1 = m_pattern.unicode() + pattern_len - 1;

116

const QChar *c2 = filename.unicode() + len - 1;

117

int cnt = 1;

118

while (cnt < pattern_len && *c1-- == *c2--)

119

++cnt;

120

return cnt == pattern_len;

121

}

122

123

// Patterns like "README*" (well this is currently the only one like that...)

124

if (starCount == 1 && m_pattern.at(pattern_len - 1) == QLatin1Char('*')) {

125

if (len + 1 < pattern_len) return false;

126

if (m_pattern.at(0) == QLatin1Char('*'))

127

return filename.indexOf(m_pattern.mid(1, pattern_len - 2)) != -1;

128

129

const QChar *c1 = m_pattern.unicode();

130

const QChar *c2 = filename.unicode();

131

int cnt = 1;

132

while (cnt < pattern_len && *c1++ == *c2++)

133

++cnt;

134

return cnt == pattern_len;

135

}

136

137

// Names without any wildcards like "README"

138

if (m_pattern.indexOf(QLatin1Char('[')) == -1 && starCount == 0 && m_pattern.indexOf(QLatin1Char('?')))

139

return (m_pattern == filename);

140

141

// Other (quite rare) patterns, like "*.anim[1-9j]": use slow but correct method

142

QRegExp rx(m_pattern, Qt::CaseSensitive, QRegExp::WildcardUnix);

143

return rx.exactMatch(filename);

144

}

145

146

static bool isFastPattern(const QString &pattern)

147

{

148

// starts with "*.", has no other '*' and no other '.'

149

return pattern.lastIndexOf(QLatin1Char('*')) == 0

150

&& pattern.lastIndexOf(QLatin1Char('.')) == 1

151

// and contains no other special character

152

&& !pattern.contains(QLatin1Char('?'))

153

&& !pattern.contains(QLatin1Char('['))

;

}

void QMimeAllGlobPatterns::addGlob(const QMimeGlobPattern &glob)

158

{

159

const QString &pattern = glob.pattern();

160

Q_ASSERT(!pattern.isEmpty());

161

162

// Store each patterns into either m_fastPatternDict (*.txt, *.html etc. with default weight 50)

163

// or for the rest, like core.*, *.tar.bz2, *~, into highWeightPatternOffset (>50)

164

// or lowWeightPatternOffset (<=50)

165

166

if (glob.weight() == 50 && isFastPattern(pattern) && !glob.isCaseSensitive()) {

167

// The bulk of the patterns is *.foo with weight 50 --> those go into the fast patterns hash.

168

const QString extension = pattern.mid(2).toLower();

169

QStringList &patterns = m_fastPatterns[extension]; // find or create

170

if (!patterns.contains(glob.mimeType()))

171

patterns.append(glob.mimeType());

172

} else {

173

if (glob.weight() > 50) {

174

if (!m_highWeightGlobs.hasPattern(glob.mimeType(), glob.pattern()))

175

m_highWeightGlobs.append(glob);

176

} else {

177

if (!m_lowWeightGlobs.hasPattern(glob.mimeType(), glob.pattern()))

178

m_lowWeightGlobs.append(glob);

}

}

}

void QMimeAllGlobPatterns::removeMimeType(const QString &mimeType)

184

{

185

QMutableHashIterator<QString, QStringList> itfor (auto &x : m_fastPatterns);

while (it.hasNext()) {

it)

186

never executed: x.removeAll(mimeType);

.next().value().removeAll(mimeType);

never executed: x.removeAll(mimeType);

187

}m_highWeightGlobs.removeMimeType(mimeType);

188

m_lowWeightGlobs.removeMimeType(mimeType);

189

}

never executed: end of block

190

191

void QMimeGlobPatternList::match(QMimeGlobMatchResult &result,

192

const QString &fileName) const

193

{

194

195

QMimeGlobPatternList::const_iterator it = this->constBegin();

196

const QMimeGlobPatternList::const_iterator endIt = this->constEnd();

197

for (; it != endIt; ++it) {

198

const QMimeGlobPattern &glob = *it;

199

if (glob.matchFileName(fileName))

200

result.addMatch(glob.mimeType(), glob.weight(), glob.pattern());

}

}

QStringList QMimeAllGlobPatterns::matchingGlobs(const QString &fileName, QString *foundSuffix) const

205

{

206

// First try the high weight matches (>50), if any.

207

QMimeGlobMatchResult result;

208

m_highWeightGlobs.match(result, fileName);

209

if (result.m_matchingMimeTypes.isEmpty()) {

result.m_match...ypes.isEmpty()	Description
TRUE	evaluated 96 times by 1 test Evaluated by: tst_QMimeDatabase
FALSE	never evaluated

0-96

210

211

// Now use the "fast patterns" dict, for simple *.foo patterns with weight 50

212

// (which is most of them, so this optimization is definitely worth it)

213

const int lastDot = fileName.lastIndexOf(QLatin1Char('.'));

214

if (lastDot != -1) { // if no '.', skip the extension lookup

lastDot != -1	Description
TRUE	evaluated 71 times by 1 test Evaluated by: tst_QMimeDatabase
FALSE	evaluated 25 times by 1 test Evaluated by: tst_QMimeDatabase

25-71

215

const int ext_len = fileName.length() - lastDot - 1;

216

const QString simpleExtension = fileName.right(ext_len).toLower();

217

// (toLower because fast patterns are always case-insensitive and saved as lowercase)

218

219

const QStringList matchingMimeTypes = m_fastPatterns.value(simpleExtension);

220

foreachconst QString simplePattern = QLatin1String("*.") + simpleExtension;

221

for (const QString &mime ,: matchingMimeTypes)

222

{result.addMatch(mime, 50, QLatin1String("*.") + simpleExtensionsimplePattern);}

executed 57 times by 1 test: result.addMatch(mime, 50, simplePattern);

Executed by:

tst_QMimeDatabase

223

// Can't return yet; *.tar.bz2 has to win over *.bz2, so we need the low-weight mimetypes anyway,

224

// at least those with weight 50.

225

}

executed 71 times by 1 test: end of block

Executed by:

tst_QMimeDatabase

226

227

// Finally, try the low weight matches (<=50)

228

m_lowWeightGlobs.match(result, fileName);

229

}

executed 96 times by 1 test: end of block

Executed by:

tst_QMimeDatabase

230

if (foundSuffix)

foundSuffix	Description
TRUE	evaluated 8 times by 1 test Evaluated by: tst_QMimeDatabase
FALSE	evaluated 88 times by 1 test Evaluated by: tst_QMimeDatabase

8-88

231

*foundSuffix = result.m_foundSuffix;

executed 8 times by 1 test: *foundSuffix = result.m_foundSuffix;

Executed by:

tst_QMimeDatabase

232

return result.m_matchingMimeTypes;

executed 96 times by 1 test: return result.m_matchingMimeTypes;

Executed by:

tst_QMimeDatabase

233

}

234

235

void QMimeAllGlobPatterns::clear()

236

{

237

m_fastPatterns.clear();

238

m_highWeightGlobs.clear();

239

m_lowWeightGlobs.clear();

}

QT_END_NAMESPACE

#endif // QT_NO_MIMETYPE

Generated by Squish Coco Non-Commercial 4.3.0-BETA-master-30-08-2018-4cb69e9