text/qcssparser.cpp

QString s = v.variant.toString();

executed: }

Execution Count:5492

5492

373 -

374 LengthData ValueExtractor::lengthValue(const Value& v) -

375 { -

376

executed (the execution status of this line is deduced): QString s = v.variant.toString();

377

s.reserve(s.length());

executed (the execution status of this line is deduced): s.reserve(s.length());

378

LengthData data;

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

379

data.unit = LengthData::None;

executed (the execution status of this line is deduced): data.unit = LengthData::None;

380

if (s.endsWith(QLatin1String("px"), Qt::CaseInsensitive))

evaluated: s.endsWith(QLatin1String("px"), Qt::CaseInsensitive)

TRUE	FALSE
yes Evaluation Count:189	yes Evaluation Count:6

6-189

381

data.unit = LengthData::Px;

executed: data.unit = LengthData::Px;

Execution Count:189

189

382

else if (s.endsWith(QLatin1String("ex"), Qt::CaseInsensitive))

partially evaluated: s.endsWith(QLatin1String("ex"), Qt::CaseInsensitive)

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

0-6

383

data.unit = LengthData::Ex;

never executed: data.unit = LengthData::Ex;

384

else if (s.endsWith(QLatin1String("em"), Qt::CaseInsensitive))

partially evaluated: s.endsWith(QLatin1String("em"), Qt::CaseInsensitive)

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

0-6

385

data.unit = LengthData::Em;

never executed: data.unit = LengthData::Em;

386 -

387

if (data.unit != LengthData::None)

evaluated: data.unit != LengthData::None

TRUE	FALSE
yes Evaluation Count:189	yes Evaluation Count:6

6-189

388

s.chop(2);

executed: s.chop(2);

Execution Count:189

189

389 -

390

data.number = s.toDouble();

executed (the execution status of this line is deduced): data.number = s.toDouble();

391

return data;

executed: return data;

Execution Count:195

195

392 } -

393 -

394 static int lengthValueFromData(const LengthData& data, const QFont& f) -

395 { -

396

if (data.unit == LengthData::Ex)

partially evaluated: data.unit == LengthData::Ex

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

0-1022

397

return qRound(QFontMetrics(f).xHeight() * data.number);

never executed: return qRound(QFontMetrics(f).xHeight() * data.number);

398

else if (data.unit == LengthData::Em)

partially evaluated: data.unit == LengthData::Em

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

0-1022

399

return qRound(QFontMetrics(f).height() * data.number);

never executed: return qRound(QFontMetrics(f).height() * data.number);

400

return qRound(data.number);

executed: return qRound(data.number);

Execution Count:1022

1022

401 } -

402 -

403 int ValueExtractor::lengthValue(const Declaration &decl) -

404 { -

405

if (decl.d->parsed.isValid())

partially evaluated: decl.d->parsed.isValid()

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

0-193

406

return lengthValueFromData(qvariant_cast<LengthData>(decl.d->parsed), f);

never executed: return lengthValueFromData(qvariant_cast<LengthData>(decl.d->parsed), f);

407

if (decl.d->values.count() < 1)

partially evaluated: decl.d->values.count() < 1

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

0-193

408

return 0;

never executed: return 0;

409

LengthData data = lengthValue(decl.d->values.at(0));

executed (the execution status of this line is deduced): LengthData data = lengthValue(decl.d->values.at(0));

410

decl.d->parsed = QVariant::fromValue<LengthData>(data);

executed (the execution status of this line is deduced): decl.d->parsed = QVariant::fromValue<LengthData>(data);

411

return lengthValueFromData(data,f);

executed: return lengthValueFromData(data,f);

Execution Count:193

193

412 } -

413 -

414 void ValueExtractor::lengthValues(const Declaration &decl, int *m) -

415 { -

416

QList<QVariant> v = decl.d->parsed.toList();

partially evaluated: decl.d->parsed.isValid()

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

0-1

417

never executed (the execution status of this line is deduced): QList<QVariant> v = decl.d->parsed.toList();

418

for (int i = 0; i < 4; i++)

never evaluated: i < 4

419

m[i] = lengthValueFromData(qvariant_cast<LengthData>(v.at(i)), f);

never executed: m[i] = lengthValueFromData(qvariant_cast<LengthData>(v.at(i)), f);

420

never executed: return;

421 } -

422 -

423

LengthData datas[4];

executed (the execution status of this line is deduced): LengthData datas[4];

424

for (i = 0; i < qMin(decl.d->values.count(), 4); i++)

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

425

evaluated: i < qMin(decl.d->values.count(), 4)

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

426

datas[i] = lengthValue(decl.d->values[i]);

executed: datas[i] = lengthValue(decl.d->values[i]);

Execution Count:1

427 -

428

if (i == 0) {

partially evaluated: i == 0

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

0-1

429

LengthData zero = {0.0, LengthData::None};

never executed (the execution status of this line is deduced): LengthData zero = {0.0, LengthData::None};

430

datas[0] = datas[1] = datas[2] = datas[3] = zero;

never executed (the execution status of this line is deduced): datas[0] = datas[1] = datas[2] = datas[3] = zero;

431

} else if (i == 1) {

never executed: }

partially evaluated: i == 1

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

0-1

432

datas[3] = datas[2] = datas[1] = datas[0];

executed (the execution status of this line is deduced): datas[3] = datas[2] = datas[1] = datas[0];

433

} else if (i == 2) {

executed: }

Execution Count:1

never evaluated: i == 2

0-1

434

datas[2] = datas[0];

never executed (the execution status of this line is deduced): datas[2] = datas[0];

435

datas[3] = datas[1];

never executed (the execution status of this line is deduced): datas[3] = datas[1];

436

} else if (i == 3) {

never executed: }

never evaluated: i == 3

437

datas[3] = datas[1];

never executed (the execution status of this line is deduced): datas[3] = datas[1];

438

for (i = 0; i < 4; i++) {

never executed: }

439 -

440

QList<QVariant> v;

executed (the execution status of this line is deduced): QList<QVariant> v;

441

evaluated: i < 4

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:1

1-4

442

v += QVariant::fromValue<LengthData>(datas[i]);

executed (the execution status of this line is deduced): v += QVariant::fromValue<LengthData>(datas[i]);

443

m[i] = lengthValueFromData(datas[i], f);

executed (the execution status of this line is deduced): m[i] = lengthValueFromData(datas[i], f);

444

executed: }

Execution Count:4

445

decl.d->parsed = v;

executed (the execution status of this line is deduced): decl.d->parsed = v;

446

executed: }

Execution Count:1

447 -

448 bool ValueExtractor::extractGeometry(int *w, int *h, int *minw, int *minh, int *maxw, int *maxh) -

449 { -

450

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

451

executed (the execution status of this line is deduced): bool hit = false;

452

evaluated: i < declarations.count()

TRUE	FALSE
yes Evaluation Count:2915	yes Evaluation Count:3726

2915-3726

453

case Width: *w = lengthValue(decl); break;

executed (the execution status of this line is deduced): const Declaration &decl = declarations.at(i);

454 switch (decl.d->propertyId) { -

455

never executed: break;

456

case Height: *h = lengthValue(decl); break;

never executed: break;

457

case MinimumWidth: *minw = lengthValue(decl); break;

never executed: break;

458

case MinimumHeight: *minh = lengthValue(decl); break;

never executed: break;

459

case MaximumWidth: *maxw = lengthValue(decl); break;

never executed: break;

460

case MaximumHeight: *maxh = lengthValue(decl); break;

never executed: break;

461

executed: continue;

Execution Count:2915

2915

462 } -

463

never executed (the execution status of this line is deduced): hit = true;

464

never executed: }

465 -

466

executed: return hit;

Execution Count:3726

3726

467 } -

468 -

469 bool ValueExtractor::extractPosition(int *left, int *top, int *right, int *bottom, QCss::Origin *origin, -

470 Qt::Alignment *position, QCss::PositionMode *mode, Qt::Alignment *textAlignment) -

471 { -

472

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

473

executed (the execution status of this line is deduced): bool hit = false;

474

evaluated: i < declarations.count()

TRUE	FALSE
yes Evaluation Count:2915	yes Evaluation Count:3726

2915-3726

475

case Left: *left = lengthValue(decl); break;

executed (the execution status of this line is deduced): const Declaration &decl = declarations.at(i);

476 switch (decl.d->propertyId) { -

477

never executed: break;

478

case Top: *top = lengthValue(decl); break;

never executed: break;

479

case Right: *right = lengthValue(decl); break;

never executed: break;

480

case Bottom: *bottom = lengthValue(decl); break;

never executed: break;

481

case QtOrigin: *origin = decl.originValue(); break;

never executed: break;

482

case QtPosition: *position = decl.alignmentValue(); break;

never executed: break;

483

case TextAlignment: *textAlignment = decl.alignmentValue(); break;

never executed: break;

484

case Position: *mode = decl.positionValue(); break;

never executed: break;

485

executed: continue;

Execution Count:2915

2915

486 } -

487

never executed (the execution status of this line is deduced): hit = true;

488

never executed: }

489 -

490

executed: return hit;

Execution Count:3726

3726

491 } -

492 -

493 bool ValueExtractor::extractBox(int *margins, int *paddings, int *spacing) -

494 { -

495

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

496

executed (the execution status of this line is deduced): bool hit = false;

497

evaluated: i < declarations.count()

TRUE	FALSE
yes Evaluation Count:3448	yes Evaluation Count:5492

3448-5492

498

case PaddingLeft: paddings[LeftEdge] = lengthValue(decl); break;

executed (the execution status of this line is deduced): const Declaration &decl = declarations.at(i);

499 switch (decl.d->propertyId) { -

500

executed: break;

Execution Count:1

501

case PaddingRight: paddings[RightEdge] = lengthValue(decl); break;

executed: break;

Execution Count:1

502

case PaddingTop: paddings[TopEdge] = lengthValue(decl); break;

executed: break;

Execution Count:1

503

case PaddingBottom: paddings[BottomEdge] = lengthValue(decl); break;

executed: break;

Execution Count:1

504

case Padding: lengthValues(decl, paddings); break;

executed: break;

Execution Count:1

505 -

506

case MarginLeft: margins[LeftEdge] = lengthValue(decl); break;

executed: break;

Execution Count:51

507

case MarginRight: margins[RightEdge] = lengthValue(decl); break;

executed: break;

Execution Count:44

508

case MarginTop: margins[TopEdge] = lengthValue(decl); break;

executed: break;

Execution Count:47

509

case MarginBottom: margins[BottomEdge] = lengthValue(decl); break;

executed: break;

Execution Count:45

510

case Margin: lengthValues(decl, margins); break;

never executed: break;

511

case QtSpacing: if (spacing) *spacing = lengthValue(decl); break;

never executed: *spacing = lengthValue(decl);

never executed: break;

never evaluated: spacing

512 -

513

executed: continue;

Execution Count:3256

3256

514 } -

515

executed (the execution status of this line is deduced): hit = true;

516

executed: }

Execution Count:192

192

517 -

518

int features = StyleFeature_None;

executed: return hit;

Execution Count:5492

5492

519 } -

520 -

521 int ValueExtractor::extractStyleFeatures() -

522 { -

523

executed (the execution status of this line is deduced): int features = StyleFeature_None;

524

evaluated: i < declarations.count()

TRUE	FALSE
yes Evaluation Count:2915	yes Evaluation Count:3726

2915-3726

525

if (decl.d->propertyId == QtStyleFeatures)

executed (the execution status of this line is deduced): const Declaration &decl = declarations.at(i);

526

evaluated: decl.d->propertyId == QtStyleFeatures

TRUE	FALSE
yes Evaluation Count:29	yes Evaluation Count:2886

29-2886

527

features = decl.styleFeaturesValue();

executed: features = decl.styleFeaturesValue();

Execution Count:29

528

executed: }

Execution Count:2915

2915

529

return features;

executed: return features;

Execution Count:3726

3726

530 } -

531 -

532 QSize ValueExtractor::sizeValue(const Declaration &decl) -

533 { -

534

QList<QVariant> v = decl.d->parsed.toList();

never evaluated: decl.d->parsed.isValid()

535

never executed (the execution status of this line is deduced): QList<QVariant> v = decl.d->parsed.toList();

536

return QSize(lengthValueFromData(qvariant_cast<LengthData>(v.at(0)), f),

never executed:

return QSize(lengthValueFromData(qvariant_cast<LengthData>(v.at(0)), f), lengthValueFromData(qvariant_cast<LengthData>(v.at(1)), f));

537

lengthValueFromData(qvariant_cast<LengthData>(v.at(1)), f));

never executed:

return QSize(lengthValueFromData(qvariant_cast<LengthData>(v.at(0)), f), lengthValueFromData(qvariant_cast<LengthData>(v.at(1)), f));

538 } -

539 -

540

LengthData x[2] = { {0, LengthData::None }, {0, LengthData::None} };

never executed (the execution status of this line is deduced): LengthData x[2] = { {0, LengthData::None }, {0, LengthData::None} };

541

if (decl.d->values.count() > 0)

never evaluated: decl.d->values.count() > 0

542

x[0] = lengthValue(decl.d->values.at(0));

never executed: x[0] = lengthValue(decl.d->values.at(0));

543

if (decl.d->values.count() > 1)

never evaluated: decl.d->values.count() > 1

544

x[1] = lengthValue(decl.d->values.at(1));

never executed: x[1] = lengthValue(decl.d->values.at(1));

545 else -

546

x[1] = x[0];

never executed: x[1] = x[0];

547

QList<QVariant> v;

never executed (the execution status of this line is deduced): QList<QVariant> v;

548

v << QVariant::fromValue<LengthData>(x[0]) << QVariant::fromValue<LengthData>(x[1]);

never executed (the execution status of this line is deduced): v << QVariant::fromValue<LengthData>(x[0]) << QVariant::fromValue<LengthData>(x[1]);

549

decl.d->parsed = v;

never executed (the execution status of this line is deduced): decl.d->parsed = v;

550

return QSize(lengthValueFromData(x[0], f), lengthValueFromData(x[1], f));

never executed: return QSize(lengthValueFromData(x[0], f), lengthValueFromData(x[1], f));

551 } -

552 -

553 void ValueExtractor::sizeValues(const Declaration &decl, QSize *radii) -

554 { -

555

radii[0] = sizeValue(decl);

never executed (the execution status of this line is deduced): radii[0] = sizeValue(decl);

556

for (int i = 1; i < 4; i++)

never evaluated: i < 4

557

radii[i] = radii[0];

never executed: radii[i] = radii[0];

558

never executed: }

559 -

560 bool ValueExtractor::extractBorder(int *borders, QBrush *colors, BorderStyle *styles, -

561 QSize *radii) -

562 { -

563

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

564

executed (the execution status of this line is deduced): bool hit = false;

565

evaluated: i < declarations.count()

TRUE	FALSE
yes Evaluation Count:2915	yes Evaluation Count:3726

2915-3726

566

case BorderLeftWidth: borders[LeftEdge] = lengthValue(decl); break;

executed (the execution status of this line is deduced): const Declaration &decl = declarations.at(i);

567 switch (decl.d->propertyId) { -

568

never executed: break;

569

case BorderRightWidth: borders[RightEdge] = lengthValue(decl); break;

never executed: break;

570

case BorderTopWidth: borders[TopEdge] = lengthValue(decl); break;

never executed: break;

571

case BorderBottomWidth: borders[BottomEdge] = lengthValue(decl); break;

never executed: break;

572

case BorderWidth: lengthValues(decl, borders); break;

never executed: break;

573 -

574

case BorderLeftColor: colors[LeftEdge] = decl.brushValue(pal); break;

never executed: break;

575

case BorderRightColor: colors[RightEdge] = decl.brushValue(pal); break;

never executed: break;

576

case BorderTopColor: colors[TopEdge] = decl.brushValue(pal); break;

never executed: break;

577

case BorderBottomColor: colors[BottomEdge] = decl.brushValue(pal); break;

never executed: break;

578

case BorderColor: decl.brushValues(colors, pal); break;

never executed: break;

579 -

580

case BorderTopStyle: styles[TopEdge] = decl.styleValue(); break;

never executed: break;

581

case BorderBottomStyle: styles[BottomEdge] = decl.styleValue(); break;

never executed: break;

582

case BorderLeftStyle: styles[LeftEdge] = decl.styleValue(); break;

never executed: break;

583

case BorderRightStyle: styles[RightEdge] = decl.styleValue(); break;

never executed: break;

584

case BorderStyles: decl.styleValues(styles); break;

executed: break;

Execution Count:21

585 -

586

case BorderTopLeftRadius: radii[0] = sizeValue(decl); break;

never executed: break;

587

case BorderTopRightRadius: radii[1] = sizeValue(decl); break;

never executed: break;

588

case BorderBottomLeftRadius: radii[2] = sizeValue(decl); break;

never executed: break;

589

case BorderBottomRightRadius: radii[3] = sizeValue(decl); break;

never executed: break;

590

case BorderRadius: sizeValues(decl, radii); break;

never executed: break;

591 -

592 case BorderLeft: -

593

borderValue(decl, &borders[LeftEdge], &styles[LeftEdge], &colors[LeftEdge]);

never executed (the execution status of this line is deduced): borderValue(decl, &borders[LeftEdge], &styles[LeftEdge], &colors[LeftEdge]);

594

borderValue(decl, &borders[TopEdge], &styles[TopEdge], &colors[TopEdge]);

never executed: break;

595 case BorderTop: -

596

never executed (the execution status of this line is deduced): borderValue(decl, &borders[TopEdge], &styles[TopEdge], &colors[TopEdge]);

597

borderValue(decl, &borders[RightEdge], &styles[RightEdge], &colors[RightEdge]);

never executed: break;

598 case BorderRight: -

599

never executed (the execution status of this line is deduced): borderValue(decl, &borders[RightEdge], &styles[RightEdge], &colors[RightEdge]);

600

borderValue(decl, &borders[BottomEdge], &styles[BottomEdge], &colors[BottomEdge]);

never executed: break;

601 case BorderBottom: -

602

never executed (the execution status of this line is deduced): borderValue(decl, &borders[BottomEdge], &styles[BottomEdge], &colors[BottomEdge]);

603

borderValue(decl, &borders[LeftEdge], &styles[LeftEdge], &colors[LeftEdge]);

never executed: break;

604 case Border: -

605

executed (the execution status of this line is deduced): borderValue(decl, &borders[LeftEdge], &styles[LeftEdge], &colors[LeftEdge]);

606

borders[TopEdge] = borders[RightEdge] = borders[BottomEdge] = borders[LeftEdge];

executed (the execution status of this line is deduced): borders[TopEdge] = borders[RightEdge] = borders[BottomEdge] = borders[LeftEdge];

607

styles[TopEdge] = styles[RightEdge] = styles[BottomEdge] = styles[LeftEdge];

executed (the execution status of this line is deduced): styles[TopEdge] = styles[RightEdge] = styles[BottomEdge] = styles[LeftEdge];

608

colors[TopEdge] = colors[RightEdge] = colors[BottomEdge] = colors[LeftEdge];

executed (the execution status of this line is deduced): colors[TopEdge] = colors[RightEdge] = colors[BottomEdge] = colors[LeftEdge];

609

executed: break;

Execution Count:1216

1216

610 -

611

executed: continue;

Execution Count:1678

1678

612 } -

613

executed (the execution status of this line is deduced): hit = true;

614

executed: }

Execution Count:1237

1237

615 -

616

executed: return hit;

Execution Count:3726

3726

617 } -

618 -

619 bool ValueExtractor::extractOutline(int *borders, QBrush *colors, BorderStyle *styles, -

620 QSize *radii, int *offsets) -

621 { -

622

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

623

executed (the execution status of this line is deduced): bool hit = false;

624

evaluated: i < declarations.count()

TRUE	FALSE
yes Evaluation Count:2915	yes Evaluation Count:3726

2915-3726

625

case OutlineWidth: lengthValues(decl, borders); break;

executed (the execution status of this line is deduced): const Declaration &decl = declarations.at(i);

626 switch (decl.d->propertyId) { -

627

never executed: break;

628

case OutlineColor: decl.brushValues(colors, pal); break;

never executed: break;

629

case OutlineStyle: decl.styleValues(styles); break;

never executed: break;

630 -

631

case OutlineTopLeftRadius: radii[0] = sizeValue(decl); break;

never executed: break;

632

case OutlineTopRightRadius: radii[1] = sizeValue(decl); break;

never executed: break;

633

case OutlineBottomLeftRadius: radii[2] = sizeValue(decl); break;

never executed: break;

634

case OutlineBottomRightRadius: radii[3] = sizeValue(decl); break;

never executed: break;

635

case OutlineRadius: sizeValues(decl, radii); break;

never executed: break;

636

case OutlineOffset: lengthValues(decl, offsets); break;

never executed: break;

637 -

638 case Outline: -

639

borderValue(decl, &borders[LeftEdge], &styles[LeftEdge], &colors[LeftEdge]);

never executed (the execution status of this line is deduced): borderValue(decl, &borders[LeftEdge], &styles[LeftEdge], &colors[LeftEdge]);

640

borders[TopEdge] = borders[RightEdge] = borders[BottomEdge] = borders[LeftEdge];

never executed (the execution status of this line is deduced): borders[TopEdge] = borders[RightEdge] = borders[BottomEdge] = borders[LeftEdge];

641

styles[TopEdge] = styles[RightEdge] = styles[BottomEdge] = styles[LeftEdge];

never executed (the execution status of this line is deduced): styles[TopEdge] = styles[RightEdge] = styles[BottomEdge] = styles[LeftEdge];

642

colors[TopEdge] = colors[RightEdge] = colors[BottomEdge] = colors[LeftEdge];

never executed (the execution status of this line is deduced): colors[TopEdge] = colors[RightEdge] = colors[BottomEdge] = colors[LeftEdge];

643

never executed: break;

644 -

645

executed: continue;

Execution Count:2915

2915

646 } -

647

never executed (the execution status of this line is deduced): hit = true;

648

never executed: }

649 -

650

Qt::Alignment a[2] = { 0, 0 };

executed: return hit;

Execution Count:3726

3726

651 } -

652 -

653 static Qt::Alignment parseAlignment(const QCss::Value *values, int count) -

