io/qiodevice.cpp

executed: }

Execution Count:39960

39960

132 -

133 /*! -

134 \internal -

135 */ -

136 QIODevicePrivate::~QIODevicePrivate() -

137 { -

138 } -

139 -

140 /*! -

141 \class QIODevice -

142 \inmodule QtCore -

143 \reentrant -

144 -

145 \brief The QIODevice class is the base interface class of all I/O -

146 devices in Qt. -

147 -

148 \ingroup io -

149 -

150 QIODevice provides both a common implementation and an abstract -

151 interface for devices that support reading and writing of blocks -

152 of data, such as QFile, QBuffer and QTcpSocket. QIODevice is -

153 abstract and can not be instantiated, but it is common to use the -

154 interface it defines to provide device-independent I/O features. -

155 For example, Qt's XML classes operate on a QIODevice pointer, -

156 allowing them to be used with various devices (such as files and -

157 buffers). -

158 -

159 Before accessing the device, open() must be called to set the -

160 correct OpenMode (such as ReadOnly or ReadWrite). You can then -

161 write to the device with write() or putChar(), and read by calling -

162 either read(), readLine(), or readAll(). Call close() when you are -

163 done with the device. -

164 -

165 QIODevice distinguishes between two types of devices: -

166 random-access devices and sequential devices. -

167 -

168 \list -

169 \li Random-access devices support seeking to arbitrary -

170 positions using seek(). The current position in the file is -

171 available by calling pos(). QFile and QBuffer are examples of -

172 random-access devices. -

173 -

174 \li Sequential devices don't support seeking to arbitrary -

175 positions. The data must be read in one pass. The functions -

176 pos() and size() don't work for sequential devices. -

177 QTcpSocket and QProcess are examples of sequential devices. -

178 \endlist -

179 -

180 You can use isSequential() to determine the type of device. -

181 -

182 QIODevice emits readyRead() when new data is available for -

183 reading; for example, if new data has arrived on the network or if -

184 additional data is appended to a file that you are reading -

185 from. You can call bytesAvailable() to determine the number of -

186 bytes that are currently available for reading. It's common to use -

187 bytesAvailable() together with the readyRead() signal when -

188 programming with asynchronous devices such as QTcpSocket, where -

189 fragments of data can arrive at arbitrary points in -

190 time. QIODevice emits the bytesWritten() signal every time a -

191 payload of data has been written to the device. Use bytesToWrite() -

192 to determine the current amount of data waiting to be written. -

193 -

194 Certain subclasses of QIODevice, such as QTcpSocket and QProcess, -

195 are asynchronous. This means that I/O functions such as write() -

196 or read() always return immediately, while communication with the -

197 device itself may happen when control goes back to the event loop. -

198 QIODevice provides functions that allow you to force these -

199 operations to be performed immediately, while blocking the -

200 calling thread and without entering the event loop. This allows -

201 QIODevice subclasses to be used without an event loop, or in -

202 a separate thread: -

203 -

204 \list -

205 \li waitForReadyRead() - This function suspends operation in the -

206 calling thread until new data is available for reading. -

207 -

208 \li waitForBytesWritten() - This function suspends operation in the -

209 calling thread until one payload of data has been written to the -

210 device. -

211 -

212 \li waitFor....() - Subclasses of QIODevice implement blocking -

213 functions for device-specific operations. For example, QProcess -

214 has a function called waitForStarted() which suspends operation in -

215 the calling thread until the process has started. -

216 \endlist -

217 -

218 Calling these functions from the main, GUI thread, may cause your -

219 user interface to freeze. Example: -

220 -

221 \snippet code/src_corelib_io_qiodevice.cpp 0 -

222 -

223 By subclassing QIODevice, you can provide the same interface to -

224 your own I/O devices. Subclasses of QIODevice are only required to -

225 implement the protected readData() and writeData() functions. -

226 QIODevice uses these functions to implement all its convenience -

227 functions, such as getChar(), readLine() and write(). QIODevice -

228 also handles access control for you, so you can safely assume that -

229 the device is opened in write mode if writeData() is called. -

230 -

231 Some subclasses, such as QFile and QTcpSocket, are implemented -

232 using a memory buffer for intermediate storing of data. This -

233 reduces the number of required device accessing calls, which are -

234 often very slow. Buffering makes functions like getChar() and -

235 putChar() fast, as they can operate on the memory buffer instead -

236 of directly on the device itself. Certain I/O operations, however, -

237 don't work well with a buffer. For example, if several users open -

238 the same device and read it character by character, they may end -

239 up reading the same data when they meant to read a separate chunk -

240 each. For this reason, QIODevice allows you to bypass any -

241 buffering by passing the Unbuffered flag to open(). When -

242 subclassing QIODevice, remember to bypass any buffer you may use -

243 when the device is open in Unbuffered mode. -

244 -

245 \sa QBuffer, QFile, QTcpSocket -

246 */ -

247 -

248 /*! -

249 \enum QIODevice::OpenModeFlag -

250 -

251 This enum is used with open() to describe the mode in which a device -

252 is opened. It is also returned by openMode(). -

253 -

254 \value NotOpen The device is not open. -

255 \value ReadOnly The device is open for reading. -

256 \value WriteOnly The device is open for writing. -

257 \value ReadWrite The device is open for reading and writing. -

258 \value Append The device is opened in append mode, so that all data is -

259 written to the end of the file. -

260 \value Truncate If possible, the device is truncated before it is opened. -

261 All earlier contents of the device are lost. -

262 \value Text When reading, the end-of-line terminators are -

263 translated to '\\n'. When writing, the end-of-line -

264 terminators are translated to the local encoding, for -

265 example '\\r\\n' for Win32. -

266 \value Unbuffered Any buffer in the device is bypassed. -

267 -

268 Certain flags, such as \c Unbuffered and \c Truncate, are -

269 meaningless when used with some subclasses. Some of these -

270 restrictions are implied by the type of device that is represented -

271 by a subclass. In other cases, the restriction may be due to the -

272 implementation, or may be imposed by the underlying platform; for -

273 example, QTcpSocket does not support \c Unbuffered mode, and -

274 limitations in the native API prevent QFile from supporting \c -

275 Unbuffered on Windows. -

276 */ -

277 -

278 /*! \fn QIODevice::bytesWritten(qint64 bytes) -

279 -

280 This signal is emitted every time a payload of data has been -

281 written to the device. The \a bytes argument is set to the number -

282 of bytes that were written in this payload. -

283 -

284 bytesWritten() is not emitted recursively; if you reenter the event loop -

285 or call waitForBytesWritten() inside a slot connected to the -

286 bytesWritten() signal, the signal will not be reemitted (although -

287 waitForBytesWritten() may still return true). -

288 -

289 \sa readyRead() -

290 */ -

291 -

292 /*! -

293 \fn QIODevice::readyRead() -

294 -

295 This signal is emitted once every time new data is available for -

296 reading from the device. It will only be emitted again once new -

297 data is available, such as when a new payload of network data has -

298 arrived on your network socket, or when a new block of data has -

299 been appended to your device. -

300 -

301 readyRead() is not emitted recursively; if you reenter the event loop or -

302 call waitForReadyRead() inside a slot connected to the readyRead() signal, -

303 the signal will not be reemitted (although waitForReadyRead() may still -

304 return true). -

305 -

306 Note for developers implementing classes derived from QIODevice: -

307 you should always emit readyRead() when new data has arrived (do not -

308 emit it only because there's data still to be read in your -

309 buffers). Do not emit readyRead() in other conditions. -

310 -

311 \sa bytesWritten() -

312 */ -

313 -

314 /*! \fn QIODevice::aboutToClose() -

315 -

316 This signal is emitted when the device is about to close. Connect -

317 this signal if you have operations that need to be performed -

318 before the device closes (e.g., if you have data in a separate -

319 buffer that needs to be written to the device). -

320 */ -

321 -

322 /*! -

323 \fn QIODevice::readChannelFinished() -

324 \since 4.4 -

325 -

326 This signal is emitted when the input (reading) stream is closed -

327 in this device. It is emitted as soon as the closing is detected, -

328 which means that there might still be data available for reading -

329 with read(). -

330 -

331 \sa atEnd(), read() -

332 */ -

333 -

334 #ifdef QT_NO_QOBJECT -

335 QIODevice::QIODevice() -

336 : d_ptr(new QIODevicePrivate) -

337 { -

338 d_ptr->q_ptr = this; -

339 } -

340 -

341 /*! -

342 \internal -

343 */ -

344 QIODevice::QIODevice(QIODevicePrivate &dd) -

345 : d_ptr(&dd) -

346 { -

347 d_ptr->q_ptr = this; -

348 } -

349 #else -

350 -

351 /*! -

352 Constructs a QIODevice object. -

353 */ -

354 -

355 QIODevice::QIODevice() -

356 : QObject(*new QIODevicePrivate, 0) -

357 { -

358 #if defined QIODEVICE_DEBUG -

359 QFile *file = qobject_cast<QFile *>(this); -

360 printf("%p QIODevice::QIODevice(\"%s\") %s\n", this, metaObject()->className(), -

361 qPrintable(file ? file->fileName() : QString())); -

362 #endif -

363

executed: }

Execution Count:34

364 -

365 /*! -

366 Constructs a QIODevice object with the given \a parent. -

367 */ -

368 -

369 QIODevice::QIODevice(QObject *parent) -

370 : QObject(*new QIODevicePrivate, parent) -

371 { -

372 #if defined QIODEVICE_DEBUG -

373 printf("%p QIODevice::QIODevice(%p \"%s\")\n", this, parent, metaObject()->className()); -

374 #endif -

375

executed: }

Execution Count:11

376 -

377 /*! -

378 \internal -

379 */ -

380 QIODevice::QIODevice(QIODevicePrivate &dd, QObject *parent) -

381 : QObject(dd, parent) -

382 { -

383

executed: }

Execution Count:39915

39915

384 #endif -

385 -

386 -

387 /*! -

388 The destructor is virtual, and QIODevice is an abstract base -

389 class. This destructor does not call close(), but the subclass -

390 destructor might. If you are in doubt, call close() before -

391 destroying the QIODevice. -

392 */ -

393 QIODevice::~QIODevice() -

394 { -

395 #if defined QIODEVICE_DEBUG -

396 printf("%p QIODevice::~QIODevice()\n", this); -

397 #endif -

398 } -

399 -

