tools/qstring.cpp

const QString copy(*this);

evaluated: !re.isValid()

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:33

2-33

2951

qWarning("QString::replace: invalid ~~QRegularExpresssion~~QRegularExpression object");

executed (the execution status of this line is deduced):

 QMessageLogger("tools/qstring.cpp", 2951, __PRETTY_FUNCTION__).warning("QString::replace: invalid QRegularExpression object");

2952

return *this;

executed: return *this;

Execution Count:2

2953 } -

2954 -

2955

executed (the execution status of this line is deduced): const QString copy(*this);

2956

QRegularExpressionMatchIterator iterator = re.globalMatch(copy);

executed (the execution status of this line is deduced): QRegularExpressionMatchIterator iterator = re.globalMatch(copy);

2957

if (!iterator.hasNext()) // no matches at all

evaluated: !iterator.hasNext()

TRUE	FALSE
yes Evaluation Count:12	yes Evaluation Count:21

12-21

2958

return *this;

executed: return *this;

Execution Count:12

2959 -

2960

reallocData(uint(d->size) + 1u);

executed (the execution status of this line is deduced): reallocData(uint(d->size) + 1u);

2961 -

2962

int numCaptures = re.captureCount();

executed (the execution status of this line is deduced): int numCaptures = re.captureCount();

2963 -

2964 // 1. build the backreferences vector, holding where the backreferences -

2965 // are in the replacement string -

2966

QVector<QStringCapture> backReferences;

executed (the execution status of this line is deduced): QVector<QStringCapture> backReferences;

2967

const int al = after.length();

executed (the execution status of this line is deduced): const int al = after.length();

2968

const QChar *ac = after.unicode();

executed (the execution status of this line is deduced): const QChar *ac = after.unicode();

2969 -

2970

for (int i = 0; i < al - 1; i++) {

evaluated: i < al - 1

TRUE	FALSE
yes Evaluation Count:138	yes Evaluation Count:21

21-138

2971

if (ac[i] == QLatin1Char('\\')) {

evaluated: ac[i] == QLatin1Char('\\')

TRUE	FALSE
yes Evaluation Count:55	yes Evaluation Count:83

55-83

2972

int no = ac[i + 1].digitValue();

executed (the execution status of this line is deduced): int no = ac[i + 1].digitValue();

2973

if (no > 0 && no <= numCaptures) {

evaluated: no > 0

TRUE	FALSE
yes Evaluation Count:51	yes Evaluation Count:4

evaluated: no <= numCaptures

TRUE	FALSE
yes Evaluation Count:48	yes Evaluation Count:3

3-51

2974

QStringCapture backReference;

executed (the execution status of this line is deduced): QStringCapture backReference;

2975

backReference.pos = i;

executed (the execution status of this line is deduced): backReference.pos = i;

2976

backReference.len = 2;

executed (the execution status of this line is deduced): backReference.len = 2;

2977 -

2978

if (i < al - 2) {

evaluated: i < al - 2

TRUE	FALSE
yes Evaluation Count:43	yes Evaluation Count:5

5-43

2979

int secondDigit = ac[i + 2].digitValue();

executed (the execution status of this line is deduced): int secondDigit = ac[i + 2].digitValue();

2980

if (secondDigit != -1 && ((no * 10) + secondDigit) <= numCaptures) {

evaluated: secondDigit != -1

TRUE	FALSE
yes Evaluation Count:28	yes Evaluation Count:15

evaluated: ((no * 10) + secondDigit) <= numCaptures

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:22

6-28

2981

no = (no * 10) + secondDigit;

executed (the execution status of this line is deduced): no = (no * 10) + secondDigit;

2982

++backReference.len;

executed (the execution status of this line is deduced): ++backReference.len;

2983

executed: }

Execution Count:6

2984

backReferences.append(backReference);

executed: }

Execution Count:43

2985 -

2986

backReference.no = no;

executed (the execution status of this line is deduced): backReference.no = no;

2987

executed (the execution status of this line is deduced): backReferences.append(backReference);

2988

executed: }

Execution Count:48

2989

executed: }

Execution Count:55

2990

int newLength = 0; // length of the new string, with all the replacements

executed: }