654 { -

655

never executed (the execution status of this line is deduced): Qt::Alignment a[2] = { 0, 0 };

656

for (int i = 0; i < qMin(2, count); i++) {

never evaluated: i < qMin(2, count)

657

if (values[i].type != Value::KnownIdentifier)

never evaluated: values[i].type != Value::KnownIdentifier

658

case Value_Left: a[i] = Qt::AlignLeft; break;

never executed: break;

659 switch (values[i].variant.toInt()) { -

660

never executed: break;

661

case Value_Right: a[i] = Qt::AlignRight; break;

never executed: break;

662

case Value_Top: a[i] = Qt::AlignTop; break;

never executed: break;

663

case Value_Bottom: a[i] = Qt::AlignBottom; break;

never executed: break;

664

case Value_Center: a[i] = Qt::AlignCenter; break;

never executed: break;

665

never executed: break;

666 } -

667

if (a[0] == Qt::AlignCenter && a[1] != 0 && a[1] != Qt::AlignCenter)

never executed: }

668 -

669

never evaluated: a[0] == Qt::AlignCenter

never evaluated: a[1] != 0

never evaluated: a[1] != Qt::AlignCenter

670

a[0] = (a[1] == Qt::AlignLeft || a[1] == Qt::AlignRight) ? Qt::AlignVCenter : Qt::AlignHCenter;

never executed: a[0] = (a[1] == Qt::AlignLeft || a[1] == Qt::AlignRight) ? Qt::AlignVCenter : Qt::AlignHCenter;

never evaluated: a[1] == Qt::AlignLeft

never evaluated: a[1] == Qt::AlignRight

671

if ((a[1] == 0 || a[1] == Qt::AlignCenter) && a[0] != Qt::AlignCenter)

never evaluated: a[1] == 0

never evaluated: a[1] == Qt::AlignCenter

never evaluated: a[0] != Qt::AlignCenter

672

a[1] = (a[0] == Qt::AlignLeft || a[0] == Qt::AlignRight) ? Qt::AlignVCenter : Qt::AlignHCenter;

never executed: a[1] = (a[0] == Qt::AlignLeft || a[0] == Qt::AlignRight) ? Qt::AlignVCenter : Qt::AlignHCenter;

never evaluated: a[0] == Qt::AlignLeft

never evaluated: a[0] == Qt::AlignRight

673

return a[0] | a[1];

never executed: return a[0] | a[1];

674 } -

675 -

676 static ColorData parseColorValue(QCss::Value v) -

677 { -

678

if (v.type == Value::Identifier || v.type == Value::String) {

evaluated: v.type == Value::Identifier

TRUE	FALSE
yes Evaluation Count:48	yes Evaluation Count:16

partially evaluated: v.type == Value::String

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

0-48

679

v.variant.convert(QVariant::Color);

executed (the execution status of this line is deduced): v.variant.convert(QVariant::Color);

680

v.type = Value::Color;

executed (the execution status of this line is deduced): v.type = Value::Color;

681

if (v.type == Value::Color)

executed: }

Execution Count:48

682 -

683

evaluated: v.type == Value::Color

TRUE	FALSE
yes Evaluation Count:63	yes Evaluation Count:1

1-63

684

return qvariant_cast<QColor>(v.variant);

executed: return qvariant_cast<QColor>(v.variant);

Execution Count:63

685 -

686

if (v.type == Value::KnownIdentifier && v.variant.toInt() == Value_Transparent)

partially evaluated: v.type == Value::KnownIdentifier

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

never evaluated: v.variant.toInt() == Value_Transparent

0-1

687

return QColor(Qt::transparent);

never executed: return QColor(Qt::transparent);

688 -

689

if (v.type != Value::Function)

partially evaluated: v.type != Value::Function

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

0-1

690

QStringList lst = v.variant.toStringList();

never executed: return ColorData();

691 -

692

executed (the execution status of this line is deduced): QStringList lst = v.variant.toStringList();

693

if (lst.count() != 2)

partially evaluated: lst.count() != 2

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

0-1

694

if ((lst.at(0).compare(QLatin1String("palette"), Qt::CaseInsensitive)) == 0) {

never executed: return ColorData();

695 -

696

partially evaluated: (lst.at(0).compare(QLatin1String("palette"), Qt::CaseInsensitive)) == 0

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

0-1

697

int role = findKnownValue(lst.at(1).trimmed(), values, NumKnownValues);

never executed (the execution status of this line is deduced): int role = findKnownValue(lst.at(1).trimmed(), values, NumKnownValues);

698

if (role >= Value_FirstColorRole && role <= Value_LastColorRole)

never evaluated: role >= Value_FirstColorRole

never evaluated: role <= Value_LastColorRole

699

return (QPalette::ColorRole)(role-Value_FirstColorRole);

never executed: return (QPalette::ColorRole)(role-Value_FirstColorRole);

700 -

701

bool rgb = lst.at(0).startsWith(QLatin1String("rgb"));

never executed: return ColorData();

702 } -

703 -

704

executed (the execution status of this line is deduced): bool rgb = lst.at(0).startsWith(QLatin1String("rgb"));

705

bool rgba = lst.at(0).startsWith(QLatin1String("rgba"));

executed (the execution status of this line is deduced): bool rgba = lst.at(0).startsWith(QLatin1String("rgba"));

706 -

707

Parser p(lst.at(1));

executed (the execution status of this line is deduced): Parser p(lst.at(1));

708

if (!p.testExpr())

partially evaluated: !p.testExpr()

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

0-1

709

QVector<QCss::Value> colorDigits;

never executed: return ColorData();

710 -

711

executed (the execution status of this line is deduced): QVector<QCss::Value> colorDigits;

712

if (!p.parseExpr(&colorDigits))

partially evaluated: !p.parseExpr(&colorDigits)

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

0-1

713

for (int i = 0; i < qMin(colorDigits.count(), 7); i += 2) {

never executed: return ColorData();

714 -

715

evaluated: i < qMin(colorDigits.count(), 7)

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:1

1-3

716

if (colorDigits.at(i).type == Value::Percentage) {

partially evaluated: colorDigits.at(i).type == Value::Percentage

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

0-3

717

colorDigits[i].variant = colorDigits.at(i).variant.toReal() * (255. / 100.);

never executed (the execution status of this line is deduced): colorDigits[i].variant = colorDigits.at(i).variant.toReal() * (255. / 100.);

718

colorDigits[i].type = Value::Number;

never executed (the execution status of this line is deduced): colorDigits[i].type = Value::Number;

719

} else if (colorDigits.at(i).type != Value::Number) {

never executed: }

partially evaluated: colorDigits.at(i).type != Value::Number

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

0-3

720

int v1 = colorDigits.at(0).variant.toInt();

never executed: return ColorData();

721 } -

722 } -

723 -

724

executed (the execution status of this line is deduced): int v1 = colorDigits.at(0).variant.toInt();

725

int v2 = colorDigits.at(2).variant.toInt();

executed (the execution status of this line is deduced): int v2 = colorDigits.at(2).variant.toInt();

726

int v3 = colorDigits.at(4).variant.toInt();

executed (the execution status of this line is deduced): int v3 = colorDigits.at(4).variant.toInt();

727

int alpha = 255;

executed (the execution status of this line is deduced): int alpha = 255;

728

if (colorDigits.count() >= 7) {

partially evaluated: colorDigits.count() >= 7

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

0-1

729

int alphaValue = colorDigits.at(6).variant.toInt();

never executed (the execution status of this line is deduced): int alphaValue = colorDigits.at(6).variant.toInt();

730

if (rgba && alphaValue <= 1)

never evaluated: rgba

never evaluated: alphaValue <= 1

731

alpha = colorDigits.at(6).variant.toReal() * 255.;

never executed: alpha = colorDigits.at(6).variant.toReal() * 255.;

732 else -

733

alpha = alphaValue;

never executed: alpha = alphaValue;

734 } -

735 -

736

return rgb ? QColor::fromRgb(v1, v2, v3, alpha)

executed: return rgb ? QColor::fromRgb(v1, v2, v3, alpha) : QColor::fromHsv(v1, v2, v3, alpha);

Execution Count:1

737

: QColor::fromHsv(v1, v2, v3, alpha);

executed: return rgb ? QColor::fromRgb(v1, v2, v3, alpha) : QColor::fromHsv(v1, v2, v3, alpha);

Execution Count:1

738 } -

739 -

740 static QColor colorFromData(const ColorData& c, const QPalette &pal) -

741 { -

742

if (c.type == ColorData::Color) {

never evaluated: c.type == ColorData::Color

743

return c.color;

never executed: return c.color;

744

} else if (c.type == ColorData::Role) {

never evaluated: c.type == ColorData::Role

745

return pal.color(c.role);

never executed: return pal.color(c.role);

746 } -

747

return QColor();

never executed: return QColor();

748 } -

749 -

750 static BrushData parseBrushValue(const QCss::Value &v, const QPalette &pal) -

751 { -

752

ColorData c = parseColorValue(v);

never executed (the execution status of this line is deduced): ColorData c = parseColorValue(v);

753

if (c.type == ColorData::Color) {

partially evaluated: c.type == ColorData::Color

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

0-50

754

return QBrush(c.color);

executed: return QBrush(c.color);

Execution Count:50

755

} else if (c.type == ColorData::Role) {

never evaluated: c.type == ColorData::Role

756

return c.role;

never executed: return c.role;

757 } -

758 -

759

if (v.type != Value::Function)

never evaluated: v.type != Value::Function

760

QStringList lst = v.variant.toStringList();

never executed: return BrushData();

761 -

762

never executed (the execution status of this line is deduced): QStringList lst = v.variant.toStringList();

763

if (lst.count() != 2)

never evaluated: lst.count() != 2

764

gradFuncs << QLatin1String("qlineargradient") << QLatin1String("qradialgradient") << QLatin1String("qconicalgradient") << QLatin1String("qgradient");

never executed: return BrushData();

765 -

766

QStringList gradFuncs;

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

767

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

 gradFuncs << QLatin1String("qlineargradient") << QLatin1String("qradialgradient") << QLatin1String("qconicalgradient") << QLatin1String("qgradient");

768

int gradType = -1;

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

769 -

770

if ((gradType = gradFuncs.indexOf(lst.at(0).toLower())) == -1)

never evaluated: (gradType = gradFuncs.indexOf(lst.at(0).toLower())) == -1

771

QHash<QString, qreal> vars;

never executed: return BrushData();

772 -

773

never executed (the execution status of this line is deduced): QHash<QString, qreal> vars;

774

QVector<QGradientStop> stops;

never executed (the execution status of this line is deduced): QVector<QGradientStop> stops;

775 -

776

int spread = -1;

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

777

QStringList spreads;

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

778

spreads << QLatin1String("pad") << QLatin1String("reflect") << QLatin1String("repeat");

never executed (the execution status of this line is deduced): spreads << QLatin1String("pad") << QLatin1String("reflect") << QLatin1String("repeat");

779 -

780

bool dependsOnThePalette = false;

never executed (the execution status of this line is deduced): bool dependsOnThePalette = false;

781

Parser parser(lst.at(1));

never executed (the execution status of this line is deduced): Parser parser(lst.at(1));

782

while (parser.hasNext()) {

never evaluated: parser.hasNext()

783

never executed (the execution status of this line is deduced): parser.skipSpace();

784

if (!parser.test(IDENT))

never evaluated: !parser.test(IDENT)

785

QString attr = parser.lexem();

never executed: return BrushData();

786

never executed (the execution status of this line is deduced): QString attr = parser.lexem();

787

never executed (the execution status of this line is deduced): parser.skipSpace();

788

if (!parser.test(COLON))

never evaluated: !parser.test(COLON)

789

never executed: return BrushData();

790

if (attr.compare(QLatin1String("stop"), Qt::CaseInsensitive) == 0) {

never executed (the execution status of this line is deduced): parser.skipSpace();

791

never evaluated: attr.compare(QLatin1String("stop"), Qt::CaseInsensitive) == 0

792

QCss::Value stop, color;

never executed (the execution status of this line is deduced): QCss::Value stop, color;

793

parser.next();

never executed (the execution status of this line is deduced): parser.next();

794

if (!parser.parseTerm(&stop)) return BrushData();

never executed: return BrushData();

never evaluated: !parser.parseTerm(&stop)

795

if (!parser.parseTerm(&color)) return BrushData();

never executed (the execution status of this line is deduced): parser.skipSpace();

796

parser.next();

never executed (the execution status of this line is deduced): parser.next();

797

never executed: return BrushData();

never evaluated: !parser.parseTerm(&color)

798

ColorData cd = parseColorValue(color);

never executed (the execution status of this line is deduced): ColorData cd = parseColorValue(color);

799

if(cd.type == ColorData::Role)

never evaluated: cd.type == ColorData::Role

800

dependsOnThePalette = true;

never executed: dependsOnThePalette = true;

801

stops.append(QGradientStop(stop.variant.toReal(), colorFromData(cd, pal)));

never executed (the execution status of this line is deduced): stops.append(QGradientStop(stop.variant.toReal(), colorFromData(cd, pal)));

never executed: }

never executed (the execution status of this line is deduced): parser.next();

804

QCss::Value value;

never executed (the execution status of this line is deduced): QCss::Value value;

805

(void)parser.parseTerm(&value);

never executed (the execution status of this line is deduced): (void)parser.parseTerm(&value);

806

if (attr.compare(QLatin1String("spread"), Qt::CaseInsensitive) == 0) {

never evaluated: attr.compare(QLatin1String("spread"), Qt::CaseInsensitive) == 0

807

spread = spreads.indexOf(value.variant.toString());

never executed (the execution status of this line is deduced): spread = spreads.indexOf(value.variant.toString());

808

vars[attr] = value.variant.toReal();

never executed: }

809

never executed (the execution status of this line is deduced): vars[attr] = value.variant.toReal();

810

never executed: }

811 } -

812

(void)parser.test(COMMA);

never executed (the execution status of this line is deduced): parser.skipSpace();

813

never executed (the execution status of this line is deduced): (void)parser.test(COMMA);

814

QLinearGradient lg(vars.value(QLatin1String("x1")), vars.value(QLatin1String("y1")),

never executed: }

815 -

816

if (gradType == 0) {

never evaluated: gradType == 0

817

never executed (the execution status of this line is deduced): QLinearGradient lg(vars.value(QLatin1String("x1")), vars.value(QLatin1String("y1")),

818

vars.value(QLatin1String("x2")), vars.value(QLatin1String("y2")));

never executed (the execution status of this line is deduced): vars.value(QLatin1String("x2")), vars.value(QLatin1String("y2")));

819

lg.setCoordinateMode(QGradient::ObjectBoundingMode);

never executed (the execution status of this line is deduced): lg.setCoordinateMode(QGradient::ObjectBoundingMode);

820

lg.setStops(stops);

never executed (the execution status of this line is deduced): lg.setStops(stops);

821

if (spread != -1)

never evaluated: spread != -1

822

lg.setSpread(QGradient::Spread(spread));

never executed: lg.setSpread(QGradient::Spread(spread));

823

BrushData bd = QBrush(lg);

never executed (the execution status of this line is deduced): BrushData bd = QBrush(lg);

824

if (dependsOnThePalette)

never evaluated: dependsOnThePalette

825

bd.type = BrushData::DependsOnThePalette;

never executed: bd.type = BrushData::DependsOnThePalette;

826

return bd;

never executed: return bd;

827 } -

828 -

829

if (gradType == 1) {

never evaluated: gradType == 1

830

QRadialGradient rg(vars.value(QLatin1String("cx")), vars.value(QLatin1String("cy")),

never executed (the execution status of this line is deduced): QRadialGradient rg(vars.value(QLatin1String("cx")), vars.value(QLatin1String("cy")),

831

vars.value(QLatin1String("radius")), vars.value(QLatin1String("fx")),

never executed (the execution status of this line is deduced): vars.value(QLatin1String("radius")), vars.value(QLatin1String("fx")),

832

vars.value(QLatin1String("fy")));

never executed (the execution status of this line is deduced): vars.value(QLatin1String("fy")));

833

rg.setCoordinateMode(QGradient::ObjectBoundingMode);

never executed (the execution status of this line is deduced): rg.setCoordinateMode(QGradient::ObjectBoundingMode);

834

rg.setStops(stops);

never executed (the execution status of this line is deduced): rg.setStops(stops);

835

if (spread != -1)

never evaluated: spread != -1

836

rg.setSpread(QGradient::Spread(spread));

never executed: rg.setSpread(QGradient::Spread(spread));

837

BrushData bd = QBrush(rg);

never executed (the execution status of this line is deduced): BrushData bd = QBrush(rg);

838

if (dependsOnThePalette)

never evaluated: dependsOnThePalette

839

bd.type = BrushData::DependsOnThePalette;

never executed: bd.type = BrushData::DependsOnThePalette;

840

return bd;

never executed: return bd;

841 } -

842 -

843

if (gradType == 2) {

never evaluated: gradType == 2

844

QConicalGradient cg(vars.value(QLatin1String("cx")), vars.value(QLatin1String("cy")),

never executed (the execution status of this line is deduced): QConicalGradient cg(vars.value(QLatin1String("cx")), vars.value(QLatin1String("cy")),

845

vars.value(QLatin1String("angle")));

never executed (the execution status of this line is deduced): vars.value(QLatin1String("angle")));

846

cg.setCoordinateMode(QGradient::ObjectBoundingMode);

never executed (the execution status of this line is deduced): cg.setCoordinateMode(QGradient::ObjectBoundingMode);

847

cg.setStops(stops);

never executed (the execution status of this line is deduced): cg.setStops(stops);

848

if (spread != -1)

never evaluated: spread != -1

849

cg.setSpread(QGradient::Spread(spread));

never executed: cg.setSpread(QGradient::Spread(spread));

850

BrushData bd = QBrush(cg);

never executed (the execution status of this line is deduced): BrushData bd = QBrush(cg);

851

if (dependsOnThePalette)

never evaluated: dependsOnThePalette

852

bd.type = BrushData::DependsOnThePalette;

never executed: bd.type = BrushData::DependsOnThePalette;

853

return bd;

never executed: return bd;

854 } -

855 -

856

if (c.type == BrushData::Role) {

never executed: return BrushData();

857 } -

858 -

859 static QBrush brushFromData(const BrushData& c, const QPalette &pal) -

860 { -

861

partially evaluated: c.type == BrushData::Role

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

0-8

862

return pal.color(c.role);

never executed: return pal.color(c.role);

863 } else { -

864

return c.brush;

executed: return c.brush;

Execution Count:8

865 } -

866 } -

867 -

868 static BorderStyle parseStyleValue(QCss::Value v) -

869 { -

870

if (v.type == Value::KnownIdentifier) {

partially evaluated: v.type == Value::KnownIdentifier

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

0-416

871 switch (v.variant.toInt()) { -

872 case Value_None: -

873

return BorderStyle_None;

executed: return BorderStyle_None;

Execution Count:1

874 case Value_Dotted: -

875

return BorderStyle_Dotted;

never executed: return BorderStyle_Dotted;

876 case Value_Dashed: -

877

return BorderStyle_Dashed;

never executed: return BorderStyle_Dashed;

878 case Value_Solid: -

879

return BorderStyle_Solid;

executed: return BorderStyle_Solid;

Execution Count:4

880 case Value_Double: -

881

return BorderStyle_Double;

never executed: return BorderStyle_Double;

882 case Value_DotDash: -

883

return BorderStyle_DotDash;

never executed: return BorderStyle_DotDash;

884 case Value_DotDotDash: -

885

return BorderStyle_DotDotDash;

never executed: return BorderStyle_DotDotDash;

886 case Value_Groove: -

887

return BorderStyle_Groove;

never executed: return BorderStyle_Groove;

888 case Value_Ridge: -

889

return BorderStyle_Ridge;

never executed: return BorderStyle_Ridge;

890 case Value_Inset: -

891

return BorderStyle_Inset;

never executed: return BorderStyle_Inset;

892 case Value_Outset: -

893

return BorderStyle_Outset;

never executed: return BorderStyle_Outset;

894 case Value_Native: -

895

return BorderStyle_Native;

executed: return BorderStyle_Native;

Execution Count:411

411

896 default: -

897

never executed: break;

898 } -

899

return BorderStyle_Unknown;

never executed: }

900 -

901

never executed: return BorderStyle_Unknown;

902 } -

903 -

904 void ValueExtractor::borderValue(const Declaration &decl, int *width, QCss::BorderStyle *style, QBrush *color) -

905 { -

906

BorderData data = qvariant_cast<BorderData>(decl.d->parsed);

evaluated: decl.d->parsed.isValid()

TRUE	FALSE
yes Evaluation Count:824	yes Evaluation Count:392

392-824

907

executed (the execution status of this line is deduced): BorderData data = qvariant_cast<BorderData>(decl.d->parsed);

908

*width = lengthValueFromData(data.width, f);

executed (the execution status of this line is deduced): *width = lengthValueFromData(data.width, f);

909

*style = data.style;

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

910

*color = data.color.type != BrushData::Invalid ? brushFromData(data.color, pal) : QBrush(QColor());

partially evaluated: data.color.type != BrushData::Invalid

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

0-824

911

*style = BorderStyle_None;

executed: return;

Execution Count:824

824

912 } -

913 -

914

*width = 0;

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

915

executed (the execution status of this line is deduced): *style = BorderStyle_None;

916

*color = QColor();

executed (the execution status of this line is deduced): *color = QColor();

917 -

918

if (decl.d->values.isEmpty())

partially evaluated: decl.d->values.isEmpty()

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

0-392

919

data.width.unit = LengthData::None;

never executed: return;

920 -

921

BorderData data;

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

922

data.width.number = 0;

executed (the execution status of this line is deduced): data.width.number = 0;

923

executed (the execution status of this line is deduced): data.width.unit = LengthData::None;

924

data.style = BorderStyle_None;

executed (the execution status of this line is deduced): data.style = BorderStyle_None;

925 -

926

if (decl.d->values.at(i).type == Value::Length || decl.d->values.at(i).type == Value::Number) {

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

927

evaluated: decl.d->values.at(i).type == Value::Length

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:391

partially evaluated: decl.d->values.at(i).type == Value::Number

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

0-391

928

data.width = lengthValue(decl.d->values.at(i));

executed (the execution status of this line is deduced): data.width = lengthValue(decl.d->values.at(i));

929

*width = lengthValueFromData(data.width, f);

executed (the execution status of this line is deduced): *width = lengthValueFromData(data.width, f);

930

if (++i >= decl.d->values.count()) {

partially evaluated: ++i >= decl.d->values.count()

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

0-1

931

decl.d->parsed = QVariant::fromValue<BorderData>(data);

never executed (the execution status of this line is deduced): decl.d->parsed = QVariant::fromValue<BorderData>(data);

932

never executed: return;

933 } -

934

data.style = parseStyleValue(decl.d->values.at(i));

executed: }

Execution Count:1

935 -

936

executed (the execution status of this line is deduced): data.style = parseStyleValue(decl.d->values.at(i));

937