400 /*! -

401 Returns true if this device is sequential; otherwise returns -

402 false. -

403 -

404 Sequential devices, as opposed to a random-access devices, have no -

405 concept of a start, an end, a size, or a current position, and they -

406 do not support seeking. You can only read from the device when it -

407 reports that data is available. The most common example of a -

408 sequential device is a network socket. On Unix, special files such -

409 as /dev/zero and fifo pipes are sequential. -

410 -

411 Regular files, on the other hand, do support random access. They -

412 have both a size and a current position, and they also support -

413 seeking backwards and forwards in the data stream. Regular files -

414 are non-sequential. -

415 -

416 \sa bytesAvailable() -

417 */ -

418 bool QIODevice::isSequential() const -

419 { -

420

return d_func()->openMode;

executed: return false;

Execution Count:8352

8352

421 } -

422 -

423 /*! -

424 Returns the mode in which the device has been opened; -

425 i.e. ReadOnly or WriteOnly. -

426 -

427 \sa OpenMode -

428 */ -

429 QIODevice::OpenMode QIODevice::openMode() const -

430 { -

431

executed: return d_func()->openMode;

Execution Count:6601

6601

432 } -

433 -

434 /*! -

435 Sets the OpenMode of the device to \a openMode. Call this -

436 function to set the open mode if the flags change after the device -

437 has been opened. -

438 -

439 \sa openMode(), OpenMode -

440 */ -

441 void QIODevice::setOpenMode(OpenMode openMode) -

442 { -

443

d->accessMode = QIODevicePrivate::Unset;

executed (the execution status of this line is deduced): QIODevicePrivate * const d = d_func();

444 #if defined QIODEVICE_DEBUG -

445 printf("%p QIODevice::setOpenMode(0x%x)\n", this, int(openMode)); -

446 #endif -

447

d->openMode = openMode;

executed (the execution status of this line is deduced): d->openMode = openMode;

448

executed (the execution status of this line is deduced): d->accessMode = QIODevicePrivate::Unset;

449

d->firstRead = true;

executed (the execution status of this line is deduced): d->firstRead = true;

450

if (!isReadable())

evaluated: !isReadable()

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:108

2-108

451

executed: d->buffer.clear();

Execution Count:2

452

executed: }

Execution Count:110

110

453 -

454 /*! -

455 If \a enabled is true, this function sets the \l Text flag on the device; -

456 otherwise the \l Text flag is removed. This feature is useful for classes -

457 that provide custom end-of-line handling on a QIODevice. -

458 -

459 The IO device should be opened before calling this function. -

460 -

461 \sa open(), setOpenMode() -

462 */ -

463 void QIODevice::setTextModeEnabled(bool enabled) -

464 { -

465

qWarning("QIODevice::setTextModeEnabled: The device is not open");

executed (the execution status of this line is deduced): QIODevicePrivate * const d = d_func();

466

if (!isOpen()) {

partially evaluated: !isOpen()

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

0-82078611

467

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

 QMessageLogger("io/qiodevice.cpp", 467, __PRETTY_FUNCTION__).warning("QIODevice::setTextModeEnabled: The device is not open");

468

return;

never executed: return;

469 } -

470

if (enabled)

evaluated: enabled

TRUE	FALSE
yes Evaluation Count:41038132	yes Evaluation Count:41040479

41038132-41040479

471

d->openMode |= Text;

executed: d->openMode |= Text;

Execution Count:41038132

41038132

472 else -

473

d->openMode &= ~Text;

executed: d->openMode &= ~Text;

Execution Count:41040479

41040479

474 } -

475 -

476 /*! -

477 Returns true if the \l Text flag is enabled; otherwise returns false. -

478 -

479 \sa setTextModeEnabled() -

480 */ -

481 bool QIODevice::isTextModeEnabled() const -

482 { -

483

return d_func()->openMode & Text;

executed: return d_func()->openMode & Text;

Execution Count:41042456

41042456

484 } -

485 -

486 /*! -

487 Returns true if the device is open; otherwise returns false. A -

488 device is open if it can be read from and/or written to. By -

489 default, this function returns false if openMode() returns -

490 \c NotOpen. -

491 -

492 \sa openMode(), OpenMode -

493 */ -

494 bool QIODevice::isOpen() const -

495 { -

496

return d_func()->openMode != NotOpen;

executed: return d_func()->openMode != NotOpen;

Execution Count:82403739

82403739

497 } -

498 -

499 /*! -

500 Returns true if data can be read from the device; otherwise returns -

501 false. Use bytesAvailable() to determine how many bytes can be read. -

502 -

503 This is a convenience function which checks if the OpenMode of the -

504 device contains the ReadOnly flag. -

505 -

506 \sa openMode(), OpenMode -

507 */ -

508 bool QIODevice::isReadable() const -

509 { -

510

return (openMode() & ReadOnly) != 0;

executed: return (openMode() & ReadOnly) != 0;

Execution Count:4769

4769

511 } -

512 -

513 /*! -

514 Returns true if data can be written to the device; otherwise returns -

515 false. -

516 -

517 This is a convenience function which checks if the OpenMode of the -

518 device contains the WriteOnly flag. -

519 -

520 \sa openMode(), OpenMode -

521 */ -

522 bool QIODevice::isWritable() const -

523 { -

524

return (openMode() & WriteOnly) != 0;

executed: return (openMode() & WriteOnly) != 0;

Execution Count:1806

1806

525 } -

526 -

527 /*! -

528 Opens the device and sets its OpenMode to \a mode. Returns true if successful; -

529 otherwise returns false. This function should be called from any -

530 reimplementations of open() or other functions that open the device. -

531 -

532 \sa openMode(), OpenMode -

533 */ -

534 bool QIODevice::open(OpenMode mode) -

535 { -

536

d->pos = (mode & Append) ? size() : qint64(0);

executed (the execution status of this line is deduced): QIODevicePrivate * const d = d_func();

537

d->openMode = mode;

executed (the execution status of this line is deduced): d->openMode = mode;

538

evaluated: (mode & Append)

TRUE	FALSE
yes Evaluation Count:274	yes Evaluation Count:31302

274-31302

539

d->accessMode = QIODevicePrivate::Unset;

executed (the execution status of this line is deduced): d->buffer.clear();

540

executed (the execution status of this line is deduced): d->accessMode = QIODevicePrivate::Unset;

541

d->firstRead = true;

executed (the execution status of this line is deduced): d->firstRead = true;

542 #if defined QIODEVICE_DEBUG -

543 printf("%p QIODevice::open(0x%x)\n", this, quint32(mode)); -

544 #endif -

545

return true;

executed: return true;

Execution Count:31576

31576

546 } -

547 -

548 /*! -

549 First emits aboutToClose(), then closes the device and sets its -

550 OpenMode to NotOpen. The error string is also reset. -

551 -

552 \sa setOpenMode(), OpenMode -

553 */ -

554 void QIODevice::close() -

555 { -

556

if (d->openMode == NotOpen)

executed (the execution status of this line is deduced): QIODevicePrivate * const d = d_func();

557

evaluated: d->openMode == NotOpen

TRUE	FALSE
yes Evaluation Count:3627	yes Evaluation Count:22074

3627-22074

558

return;

executed: return;

Execution Count:3627

3627

559 -

560 #if defined QIODEVICE_DEBUG -

561 printf("%p QIODevice::close()\n", this); -

562 #endif -

563 -

564 #ifndef QT_NO_QOBJECT -

565

emit aboutToClose();

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

566 #endif -

567

d->openMode = NotOpen;

executed (the execution status of this line is deduced): d->openMode = NotOpen;

568

d->errorString.clear();

executed (the execution status of this line is deduced): d->errorString.clear();

569

d->pos = 0;

executed (the execution status of this line is deduced): d->pos = 0;

570

d->seqDumpPos = 0;

executed (the execution status of this line is deduced): d->seqDumpPos = 0;

571

executed (the execution status of this line is deduced): d->buffer.clear();

572

d->firstRead = true;

executed (the execution status of this line is deduced): d->firstRead = true;

573

executed: }

Execution Count:22074

22074

574 -

575 /*! -

576 For random-access devices, this function returns the position that -

577 data is written to or read from. For sequential devices or closed -

578 devices, where there is no concept of a "current position", 0 is -

579 returned. -

580 -

581 The current read/write position of the device is maintained internally by -

582 QIODevice, so reimplementing this function is not necessary. When -

583 subclassing QIODevice, use QIODevice::seek() to notify QIODevice about -

584 changes in the device position. -

585 -

586 \sa isSequential(), seek() -

587 */ -

588 qint64 QIODevice::pos() const -

589 { -

590

return d_func()->isSequential() ? bytesAvailable() : qint64(0);

executed (the execution status of this line is deduced): const QIODevicePrivate * const d = d_func();

591 #if defined QIODEVICE_DEBUG -

592 printf("%p QIODevice::pos() == %d\n", this, int(d->pos)); -

593 #endif -

594

return d->pos;

executed: return d->pos;

Execution Count:460014

460014

595 } -

596 -

597 /*! -

598 For open random-access devices, this function returns the size of the -

599 device. For open sequential devices, bytesAvailable() is returned. -

600 -

601 If the device is closed, the size returned will not reflect the actual -

602 size of the device. -

603 -

604 \sa isSequential(), pos() -

605 */ -

606 qint64 QIODevice::size() const -

607 { -

608

executed: return d_func()->isSequential() ? bytesAvailable() : qint64(0);

Execution Count:69

609 } -

610 -

611 /*! -

612 For random-access devices, this function sets the current position -

613 to \a pos, returning true on success, or false if an error occurred. -

614 For sequential devices, the default behavior is to produce a warning -

615 and return false. -

616 -

617 When subclassing QIODevice, you must call QIODevice::seek() at the -

618 start of your function to ensure integrity with QIODevice's -

619 built-in buffer. -

620 -

621 \sa pos(), isSequential() -

622 */ -

623 bool QIODevice::seek(qint64 pos) -