Execution Count:138

138

2991 -

2992 // 2. iterate on the matches. For every match, copy in chunks -

2993 // - the part before the match -

2994 // - the after string, with the proper replacements for the backreferences -

2995 -

2996

executed (the execution status of this line is deduced): int newLength = 0;

2997

int lastEnd = 0;

executed (the execution status of this line is deduced): int lastEnd = 0;

2998

QVector<QStringRef> chunks;

executed (the execution status of this line is deduced): QVector<QStringRef> chunks;

2999

while (iterator.hasNext()) {

evaluated: iterator.hasNext()

TRUE	FALSE
yes Evaluation Count:38	yes Evaluation Count:21

21-38

3000

QRegularExpressionMatch match = iterator.next();

executed (the execution status of this line is deduced): QRegularExpressionMatch match = iterator.next();

3001

int len;

executed (the execution status of this line is deduced): int len;

3002 // add the part before the match -

3003

len = match.capturedStart() - lastEnd;

executed (the execution status of this line is deduced): len = match.capturedStart() - lastEnd;

3004

chunks << copy.midRef(lastEnd, len);

evaluated: len > 0

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:34

4-34

3005

executed (the execution status of this line is deduced): chunks << copy.midRef(lastEnd, len);

3006

executed (the execution status of this line is deduced): newLength += len;

3007

foreach (const QStringCapture &backReference, backReferences) {

executed: }

Execution Count:4

3008 -

3009

lastEnd = 0;

executed (the execution status of this line is deduced): lastEnd = 0;

3010 // add the after string, with replacements for the backreferences -

3011

executed (the execution status of this line is deduced):

 for (QForeachContainer<__typeof__(backReferences)> _container_(backReferences); !_container_.brk && _container_.i != _container_.e; __extension__ ({ ++_container_.brk; ++_container_.i; })) for (const QStringCapture &backReference = *_container_.i;; __extension__ ({--_container_.brk; break;})) {

3012 // part of "after" before the backreference -

3013

len = backReference.pos - lastEnd;

executed (the execution status of this line is deduced): len = backReference.pos - lastEnd;

3014

chunks << after.midRef(lastEnd, len);

evaluated: len > 0

TRUE	FALSE
yes Evaluation Count:28	yes Evaluation Count:30

28-30

3015

executed (the execution status of this line is deduced): chunks << after.midRef(lastEnd, len);

3016

executed (the execution status of this line is deduced): newLength += len;

3017

len = match.capturedLength(backReference.no);

executed: }

Execution Count:28

3018 -

3019 // backreference itself -

3020

executed (the execution status of this line is deduced): len = match.capturedLength(backReference.no);

3021

chunks << copy.midRef(match.capturedStart(backReference.no), len);

evaluated: len > 0

TRUE	FALSE
yes Evaluation Count:57	yes Evaluation Count:1

1-57

3022

executed (the execution status of this line is deduced): chunks << copy.midRef(match.capturedStart(backReference.no), len);

3023

executed (the execution status of this line is deduced): newLength += len;

3024

lastEnd = backReference.pos + backReference.len;

executed: }

Execution Count:57

3025 -

3026

executed (the execution status of this line is deduced): lastEnd = backReference.pos + backReference.len;

3027

len = after.length() - lastEnd;

executed: }

Execution Count:58

3028 -

3029 // add the last part of the after string -

3030

executed (the execution status of this line is deduced): len = after.length() - lastEnd;

3031

chunks << after.midRef(lastEnd, len);

evaluated: len > 0

TRUE	FALSE
yes Evaluation Count:27	yes Evaluation Count:11

11-27

3032