if (data.style != BorderStyle_Unknown) {

partially evaluated: data.style != BorderStyle_Unknown

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

0-392

938

*style = data.style;

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

939

if (++i >= decl.d->values.count()) {

partially evaluated: ++i >= decl.d->values.count()

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

0-392

940

decl.d->parsed = QVariant::fromValue<BorderData>(data);

executed (the execution status of this line is deduced): decl.d->parsed = QVariant::fromValue<BorderData>(data);

941

executed: return;

Execution Count:392

392

942 } -

943

data.style = BorderStyle_None;

never executed: }

944

never executed (the execution status of this line is deduced): data.style = BorderStyle_None;

945

data.color = parseBrushValue(decl.d->values.at(i), pal);

never executed: }

946 -

947

never executed (the execution status of this line is deduced): data.color = parseBrushValue(decl.d->values.at(i), pal);

948

*color = brushFromData(data.color, pal);

never executed (the execution status of this line is deduced): *color = brushFromData(data.color, pal);

949

if (data.color.type != BrushData::DependsOnThePalette)

never evaluated: data.color.type != BrushData::DependsOnThePalette

950

decl.d->parsed = QVariant::fromValue<BorderData>(data);

never executed: decl.d->parsed = QVariant::fromValue<BorderData>(data);

951

*alignment = Qt::AlignTop | Qt::AlignLeft;

never executed: }

952 -

953 static void parseShorthandBackgroundProperty(const QVector<QCss::Value> &values, BrushData *brush, QString *image, Repeat *repeat, Qt::Alignment *alignment, const QPalette &pal) -

954 { -

955

*brush = BrushData();

executed (the execution status of this line is deduced): *brush = BrushData();

956

*image = QString();

executed (the execution status of this line is deduced): *image = QString();

957

*repeat = Repeat_XY;

executed (the execution status of this line is deduced): *repeat = Repeat_XY;

958

executed (the execution status of this line is deduced): *alignment = Qt::AlignTop | Qt::AlignLeft;

959 -

960

for (int i = 0; i < values.count(); ++i) {

evaluated: i < values.count()

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

961

const QCss::Value &v = values.at(i);

executed (the execution status of this line is deduced): const QCss::Value &v = values.at(i);

962

if (v.type == Value::Uri) {

partially evaluated: v.type == Value::Uri

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

0-4

963

*image = v.variant.toString();

never executed (the execution status of this line is deduced): *image = v.variant.toString();

964

} else if (v.type == Value::KnownIdentifier && v.variant.toInt() == Value_None) {

never executed: continue;

965

partially evaluated: v.type == Value::KnownIdentifier

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

never evaluated: v.variant.toInt() == Value_None

0-4

966

*image = QString();

never executed (the execution status of this line is deduced): *image = QString();

967

} else if (v.type == Value::KnownIdentifier && v.variant.toInt() == Value_Transparent) {

never executed: continue;

968

partially evaluated: v.type == Value::KnownIdentifier

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

never evaluated: v.variant.toInt() == Value_Transparent

0-4

969

*brush = QBrush(Qt::transparent);

never executed (the execution status of this line is deduced): *brush = QBrush(Qt::transparent);

970

Repeat repeatAttempt = static_cast<Repeat>(findKnownValue(v.variant.toString(),

never executed: }

971 -

972

executed (the execution status of this line is deduced): Repeat repeatAttempt = static_cast<Repeat>(findKnownValue(v.variant.toString(),

973

repeats, NumKnownRepeats));

executed (the execution status of this line is deduced): repeats, NumKnownRepeats));

974

if (repeatAttempt != Repeat_Unknown) {

partially evaluated: repeatAttempt != Repeat_Unknown

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

0-4

975

*repeat = repeatAttempt;

never executed (the execution status of this line is deduced): *repeat = repeatAttempt;

976

if (v.type == Value::KnownIdentifier) {

never executed: continue;

977 } -

978 -

979

partially evaluated: v.type == Value::KnownIdentifier

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

0-4

980

const int start = i;

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

981

int count = 1;

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

982

if (i < values.count() - 1

never evaluated: i < values.count() - 1

983

&& values.at(i + 1).type == Value::KnownIdentifier) {

never evaluated: values.at(i + 1).type == Value::KnownIdentifier

984

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

985

++count;

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

986

Qt::Alignment a = parseAlignment(values.constData() + start, count);

never executed: }

987

never executed (the execution status of this line is deduced): Qt::Alignment a = parseAlignment(values.constData() + start, count);

988

if (int(a) != 0) {

never evaluated: int(a) != 0

989

*alignment = a;

never executed (the execution status of this line is deduced): *alignment = a;

990

never executed: continue;

991 } -

992

i -= count - 1;

never executed (the execution status of this line is deduced): i -= count - 1;

993

*brush = parseBrushValue(v, pal);

never executed: }

994 -

995

executed (the execution status of this line is deduced): *brush = parseBrushValue(v, pal);

996

executed: }

Execution Count:4

997

executed: }

Execution Count:4

998 -

999 bool ValueExtractor::extractBackground(QBrush *brush, QString *image, Repeat *repeat, -

1000 Qt::Alignment *alignment, Origin *origin, Attachment *attachment, -

1001 Origin *clip) -

1002 { -

1003

executed (the execution status of this line is deduced): bool hit = false;

1004

evaluated: i < declarations.count()

TRUE	FALSE
yes Evaluation Count:3448	yes Evaluation Count:5492

3448-5492

1005

if (decl.d->values.isEmpty())

executed (the execution status of this line is deduced): const Declaration &decl = declarations.at(i);

1006

partially evaluated: decl.d->values.isEmpty()

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

0-3448

1007

const QCss::Value &val = decl.d->values.at(0);

never executed: continue;

1008

executed (the execution status of this line is deduced): const QCss::Value &val = decl.d->values.at(0);

1009 switch (decl.d->propertyId) { -

1010 case BackgroundColor: -

1011

*brush = decl.brushValue();

executed (the execution status of this line is deduced): *brush = decl.brushValue();

1012

if (val.type == Value::Uri)

executed: break;

Execution Count:87

1013 case BackgroundImage: -

1014

partially evaluated: val.type == Value::Uri

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

0-3

1015

*image = val.variant.toString();

executed: *image = val.variant.toString();

Execution Count:3

1016

executed: break;

Execution Count:3

1017 case BackgroundRepeat: -

1018

*repeat = static_cast<Repeat>(decl.d->parsed.toInt());

never evaluated: decl.d->parsed.isValid()

1019

never executed (the execution status of this line is deduced): *repeat = static_cast<Repeat>(decl.d->parsed.toInt());

1020

*repeat = static_cast<Repeat>(findKnownValue(val.variant.toString(),

never executed: }

1021

never executed (the execution status of this line is deduced): *repeat = static_cast<Repeat>(findKnownValue(val.variant.toString(),

1022

repeats, NumKnownRepeats));

never executed (the execution status of this line is deduced): repeats, NumKnownRepeats));

1023

decl.d->parsed = *repeat;

never executed (the execution status of this line is deduced): decl.d->parsed = *repeat;

never executed: }

never executed: break;

1026 case BackgroundPosition: -

1027

*alignment = decl.alignmentValue();

never executed (the execution status of this line is deduced): *alignment = decl.alignmentValue();

1028

*origin = decl.originValue();

never executed: break;

1029 case BackgroundOrigin: -

1030

never executed (the execution status of this line is deduced): *origin = decl.originValue();

1031

*clip = decl.originValue();

never executed: break;

1032 case BackgroundClip: -

1033

never executed (the execution status of this line is deduced): *clip = decl.originValue();

1034

never executed: break;

1035 case Background: -

1036

BackgroundData data = qvariant_cast<BackgroundData>(decl.d->parsed);

evaluated: decl.d->parsed.isValid()

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

1037

executed (the execution status of this line is deduced): BackgroundData data = qvariant_cast<BackgroundData>(decl.d->parsed);

1038

*brush = brushFromData(data.brush, pal);

executed (the execution status of this line is deduced): *brush = brushFromData(data.brush, pal);

1039

*image = data.image;

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

1040

*repeat = data.repeat;

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

1041

*alignment = data.alignment;

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

1042

parseShorthandBackgroundProperty(decl.d->values, &brushData, image, repeat, alignment, pal);

executed: }

Execution Count:4

1043

BrushData brushData;

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

1044

executed (the execution status of this line is deduced): parseShorthandBackgroundProperty(decl.d->values, &brushData, image, repeat, alignment, pal);

1045

*brush = brushFromData(brushData, pal);

executed (the execution status of this line is deduced): *brush = brushFromData(brushData, pal);

1046

if (brushData.type != BrushData::DependsOnThePalette) {

partially evaluated: brushData.type != BrushData::DependsOnThePalette

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

0-4

1047

BackgroundData data = { brushData, *image, *repeat, *alignment };

executed (the execution status of this line is deduced): BackgroundData data = { brushData, *image, *repeat, *alignment };

1048

decl.d->parsed = QVariant::fromValue<BackgroundData>(data);

executed (the execution status of this line is deduced): decl.d->parsed = QVariant::fromValue<BackgroundData>(data);

1049

executed: }

Execution Count:4

1050

executed: }

Execution Count:4

1051

*attachment = decl.attachmentValue();

executed: break;

Execution Count:8

1052 case BackgroundAttachment: -

1053

never executed (the execution status of this line is deduced): *attachment = decl.attachmentValue();

1054

never executed: break;

1055

executed: continue;

Execution Count:3350

3350

1056 } -

1057

executed (the execution status of this line is deduced): hit = true;

1058

executed: }

Execution Count:98

1059

executed: return hit;

Execution Count:5492

5492

1060 } -

1061 -

1062 static bool setFontSizeFromValue(QCss::Value value, QFont *font, int *fontSizeAdjustment) -

1063 { -

1064

case Value_Small: *fontSizeAdjustment = -1; break;

evaluated: value.type == Value::KnownIdentifier

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:23

1-23

1065

bool valid = true;

executed (the execution status of this line is deduced): bool valid = true;

1066 switch (value.variant.toInt()) { -

1067

never executed: break;

1068

case Value_Medium: *fontSizeAdjustment = 0; break;

never executed: break;

1069

case Value_Large: *fontSizeAdjustment = 1; break;

executed: break;

Execution Count:1

1070

case Value_XLarge: *fontSizeAdjustment = 2; break;

never executed: break;

1071

case Value_XXLarge: *fontSizeAdjustment = 3; break;

never executed: break;

1072

default: valid = false; break;

never executed: break;

1073 } -

1074

return valid;

executed: return valid;

Execution Count:1

1075 } -

1076

if (value.type != Value::Length)

partially evaluated: value.type != Value::Length

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

0-23

1077

QString s = value.variant.toString();

never executed: return false;

1078 -

1079

bool valid = false;

executed (the execution status of this line is deduced): bool valid = false;

1080

executed (the execution status of this line is deduced): QString s = value.variant.toString();

1081

if (s.endsWith(QLatin1String("pt"), Qt::CaseInsensitive)) {

evaluated: s.endsWith(QLatin1String("pt"), Qt::CaseInsensitive)

TRUE	FALSE
yes Evaluation Count:14	yes Evaluation Count:9

9-14

1082

s.chop(2);

executed (the execution status of this line is deduced): s.chop(2);

1083

value.variant = s;

executed (the execution status of this line is deduced): value.variant = s;

1084

if (value.variant.convert((QVariant::Type)qMetaTypeId<qreal>())) {

partially evaluated: value.variant.convert((QVariant::Type)qMetaTypeId<qreal>())

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

0-14

1085

font->setPointSizeF(value.variant.toReal());

executed (the execution status of this line is deduced): font->setPointSizeF(value.variant.toReal());

1086

valid = true;

executed (the execution status of this line is deduced): valid = true;

1087

} else if (s.endsWith(QLatin1String("px"), Qt::CaseInsensitive)) {

executed: }

Execution Count:14

1088

executed: }

Execution Count:14

partially evaluated: s.endsWith(QLatin1String("px"), Qt::CaseInsensitive)

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

0-14

1089

s.chop(2);

executed (the execution status of this line is deduced): s.chop(2);

1090

value.variant = s;

executed (the execution status of this line is deduced): value.variant = s;

1091

if (value.variant.convert(QVariant::Int)) {

partially evaluated: value.variant.convert(QVariant::Int)

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

0-9

1092

font->setPixelSize(value.variant.toInt());

executed (the execution status of this line is deduced): font->setPixelSize(value.variant.toInt());

1093

valid = true;

executed (the execution status of this line is deduced): valid = true;

1094

executed: }

Execution Count:9

1095

if (value.type != Value::KnownIdentifier)

executed: }

Execution Count:9

1096

return valid;

executed: return valid;

Execution Count:23

1097 } -

1098 -

1099 static bool setFontStyleFromValue(const QCss::Value &value, QFont *font) -

1100 { -

1101

evaluated: value.type != Value::KnownIdentifier

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:13

6-13

1102

return false ;

executed: return false ;

Execution Count:6

1103 switch (value.variant.toInt()) { -

1104

case Value_Normal: font->setStyle(QFont::StyleNormal); return true;

executed: return true;

Execution Count:8

1105

case Value_Italic: font->setStyle(QFont::StyleItalic); return true;

executed: return true;

Execution Count:2

1106

case Value_Oblique: font->setStyle(QFont::StyleOblique); return true;

never executed: return true;

1107

executed: break;

Execution Count:3

1108 } -

1109

executed: return false;

Execution Count:3

1110 } -

1111 -

1112 static bool setFontWeightFromValue(const QCss::Value &value, QFont *font) -

1113 { -

1114

case Value_Normal: font->setWeight(QFont::Normal); return true;

evaluated: value.type == Value::KnownIdentifier

TRUE	FALSE
yes Evaluation Count:5	yes Evaluation Count:13

5-13

1115 switch (value.variant.toInt()) { -

1116

never executed: return true;

1117

case Value_Bold: font->setWeight(QFont::Bold); return true;

executed: return true;

Execution Count:5

1118

never executed: break;

1119 } -

1120

if (value.type != Value::Number)

never executed: return false;

1121 } -

1122

evaluated: value.type != Value::Number

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:7

6-7

1123

font->setWeight(qMin(value.variant.toInt() / 8, 99));

executed: return false;

Execution Count:6

1124

executed (the execution status of this line is deduced): font->setWeight(qMin(value.variant.toInt() / 8, 99));

1125

bool shouldAddSpace = false;

executed: return true;

Execution Count:7

1126 } -

1127 -

1128 /** \internal -

1129 * parse the font family from the values (starting from index \a start) -

1130 * and set it the \a font -

1131 * The function returns true if a family was extracted. -

1132 */ -

1133 static bool setFontFamilyFromValues(const QVector<QCss::Value> &values, QFont *font, int start = 0) -

1134 { -

1135

QString family;

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

1136

executed (the execution status of this line is deduced): bool shouldAddSpace = false;

1137

for (int i = start; i < values.count(); ++i) {

evaluated: i < values.count()

TRUE	FALSE
yes Evaluation Count:23	yes Evaluation Count:17

17-23

1138

const QCss::Value &v = values.at(i);

executed (the execution status of this line is deduced): const QCss::Value &v = values.at(i);

1139

if (v.type == Value::TermOperatorComma) {

evaluated: v.type == Value::TermOperatorComma

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:21

2-21

1140

family += QLatin1Char(',');

executed (the execution status of this line is deduced): family += QLatin1Char(',');

1141

shouldAddSpace = false;

executed (the execution status of this line is deduced): shouldAddSpace = false;

1142

const QString str = v.variant.toString();

executed: continue;

Execution Count:2

1143 } -

1144

executed (the execution status of this line is deduced): const QString str = v.variant.toString();

1145

if (str.isEmpty())

partially evaluated: str.isEmpty()

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

0-21

1146

family += QLatin1Char(' ');

never executed: break;

1147

if (shouldAddSpace)

evaluated: shouldAddSpace

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:19

2-19

1148

executed: family += QLatin1Char(' ');

Execution Count:2

1149

family += str;

executed (the execution status of this line is deduced): family += str;

1150

shouldAddSpace = true;

executed (the execution status of this line is deduced): shouldAddSpace = true;

1151

executed: }

Execution Count:21

1152

if (family.isEmpty())

partially evaluated: family.isEmpty()

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

0-17

1153

never executed: return false;

1154

font->setFamily(family);

executed (the execution status of this line is deduced): font->setFamily(family);

1155

for (int i = 0; i < values.count(); ++i) {

executed: return true;

Execution Count:17

1156 } -

1157 -

1158 static void setTextDecorationFromValues(const QVector<QCss::Value> &values, QFont *font) -

1159 { -

1160

evaluated: i < values.count()

TRUE	FALSE
yes Evaluation Count:7	yes Evaluation Count:5

5-7

1161

if (values.at(i).type != Value::KnownIdentifier)

partially evaluated: values.at(i).type != Value::KnownIdentifier

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

0-7

1162

case Value_Underline: font->setUnderline(true); break;

never executed: continue;

1163 switch (values.at(i).variant.toInt()) { -

1164

executed: break;

Execution Count:1

1165

case Value_Overline: font->setOverline(true); break;

executed: break;

Execution Count:3

1166

case Value_LineThrough: font->setStrikeOut(true); break;

executed: break;

Execution Count:1

1167 case Value_None: -

1168

font->setUnderline(false);

executed (the execution status of this line is deduced): font->setUnderline(false);

1169

font->setOverline(false);

executed (the execution status of this line is deduced): font->setOverline(false);

1170

font->setStrikeOut(false);

executed (the execution status of this line is deduced): font->setStrikeOut(false);

1171

executed: break;

Execution Count:2

1172

never executed: break;

1173 } -

1174

executed: }

Execution Count:7

1175

font->setStyle(QFont::StyleNormal);

executed: }

Execution Count:5

1176 -

1177 static void parseShorthandFontProperty(const QVector<QCss::Value> &values, QFont *font, int *fontSizeAdjustment) -

1178 { -

1179

executed (the execution status of this line is deduced): font->setStyle(QFont::StyleNormal);

1180

font->setWeight(QFont::Normal);

executed (the execution status of this line is deduced): font->setWeight(QFont::Normal);

1181

*fontSizeAdjustment = -255;

executed (the execution status of this line is deduced): *fontSizeAdjustment = -255;

1182 -

1183

while (i < values.count()) {

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

1184

partially evaluated: i < values.count()

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

0-11

1185

if (setFontStyleFromValue(values.at(i), font)

evaluated: setFontStyleFromValue(values.at(i), font)

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:9

2-9

1186

|| setFontWeightFromValue(values.at(i), font))

evaluated: setFontWeightFromValue(values.at(i), font)

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:6

3-6

1187

executed: ++i;

Execution Count:5

1188 else -

1189

if (i < values.count()) {

executed: break;

Execution Count:6

1190 } -

1191 -

1192

partially evaluated: i < values.count()

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

0-6

1193

setFontSizeFromValue(values.at(i), font, fontSizeAdjustment);

executed (the execution status of this line is deduced): setFontSizeFromValue(values.at(i), font, fontSizeAdjustment);

1194

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

1195

if (i < values.count()) {

executed: }

Execution Count:6

1196 -

1197

evaluated: i < values.count()

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:2

2-4

1198

setFontFamilyFromValues(values, font, i);

executed (the execution status of this line is deduced): setFontFamilyFromValues(values, font, i);

1199

executed: }

Execution Count:4

1200

executed: }

Execution Count:6

1201 -

1202 static void setFontVariantFromValue(const QCss::Value &value, QFont *font) -

1203 { -

1204

case Value_Normal: font->setCapitalization(QFont::MixedCase); break;

partially evaluated: value.type == Value::KnownIdentifier

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

0-1

1205 switch (value.variant.toInt()) { -

1206

never executed: break;

1207

case Value_SmallCaps: font->setCapitalization(QFont::SmallCaps); break;

executed: break;

Execution Count:1

1208

never executed: break;

1209 } -

1210

executed: }

Execution Count:1

1211

executed: }

Execution Count:1

1212 -

1213 static void setTextTransformFromValue(const QCss::Value &value, QFont *font) -

1214 { -

1215

case Value_None: font->setCapitalization(QFont::MixedCase); break;

partially evaluated: value.type == Value::KnownIdentifier

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

0-2

1216 switch (value.variant.toInt()) { -

1217

never executed: break;

1218

case Value_Uppercase: font->setCapitalization(QFont::AllUppercase); break;

executed: break;

Execution Count:1

1219

case Value_Lowercase: font->setCapitalization(QFont::AllLowercase); break;

executed: break;

Execution Count:1

1220

never executed: break;

1221 } -

1222

executed: }

Execution Count:2

1223

*fontSizeAdjustment = adjustment;

executed: }

Execution Count:2

1224 -

1225 bool ValueExtractor::extractFont(QFont *font, int *fontSizeAdjustment) -

1226 { -

1227

if (fontExtracted) {

evaluated: fontExtracted

TRUE	FALSE
yes Evaluation Count:5492	yes Evaluation Count:5492

5492

1228

*font = f;

executed (the execution status of this line is deduced): *font = f;

1229

executed (the execution status of this line is deduced): *fontSizeAdjustment = adjustment;

1230

return fontExtracted == 1;

executed: return fontExtracted == 1;

Execution Count:5492

5492

1231 } -

1232 -

1233

executed (the execution status of this line is deduced): bool hit = false;

1234

evaluated: i < declarations.count()

TRUE	FALSE
yes Evaluation Count:3448	yes Evaluation Count:5492

3448-5492

1235

if (decl.d->values.isEmpty())

executed (the execution status of this line is deduced): const Declaration &decl = declarations.at(i);

1236

partially evaluated: decl.d->values.isEmpty()

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

0-3448

1237

const QCss::Value &val = decl.d->values.at(0);

never executed: continue;

1238

executed (the execution status of this line is deduced): const QCss::Value &val = decl.d->values.at(0);

1239 switch (decl.d->propertyId) { -

1240

case FontSize: setFontSizeFromValue(val, font, fontSizeAdjustment); break;

executed: break;

Execution Count:18

1241

case FontStyle: setFontStyleFromValue(val, font); break;

executed: break;

Execution Count:8

1242

case FontWeight: setFontWeightFromValue(val, font); break;

executed: break;

Execution Count:9

1243

case FontFamily: setFontFamilyFromValues(decl.d->values, font); break;

executed: break;

Execution Count:13

1244

case TextDecoration: setTextDecorationFromValues(decl.d->values, font); break;

executed: break;

Execution Count:5

1245

case Font: parseShorthandFontProperty(decl.d->values, font, fontSizeAdjustment); break;

executed: break;

Execution Count:6

1246

case FontVariant: setFontVariantFromValue(val, font); break;

executed: break;

Execution Count:1

1247

case TextTransform: setTextTransformFromValue(val, font); break;

executed: break;

Execution Count:2

1248

executed: continue;

Execution Count:3386

3386

1249 } -

1250

executed (the execution status of this line is deduced): hit = true;

1251

adjustment = *fontSizeAdjustment;

executed: }