624 { -

625

qWarning("QIODevice::seek: Cannot call seek on a sequential device");

executed (the execution status of this line is deduced): QIODevicePrivate * const d = d_func();

626

if (d->isSequential()) {

evaluated: d->isSequential()

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

1-262918

627

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

 QMessageLogger("io/qiodevice.cpp", 627, __PRETTY_FUNCTION__).warning("QIODevice::seek: Cannot call seek on a sequential device");

628

if (d->openMode == NotOpen) {

executed: return false;

Execution Count:1

629 } -

630

partially evaluated: d->openMode == NotOpen

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

0-262918

631

qWarning("QIODevice::seek: The device is not open");

never executed (the execution status of this line is deduced): QMessageLogger("io/qiodevice.cpp", 631, __PRETTY_FUNCTION__).warning("QIODevice::seek: The device is not open");

632

qWarning("QIODevice::seek: Invalid pos: %d", int(pos));

never executed: return false;

633 } -

634

if (pos < 0) {

partially evaluated: pos < 0

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

0-262918

635

never executed (the execution status of this line is deduced): QMessageLogger("io/qiodevice.cpp", 635, __PRETTY_FUNCTION__).warning("QIODevice::seek: Invalid pos: %d", int(pos));

636

qint64 offset = pos - d->pos;

never executed: return false;

637 } -

638 -

639 #if defined QIODEVICE_DEBUG -

640 printf("%p QIODevice::seek(%d), before: d->pos = %d, d->buffer.size() = %d\n", -

641 this, int(pos), int(d->pos), d->buffer.size()); -

642 #endif -

643 -

644

executed (the execution status of this line is deduced): qint64 offset = pos - d->pos;

645

d->pos = pos;

executed (the execution status of this line is deduced): d->pos = pos;

646

d->devicePos = pos;

executed (the execution status of this line is deduced): d->devicePos = pos;

647 -

648

if (offset < 0

evaluated: offset < 0

TRUE	FALSE
yes Evaluation Count:126245	yes Evaluation Count:136673

126245-136673

649

|| offset >= qint64(d->buffer.size()))

evaluated: offset >= qint64(d->buffer.size())

TRUE	FALSE
yes Evaluation Count:117886	yes Evaluation Count:18787

18787-117886

650 // When seeking backwards, an operation that is only allowed for -

651 // random-access devices, the buffer is cleared. The next read -

652 // operation will then refill the buffer. We can optimize this, if we -

653 // find that seeking backwards becomes a significant performance hit. -

654

else if (!d->buffer.isEmpty())

executed: d->buffer.clear();

Execution Count:244131

244131

655

partially evaluated: !d->buffer.isEmpty()

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

0-18787

656

d->buffer.skip(int(offset));

executed: d->buffer.skip(int(offset));

Execution Count:18787

18787

657 -

658 #if defined QIODEVICE_DEBUG -

659 printf("%p \tafter: d->pos == %d, d->buffer.size() == %d\n", this, int(d->pos), -

660 d->buffer.size()); -

661 #endif -

662

return true;

executed: return true;

Execution Count:262918

262918

663 } -

664 -

665 /*! -

666 Returns true if the current read and write position is at the end -

667 of the device (i.e. there is no more data available for reading on -

668 the device); otherwise returns false. -

669 -

670 For some devices, atEnd() can return true even though there is more data -

671 to read. This special case only applies to devices that generate data in -

672 direct response to you calling read() (e.g., \c /dev or \c /proc files on -

673 Unix and Mac OS X, or console input / \c stdin on all platforms). -

674 -

675 \sa bytesAvailable(), read(), isSequential() -

676 */ -

677 bool QIODevice::atEnd() const -

678 { -

679

return d->openMode == NotOpen || (d->buffer.isEmpty() && bytesAvailable() == 0);

executed (the execution status of this line is deduced): const QIODevicePrivate * const d = d_func();

680 #if defined QIODEVICE_DEBUG -

681 printf("%p QIODevice::atEnd() returns %s, d->openMode == %d, d->pos == %d\n", this, (d->openMode == NotOpen || d->pos == size()) ? "true" : "false", -

682 int(d->openMode), int(d->pos)); -

683 #endif -

684

executed: return d->openMode == NotOpen || (d->buffer.isEmpty() && bytesAvailable() == 0);

Execution Count:5530

5530

685 } -

686 -

687 /*! -

688 Seeks to the start of input for random-access devices. Returns -

689 true on success; otherwise returns false (for example, if the -

690 device is not open). -

691 -

692 Note that when using a QTextStream on a QFile, calling reset() on -

693 the QFile will not have the expected result because QTextStream -

694 buffers the file. Use the QTextStream::seek() function instead. -

695 -

696 \sa seek() -

697 */ -

698 bool QIODevice::reset() -

699 { -

700 #if defined QIODEVICE_DEBUG -

701 printf("%p QIODevice::reset()\n", this); -

702 #endif -

703

return seek(0);

executed: return seek(0);

Execution Count:102

102

704 } -

705 -

706 /*! -

707 Returns the number of bytes that are available for reading. This -

708 function is commonly used with sequential devices to determine the -

709 number of bytes to allocate in a buffer before reading. -

710 -

711 Subclasses that reimplement this function must call the base -

712 implementation in order to include the size of QIODevices' buffer. Example: -

713 -

714 \snippet code/src_corelib_io_qiodevice.cpp 1 -

715 -

716 \sa bytesToWrite(), readyRead(), isSequential() -

717 */ -

718 qint64 QIODevice::bytesAvailable() const -

719 { -

720

return qMax(size() - d->pos, qint64(0));

executed (the execution status of this line is deduced): const QIODevicePrivate * const d = d_func();

721

if (!d->isSequential())

evaluated: !d->isSequential()

TRUE	FALSE
yes Evaluation Count:5587	yes Evaluation Count:45931

5587-45931

722

executed: return qMax(size() - d->pos, qint64(0));

Execution Count:5587

5587

723

return d->buffer.size();

executed: return d->buffer.size();

Execution Count:45932

45932

724 } -

725 -

726 /*! -

727 For buffered devices, this function returns the number of bytes -

728 waiting to be written. For devices with no buffer, this function -

729 returns 0. -

730 -

731 \sa bytesAvailable(), bytesWritten(), isSequential() -

732 */ -

733 qint64 QIODevice::bytesToWrite() const -

734 { -

735

return qint64(0);

never executed: return qint64(0);

736 } -

737 -

738 #ifdef Q_CC_RVCT -

739 // arm mode makes the 64-bit integer operations much faster in RVCT 2.2 -

740 #pragma push -

741 #pragma arm -

742 #endif -

743 -

744 /*! -

745 Reads at most \a maxSize bytes from the device into \a data, and -

746 returns the number of bytes read. If an error occurs, such as when -

747 attempting to read from a device opened in WriteOnly mode, this -

748 function returns -1. -

749 -

750 0 is returned when no more data is available for reading. However, -

751 reading past the end of the stream is considered an error, so this -

752 function returns -1 in those cases (that is, reading on a closed -

753 socket or after a process has died). -

754 -

755 \sa readData(), readLine(), write() -

756 */ -

757 qint64 QIODevice::read(char *data, qint64 maxSize) -

758 { -

759

while ((chint = d->buffer.getChar()) != -1) {

executed (the execution status of this line is deduced): QIODevicePrivate * const d = d_func();

760 -

761 #if defined QIODEVICE_DEBUG -

762 printf("%p QIODevice::read(%p, %d), d->pos = %d, d->buffer.size() = %d\n", -

763 this, data, int(maxSize), int(d->pos), int(d->buffer.size())); -

764 #endif -

765 -

766 // Short circuit for getChar() -

767

if (maxSize == 1) {

evaluated: maxSize == 1

TRUE	FALSE
yes Evaluation Count:43557679	yes Evaluation Count:327886

327886-43557679

768

int chint;

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

769

evaluated: (chint = d->buffer.getChar()) != -1

TRUE	FALSE
yes Evaluation Count:43410030	yes Evaluation Count:147786

147786-43410030

770

++(*d->pPos);

executed (the execution status of this line is deduced): ++(*d->pPos);

771 -

772

char c = char(uchar(chint));

executed (the execution status of this line is deduced): char c = char(uchar(chint));

773

if (c == '\r' && (d->openMode & Text))

evaluated: c == '\r'

TRUE	FALSE
yes Evaluation Count:16062	yes Evaluation Count:43393968

evaluated: (d->openMode & Text)

TRUE	FALSE
yes Evaluation Count:137	yes Evaluation Count:15925

137-43393968

774

continue;

executed: continue;

Execution Count:137

137

775

*data = c;

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

776 #if defined QIODEVICE_DEBUG -

777 printf("%p \tread 0x%hhx (%c) returning 1 (shortcut)\n", this, -

778 int(c), isprint(c) ? c : '?'); -

779 #endif -

780

if (d->buffer.isEmpty())

evaluated: d->buffer.isEmpty()

TRUE	FALSE
yes Evaluation Count:2949	yes Evaluation Count:43406944

2949-43406944

781

readData(data, 0);

executed: readData(data, 0);

Execution Count:2949

2949

782

return qint64(1);

executed: return qint64(1);

Execution Count:43409893

43409893

783 } -

784

CHECK_MAXLEN(read, qint64(-1));

executed: }

Execution Count:147786

147786

785 -

786

never executed: return qint64(-1);

executed: }

Execution Count:475672

partially evaluated: maxSize < 0

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

partially evaluated: 0

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

0-475672

787

qint64 readSoFar = 0;

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

788

bool moreToRead = true;

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

789 do { -

790 // Try reading from the buffer. -

791

int lastReadChunkSize = d->buffer.read(data, maxSize);

executed (the execution status of this line is deduced): int lastReadChunkSize = d->buffer.read(data, maxSize);

792

if (lastReadChunkSize > 0) {

evaluated: lastReadChunkSize > 0

TRUE	FALSE
yes Evaluation Count:216588	yes Evaluation Count:259102

216588-259102

793

*d->pPos += lastReadChunkSize;

executed (the execution status of this line is deduced): *d->pPos += lastReadChunkSize;

794

readSoFar += lastReadChunkSize;

executed (the execution status of this line is deduced): readSoFar += lastReadChunkSize;

795 // fast exit when satisfied by buffer -

796

if (lastReadChunkSize == maxSize && !(d->openMode & Text)) {

evaluated: lastReadChunkSize == maxSize

TRUE	FALSE
yes Evaluation Count:197649	yes Evaluation Count:18939

evaluated: !(d->openMode & Text)

TRUE	FALSE
yes Evaluation Count:197643	yes Evaluation Count:6

6-197649

797

if (d->buffer.isEmpty()) {

evaluated: d->buffer.isEmpty()

TRUE	FALSE
yes Evaluation Count:6085	yes Evaluation Count:191558

6085-191558

798

executed (the execution status of this line is deduced): d->buffer.clear();

799

readData(data, 0);

executed (the execution status of this line is deduced): readData(data, 0);

800

executed: }

Execution Count:6085

6085

801

data += lastReadChunkSize;

executed: return readSoFar;

Execution Count:197643

197643

802 } -

803 -

804

executed (the execution status of this line is deduced): data += lastReadChunkSize;

805

maxSize -= lastReadChunkSize;

executed (the execution status of this line is deduced): maxSize -= lastReadChunkSize;

806 #if defined QIODEVICE_DEBUG -

807 printf("%p \treading %d bytes from buffer into position %d\n", this, lastReadChunkSize, -

808 int(readSoFar) - lastReadChunkSize); -

809 #endif -

810

CHECK_READABLE(read, qint64(-1));

executed: }

Execution Count:18945

18945

811

if (d->firstRead) {

evaluated: d->firstRead

TRUE	FALSE
yes Evaluation Count:19231	yes Evaluation Count:239871

19231-239871

812 // this is the first time the file has been read, check it's valid and set up pos pointers -

813 // for fast pos updates. -

814

executed: return qint64(-1);

Execution Count:25

executed: return qint64(-1);

Execution Count:2

executed: }

Execution Count:19205

evaluated: (d->openMode & ReadOnly) == 0

TRUE	FALSE
yes Evaluation Count:27	yes Evaluation Count:19204

evaluated: d->openMode == NotOpen

TRUE	FALSE
yes Evaluation Count:25	yes Evaluation Count:2

partially evaluated: 0

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

0-19205

815

d->firstRead = false;

executed (the execution status of this line is deduced): d->firstRead = false;

816

if (d->isSequential()) {

evaluated: d->isSequential()

TRUE	FALSE
yes Evaluation Count:2591	yes Evaluation Count:16614

2591-16614

817

d->pPos = &d->seqDumpPos;

executed (the execution status of this line is deduced): d->pPos = &d->seqDumpPos;

818

d->pDevicePos = &d->seqDumpPos;

executed (the execution status of this line is deduced): d->pDevicePos = &d->seqDumpPos;

819

executed: }

Execution Count:2591

2591

820

executed: }