executed (the execution status of this line is deduced): chunks << after.midRef(lastEnd, len);

3033

executed (the execution status of this line is deduced): newLength += len;

3034

lastEnd = match.capturedEnd();

executed: }

Execution Count:27

3035 -

3036

executed (the execution status of this line is deduced): lastEnd = match.capturedEnd();

3037

if (copy.length() > lastEnd) {

executed: }

Execution Count:38

3038 -

3039 // 3. trailing string after the last match -

3040

evaluated: copy.length() > lastEnd

TRUE	FALSE
yes Evaluation Count:7	yes Evaluation Count:14

7-14

3041

chunks << copy.midRef(lastEnd);

executed (the execution status of this line is deduced): chunks << copy.midRef(lastEnd);

3042

newLength += copy.length() - lastEnd;

executed (the execution status of this line is deduced): newLength += copy.length() - lastEnd;

3043

foreach (const QStringRef &chunk, chunks) {

executed: }

Execution Count:7

3044 -

3045 // 4. assemble the chunks together -

3046

resize(newLength);

executed (the execution status of this line is deduced): resize(newLength);

3047

int i = 0;

executed (the execution status of this line is deduced): int i = 0;

3048

QChar *uc = data();

executed (the execution status of this line is deduced): QChar *uc = data();

3049

executed (the execution status of this line is deduced):

 for (QForeachContainer<__typeof__(chunks)> _container_(chunks); !_container_.brk && _container_.i != _container_.e; __extension__ ({ ++_container_.brk; ++_container_.i; })) for (const QStringRef &chunk = *_container_.i;; __extension__ ({--_container_.brk; break;})) {

3050

int len = chunk.length();

executed (the execution status of this line is deduced): int len = chunk.length();

3051

memcpy(uc + i, chunk.unicode(), len * sizeof(QChar));

executed (the execution status of this line is deduced): memcpy(uc + i, chunk.unicode(), len * sizeof(QChar));

3052

i += len;

executed (the execution status of this line is deduced): i += len;

3053

executed: }

Execution Count:123

123

3054 -

3055

return *this;

executed: return *this;

Execution Count:21

3056 } -

3057 #endif // QT_BOOTSTRAPPED -

3058 #endif // QT_NO_REGEXP -

3059 -

3060 /*! -

3061 Returns the number of (potentially overlapping) occurrences of -

3062 the string \a str in this string. -

3063 -

3064 If \a cs is Qt::CaseSensitive (default), the search is -

3065 case sensitive; otherwise the search is case insensitive. -

3066 -

3067 \sa contains(), indexOf() -

3068 */ -

3069 -

3070 int QString::count(const QString &str, Qt::CaseSensitivity cs) const -

3071 { -

3072 return qt_string_count(unicode(), size(), str.unicode(), str.size(), cs); -

3073 } -

3074 -

3075 /*! -

3076 \overload count() -

3077 -

3078 Returns the number of occurrences of character \a ch in the string. -

3079 */ -

3080 -

3081 int QString::count(QChar ch, Qt::CaseSensitivity cs) const -

3082 { -

3083 return qt_string_count(unicode(), size(), ch, cs); -

3084 } -

3085 -

3086 /*! -

3087 \since 4.8 -

3088 \overload count() -

3089 Returns the number of (potentially overlapping) occurrences of the -

3090 string reference \a str in this string. -

3091 -

3092 If \a cs is Qt::CaseSensitive (default), the search is -

3093 case sensitive; otherwise the search is case insensitive. -

3094 -

3095 \sa contains(), indexOf() -

3096 */ -

3097 int QString::count(const QStringRef &str, Qt::CaseSensitivity cs) const -

3098 { -

3099 return qt_string_count(unicode(), size(), str.unicode(), str.size(), cs); -

3100 } -

3101 -

3102 -