Execution Count:62

1252 -

1253

f = *font;

executed (the execution status of this line is deduced): f = *font;

1254

executed (the execution status of this line is deduced): adjustment = *fontSizeAdjustment;

1255

fontExtracted = hit ? 1 : 2;

evaluated: hit

TRUE	FALSE
yes Evaluation Count:42	yes Evaluation Count:5450

42-5450

1256

executed: return hit;

Execution Count:5492

5492

1257 } -

1258 -

1259 bool ValueExtractor::extractPalette(QBrush *fg, QBrush *sfg, QBrush *sbg, QBrush *abg) -

1260 { -

1261

executed (the execution status of this line is deduced): bool hit = false;

1262

evaluated: i < declarations.count()

TRUE	FALSE
yes Evaluation Count:2915	yes Evaluation Count:3726

2915-3726

1263

case Color: *fg = decl.brushValue(pal); break;

executed (the execution status of this line is deduced): const Declaration &decl = declarations.at(i);

1264 switch (decl.d->propertyId) { -

1265

never executed: break;

1266

case QtSelectionForeground: *sfg = decl.brushValue(pal); break;

never executed: break;

1267

case QtSelectionBackground: *sbg = decl.brushValue(pal); break;

never executed: break;

1268

case QtAlternateBackground: *abg = decl.brushValue(pal); break;

never executed: break;

1269

executed: continue;

Execution Count:2915

2915

1270 } -

1271

never executed (the execution status of this line is deduced): hit = true;

never executed: }

executed: return hit;

Execution Count:3726

3726

1274 } -

1275 -

1276 void ValueExtractor::extractFont() -

1277 { -

1278

if (fontExtracted)

evaluated: fontExtracted

TRUE	FALSE
yes Evaluation Count:14904	yes Evaluation Count:5492

5492-14904

1279

executed: return;

Execution Count:14904

14904

1280

int dummy = -255;

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

1281

extractFont(&f, &dummy);

executed (the execution status of this line is deduced): extractFont(&f, &dummy);

1282

executed: }

Execution Count:5492

5492

1283 -

1284 bool ValueExtractor::extractImage(QIcon *icon, Qt::Alignment *a, QSize *size) -

1285 { -

1286

executed (the execution status of this line is deduced): bool hit = false;

1287

evaluated: i < declarations.count()

TRUE	FALSE
yes Evaluation Count:2915	yes Evaluation Count:3726

2915-3726

1288

*icon = decl.iconValue();

executed (the execution status of this line is deduced): const Declaration &decl = declarations.at(i);

1289 switch (decl.d->propertyId) { -

1290 case QtImage: -

1291

never executed (the execution status of this line is deduced): *icon = decl.iconValue();

1292

if (decl.d->values.count() > 0 && decl.d->values.at(0).type == Value::Uri) {

never evaluated: decl.d->values.count() > 0

never evaluated: decl.d->values.at(0).type == Value::Uri

1293 // try to pull just the size from the image... -

1294

QImageReader imageReader(decl.d->values.at(0).variant.toString());

never executed (the execution status of this line is deduced): QImageReader imageReader(decl.d->values.at(0).variant.toString());

1295

if ((*size = imageReader.size()).isNull()) {

never evaluated: (*size = imageReader.size()).isNull()

1296 // but we'll have to load the whole image if the -

1297 // format doesn't support just reading the size -

1298

*size = imageReader.read().size();

never executed (the execution status of this line is deduced): *size = imageReader.read().size();

never executed: }

never executed: }

never executed: break;

1302

case QtImageAlignment: *a = decl.alignmentValue(); break;

never executed: break;

1303

executed: continue;

Execution Count:2915

2915

1304 } -

1305

never executed (the execution status of this line is deduced): hit = true;

never executed: }

executed: return hit;

Execution Count:3726

3726

1308 } -

1309 -

1310 /////////////////////////////////////////////////////////////////////////////// -

1311 // Declaration -

1312 QColor Declaration::colorValue(const QPalette &pal) const -

1313 { -

1314

partially evaluated: d->values.count() != 1

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

0-14

1315

return QColor();

never executed: return QColor();

1316 -

1317

if (d->parsed.type() == QVariant::Color)

partially evaluated: d->parsed.isValid()

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

0-14

1318

never evaluated: d->parsed.type() == QVariant::Color

1319

return qvariant_cast<QColor>(d->parsed);

never executed: return qvariant_cast<QColor>(d->parsed);

1320

if (d->parsed.type() == QVariant::Int)

never evaluated: d->parsed.type() == QVariant::Int

1321

return pal.color((QPalette::ColorRole)(d->parsed.toInt()));

never executed: return pal.color((QPalette::ColorRole)(d->parsed.toInt()));

1322

ColorData color = parseColorValue(d->values.at(0));

never executed: }

1323 -

1324

executed (the execution status of this line is deduced): ColorData color = parseColorValue(d->values.at(0));

1325

if(color.type == ColorData::Role) {

partially evaluated: color.type == ColorData::Role

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

0-14

1326

d->parsed = QVariant::fromValue<int>(color.role);

never executed (the execution status of this line is deduced): d->parsed = QVariant::fromValue<int>(color.role);

1327

return pal.color((QPalette::ColorRole)(color.role));

never executed: return pal.color((QPalette::ColorRole)(color.role));

1328 } else { -

1329

d->parsed = QVariant::fromValue<QColor>(color.color);

executed (the execution status of this line is deduced): d->parsed = QVariant::fromValue<QColor>(color.color);

1330

return color.color;

executed: return color.color;

Execution Count:14

1331 } -

1332 } -

1333 -

1334 QBrush Declaration::brushValue(const QPalette &pal) const -

1335 { -

1336

partially evaluated: d->values.count() != 1

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

0-87

1337

return QBrush();

never executed: return QBrush();

1338 -

1339

if (d->parsed.type() == QVariant::Brush)

evaluated: d->parsed.isValid()

TRUE	FALSE
yes Evaluation Count:41	yes Evaluation Count:46

41-46

1340

partially evaluated: d->parsed.type() == QVariant::Brush

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

0-41

1341

return qvariant_cast<QBrush>(d->parsed);

executed: return qvariant_cast<QBrush>(d->parsed);

Execution Count:41

1342

if (d->parsed.type() == QVariant::Int)

never evaluated: d->parsed.type() == QVariant::Int

1343

return pal.color((QPalette::ColorRole)(d->parsed.toInt()));

never executed: return pal.color((QPalette::ColorRole)(d->parsed.toInt()));

1344

BrushData data = parseBrushValue(d->values.at(0), pal);

never executed: }

1345 -

1346

executed (the execution status of this line is deduced): BrushData data = parseBrushValue(d->values.at(0), pal);

1347 -

1348

if(data.type == BrushData::Role) {

partially evaluated: data.type == BrushData::Role

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

0-46

1349

d->parsed = QVariant::fromValue<int>(data.role);

never executed (the execution status of this line is deduced): d->parsed = QVariant::fromValue<int>(data.role);

1350

return pal.color((QPalette::ColorRole)(data.role));

never executed: return pal.color((QPalette::ColorRole)(data.role));

1351 } else { -

1352

if (data.type != BrushData::DependsOnThePalette)

partially evaluated: data.type != BrushData::DependsOnThePalette

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

0-46

1353

d->parsed = QVariant::fromValue<QBrush>(data.brush);

executed: d->parsed = QVariant::fromValue<QBrush>(data.brush);

Execution Count:46

1354

return data.brush;

executed: return data.brush;

Execution Count:46

1355 } -

1356 } -

1357 -

1358 void Declaration::brushValues(QBrush *c, const QPalette &pal) const -

1359 { -

1360

int needParse = 0x1f; // bits 0..3 say if we should parse the corresponding value.

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

1361 // the bit 4 say we need to update d->parsed -

1362

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

1363

QList<QVariant> v = d->parsed.toList();

never evaluated: d->parsed.isValid()

1364

needParse = 0;

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

1365

never executed (the execution status of this line is deduced): QList<QVariant> v = d->parsed.toList();

1366

for (i = 0; i < qMin(v.count(), 4); i++) {

never evaluated: i < qMin(v.count(), 4)

1367

if (v.at(i).type() == QVariant::Brush) {

never evaluated: v.at(i).type() == QVariant::Brush

1368

c[i] = qvariant_cast<QBrush>(v.at(i));

never executed (the execution status of this line is deduced): c[i] = qvariant_cast<QBrush>(v.at(i));

1369

} else if (v.at(i).type() == QVariant::Int) {

never executed: }

never evaluated: v.at(i).type() == QVariant::Int

1370

c[i] = pal.color((QPalette::ColorRole)(v.at(i).toInt()));

never executed (the execution status of this line is deduced): c[i] = pal.color((QPalette::ColorRole)(v.at(i).toInt()));

never executed: }

never executed (the execution status of this line is deduced): needParse |= (1<<i);

1373

never executed: }

1374 } -

1375

for (i = 0; i < qMin(d->values.count(), 4); i++) {

never executed: }

1376

if (needParse != 0) {

never evaluated: needParse != 0

1377

QList<QVariant> v;

never executed (the execution status of this line is deduced): QList<QVariant> v;

1378

never evaluated: i < qMin(d->values.count(), 4)

1379

if (!(needParse & (1<<i)))

never evaluated: !(needParse & (1<<i))

1380

BrushData data = parseBrushValue(d->values.at(i), pal);

never executed: continue;

1381

never executed (the execution status of this line is deduced): BrushData data = parseBrushValue(d->values.at(i), pal);

1382

if(data.type == BrushData::Role) {

never evaluated: data.type == BrushData::Role

1383

v += QVariant::fromValue<int>(data.role);

never executed (the execution status of this line is deduced): v += QVariant::fromValue<int>(data.role);

1384

c[i] = pal.color((QPalette::ColorRole)(data.role));

never executed (the execution status of this line is deduced): c[i] = pal.color((QPalette::ColorRole)(data.role));

1385

if (data.type != BrushData::DependsOnThePalette) {

never executed: }

1386

never evaluated: data.type != BrushData::DependsOnThePalette

1387

v += QVariant::fromValue<QBrush>(data.brush);

never executed (the execution status of this line is deduced): v += QVariant::fromValue<QBrush>(data.brush);

never executed: }

never executed (the execution status of this line is deduced): v += QVariant();

never executed: }

never executed (the execution status of this line is deduced): c[i] = data.brush;

1392

never executed: }

1393 } -

1394

if (needParse & 0x10)

never evaluated: needParse & 0x10

1395

never executed: d->parsed = v;

1396

if (i == 0) c[0] = c[1] = c[2] = c[3] = QBrush();

never executed: }

1397

never executed: c[0] = c[1] = c[2] = c[3] = QBrush();

never evaluated: i == 0

1398

else if (i == 1) c[3] = c[2] = c[1] = c[0];

never executed: c[3] = c[2] = c[1] = c[0];

never evaluated: i == 1

1399

else if (i == 2) c[2] = c[0], c[3] = c[1];

never executed: c[2] = c[0], c[3] = c[1];

never evaluated: i == 2

1400

else if (i == 3) c[3] = c[1];

never executed: c[3] = c[1];

never evaluated: i == 3

1401 } -

1402 -

1403 bool Declaration::realValue(qreal *real, const char *unit) const -

1404 { -

1405

partially evaluated: d->values.count() != 1

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

0-41

1406

const Value &v = d->values.at(0);

never executed: return false;

1407

executed (the execution status of this line is deduced): const Value &v = d->values.at(0);

1408

if (unit && v.type != Value::Length)

partially evaluated: unit

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

partially evaluated: v.type != Value::Length

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

0-41

1409

QString s = v.variant.toString();

never executed: return false;

1410

executed (the execution status of this line is deduced): QString s = v.variant.toString();

1411

if (unit) {

partially evaluated: unit

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

0-41

1412

if (!s.endsWith(QLatin1String(unit), Qt::CaseInsensitive))

partially evaluated: !s.endsWith(QLatin1String(unit), Qt::CaseInsensitive)

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

0-41

1413

never executed: return false;

1414

s.chop(qstrlen(unit));

executed (the execution status of this line is deduced): s.chop(qstrlen(unit));

1415

qreal val = s.toDouble(&ok);

executed: }

Execution Count:41

1416

bool ok = false;

executed (the execution status of this line is deduced): bool ok = false;

1417

executed (the execution status of this line is deduced): qreal val = s.toDouble(&ok);

1418

if (ok)

partially evaluated: ok

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

0-41

1419

*real = val;

executed: *real = val;

Execution Count:41

1420

return ok;

executed: return ok;

Execution Count:41

1421 } -

1422 -

1423 static bool intValueHelper(const QCss::Value &v, int *i, const char *unit) -

1424 { -

1425

if (unit && v.type != Value::Length)

partially evaluated: unit

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

never evaluated: v.type != Value::Length

0-2

1426

QString s = v.variant.toString();

never executed: return false;

1427

executed (the execution status of this line is deduced): QString s = v.variant.toString();

1428

if (unit) {

partially evaluated: unit

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

0-2

1429

if (!s.endsWith(QLatin1String(unit), Qt::CaseInsensitive))

never evaluated: !s.endsWith(QLatin1String(unit), Qt::CaseInsensitive)

1430

never executed: return false;

1431

s.chop(qstrlen(unit));

never executed (the execution status of this line is deduced): s.chop(qstrlen(unit));

never executed: }

executed (the execution status of this line is deduced): bool ok = false;

1434

int val = s.toInt(&ok);

executed (the execution status of this line is deduced): int val = s.toInt(&ok);

1435

if (ok)

partially evaluated: ok

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

0-2

1436

*i = val;

executed: *i = val;

Execution Count:2

1437

return ok;

executed: return ok;

Execution Count:2

1438 } -

1439 -

1440 bool Declaration::intValue(int *i, const char *unit) const -

1441 { -

1442

partially evaluated: d->values.count() != 1

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

0-2

1443

return intValueHelper(d->values.at(0), i, unit);

never executed: return false;

1444

executed: return intValueHelper(d->values.at(0), i, unit);

Execution Count:2

1445 } -

1446 -

1447 QSize Declaration::sizeValue() const -

1448 { -

1449

return qvariant_cast<QSize>(d->parsed);

never evaluated: d->parsed.isValid()

1450

never executed: return qvariant_cast<QSize>(d->parsed);

1451 -

1452

int x[2] = { 0, 0 };

never executed (the execution status of this line is deduced): int x[2] = { 0, 0 };

1453

if (d->values.count() > 0)

never evaluated: d->values.count() > 0

1454

intValueHelper(d->values.at(0), &x[0], "px");

never executed: intValueHelper(d->values.at(0), &x[0], "px");

1455

if (d->values.count() > 1)

never evaluated: d->values.count() > 1

1456

intValueHelper(d->values.at(1), &x[1], "px");

never executed: intValueHelper(d->values.at(1), &x[1], "px");

1457 else -

1458

x[1] = x[0];

never executed: x[1] = x[0];

1459

QSize size(x[0], x[1]);

never executed (the execution status of this line is deduced): QSize size(x[0], x[1]);

1460

d->parsed = QVariant::fromValue<QSize>(size);

never executed (the execution status of this line is deduced): d->parsed = QVariant::fromValue<QSize>(size);

1461

return size;

never executed: return size;

1462 } -

1463 -

1464 QRect Declaration::rectValue() const -

1465 { -

1466

never evaluated: d->values.count() != 1

1467

never executed: return QRect();

1468 -

1469

return qvariant_cast<QRect>(d->parsed);

never evaluated: d->parsed.isValid()

1470

never executed: return qvariant_cast<QRect>(d->parsed);

1471 -

1472

const QCss::Value &v = d->values.at(0);

never executed (the execution status of this line is deduced): const QCss::Value &v = d->values.at(0);

1473

if (v.type != Value::Function)

never evaluated: v.type != Value::Function

1474

QStringList func = v.variant.toStringList();

never executed: return QRect();

1475

never executed (the execution status of this line is deduced): QStringList func = v.variant.toStringList();

1476

if (func.count() != 2 || func.at(0).compare(QLatin1String("rect")) != 0)

never evaluated: func.count() != 2

never evaluated: func.at(0).compare(QLatin1String("rect")) != 0

1477

QStringList args = func[1].split(QLatin1Char(' '), QString::SkipEmptyParts);

never executed: return QRect();

1478

never executed (the execution status of this line is deduced): QStringList args = func[1].split(QLatin1Char(' '), QString::SkipEmptyParts);

1479

if (args.count() != 4)

never evaluated: args.count() != 4

1480

QRect rect(args[0].toInt(), args[1].toInt(), args[2].toInt(), args[3].toInt());

never executed: return QRect();

1481

never executed (the execution status of this line is deduced): QRect rect(args[0].toInt(), args[1].toInt(), args[2].toInt(), args[3].toInt());

1482

d->parsed = QVariant::fromValue<QRect>(rect);

never executed (the execution status of this line is deduced): d->parsed = QVariant::fromValue<QRect>(rect);

1483

return rect;

never executed: return rect;

1484 } -

1485 -

1486 void Declaration::colorValues(QColor *c, const QPalette &pal) const -

1487 { -

1488

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

1489

QList<QVariant> v = d->parsed.toList();

never evaluated: d->parsed.isValid()

1490

never executed (the execution status of this line is deduced): QList<QVariant> v = d->parsed.toList();

1491

for (i = 0; i < qMin(d->values.count(), 4); i++) {

never evaluated: i < qMin(d->values.count(), 4)

1492

if (v.at(i).type() == QVariant::Color) {

never evaluated: v.at(i).type() == QVariant::Color

1493

c[i] = qvariant_cast<QColor>(v.at(i));

never executed (the execution status of this line is deduced): c[i] = qvariant_cast<QColor>(v.at(i));

1494

c[i] = pal.color((QPalette::ColorRole)(v.at(i).toInt()));

never executed: }

1495

never executed (the execution status of this line is deduced): c[i] = pal.color((QPalette::ColorRole)(v.at(i).toInt()));

1496

for (i = 0; i < qMin(d->values.count(), 4); i++) {

never executed: }

1497 } -

never executed: }

never executed (the execution status of this line is deduced): QList<QVariant> v;

1500

never evaluated: i < qMin(d->values.count(), 4)

1501

ColorData color = parseColorValue(d->values.at(i));

never executed (the execution status of this line is deduced): ColorData color = parseColorValue(d->values.at(i));

1502

if(color.type == ColorData::Role) {

never evaluated: color.type == ColorData::Role

1503

v += QVariant::fromValue<int>(color.role);

never executed (the execution status of this line is deduced): v += QVariant::fromValue<int>(color.role);

1504

c[i] = pal.color((QPalette::ColorRole)(color.role));

never executed (the execution status of this line is deduced): c[i] = pal.color((QPalette::ColorRole)(color.role));

1505

v += QVariant::fromValue<QColor>(color.color);

never executed: }

1506

never executed (the execution status of this line is deduced): v += QVariant::fromValue<QColor>(color.color);

1507

c[i] = color.color;

never executed (the execution status of this line is deduced): c[i] = color.color;

1508

never executed: }

1509 } -

1510

never executed (the execution status of this line is deduced): d->parsed = v;

1511

if (i == 0) c[0] = c[1] = c[2] = c[3] = QColor();

never executed: }

1512 -

1513

never executed: c[0] = c[1] = c[2] = c[3] = QColor();

never evaluated: i == 0

1514

else if (i == 1) c[3] = c[2] = c[1] = c[0];

never executed: c[3] = c[2] = c[1] = c[0];

never evaluated: i == 1

1515

else if (i == 2) c[2] = c[0], c[3] = c[1];

never executed: c[2] = c[0], c[3] = c[1];

never evaluated: i == 2

1516

else if (i == 3) c[3] = c[1];

never executed: c[3] = c[1];

never evaluated: i == 3

1517 } -

1518 -

1519 BorderStyle Declaration::styleValue() const -

1520 { -

1521

return parseStyleValue(d->values.at(0));

partially evaluated: d->values.count() != 1

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

0-3

1522

return BorderStyle_None;

never executed: return BorderStyle_None;

1523

executed: return parseStyleValue(d->values.at(0));

Execution Count:3

1524 } -

1525 -

1526 void Declaration::styleValues(BorderStyle *s) const -

1527 { -

1528

for (i = 0; i < qMin(d->values.count(), 4); i++)

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

1529

evaluated: i < qMin(d->values.count(), 4)

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

1530

s[i] = parseStyleValue(d->values.at(i));

executed: s[i] = parseStyleValue(d->values.at(i));

Execution Count:21

1531

if (i == 0) s[0] = s[1] = s[2] = s[3] = BorderStyle_None;

never executed: s[0] = s[1] = s[2] = s[3] = BorderStyle_None;

partially evaluated: i == 0

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

0-21

1532

else if (i == 1) s[3] = s[2] = s[1] = s[0];

executed: s[3] = s[2] = s[1] = s[0];

Execution Count:21

partially evaluated: i == 1

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

0-21

1533

else if (i == 2) s[2] = s[0], s[3] = s[1];

never executed: s[2] = s[0], s[3] = s[1];

never evaluated: i == 2

1534

else if (i == 3) s[3] = s[1];

never executed: s[3] = s[1];

never evaluated: i == 3

1535 } -

1536 -

1537 Repeat Declaration::repeatValue() const -

1538 { -

1539

return static_cast<Repeat>(d->parsed.toInt());

never evaluated: d->parsed.isValid()

1540

never executed: return static_cast<Repeat>(d->parsed.toInt());

1541

int v = findKnownValue(d->values.at(0).variant.toString(),

never evaluated: d->values.count() != 1

1542

return Repeat_Unknown;

never executed: return Repeat_Unknown;

1543

never executed (the execution status of this line is deduced): int v = findKnownValue(d->values.at(0).variant.toString(),

1544

repeats, NumKnownRepeats);

never executed (the execution status of this line is deduced): repeats, NumKnownRepeats);

1545

return static_cast<Repeat>(v);

never executed (the execution status of this line is deduced): d->parsed = v;

1546

never executed: return static_cast<Repeat>(v);

1547 } -

1548 -

1549 Origin Declaration::originValue() const -

1550 { -

1551

return static_cast<Origin>(d->parsed.toInt());

never evaluated: d->parsed.isValid()

1552

never executed: return static_cast<Origin>(d->parsed.toInt());

1553

int v = findKnownValue(d->values.at(0).variant.toString(),

never evaluated: d->values.count() != 1

1554

return Origin_Unknown;

never executed: return Origin_Unknown;

1555

never executed (the execution status of this line is deduced): int v = findKnownValue(d->values.at(0).variant.toString(),

1556

origins, NumKnownOrigins);

never executed (the execution status of this line is deduced): origins, NumKnownOrigins);

1557

return static_cast<Origin>(v);

never executed (the execution status of this line is deduced): d->parsed = v;

1558

never executed: return static_cast<Origin>(v);

1559 } -