Execution Count:19205

19205

821 -

822

if (!maxSize)

evaluated: !maxSize

TRUE	FALSE
yes Evaluation Count:1961	yes Evaluation Count:257115

1961-257115

823

if ((d->openMode & Unbuffered) == 0 && maxSize < QIODEVICE_BUFFERSIZE) {

executed: return readSoFar;

Execution Count:1961

1961

824 -

825

evaluated: (d->openMode & Unbuffered) == 0

TRUE	FALSE
yes Evaluation Count:118741	yes Evaluation Count:138374

evaluated: maxSize < static_cast<long long>(16384LL)

TRUE	FALSE
yes Evaluation Count:103685	yes Evaluation Count:15056

15056-138374

826 // In buffered mode, we try to fill up the QIODevice buffer before -

827 // we do anything else. -

828 // buffer is empty at this point, try to fill it -

829

int bytesToBuffer = QIODEVICE_BUFFERSIZE;

executed (the execution status of this line is deduced): int bytesToBuffer = static_cast<long long>(16384LL);

830

char *writePointer = d->buffer.reserve(bytesToBuffer);

executed (the execution status of this line is deduced): char *writePointer = d->buffer.reserve(bytesToBuffer);

831 -

832 // Make sure the device is positioned correctly. -

833

if (d->pos != d->devicePos && !d->isSequential() && !seek(d->pos))

evaluated: d->pos != d->devicePos

TRUE	FALSE
yes Evaluation Count:3357	yes Evaluation Count:100328

evaluated: !d->isSequential()

TRUE	FALSE
yes Evaluation Count:420	yes Evaluation Count:2937

partially evaluated: !seek(d->pos)

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

0-100328

834

return readSoFar ? readSoFar : qint64(-1);

never executed: return readSoFar ? readSoFar : qint64(-1);

835

qint64 readFromDevice = readData(writePointer, bytesToBuffer);

executed (the execution status of this line is deduced): qint64 readFromDevice = readData(writePointer, bytesToBuffer);

836

d->buffer.chop(bytesToBuffer - (readFromDevice < 0 ? 0 : int(readFromDevice)));

executed (the execution status of this line is deduced): d->buffer.chop(bytesToBuffer - (readFromDevice < 0 ? 0 : int(readFromDevice)));

837 -

838

if (readFromDevice > 0) {

evaluated: readFromDevice > 0

TRUE	FALSE
yes Evaluation Count:39153	yes Evaluation Count:64532

39153-64532

839

*d->pDevicePos += readFromDevice;

executed (the execution status of this line is deduced): *d->pDevicePos += readFromDevice;

840 #if defined QIODEVICE_DEBUG -

841 printf("%p \treading %d from device into buffer\n", this, int(readFromDevice)); -

842 #endif -

843 -

844

if (!d->buffer.isEmpty()) {

evaluated: !d->buffer.isEmpty()

TRUE	FALSE
yes Evaluation Count:39083	yes Evaluation Count:70

70-39083

845

lastReadChunkSize = d->buffer.read(data, maxSize);

executed (the execution status of this line is deduced): lastReadChunkSize = d->buffer.read(data, maxSize);

846

readSoFar += lastReadChunkSize;

executed (the execution status of this line is deduced): readSoFar += lastReadChunkSize;

847

data += lastReadChunkSize;

executed (the execution status of this line is deduced): data += lastReadChunkSize;

848

maxSize -= lastReadChunkSize;

executed (the execution status of this line is deduced): maxSize -= lastReadChunkSize;

849

*d->pPos += lastReadChunkSize;

executed (the execution status of this line is deduced): *d->pPos += lastReadChunkSize;

850 #if defined QIODEVICE_DEBUG -

851 printf("%p \treading %d bytes from buffer at position %d\n", this, -

852 lastReadChunkSize, int(readSoFar)); -

853 #endif -

854

executed: }

Execution Count:39083

39083

855

executed: }

Execution Count:39153

39153

856

executed: }

Execution Count:103685

103685

857

if (d->pos != d->devicePos && !d->isSequential() && !seek(d->pos))

executed: }

Execution Count:257115

257115

858 -

859 // If we need more, try reading from the device. -

860

if (maxSize > 0) {

evaluated: maxSize > 0

TRUE	FALSE
yes Evaluation Count:239414	yes Evaluation Count:36646

36646-239414

861 // Make sure the device is positioned correctly. -

862

evaluated: d->pos != d->devicePos

TRUE	FALSE
yes Evaluation Count:5340	yes Evaluation Count:234073

evaluated: !d->isSequential()

TRUE	FALSE
yes Evaluation Count:491	yes Evaluation Count:4849

partially evaluated: !seek(d->pos)

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

0-234073

863

return readSoFar ? readSoFar : qint64(-1);

never executed: return readSoFar ? readSoFar : qint64(-1);

864

qint64 readFromDevice = readData(data, maxSize);

executed (the execution status of this line is deduced): qint64 readFromDevice = readData(data, maxSize);

865 #if defined QIODEVICE_DEBUG -

866 printf("%p \treading %d bytes from device (total %d)\n", this, int(readFromDevice), int(readSoFar)); -

867 #endif -

868

if (readFromDevice == -1 && readSoFar == 0) {

evaluated: readFromDevice == -1

TRUE	FALSE
yes Evaluation Count:4600	yes Evaluation Count:234814

evaluated: readSoFar == 0

TRUE	FALSE
yes Evaluation Count:4590	yes Evaluation Count:10

10-234814

869 // error and we haven't read anything: return immediately -

870

return -1;

executed: return -1;

Execution Count:4590

4590

871 } -

872

if (readFromDevice > 0) {

evaluated: readFromDevice > 0

TRUE	FALSE
yes Evaluation Count:149898	yes Evaluation Count:84926

84926-149898

873

lastReadChunkSize += int(readFromDevice);

executed (the execution status of this line is deduced): lastReadChunkSize += int(readFromDevice);

874

readSoFar += readFromDevice;

executed (the execution status of this line is deduced): readSoFar += readFromDevice;

875

data += readFromDevice;

executed (the execution status of this line is deduced): data += readFromDevice;

876

maxSize -= readFromDevice;

executed (the execution status of this line is deduced): maxSize -= readFromDevice;

877

*d->pPos += readFromDevice;

executed (the execution status of this line is deduced): *d->pPos += readFromDevice;

878

*d->pDevicePos += readFromDevice;

executed (the execution status of this line is deduced): *d->pDevicePos += readFromDevice;

879

executed: }

Execution Count:149898

149898

880

if (readSoFar && d->openMode & Text) {

executed: }

Execution Count:234824

234824

881 // Best attempt has been made to read data, don't try again except for text mode adjustment below -

882

moreToRead = false;

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

883 -

884

evaluated: readSoFar

TRUE	FALSE
yes Evaluation Count:202502	yes Evaluation Count:68968

evaluated: d->openMode & Text

TRUE	FALSE
yes Evaluation Count:824	yes Evaluation Count:201678

824-202502

885

char *readPtr = data - lastReadChunkSize;

executed (the execution status of this line is deduced): char *readPtr = data - lastReadChunkSize;

886

const char *endPtr = data;

executed (the execution status of this line is deduced): const char *endPtr = data;

887 -

888

if (readPtr < endPtr) {

evaluated: readPtr < endPtr

TRUE	FALSE
yes Evaluation Count:808	yes Evaluation Count:16

16-808

889 // optimization to avoid initial self-assignment -

890

while (*readPtr != '\r') {

evaluated: *readPtr != '\r'

TRUE	FALSE
yes Evaluation Count:2463955	yes Evaluation Count:18

18-2463955

891

if (++readPtr == endPtr)

evaluated: ++readPtr == endPtr

TRUE	FALSE
yes Evaluation Count:790	yes Evaluation Count:2463165

790-2463165

892

executed: return readSoFar;

Execution Count:790

790

893

char *writePtr = readPtr;

executed: }

Execution Count:2463165

2463165

894 -

895

executed (the execution status of this line is deduced): char *writePtr = readPtr;

896 -

897

while (readPtr < endPtr) {

evaluated: readPtr < endPtr

TRUE	FALSE
yes Evaluation Count:5253	yes Evaluation Count:18

18-5253

898

char ch = *readPtr++;

executed (the execution status of this line is deduced): char ch = *readPtr++;

899

if (ch != '\r')

evaluated: ch != '\r'

TRUE	FALSE
yes Evaluation Count:5168	yes Evaluation Count:85

85-5168

900

*writePtr++ = ch;

executed: *writePtr++ = ch;

Execution Count:5168

5168

901 else { -

902

--readSoFar;

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

903

--data;

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

904

++maxSize;

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

905

moreToRead = (readPtr != writePtr);

executed: }

Execution Count:85

906 } -

907 -

908 // Make sure we get more data if there is room for more. This -

909 // is very important for when someone seeks to the start of a -

910 // '\r\n' and reads one character - they should get the '\n'. -

911

executed (the execution status of this line is deduced): moreToRead = (readPtr != writePtr);

912

executed: }

Execution Count:18

913

executed: }

Execution Count:34

914

} while (moreToRead);

executed: }

Execution Count:270680

evaluated: moreToRead

TRUE	FALSE
yes Evaluation Count:18	yes Evaluation Count:270662