3103 /*! \fn bool QString::contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const -

3104 -

3105 Returns true if this string contains an occurrence of the string -

3106 \a str; otherwise returns false. -

3107 -

3108 If \a cs is Qt::CaseSensitive (default), the search is -

3109 case sensitive; otherwise the search is case insensitive. -

3110 -

3111 Example: -

3112 \snippet qstring/main.cpp 17 -

3113 -

3114 \sa indexOf(), count() -

3115 */ -

3116 -

3117 /*! \fn bool QString::contains(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const -

3118 -

3119 \overload contains() -

3120 -

3121 Returns true if this string contains an occurrence of the -

3122 character \a ch; otherwise returns false. -

3123 */ -

3124 -

3125 /*! \fn bool QString::contains(const QStringRef &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const -

3126 \since 4.8 -

3127 -

3128 Returns true if this string contains an occurrence of the string -

3129 reference \a str; otherwise returns false. -

3130 -

3131 If \a cs is Qt::CaseSensitive (default), the search is -

3132 case sensitive; otherwise the search is case insensitive. -

3133 -

3134 \sa indexOf(), count() -

3135 */ -

3136 -

3137 /*! \fn bool QString::contains(const QRegExp &rx) const -

3138 -

3139 \overload contains() -

3140 -

3141 Returns true if the regular expression \a rx matches somewhere in -

3142 this string; otherwise returns false. -

3143 */ -

3144 -

3145 /*! \fn bool QString::contains(QRegExp &rx) const -

3146 \overload contains() -

3147 \since 4.5 -

3148 -

3149 Returns true if the regular expression \a rx matches somewhere in -

3150 this string; otherwise returns false. -

3151 -

3152 If there is a match, the \a rx regular expression will contain the -

3153 matched captures (see QRegExp::matchedLength, QRegExp::cap). -

3154 */ -

3155 -

3156 #ifndef QT_NO_REGEXP -

3157 /*! -

3158 \overload indexOf() -

3159 -

3160 Returns the index position of the first match of the regular -

3161 expression \a rx in the string, searching forward from index -

3162 position \a from. Returns -1 if \a rx didn't match anywhere. -

3163 -

3164 Example: -

3165 -

3166 \snippet qstring/main.cpp 25 -

3167 */ -

3168 int QString::indexOf(const QRegExp& rx, int from) const -

3169 { -

3170 QRegExp rx2(rx); -

3171 return rx2.indexIn(*this, from); -

3172 } -

3173 -

3174 /*! -

3175 \overload indexOf() -

3176 \since 4.5 -

3177 -

3178 Returns the index position of the first match of the regular -

3179 expression \a rx in the string, searching forward from index -

3180 position \a from. Returns -1 if \a rx didn't match anywhere. -

3181 -

3182 If there is a match, the \a rx regular expression will contain the -

3183 matched captures (see QRegExp::matchedLength, QRegExp::cap). -

3184 -

3185 Example: -

3186 -

3187 \snippet qstring/main.cpp 25 -

3188 */ -

3189 int QString::indexOf(QRegExp& rx, int from) const -

3190 { -

3191 return rx.indexIn(*this, from); -

3192 } -

3193 -

3194 /*! -

3195 \overload lastIndexOf() -

3196 -

3197 Returns the index position of the last match of the regular -

3198 expression \a rx in the string, searching backward from index -

3199 position \a from. Returns -1 if \a rx didn't match anywhere. -

3200 -

3201 Example: -

3202 -

3203 \snippet qstring/main.cpp 30 -

3204 */ -

3205 int QString::lastIndexOf(const QRegExp& rx, int from) const -

3206 { -

3207 QRegExp rx2(rx); -

3208 return rx2.lastIndexIn(*this, from); -

3209 } -

3210 -

3211 /*! -

3212 \overload lastIndexOf() -

3213 \since 4.5 -

3214 -

3215 Returns the index position of the last match of the regular -

3216 expression \a rx in the string, searching backward from index -

3217 position \a from. Returns -1 if \a rx didn't match anywhere. -

3218 -

3219 If there is a match, the \a rx regular expression will contain the -

3220 matched captures (see QRegExp::matchedLength, QRegExp::cap). -

3221 -

3222 Example: -

3223 -

3224 \snippet qstring/main.cpp 30 -

3225 */ -