1560 -

1561 PositionMode Declaration::positionValue() const -

1562 { -

1563

return static_cast<PositionMode>(d->parsed.toInt());

never evaluated: d->parsed.isValid()

1564

never executed: return static_cast<PositionMode>(d->parsed.toInt());

1565

return PositionMode_Unknown;

never evaluated: d->values.count() != 1

1566

never executed: return PositionMode_Unknown;

1567

int v = findKnownValue(d->values.at(0).variant.toString(),

never executed (the execution status of this line is deduced): int v = findKnownValue(d->values.at(0).variant.toString(),

1568

positions, NumKnownPositionModes);

never executed (the execution status of this line is deduced): positions, NumKnownPositionModes);

1569

return static_cast<PositionMode>(v);

never executed (the execution status of this line is deduced): d->parsed = v;

1570

never executed: return static_cast<PositionMode>(v);

1571 } -

1572 -

1573 Attachment Declaration::attachmentValue() const -

1574 { -

1575

return static_cast<Attachment>(d->parsed.toInt());

never evaluated: d->parsed.isValid()

1576

never executed: return static_cast<Attachment>(d->parsed.toInt());

1577

return Attachment_Unknown;

never evaluated: d->values.count() != 1

1578

never executed: return Attachment_Unknown;

1579

int v = findKnownValue(d->values.at(0).variant.toString(),

never executed (the execution status of this line is deduced): int v = findKnownValue(d->values.at(0).variant.toString(),

1580

attachments, NumKnownAttachments);

never executed (the execution status of this line is deduced): attachments, NumKnownAttachments);

1581

return static_cast<Attachment>(v);

never executed (the execution status of this line is deduced): d->parsed = v;

1582

never executed: return static_cast<Attachment>(v);

1583 } -

1584 -

1585 int Declaration::styleFeaturesValue() const -

1586 { -

1587

Q_ASSERT(d->propertyId == QtStyleFeatures);

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

1588

return d->parsed.toInt();

evaluated: d->parsed.isValid()

TRUE	FALSE
yes Evaluation Count:15	yes Evaluation Count:14

14-15

1589

executed: return d->parsed.toInt();

Execution Count:15

1590

int features = StyleFeature_None;

executed (the execution status of this line is deduced): int features = StyleFeature_None;

1591

for (int i = 0; i < d->values.count(); i++) {

evaluated: i < d->values.count()

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

1592

features |= static_cast<int>(findKnownValue(d->values.value(i).variant.toString(),

executed (the execution status of this line is deduced): features |= static_cast<int>(findKnownValue(d->values.value(i).variant.toString(),

1593

styleFeatures, NumKnownStyleFeatures));

executed (the execution status of this line is deduced): styleFeatures, NumKnownStyleFeatures));

1594

if (d->values.isEmpty() || d->values.at(0).type != Value::Uri)

executed: }

Execution Count:14

1595

d->parsed = features;

executed (the execution status of this line is deduced): d->parsed = features;

1596

return features;

executed: return features;

Execution Count:14

1597 } -

1598 -

1599 QString Declaration::uriValue() const -

1600 { -

1601

never evaluated: d->values.isEmpty()

never evaluated: d->values.at(0).type != Value::Uri

1602

return QString();

never executed: return QString();

1603

return d->values.at(0).variant.toString();

never executed: return d->values.at(0).variant.toString();

1604 } -

1605 -

1606 Qt::Alignment Declaration::alignmentValue() const -

1607 { -

1608

return Qt::Alignment(d->parsed.toInt());

never evaluated: d->parsed.isValid()

1609

never executed: return Qt::Alignment(d->parsed.toInt());

1610

if (d->values.isEmpty() || d->values.count() > 2)

never evaluated: d->values.isEmpty()

never evaluated: d->values.count() > 2

1611

return Qt::AlignLeft | Qt::AlignTop;

never executed: return Qt::AlignLeft | Qt::AlignTop;

1612 -

1613

Qt::Alignment v = parseAlignment(d->values.constData(), d->values.count());

never executed (the execution status of this line is deduced): Qt::Alignment v = parseAlignment(d->values.constData(), d->values.count());

1614

d->parsed = int(v);

never executed (the execution status of this line is deduced): d->parsed = int(v);

1615

return v;

never executed: return v;

1616 } -

1617 -

1618 void Declaration::borderImageValue(QString *image, int *cuts, -

1619 TileMode *h, TileMode *v) const -

1620 { -

1621

*image = uriValue();

never executed (the execution status of this line is deduced): *image = uriValue();

1622

for (int i = 0; i < 4; i++)

never evaluated: i < 4

1623

cuts[i] = -1;

never executed: cuts[i] = -1;

1624

*h = *v = TileMode_Stretch;

never executed (the execution status of this line is deduced): *h = *v = TileMode_Stretch;

1625 -

1626

if (d->values.count() < 2)

never evaluated: d->values.count() < 2

1627

if (d->values.at(1).type == Value::Number) { // cuts!

never executed: return;

1628 -

1629

never evaluated: d->values.at(1).type == Value::Number

1630

for (i = 0; i < qMin(d->values.count()-1, 4); i++) {

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

1631

never evaluated: i < qMin(d->values.count()-1, 4)

1632

const Value& v = d->values.at(i+1);

never executed (the execution status of this line is deduced): const Value& v = d->values.at(i+1);

1633

if (v.type != Value::Number)

never evaluated: v.type != Value::Number

1634

cuts[i] = v.variant.toString().toInt();

never executed: break;

1635

never executed (the execution status of this line is deduced): cuts[i] = v.variant.toString().toInt();

1636

if (i == 0) cuts[0] = cuts[1] = cuts[2] = cuts[3] = 0;

never executed: }

1637

never executed: cuts[0] = cuts[1] = cuts[2] = cuts[3] = 0;

never evaluated: i == 0

1638

else if (i == 1) cuts[3] = cuts[2] = cuts[1] = cuts[0];

never executed: cuts[3] = cuts[2] = cuts[1] = cuts[0];

never evaluated: i == 1

1639

else if (i == 2) cuts[2] = cuts[0], cuts[3] = cuts[1];

never executed: cuts[2] = cuts[0], cuts[3] = cuts[1];

never evaluated: i == 2

1640

else if (i == 3) cuts[3] = cuts[1];

never executed: cuts[3] = cuts[1];

never evaluated: i == 3

1641 } -

1642 -

1643

if (d->values.last().type == Value::Identifier) {

never evaluated: d->values.last().type == Value::Identifier

1644

*v = static_cast<TileMode>(findKnownValue(d->values.last().variant.toString(),

never executed (the execution status of this line is deduced): *v = static_cast<TileMode>(findKnownValue(d->values.last().variant.toString(),

1645

tileModes, NumKnownTileModes));

never executed (the execution status of this line is deduced): tileModes, NumKnownTileModes));

1646

if (d->values[d->values.count() - 2].type == Value::Identifier) {

never executed: }

1647

never evaluated: d->values[d->values.count() - 2].type == Value::Identifier

1648

*h = static_cast<TileMode>

never executed (the execution status of this line is deduced): *h = static_cast<TileMode>

1649

(findKnownValue(d->values[d->values.count()-2].variant.toString(),

never executed (the execution status of this line is deduced): (findKnownValue(d->values[d->values.count()-2].variant.toString(),

1650

tileModes, NumKnownTileModes));

never executed (the execution status of this line is deduced): tileModes, NumKnownTileModes));

never executed: }

never executed: *h = *v;

1653 } -

1654 -

1655 QIcon Declaration::iconValue() const -

1656 { -

1657

return qvariant_cast<QIcon>(d->parsed);

never evaluated: d->parsed.isValid()

1658

never executed: return qvariant_cast<QIcon>(d->parsed);

1659 -

1660

QIcon icon;

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

1661

for (int i = 0; i < d->values.count();) {

never evaluated: i < d->values.count()

1662

const Value &value = d->values.at(i++);

never executed (the execution status of this line is deduced): const Value &value = d->values.at(i++);

1663

if (value.type != Value::Uri)

never evaluated: value.type != Value::Uri

1664

QString uri = value.variant.toString();

never executed: break;

1665

never executed (the execution status of this line is deduced): QString uri = value.variant.toString();

1666

QIcon::Mode mode = QIcon::Normal;

never executed (the execution status of this line is deduced): QIcon::Mode mode = QIcon::Normal;

1667

QIcon::State state = QIcon::Off;

never executed (the execution status of this line is deduced): QIcon::State state = QIcon::Off;

1668

for (int j = 0; j < 2; j++) {

never evaluated: j < 2

1669

if (i != d->values.count() && d->values.at(i).type == Value::KnownIdentifier) {

never evaluated: i != d->values.count()

never evaluated: d->values.at(i).type == Value::KnownIdentifier

1670 switch (d->values.at(i).variant.toInt()) { -

1671

case Value_Disabled: mode = QIcon::Disabled; break;

never executed: break;

1672

case Value_Active: mode = QIcon::Active; break;

never executed: break;

1673

case Value_Selected: mode = QIcon::Selected; break;

never executed: break;

1674

case Value_Normal: mode = QIcon::Normal; break;

never executed: break;

1675

case Value_On: state = QIcon::On; break;

never executed: break;

1676

case Value_Off: state = QIcon::Off; break;

never executed: break;

1677

never executed: break;

1678 } -

1679

icon.addPixmap(uri, mode, state);

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

never executed: }

never executed: break;

1682 } -

1683 } -

1684 -

1685 // QIcon is soo broken -

1686

if (icon.isNull())

never evaluated: icon.isNull()

1687

icon = QIcon(uri);

never executed: icon = QIcon(uri);

1688 else -

1689

never executed: icon.addPixmap(uri, mode, state);

1690 -

1691

if (i == d->values.count())

never evaluated: i == d->values.count()

1692

if (d->values.at(i).type == Value::TermOperatorComma)

never executed: break;

1693 -

1694

never evaluated: d->values.at(i).type == Value::TermOperatorComma

1695

i++;

never executed: i++;

1696

d->parsed = QVariant::fromValue<QIcon>(icon);

never executed: }

1697 -

1698

never executed (the execution status of this line is deduced): d->parsed = QVariant::fromValue<QIcon>(icon);

1699

return icon;

never executed: return icon;

1700 } -

1701 -

1702 /////////////////////////////////////////////////////////////////////////////// -

1703 // Selector -

1704 int Selector::specificity() const -

1705 { -

1706

int val = 0;

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

1707

for (int i = 0; i < basicSelectors.count(); ++i) {

evaluated: i < basicSelectors.count()

TRUE	FALSE
yes Evaluation Count:1763	yes Evaluation Count:1763

1763

1708

const BasicSelector &sel = basicSelectors.at(i);

executed (the execution status of this line is deduced): const BasicSelector &sel = basicSelectors.at(i);

1709

if (!sel.elementName.isEmpty())

evaluated: !sel.elementName.isEmpty()

TRUE	FALSE
yes Evaluation Count:1724	yes Evaluation Count:39

39-1724

1710

val += 1;

executed: val += 1;

Execution Count:1724

1724

1711 -

1712

val += (sel.pseudos.count() + sel.attributeSelectors.count()) * 0x10;

executed (the execution status of this line is deduced): val += (sel.pseudos.count() + sel.attributeSelectors.count()) * 0x10;

1713

val += sel.ids.count() * 0x100;

executed (the execution status of this line is deduced): val += sel.ids.count() * 0x100;

1714

const BasicSelector& bs = basicSelectors.last();

executed: }

Execution Count:1763

1763

1715

return val;

executed: return val;

Execution Count:1763

1763

1716 } -

1717 -

1718 QString Selector::pseudoElement() const -

1719 { -

1720

executed (the execution status of this line is deduced): const BasicSelector& bs = basicSelectors.last();

1721

if (!bs.pseudos.isEmpty() && bs.pseudos.at(0).type == PseudoClass_Unknown)

evaluated: !bs.pseudos.isEmpty()

TRUE	FALSE
yes Evaluation Count:110	yes Evaluation Count:5109

evaluated: bs.pseudos.at(0).type == PseudoClass_Unknown

TRUE	FALSE
yes Evaluation Count:72	yes Evaluation Count:38

38-5109

1722

return bs.pseudos.at(0).name;

executed: return bs.pseudos.at(0).name;

Execution Count:72

1723

return QString();

executed: return QString();

Execution Count:5147

5147

1724 } -

1725 -

1726 quint64 Selector::pseudoClass(quint64 *negated) const -

1727 { -

1728

const BasicSelector& bs = basicSelectors.last();

executed (the execution status of this line is deduced): const BasicSelector& bs = basicSelectors.last();

1729

if (bs.pseudos.isEmpty())

evaluated: bs.pseudos.isEmpty()

TRUE	FALSE
yes Evaluation Count:16114	yes Evaluation Count:77

77-16114

1730

return PseudoClass_Unspecified;

executed: return PseudoClass_Unspecified;

Execution Count:16114

16114

1731

quint64 pc = PseudoClass_Unknown;

executed (the execution status of this line is deduced): quint64 pc = PseudoClass_Unknown;

1732

for (int i = !pseudoElement().isEmpty(); i < bs.pseudos.count(); i++) {

evaluated: i < bs.pseudos.count()

TRUE	FALSE
yes Evaluation Count:30	yes Evaluation Count:77

30-77

1733

const Pseudo &pseudo = bs.pseudos.at(i);

executed (the execution status of this line is deduced): const Pseudo &pseudo = bs.pseudos.at(i);

1734

if (pseudo.type == PseudoClass_Unknown)

partially evaluated: pseudo.type == PseudoClass_Unknown

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

0-30

1735

return PseudoClass_Unknown;

never executed: return PseudoClass_Unknown;

1736

if (!pseudo.negated)

partially evaluated: !pseudo.negated

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

0-30

1737

pc |= pseudo.type;

executed: pc |= pseudo.type;

Execution Count:30

1738

else if (negated)

never evaluated: negated

1739

*negated |= pseudo.type;

never executed: *negated |= pseudo.type;

1740 } -

1741

return pc;

executed: return pc;

Execution Count:77

1742 } -

1743 -

1744 /////////////////////////////////////////////////////////////////////////////// -

1745 // StyleSheet -

1746 void StyleSheet::buildIndexes(Qt::CaseSensitivity nameCaseSensitivity) -

1747 { -

1748

QVector<StyleRule> universals;

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

1749

for (int i = 0; i < styleRules.count(); ++i) {

evaluated: i < styleRules.count()

TRUE	FALSE
yes Evaluation Count:6846	yes Evaluation Count:1020

1020-6846

1750

const StyleRule &rule = styleRules.at(i);

executed (the execution status of this line is deduced): const StyleRule &rule = styleRules.at(i);

1751

QVector<Selector> universalsSelectors;

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

1752

for (int j = 0; j < rule.selectors.count(); ++j) {

evaluated: j < rule.selectors.count()

TRUE	FALSE
yes Evaluation Count:8058	yes Evaluation Count:6846

6846-8058

1753

const Selector& selector = rule.selectors.at(j);

executed (the execution status of this line is deduced): const Selector& selector = rule.selectors.at(j);

1754 -

1755

if (selector.basicSelectors.isEmpty())

partially evaluated: selector.basicSelectors.isEmpty()

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

0-8058

1756

if (selector.basicSelectors.at(0).relationToNext == BasicSelector::NoRelation) {

never executed: continue;

1757 -

1758

evaluated: selector.basicSelectors.at(0).relationToNext == BasicSelector::NoRelation

TRUE	FALSE
yes Evaluation Count:8057	yes Evaluation Count:1

1-8057

1759

if (selector.basicSelectors.count() != 1)

partially evaluated: selector.basicSelectors.count() != 1

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

0-8057

1760

} else if (selector.basicSelectors.count() <= 1) {

never executed: continue;

1761

executed: }

Execution Count:8057

partially evaluated: selector.basicSelectors.count() <= 1

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

0-8057

1762

const BasicSelector &sel = selector.basicSelectors.at(selector.basicSelectors.count() - 1);

never executed: continue;

1763 } -

1764 -

1765

executed (the execution status of this line is deduced): const BasicSelector &sel = selector.basicSelectors.at(selector.basicSelectors.count() - 1);

1766 -

1767

if (!sel.ids.isEmpty()) {

partially evaluated: !sel.ids.isEmpty()

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

0-8058

1768

StyleRule nr;

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

1769

nr.selectors += selector;

never executed (the execution status of this line is deduced): nr.selectors += selector;

1770

nr.declarations = rule.declarations;

never executed (the execution status of this line is deduced): nr.declarations = rule.declarations;

1771

nr.order = i;

never executed (the execution status of this line is deduced): nr.order = i;

1772

idIndex.insert(sel.ids.at(0), nr);

never executed (the execution status of this line is deduced): idIndex.insert(sel.ids.at(0), nr);

1773

} else if (!sel.elementName.isEmpty()) {

never executed: }

evaluated: !sel.elementName.isEmpty()

TRUE	FALSE
yes Evaluation Count:7872	yes Evaluation Count:186

0-7872

1774

StyleRule nr;

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

1775

nr.selectors += selector;

executed (the execution status of this line is deduced): nr.selectors += selector;

1776

nr.declarations = rule.declarations;

executed (the execution status of this line is deduced): nr.declarations = rule.declarations;

1777

nr.order = i;

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

1778

QString name = sel.elementName;

executed (the execution status of this line is deduced): QString name = sel.elementName;

1779

if (nameCaseSensitivity == Qt::CaseInsensitive)

evaluated: nameCaseSensitivity == Qt::CaseInsensitive

TRUE	FALSE
yes Evaluation Count:49	yes Evaluation Count:7823

49-7823

1780

name=name.toLower();

executed: name=name.toLower();

Execution Count:49

1781

nameIndex.insert(name, nr);

executed (the execution status of this line is deduced): nameIndex.insert(name, nr);

1782

universalsSelectors += selector;

executed: }

Execution Count:7872

7872

1783

executed (the execution status of this line is deduced): universalsSelectors += selector;

1784

if (!universalsSelectors.isEmpty()) {

executed: }

Execution Count:186

186

1785 } -

1786

evaluated: !universalsSelectors.isEmpty()

TRUE	FALSE
yes Evaluation Count:185	yes Evaluation Count:6661

185-6661

1787

StyleRule nr;

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

1788

nr.selectors = universalsSelectors;

executed (the execution status of this line is deduced): nr.selectors = universalsSelectors;

1789

nr.declarations = rule.declarations;

executed (the execution status of this line is deduced): nr.declarations = rule.declarations;

1790

nr.order = i;

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

1791

universals << nr;

executed (the execution status of this line is deduced): universals << nr;

1792

executed: }

Execution Count:185

185

1793

executed: }

Execution Count:6846

6846

1794

styleRules = universals;

executed (the execution status of this line is deduced): styleRules = universals;

1795

return nodeNames(node).contains(nodeName, nameCaseSensitivity);

executed: }

Execution Count:1020

1020

1796 -

1797 /////////////////////////////////////////////////////////////////////////////// -

1798 // StyleSelector -

1799 StyleSelector::~StyleSelector() -

1800 { -

1801 } -

1802 -

1803 bool StyleSelector::nodeNameEquals(NodePtr node, const QString& nodeName) const -

1804 { -

1805

executed: return nodeNames(node).contains(nodeName, nameCaseSensitivity);

Execution Count:74

1806 } -

1807 -

1808 QStringList StyleSelector::nodeIds(NodePtr node) const -

1809 { -

1810

return QStringList(attribute(node, QLatin1String("id")));

never executed: return QStringList(attribute(node, QLatin1String("id")));

1811 } -

1812 -

1813 bool StyleSelector::selectorMatches(const Selector &selector, NodePtr node) -

1814 { -

1815

if (selector.basicSelectors.isEmpty())

partially evaluated: selector.basicSelectors.isEmpty()

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

0-1776

1816

if (selector.basicSelectors.at(0).relationToNext == BasicSelector::NoRelation) {

never executed: return false;

1817 -

1818

evaluated: selector.basicSelectors.at(0).relationToNext == BasicSelector::NoRelation

TRUE	FALSE
yes Evaluation Count:1772	yes Evaluation Count:4

4-1772

1819

if (selector.basicSelectors.count() != 1)

partially evaluated: selector.basicSelectors.count() != 1

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

0-1772

1820

return basicSelectorMatches(selector.basicSelectors.at(0), node);

never executed: return false;

1821

executed: return basicSelectorMatches(selector.basicSelectors.at(0), node);

Execution Count:1772

1772

1822 } -

1823

if (selector.basicSelectors.count() <= 1)

partially evaluated: selector.basicSelectors.count() <= 1

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

0-4

1824

int i = selector.basicSelectors.count() - 1;

never executed: return false;

1825 -

1826

executed (the execution status of this line is deduced): int i = selector.basicSelectors.count() - 1;

1827

node = duplicateNode(node);

executed (the execution status of this line is deduced): node = duplicateNode(node);

1828

bool match = true;

executed (the execution status of this line is deduced): bool match = true;

1829 -

1830

BasicSelector sel = selector.basicSelectors.at(i);

executed (the execution status of this line is deduced): BasicSelector sel = selector.basicSelectors.at(i);

1831 do { -

1832

match = basicSelectorMatches(sel, node);

executed (the execution status of this line is deduced): match = basicSelectorMatches(sel, node);

1833

if (!match) {

partially evaluated: !match

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

0-4

1834

if (sel.relationToNext == BasicSelector::MatchNextSelectorIfParent

partially evaluated: sel.relationToNext == BasicSelector::MatchNextSelectorIfParent

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

0-4

1835

|| i == selector.basicSelectors.count() - 1) // first element must always match!

partially evaluated: i == selector.basicSelectors.count() - 1

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

0-4

1836

executed: break;

Execution Count:4

1837

if (match || sel.relationToNext != BasicSelector::MatchNextSelectorIfAncestor)

never executed: }

1838 -

1839

never evaluated: match

never evaluated: sel.relationToNext != BasicSelector::MatchNextSelectorIfAncestor

1840

--i;

never executed: --i;

1841 -

1842

if (i < 0)

never evaluated: i < 0

1843

sel = selector.basicSelectors.at(i);

never executed: break;

1844 -

1845

never executed (the execution status of this line is deduced): sel = selector.basicSelectors.at(i);

1846

if (sel.relationToNext == BasicSelector::MatchNextSelectorIfAncestor

never evaluated: sel.relationToNext == BasicSelector::MatchNextSelectorIfAncestor

1847

|| sel.relationToNext == BasicSelector::MatchNextSelectorIfParent) {

never evaluated: sel.relationToNext == BasicSelector::MatchNextSelectorIfParent

1848 -

1849

NodePtr nextParent = parentNode(node);

never executed (the execution status of this line is deduced): NodePtr nextParent = parentNode(node);

1850

freeNode(node);

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

1851

node = nextParent;

never executed (the execution status of this line is deduced): node = nextParent;

1852

} else if (sel.relationToNext == BasicSelector::MatchNextSelectorIfPreceeds) {

never executed: }

never evaluated: sel.relationToNext == BasicSelector::MatchNextSelectorIfPreceeds

1853

NodePtr previousSibling = previousSiblingNode(node);

never executed (the execution status of this line is deduced): NodePtr previousSibling = previousSiblingNode(node);

1854

freeNode(node);

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

1855

node = previousSibling;

never executed (the execution status of this line is deduced): node = previousSibling;

1856

never executed: }

1857

if (isNullNode(node)) {

never evaluated: isNullNode(node)

1858

match = false;

never executed (the execution status of this line is deduced): match = false;

1859

} while (i >= 0 && (match || sel.relationToNext == BasicSelector::MatchNextSelectorIfAncestor));

never executed: break;

1860 } -