18-270680

915 -

916 #if defined QIODEVICE_DEBUG -

917 printf("%p \treturning %d, d->pos == %d, d->buffer.size() == %d\n", this, -

918 int(readSoFar), int(d->pos), d->buffer.size()); -

919 debugBinaryString(data - readSoFar, readSoFar); -

920 #endif -

921 -

922

if (d->buffer.isEmpty())

evaluated: d->buffer.isEmpty()

TRUE	FALSE
yes Evaluation Count:239931	yes Evaluation Count:30731

30731-239931

923

readData(data, 0);

executed: readData(data, 0);

Execution Count:239931

239931

924 -

925

executed: return readSoFar;

Execution Count:270662

270662

926 } -

927 -

928 #ifdef Q_CC_RVCT -

929 #pragma pop -

930 #endif -

931 -

932 /*! -

933 \overload -

934 -

935 Reads at most \a maxSize bytes from the device, and returns the -

936 data read as a QByteArray. -

937 -

938 This function has no way of reporting errors; returning an empty -

939 QByteArray() can mean either that no data was currently available -

940 for reading, or that an error occurred. -

941 */ -

942 QByteArray QIODevice::read(qint64 maxSize) -

943 { -

944

CHECK_MAXLEN(read, result);

executed (the execution status of this line is deduced): QIODevicePrivate * const d = d_func();

945

QByteArray result;

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

946 -

947

never executed: return result;

executed: }

Execution Count:49464

partially evaluated: maxSize < 0

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

partially evaluated: 0

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

0-49464

948 -

949 #if defined QIODEVICE_DEBUG -

950 printf("%p QIODevice::read(%d), d->pos = %d, d->buffer.size() = %d\n", -

951 this, int(maxSize), int(d->pos), int(d->buffer.size())); -

952 #else -

953

Q_UNUSED(d);

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

954 #endif -

955 -

956

if (maxSize != qint64(int(maxSize))) {

partially evaluated: maxSize != qint64(int(maxSize))

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

0-49464

957

qWarning("QIODevice::read: maxSize argument exceeds QByteArray size limit");

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

 QMessageLogger("io/qiodevice.cpp", 957, __PRETTY_FUNCTION__).warning("QIODevice::read: maxSize argument exceeds QByteArray size limit");

958

maxSize = INT_MAX;

never executed (the execution status of this line is deduced): maxSize = 2147483647;

959

result.resize(int(maxSize));

never executed: }

960 -

961

qint64 readBytes = 0;

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

962

if (maxSize) {

evaluated: maxSize

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

1-49463

963

executed (the execution status of this line is deduced): result.resize(int(maxSize));

964

if (!result.size()) {

partially evaluated: !result.size()

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

0-49463

965 // If resize fails, read incrementally. -

966

qint64 readResult;

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

967 do { -

968

result.resize(int(qMin(maxSize, result.size() + QIODEVICE_BUFFERSIZE)));

never executed (the execution status of this line is deduced): result.resize(int(qMin(maxSize, result.size() + static_cast<long long>(16384LL))));

969

readResult = read(result.data() + readBytes, result.size() - readBytes);

never executed (the execution status of this line is deduced): readResult = read(result.data() + readBytes, result.size() - readBytes);

970

if (readResult > 0 || readBytes == 0)

never evaluated: readResult > 0

never evaluated: readBytes == 0

971

readBytes += readResult;

never executed: readBytes += readResult;

972

} while (readResult == QIODEVICE_BUFFERSIZE);

never executed: }

never evaluated: readResult == static_cast<long long>(16384LL)

973

readBytes = read(result.data(), result.size());

never executed: }

974

executed (the execution status of this line is deduced): readBytes = read(result.data(), result.size());

975

executed: }

Execution Count:49463

49463

976 } -

977 -

978

result.resize(int(readBytes));

evaluated: readBytes <= 0

TRUE	FALSE
yes Evaluation Count:93	yes Evaluation Count:49371

93-49371

979

result.clear();

executed: result.clear();

Execution Count:93

980 else -

981

executed: result.resize(int(readBytes));

Execution Count:49371

49371

982 -

983

executed: return result;

Execution Count:49464

49464

984 } -

985 -

986 /*! -

987 \overload -

988 -

989 Reads all available data from the device, and returns it as a -

990 QByteArray. -

991 -

992 This function has no way of reporting errors; returning an empty -

993 QByteArray() can mean either that no data was currently available -

994 for reading, or that an error occurred. -

995 */ -

996 QByteArray QIODevice::readAll() -

997 { -

998

if (!(d->openMode & Text) && !d->buffer.isEmpty()) {

executed (the execution status of this line is deduced): QIODevicePrivate * const d = d_func();

999 #if defined QIODEVICE_DEBUG -

1000 printf("%p QIODevice::readAll(), d->pos = %d, d->buffer.size() = %d\n", -

1001 this, int(d->pos), int(d->buffer.size())); -

1002 #endif -

1003 -

1004

QByteArray result;

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

1005

qint64 readBytes = 0;

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

1006 -

1007 // flush internal read buffer -

1008

evaluated: !(d->openMode & Text)

TRUE	FALSE
yes Evaluation Count:9519	yes Evaluation Count:606

evaluated: !d->buffer.isEmpty()

TRUE	FALSE
yes Evaluation Count:1373	yes Evaluation Count:8146

606-9519

1009

result = d->buffer.readAll();

executed (the execution status of this line is deduced): result = d->buffer.readAll();

1010

readBytes = result.size();

executed (the execution status of this line is deduced): readBytes = result.size();

1011

d->pos += readBytes;

executed (the execution status of this line is deduced): d->pos += readBytes;

1012

if (d->isSequential() || (theSize = size()) == 0) {

executed: }

Execution Count:1373

1373

1013 -

1014

qint64 theSize;

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

1015

evaluated: d->isSequential()

TRUE	FALSE
yes Evaluation Count:3665	yes Evaluation Count:6460

evaluated: (theSize = size()) == 0

TRUE	FALSE
yes Evaluation Count:20	yes Evaluation Count:6440

20-6460

1016 // Size is unknown, read incrementally. -

1017

qint64 readResult;

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

1018 do { -

1019

result.resize(result.size() + QIODEVICE_BUFFERSIZE);

executed (the execution status of this line is deduced): result.resize(result.size() + static_cast<long long>(16384LL));

1020

readResult = read(result.data() + readBytes, result.size() - readBytes);

executed (the execution status of this line is deduced): readResult = read(result.data() + readBytes, result.size() - readBytes);

1021

if (readResult > 0 || readBytes == 0)

evaluated: readResult > 0

TRUE	FALSE
yes Evaluation Count:1887	yes Evaluation Count:3685

evaluated: readBytes == 0

TRUE	FALSE
yes Evaluation Count:923	yes Evaluation Count:2762

923-3685

1022

readBytes += readResult;

executed: readBytes += readResult;

Execution Count:2810

2810

1023

} while (readResult > 0);

executed: }

Execution Count:5572

evaluated: readResult > 0

TRUE	FALSE
yes Evaluation Count:1887	yes Evaluation Count:3685

1887-5572

1024

result.resize(int(readBytes + theSize - d->pos));

executed: }

Execution Count:3685

3685

1025 // Read it all in one go. -

1026 // If resize fails, don't read anything. -

1027

executed (the execution status of this line is deduced): result.resize(int(readBytes + theSize - d->pos));

1028

readBytes += read(result.data() + readBytes, result.size() - readBytes);

executed (the execution status of this line is deduced): readBytes += read(result.data() + readBytes, result.size() - readBytes);

1029

executed: }

Execution Count:6440

6440

1030 -

1031

result.resize(int(readBytes));

evaluated: readBytes <= 0

TRUE	FALSE
yes Evaluation Count:2144	yes Evaluation Count:7981

2144-7981

1032

result.clear();

executed: result.clear();

Execution Count:2144

2144

1033 else -

1034

executed: result.resize(int(readBytes));

Execution Count:7981

7981

1035 -

1036

executed: return result;

Execution Count:10125

10125

1037 } -

1038 -

1039 #ifdef Q_CC_RVCT -

1040 // arm mode makes the 64-bit integer operations much faster in RVCT 2.2 -

1041 #pragma push -

1042 #pragma arm -

1043 #endif -

1044 -

1045 /*! -

1046 This function reads a line of ASCII characters from the device, up -

1047 to a maximum of \a maxSize - 1 bytes, stores the characters in \a -

1048 data, and returns the number of bytes read. If a line could not be -

1049 read but no error ocurred, this function returns 0. If an error -

1050 occurs, this function returns the length of what could be read, or -

1051 -1 if nothing was read. -

1052 -

1053 A terminating '\\0' byte is always appended to \a data, so \a -

1054 maxSize must be larger than 1. -

1055 -

1056 Data is read until either of the following conditions are met: -

1057 -

1058 \list -

1059 \li The first '\\n' character is read. -

1060 \li \a maxSize - 1 bytes are read. -

1061 \li The end of the device data is detected. -

1062 \endlist -

1063 -

1064 For example, the following code reads a line of characters from a -

1065 file: -

1066 -

1067 \snippet code/src_corelib_io_qiodevice.cpp 2 -

1068 -

1069 The newline character ('\\n') is included in the buffer. If a -

1070 newline is not encountered before maxSize - 1 bytes are read, a -

1071 newline will not be inserted into the buffer. On windows newline -

1072 characters are replaced with '\\n'. -

1073 -

1074 This function calls readLineData(), which is implemented using -

1075 repeated calls to getChar(). You can provide a more efficient -

1076 implementation by reimplementing readLineData() in your own -

1077 subclass. -

1078 -

1079 \sa getChar(), read(), write() -

1080 */ -

1081 qint64 QIODevice::readLine(char *data, qint64 maxSize) -