3226 int QString::lastIndexOf(QRegExp& rx, int from) const -

3227 { -

3228 return rx.lastIndexIn(*this, from); -

3229 } -

3230 -

3231 /*! -

3232 \overload count() -

3233 -

3234 Returns the number of times the regular expression \a rx matches -

3235 in the string. -

3236 -

3237 This function counts overlapping matches, so in the example -

3238 below, there are four instances of "ana" or "ama": -

3239 -

3240 \snippet qstring/main.cpp 18 -

3241 -

3242 */ -

3243 int QString::count(const QRegExp& rx) const -

3244 { -

3245 QRegExp rx2(rx); -

3246 int count = 0; -

3247 int index = -1; -

3248 int len = length(); -

3249 while (index < len - 1) { // count overlapping matches -

3250 index = rx2.indexIn(*this, index + 1); -

3251 if (index == -1) -

3252 break; -

3253 count++; -

3254 } -

3255 return count; -

3256 } -

3257 #endif // QT_NO_REGEXP -

3258 -

3259 #ifndef QT_NO_REGEXP -

3260 #ifndef QT_BOOTSTRAPPED -

3261 /*! -

3262 \overload indexOf() -

3263 \since 5.0 -

3264 -

3265 Returns the index position of the first match of the regular -

3266 expression \a re in the string, searching forward from index -

3267 position \a from. Returns -1 if \a re didn't match anywhere. -

3268 -

3269 Example: -

3270 -

3271 \snippet qstring/main.cpp 93 -

3272 */ -

3273 int QString::indexOf(const QRegularExpression& re, int from) const -

3274 { -

3275

QRegularExpressionMatch match = re.match(*this, from);

partially evaluated: !re.isValid()

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:64

0-64

3276

qWarning("QString::indexOf: invalid ~~QRegularExpresssion~~QRegularExpression object");

never executed (the execution status of this line is deduced):

 QMessageLogger("tools/qstring.cpp", 3276, __PRETTY_FUNCTION__).warning("QString::indexOf: invalid QRegularExpression object");

3277

return -1;

never executed: return -1;

3278 } -

3279 -

3280

executed (the execution status of this line is deduced): QRegularExpressionMatch match = re.match(*this, from);

3281

if (match.hasMatch())

evaluated: match.hasMatch()

TRUE	FALSE
yes Evaluation Count:33	yes Evaluation Count:31

31-33

3282

return match.capturedStart();

executed: return match.capturedStart();

Execution Count:33

3283 -

3284

return -1;

executed: return -1;

Execution Count:31

3285 } -

3286 -

3287 /*! -

3288 \overload lastIndexOf() -

3289 \since 5.0 -

3290 -

3291 Returns the index position of the last match of the regular -

3292 expression \a re in the string, which starts before the index -

3293 position \a from. Returns -1 if \a re didn't match anywhere. -

3294 -

3295 Example: -

3296 -

3297 \snippet qstring/main.cpp 94 -

3298 */ -

3299 int QString::lastIndexOf(const QRegularExpression &re, int from) const -

3300 { -

3301

int endpos = (from < 0) ? (size() + from + 1) : (from + 1);

evaluated: !re.isValid()

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:18

1-18

3302

qWarning("QString::lastIndexOf: invalid ~~QRegularExpresssion~~QRegularExpression object");

executed (the execution status of this line is deduced):

 QMessageLogger("tools/qstring.cpp", 3302, __PRETTY_FUNCTION__).warning("QString::lastIndexOf: invalid QRegularExpression object");

3303

return -1;

executed: return -1;

Execution Count:1

3304 } -

3305 -

3306

evaluated: (from < 0)

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:12