1861

never executed: }

never evaluated: i >= 0

never evaluated: match

never evaluated: sel.relationToNext == BasicSelector::MatchNextSelectorIfAncestor

1862 -

1863

freeNode(node);

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

1864 -

1865

return match;

executed: return match;

Execution Count:4

1866 } -

1867 -

1868 bool StyleSelector::basicSelectorMatches(const BasicSelector &sel, NodePtr node) -

1869 { -

1870

if (!sel.attributeSelectors.isEmpty()) {

evaluated: !sel.attributeSelectors.isEmpty()

TRUE	FALSE
yes Evaluation Count:22	yes Evaluation Count:1754

22-1754

1871

if (!hasAttributes(node))

partially evaluated: !hasAttributes(node)

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

0-22

1872

for (int i = 0; i < sel.attributeSelectors.count(); ++i) {

never executed: return false;

1873 -

1874

evaluated: i < sel.attributeSelectors.count()

TRUE	FALSE
yes Evaluation Count:22	yes Evaluation Count:9

9-22

1875

const QCss::AttributeSelector &a = sel.attributeSelectors.at(i);

executed (the execution status of this line is deduced): const QCss::AttributeSelector &a = sel.attributeSelectors.at(i);

1876 -

1877

const QString attrValue = attribute(node, a.name);

executed (the execution status of this line is deduced): const QString attrValue = attribute(node, a.name);

1878

if (attrValue.isNull())

evaluated: attrValue.isNull()

TRUE	FALSE
yes Evaluation Count:5	yes Evaluation Count:17

5-17

1879

if (a.valueMatchCriterium == QCss::AttributeSelector::MatchContains) {

executed: return false;

Execution Count:5

1880 -

1881

evaluated: a.valueMatchCriterium == QCss::AttributeSelector::MatchContains

TRUE	FALSE
yes Evaluation Count:5	yes Evaluation Count:12

5-12

1882 -

1883

QStringList lst = attrValue.split(QLatin1Char(' '));

executed (the execution status of this line is deduced): QStringList lst = attrValue.split(QLatin1Char(' '));

1884

if (!lst.contains(a.value))

evaluated: !lst.contains(a.value)

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

2-3

1885

(a.valueMatchCriterium == QCss::AttributeSelector::MatchEqual

executed: return false;

Execution Count:2

1886

} else if (

executed: }

Execution Count:3

1887

evaluated: a.valueMatchCriterium == QCss::AttributeSelector::MatchEqual

TRUE	FALSE
yes Evaluation Count:9	yes Evaluation Count:3

3-9

1888

&& attrValue != a.value)

evaluated: attrValue != a.value

TRUE	FALSE
yes Evaluation Count:5	yes Evaluation Count:4

4-5

1889

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

1890

(a.valueMatchCriterium == QCss::AttributeSelector::MatchBeginsWith

evaluated: a.valueMatchCriterium == QCss::AttributeSelector::MatchBeginsWith

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:5

2-5

1891

&& !attrValue.startsWith(a.value))

evaluated: !attrValue.startsWith(a.value)

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

1892 ) -

1893

executed: return false;

Execution Count:6

1894 } -

1895

if (!sel.elementName.isEmpty()

executed: }

Execution Count:9

1896 -

1897

evaluated: !sel.elementName.isEmpty()

TRUE	FALSE
yes Evaluation Count:1724	yes Evaluation Count:39

39-1724

1898

&& !nodeNameEquals(node, sel.elementName))

partially evaluated: !nodeNameEquals(node, sel.elementName)

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

0-1724

1899

&& sel.ids != nodeIds(node))

never executed: return false;

1900 -

1901

if (!sel.ids.isEmpty()

partially evaluated: !sel.ids.isEmpty()

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

0-1763

1902

never evaluated: sel.ids != nodeIds(node)

1903

never executed: return false;

1904 -

1905

for (int j = 0; j < rule.selectors.count(); ++j) {

executed: return true;

Execution Count:1763

1763

1906 } -

1907 -

1908 void StyleSelector::matchRule(NodePtr node, const StyleRule &rule, StyleSheetOrigin origin, -

1909 int depth, QMap<uint, StyleRule> *weightedRules) -

1910 { -

1911

evaluated: j < rule.selectors.count()

TRUE	FALSE
yes Evaluation Count:1776	yes Evaluation Count:1775

1775-1776

1912

const Selector& selector = rule.selectors.at(j);

executed (the execution status of this line is deduced): const Selector& selector = rule.selectors.at(j);

1913

if (selectorMatches(selector, node)) {

evaluated: selectorMatches(selector, node)

TRUE	FALSE
yes Evaluation Count:1763	yes Evaluation Count:13

13-1763

1914

uint weight = rule.order

executed (the execution status of this line is deduced): uint weight = rule.order

1915

+ selector.specificity() *0x100

executed (the execution status of this line is deduced): + selector.specificity() *0x100

1916

+ (uint(origin) + depth)*0x100000;

executed (the execution status of this line is deduced): + (uint(origin) + depth)*0x100000;

1917

StyleRule newRule = rule;

executed (the execution status of this line is deduced): StyleRule newRule = rule;

1918

if(rule.selectors.count() > 1) {

partially evaluated: rule.selectors.count() > 1

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

0-1763

1919

newRule.selectors.resize(1);

never executed (the execution status of this line is deduced): newRule.selectors.resize(1);

1920

newRule.selectors[0] = selector;

never executed (the execution status of this line is deduced): newRule.selectors[0] = selector;

1921

weightedRules->insertMulti(weight, newRule);

never executed: }

1922 //We might have rules with the same weight if they came from a rule with several selectors -

1923

executed (the execution status of this line is deduced): weightedRules->insertMulti(weight, newRule);

1924

executed: }

Execution Count:1763

1763

1925

executed: }

Execution Count:1776

1776

1926

QVector<StyleRule> rules;

executed: }

Execution Count:1775

1775

1927 -

1928 // Returns style rules that are in ascending order of specificity -

1929 // Each of the StyleRule returned will contain exactly one Selector -

1930 QVector<StyleRule> StyleSelector::styleRulesForNode(NodePtr node) -

1931 { -

1932

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

1933

if (styleSheets.isEmpty())

partially evaluated: styleSheets.isEmpty()

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

0-3985

1934

return rules;

never executed: return rules;

1935 -

1936

QMap<uint, StyleRule> weightedRules; // (spec, rule) that will be sorted below

executed (the execution status of this line is deduced): QMap<uint, StyleRule> weightedRules;

1937 -

1938 //prune using indexed stylesheet -

1939

for (int sheetIdx = 0; sheetIdx < styleSheets.count(); ++sheetIdx) {

evaluated: sheetIdx < styleSheets.count()

TRUE	FALSE
yes Evaluation Count:6502	yes Evaluation Count:3985

3985-6502

1940

const StyleSheet &styleSheet = styleSheets.at(sheetIdx);

executed (the execution status of this line is deduced): const StyleSheet &styleSheet = styleSheets.at(sheetIdx);

1941

for (int i = 0; i < styleSheet.styleRules.count(); ++i) {

evaluated: i < styleSheet.styleRules.count()

TRUE	FALSE
yes Evaluation Count:46	yes Evaluation Count:6502

46-6502

1942

matchRule(node, styleSheet.styleRules.at(i), styleSheet.origin, styleSheet.depth, &weightedRules);

executed (the execution status of this line is deduced): matchRule(node, styleSheet.styleRules.at(i), styleSheet.origin, styleSheet.depth, &weightedRules);

1943

if (!styleSheet.idIndex.isEmpty()) {

executed: }

Execution Count:46

1944 -

1945

partially evaluated: !styleSheet.idIndex.isEmpty()

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

0-6502

1946

QStringList ids = nodeIds(node);

never executed (the execution status of this line is deduced): QStringList ids = nodeIds(node);

1947

for (int i = 0; i < ids.count(); i++) {

never evaluated: i < ids.count()

1948

const QString &key = ids.at(i);

never executed (the execution status of this line is deduced): const QString &key = ids.at(i);

1949

QMultiHash<QString, StyleRule>::const_iterator it = styleSheet.idIndex.constFind(key);

never executed (the execution status of this line is deduced): QMultiHash<QString, StyleRule>::const_iterator it = styleSheet.idIndex.constFind(key);

1950

while (it != styleSheet.idIndex.constEnd() && it.key() == key) {

never evaluated: it != styleSheet.idIndex.constEnd()

never evaluated: it.key() == key

1951

matchRule(node, it.value(), styleSheet.origin, styleSheet.depth, &weightedRules);

never executed (the execution status of this line is deduced): matchRule(node, it.value(), styleSheet.origin, styleSheet.depth, &weightedRules);

1952

++it;

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

never executed: }

never executed: }

never executed: }

if (!styleSheet.nameIndex.isEmpty()) {

evaluated: !styleSheet.nameIndex.isEmpty()

TRUE	FALSE
yes Evaluation Count:2539	yes Evaluation Count:3963

2539-3963

1957

QStringList names = nodeNames(node);

executed (the execution status of this line is deduced): QStringList names = nodeNames(node);

1958

for (int i = 0; i < names.count(); i++) {

evaluated: i < names.count()

TRUE	FALSE
yes Evaluation Count:9008	yes Evaluation Count:2539

2539-9008

1959

QString name = names.at(i);

executed (the execution status of this line is deduced): QString name = names.at(i);

1960

if (nameCaseSensitivity == Qt::CaseInsensitive)

evaluated: nameCaseSensitivity == Qt::CaseInsensitive

TRUE	FALSE
yes Evaluation Count:116	yes Evaluation Count:8892

116-8892

1961

name = name.toLower();

executed: name = name.toLower();

Execution Count:116

116

1962

QMultiHash<QString, StyleRule>::const_iterator it = styleSheet.nameIndex.constFind(name);

executed (the execution status of this line is deduced): QMultiHash<QString, StyleRule>::const_iterator it = styleSheet.nameIndex.constFind(name);

1963

while (it != styleSheet.nameIndex.constEnd() && it.key() == name) {

evaluated: it != styleSheet.nameIndex.constEnd()

TRUE	FALSE
yes Evaluation Count:3373	yes Evaluation Count:7362

evaluated: it.key() == name

TRUE	FALSE
yes Evaluation Count:1727	yes Evaluation Count:1646

1646-7362

1964

matchRule(node, it.value(), styleSheet.origin, styleSheet.depth, &weightedRules);

executed (the execution status of this line is deduced): matchRule(node, it.value(), styleSheet.origin, styleSheet.depth, &weightedRules);

1965

++it;

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

1966

executed: }

Execution Count:1727

1727

1967

executed: }

Execution Count:9008

9008

1968

for (int i = 0; i < styleSheet.mediaRules.count(); ++i) {

executed: }

Execution Count:2539

2539

1969

if (!medium.isEmpty()) {

evaluated: !medium.isEmpty()

TRUE	FALSE
yes Evaluation Count:1718	yes Evaluation Count:4784

1718-4784

1970

evaluated: i < styleSheet.mediaRules.count()

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:1718

3-1718

1971

if (styleSheet.mediaRules.at(i).media.contains(medium, Qt::CaseInsensitive)) {

evaluated: styleSheet.mediaRules.at(i).media.contains(medium, Qt::CaseInsensitive)

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

1-2

1972

for (int j = 0; j < styleSheet.mediaRules.at(i).styleRules.count(); ++j) {

evaluated: j < styleSheet.mediaRules.at(i).styleRules.count()

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

1973

matchRule(node, styleSheet.mediaRules.at(i).styleRules.at(j), styleSheet.origin,

executed (the execution status of this line is deduced): matchRule(node, styleSheet.mediaRules.at(i).styleRules.at(j), styleSheet.origin,

1974

styleSheet.depth, &weightedRules);

executed (the execution status of this line is deduced): styleSheet.depth, &weightedRules);

1975

executed: }

Execution Count:2

1976

executed: }

Execution Count:2

1977

executed: }

Execution Count:3

1978

executed: }

Execution Count:1718

1718

1979

rules.reserve(weightedRules.count());

executed: }

Execution Count:6502

6502

1980 -

1981

executed (the execution status of this line is deduced): rules.reserve(weightedRules.count());

1982

QMap<uint, StyleRule>::const_iterator it = weightedRules.constBegin();

executed (the execution status of this line is deduced): QMap<uint, StyleRule>::const_iterator it = weightedRules.constBegin();

1983

for ( ; it != weightedRules.constEnd() ; ++it)

evaluated: it != weightedRules.constEnd()

TRUE	FALSE
yes Evaluation Count:1763	yes Evaluation Count:3985

1763-3985

1984

rules += *it;

executed: rules += *it;

Execution Count:1763

1763

1985 -

1986

return rules;

executed: return rules;

Execution Count:3985

3985

1987 } -

1988 -

1989 // for qtexthtmlparser which requires just the declarations with Enabled state -

1990 // and without pseudo elements -

1991 QVector<Declaration> StyleSelector::declarationsForNode(NodePtr node, const char *extraPseudo) -

1992 { -

1993

QVector<Declaration> decls;

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

1994

QVector<StyleRule> rules = styleRulesForNode(node);

executed (the execution status of this line is deduced): QVector<StyleRule> rules = styleRulesForNode(node);

1995

for (int i = 0; i < rules.count(); i++) {

evaluated: i < rules.count()

TRUE	FALSE
yes Evaluation Count:78	yes Evaluation Count:1593

78-1593

1996

const Selector& selector = rules.at(i).selectors.at(0);

executed (the execution status of this line is deduced): const Selector& selector = rules.at(i).selectors.at(0);

1997

const QString pseudoElement = selector.pseudoElement();

executed (the execution status of this line is deduced): const QString pseudoElement = selector.pseudoElement();

1998 -

1999

if (extraPseudo && pseudoElement == QLatin1String(extraPseudo)) {

evaluated: extraPseudo

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:76

evaluated: pseudoElement == QLatin1String(extraPseudo)

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

1-76

2000

decls += rules.at(i).declarations;

executed (the execution status of this line is deduced): decls += rules.at(i).declarations;

2001

if (!pseudoElement.isEmpty()) // skip rules with pseudo elements

executed: continue;

Execution Count:1

2002 } -

2003 -

2004

partially evaluated: !pseudoElement.isEmpty()

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

0-77

2005

quint64 pseudoClass = selector.pseudoClass();

never executed: continue;

2006

executed (the execution status of this line is deduced): quint64 pseudoClass = selector.pseudoClass();

2007

if (pseudoClass == PseudoClass_Enabled || pseudoClass == PseudoClass_Unspecified)

partially evaluated: pseudoClass == PseudoClass_Enabled

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

partially evaluated: pseudoClass == PseudoClass_Unspecified

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

0-77

2008

decls += rules.at(i).declarations;

executed: decls += rules.at(i).declarations;

Execution Count:77

2009

return (c >= '0' && c <= '9')

executed: }

Execution Count:77

2010

return decls;

executed: return decls;

Execution Count:1593

1593

2011 } -

2012 -

2013 static inline bool isHexDigit(const char c) -

2014 { -

2015

executed: return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') ;

Execution Count:3

2016

|| (c >= 'a' && c <= 'f')

executed: return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') ;

Execution Count:3

2017

|| (c >= 'A' && c <= 'F')

executed: return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') ;

Execution Count:3

2018

;

executed: return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') ;

Execution Count:3

2019 } -

2020 -

2021 QString Scanner::preprocess(const QString &input, bool *hasEscapeSequences) -

2022 { -

2023

QString output = input;

executed (the execution status of this line is deduced): QString output = input;

2024 -

2025

if (hasEscapeSequences)

partially evaluated: hasEscapeSequences

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

0-627

2026

*hasEscapeSequences = false;

executed: *hasEscapeSequences = false;

Execution Count:627

627

2027 -

2028

while (i < output.size()) {

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

2029

evaluated: i < output.size()

TRUE	FALSE
yes Evaluation Count:12232	yes Evaluation Count:627

627-12232

2030

if (output.at(i) == QLatin1Char('\\')) {

evaluated: output.at(i) == QLatin1Char('\\')

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:12231

1-12231

2031 -

2032

&& isHexDigit(output.at(i).toLatin1())

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

2033 // test for unicode hex escape -

2034

int hexCount = 0;

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

2035

const int hexStart = i;

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

2036

while (i < output.size()

partially evaluated: i < output.size()

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

0-3

2037

evaluated: isHexDigit(output.at(i).toLatin1())

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

1-2

2038

&& hexCount < 7) {

partially evaluated: hexCount < 7

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

0-2

2039

++hexCount;

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

2040

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

2041

*hasEscapeSequences = true;

executed: }

Execution Count:2

2042

if (hexCount == 0) {

partially evaluated: hexCount == 0

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

0-1

2043

if (hasEscapeSequences)

never evaluated: hasEscapeSequences

2044

never executed: *hasEscapeSequences = true;

2045

hexCount = qMin(hexCount, 6);

never executed: continue;

2046 } -

2047 -

2048

executed (the execution status of this line is deduced): hexCount = qMin(hexCount, 6);

2049

bool ok = false;

executed (the execution status of this line is deduced): bool ok = false;

2050

ushort code = output.mid(hexStart, hexCount).toUShort(&ok, 16);

executed (the execution status of this line is deduced): ushort code = output.mid(hexStart, hexCount).toUShort(&ok, 16);

2051

if (ok) {

partially evaluated: ok

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

0-1

2052

output.replace(hexStart - 1, hexCount + 1, QChar(code));

executed (the execution status of this line is deduced): output.replace(hexStart - 1, hexCount + 1, QChar(code));

2053

i = hexStart;

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

2054

executed: }

Execution Count:1

2055

i = hexStart;

never executed (the execution status of this line is deduced): i = hexStart;

2056

never executed: }

2057 } else { -

2058

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

2059

while (pos < input.size() - 1) {

executed: }

Execution Count:12231

12231

2060 } -

2061

return output;

executed: return output;

Execution Count:627

627

2062 } -

2063 -

2064 int QCssScanner_Generated::handleCommentStart() -

2065 { -

2066

partially evaluated: pos < input.size() - 1

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

0-3

2067

if (input.at(pos) == QLatin1Char('*')

evaluated: input.at(pos) == QLatin1Char('*')

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

1-2

2068

&& input.at(pos + 1) == QLatin1Char('/')) {

partially evaluated: input.at(pos + 1) == QLatin1Char('/')

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

0-1

2069

pos += 2;

executed (the execution status of this line is deduced): pos += 2;

2070

executed: break;

Execution Count:1

2071 } -

2072

++pos;

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

2073

QCssScanner_Generated scanner(preprocessedInput);

executed: }

Execution Count:2

2074

return S;

executed: return S;

Execution Count:1

2075 } -

2076 -

2077 void Scanner::scan(const QString &preprocessedInput, QVector<Symbol> *symbols) -

2078 { -

2079

executed (the execution status of this line is deduced): QCssScanner_Generated scanner(preprocessedInput);

2080

Symbol sym;

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

2081

int tok = scanner.lex();

executed (the execution status of this line is deduced): int tok = scanner.lex();

2082

while (tok != -1) {

evaluated: tok != -1

TRUE	FALSE
yes Evaluation Count:3930	yes Evaluation Count:627

627-3930

2083

sym.token = static_cast<QCss::TokenType>(tok);

executed (the execution status of this line is deduced): sym.token = static_cast<QCss::TokenType>(tok);

2084

sym.text = scanner.input;

executed (the execution status of this line is deduced): sym.text = scanner.input;

2085

sym.start = scanner.lexemStart;

executed (the execution status of this line is deduced): sym.start = scanner.lexemStart;

2086

sym.len = scanner.lexemLength;

executed (the execution status of this line is deduced): sym.len = scanner.lexemLength;

2087

symbols->append(sym);

executed (the execution status of this line is deduced): symbols->append(sym);

2088

tok = scanner.lex();

executed (the execution status of this line is deduced): tok = scanner.lex();

2089

executed: }

Execution Count:3930

3930

2090

for (int i = 0; i < len; ++i) {

executed: }

Execution Count:627

627

2091 -

2092 QString Symbol::lexem() const -

2093 { -

2094

QString result;

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

2095

if (len > 0)

partially evaluated: len > 0

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

0-1232

2096

result.reserve(len);

executed: result.reserve(len);

Execution Count:1232

1232

2097

evaluated: i < len

TRUE	FALSE
yes Evaluation Count:9399	yes Evaluation Count:1232

1232-9399

2098

if (text.at(start + i) == QLatin1Char('\\') && i < len - 1)

partially evaluated: text.at(start + i) == QLatin1Char('\\')

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

never evaluated: i < len - 1

0-9399

2099

result += text.at(start + i);

never executed: ++i;

2100

executed (the execution status of this line is deduced): result += text.at(start + i);

2101

executed: }

Execution Count:9399

9399

2102

return result;

executed: return result;

Execution Count:1232

1232

2103 } -

2104 -

2105 Parser::Parser(const QString &css, bool isFile) -

2106 { -

2107

init(css, isFile);

executed (the execution status of this line is deduced): init(css, isFile);

2108

hasEscapeSequences = false;

executed: }

Execution Count:221

221

2109 -

2110 Parser::Parser() -

2111 { -

2112

index = 0;

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

2113

errorIndex = -1;

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

2114

executed (the execution status of this line is deduced): hasEscapeSequences = false;

2115

QString styleSheet = css;

executed: }

Execution Count:402

402

2116 -

2117 void Parser::init(const QString &css, bool isFile) -