1082 { -

1083

qWarning("QIODevice::readLine: Called with maxSize < 2");

executed (the execution status of this line is deduced): QIODevicePrivate * const d = d_func();

1084

if (maxSize < 2) {

evaluated: maxSize < 2

TRUE	FALSE
yes Evaluation Count:5	yes Evaluation Count:77493

5-77493

1085

executed (the execution status of this line is deduced): QMessageLogger("io/qiodevice.cpp", 1085, __PRETTY_FUNCTION__).warning("QIODevice::readLine: Called with maxSize < 2");

1086

return qint64(-1);

executed: return qint64(-1);

Execution Count:5

1087 } -

1088 -

1089 #if defined QIODEVICE_DEBUG -

1090 printf("%p QIODevice::readLine(%p, %d), d->pos = %d, d->buffer.size() = %d\n", -

1091 this, data, int(maxSize), int(d->pos), int(d->buffer.size())); -

1092 #endif -

1093 -

1094 // Leave room for a '\0' -

1095

--maxSize;

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

1096 -

1097

const bool sequential = d->isSequential();

executed (the execution status of this line is deduced): const bool sequential = d->isSequential();

1098 -

1099

qint64 readSoFar = 0;

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

1100

if (!d->buffer.isEmpty()) {

evaluated: !d->buffer.isEmpty()

TRUE	FALSE
yes Evaluation Count:77057	yes Evaluation Count:436

436-77057

1101

readSoFar = d->buffer.readLine(data, maxSize);

executed (the execution status of this line is deduced): readSoFar = d->buffer.readLine(data, maxSize);

1102

if (d->buffer.isEmpty())

evaluated: d->buffer.isEmpty()

TRUE	FALSE
yes Evaluation Count:1223	yes Evaluation Count:75834

1223-75834

1103

readData(data,0);

executed: readData(data,0);

Execution Count:1223

1223

1104

if (!sequential)

evaluated: !sequential

TRUE	FALSE
yes Evaluation Count:75882	yes Evaluation Count:1175

1175-75882

1105

d->pos += readSoFar;

executed: d->pos += readSoFar;

Execution Count:75882

75882

1106 #if defined QIODEVICE_DEBUG -

1107 printf("%p \tread from buffer: %d bytes, last character read: %hhx\n", this, -

1108 int(readSoFar), data[int(readSoFar) - 1]); -

1109 if (readSoFar) -

1110 debugBinaryString(data, int(readSoFar)); -

1111 #endif -

1112

if (readSoFar && data[readSoFar - 1] == '\n') {

partially evaluated: readSoFar

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

evaluated: data[readSoFar - 1] == '\n'

TRUE	FALSE
yes Evaluation Count:76407	yes Evaluation Count:650

0-77057

1113

if (d->openMode & Text) {

evaluated: d->openMode & Text

TRUE	FALSE
yes Evaluation Count:163	yes Evaluation Count:76244

163-76244

1114 // QRingBuffer::readLine() isn't Text aware. -

1115

if (readSoFar > 1 && data[readSoFar - 2] == '\r') {

partially evaluated: readSoFar > 1

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

evaluated: data[readSoFar - 2] == '\r'

TRUE	FALSE
yes Evaluation Count:161	yes Evaluation Count:2

0-163

1116

--readSoFar;

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

1117

data[readSoFar - 1] = '\n';

executed (the execution status of this line is deduced): data[readSoFar - 1] = '\n';

1118

executed: }

Execution Count:161

161

1119

executed: }

Execution Count:163

163

1120

data[readSoFar] = '\0';

executed (the execution status of this line is deduced): data[readSoFar] = '\0';

1121

executed: return readSoFar;

Execution Count:76407

76407

1122 } -

1123

if (d->pos != d->devicePos && !sequential && !seek(d->pos))

executed: }

Execution Count:650

650

1124 -

1125

evaluated: d->pos != d->devicePos

TRUE	FALSE
yes Evaluation Count:65	yes Evaluation Count:1021

evaluated: !sequential

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

partially evaluated: !seek(d->pos)

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

0-1021

1126

return qint64(-1);

never executed: return qint64(-1);

1127

d->baseReadLineDataCalled = false;

executed (the execution status of this line is deduced): d->baseReadLineDataCalled = false;

1128

qint64 readBytes = readLineData(data + readSoFar, maxSize - readSoFar);

executed (the execution status of this line is deduced): qint64 readBytes = readLineData(data + readSoFar, maxSize - readSoFar);

1129 #if defined QIODEVICE_DEBUG -

1130 printf("%p \tread from readLineData: %d bytes, readSoFar = %d bytes\n", this, -

1131 int(readBytes), int(readSoFar)); -

1132 if (readBytes > 0) { -

1133 debugBinaryString(data, int(readSoFar + readBytes)); -

1134 } -

1135 #endif -

1136

if (readBytes < 0) {

evaluated: readBytes < 0

TRUE	FALSE
yes Evaluation Count:355	yes Evaluation Count:731

355-731

1137

data[readSoFar] = '\0';

executed (the execution status of this line is deduced): data[readSoFar] = '\0';

1138

return readSoFar ? readSoFar : -1;

executed: return readSoFar ? readSoFar : -1;

Execution Count:355

355

1139 } -

1140

readSoFar += readBytes;

executed (the execution status of this line is deduced): readSoFar += readBytes;

1141

if (!d->baseReadLineDataCalled && !sequential) {

partially evaluated: !d->baseReadLineDataCalled

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

never evaluated: !sequential

0-731

1142

d->pos += readBytes;

never executed (the execution status of this line is deduced): d->pos += readBytes;

1143 // If the base implementation was not called, then we must -

1144 // assume the device position is invalid and force a seek. -

1145

d->devicePos = qint64(-1);

never executed (the execution status of this line is deduced): d->devicePos = qint64(-1);

1146

if (d->openMode & Text) {

never executed: }

1147

data[readSoFar] = '\0';

executed (the execution status of this line is deduced): data[readSoFar] = '\0';

1148 -

1149

evaluated: d->openMode & Text

TRUE	FALSE
yes Evaluation Count:178	yes Evaluation Count:553

178-553

1150

if (readSoFar > 1 && data[readSoFar - 1] == '\n' && data[readSoFar - 2] == '\r') {

partially evaluated: readSoFar > 1

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

evaluated: data[readSoFar - 1] == '\n'

TRUE	FALSE
yes Evaluation Count:146	yes Evaluation Count:32

partially evaluated: data[readSoFar - 2] == '\r'

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

0-178

1151

data[readSoFar - 2] = '\n';

never executed (the execution status of this line is deduced): data[readSoFar - 2] = '\n';

1152

data[readSoFar - 1] = '\0';

never executed (the execution status of this line is deduced): data[readSoFar - 1] = '\0';

1153

--readSoFar;

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

never executed: }

executed: }

Execution Count:178

178

1156 -

1157 #if defined QIODEVICE_DEBUG -

1158 printf("%p \treturning %d, d->pos = %d, d->buffer.size() = %d, size() = %d\n", -

1159 this, int(readSoFar), int(d->pos), d->buffer.size(), int(size())); -

1160 debugBinaryString(data, int(readSoFar)); -

1161 #endif -

1162

executed: return readSoFar;

Execution Count:731

731

1163 } -

1164 -

1165 /*! -

1166 \overload -

1167 -

1168 Reads a line from the device, but no more than \a maxSize characters, -

1169 and returns the result as a QByteArray. -

1170 -

1171 This function has no way of reporting errors; returning an empty -

1172 QByteArray() can mean either that no data was currently available -

1173 for reading, or that an error occurred. -

1174 */ -

1175 QByteArray QIODevice::readLine(qint64 maxSize) -

1176 { -

1177

CHECK_MAXLEN(readLine, result);

executed (the execution status of this line is deduced): QIODevicePrivate * const d = d_func();

1178

QByteArray result;

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

1179 -

1180

never executed: return result;

executed: }

Execution Count:21432

partially evaluated: maxSize < 0

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

partially evaluated: 0

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

0-21432

1181 -

1182 #if defined QIODEVICE_DEBUG -

1183 printf("%p QIODevice::readLine(%d), d->pos = %d, d->buffer.size() = %d\n", -

1184 this, int(maxSize), int(d->pos), int(d->buffer.size())); -

1185 #else -

1186

Q_UNUSED(d);

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

1187 #endif -

1188 -

1189

if (maxSize > INT_MAX) {

partially evaluated: maxSize > 2147483647

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

0-21432

1190

qWarning("QIODevice::read: maxSize argument exceeds QByteArray size limit");

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

 QMessageLogger("io/qiodevice.cpp", 1190, __PRETTY_FUNCTION__).warning("QIODevice::read: maxSize argument exceeds QByteArray size limit");

1191

maxSize = INT_MAX;

never executed (the execution status of this line is deduced): maxSize = 2147483647;

1192

result.resize(int(maxSize));

never executed: }

1193 -

1194

executed (the execution status of this line is deduced): result.resize(int(maxSize));

1195

qint64 readBytes = 0;

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

1196

if (!result.size()) {

evaluated: !result.size()

TRUE	FALSE
yes Evaluation Count:21423	yes Evaluation Count:9

9-21423

1197 // If resize fails or maxSize == 0, read incrementally -

1198

if (maxSize == 0)

partially evaluated: maxSize == 0

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

0-21423

1199

maxSize = INT_MAX;

executed: maxSize = 2147483647;

Execution Count:21423

21423

1200 -

1201 // The first iteration needs to leave an extra byte for the terminating null -

1202

result.resize(1);

executed (the execution status of this line is deduced): result.resize(1);

1203 -

1204

qint64 readResult;

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

1205 do { -

1206

result.resize(int(qMin(maxSize, result.size() + QIODEVICE_BUFFERSIZE)));

executed (the execution status of this line is deduced): result.resize(int(qMin(maxSize, result.size() + static_cast<long long>(16384LL))));

1207

readResult = readLine(result.data() + readBytes, result.size() - readBytes);

executed (the execution status of this line is deduced): readResult = readLine(result.data() + readBytes, result.size() - readBytes);

1208

if (readResult > 0 || readBytes == 0)

evaluated: readResult > 0

TRUE	FALSE
yes Evaluation Count:21406	yes Evaluation Count:85

partially evaluated: readBytes == 0

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

0-21406

1209

readBytes += readResult;

executed: readBytes += readResult;

Execution Count:21491

21491

1210

} while (readResult == QIODEVICE_BUFFERSIZE

executed: }

Execution Count:21491

evaluated: readResult == static_cast<long long>(16384LL)

TRUE	FALSE
yes Evaluation Count:76	yes Evaluation Count:21415

76-21491

1211

&& result[int(readBytes - 1)] != '\n');

evaluated: result[int(readBytes - 1)] != '\n'

TRUE	FALSE
yes Evaluation Count:68	yes Evaluation Count:8

8-68

1212

} else

executed: }

Execution Count:21423

21423

1213

readBytes = readLine(result.data(), result.size());

executed: readBytes = readLine(result.data(), result.size());

Execution Count:9

1214 -

1215

result.resize(readBytes);

evaluated: readBytes <= 0

TRUE	FALSE
yes Evaluation Count:85	yes Evaluation Count:21347

85-21347

1216

result.clear();

executed: result.clear();

Execution Count:85

1217 else -

1218

executed: result.resize(readBytes);

Execution Count:21347

21347

1219 -

1220

executed: return result;

Execution Count:21432

21432

1221 } -

1222 -