6-12

3307 -

3308

QRegularExpressionMatchIterator iterator = re.globalMatch(*this);

executed (the execution status of this line is deduced): QRegularExpressionMatchIterator iterator = re.globalMatch(*this);

3309

int lastIndex = -1;

executed (the execution status of this line is deduced): int lastIndex = -1;

3310

while (iterator.hasNext()) {

evaluated: iterator.hasNext()

TRUE	FALSE
yes Evaluation Count:34	yes Evaluation Count:13

13-34

3311

QRegularExpressionMatch match = iterator.next();

executed (the execution status of this line is deduced): QRegularExpressionMatch match = iterator.next();

3312

int start = match.capturedStart();

executed (the execution status of this line is deduced): int start = match.capturedStart();

3313

if (start < endpos)

evaluated: start < endpos

TRUE	FALSE
yes Evaluation Count:29	yes Evaluation Count:5

5-29

3314

lastIndex = start;

executed: lastIndex = start;

Execution Count:29

3315 else -

3316

break;

executed: break;

Execution Count:5

3317 } -

3318 -

3319

return lastIndex;

executed: return lastIndex;

Execution Count:18

3320 } -

3321 -

3322 /*! \overload contains() -

3323 \since 5.0 -

3324 -

3325 Returns true if the regular expression \a re matches somewhere in -

3326 this string; otherwise returns false. -

3327 */ -

3328 bool QString::contains(const QRegularExpression &re) const -

3329 { -

3330

QRegularExpressionMatch match = re.match(*this);

evaluated: !re.isValid()

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:5

1-5

3331

qWarning("QString::contains: invalid ~~QRegularExpresssion~~QRegularExpression object");

executed (the execution status of this line is deduced):

 QMessageLogger("tools/qstring.cpp", 3331, __PRETTY_FUNCTION__).warning("QString::contains: invalid QRegularExpression object");

3332

return false;

executed: return false;

Execution Count:1

3333 } -

3334

executed (the execution status of this line is deduced): QRegularExpressionMatch match = re.match(*this);

3335

return match.hasMatch();

executed: return match.hasMatch();

Execution Count:5

3336 } -

3337 -

3338 /*! -

3339 \overload count() -

3340 \since 5.0 -

3341 -

3342 Returns the number of times the regular expression \a re matches -

3343 in the string. -

3344 -

3345 This function counts overlapping matches, so in the example -

3346 below, there are four instances of "ana" or "ama": -

3347 -

3348 \snippet qstring/main.cpp 95 -

3349 */ -

3350 int QString::count(const QRegularExpression &re) const -

3351 { -

3352

while (index < len - 1) {

evaluated: !re.isValid()

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:2

1-2

3353

qWarning("QString::count: invalid ~~QRegularExpresssion~~QRegularExpression object");

executed (the execution status of this line is deduced):

 QMessageLogger("tools/qstring.cpp", 3353, __PRETTY_FUNCTION__).warning("QString::count: invalid QRegularExpression object");

3354

return 0;

executed: return 0;

Execution Count:1

3355 } -

3356

int count = 0;

executed (the execution status of this line is deduced): int count = 0;

3357

int index = -1;

executed (the execution status of this line is deduced): int index = -1;

3358

int len = length();

executed (the execution status of this line is deduced): int len = length();

3359

partially evaluated: index < len - 1

TRUE	FALSE
yes Evaluation Count:5	no Evaluation Count:0

0-5

3360

QRegularExpressionMatch match = re.match(*this, index + 1);

executed (the execution status of this line is deduced): QRegularExpressionMatch match = re.match(*this, index + 1);

3361

if (!match.hasMatch())

evaluated: !match.hasMatch()

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:3

2-3

3362

break;

executed: break;

Execution Count:2

3363

index = match.capturedStart();

executed (the execution status of this line is deduced): index = match.capturedStart();

3364

count++;

executed (the execution status of this line is deduced): count++;

3365