2118 { -

2119

executed (the execution status of this line is deduced): QString styleSheet = css;

2120

if (isFile) {

partially evaluated: isFile

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

0-627

2121

QFile file(css);

never executed (the execution status of this line is deduced): QFile file(css);

2122

if (file.open(QFile::ReadOnly)) {

never evaluated: file.open(QFile::ReadOnly)

2123

sourcePath = QFileInfo(styleSheet).absolutePath() + QLatin1Char('/');

never executed (the execution status of this line is deduced): sourcePath = QFileInfo(styleSheet).absolutePath() + QLatin1Char('/');

2124

QTextStream stream(&file);

never executed (the execution status of this line is deduced): QTextStream stream(&file);

2125

styleSheet = stream.readAll();

never executed (the execution status of this line is deduced): styleSheet = stream.readAll();

2126

qWarning() << "QCss::Parser - Failed to load file " << css;

never executed: }

2127

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

 QMessageLogger("text/qcssparser.cpp", 2127, __PRETTY_FUNCTION__).warning() << "QCss::Parser - Failed to load file " << css;

2128

styleSheet.clear();

never executed (the execution status of this line is deduced): styleSheet.clear();

2129

never executed: }

2130 } else { -

2131

sourcePath.clear();

executed (the execution status of this line is deduced): sourcePath.clear();

2132

hasEscapeSequences = false;

executed: }

Execution Count:627

627

2133 -

2134

executed (the execution status of this line is deduced): hasEscapeSequences = false;

2135

symbols.resize(0);

executed (the execution status of this line is deduced): symbols.resize(0);

2136

symbols.reserve(8);

executed (the execution status of this line is deduced): symbols.reserve(8);

2137

Scanner::scan(Scanner::preprocess(styleSheet, &hasEscapeSequences), &symbols);

executed (the execution status of this line is deduced): Scanner::scan(Scanner::preprocess(styleSheet, &hasEscapeSequences), &symbols);

2138

index = 0;

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

2139

errorIndex = -1;

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

2140

if (testTokenAndEndsWith(ATKEYWORD_SYM, QLatin1String("charset"))) {

executed: }

Execution Count:627

627

2141 -

2142 bool Parser::parse(StyleSheet *styleSheet, Qt::CaseSensitivity nameCaseSensitivity) -

2143 { -

2144

partially evaluated: testTokenAndEndsWith(ATKEYWORD_SYM, QLatin1String("charset"))

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

0-626

2145

if (!next(STRING)) return false;

never executed: return false;

never evaluated: !next(STRING)

2146

if (!next(SEMICOLON)) return false;

never executed: return false;

never evaluated: !next(SEMICOLON)

2147

while (test(S) || test(CDO) || test(CDC)) {}

never executed: }

2148 -

2149

executed: }

Execution Count:406

evaluated: test(S)

TRUE	FALSE
yes Evaluation Count:406	yes Evaluation Count:626

partially evaluated: test(CDO)

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

partially evaluated: test(CDC)

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

0-626

2150 -

2151

while (testImport()) {

evaluated: testImport()

TRUE	FALSE
yes Evaluation Count:5	yes Evaluation Count:626

5-626

2152

ImportRule rule;

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

2153

if (!parseImport(&rule)) return false;

never executed: return false;

partially evaluated: !parseImport(&rule)

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

0-5

2154

styleSheet->importRules.append(rule);

executed (the execution status of this line is deduced): styleSheet->importRules.append(rule);

2155

while (test(S) || test(CDO) || test(CDC)) {}

never executed: }

partially evaluated: test(S)

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

partially evaluated: test(CDO)

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

partially evaluated: test(CDC)

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

0-5

2156

if (!parseMedia(&rule)) return false;

executed: }

Execution Count:5

2157 -

2158 do { -

2159

if (testMedia()) {

evaluated: testMedia()

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:635

3-635

2160

MediaRule rule;

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

2161

never executed: return false;

partially evaluated: !parseMedia(&rule)

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

0-3

2162

styleSheet->mediaRules.append(rule);

executed (the execution status of this line is deduced): styleSheet->mediaRules.append(rule);

2163

} else if (testPage()) {

executed: }

Execution Count:3

partially evaluated: testPage()

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

0-635

2164

PageRule rule;

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

2165

if (!parsePage(&rule)) return false;

never executed: return false;

never evaluated: !parsePage(&rule)

2166

styleSheet->pageRules.append(rule);

never executed (the execution status of this line is deduced): styleSheet->pageRules.append(rule);

2167

} else if (testRuleset()) {

never executed: }

evaluated: testRuleset()

TRUE	FALSE
yes Evaluation Count:244	yes Evaluation Count:391

0-391

2168

StyleRule rule;

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

2169

if (!parseRuleset(&rule)) return false;

executed: return false;

Execution Count:6

evaluated: !parseRuleset(&rule)

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:238

6-238

2170

styleSheet->styleRules.append(rule);

executed (the execution status of this line is deduced): styleSheet->styleRules.append(rule);

2171

} else if (test(ATKEYWORD_SYM)) {

executed: }

Execution Count:238

partially evaluated: test(ATKEYWORD_SYM)

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

0-391

2172

if (!until(RBRACE)) return false;

never executed: return false;

never evaluated: !until(RBRACE)

2173

} else if (hasNext()) {

never executed: }

evaluated: hasNext()

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:390

0-390

2174

while (test(S) || test(CDO) || test(CDC)) {}

executed: return false;

Execution Count:1

2175 } -

2176

never executed: }

partially evaluated: test(S)

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

partially evaluated: test(CDO)

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

partially evaluated: test(CDC)

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

0-631

2177

} while (hasNext());

executed: }

Execution Count:631

evaluated: hasNext()

TRUE	FALSE
yes Evaluation Count:12	yes Evaluation Count:619

12-631

2178

styleSheet->buildIndexes(nameCaseSensitivity);

executed (the execution status of this line is deduced): styleSheet->buildIndexes(nameCaseSensitivity);

2179

if (errorIndex == -1) return Symbol();

executed: return true;

Execution Count:619

619

2180 } -

2181 -

2182 Symbol Parser::errorSymbol() -

2183 { -

2184

never executed: return Symbol();

never evaluated: errorIndex == -1

2185

return symbols.at(errorIndex);

never executed: return symbols.at(errorIndex);

2186 } -

2187 -

2188 static inline void removeOptionalQuotes(QString *str) -

2189 { -

2190

if (!str->startsWith(QLatin1Char('\''))

evaluated: !str->startsWith(QLatin1Char('\''))

TRUE	FALSE
yes Evaluation Count:8	yes Evaluation Count:2

2-8

2191

&& !str->startsWith(QLatin1Char('\"')))

evaluated: !str->startsWith(QLatin1Char('\"'))

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:5

3-5

2192

executed: return;

Execution Count:3

2193

str->remove(0, 1);

executed (the execution status of this line is deduced): str->remove(0, 1);

2194

str->chop(1);

executed (the execution status of this line is deduced): str->chop(1);

2195

executed: }

Execution Count:7

2196 -

2197 bool Parser::parseImport(ImportRule *importRule) -

2198 { -

2199

importRule->href = lexem();

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

2200 -

2201

if (test(STRING)) {

evaluated: test(STRING)

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

2-3

2202

executed (the execution status of this line is deduced): importRule->href = lexem();

2203

if (!testAndParseUri(&importRule->href)) return false;

executed: }

Execution Count:3

2204

never executed: return false;

partially evaluated: !testAndParseUri(&importRule->href)

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

0-2

2205

removeOptionalQuotes(&importRule->href);

executed: }

Execution Count:2

2206

executed (the execution status of this line is deduced): removeOptionalQuotes(&importRule->href);

2207 -

2208

if (!parseMedium(&importRule->media)) return false;

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

2209 -

2210

if (testMedium()) {

evaluated: testMedium()

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:4

1-4

2211

never executed: return false;

partially evaluated: !parseMedium(&importRule->media)

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

0-1

2212 -

2213

while (test(COMMA)) {

partially evaluated: test(COMMA)

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

0-1

2214

if (!parseNextMedium(&importRule->media)) return false;

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

2215

never executed: return false;

never evaluated: !parseNextMedium(&importRule->media)

never executed: }

executed: }

Execution Count:1

2218 -

2219

if (!next(SEMICOLON)) return false;

never executed: return false;

partially evaluated: !next(SEMICOLON)

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

0-5

2220 -

2221

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

2222

executed: return true;

Execution Count:5

2223 } -

2224 -

2225 bool Parser::parseMedia(MediaRule *mediaRule) -

2226 { -

2227 do { -

2228

if (!parseNextMedium(&mediaRule->media)) return false;

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

2229

never executed: return false;

partially evaluated: !parseNextMedium(&mediaRule->media)

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

0-3

2230

} while (test(COMMA));

executed: }

Execution Count:3

partially evaluated: test(COMMA)

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

0-3

2231 -

2232

if (!next(LBRACE)) return false;

never executed: return false;

partially evaluated: !next(LBRACE)

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

0-3

2233

if (!parseRuleset(&rule)) return false;

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

2234 -

2235

while (testRuleset()) {

evaluated: testRuleset()

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

2236

StyleRule rule;

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

2237

never executed: return false;

partially evaluated: !parseRuleset(&rule)

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

0-3

2238

mediaRule->styleRules.append(rule);

executed (the execution status of this line is deduced): mediaRule->styleRules.append(rule);

2239

if (!next(RBRACE)) return false;

executed: }

Execution Count:3

2240 -

2241

never executed: return false;

partially evaluated: !next(RBRACE)

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

0-3

2242

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

2243

executed: return true;

Execution Count:3

2244 } -

2245 -

2246 bool Parser::parseMedium(QStringList *media) -

2247 { -

2248

media->append(lexem());

executed (the execution status of this line is deduced): media->append(lexem());

2249

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

2250

executed: return true;

Execution Count:4

2251 } -

2252 -

2253 bool Parser::parsePage(PageRule *pageRule) -

2254 { -

2255

if (!parsePseudoPage(&pageRule->selector)) return false;

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

2256 -

2257

if (testPseudoPage())

never evaluated: testPseudoPage()

2258

never executed: return false;

never evaluated: !parsePseudoPage(&pageRule->selector)

2259 -

2260

if (!next(LBRACE)) return false;

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

2261

never executed: return false;

never evaluated: !next(LBRACE)

2262 -

2263 do { -

2264

if (!parseNextDeclaration(&decl)) return false;

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

2265

Declaration decl;

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

2266

never executed: return false;

never evaluated: !parseNextDeclaration(&decl)

2267

if (!decl.isEmpty())

never evaluated: !decl.isEmpty()

2268

pageRule->declarations.append(decl);

never executed: pageRule->declarations.append(decl);

2269

} while (test(SEMICOLON));

never executed: }

never evaluated: test(SEMICOLON)

2270 -

2271

if (!next(RBRACE)) return false;

never executed: return false;

never evaluated: !next(RBRACE)

2272

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

2273

if (!next(IDENT)) return false;

never executed: return true;

2274 } -

2275 -

2276 bool Parser::parsePseudoPage(QString *selector) -

2277 { -

2278

never executed: return false;

never evaluated: !next(IDENT)

2279

*selector = lexem();

never executed (the execution status of this line is deduced): *selector = lexem();

2280

if (!hasNext()) return true;

never executed: return true;

2281 } -

2282 -

2283 bool Parser::parseNextOperator(Value *value) -

2284 { -

2285

executed: return true;

Execution Count:1

evaluated: !hasNext()

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:542

1-542

2286 switch (next()) { -

2287

case SLASH: value->type = Value::TermOperatorSlash; skipSpace(); break;

never executed: break;

2288

case COMMA: value->type = Value::TermOperatorComma; skipSpace(); break;

executed: break;

Execution Count:4

2289

default: prev(); break;

executed: break;

Execution Count:538

538

2290 } -

2291

*relation = BasicSelector::NoRelation;

executed: return true;

Execution Count:542

542

2292 } -

2293 -

2294 bool Parser::parseCombinator(BasicSelector::Relation *relation) -

2295 { -

2296

executed (the execution status of this line is deduced): *relation = BasicSelector::NoRelation;

2297

if (lookup() == S) {

partially evaluated: lookup() == S

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

0-3

2298

*relation = BasicSelector::MatchNextSelectorIfAncestor;

executed (the execution status of this line is deduced): *relation = BasicSelector::MatchNextSelectorIfAncestor;

2299

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

2300

executed: }

Execution Count:3

2301

*relation = BasicSelector::MatchNextSelectorIfPreceeds;

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

never executed: }

partially evaluated: test(PLUS)

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

0-3

2304

never executed (the execution status of this line is deduced): *relation = BasicSelector::MatchNextSelectorIfPreceeds;

2305

} else if (test(GREATER)) {

never executed: }

partially evaluated: test(GREATER)

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

0-3

2306

*relation = BasicSelector::MatchNextSelectorIfParent;

never executed (the execution status of this line is deduced): *relation = BasicSelector::MatchNextSelectorIfParent;

never executed: }

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

2309

decl->d->property = lexem();

executed: return true;

Execution Count:3

2310 } -

2311 -

2312 bool Parser::parseProperty(Declaration *decl) -

2313 { -

2314

executed (the execution status of this line is deduced): decl->d->property = lexem();

2315

decl->d->propertyId = static_cast<Property>(findKnownValue(decl->d->property, properties, NumProperties));

executed (the execution status of this line is deduced): decl->d->propertyId = static_cast<Property>(findKnownValue(decl->d->property, properties, NumProperties));

2316

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

2317

if (!parseSelector(&sel)) return false;

executed: return true;

Execution Count:523

523

2318 } -

2319 -

2320 bool Parser::parseRuleset(StyleRule *styleRule) -

2321 { -

2322

Selector sel;

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

2323

executed: return false;

Execution Count:5

evaluated: !parseSelector(&sel)

TRUE	FALSE
yes Evaluation Count:5	yes Evaluation Count:242

5-242

2324

styleRule->selectors.append(sel);

executed (the execution status of this line is deduced): styleRule->selectors.append(sel);

2325 -

2326

while (test(COMMA)) {

evaluated: test(COMMA)

TRUE	FALSE
yes Evaluation Count:9	yes Evaluation Count:242

9-242

2327

if (!parseNextSelector(&sel)) return false;

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

2328

Selector sel;

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

2329

never executed: return false;

partially evaluated: !parseNextSelector(&sel)

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

0-9

2330

styleRule->selectors.append(sel);

executed (the execution status of this line is deduced): styleRule->selectors.append(sel);

2331

executed: }

Execution Count:9

2332 -

2333

if (!next(LBRACE)) return false;

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

2334

executed: return false;

Execution Count:1

evaluated: !next(LBRACE)

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:241

1-241

2335

const int declarationStart = index;

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

2336 -

2337 do { -

2338

const int rewind = index;

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

2339

Declaration decl;

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

2340

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

2341

if (!parseNextDeclaration(&decl)) {

partially evaluated: !parseNextDeclaration(&decl)

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

0-642

2342

const bool foundSemicolon = until(SEMICOLON);

never executed (the execution status of this line is deduced): index = rewind;

2343

never executed (the execution status of this line is deduced): const bool foundSemicolon = until(SEMICOLON);

2344

const int semicolonIndex = index;

never executed (the execution status of this line is deduced): const int semicolonIndex = index;

2345 -

2346

index = declarationStart;

never executed (the execution status of this line is deduced): index = declarationStart;

2347

const bool foundRBrace = until(RBRACE);

never executed (the execution status of this line is deduced): const bool foundRBrace = until(RBRACE);

2348 -

2349

if (foundSemicolon && semicolonIndex < index) {

never evaluated: foundSemicolon

never evaluated: semicolonIndex < index

2350

decl = Declaration();

never executed (the execution status of this line is deduced): decl = Declaration();

2351

index = semicolonIndex - 1;

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

never executed: }

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

2354

return foundRBrace;

never executed: return foundRBrace;

2355 } -

2356 } -

2357

if (!decl.isEmpty())

evaluated: !decl.isEmpty()

TRUE	FALSE
yes Evaluation Count:523	yes Evaluation Count:119

119-523

2358

styleRule->declarations.append(decl);

executed: styleRule->declarations.append(decl);

Execution Count:523

523

2359

} while (test(SEMICOLON));

executed: }

Execution Count:642

evaluated: test(SEMICOLON)

TRUE	FALSE
yes Evaluation Count:401	yes Evaluation Count:241

241-642

2360 -

2361

if (!next(RBRACE)) return false;

never executed: return false;

partially evaluated: !next(RBRACE)

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

0-241

2362

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

2363

if (!parseSimpleSelector(&basicSel)) return false;

executed: return true;

Execution Count:241

241

2364 } -

2365 -

2366 bool Parser::parseSelector(Selector *sel) -

2367 { -

2368

BasicSelector basicSel;

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

2369

executed: return false;

Execution Count:4

evaluated: !parseSimpleSelector(&basicSel)

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:252

4-252

2370

while (testCombinator()) {

evaluated: testCombinator()

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:251

3-251

2371

if (!parseCombinator(&basicSel.relationToNext)) return false;

never executed: return false;

partially evaluated: !parseCombinator(&basicSel.relationToNext)

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

0-3

2372 -

2373

if (!testSimpleSelector()) break;

never executed: break;

partially evaluated: !testSimpleSelector()

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

0-3

2374

sel->basicSelectors.append(basicSel);

executed (the execution status of this line is deduced): sel->basicSelectors.append(basicSel);

2375 -

2376

basicSel = BasicSelector();

executed (the execution status of this line is deduced): basicSel = BasicSelector();

2377

if (!parseSimpleSelector(&basicSel)) return false;

executed: return false;

Execution Count:1

evaluated: !parseSimpleSelector(&basicSel)

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

1-2

2378

sel->basicSelectors.append(basicSel);

executed: }

Execution Count:2

2379

executed (the execution status of this line is deduced): sel->basicSelectors.append(basicSel);

2380

if (lookupElementName()) {

executed: return true;

Execution Count:251

251

2381 } -

2382 -

2383 bool Parser::parseSimpleSelector(BasicSelector *basicSel) -

2384 { -

2385

int minCount = 0;

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

2386

evaluated: lookupElementName()

TRUE	FALSE
yes Evaluation Count:253	yes Evaluation Count:6

6-253

2387

if (!parseElementName(&basicSel->elementName)) return false;

never executed: return false;

partially evaluated: !parseElementName(&basicSel->elementName)

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

0-253

2388

executed: }

Execution Count:253

253

2389

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

2390

minCount = 1;

executed (the execution status of this line is deduced): minCount = 1;

2391

basicSel->ids.append(theid);

executed: }

Execution Count:6

2392

bool onceMore;

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

2393

int count = 0;

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

2394 do { -

2395

onceMore = false;

executed (the execution status of this line is deduced): onceMore = false;

2396

if (test(HASH)) {

partially evaluated: test(HASH)

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

0-279

2397

QString theid = lexem();

never executed (the execution status of this line is deduced): QString theid = lexem();

2398 // chop off leading # -

2399

theid.remove(0, 1);

never executed (the execution status of this line is deduced): theid.remove(0, 1);

2400

never executed (the execution status of this line is deduced): basicSel->ids.append(theid);

2401

} else if (testClass()) {

never executed (the execution status of this line is deduced): onceMore = true;

2402

never executed: }

evaluated: testClass()

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:275

0-275

2403

a.name = QLatin1String("class");

executed (the execution status of this line is deduced): onceMore = true;

2404

AttributeSelector a;

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

2405

executed (the execution status of this line is deduced): a.name = QLatin1String("class");

2406

a.valueMatchCriterium = AttributeSelector::MatchContains;

executed (the execution status of this line is deduced): a.valueMatchCriterium = AttributeSelector::MatchContains;

2407

if (!parseClass(&a.value)) return false;

executed: return false;

Execution Count:1

evaluated: !parseClass(&a.value)

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:3

1-3

2408

basicSel->attributeSelectors.append(a);

executed (the execution status of this line is deduced): basicSel->attributeSelectors.append(a);

2409

} else if (testAttrib()) {

executed: }

Execution Count:3

evaluated: testAttrib()

TRUE	FALSE
yes Evaluation Count:16	yes Evaluation Count:259

3-259

2410

if (!parseAttrib(&a)) return false;

executed (the execution status of this line is deduced): onceMore = true;

2411

AttributeSelector a;

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

2412

never executed: return false;

partially evaluated: !parseAttrib(&a)

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

0-16

2413

basicSel->attributeSelectors.append(a);

executed (the execution status of this line is deduced): basicSel->attributeSelectors.append(a);

2414

} else if (testPseudo()) {

executed: }

Execution Count:16

evaluated: testPseudo()

TRUE	FALSE
yes Evaluation Count:5	yes Evaluation Count:254

5-254

2415

if (!parsePseudo(&ps)) return false;

executed (the execution status of this line is deduced): onceMore = true;

2416

Pseudo ps;

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

2417

executed: return false;

Execution Count:4

evaluated: !parsePseudo(&ps)

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:1

1-4

2418

basicSel->pseudos.append(ps);

executed (the execution status of this line is deduced): basicSel->pseudos.append(ps);

2419

return count >= minCount;

executed: }

Execution Count:1

2420

if (onceMore) ++count;

executed: ++count;

Execution Count:20

evaluated: onceMore

TRUE	FALSE
yes Evaluation Count:20	yes Evaluation Count:254

20-254

2421

} while (onceMore);

executed: }

Execution Count:274

evaluated: onceMore

TRUE	FALSE
yes Evaluation Count:20	yes Evaluation Count:254

20-274

2422

executed: return count >= minCount;

Execution Count:254

254

2423 } -

2424 -

2425 bool Parser::parseClass(QString *name) -

2426 { -

2427

if (!next(IDENT)) return false;

executed: return false;

Execution Count:1

evaluated: !next(IDENT)

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:3

1-3

2428

*name = lexem();

executed (the execution status of this line is deduced): *name = lexem();

2429

case STAR: name->clear(); break;

executed: return true;

Execution Count:3

2430 } -

2431 -

2432 bool Parser::parseElementName(QString *name) -

2433 { -

2434 switch (lookup()) { -

2435

executed: break;

Execution Count:180

180

2436

case IDENT: *name = lexem(); break;

executed: break;

Execution Count:73

2437

default: return false;

never executed: return false;

2438 } -

2439

executed: return true;

Execution Count:253

253

2440 } -

2441 -

2442 bool Parser::parseAttrib(AttributeSelector *attr) -