1223 /*! -

1224 Reads up to \a maxSize characters into \a data and returns the -

1225 number of characters read. -

1226 -

1227 This function is called by readLine(), and provides its base -

1228 implementation, using getChar(). Buffered devices can improve the -

1229 performance of readLine() by reimplementing this function. -

1230 -

1231 readLine() appends a '\\0' byte to \a data; readLineData() does not -

1232 need to do this. -

1233 -

1234 If you reimplement this function, be careful to return the correct -

1235 value: it should return the number of bytes read in this line, -

1236 including the terminating newline, or 0 if there is no line to be -

1237 read at this point. If an error occurs, it should return -1 if and -

1238 only if no bytes were read. Reading past EOF is considered an error. -

1239 */ -

1240 qint64 QIODevice::readLineData(char *data, qint64 maxSize) -

1241 { -

1242

d->baseReadLineDataCalled = true;

executed (the execution status of this line is deduced): QIODevicePrivate * const d = d_func();

1243

qint64 readSoFar = 0;

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

1244

char c;

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

1245

int lastReadReturn = 0;

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

1246

executed (the execution status of this line is deduced): d->baseReadLineDataCalled = true;

1247 -

1248

while (readSoFar < maxSize && (lastReadReturn = read(&c, 1)) == 1) {

evaluated: readSoFar < maxSize

TRUE	FALSE
yes Evaluation Count:837125	yes Evaluation Count:87

evaluated: (lastReadReturn = read(&c, 1)) == 1

TRUE	FALSE
yes Evaluation Count:836792	yes Evaluation Count:333

87-837125

1249

*data++ = c;

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

1250

++readSoFar;

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

1251

if (c == '\n')

evaluated: c == '\n'

TRUE	FALSE
yes Evaluation Count:658	yes Evaluation Count:836134

658-836134

1252

break;

executed: break;

Execution Count:658

658

1253

if (lastReadReturn != 1 && readSoFar == 0)

executed: }

Execution Count:836134

836134

1254 -

1255 #if defined QIODEVICE_DEBUG -

1256 printf("%p QIODevice::readLineData(%p, %d), d->pos = %d, d->buffer.size() = %d, returns %d\n", -

1257 this, data, int(maxSize), int(d->pos), int(d->buffer.size()), int(readSoFar)); -

1258 #endif -

1259

evaluated: lastReadReturn != 1

TRUE	FALSE
yes Evaluation Count:350	yes Evaluation Count:728

evaluated: readSoFar == 0

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

1-728

1260

return isSequential() ? lastReadReturn : -1;

executed: return isSequential() ? lastReadReturn : -1;

Execution Count:349

349

1261

return d_func()->buffer.canReadLine();

executed: return readSoFar;

Execution Count:729

729

1262 } -

1263 -

1264 #ifdef Q_CC_RVCT -

1265 #pragma pop -

1266 #endif -

1267 -

1268 /*! -

1269 Returns true if a complete line of data can be read from the device; -

1270 otherwise returns false. -

1271 -

1272 Note that unbuffered devices, which have no way of determining what -

1273 can be read, always return false. -

1274 -

1275 This function is often called in conjunction with the readyRead() -

1276 signal. -

1277 -

1278 Subclasses that reimplement this function must call the base -

1279 implementation in order to include the contents of the QIODevice's buffer. Example: -

1280 -

1281 \snippet code/src_corelib_io_qiodevice.cpp 3 -

1282 -

1283 \sa readyRead(), readLine() -

1284 */ -

1285 bool QIODevice::canReadLine() const -

1286 { -

1287

executed: return d_func()->buffer.canReadLine();

Execution Count:586

586

1288 } -

1289 -

1290 /*! -

1291 Writes at most \a maxSize bytes of data from \a data to the -

1292 device. Returns the number of bytes that were actually written, or -

1293 -1 if an error occurred. -

1294 -

1295 \sa read(), writeData() -

1296 */ -

1297 qint64 QIODevice::write(const char *data, qint64 maxSize) -

1298 { -

1299

CHECK_WRITABLE(write, qint64(-1));

executed (the execution status of this line is deduced): QIODevicePrivate * const d = d_func();

1300

executed: return qint64(-1);

Execution Count:2

executed: return qint64(-1);

Execution Count:1

executed: }

Execution Count:1577757

evaluated: (d->openMode & WriteOnly) == 0

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:1577757

evaluated: d->openMode == NotOpen

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

partially evaluated: 0

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

0-1577757

1301

CHECK_MAXLEN(write, qint64(-1));

never executed: return qint64(-1);

executed: }

Execution Count:1577757

partially evaluated: maxSize < 0

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

partially evaluated: 0

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

0-1577757

1302 -

1303

const bool sequential = d->isSequential();

executed (the execution status of this line is deduced): const bool sequential = d->isSequential();

1304 // Make sure the device is positioned correctly. -

1305

if (d->pos != d->devicePos && !sequential && !seek(d->pos))

evaluated: d->pos != d->devicePos

TRUE	FALSE
yes Evaluation Count:12956	yes Evaluation Count:1564801

evaluated: !sequential

TRUE	FALSE
yes Evaluation Count:46	yes Evaluation Count:12910

partially evaluated: !seek(d->pos)

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

0-1564801

1306

return qint64(-1);

never executed: return qint64(-1);

1307 -

1308 #ifdef Q_OS_WIN -

1309 if (d->openMode & Text) { -

1310 const char *endOfData = data + maxSize; -

1311 const char *startOfBlock = data; -

1312 -

1313 qint64 writtenSoFar = 0; -

1314 -

1315 forever { -

1316 const char *endOfBlock = startOfBlock; -

1317 while (endOfBlock < endOfData && *endOfBlock != '\n') -

1318 ++endOfBlock; -

1319 -

1320 qint64 blockSize = endOfBlock - startOfBlock; -

1321 if (blockSize > 0) { -

1322 qint64 ret = writeData(startOfBlock, blockSize); -

1323 if (ret <= 0) { -

1324 if (writtenSoFar && !sequential) -

1325 d->buffer.skip(writtenSoFar); -

1326 return writtenSoFar ? writtenSoFar : ret; -

1327 } -

1328 if (!sequential) { -

1329 d->pos += ret; -

1330 d->devicePos += ret; -

1331 } -

1332 writtenSoFar += ret; -

1333 } -

1334 -

1335 if (endOfBlock == endOfData) -

1336 break; -

1337 -

1338 qint64 ret = writeData("\r\n", 2); -

1339 if (ret <= 0) { -

1340 if (writtenSoFar && !sequential) -

1341 d->buffer.skip(writtenSoFar); -

1342 return writtenSoFar ? writtenSoFar : ret; -

1343 } -

1344 if (!sequential) { -

1345 d->pos += ret; -

1346 d->devicePos += ret; -

1347 } -

1348 ++writtenSoFar; -

1349 -

1350 startOfBlock = endOfBlock + 1; -

1351 } -

1352 -

1353 if (writtenSoFar && !sequential) -

1354 d->buffer.skip(writtenSoFar); -

1355 return writtenSoFar; -

1356 } -

1357 #endif -

1358 -

1359

qint64 written = writeData(data, maxSize);

executed (the execution status of this line is deduced): qint64 written = writeData(data, maxSize);

1360

if (written > 0) {

evaluated: written > 0

TRUE	FALSE
yes Evaluation Count:1575555	yes Evaluation Count:2202

2202-1575555

1361

if (!sequential) {

evaluated: !sequential

TRUE	FALSE
yes Evaluation Count:274402	yes Evaluation Count:1301153

274402-1301153

1362

d->pos += written;

executed (the execution status of this line is deduced): d->pos += written;

1363

d->devicePos += written;

executed (the execution status of this line is deduced): d->devicePos += written;

1364

if (!d->buffer.isEmpty() && !sequential)

executed: }

Execution Count:274402

274402

1365

evaluated: !d->buffer.isEmpty()

TRUE	FALSE
yes Evaluation Count:11	yes Evaluation Count:1575544

evaluated: !sequential

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

2-1575544

1366

d->buffer.skip(written);

executed: d->buffer.skip(written);

Execution Count:2

1367

return write(data, qstrlen(data));

executed: }

Execution Count:1575555

1575555

1368

return written;

executed: return written;

Execution Count:1577757

1577757

1369 } -

1370 -

1371 /*! -

1372 \since 4.5 -

1373 -

1374 \overload -

1375 -

1376 Writes data from a zero-terminated string of 8-bit characters to the -

1377 device. Returns the number of bytes that were actually written, or -

1378 -1 if an error occurred. This is equivalent to -

1379 \code -

1380 ... -

1381 QIODevice::write(data, qstrlen(data)); -

1382 ... -

1383 \endcode -

1384 -

1385 \sa read(), writeData() -

1386 */ -

1387 qint64 QIODevice::write(const char *data) -

1388 { -

1389

executed: return write(data, qstrlen(data));

Execution Count:2913

2913

1390 } -

1391 -

1392 /*! \fn qint64 QIODevice::write(const QByteArray &byteArray) -

1393 -

1394 \overload -

1395 -

1396 Writes the content of \a byteArray to the device. Returns the number of -

1397 bytes that were actually written, or -1 if an error occurred. -

1398 -

1399 \sa read(), writeData() -

1400 */ -

1401 -

1402 /*! -

1403 Puts the character \a c back into the device, and decrements the -

1404 current position unless the position is 0. This function is -

1405 usually called to "undo" a getChar() operation, such as when -

1406 writing a backtracking parser. -

1407 -

1408 If \a c was not previously read from the device, the behavior is -

1409 undefined. -

1410 */ -

1411 void QIODevice::ungetChar(char c) -

1412 { -

1413

CHECK_READABLE(read, Q_VOID);

executed (the execution status of this line is deduced): QIODevicePrivate * const d = d_func();

1414

never executed: return ;

executed: }

Execution Count:36147

partially evaluated: (d->openMode & ReadOnly) == 0

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

never evaluated: d->openMode == NotOpen

partially evaluated: 0

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

0-36147

1415 -

1416 #if defined QIODEVICE_DEBUG -

1417 printf("%p QIODevice::ungetChar(0x%hhx '%c')\n", this, c, isprint(c) ? c : '?'); -

1418 #endif -

1419 -

1420

d->buffer.ungetChar(c);

executed (the execution status of this line is deduced): d->buffer.ungetChar(c);

1421

if (!d->isSequential())

evaluated: !d->isSequential()

TRUE	FALSE
yes Evaluation Count:35697	yes Evaluation Count:450

450-35697

1422

--d->pos;

executed: --d->pos;

Execution Count:35697

35697

1423

return d_func()->putCharHelper(c);

executed: }

Execution Count:36147

36147

1424 -

1425 /*! \fn bool QIODevice::putChar(char c) -

1426 -

1427 Writes the character \a c to the device. Returns true on success; -

1428 otherwise returns false. -

1429 -

1430 \sa write(), getChar(), ungetChar() -

1431 */ -

1432 bool QIODevice::putChar(char c) -

1433 { -

1434

executed: return d_func()->putCharHelper(c);

Execution Count:18740

18740

1435 } -

1436 -

1437 /*! -

1438 \internal -

1439 */ -

1440 bool QIODevicePrivate::putCharHelper(char c) -

1441 { -

1442

return q_func()->write(&c, 1) == 1;

executed: return q_func()->write(&c, 1) == 1;

Execution Count:17436

17436

1443 } -

1444 -

1445 /*! -

1446 \internal -

1447 */ -

1448 qint64 QIODevicePrivate::peek(char *data, qint64 maxSize) -

1449 { -

1450

qint64 readBytes = q_func()->read(data, maxSize);

executed (the execution status of this line is deduced): qint64 readBytes = q_func()->read(data, maxSize);

1451

buffer.ungetBlock(data, readBytes);

evaluated: readBytes <= 0

TRUE	FALSE
yes Evaluation Count:680	yes Evaluation Count:4506

680-4506

1452

return readBytes;

executed: return readBytes;

Execution Count:680

680

1453 -

1454

executed (the execution status of this line is deduced): buffer.ungetBlock(data, readBytes);

1455

*pPos -= readBytes;

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

1456

return readBytes;

executed: return readBytes;

Execution Count:4506

4506

1457 } -

1458 -

1459 /*! -

1460 \internal -

1461 */ -

1462 QByteArray QIODevicePrivate::peek(qint64 maxSize) -

1463 { -

1464

QByteArray result = q_func()->read(maxSize);

executed (the execution status of this line is deduced): QByteArray result = q_func()->read(maxSize);

1465 -

1466

if (result.isEmpty())

evaluated: result.isEmpty()

TRUE	FALSE
yes Evaluation Count:7	yes Evaluation Count:533

7-533

1467

buffer.ungetBlock(result.constData(), result.size());

executed: return result;

Execution Count:7

1468 -

1469

executed (the execution status of this line is deduced): buffer.ungetBlock(result.constData(), result.size());

1470

*pPos -= result.size();

executed (the execution status of this line is deduced): *pPos -= result.size();

1471

return (1 == read(c ? c : &ch, 1));

executed: return result;

Execution Count:533

533

1472 } -

1473 -

1474 /*! \fn bool QIODevice::getChar(char *c) -

1475 -

1476 Reads one character from the device and stores it in \a c. If \a c -

1477 is 0, the character is discarded. Returns true on success; -

1478 otherwise returns false. -

1479 -

1480 \sa read(), putChar(), ungetChar() -

1481 */ -

1482 bool QIODevice::getChar(char *c) -

1483 { -

1484 // readability checked in read() -

1485

char ch;

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

1486

executed: return (1 == read(c ? c : &ch, 1));

Execution Count:1466285

1466285

1487 } -

1488 -

1489 /*! -

1490 \since 4.1 -

1491 -

1492 Reads at most \a maxSize bytes from the device into \a data, without side -

1493 effects (i.e., if you call read() after peek(), you will get the same -

1494 data). Returns the number of bytes read. If an error occurs, such as -

1495 when attempting to peek a device opened in WriteOnly mode, this function -

1496 returns -1. -

1497 -

1498 0 is returned when no more data is available for reading. -

1499 -

1500 Example: -

1501 -

1502 \snippet code/src_corelib_io_qiodevice.cpp 4 -

1503 -

1504 \sa read() -

1505 */ -

1506 qint64 QIODevice::peek(char *data, qint64 maxSize) -

1507 { -

1508

return d_func()->peek(data, maxSize);

executed: return d_func()->peek(data, maxSize);

Execution Count:6634

6634

1509 } -

1510 -

1511 /*! -

1512 \since 4.1 -

1513 \overload -

1514 -

1515 Peeks at most \a maxSize bytes from the device, returning the data peeked -

1516 as a QByteArray. -

1517 -

1518 Example: -

1519 -

1520 \snippet code/src_corelib_io_qiodevice.cpp 5 -

1521 -

1522 This function has no way of reporting errors; returning an empty -

1523 QByteArray() can mean either that no data was currently available -

1524 for peeking, or that an error occurred. -

1525 -

1526 \sa read() -

1527 */ -

1528 QByteArray QIODevice::peek(qint64 maxSize) -

1529 { -

1530

return d_func()->peek(maxSize);

executed: return d_func()->peek(maxSize);

Execution Count:724

724

1531 } -

1532 -

1533 /*! -

1534 Blocks until new data is available for reading and the readyRead() -

1535 signal has been emitted, or until \a msecs milliseconds have -

1536 passed. If msecs is -1, this function will not time out. -

1537 -

1538 Returns true if new data is available for reading; otherwise returns -

1539 false (if the operation timed out or if an error occurred). -

1540 -

1541 This function can operate without an event loop. It is -

1542 useful when writing non-GUI applications and when performing -

1543 I/O operations in a non-GUI thread. -

1544 -

1545 If called from within a slot connected to the readyRead() signal, -

1546 readyRead() will not be reemitted. -

1547 -

1548 Reimplement this function to provide a blocking API for a custom -

1549 device. The default implementation does nothing, and returns false. -

1550 -

1551 \warning Calling this function from the main (GUI) thread -

1552 might cause your user interface to freeze. -

1553 -

1554 \sa waitForBytesWritten() -

1555 */ -

1556 bool QIODevice::waitForReadyRead(int msecs) -

1557 { -

1558

Q_UNUSED(msecs);

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

1559

executed: return false;

Execution Count:325

325

1560 } -

1561 -

1562 /*! -

1563 For buffered devices, this function waits until a payload of -

1564 buffered written data has been written to the device and the -

1565 bytesWritten() signal has been emitted, or until \a msecs -

1566 milliseconds have passed. If msecs is -1, this function will -

1567 not time out. For unbuffered devices, it returns immediately. -

1568 -

1569 Returns true if a payload of data was written to the device; -

1570 otherwise returns false (i.e. if the operation timed out, or if an -

1571 error occurred). -

1572 -

1573 This function can operate without an event loop. It is -

1574 useful when writing non-GUI applications and when performing -

1575 I/O operations in a non-GUI thread. -

1576 -

1577 If called from within a slot connected to the bytesWritten() signal, -

1578 bytesWritten() will not be reemitted. -

1579 -

1580 Reimplement this function to provide a blocking API for a custom -

1581 device. The default implementation does nothing, and returns false. -

1582 -

1583 \warning Calling this function from the main (GUI) thread -

1584 might cause your user interface to freeze. -

1585 -

1586 \sa waitForReadyRead() -

1587 */ -

1588 bool QIODevice::waitForBytesWritten(int msecs) -

1589 { -

1590

Q_UNUSED(msecs);

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

1591

d_func()->errorString = str;

never executed: return false;

1592 } -

1593 -

1594 /*! -

1595 Sets the human readable description of the last device error that -

1596 occurred to \a str. -

1597 -

1598 \sa errorString() -

1599 */ -

1600 void QIODevice::setErrorString(const QString &str) -

1601 { -

1602

executed (the execution status of this line is deduced): d_func()->errorString = str;

1603

executed: }

Execution Count:1693

1693

1604 -

1605 /*! -

1606 Returns a human-readable description of the last device error that -

1607 occurred. -

1608 -

1609 \sa setErrorString() -

1610 */ -

1611 QString QIODevice::errorString() const -

1612 { -

1613

if (d->errorString.isEmpty()) {

executed (the execution status of this line is deduced): const QIODevicePrivate * const d = d_func();

1614

evaluated: d->errorString.isEmpty()

TRUE	FALSE
yes Evaluation Count:3061	yes Evaluation Count:388

388-3061

1615 #ifdef QT_NO_QOBJECT -

1616 return QLatin1String(QT_TRANSLATE_NOOP(QIODevice, "Unknown error")); -

1617 #else -

1618

return tr("Unknown error");

executed: return tr("Unknown error");

Execution Count:3061

3061

1619 #endif -

1620 } -

1621

return d->errorString;

executed: return d->errorString;

Execution Count:388

388

1622 } -

1623 -

1624 /*! -

1625 \fn qint64 QIODevice::readData(char *data, qint64 maxSize) -

1626 -

1627 Reads up to \a maxSize bytes from the device into \a data, and -

1628 returns the number of bytes read or -1 if an error occurred. -

1629 -

1630 If there are no bytes to be read and there can never be more bytes -

1631 available (examples include socket closed, pipe closed, sub-process -

1632 finished), this function returns -1. -

1633 -

1634 This function is called by QIODevice. Reimplement this function -

1635 when creating a subclass of QIODevice. -

1636 -

1637 When reimplementing this function it is important that this function -

1638 reads all the required data before returning. This is required in order -

1639 for QDataStream to be able to operate on the class. QDataStream assumes -

1640 all the requested information was read and therefore does not retry reading -

1641 if there was a problem. -

1642 -

1643 This function might be called with a maxSize of 0, which can be used to -

1644 perform post-reading operations. -

1645 -

1646 \sa read(), readLine(), writeData() -

1647 */ -

1648 -

1649 /*! -

1650 \fn qint64 QIODevice::writeData(const char *data, qint64 maxSize) -

1651 -

1652 Writes up to \a maxSize bytes from \a data to the device. Returns -

1653 the number of bytes written, or -1 if an error occurred. -

1654 -

1655 This function is called by QIODevice. Reimplement this function -

1656 when creating a subclass of QIODevice. -

1657 -

1658 When reimplementing this function it is important that this function -

1659 writes all the data available before returning. This is required in order -

1660 for QDataStream to be able to operate on the class. QDataStream assumes -

1661 all the information was written and therefore does not retry writing if -

1662 there was a problem. -

1663 -

1664 \sa read(), write() -

1665 */ -

1666 -

1667 -

1668 #if !defined(QT_NO_DEBUG_STREAM) -

1669 QDebug operator<<(QDebug debug, QIODevice::OpenMode modes) -

1670 { -

1671

debug << "OpenMode(";

never executed (the execution status of this line is deduced): debug << "OpenMode(";

1672

QStringList modeList;

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

1673

if (modes == QIODevice::NotOpen) {

never evaluated: modes == QIODevice::NotOpen

1674

modeList << QLatin1String("NotOpen");

never executed (the execution status of this line is deduced): modeList << QLatin1String("NotOpen");

1675