2443 { -

2444

if (!next(IDENT)) return false;

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

2445

never executed: return false;

partially evaluated: !next(IDENT)

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

0-16

2446

attr->name = lexem();

executed (the execution status of this line is deduced): attr->name = lexem();

2447

attr->valueMatchCriterium = AttributeSelector::MatchEqual;

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

2448 -

2449

if (test(EQUAL)) {

evaluated: test(EQUAL)

TRUE	FALSE
yes Evaluation Count:10	yes Evaluation Count:6

6-10

2450

executed (the execution status of this line is deduced): attr->valueMatchCriterium = AttributeSelector::MatchEqual;

2451

} else if (test(INCLUDES)) {

executed: }

Execution Count:10

evaluated: test(INCLUDES)

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:4

2-10

2452

attr->valueMatchCriterium = AttributeSelector::MatchContains;

executed (the execution status of this line is deduced): attr->valueMatchCriterium = AttributeSelector::MatchContains;

2453

} else if (test(DASHMATCH)) {

executed: }

Execution Count:2

evaluated: test(DASHMATCH)

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

2454

attr->valueMatchCriterium = AttributeSelector::MatchBeginsWith;

executed (the execution status of this line is deduced): attr->valueMatchCriterium = AttributeSelector::MatchBeginsWith;

2455

executed: }

Execution Count:2

2456

return next(RBRACKET);

executed: return next(RBRACKET);

Execution Count:2

2457 } -

2458 -

2459

if (!test(IDENT) && !test(STRING)) return false;

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

2460 -

2461

never executed: return false;

evaluated: !test(IDENT)

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:11

partially evaluated: !test(STRING)

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

0-11

2462

attr->value = unquotedLexem();

executed (the execution status of this line is deduced): attr->value = unquotedLexem();

2463 -

2464

pseudo->negated = test(EXCLAMATION_SYM);

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

2465

return next(RBRACKET);

executed: return next(RBRACKET);

Execution Count:14

2466 } -

2467 -

2468 bool Parser::parsePseudo(Pseudo *pseudo) -

2469 { -

2470

(void)test(COLON);

executed (the execution status of this line is deduced): (void)test(COLON);

2471

executed (the execution status of this line is deduced): pseudo->negated = test(EXCLAMATION_SYM);

2472

if (test(IDENT)) {

evaluated: test(IDENT)

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:4

1-4

2473

pseudo->name = lexem();

executed (the execution status of this line is deduced): pseudo->name = lexem();

2474

pseudo->type = static_cast<quint64>(findKnownValue(pseudo->name, pseudos, NumPseudos));

executed (the execution status of this line is deduced): pseudo->type = static_cast<quint64>(findKnownValue(pseudo->name, pseudos, NumPseudos));

2475

if (!next(FUNCTION)) return false;

executed: return true;

Execution Count:1

2476 } -

2477

executed: return false;

Execution Count:4

partially evaluated: !next(FUNCTION)

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

0-4

2478

pseudo->function = lexem();

never executed (the execution status of this line is deduced): pseudo->function = lexem();

2479 // chop off trailing parenthesis -

2480

pseudo->function.chop(1);

never executed (the execution status of this line is deduced): pseudo->function.chop(1);

2481

if (!test(IDENT)) return false;

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

2482

never executed: return false;

never evaluated: !test(IDENT)

2483

pseudo->name = lexem();

never executed (the execution status of this line is deduced): pseudo->name = lexem();

2484

return true; // not an error!

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

2485

return next(RPAREN);

never executed: return next(RPAREN);

2486 } -

2487 -

2488 bool Parser::parseNextDeclaration(Declaration *decl) -

2489 { -

2490

if (!testProperty())

evaluated: !testProperty()

TRUE	FALSE
yes Evaluation Count:119	yes Evaluation Count:523

119-523

2491

executed: return true;

Execution Count:119

119

2492

if (!parseProperty(decl)) return false;

never executed: return false;

partially evaluated: !parseProperty(decl)

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

0-523

2493

if (!next(COLON)) return false;

never executed: return false;

partially evaluated: !next(COLON)

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

0-523

2494

if (!parseNextExpr(&decl->d->values)) return false;

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

2495

never executed: return false;

partially evaluated: !parseNextExpr(&decl->d->values)

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

0-523

2496

if (testPrio())

partially evaluated: testPrio()

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

0-523

2497

if (!parsePrio(decl)) return false;

never executed: return false;

never evaluated: !parsePrio(decl)

2498

const int rewind = index;

executed: return true;

Execution Count:523

523

2499 } -

2500 -

2501 bool Parser::testPrio() -

2502 { -

2503

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

2504

if (!test(EXCLAMATION_SYM)) return false;

executed: return false;

Execution Count:523

partially evaluated: !test(EXCLAMATION_SYM)

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

0-523

2505

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

2506

if (!test(IDENT)) {

never evaluated: !test(IDENT)

2507

never executed (the execution status of this line is deduced): index = rewind;

2508

if (lexem().compare(QLatin1String("important"), Qt::CaseInsensitive) != 0) {

never executed: return false;

2509 } -

2510

never evaluated: lexem().compare(QLatin1String("important"), Qt::CaseInsensitive) != 0

2511

never executed (the execution status of this line is deduced): index = rewind;

2512

never executed: return false;

2513 } -

2514

declaration->d->important = true;

never executed: return true;

2515 } -

2516 -

2517 bool Parser::parsePrio(Declaration *declaration) -

2518 { -

2519

never executed (the execution status of this line is deduced): declaration->d->important = true;

2520

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

2521

if (!parseTerm(&val)) return false;

never executed: return true;

2522 } -

2523 -

2524 bool Parser::parseExpr(QVector<Value> *values) -

2525 { -

2526

Value val;

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

2527

never executed: return false;

partially evaluated: !parseTerm(&val)

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

0-524

2528

values->append(val);

executed (the execution status of this line is deduced): values->append(val);

2529

bool onceMore;

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

2530 do { -

2531

onceMore = false;

executed (the execution status of this line is deduced): onceMore = false;

2532

val = Value();

executed (the execution status of this line is deduced): val = Value();

2533

if (!parseNextOperator(&val)) return false;

never executed: return false;

partially evaluated: !parseNextOperator(&val)

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

0-543

2534

if (val.type != QCss::Value::Unknown)

evaluated: val.type != QCss::Value::Unknown

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:539

4-539

2535

values->append(val);

executed: values->append(val);

Execution Count:4

2536

if (testTerm()) {

evaluated: testTerm()

TRUE	FALSE
yes Evaluation Count:19	yes Evaluation Count:524

19-524

2537

if (!parseTerm(&val)) return false;

executed (the execution status of this line is deduced): onceMore = true;

2538

val = Value();

executed (the execution status of this line is deduced): val = Value();

2539

never executed: return false;

partially evaluated: !parseTerm(&val)

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

0-19

2540

values->append(val);

executed (the execution status of this line is deduced): values->append(val);

2541

executed: }

Execution Count:19

2542

} while (onceMore);

executed: }

Execution Count:543

evaluated: onceMore

TRUE	FALSE
yes Evaluation Count:19	yes Evaluation Count:524

19-543

2543

return test(PLUS) || test(MINUS)

executed: return true;

Execution Count:524

524

2544 } -

2545 -

2546 bool Parser::testTerm() -

2547 { -

2548

executed:

return test(PLUS) || test(MINUS) || test(NUMBER) || test(PERCENTAGE) || test(LENGTH) || test(STRING) || test(IDENT) || testHexColor() || testFunction();

Execution Count:1067

1067

2549

|| test(NUMBER)

executed:

return test(PLUS) || test(MINUS) || test(NUMBER) || test(PERCENTAGE) || test(LENGTH) || test(STRING) || test(IDENT) || testHexColor() || testFunction();

Execution Count:1067

1067

2550

|| test(PERCENTAGE)

executed:

return test(PLUS) || test(MINUS) || test(NUMBER) || test(PERCENTAGE) || test(LENGTH) || test(STRING) || test(IDENT) || testHexColor() || testFunction();

Execution Count:1067

1067

2551

|| test(LENGTH)

executed:

return test(PLUS) || test(MINUS) || test(NUMBER) || test(PERCENTAGE) || test(LENGTH) || test(STRING) || test(IDENT) || testHexColor() || testFunction();

Execution Count:1067

1067

2552

|| test(STRING)

executed:

return test(PLUS) || test(MINUS) || test(NUMBER) || test(PERCENTAGE) || test(LENGTH) || test(STRING) || test(IDENT) || testHexColor() || testFunction();

Execution Count:1067

1067

2553

|| test(IDENT)

executed:

return test(PLUS) || test(MINUS) || test(NUMBER) || test(PERCENTAGE) || test(LENGTH) || test(STRING) || test(IDENT) || testHexColor() || testFunction();

Execution Count:1067

1067

2554

|| testHexColor()

executed:

return test(PLUS) || test(MINUS) || test(NUMBER) || test(PERCENTAGE) || test(LENGTH) || test(STRING) || test(IDENT) || testHexColor() || testFunction();

Execution Count:1067

1067

2555

|| testFunction();

executed:

return test(PLUS) || test(MINUS) || test(NUMBER) || test(PERCENTAGE) || test(LENGTH) || test(STRING) || test(IDENT) || testHexColor() || testFunction();

Execution Count:1067

1067

2556 } -

2557 -

2558 bool Parser::parseTerm(Value *value) -

2559 { -

2560

QString str = lexem();

executed (the execution status of this line is deduced): QString str = lexem();

2561

bool haveUnary = false;

executed (the execution status of this line is deduced): bool haveUnary = false;

2562

if (lookup() == PLUS || lookup() == MINUS) {

partially evaluated: lookup() == PLUS

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

partially evaluated: lookup() == MINUS

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

0-543

2563

haveUnary = true;

never executed (the execution status of this line is deduced): haveUnary = true;

2564

if (!hasNext()) return false;

never executed: return false;

never evaluated: !hasNext()

2565

next();

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

2566

str += lexem();

never executed (the execution status of this line is deduced): str += lexem();

2567

value->type = QCss::Value::String;

never executed: }

2568 -

2569

value->variant = str;

executed (the execution status of this line is deduced): value->variant = str;

2570

executed (the execution status of this line is deduced): value->type = QCss::Value::String;

2571 switch (lookup()) { -

2572 case NUMBER: -

2573

value->type = Value::Number;

executed (the execution status of this line is deduced): value->type = Value::Number;

2574

value->variant.convert(QVariant::Double);

executed (the execution status of this line is deduced): value->variant.convert(QVariant::Double);

2575

value->type = Value::Percentage;

executed: break;

Execution Count:62

2576 case PERCENTAGE: -

2577

never executed (the execution status of this line is deduced): value->type = Value::Percentage;

2578

str.chop(1); // strip off %

never executed (the execution status of this line is deduced): str.chop(1);

2579

value->variant = str;

never executed (the execution status of this line is deduced): value->variant = str;

2580

value->type = Value::Length;

never executed: break;

2581 case LENGTH: -

2582

executed (the execution status of this line is deduced): value->type = Value::Length;

2583

if (haveUnary) return false;

executed: break;

Execution Count:267

267

2584 -

2585 case STRING: -

2586

never executed: return false;

partially evaluated: haveUnary

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

0-14

2587

value->type = Value::String;

executed (the execution status of this line is deduced): value->type = Value::String;

2588

str.chop(1);

executed (the execution status of this line is deduced): str.chop(1);

2589

str.remove(0, 1);

executed (the execution status of this line is deduced): str.remove(0, 1);

2590

value->variant = str;

executed (the execution status of this line is deduced): value->variant = str;

2591

if (haveUnary) return false;

executed: break;

Execution Count:14

2592 case IDENT: { -

2593

never executed: return false;

partially evaluated: haveUnary

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

0-181

2594

value->type = Value::Identifier;

executed (the execution status of this line is deduced): value->type = Value::Identifier;

2595

const int theid = findKnownValue(str, values, NumKnownValues);

executed (the execution status of this line is deduced): const int theid = findKnownValue(str, values, NumKnownValues);

2596

if (theid != 0) {

evaluated: theid != 0

TRUE	FALSE
yes Evaluation Count:75	yes Evaluation Count:106

75-106

2597

value->type = Value::KnownIdentifier;

executed (the execution status of this line is deduced): value->type = Value::KnownIdentifier;

2598

value->variant = theid;

executed (the execution status of this line is deduced): value->variant = theid;

2599

executed: }

Execution Count:75

2600

if (haveUnary) return false;

executed: break;

Execution Count:181

181

2601 } -

2602 default: { -

2603

never executed: return false;

partially evaluated: haveUnary

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

0-19

2604

if (!parseHexColor(&col)) return false;

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

2605

if (testHexColor()) {

evaluated: testHexColor()

TRUE	FALSE
yes Evaluation Count:15	yes Evaluation Count:4

4-15

2606

QColor col;

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

2607

never executed: return false;

partially evaluated: !parseHexColor(&col)

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

0-15

2608

value->type = Value::Color;

executed (the execution status of this line is deduced): value->type = Value::Color;

2609

value->variant = col;

executed (the execution status of this line is deduced): value->variant = col;

2610

} else if (testFunction()) {

executed: }

Execution Count:15

partially evaluated: testFunction()

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

0-15

2611

QString name, args;

executed (the execution status of this line is deduced): QString name, args;

2612

if (!parseFunction(&name, &args)) return false;

never executed: return false;

partially evaluated: !parseFunction(&name, &args)

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

0-4

2613

if (name == QLatin1String("url")) {

evaluated: name == QLatin1String("url")

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:1

1-3

2614

value->type = Value::Uri;

executed (the execution status of this line is deduced): value->type = Value::Uri;

2615

removeOptionalQuotes(&args);

executed (the execution status of this line is deduced): removeOptionalQuotes(&args);

2616

if (QFileInfo(args).isRelative() && !sourcePath.isEmpty()) {

partially evaluated: QFileInfo(args).isRelative()

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

partially evaluated: !sourcePath.isEmpty()

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

0-3

2617

args.prepend(sourcePath);

never executed (the execution status of this line is deduced): args.prepend(sourcePath);

2618

never executed: }

2619

value->variant = args;

executed (the execution status of this line is deduced): value->variant = args;

2620

value->type = Value::Function;

executed: }

Execution Count:3

2621

executed (the execution status of this line is deduced): value->type = Value::Function;

2622

value->variant = QStringList() << name << args;

executed (the execution status of this line is deduced): value->variant = QStringList() << name << args;

2623

executed: }

Execution Count:1

2624 } else { -

2625

return recordError();

never executed: return recordError();

2626 } -

2627

executed: return true;

Execution Count:19

2628 } -

2629 } -

2630

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

2631

executed: return true;

Execution Count:524

524

2632 } -

2633 -

2634 bool Parser::parseFunction(QString *name, QString *args) -

2635 { -

2636

*name = lexem();

executed (the execution status of this line is deduced): *name = lexem();

2637

name->chop(1);

executed (the execution status of this line is deduced): name->chop(1);

2638

if (!until(RPAREN)) return false;

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

2639

const int start = index;

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

2640

never executed: return false;

partially evaluated: !until(RPAREN)

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

0-6

2641

for (int i = start; i < index - 1; ++i)

evaluated: i < index - 1

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

6-12

2642

args->append(symbols.at(i).lexem());

executed: args->append(symbols.at(i).lexem());

Execution Count:12

2643 /* -

2644 if (!nextExpr(&arguments)) return false; -

2645 if (!next(RPAREN)) return false; -

2646 */ -

2647

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

2648

col->setNamedColor(lexem());

executed: return true;

Execution Count:6

2649 } -

2650 -

2651 bool Parser::parseHexColor(QColor *col) -

2652 { -

2653

executed (the execution status of this line is deduced): col->setNamedColor(lexem());

2654

if (!col->isValid()) {

partially evaluated: !col->isValid()

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

0-15

2655

qWarning("QCssParser::parseHexColor: Unknown color name '%s'",lexem().toLatin1().constData());

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

 QMessageLogger("text/qcssparser.cpp", 2655, __PRETTY_FUNCTION__).warning("QCssParser::parseHexColor: Unknown color name '%s'",lexem().toLatin1().constData());

2656

never executed: return false;

2657 } -

2658

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

2659

const int rewind = index;

executed: return true;

Execution Count:15

2660 } -

2661 -

2662 bool Parser::testAndParseUri(QString *uri) -

2663 { -

2664

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

2665

if (!testFunction()) return false;

never executed: return false;

partially evaluated: !testFunction()

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

0-2

2666 -

2667

QString name, args;

executed (the execution status of this line is deduced): QString name, args;

2668

if (!parseFunction(&name, &args)) {

partially evaluated: !parseFunction(&name, &args)

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

0-2

2669

never executed (the execution status of this line is deduced): index = rewind;

2670

if (name.toLower() != QLatin1String("url")) {

never executed: return false;

2671 } -

2672

partially evaluated: name.toLower() != QLatin1String("url")

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

0-2

2673

never executed (the execution status of this line is deduced): index = rewind;

2674

removeOptionalQuotes(uri);

never executed: return false;

2675 } -

2676

*uri = args;

executed (the execution status of this line is deduced): *uri = args;

2677

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

2678

if (hasNext() && next() == t)

executed: return true;

Execution Count:2

2679 } -

2680 -

2681 bool Parser::testSimpleSelector() -

2682 { -

2683

return testElementName()

executed: return testElementName() || (test(HASH)) || testClass() || testAttrib() || testPseudo();

Execution Count:653

653

2684

|| (test(HASH))

executed: return testElementName() || (test(HASH)) || testClass() || testAttrib() || testPseudo();

Execution Count:653

653

2685

|| testClass()

executed: return testElementName() || (test(HASH)) || testClass() || testAttrib() || testPseudo();

Execution Count:653

653

2686

|| testAttrib()

executed: return testElementName() || (test(HASH)) || testClass() || testAttrib() || testPseudo();

Execution Count:653

653

2687

|| testPseudo();

executed: return testElementName() || (test(HASH)) || testClass() || testAttrib() || testPseudo();

Execution Count:653

653

2688 } -

2689 -

2690 bool Parser::next(QCss::TokenType t) -

2691 { -

2692

evaluated: hasNext()

TRUE	FALSE
yes Evaluation Count:1056	yes Evaluation Count:1

evaluated: next() == t

TRUE	FALSE
yes Evaluation Count:1051	yes Evaluation Count:5

1-1056

2693

if (index >= symbols.count())

executed: return true;

Execution Count:1051

1051

2694

return recordError();

executed: return recordError();

Execution Count:6

2695 } -

2696 -

2697 bool Parser::test(QCss::TokenType t) -

2698 { -

2699

evaluated: index >= symbols.count()

TRUE	FALSE
yes Evaluation Count:7180	yes Evaluation Count:17975

7180-17975

2700

if (symbols.at(index).token == t) {

executed: return false;

Execution Count:7180

7180

2701

evaluated: symbols.at(index).token == t

TRUE	FALSE
yes Evaluation Count:2870	yes Evaluation Count:15105

2870-15105

2702

++index;

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

2703

executed: return true;

Execution Count:2870

2870

2704 } -

2705

if (lookup() == STRING) {

executed: return false;

Execution Count:15105

15105

2706 } -

2707 -

2708 QString Parser::unquotedLexem() const -

2709 { -

2710

QString s = lexem();

executed (the execution status of this line is deduced): QString s = lexem();

2711

evaluated: lookup() == STRING

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:11

3-11

2712

s.chop(1);

executed (the execution status of this line is deduced): s.chop(1);

2713

s.remove(0, 1);

executed (the execution status of this line is deduced): s.remove(0, 1);

2714

while (hasNext() && next() != t)

executed: }

Execution Count:3

2715

return s;

executed: return s;

Execution Count:14

2716 } -

2717 -

2718 QString Parser::lexemUntil(QCss::TokenType t) -

2719 { -

2720

QString lexem;

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

2721

never evaluated: hasNext()

never evaluated: next() != t

2722

lexem += symbol().lexem();

never executed: lexem += symbol().lexem();

2723

return lexem;

never executed: return lexem;

2724 } -

2725 -

2726 bool Parser::until(QCss::TokenType target, QCss::TokenType target2) -

2727 { -

2728

int braceCount = 0;

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

2729

int brackCount = 0;

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

2730

int parenCount = 0;

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

2731

if (index) {

partially evaluated: index

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

0-6

2732 switch(symbols.at(index-1).token) { -

2733

case LBRACE: ++braceCount; break;

never executed: break;

2734

case LBRACKET: ++brackCount; break;

never executed: break;

2735 case FUNCTION: -

2736

case LPAREN: ++parenCount; break;

executed: break;

Execution Count:6

2737 default: ; -

never executed: }

executed: }

Execution Count:6

2740

while (index < symbols.size()) {

partially evaluated: index < symbols.size()

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

0-18

2741

QCss::TokenType t = symbols.at(index++).token;

executed (the execution status of this line is deduced): QCss::TokenType t = symbols.at(index++).token;

2742 switch (t) { -

2743

case LBRACE: ++braceCount; break;

never executed: break;

2744

case RBRACE: --braceCount; break;

never executed: break;

2745

case LBRACKET: ++brackCount; break;

never executed: break;

2746

case RBRACKET: --brackCount; break;

never executed: break;

2747 case FUNCTION: -

2748

case LPAREN: ++parenCount; break;

never executed: break;

2749

case RPAREN: --parenCount; break;

executed: break;

Execution Count:6

2750

if ((t == target || (target2 != NONE && t == target2))

executed: break;

Execution Count:12

2751 } -

2752

evaluated: t == target

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

partially evaluated: target2 != NONE

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

never evaluated: t == target2

0-12

2753

&& braceCount <= 0

partially evaluated: braceCount <= 0

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

0-6

2754

&& brackCount <= 0

partially evaluated: brackCount <= 0

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

0-6

2755

&& parenCount <= 0)

partially evaluated: parenCount <= 0

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

0-6

2756

if (braceCount < 0 || brackCount < 0 || parenCount < 0) {

executed: return true;

Execution Count:6

2757 -

2758

partially evaluated: braceCount < 0

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

partially evaluated: brackCount < 0

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

partially evaluated: parenCount < 0

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

0-12

2759

--index;

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

2760

never executed: break;

2761 } -

2762

executed: }

Execution Count:12

2763

if (!test(t)) return false;

never executed: return false;

2764 } -

2765 -

2766 bool Parser::testTokenAndEndsWith(QCss::TokenType t, QLatin1String str) -

2767 { -

2768

executed: return false;

Execution Count:2511

evaluated: !test(t)

TRUE	FALSE
yes Evaluation Count:2511	yes Evaluation Count:19

19-2511

2769

if (!lexem().endsWith(str, Qt::CaseInsensitive)) {

evaluated: !lexem().endsWith(str, Qt::CaseInsensitive)

TRUE	FALSE
yes Evaluation Count:11	yes Evaluation Count:8

8-11

2770

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

2771

executed: return false;

Execution Count:11

2772 } -

2773