OpenCoverage

dd.c

Absolute File Name:

/home/opencoverage/opencoverage/guest-scripts/coreutils/src/src/dd.c

Source code

Switch to Preprocessed file

Line Source Count

1 /* dd -- convert a file while copying it. -

3 -

4 This program is free software: you can redistribute it and/or modify -

5 it under the terms of the GNU General Public License as published by -

6 the Free Software Foundation, either version 3 of the License, or -

7 (at your option) any later version. -

8 -

9 This program is distributed in the hope that it will be useful, -

10 but WITHOUT ANY WARRANTY; without even the implied warranty of -

11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -

12 GNU General Public License for more details. -

13 -

14 You should have received a copy of the GNU General Public License -

15 along with this program. If not, see <https://www.gnu.org/licenses/>. */ -

16 -

17 /* Written by Paul Rubin, David MacKenzie, and Stuart Kemp. */ -

18 -

19 #include <config.h> -

20 -

21 #define SWAB_ALIGN_OFFSET 2 -

22 -

23 #include <sys/types.h> -

24 #include <signal.h> -

25 #include <getopt.h> -

26 -

27 #include "system.h" -

28 #include "close-stream.h" -

29 #include "die.h" -

30 #include "error.h" -

31 #include "fd-reopen.h" -

32 #include "gethrxtime.h" -

33 #include "human.h" -

34 #include "ioblksize.h" -

35 #include "long-options.h" -

36 #include "quote.h" -

37 #include "verror.h" -

38 #include "xstrtol.h" -

39 #include "xtime.h" -

40 -

41 /* The official name of this program (e.g., no 'g' prefix). */ -

42 #define PROGRAM_NAME "dd" -

43 -

44 #define AUTHORS \ -

45 proper_name ("Paul Rubin"), \ -

46 proper_name ("David MacKenzie"), \ -

47 proper_name ("Stuart Kemp") -

48 -

49 static struct option const long_options[] = -

50 { -

51 {NULL, 0, NULL, 0} -

52 }; -

53 -

54 /* Use SA_NOCLDSTOP as a proxy for whether the sigaction machinery is -

55 present. */ -

56 #ifndef SA_NOCLDSTOP -

57 # define SA_NOCLDSTOP 0 -

58 # define sigprocmask(How, Set, Oset) /* empty */ -

59 # define sigset_t int -

60 # if ! HAVE_SIGINTERRUPT -

61 # define siginterrupt(sig, flag) /* empty */ -

62 # endif -

63 #endif -

64 -

65 /* NonStop circa 2011 lacks SA_RESETHAND; see Bug#9076. */ -

66 #ifndef SA_RESETHAND -

67 # define SA_RESETHAND 0 -

68 #endif -

69 -

70 #ifndef SIGINFO -

71 # define SIGINFO SIGUSR1 -

72 #endif -

73 -

74 /* This may belong in GNULIB's fcntl module instead. -

75 Define O_CIO to 0 if it is not supported by this OS. */ -

76 #ifndef O_CIO -

77 # define O_CIO 0 -

78 #endif -

79 -

80 /* On AIX 5.1 and AIX 5.2, O_NOCACHE is defined via <fcntl.h> -

81 and would interfere with our use of that name, below. */ -

82 #undef O_NOCACHE -

83 -

84 #if ! HAVE_FDATASYNC -

85 # define fdatasync(fd) (errno = ENOSYS, -1) -

86 #endif -

87 -

88 #define output_char(c) \ -

89 do \ -

90 { \ -

91 obuf[oc++] = (c); \ -

92 if (oc >= output_blocksize) \ -

93 write_output (); \ -

94 } \ -

95 while (0) -

96 -

97 /* Default input and output blocksize. */ -

98 #define DEFAULT_BLOCKSIZE 512 -

99 -

100 /* How many bytes to add to the input and output block sizes before invoking -

101 malloc. See dd_copy for details. INPUT_BLOCK_SLOP must be no less than -

102 OUTPUT_BLOCK_SLOP. */ -

103 #define INPUT_BLOCK_SLOP (2 * SWAB_ALIGN_OFFSET + 2 * page_size - 1) -

104 #define OUTPUT_BLOCK_SLOP (page_size - 1) -

105 -

106 /* Maximum blocksize for the given SLOP. -

107 Keep it smaller than SIZE_MAX - SLOP, so that we can -

108 allocate buffers that size. Keep it smaller than SSIZE_MAX, for -

109 the benefit of system calls like "read". And keep it smaller than -

110 OFF_T_MAX, for the benefit of the large-offset seek code. */ -

111 #define MAX_BLOCKSIZE(slop) MIN (SIZE_MAX - (slop), MIN (SSIZE_MAX, OFF_T_MAX)) -

112 -

113 /* Conversions bit masks. */ -

114 enum -

115 { -

116 C_ASCII = 01, -

117 -

118 C_EBCDIC = 02, -

119 C_IBM = 04, -

120 C_BLOCK = 010, -

121 C_UNBLOCK = 020, -

122 C_LCASE = 040, -

123 C_UCASE = 0100, -

124 C_SWAB = 0200, -

125 C_NOERROR = 0400, -

126 C_NOTRUNC = 01000, -

127 C_SYNC = 02000, -

128 -

129 /* Use separate input and output buffers, and combine partial -

130 input blocks. */ -

131 C_TWOBUFS = 04000, -

132 -

133 C_NOCREAT = 010000, -

134 C_EXCL = 020000, -

135 C_FDATASYNC = 040000, -

136 C_FSYNC = 0100000, -

137 -

138 C_SPARSE = 0200000 -

139 }; -

140 -

141 /* Status levels. */ -

142 enum -

143 { -

144 STATUS_NONE = 1, -

145 STATUS_NOXFER = 2, -

146 STATUS_DEFAULT = 3, -

147 STATUS_PROGRESS = 4 -

148 }; -

149 -

150 /* The name of the input file, or NULL for the standard input. */ -

151 static char const *input_file = NULL; -

152 -

153 /* The name of the output file, or NULL for the standard output. */ -

154 static char const *output_file = NULL; -

155 -

156 /* The page size on this host. */ -

157 static size_t page_size; -

158 -

159 /* The number of bytes in which atomic reads are done. */ -

160 static size_t input_blocksize = 0; -

161 -

162 /* The number of bytes in which atomic writes are done. */ -

163 static size_t output_blocksize = 0; -

164 -

165 /* Conversion buffer size, in bytes. 0 prevents conversions. */ -

166 static size_t conversion_blocksize = 0; -

167 -

168 /* Skip this many records of 'input_blocksize' bytes before input. */ -

169 static uintmax_t skip_records = 0; -

170 -

171 /* Skip this many bytes before input in addition of 'skip_records' -

172 records. */ -

173 static size_t skip_bytes = 0; -

174 -

175 /* Skip this many records of 'output_blocksize' bytes before output. */ -

176 static uintmax_t seek_records = 0; -

177 -

178 /* Skip this many bytes in addition to 'seek_records' records before -

179 output. */ -

180 static uintmax_t seek_bytes = 0; -

181 -

182 /* Whether the final output was done with a seek (rather than a write). */ -

183 static bool final_op_was_seek; -

184 -

185 /* Copy only this many records. The default is effectively infinity. */ -

186 static uintmax_t max_records = (uintmax_t) -1; -

187 -

188 /* Copy this many bytes in addition to 'max_records' records. */ -

189 static size_t max_bytes = 0; -

190 -

191 /* Bit vector of conversions to apply. */ -

192 static int conversions_mask = 0; -

193 -

194 /* Open flags for the input and output files. */ -

195 static int input_flags = 0; -

196 static int output_flags = 0; -

197 -

198 /* Status flags for what is printed to stderr. */ -

199 static int status_level = STATUS_DEFAULT; -

200 -

201 /* If nonzero, filter characters through the translation table. */ -

202 static bool translation_needed = false; -

203 -

204 /* Number of partial blocks written. */ -

205 static uintmax_t w_partial = 0; -

206 -

207 /* Number of full blocks written. */ -

208 static uintmax_t w_full = 0; -

209 -

210 /* Number of partial blocks read. */ -

211 static uintmax_t r_partial = 0; -

212 -

213 /* Number of full blocks read. */ -

214 static uintmax_t r_full = 0; -

215 -

216 /* Number of bytes written. */ -

217 static uintmax_t w_bytes = 0; -

218 -

219 /* Time that dd started. */ -

220 static xtime_t start_time; -

221 -

222 /* Next time to report periodic progress. */ -

223 static xtime_t next_time; -

224 -

225 /* If positive, the number of bytes output in the current progress line. */ -

226 static int progress_len; -

227 -

228 /* True if input is seekable. */ -

229 static bool input_seekable; -

230 -

231 /* Error number corresponding to initial attempt to lseek input. -

232 If ESPIPE, do not issue any more diagnostics about it. */ -

233 static int input_seek_errno; -

234 -

235 /* File offset of the input, in bytes, along with a flag recording -

236 whether it overflowed. */ -

237 static uintmax_t input_offset; -

238 static bool input_offset_overflow; -

239 -

240 /* True if a partial read should be diagnosed. */ -

241 static bool warn_partial_read; -

242 -

243 /* Records truncated by conv=block. */ -

244 static uintmax_t r_truncate = 0; -

245 -

246 /* Output representation of newline and space characters. -

247 They change if we're converting to EBCDIC. */ -

248 static char newline_character = '\n'; -

249 static char space_character = ' '; -

250 -

251 /* Input buffer. */ -

252 static char *ibuf; -

253 -

254 /* Output buffer. */ -

255 static char *obuf; -

256 -

257 /* Current index into 'obuf'. */ -

258 static size_t oc = 0; -

259 -

260 /* Index into current line, for 'conv=block' and 'conv=unblock'. */ -

261 static size_t col = 0; -

262 -

263 /* The set of signals that are caught. */ -

264 static sigset_t caught_signals; -

265 -

266 /* If nonzero, the value of the pending fatal signal. */ -

267 static sig_atomic_t volatile interrupt_signal; -

268 -

269 /* A count of the number of pending info signals that have been received. */ -

270 static sig_atomic_t volatile info_signal_count; -

271 -

272 /* Whether to discard cache for input or output. */ -

273 static bool i_nocache, o_nocache; -

274 -

275 /* Whether to instruct the kernel to discard the complete file. */ -

276 static bool i_nocache_eof, o_nocache_eof; -

277 -

278 /* Function used for read (to handle iflag=fullblock parameter). */ -

279 static ssize_t (*iread_fnc) (int fd, char *buf, size_t size); -

280 -

281 /* A longest symbol in the struct symbol_values tables below. */ -

282 #define LONGEST_SYMBOL "count_bytes" -

283 -

284 /* A symbol and the corresponding integer value. */ -

285 struct symbol_value -

286 { -

287 char symbol[sizeof LONGEST_SYMBOL]; -

288 int value; -

289 }; -

290 -

291 /* Conversion symbols, for conv="...". */ -

292 static struct symbol_value const conversions[] = -

293 { -

294 {"ascii", C_ASCII | C_UNBLOCK | C_TWOBUFS}, /* EBCDIC to ASCII. */ -

295 {"ebcdic", C_EBCDIC | C_BLOCK | C_TWOBUFS}, /* ASCII to EBCDIC. */ -

296 {"ibm", C_IBM | C_BLOCK | C_TWOBUFS}, /* Different ASCII to EBCDIC. */ -

297 {"block", C_BLOCK | C_TWOBUFS}, /* Variable to fixed length records. */ -

298 {"unblock", C_UNBLOCK | C_TWOBUFS}, /* Fixed to variable length records. */ -

299 {"lcase", C_LCASE | C_TWOBUFS}, /* Translate upper to lower case. */ -

300 {"ucase", C_UCASE | C_TWOBUFS}, /* Translate lower to upper case. */ -

301 {"sparse", C_SPARSE}, /* Try to sparsely write output. */ -

302 {"swab", C_SWAB | C_TWOBUFS}, /* Swap bytes of input. */ -

303 {"noerror", C_NOERROR}, /* Ignore i/o errors. */ -

304 {"nocreat", C_NOCREAT}, /* Do not create output file. */ -

305 {"excl", C_EXCL}, /* Fail if the output file already exists. */ -

306 {"notrunc", C_NOTRUNC}, /* Do not truncate output file. */ -

307 {"sync", C_SYNC}, /* Pad input records to ibs with NULs. */ -

308 {"fdatasync", C_FDATASYNC}, /* Synchronize output data before finishing. */ -

309 {"fsync", C_FSYNC}, /* Also synchronize output metadata. */ -

310 {"", 0} -

311 }; -

312 -

313 #define FFS_MASK(x) ((x) ^ ((x) & ((x) - 1))) -

314 enum -

315 { -

316 /* Compute a value that's bitwise disjoint from the union -

317 of all O_ values. */ -

318 v = ~(0 -

319 | O_APPEND -

320 | O_BINARY -

321 | O_CIO -

322 | O_DIRECT -

323 | O_DIRECTORY -

324 | O_DSYNC -

325 | O_NOATIME -

326 | O_NOCTTY -

327 | O_NOFOLLOW -

328 | O_NOLINKS -

329 | O_NONBLOCK -

330 | O_SYNC -

331 | O_TEXT -

332 ), -

333 -

334 /* Use its lowest bits for private flags. */ -

335 O_FULLBLOCK = FFS_MASK (v), -

336 v2 = v ^ O_FULLBLOCK, -

337 -

338 O_NOCACHE = FFS_MASK (v2), -

339 v3 = v2 ^ O_NOCACHE, -

340 -

341 O_COUNT_BYTES = FFS_MASK (v3), -

342 v4 = v3 ^ O_COUNT_BYTES, -

343 -

344 O_SKIP_BYTES = FFS_MASK (v4), -

345 v5 = v4 ^ O_SKIP_BYTES, -

346 -

347 O_SEEK_BYTES = FFS_MASK (v5) -

348 }; -

349 -

350 /* Ensure that we got something. */ -

351 verify (O_FULLBLOCK != 0); -

352 verify (O_NOCACHE != 0); -

353 verify (O_COUNT_BYTES != 0); -

354 verify (O_SKIP_BYTES != 0); -

355 verify (O_SEEK_BYTES != 0); -

356 -

357 #define MULTIPLE_BITS_SET(i) (((i) & ((i) - 1)) != 0) -

358 -

359 /* Ensure that this is a single-bit value. */ -

360 verify ( ! MULTIPLE_BITS_SET (O_FULLBLOCK)); -

361 verify ( ! MULTIPLE_BITS_SET (O_NOCACHE)); -

362 verify ( ! MULTIPLE_BITS_SET (O_COUNT_BYTES)); -

363 verify ( ! MULTIPLE_BITS_SET (O_SKIP_BYTES)); -

364 verify ( ! MULTIPLE_BITS_SET (O_SEEK_BYTES)); -

365 -

366 /* Flags, for iflag="..." and oflag="...". */ -

367 static struct symbol_value const flags[] = -

368 { -

369 {"append", O_APPEND}, -

370 {"binary", O_BINARY}, -

371 {"cio", O_CIO}, -

372 {"direct", O_DIRECT}, -

373 {"directory", O_DIRECTORY}, -

374 {"dsync", O_DSYNC}, -

375 {"noatime", O_NOATIME}, -

376 {"nocache", O_NOCACHE}, /* Discard cache. */ -

377 {"noctty", O_NOCTTY}, -

378 {"nofollow", HAVE_WORKING_O_NOFOLLOW ? O_NOFOLLOW : 0}, -

379 {"nolinks", O_NOLINKS}, -

380 {"nonblock", O_NONBLOCK}, -

381 {"sync", O_SYNC}, -

382 {"text", O_TEXT}, -

383 {"fullblock", O_FULLBLOCK}, /* Accumulate full blocks from input. */ -

384 {"count_bytes", O_COUNT_BYTES}, -

385 {"skip_bytes", O_SKIP_BYTES}, -

386 {"seek_bytes", O_SEEK_BYTES}, -

387 {"", 0} -

388 }; -

389 -

390 /* Status, for status="...". */ -

391 static struct symbol_value const statuses[] = -

392 { -

393 {"none", STATUS_NONE}, -

394 {"noxfer", STATUS_NOXFER}, -

395 {"progress", STATUS_PROGRESS}, -

396 {"", 0} -

397 }; -

398 -

399 /* Translation table formed by applying successive transformations. */ -

400 static unsigned char trans_table[256]; -

401 -

402 /* Standard translation tables, taken from POSIX 1003.1-2013. -

403 Beware of imitations; there are lots of ASCII<->EBCDIC tables -

404 floating around the net, perhaps valid for some applications but -

405 not correct here. */ -

406 -

407 static char const ascii_to_ebcdic[] = -

408 { -

409 '\000', '\001', '\002', '\003', '\067', '\055', '\056', '\057', -

410 '\026', '\005', '\045', '\013', '\014', '\015', '\016', '\017', -

411 '\020', '\021', '\022', '\023', '\074', '\075', '\062', '\046', -

412 '\030', '\031', '\077', '\047', '\034', '\035', '\036', '\037', -

413 '\100', '\132', '\177', '\173', '\133', '\154', '\120', '\175', -

414 '\115', '\135', '\134', '\116', '\153', '\140', '\113', '\141', -

415 '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367', -

416 '\370', '\371', '\172', '\136', '\114', '\176', '\156', '\157', -

417 '\174', '\301', '\302', '\303', '\304', '\305', '\306', '\307', -

418 '\310', '\311', '\321', '\322', '\323', '\324', '\325', '\326', -

419 '\327', '\330', '\331', '\342', '\343', '\344', '\345', '\346', -

420 '\347', '\350', '\351', '\255', '\340', '\275', '\232', '\155', -

421 '\171', '\201', '\202', '\203', '\204', '\205', '\206', '\207', -

422 '\210', '\211', '\221', '\222', '\223', '\224', '\225', '\226', -

423 '\227', '\230', '\231', '\242', '\243', '\244', '\245', '\246', -

424 '\247', '\250', '\251', '\300', '\117', '\320', '\137', '\007', -

425 '\040', '\041', '\042', '\043', '\044', '\025', '\006', '\027', -

426 '\050', '\051', '\052', '\053', '\054', '\011', '\012', '\033', -

427 '\060', '\061', '\032', '\063', '\064', '\065', '\066', '\010', -

428 '\070', '\071', '\072', '\073', '\004', '\024', '\076', '\341', -

429 '\101', '\102', '\103', '\104', '\105', '\106', '\107', '\110', -

430 '\111', '\121', '\122', '\123', '\124', '\125', '\126', '\127', -

431 '\130', '\131', '\142', '\143', '\144', '\145', '\146', '\147', -

432 '\150', '\151', '\160', '\161', '\162', '\163', '\164', '\165', -

433 '\166', '\167', '\170', '\200', '\212', '\213', '\214', '\215', -

434 '\216', '\217', '\220', '\152', '\233', '\234', '\235', '\236', -

435 '\237', '\240', '\252', '\253', '\254', '\112', '\256', '\257', -

436 '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267', -

437 '\270', '\271', '\272', '\273', '\274', '\241', '\276', '\277', -

438 '\312', '\313', '\314', '\315', '\316', '\317', '\332', '\333', -

439 '\334', '\335', '\336', '\337', '\352', '\353', '\354', '\355', -

440 '\356', '\357', '\372', '\373', '\374', '\375', '\376', '\377' -

441 }; -

442 -

443 static char const ascii_to_ibm[] = -

444 { -

445 '\000', '\001', '\002', '\003', '\067', '\055', '\056', '\057', -

446 '\026', '\005', '\045', '\013', '\014', '\015', '\016', '\017', -

447 '\020', '\021', '\022', '\023', '\074', '\075', '\062', '\046', -

448 '\030', '\031', '\077', '\047', '\034', '\035', '\036', '\037', -

449 '\100', '\132', '\177', '\173', '\133', '\154', '\120', '\175', -

450 '\115', '\135', '\134', '\116', '\153', '\140', '\113', '\141', -

451 '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367', -

452 '\370', '\371', '\172', '\136', '\114', '\176', '\156', '\157', -

453 '\174', '\301', '\302', '\303', '\304', '\305', '\306', '\307', -

454 '\310', '\311', '\321', '\322', '\323', '\324', '\325', '\326', -

455 '\327', '\330', '\331', '\342', '\343', '\344', '\345', '\346', -

456 '\347', '\350', '\351', '\255', '\340', '\275', '\137', '\155', -

457 '\171', '\201', '\202', '\203', '\204', '\205', '\206', '\207', -

458 '\210', '\211', '\221', '\222', '\223', '\224', '\225', '\226', -

459 '\227', '\230', '\231', '\242', '\243', '\244', '\245', '\246', -

460 '\247', '\250', '\251', '\300', '\117', '\320', '\241', '\007', -

461 '\040', '\041', '\042', '\043', '\044', '\025', '\006', '\027', -

462 '\050', '\051', '\052', '\053', '\054', '\011', '\012', '\033', -

463 '\060', '\061', '\032', '\063', '\064', '\065', '\066', '\010', -

464 '\070', '\071', '\072', '\073', '\004', '\024', '\076', '\341', -

465 '\101', '\102', '\103', '\104', '\105', '\106', '\107', '\110', -

466 '\111', '\121', '\122', '\123', '\124', '\125', '\126', '\127', -

467 '\130', '\131', '\142', '\143', '\144', '\145', '\146', '\147', -

468 '\150', '\151', '\160', '\161', '\162', '\163', '\164', '\165', -

469 '\166', '\167', '\170', '\200', '\212', '\213', '\214', '\215', -

470 '\216', '\217', '\220', '\232', '\233', '\234', '\235', '\236', -

471 '\237', '\240', '\252', '\253', '\254', '\255', '\256', '\257', -

472 '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267', -

473 '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277', -

474 '\312', '\313', '\314', '\315', '\316', '\317', '\332', '\333', -

475 '\334', '\335', '\336', '\337', '\352', '\353', '\354', '\355', -

476 '\356', '\357', '\372', '\373', '\374', '\375', '\376', '\377' -

477 }; -

478 -

479 static char const ebcdic_to_ascii[] = -

480 { -

481 '\000', '\001', '\002', '\003', '\234', '\011', '\206', '\177', -

482 '\227', '\215', '\216', '\013', '\014', '\015', '\016', '\017', -

483 '\020', '\021', '\022', '\023', '\235', '\205', '\010', '\207', -

484 '\030', '\031', '\222', '\217', '\034', '\035', '\036', '\037', -

485 '\200', '\201', '\202', '\203', '\204', '\012', '\027', '\033', -

486 '\210', '\211', '\212', '\213', '\214', '\005', '\006', '\007', -

487 '\220', '\221', '\026', '\223', '\224', '\225', '\226', '\004', -

488 '\230', '\231', '\232', '\233', '\024', '\025', '\236', '\032', -

489 '\040', '\240', '\241', '\242', '\243', '\244', '\245', '\246', -

490 '\247', '\250', '\325', '\056', '\074', '\050', '\053', '\174', -

491 '\046', '\251', '\252', '\253', '\254', '\255', '\256', '\257', -

492 '\260', '\261', '\041', '\044', '\052', '\051', '\073', '\176', -

493 '\055', '\057', '\262', '\263', '\264', '\265', '\266', '\267', -

494 '\270', '\271', '\313', '\054', '\045', '\137', '\076', '\077', -

495 '\272', '\273', '\274', '\275', '\276', '\277', '\300', '\301', -

496 '\302', '\140', '\072', '\043', '\100', '\047', '\075', '\042', -

497 '\303', '\141', '\142', '\143', '\144', '\145', '\146', '\147', -

498 '\150', '\151', '\304', '\305', '\306', '\307', '\310', '\311', -

499 '\312', '\152', '\153', '\154', '\155', '\156', '\157', '\160', -

500 '\161', '\162', '\136', '\314', '\315', '\316', '\317', '\320', -

501 '\321', '\345', '\163', '\164', '\165', '\166', '\167', '\170', -

502 '\171', '\172', '\322', '\323', '\324', '\133', '\326', '\327', -

503 '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337', -

504 '\340', '\341', '\342', '\343', '\344', '\135', '\346', '\347', -

505 '\173', '\101', '\102', '\103', '\104', '\105', '\106', '\107', -

506 '\110', '\111', '\350', '\351', '\352', '\353', '\354', '\355', -

507 '\175', '\112', '\113', '\114', '\115', '\116', '\117', '\120', -

508 '\121', '\122', '\356', '\357', '\360', '\361', '\362', '\363', -

509 '\134', '\237', '\123', '\124', '\125', '\126', '\127', '\130', -

510 '\131', '\132', '\364', '\365', '\366', '\367', '\370', '\371', -

511 '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067', -

512 '\070', '\071', '\372', '\373', '\374', '\375', '\376', '\377' -

513 }; -

514 -

515 /* True if we need to close the standard output *stream*. */ -

516 static bool close_stdout_required = true; -

517 -

518 /* The only reason to close the standard output *stream* is if -

519 parse_long_options fails (as it does for --help or --version). -

520 In any other case, dd uses only the STDOUT_FILENO file descriptor, -

521 and the "cleanup" function calls "close (STDOUT_FILENO)". -

522 Closing the file descriptor and then letting the usual atexit-run -

523 close_stdout function call "fclose (stdout)" would result in a -

524 harmless failure of the close syscall (with errno EBADF). -

525 This function serves solely to avoid the unnecessary close_stdout -

526 call, once parse_long_options has succeeded. -

527 Meanwhile, we guarantee that the standard error stream is flushed, -

528 by inlining the last half of close_stdout as needed. */ -

529 static void -

530 maybe_close_stdout (void) -

531 { -

532

if (close_stdout_required)

close_stdout_required	Description
TRUE	evaluated 25 times by 1 test Evaluated by: dd
FALSE	evaluated 633 times by 1 test Evaluated by: dd

25-633

533

close_stdout ();

executed 25 times by 1 test: close_stdout ();

Executed by:

534

else if (close_stream (stderr) != 0)

close_stream ( stderr ) != 0	Description
TRUE	never evaluated
FALSE	evaluated 633 times by 1 test Evaluated by: dd

0-633

535

_exit (EXIT_FAILURE);

never executed: _exit ( 1 );

536

}

executed 658 times by 1 test: end of block

Executed by:

658

537 -

538 /* Like error() but handle any pending newline. */ -

539 -

540 static void _GL_ATTRIBUTE_FORMAT ((__printf__, 3, 4)) -

541 nl_error (int status, int errnum, const char *fmt, ...) -

542 { -

543

if (0 < progress_len)

0 < progress_len	Description
TRUE	never evaluated
FALSE	evaluated 20 times by 1 test Evaluated by: dd

0-20

544 { -

545 fputc ('\n', stderr); -

546 progress_len = 0; -

547

}

never executed: end of block

548 -

549 va_list ap; -

550 va_start (ap, fmt); -

551 verror (status, errnum, fmt, ap); -

552 va_end (ap); -

553

}

executed 13 times by 1 test: end of block

Executed by:

554 -

555 #define error nl_error -

556 -

557 void -

558 usage (int status) -

559 { -

560

if (status != EXIT_SUCCESS)

status != 0	Description
TRUE	evaluated 4 times by 1 test Evaluated by: dd
FALSE	evaluated 4 times by 1 test Evaluated by: dd

561

emit_try_help ();

executed 4 times by 1 test: end of block

Executed by:

562 else -

563 { -

564 printf (_("\ -

565 Usage: %s [OPERAND]...\n\ -

566 or: %s OPTION\n\ -

567 "), -

568 program_name, program_name); -

569 fputs (_("\ -

570 Copy a file, converting and formatting according to the operands.\n\ -

571 \n\ -

572 bs=BYTES read and write up to BYTES bytes at a time (default: 512);\n\ -

573 overrides ibs and obs\n\ -

574 cbs=BYTES convert BYTES bytes at a time\n\ -

575 conv=CONVS convert the file as per the comma separated symbol list\n\ -

576 count=N copy only N input blocks\n\ -

577 ibs=BYTES read up to BYTES bytes at a time (default: 512)\n\ -

578 "), stdout); -

579 fputs (_("\ -

580 if=FILE read from FILE instead of stdin\n\ -

581 iflag=FLAGS read as per the comma separated symbol list\n\ -

582 obs=BYTES write BYTES bytes at a time (default: 512)\n\ -

583 of=FILE write to FILE instead of stdout\n\ -

584 oflag=FLAGS write as per the comma separated symbol list\n\ -

585 seek=N skip N obs-sized blocks at start of output\n\ -

586 skip=N skip N ibs-sized blocks at start of input\n\ -

587 status=LEVEL The LEVEL of information to print to stderr;\n\ -

588 'none' suppresses everything but error messages,\n\ -

589 'noxfer' suppresses the final transfer statistics,\n\ -

590 'progress' shows periodic transfer statistics\n\ -

591 "), stdout); -

592 fputs (_("\ -

593 \n\ -

594 N and BYTES may be followed by the following multiplicative suffixes:\n\ -

595 c =1, w =2, b =512, kB =1000, K =1024, MB =1000*1000, M =1024*1024, xM =M,\n\ -

596 GB =1000*1000*1000, G =1024*1024*1024, and so on for T, P, E, Z, Y.\n\ -

597 \n\ -

598 Each CONV symbol may be:\n\ -

599 \n\ -

600 "), stdout); -

601 fputs (_("\ -

602 ascii from EBCDIC to ASCII\n\ -

603 ebcdic from ASCII to EBCDIC\n\ -

604 ibm from ASCII to alternate EBCDIC\n\ -

605 block pad newline-terminated records with spaces to cbs-size\n\ -

606 unblock replace trailing spaces in cbs-size records with newline\n\ -

607 lcase change upper case to lower case\n\ -

608 ucase change lower case to upper case\n\ -

609 sparse try to seek rather than write the output for NUL input blocks\n\ -

610 swab swap every pair of input bytes\n\ -

611 sync pad every input block with NULs to ibs-size; when used\n\ -

612 with block or unblock, pad with spaces rather than NULs\n\ -

613 "), stdout); -

614 fputs (_("\ -

615 excl fail if the output file already exists\n\ -

616 nocreat do not create the output file\n\ -

617 notrunc do not truncate the output file\n\ -

618 noerror continue after read errors\n\ -

619 fdatasync physically write output file data before finishing\n\ -

620 fsync likewise, but also write metadata\n\ -

621 "), stdout); -

622 fputs (_("\ -

623 \n\ -

624 Each FLAG symbol may be:\n\ -

625 \n\ -

626 append append mode (makes sense only for output; conv=notrunc suggested)\n\ -

627 "), stdout); -

628

if (O_CIO)

dead code: fputs_unlocked ( dcgettext (((void *)0), " cio use concurrent I/O for data\n" , 5) , stdout );

629

fputs (_(" cio use concurrent I/O for data\n"), stdout);

dead code: fputs_unlocked ( dcgettext (((void *)0), " cio use concurrent I/O for data\n" , 5) , stdout );

630 if (O_DIRECT) -

631

fputs (_(" direct use direct I/O for data\n"), stdout);

executed 4 times by 1 test: fputs_unlocked ( dcgettext (((void *)0), " direct use direct I/O for data\n" , 5) , stdout );

Executed by:

632 if (O_DIRECTORY) -

633

fputs (_(" directory fail unless a directory\n"), stdout);

executed 4 times by 1 test: fputs_unlocked ( dcgettext (((void *)0), " directory fail unless a directory\n" , 5) , stdout );

Executed by:

634 if (O_DSYNC) -

635

fputs (_(" dsync use synchronized I/O for data\n"), stdout);

executed 4 times by 1 test: fputs_unlocked ( dcgettext (((void *)0), " dsync use synchronized I/O for data\n" , 5) , stdout );

Executed by:

636 if (O_SYNC) -

637

fputs (_(" sync likewise, but also for metadata\n"), stdout);

executed 4 times by 1 test: fputs_unlocked ( dcgettext (((void *)0), " sync likewise, but also for metadata\n" , 5) , stdout );

Executed by:

638 fputs (_(" fullblock accumulate full blocks of input (iflag only)\n"), -

639 stdout); -

640 if (O_NONBLOCK) -

641

fputs (_(" nonblock use non-blocking I/O\n"), stdout);

executed 4 times by 1 test: fputs_unlocked ( dcgettext (((void *)0), " nonblock use non-blocking I/O\n" , 5) , stdout );

Executed by:

642 if (O_NOATIME) -

643

fputs (_(" noatime do not update access time\n"), stdout);

executed 4 times by 1 test: fputs_unlocked ( dcgettext (((void *)0), " noatime do not update access time\n" , 5) , stdout );

Executed by:

644 #if HAVE_POSIX_FADVISE -

645

if (O_NOCACHE)

O_NOCACHE	Description
TRUE	evaluated 4 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-4

646

fputs (_(" nocache Request to drop cache. See also oflag=sync\n"),

executed 4 times by 1 test: fputs_unlocked ( dcgettext (((void *)0), " nocache Request to drop cache. See also oflag=sync\n" , 5) , stdout ) ;

Executed by:

647

stdout);

executed 4 times by 1 test: fputs_unlocked ( dcgettext (((void *)0), " nocache Request to drop cache. See also oflag=sync\n" , 5) , stdout ) ;

Executed by:

648 #endif -

649 if (O_NOCTTY) -

650

fputs (_(" noctty do not assign controlling terminal from file\n"),

executed 4 times by 1 test: fputs_unlocked ( dcgettext (((void *)0), " noctty do not assign controlling terminal from file\n" , 5) , stdout ) ;

Executed by:

651

stdout);

executed 4 times by 1 test: fputs_unlocked ( dcgettext (((void *)0), " noctty do not assign controlling terminal from file\n" , 5) , stdout ) ;

Executed by:

652 if (HAVE_WORKING_O_NOFOLLOW) -

653

fputs (_(" nofollow do not follow symlinks\n"), stdout);

executed 4 times by 1 test: fputs_unlocked ( dcgettext (((void *)0), " nofollow do not follow symlinks\n" , 5) , stdout );

Executed by:

654

if (O_NOLINKS)

dead code: fputs_unlocked ( dcgettext (((void *)0), " nolinks fail if multiply-linked\n" , 5) , stdout );

655

fputs (_(" nolinks fail if multiply-linked\n"), stdout);

dead code: fputs_unlocked ( dcgettext (((void *)0), " nolinks fail if multiply-linked\n" , 5) , stdout );

656

if (O_BINARY)

dead code: fputs_unlocked ( dcgettext (((void *)0), " binary use binary I/O for data\n" , 5) , stdout );

657

fputs (_(" binary use binary I/O for data\n"), stdout);

dead code: fputs_unlocked ( dcgettext (((void *)0), " binary use binary I/O for data\n" , 5) , stdout );

658

if (O_TEXT)

dead code: fputs_unlocked ( dcgettext (((void *)0), " text use text I/O for data\n" , 5) , stdout );

659

fputs (_(" text use text I/O for data\n"), stdout);

dead code: fputs_unlocked ( dcgettext (((void *)0), " text use text I/O for data\n" , 5) , stdout );

660

if (O_COUNT_BYTES)

O_COUNT_BYTES	Description
TRUE	evaluated 4 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-4

661

fputs (_(" count_bytes treat 'count=N' as a byte count (iflag only)\n\

executed 4 times by 1 test: fputs_unlocked ( dcgettext (((void *)0), " count_bytes treat 'count=N' as a byte count (iflag only)\n" , 5) , stdout ) ;

Executed by:

662

executed 4 times by 1 test: fputs_unlocked ( dcgettext (((void *)0), " count_bytes treat 'count=N' as a byte count (iflag only)\n" , 5) , stdout ) ;

Executed by:

), stdout);

executed 4 times by 1 test: fputs_unlocked ( dcgettext (((void *)0), " count_bytes treat 'count=N' as a byte count (iflag only)\n" , 5) , stdout ) ;

Executed by:

663

if (O_SKIP_BYTES)

O_SKIP_BYTES	Description
TRUE	evaluated 4 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-4

664

fputs (_(" skip_bytes treat 'skip=N' as a byte count (iflag only)\n\

executed 4 times by 1 test: fputs_unlocked ( dcgettext (((void *)0), " skip_bytes treat 'skip=N' as a byte count (iflag only)\n" , 5) , stdout ) ;

Executed by:

665

executed 4 times by 1 test: fputs_unlocked ( dcgettext (((void *)0), " skip_bytes treat 'skip=N' as a byte count (iflag only)\n" , 5) , stdout ) ;

Executed by:

), stdout);

executed 4 times by 1 test: fputs_unlocked ( dcgettext (((void *)0), " skip_bytes treat 'skip=N' as a byte count (iflag only)\n" , 5) , stdout ) ;

Executed by:

666

if (O_SEEK_BYTES)

O_SEEK_BYTES	Description
TRUE	evaluated 4 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-4

667

fputs (_(" seek_bytes treat 'seek=N' as a byte count (oflag only)\n\

executed 4 times by 1 test: fputs_unlocked ( dcgettext (((void *)0), " seek_bytes treat 'seek=N' as a byte count (oflag only)\n" , 5) , stdout ) ;

Executed by:

668

executed 4 times by 1 test: fputs_unlocked ( dcgettext (((void *)0), " seek_bytes treat 'seek=N' as a byte count (oflag only)\n" , 5) , stdout ) ;

Executed by:

), stdout);

executed 4 times by 1 test: fputs_unlocked ( dcgettext (((void *)0), " seek_bytes treat 'seek=N' as a byte count (oflag only)\n" , 5) , stdout ) ;

Executed by:

669 -

670 { -

671 printf (_("\ -

672 \n\ -

673 Sending a %s signal to a running 'dd' process makes it\n\ -

674 print I/O statistics to standard error and then resume copying.\n\ -

675 \n\ -

676 Options are:\n\ -

677 \n\ -

678 "), SIGINFO == SIGUSR1 ? "USR1" : "INFO"); -

679 } -

680 -

681 fputs (HELP_OPTION_DESCRIPTION, stdout); -

682 fputs (VERSION_OPTION_DESCRIPTION, stdout); -

683 emit_ancillary_info (PROGRAM_NAME); -

684

}

executed 4 times by 1 test: end of block

Executed by:

685

exit (status);

executed 8 times by 1 test: exit (status);

Executed by:

686 } -

687 -

688 /* Common options to use when displaying sizes and rates. */ -

689 -

690 enum { human_opts = (human_autoscale | human_round_to_nearest -

691 | human_space_before_unit | human_SI | human_B) }; -

692 -

693 /* Ensure input buffer IBUF is allocated. */ -

694 -

695 static void -

696 alloc_ibuf (void) -

697 { -

698

if (ibuf)

ibuf	Description
TRUE	evaluated 531 times by 1 test Evaluated by: dd
FALSE	evaluated 600 times by 1 test Evaluated by: dd

531-600

699

return;

executed 531 times by 1 test: return;

Executed by:

531

700 -

701 char *real_buf = malloc (input_blocksize + INPUT_BLOCK_SLOP); -

702

if (!real_buf)

!real_buf	Description
TRUE	evaluated 3 times by 1 test Evaluated by: dd
FALSE	evaluated 597 times by 1 test Evaluated by: dd

3-597

703 { -

704 uintmax_t ibs = input_blocksize; -

705 char hbuf[LONGEST_HUMAN_READABLE + 1]; -

706 die (EXIT_FAILURE, 0, -

707 _("memory exhausted by input buffer of size %"PRIuMAX" bytes (%s)"), -

708 ibs, -

709 human_readable (input_blocksize, hbuf, -

710 human_opts | human_base_1024, 1, 1)); -

711

}

never executed: end of block

712 -

713 real_buf += SWAB_ALIGN_OFFSET; /* allow space for swab */ -

714 -

715 ibuf = ptr_align (real_buf, page_size); -

716

}

executed 597 times by 1 test: end of block

Executed by:

597

717 -

718 /* Ensure output buffer OBUF is allocated/initialized. */ -

719 -

720 static void -

721 alloc_obuf (void) -

722 { -

723

if (obuf)

obuf	Description
TRUE	never evaluated
FALSE	evaluated 597 times by 1 test Evaluated by: dd

0-597

724

return;

never executed: return;

725 -

726

if (conversions_mask & C_TWOBUFS)

conversions_mask & C_TWOBUFS	Description
TRUE	evaluated 67 times by 1 test Evaluated by: dd
FALSE	evaluated 530 times by 1 test Evaluated by: dd

67-530

727 { -

728 /* Page-align the output buffer, too. */ -

729 char *real_obuf = malloc (output_blocksize + OUTPUT_BLOCK_SLOP); -

730

if (!real_obuf)

!real_obuf	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	evaluated 66 times by 1 test Evaluated by: dd

1-66

731 { -

732 uintmax_t obs = output_blocksize; -

733 char hbuf[LONGEST_HUMAN_READABLE + 1]; -

734 die (EXIT_FAILURE, 0, -

735 _("memory exhausted by output buffer of size %"PRIuMAX -

736 " bytes (%s)"), -

737 obs, -

738 human_readable (output_blocksize, hbuf, -

739 human_opts | human_base_1024, 1, 1)); -

740

}

never executed: end of block

741 obuf = ptr_align (real_obuf, page_size); -

742

}

executed 66 times by 1 test: end of block

Executed by:

743 else -

744 { -

745 alloc_ibuf (); -

746 obuf = ibuf; -

747

}

executed 529 times by 1 test: end of block

Executed by:

529

748 } -

749 -

750 static void -

751 translate_charset (char const *new_trans) -

752 { -

753

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

i < 256	Description
TRUE	evaluated 256 times by 1 test Evaluated by: dd
FALSE	evaluated 1 time by 1 test Evaluated by: dd

1-256

754

trans_table[i] = new_trans[trans_table[i]];

executed 256 times by 1 test: trans_table[i] = new_trans[trans_table[i]];

Executed by:

256

755 translation_needed = true; -

756

}

executed 1 time by 1 test: end of block

Executed by:

757 -

758 /* Return true if I has more than one bit set. I must be nonnegative. */ -

759 -

760 static inline bool -

761 multiple_bits_set (int i) -

762 { -

763

return MULTIPLE_BITS_SET (i);

executed 3773 times by 1 test: return (((i) & ((i) - 1)) != 0);

Executed by:

3773

764 } -

765 -

766 static bool -

767 abbreviation_lacks_prefix (char const *message) -

768 { -

769

return message[strlen (message) - 2] == ' ';

executed 233 times by 1 test: return message[strlen (message) - 2] == ' ';

Executed by:

233

770 } -

771 -

772 /* Print transfer statistics. */ -

773 -

774 static void -

775 print_xfer_stats (xtime_t progress_time) -

776 { -

777

xtime_t now = progress_time ? progress_time : gethrxtime ();

progress_time	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	evaluated 149 times by 1 test Evaluated by: dd

1-149

778 static char const slash_s[] = "/s"; -

779 char hbuf[3][LONGEST_HUMAN_READABLE + sizeof slash_s]; -

780 double delta_s; -

781 char const *bytes_per_second; -

782 char const *si = human_readable (w_bytes, hbuf[0], human_opts, 1, 1); -

783 char const *iec = human_readable (w_bytes, hbuf[1], -

784 human_opts | human_base_1024, 1, 1); -

785 -

786 /* Use integer arithmetic to compute the transfer rate, -

787 since that makes it easy to use SI abbreviations. */ -

788 char *bpsbuf = hbuf[2]; -

789 int bpsbufsize = sizeof hbuf[2]; -

790

if (start_time < now)

start_time < now	Description
TRUE	evaluated 150 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-150

791 { -

792 double XTIME_PRECISIONe0 = XTIME_PRECISION; -

793 uintmax_t delta_xtime = now; -

794 delta_xtime -= start_time; -

795 delta_s = delta_xtime / XTIME_PRECISIONe0; -

796 bytes_per_second = human_readable (w_bytes, bpsbuf, human_opts, -

797 XTIME_PRECISION, delta_xtime); -

798 strcat (bytes_per_second - bpsbuf + bpsbuf, slash_s); -

799

}

executed 150 times by 1 test: end of block

Executed by:

150

800 else -

801 { -

802 delta_s = 0; -

803 snprintf (bpsbuf, bpsbufsize, "%s B/s", _("Infinity")); -

804 bytes_per_second = bpsbuf; -

805

}

never executed: end of block

806 -

807

if (progress_time)

progress_time	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	evaluated 149 times by 1 test Evaluated by: dd

1-149

808

fputc ('\r', stderr);

executed 1 time by 1 test: fputc_unlocked ('\r', stderr );

Executed by:

809 -

810 /* Use full seconds when printing progress, since the progress -

811 report is output once per second and there is little point -

812 displaying any subsecond jitter. Use default precision with %g -

813 otherwise, as this provides more-useful output then. With long -

814 transfers %g can generate a number with an exponent; that is OK. */ -

815 char delta_s_buf[24]; -

816 snprintf (delta_s_buf, sizeof delta_s_buf, -

817 progress_time ? "%.0f s" : "%g s", delta_s); -

818 -

819 int stats_len -

820

= (abbreviation_lacks_prefix (si)

abbreviation_lacks_prefix (si)	Description
TRUE	evaluated 67 times by 1 test Evaluated by: dd
FALSE	evaluated 83 times by 1 test Evaluated by: dd

67-83

821 ? fprintf (stderr, -

822 ngettext ("%"PRIuMAX" byte copied, %s, %s", -

823 "%"PRIuMAX" bytes copied, %s, %s", -

824 select_plural (w_bytes)), -

825 w_bytes, delta_s_buf, bytes_per_second) -

826

: abbreviation_lacks_prefix (iec)

abbreviation_l...s_prefix (iec)	Description
TRUE	never evaluated
FALSE	evaluated 83 times by 1 test Evaluated by: dd

0-83

827 ? fprintf (stderr, -

828 _("%"PRIuMAX" bytes (%s) copied, %s, %s"), -

829 w_bytes, si, delta_s_buf, bytes_per_second) -

830 : fprintf (stderr, -

831 _("%"PRIuMAX" bytes (%s, %s) copied, %s, %s"), -

832 w_bytes, si, iec, delta_s_buf, bytes_per_second)); -

833 -

834

if (progress_time)

progress_time	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	evaluated 149 times by 1 test Evaluated by: dd

1-149

835 { -

836 /* Erase any trailing junk on the output line by outputting -

837 spaces. In theory this could glitch the display because the -

838 formatted translation of a line describing a larger file -

839 could consume fewer screen columns than the strlen difference -

840 from the previously formatted translation. In practice this -

841 does not seem to be a problem. */ -

842

if (0 <= stats_len && stats_len < progress_len)

0 <= stats_len	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	never evaluated

stats_len < progress_len	Description
TRUE	never evaluated
FALSE	evaluated 1 time by 1 test Evaluated by: dd

0-1

843

fprintf (stderr, "%*s", progress_len - stats_len, "");

never executed: fprintf ( stderr , "%*s", progress_len - stats_len, "");

844 progress_len = stats_len; -

845

}

executed 1 time by 1 test: end of block

Executed by:

846 else -

847

fputc ('\n', stderr);

executed 149 times by 1 test: fputc_unlocked ('\n', stderr );

Executed by:

149

848 } -

849 -

850 static void -

851 print_stats (void) -

852 { -

853

if (status_level == STATUS_NONE)

status_level == STATUS_NONE	Description
TRUE	evaluated 505 times by 1 test Evaluated by: dd
FALSE	evaluated 174 times by 1 test Evaluated by: dd

174-505

854

return;

executed 505 times by 1 test: return;

Executed by:

505

855 -

856

if (0 < progress_len)

0 < progress_len	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	evaluated 173 times by 1 test Evaluated by: dd

1-173

857 { -

858 fputc ('\n', stderr); -

859 progress_len = 0; -

860

}

executed 1 time by 1 test: end of block

Executed by:

861 -

862 fprintf (stderr, -

863 _("%"PRIuMAX"+%"PRIuMAX" records in\n" -

864 "%"PRIuMAX"+%"PRIuMAX" records out\n"), -

865 r_full, r_partial, w_full, w_partial); -

866 -

867

if (r_truncate != 0)

r_truncate != 0	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	evaluated 173 times by 1 test Evaluated by: dd

1-173

868

fprintf (stderr,

executed 1 time by 1 test:

fprintf ( stderr , dcngettext (((void *)0), "%" "l" "u" " truncated record\n" , "%" "l" "u" " truncated records\n" , select_plural (r_truncate) , 5) , r_truncate);

Executed by:

869

ngettext ("%"PRIuMAX" truncated record\n",

executed 1 time by 1 test:

fprintf ( stderr , dcngettext (((void *)0), "%" "l" "u" " truncated record\n" , "%" "l" "u" " truncated records\n" , select_plural (r_truncate) , 5) , r_truncate);

Executed by:

870

"%"PRIuMAX" truncated records\n",

executed 1 time by 1 test:

fprintf ( stderr , dcngettext (((void *)0), "%" "l" "u" " truncated record\n" , "%" "l" "u" " truncated records\n" , select_plural (r_truncate) , 5) , r_truncate);

Executed by:

871

select_plural (r_truncate)),

executed 1 time by 1 test:

fprintf ( stderr , dcngettext (((void *)0), "%" "l" "u" " truncated record\n" , "%" "l" "u" " truncated records\n" , select_plural (r_truncate) , 5) , r_truncate);

Executed by:

872

r_truncate);

executed 1 time by 1 test:

fprintf ( stderr , dcngettext (((void *)0), "%" "l" "u" " truncated record\n" , "%" "l" "u" " truncated records\n" , select_plural (r_truncate) , 5) , r_truncate);

Executed by:

873 -

874

if (status_level == STATUS_NOXFER)

status_level == STATUS_NOXFER	Description
TRUE	evaluated 25 times by 1 test Evaluated by: dd
FALSE	evaluated 149 times by 1 test Evaluated by: dd

25-149

875

return;

executed 25 times by 1 test: return;

Executed by:

876 -

877 print_xfer_stats (0); -

878

}

executed 149 times by 1 test: end of block

Executed by:

149

879 -

880 /* An ordinary signal was received; arrange for the program to exit. */ -

881 -

882 static void -

883 interrupt_handler (int sig) -

884 { -

885

if (! SA_RESETHAND)

! 0x80000000	Description
TRUE	never evaluated
FALSE	never evaluated

dead code: signal (sig, ((__sighandler_t) 0) );

886

signal (sig, SIG_DFL);

dead code: signal (sig, ((__sighandler_t) 0) );

887 interrupt_signal = sig; -

888

}

never executed: end of block

889 -

890 /* An info signal was received; arrange for the program to print status. */ -

891 -

892 static void -

893 siginfo_handler (int sig) -

894 { -

895

if (! SA_NOCLDSTOP)

! 1	Description
TRUE	never evaluated
FALSE	evaluated 59 times by 1 test Evaluated by: dd

dead code: signal (sig, siginfo_handler);

896

signal (sig, siginfo_handler);

dead code: signal (sig, siginfo_handler);

897 info_signal_count++; -

898

}

executed 59 times by 1 test: end of block

Executed by:

899 -

900 /* Install the signal handlers. */ -

901 -

902 static void -

903 install_signal_handlers (void) -

904 { -

905

bool catch_siginfo = ! (SIGINFO == SIGUSR1 && getenv ("POSIXLY_CORRECT"));

10 == 10	Description
TRUE	evaluated 658 times by 1 test Evaluated by: dd
FALSE	never evaluated

getenv ("POSIXLY_CORRECT")	Description
TRUE	never evaluated
FALSE	evaluated 658 times by 1 test Evaluated by: dd

0-658

906 -

907 #if SA_NOCLDSTOP -

908 -

909 struct sigaction act; -

910 sigemptyset (&caught_signals); -

911

if (catch_siginfo)

catch_siginfo	Description
TRUE	evaluated 658 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-658

912

sigaddset (&caught_signals, SIGINFO);

executed 658 times by 1 test: sigaddset (&caught_signals, 10 );

Executed by:

658

913 sigaction (SIGINT, NULL, &act); -

914

if (act.sa_handler != SIG_IGN)

act. __sigacti...ghandler_t) 1)	Description
TRUE	evaluated 658 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-658

915

sigaddset (&caught_signals, SIGINT);

executed 658 times by 1 test: sigaddset (&caught_signals, 2 );

Executed by:

658

916 act.sa_mask = caught_signals; -

917 -

918

if (sigismember (&caught_signals, SIGINFO))

sigismember (&..._signals, 10 )	Description
TRUE	evaluated 658 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-658

919 { -

920 act.sa_handler = siginfo_handler; -

921 /* Note we don't use SA_RESTART here and instead -

922 handle EINTR explicitly in iftruncate() etc. -

923 to avoid blocking on noncommitted read()/write() calls. */ -

924 act.sa_flags = 0; -

925 sigaction (SIGINFO, &act, NULL); -

926

}

executed 658 times by 1 test: end of block

Executed by:

658

927 -

928

if (sigismember (&caught_signals, SIGINT))

sigismember (&...t_signals, 2 )	Description
TRUE	evaluated 658 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-658

929 { -

930 act.sa_handler = interrupt_handler; -

931 act.sa_flags = SA_NODEFER | SA_RESETHAND; -

932 sigaction (SIGINT, &act, NULL); -

933

}

executed 658 times by 1 test: end of block

Executed by:

658

934 -

935 #else -

936 -

937 if (catch_siginfo) -

938 { -

939 signal (SIGINFO, siginfo_handler); -

940 siginterrupt (SIGINFO, 1); -

941 } -

942 if (signal (SIGINT, SIG_IGN) != SIG_IGN) -

943 { -

944 signal (SIGINT, interrupt_handler); -

945 siginterrupt (SIGINT, 1); -

946 } -

947 #endif -

948

}

executed 658 times by 1 test: end of block

Executed by:

658

949 -

950 static void -

951 cleanup (void) -

952 { -

953

if (close (STDIN_FILENO) < 0)

close ( 0 ) < 0	Description
TRUE	never evaluated
FALSE	evaluated 622 times by 1 test Evaluated by: dd

0-622

954

die (EXIT_FAILURE, errno, _("closing input file %s"), quoteaf (input_file));

never executed:

((!!sizeof (struct { _Static_assert ( 1 , "verify_expr (" "1" ", " "(error (1, (*__errno_location ()), dcgettext (((void *)0), \"closing input file %s\", 5), quotearg_style (shell_escape_always_quoting_style, input_file)), assume (false))" ")"); int _gl_d... ? (void) 0 : __builtin_unreachable ()))) : ((nl_error ( 1 , (*__errno_location ()) , dcgettext (((void *)0), "closing input file %s" , 5) , quotearg_style (shell_escape_always_quoting_style, input_file)), (( 0 ) ? (void) 0 : __builtin_unreachable ()))));

955 -

956 /* Don't remove this call to close, even though close_stdout -

957 closes standard output. This close is necessary when cleanup -

958 is called as part of a signal handler. */ -

959

if (close (STDOUT_FILENO) < 0)

close ( 1 ) < 0	Description
TRUE	never evaluated
FALSE	evaluated 622 times by 1 test Evaluated by: dd

0-622

960

die (EXIT_FAILURE, errno,

never executed:

((!!sizeof (struct { _Static_assert ( 1 , "verify_expr (" "1" ", " "(error (1, (*__errno_location ()), dcgettext (((void *)0), \"closing output file %s\", 5), quotearg_style (shell_escape_always_quoting_style, output_file)), assume (false))" ")"); int _gl...(void) 0 : __builtin_unreachable ()))) : ((nl_error ( 1 , (*__errno_location ()) , dcgettext (((void *)0), "closing output file %s" , 5) , quotearg_style (shell_escape_always_quoting_style, output_file)), (( 0 ) ? (void) 0 : __builtin_unreachable ())))) ;

961

_("closing output file %s"), quoteaf (output_file));

never executed:

((!!sizeof (struct { _Static_assert ( 1 , "verify_expr (" "1" ", " "(error (1, (*__errno_location ()), dcgettext (((void *)0), \"closing output file %s\", 5), quotearg_style (shell_escape_always_quoting_style, output_file)), assume (false))" ")"); int _gl...(void) 0 : __builtin_unreachable ()))) : ((nl_error ( 1 , (*__errno_location ()) , dcgettext (((void *)0), "closing output file %s" , 5) , quotearg_style (shell_escape_always_quoting_style, output_file)), (( 0 ) ? (void) 0 : __builtin_unreachable ())))) ;

962

}

executed 622 times by 1 test: end of block

Executed by:

622

963 -

964 /* Process any pending signals. If signals are caught, this function -

965 should be called periodically. Ideally there should never be an -

966 unbounded amount of time when signals are not being processed. */ -

967 -

968 static void -

969 process_signals (void) -

970 { -

971

while (interrupt_signal || info_signal_count)

interrupt_signal	Description
TRUE	never evaluated
FALSE	evaluated 7843 times by 1 test Evaluated by: dd

info_signal_count	Description
TRUE	evaluated 57 times by 1 test Evaluated by: dd
FALSE	evaluated 7786 times by 1 test Evaluated by: dd

0-7843

972 { -

973 int interrupt; -

974 int infos; -

975 sigset_t oldset; -

976 -

977 sigprocmask (SIG_BLOCK, &caught_signals, &oldset); -

978 -

979 /* Reload interrupt_signal and info_signal_count, in case a new -

980 signal was handled before sigprocmask took effect. */ -

981 interrupt = interrupt_signal; -

982 infos = info_signal_count; -

983 -

984

if (infos)

infos	Description
TRUE	evaluated 57 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-57

985

info_signal_count = infos - 1;

executed 57 times by 1 test: info_signal_count = infos - 1;

Executed by:

986 -

987 sigprocmask (SIG_SETMASK, &oldset, NULL); -

988 -

989

if (interrupt)

interrupt	Description
TRUE	never evaluated
FALSE	evaluated 57 times by 1 test Evaluated by: dd

0-57

990

cleanup ();

never executed: cleanup ();

991 print_stats (); -

992

if (interrupt)

interrupt	Description
TRUE	never evaluated
FALSE	evaluated 57 times by 1 test Evaluated by: dd

0-57

993

raise (interrupt);

never executed: raise (interrupt);

994

}

executed 57 times by 1 test: end of block

Executed by:

995

}

executed 7786 times by 1 test: end of block

Executed by:

7786

996 -

997 static void -

998 finish_up (void) -

999 { -

1000 cleanup (); -

1001 print_stats (); -

1002 process_signals (); -

1003

}

executed 622 times by 1 test: end of block

Executed by:

622

1004 -

1005 static void ATTRIBUTE_NORETURN -

1006 quit (int code) -

1007 { -

1008 finish_up (); -

1009

exit (code);

executed 2 times by 1 test: exit (code);

Executed by:

1010 } -

1011 -

1012 /* Return LEN rounded down to a multiple of IO_BUFSIZE -

1013 (to minimize calls to the expensive posix_fadvise(,POSIX_FADV_DONTNEED), -

1014 while storing the remainder internally per FD. -

1015 Pass LEN == 0 to get the current remainder. */ -

1016 -

1017 static off_t -

1018 cache_round (int fd, off_t len) -

1019 { -

1020 static off_t i_pending, o_pending; -

1021

off_t *pending = (fd == STDIN_FILENO ? &i_pending : &o_pending);

fd == 0	Description
TRUE	evaluated 432 times by 1 test Evaluated by: dd
FALSE	evaluated 123 times by 1 test Evaluated by: dd

123-432

1022 -

1023

if (len)

len	Description
TRUE	evaluated 519 times by 1 test Evaluated by: dd
FALSE	evaluated 36 times by 1 test Evaluated by: dd

36-519

1024 { -

1025 uintmax_t c_pending = *pending + len; -

1026 *pending = c_pending % IO_BUFSIZE; -

1027

if (c_pending > *pending)

c_pending > *pending	Description
TRUE	evaluated 10 times by 1 test Evaluated by: dd
FALSE	evaluated 509 times by 1 test Evaluated by: dd

10-509

1028

len = c_pending - *pending;

executed 10 times by 1 test: len = c_pending - *pending;

Executed by:

1029 else -

1030

len = 0;

executed 509 times by 1 test: len = 0;

Executed by:

509

1031 } -

1032 else -

1033

len = *pending;

executed 36 times by 1 test: len = *pending;

Executed by:

1034 -

1035

return len;

executed 555 times by 1 test: return len;

Executed by:

555

1036 } -

1037 -

1038 /* Discard the cache from the current offset of either -

1039 STDIN_FILENO or STDOUT_FILENO. -

1040 Return true on success. */ -

1041 -

1042 static bool -

1043 invalidate_cache (int fd, off_t len) -

1044 { -

1045 int adv_ret = -1; -

1046 off_t offset; -

1047

bool nocache_eof = (fd == STDIN_FILENO ? i_nocache_eof : o_nocache_eof);

fd == 0	Description
TRUE	evaluated 426 times by 1 test Evaluated by: dd
FALSE	evaluated 119 times by 1 test Evaluated by: dd

119-426

1048 -

1049 /* Minimize syscalls. */ -

1050 off_t clen = cache_round (fd, len); -

1051

if (len && !clen)

len	Description
TRUE	evaluated 519 times by 1 test Evaluated by: dd
FALSE	evaluated 26 times by 1 test Evaluated by: dd

!clen	Description
TRUE	evaluated 509 times by 1 test Evaluated by: dd
FALSE	evaluated 10 times by 1 test Evaluated by: dd

10-519

1052

return true; /* Don't advise this time. */

executed 509 times by 1 test: return 1 ;

Executed by:

509

1053

else if (! len && ! clen && ! nocache_eof)

! len	Description
TRUE	evaluated 26 times by 1 test Evaluated by: dd
FALSE	evaluated 10 times by 1 test Evaluated by: dd

! clen	Description
TRUE	evaluated 18 times by 1 test Evaluated by: dd
FALSE	evaluated 8 times by 1 test Evaluated by: dd

! nocache_eof	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	evaluated 17 times by 1 test Evaluated by: dd

1-26

1054

return true;

executed 1 time by 1 test: return 1 ;

Executed by:

1055

off_t pending = len ? cache_round (fd, 0) : 0;

len	Description
TRUE	evaluated 10 times by 1 test Evaluated by: dd
FALSE	evaluated 25 times by 1 test Evaluated by: dd

10-25

1056 -

1057

if (fd == STDIN_FILENO)

fd == 0	Description
TRUE	evaluated 16 times by 1 test Evaluated by: dd
FALSE	evaluated 19 times by 1 test Evaluated by: dd

16-19

1058 { -

1059

if (input_seekable)

input_seekable	Description
TRUE	evaluated 15 times by 1 test Evaluated by: dd
FALSE	evaluated 1 time by 1 test Evaluated by: dd

1-15

1060

offset = input_offset;

executed 15 times by 1 test: offset = input_offset;

Executed by:

1061 else -

1062 { -

1063 offset = -1; -

1064 errno = ESPIPE; -

1065

}

executed 1 time by 1 test: end of block

Executed by:

1066 } -

1067 else -

1068 { -

1069 static off_t output_offset = -2; -

1070 -

1071

if (output_offset != -1)

output_offset != -1	Description
TRUE	evaluated 19 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-19

1072 { -

1073

if (output_offset < 0)

output_offset < 0	Description
TRUE	evaluated 10 times by 1 test Evaluated by: dd
FALSE	evaluated 9 times by 1 test Evaluated by: dd

9-10

1074

output_offset = lseek (fd, 0, SEEK_CUR);

executed 10 times by 1 test: output_offset = lseek (fd, 0, 1 );

Executed by:

1075

else if (len)

len	Description
TRUE	evaluated 2 times by 1 test Evaluated by: dd
FALSE	evaluated 7 times by 1 test Evaluated by: dd

2-7

1076

output_offset += clen + pending;

executed 2 times by 1 test: output_offset += clen + pending;

Executed by:

1077

}

executed 19 times by 1 test: end of block

Executed by:

1078 -

1079 offset = output_offset; -

1080

}

executed 19 times by 1 test: end of block

Executed by:

1081 -

1082

if (0 <= offset)

0 <= offset	Description
TRUE	evaluated 34 times by 1 test Evaluated by: dd
FALSE	evaluated 1 time by 1 test Evaluated by: dd

1-34

1083 { -

1084

if (! len && clen && nocache_eof)

! len	Description
TRUE	evaluated 24 times by 1 test Evaluated by: dd
FALSE	evaluated 10 times by 1 test Evaluated by: dd

clen	Description
TRUE	evaluated 8 times by 1 test Evaluated by: dd
FALSE	evaluated 16 times by 1 test Evaluated by: dd

nocache_eof	Description
TRUE	evaluated 6 times by 1 test Evaluated by: dd
FALSE	evaluated 2 times by 1 test Evaluated by: dd

2-24

1085 { -

1086 pending = clen; -

1087 clen = 0; -

1088

}

executed 6 times by 1 test: end of block

Executed by:

1089 -

1090 /* Note we're being careful here to only invalidate what -

1091 we've read, so as not to dump any read ahead cache. -

1092 Note also the kernel is conservative and only invalidates -

1093 full pages in the specified range. */ -

1094 #if HAVE_POSIX_FADVISE -

1095 offset = offset - clen - pending; -

1096 /* ensure full page specified when invalidating to eof. */ -

1097

if (clen == 0)

clen == 0	Description
TRUE	evaluated 22 times by 1 test Evaluated by: dd
FALSE	evaluated 12 times by 1 test Evaluated by: dd

12-22

1098

offset -= offset % page_size;

executed 22 times by 1 test: offset -= offset % page_size;

Executed by:

1099 adv_ret = posix_fadvise (fd, offset, clen, POSIX_FADV_DONTNEED); -

1100 #else -

1101 errno = ENOTSUP; -

1102 #endif -

1103

}

executed 34 times by 1 test: end of block

Executed by:

1104 -

1105

return adv_ret != -1 ? true : false;

executed 35 times by 1 test: return adv_ret != -1 ? 1 : 0 ;

Executed by:

1106 } -

1107 -

1108 /* Read from FD into the buffer BUF of size SIZE, processing any -

1109 signals that arrive before bytes are read. Return the number of -

1110 bytes read if successful, -1 (setting errno) on failure. */ -

1111 -

1112 static ssize_t -

1113 iread (int fd, char *buf, size_t size) -

1114 { -

1115 ssize_t nread; -

1116 static ssize_t prev_nread; -

1117 -

1118 do -

1119 { -

1120 process_signals (); -

1121 nread = read (fd, buf, size); -

1122 /* Ignore final read error with iflag=direct as that -

1123 returns EINVAL due to the non aligned file offset. */ -

1124

if (nread == -1 && errno == EINVAL

nread == -1	Description
TRUE	evaluated 3 times by 1 test Evaluated by: dd
FALSE	evaluated 3004 times by 1 test Evaluated by: dd

(*__errno_location ()) == 22	Description
TRUE	evaluated 3 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-3004

1125

&& 0 < prev_nread && prev_nread < size

0 < prev_nread	Description
TRUE	evaluated 3 times by 1 test Evaluated by: dd
FALSE	never evaluated

prev_nread < size	Description
TRUE	evaluated 3 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-3

1126

&& (input_flags & O_DIRECT))

(input_flags & 040000 )	Description
TRUE	evaluated 3 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-3

1127 { -

1128 errno = 0; -

1129 nread = 0; -

1130

}

executed 3 times by 1 test: end of block

Executed by:

1131

}

executed 3007 times by 1 test: end of block

Executed by:

3007

1132

while (nread < 0 && errno == EINTR);

nread < 0	Description
TRUE	never evaluated
FALSE	evaluated 3007 times by 1 test Evaluated by: dd

(*__errno_location ()) == 4	Description
TRUE	never evaluated
FALSE	never evaluated

0-3007

1133 -

1134 /* Short read may be due to received signal. */ -

1135

if (0 < nread && nread < size)

0 < nread	Description
TRUE	evaluated 2934 times by 1 test Evaluated by: dd
FALSE	evaluated 73 times by 1 test Evaluated by: dd

nread < size	Description
TRUE	evaluated 56 times by 1 test Evaluated by: dd
FALSE	evaluated 2878 times by 1 test Evaluated by: dd

56-2934

1136

process_signals ();

executed 56 times by 1 test: process_signals ();

Executed by:

1137 -

1138

if (0 < nread && warn_partial_read)

0 < nread	Description
TRUE	evaluated 2934 times by 1 test Evaluated by: dd
FALSE	evaluated 73 times by 1 test Evaluated by: dd

warn_partial_read	Description
TRUE	evaluated 425 times by 1 test Evaluated by: dd
FALSE	evaluated 2509 times by 1 test Evaluated by: dd

73-2934

1139 { -

1140

if (0 < prev_nread && prev_nread < size)

0 < prev_nread	Description
TRUE	evaluated 407 times by 1 test Evaluated by: dd
FALSE	evaluated 18 times by 1 test Evaluated by: dd

prev_nread < size	Description
TRUE	never evaluated
FALSE	evaluated 407 times by 1 test Evaluated by: dd

0-407

1141 { -

1142 uintmax_t prev = prev_nread; -

1143

if (status_level != STATUS_NONE)

status_level != STATUS_NONE	Description
TRUE	never evaluated
FALSE	never evaluated

1144

error (0, 0, ngettext (("warning: partial read (%"PRIuMAX" byte); "

never executed:

nl_error (0, 0, dcngettext (((void *)0), ("warning: partial read (%" "l" "u" " byte); " "suggest iflag=fullblock") , ("warning: partial read (%" "l" "u" " bytes); " "suggest iflag=fullblock") , select_plural (prev) , 5) , prev);

1145

"suggest iflag=fullblock"),

never executed:

nl_error (0, 0, dcngettext (((void *)0), ("warning: partial read (%" "l" "u" " byte); " "suggest iflag=fullblock") , ("warning: partial read (%" "l" "u" " bytes); " "suggest iflag=fullblock") , select_plural (prev) , 5) , prev);

1146

("warning: partial read (%"PRIuMAX" bytes); "

never executed:

nl_error (0, 0, dcngettext (((void *)0), ("warning: partial read (%" "l" "u" " byte); " "suggest iflag=fullblock") , ("warning: partial read (%" "l" "u" " bytes); " "suggest iflag=fullblock") , select_plural (prev) , 5) , prev);

1147

"suggest iflag=fullblock"),

never executed:

nl_error (0, 0, dcngettext (((void *)0), ("warning: partial read (%" "l" "u" " byte); " "suggest iflag=fullblock") , ("warning: partial read (%" "l" "u" " bytes); " "suggest iflag=fullblock") , select_plural (prev) , 5) , prev);

1148

select_plural (prev)),

never executed:

nl_error (0, 0, dcngettext (((void *)0), ("warning: partial read (%" "l" "u" " byte); " "suggest iflag=fullblock") , ("warning: partial read (%" "l" "u" " bytes); " "suggest iflag=fullblock") , select_plural (prev) , 5) , prev);

1149

prev);

never executed:

nl_error (0, 0, dcngettext (((void *)0), ("warning: partial read (%" "l" "u" " byte); " "suggest iflag=fullblock") , ("warning: partial read (%" "l" "u" " bytes); " "suggest iflag=fullblock") , select_plural (prev) , 5) , prev);

1150 warn_partial_read = false; -

1151

}

never executed: end of block

1152

}

executed 425 times by 1 test: end of block

Executed by:

425

1153 -

1154 prev_nread = nread; -

1155

return nread;

Executed by:

3007

1156 } -

1157 -

1158 /* Wrapper around iread function to accumulate full blocks. */ -

1159 static ssize_t -

1160 iread_fullblock (int fd, char *buf, size_t size) -

1161 { -

1162 ssize_t nread = 0; -

1163 -

1164

while (0 < size)

0 < size	Description
TRUE	evaluated 1724 times by 1 test Evaluated by: dd
FALSE	evaluated 1716 times by 1 test Evaluated by: dd

1716-1724

1165 { -

1166 ssize_t ncurr = iread (fd, buf, size); -

1167

if (ncurr < 0)

ncurr < 0	Description
TRUE	never evaluated
FALSE	evaluated 1724 times by 1 test Evaluated by: dd

0-1724

1168

return ncurr;

never executed: return ncurr;

1169

if (ncurr == 0)

ncurr == 0	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	evaluated 1723 times by 1 test Evaluated by: dd

1-1723

1170

break;

executed 1 time by 1 test: break;

Executed by:

1171 nread += ncurr; -

1172 buf += ncurr; -

1173 size -= ncurr; -

1174

}

executed 1723 times by 1 test: end of block

Executed by:

1723

1175 -

1176

return nread;

Executed by:

1717

1177 } -

1178 -

1179 /* Write to FD the buffer BUF of size SIZE, processing any signals -

1180 that arrive. Return the number of bytes written, setting errno if -

1181 this is less than SIZE. Keep trying if there are partial -

1182 writes. */ -

1183 -

1184 static size_t -

1185 iwrite (int fd, char const *buf, size_t size) -

1186 { -

1187 size_t total_written = 0; -

1188 -

1189

if ((output_flags & O_DIRECT) && size < output_blocksize)

(output_flags & 040000 )	Description
TRUE	evaluated 54 times by 1 test Evaluated by: dd
FALSE	evaluated 2854 times by 1 test Evaluated by: dd

size < output_blocksize	Description
TRUE	evaluated 5 times by 1 test Evaluated by: dd
FALSE	evaluated 49 times by 1 test Evaluated by: dd

5-2854

1190 { -

1191 int old_flags = fcntl (STDOUT_FILENO, F_GETFL); -

1192

if (fcntl (STDOUT_FILENO, F_SETFL, old_flags & ~O_DIRECT) != 0

rpl_fcntl ( 1 ... 040000 ) != 0	Description
TRUE	never evaluated
FALSE	evaluated 5 times by 1 test Evaluated by: dd

0-5

1193

&& status_level != STATUS_NONE)

status_level != STATUS_NONE	Description
TRUE	never evaluated
FALSE	never evaluated

1194

error (0, errno, _("failed to turn off O_DIRECT: %s"),

never executed:

nl_error (0, (*__errno_location ()) , dcgettext (((void *)0), "failed to turn off O_DIRECT: %s" , 5) , quotearg_n_style_colon (0, shell_escape_quoting_style, output_file));

1195

quotef (output_file));

never executed:

nl_error (0, (*__errno_location ()) , dcgettext (((void *)0), "failed to turn off O_DIRECT: %s" , 5) , quotearg_n_style_colon (0, shell_escape_quoting_style, output_file));

1196 -

1197 /* Since we have just turned off O_DIRECT for the final write, -

1198 we try to preserve some of its semantics. */ -

1199 -

1200 /* Call invalidate_cache() to setup the appropriate offsets -

1201 for subsequent calls. */ -

1202 o_nocache_eof = true; -

1203 invalidate_cache (STDOUT_FILENO, 0); -

1204 -

1205 /* Attempt to ensure that that final block is committed -

1206 to disk as quickly as possible. */ -

1207 conversions_mask |= C_FSYNC; -

1208 -

1209 /* After the subsequent fsync() we'll call invalidate_cache() -

1210 to attempt to clear all data from the page cache. */ -

1211

}

executed 5 times by 1 test: end of block

Executed by:

1212 -

1213

while (total_written < size)

total_written < size	Description
TRUE	evaluated 2958 times by 1 test Evaluated by: dd
FALSE	evaluated 2908 times by 1 test Evaluated by: dd

2908-2958

1214 { -

1215 ssize_t nwritten = 0; -

1216 process_signals (); -

1217 -

1218 /* Perform a seek for a NUL block if sparse output is enabled. */ -

1219 final_op_was_seek = false; -

1220

if ((conversions_mask & C_SPARSE) && is_nul (buf, size))

(conversions_mask & C_SPARSE)	Description
TRUE	evaluated 47 times by 1 test Evaluated by: dd
FALSE	evaluated 2911 times by 1 test Evaluated by: dd

is_nul (buf, size)	Description
TRUE	evaluated 38 times by 1 test Evaluated by: dd
FALSE	evaluated 9 times by 1 test Evaluated by: dd

9-2911

1221 { -

1222

if (lseek (fd, size, SEEK_CUR) < 0)

lseek (fd, size, 1 ) < 0	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	evaluated 37 times by 1 test Evaluated by: dd

1-37

1223 { -

1224 conversions_mask &= ~C_SPARSE; -

1225 /* Don't warn about the advisory sparse request. */ -

1226

}

executed 1 time by 1 test: end of block

Executed by:

1227 else -

1228 { -

1229 final_op_was_seek = true; -

1230 nwritten = size; -

1231

}

executed 37 times by 1 test: end of block

Executed by:

1232 } -

1233 -

1234

if (!nwritten)

!nwritten	Description
TRUE	evaluated 2921 times by 1 test Evaluated by: dd
FALSE	evaluated 37 times by 1 test Evaluated by: dd

37-2921

1235

nwritten = write (fd, buf + total_written, size - total_written);

executed 2921 times by 1 test: nwritten = write (fd, buf + total_written, size - total_written);

Executed by:

2921

1236 -

1237

if (nwritten < 0)

nwritten < 0	Description
TRUE	never evaluated
FALSE	evaluated 2958 times by 1 test Evaluated by: dd

0-2958

1238 { -

1239

if (errno != EINTR)

(*__errno_location ()) != 4	Description
TRUE	never evaluated
FALSE	never evaluated

1240

break;

never executed: break;

1241

}

never executed: end of block

1242

else if (nwritten == 0)

nwritten == 0	Description
TRUE	never evaluated
FALSE	evaluated 2958 times by 1 test Evaluated by: dd

0-2958

1243 { -

1244 /* Some buggy drivers return 0 when one tries to write beyond -

1245 a device's end. (Example: Linux kernel 1.2.13 on /dev/fd0.) -

1246 Set errno to ENOSPC so they get a sensible diagnostic. */ -

1247 errno = ENOSPC; -

1248

break;

never executed: break;

1249 } -

1250 else -

1251

total_written += nwritten;

executed 2958 times by 1 test: total_written += nwritten;

Executed by:

2958

1252 } -

1253 -

1254

if (o_nocache && total_written)

o_nocache	Description
TRUE	evaluated 104 times by 1 test Evaluated by: dd
FALSE	evaluated 2804 times by 1 test Evaluated by: dd

total_written	Description
TRUE	evaluated 104 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-2804

1255

invalidate_cache (fd, total_written);

executed 104 times by 1 test: invalidate_cache (fd, total_written);

Executed by:

104

1256 -

1257

return total_written;

executed 2908 times by 1 test: return total_written;

Executed by:

2908

1258 } -

1259 -

1260 /* Write, then empty, the output buffer 'obuf'. */ -

1261 -

1262 static void -

1263 write_output (void) -

1264 { -

1265 size_t nwritten = iwrite (STDOUT_FILENO, obuf, output_blocksize); -

1266 w_bytes += nwritten; -

1267

if (nwritten != output_blocksize)

nwritten != output_blocksize	Description
TRUE	never evaluated
FALSE	evaluated 760 times by 1 test Evaluated by: dd

0-760

1268 { -

1269 error (0, errno, _("writing to %s"), quoteaf (output_file)); -

1270

if (nwritten != 0)

nwritten != 0	Description
TRUE	never evaluated
FALSE	never evaluated

1271

w_partial++;

never executed: w_partial++;

1272 quit (EXIT_FAILURE); -

1273

}

never executed: end of block

1274 else -

1275

w_full++;

executed 760 times by 1 test: w_full++;

Executed by:

760

1276 oc = 0; -

1277

}

executed 760 times by 1 test: end of block

Executed by:

760

1278 -

1279 /* Restart on EINTR from fd_reopen(). */ -

1280 -

1281 static int -

1282 ifd_reopen (int desired_fd, char const *file, int flag, mode_t mode) -

1283 { -

1284 int ret; -

1285 -

1286 do -

1287 { -

1288 process_signals (); -

1289 ret = fd_reopen (desired_fd, file, flag, mode); -

1290

}

executed 1125 times by 1 test: end of block

Executed by:

1125

1291

while (ret < 0 && errno == EINTR);

ret < 0	Description
TRUE	evaluated 2 times by 1 test Evaluated by: dd
FALSE	evaluated 1123 times by 1 test Evaluated by: dd

(*__errno_location ()) == 4	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	evaluated 1 time by 1 test Evaluated by: dd

1-1123

1292 -

1293

return ret;

executed 1124 times by 1 test: return ret;

Executed by:

1124

1294 } -

1295 -

1296 /* Restart on EINTR from ftruncate(). */ -

1297 -

1298 static int -

1299 iftruncate (int fd, off_t length) -

1300 { -

1301 int ret; -

1302 -

1303 do -

1304 { -

1305 process_signals (); -

1306 ret = ftruncate (fd, length); -

1307

}

executed 18 times by 1 test: end of block

Executed by:

1308

while (ret < 0 && errno == EINTR);

ret < 0	Description
TRUE	evaluated 3 times by 1 test Evaluated by: dd
FALSE	evaluated 15 times by 1 test Evaluated by: dd

(*__errno_location ()) == 4	Description
TRUE	never evaluated
FALSE	evaluated 3 times by 1 test Evaluated by: dd

0-15

1309 -

1310

return ret;

executed 18 times by 1 test: return ret;

Executed by:

1311 } -

1312 -

1313 /* Return true if STR is of the form "PATTERN" or "PATTERNDELIM...". */ -

1314 -

1315 static bool _GL_ATTRIBUTE_PURE -

1316 operand_matches (char const *str, char const *pattern, char delim) -

1317 { -

1318

while (*pattern)

*pattern	Description
TRUE	evaluated 67860 times by 1 test Evaluated by: dd
FALSE	evaluated 7441 times by 1 test Evaluated by: dd

7441-67860

1319

if (*str++ != *pattern++)

str++ != pattern++	Description
TRUE	evaluated 31850 times by 1 test Evaluated by: dd
FALSE	evaluated 36010 times by 1 test Evaluated by: dd

31850-36010

1320

return false;

executed 31850 times by 1 test: return 0 ;

Executed by:

31850

1321

return !*str || *str == delim;

executed 7441 times by 1 test: return !*str || *str == delim;

Executed by:

7441

1322 } -

1323 -

1324 /* Interpret one "conv=..." or similar operand STR according to the -

1325 symbols in TABLE, returning the flags specified. If the operand -

1326 cannot be parsed, use ERROR_MSGID to generate a diagnostic. */ -

1327 -

1328 static int -

1329 parse_symbols (char const *str, struct symbol_value const *table, -

1330 bool exclusive, char const *error_msgid) -

1331 { -

1332 int value = 0; -

1333 -

1334 while (true) -

1335 { -

1336

char const *strcomma = strchr (str, ',');

__builtin_constant_p ( ',' )	Description
TRUE	evaluated 2063 times by 1 test Evaluated by: dd
FALSE	never evaluated

!__builtin_constant_p ( str )	Description
TRUE	evaluated 2063 times by 1 test Evaluated by: dd
FALSE	never evaluated

( ',' ) == '\0'	Description
TRUE	never evaluated
FALSE	evaluated 2063 times by 1 test Evaluated by: dd

0-2063

1337 struct symbol_value const *entry; -

1338 -

1339 for (entry = table; -

1340

! (operand_matches (str, entry->symbol, ',') && entry->value);

operand_matche...->symbol, ',')	Description
TRUE	evaluated 2063 times by 1 test Evaluated by: dd
FALSE	evaluated 13296 times by 1 test Evaluated by: dd

entry->value	Description
TRUE	evaluated 2062 times by 1 test Evaluated by: dd
FALSE	evaluated 1 time by 1 test Evaluated by: dd

1-13296

1341 entry++) -

1342 { -

1343

if (! entry->symbol[0])

! entry->symbol[0]	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	evaluated 13296 times by 1 test Evaluated by: dd

1-13296

1344 { -

1345

size_t slen = strcomma ? strcomma - str : strlen (str);

strcomma	Description
TRUE	never evaluated
FALSE	evaluated 1 time by 1 test Evaluated by: dd

0-1

1346 error (0, 0, "%s: %s", _(error_msgid), -

1347 quotearg_n_style_mem (0, locale_quoting_style, str, slen)); -

1348 usage (EXIT_FAILURE); -

1349

}

never executed: end of block

1350

}

executed 13296 times by 1 test: end of block

Executed by:

13296

1351 -

1352

if (exclusive)

exclusive	Description
TRUE	evaluated 533 times by 1 test Evaluated by: dd
FALSE	evaluated 1529 times by 1 test Evaluated by: dd

533-1529

1353

value = entry->value;

executed 533 times by 1 test: value = entry->value;

Executed by:

533

1354 else -

1355

value |= entry->value;

executed 1529 times by 1 test: value |= entry->value;

Executed by:

1529

1356

if (!strcomma)

!strcomma	Description
TRUE	evaluated 2054 times by 1 test Evaluated by: dd
FALSE	evaluated 8 times by 1 test Evaluated by: dd

8-2054

1357

break;

executed 2054 times by 1 test: break;

Executed by:

2054

1358 str = strcomma + 1; -

1359

}

executed 8 times by 1 test: end of block

Executed by:

1360 -

1361

return value;

executed 2054 times by 1 test: return value;

Executed by:

2054

1362 } -

1363 -

1364 /* Return the value of STR, interpreted as a non-negative decimal integer, -

1365 optionally multiplied by various values. -

1366 Set *INVALID to a nonzero error value if STR does not represent a -

1367 number in this format. */ -

1368 -

1369 static uintmax_t -

1370 parse_integer (const char *str, strtol_error *invalid) -

1371 { -

1372 uintmax_t n; -

1373 char *suffix; -

1374 strtol_error e = xstrtoumax (str, &suffix, 10, &n, "bcEGkKMPTwYZ0"); -

1375 -

1376

if (e == LONGINT_INVALID_SUFFIX_CHAR && *suffix == 'x')

e == LONGINT_I...ID_SUFFIX_CHAR	Description
TRUE	evaluated 3 times by 1 test Evaluated by: dd
FALSE	evaluated 1180 times by 1 test Evaluated by: dd

*suffix == 'x'	Description
TRUE	evaluated 3 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-1180

1377 { -

1378 uintmax_t multiplier = parse_integer (suffix + 1, invalid); -

1379 -

1380

if (multiplier != 0 && n * multiplier / multiplier != n)

multiplier != 0	Description
TRUE	evaluated 3 times by 1 test Evaluated by: dd
FALSE	never evaluated

n * multiplier...ultiplier != n	Description
TRUE	never evaluated
FALSE	evaluated 3 times by 1 test Evaluated by: dd

0-3

1381 { -

1382 *invalid = LONGINT_OVERFLOW; -

1383

return 0;

never executed: return 0;

1384 } -

1385 -

1386

if (n == 0 && STRPREFIX (str, "0x"))

never executed: __result = (((const unsigned char *) (const char *) ( str ))[3] - __s2[3]);

never executed: end of block

never executed: __result = (((const unsigned char *) (const char *) ( "0x" ))[3] - __s2[3]);

never executed: end of block

n == 0	Description
TRUE	evaluated 3 times by 1 test Evaluated by: dd
FALSE	never evaluated

( (__extension...0x") ))) == 0)	Description
TRUE	evaluated 3 times by 1 test Evaluated by: dd
FALSE	never evaluated

__builtin_cons...trlen ("0x") )	Description
TRUE	evaluated 3 times by 1 test Evaluated by: dd
FALSE	never evaluated

__builtin_constant_p ( str )	Description
TRUE	never evaluated
FALSE	evaluated 3 times by 1 test Evaluated by: dd

strlen ( str )...rlen ("0x") ))	Description
TRUE	never evaluated
FALSE	never evaluated

__builtin_constant_p ( "0x" )	Description
TRUE	evaluated 3 times by 1 test Evaluated by: dd
FALSE	never evaluated

strlen ( "0x" ...rlen ("0x") ))	Description
TRUE	never evaluated
FALSE	evaluated 3 times by 1 test Evaluated by: dd

__s1_len > 0	Description
TRUE	never evaluated
FALSE	never evaluated

__result == 0	Description
TRUE	never evaluated
FALSE	never evaluated

__s1_len > 1	Description
TRUE	never evaluated
FALSE	never evaluated

__result == 0	Description
TRUE	never evaluated
FALSE	never evaluated

__s1_len > 2	Description
TRUE	never evaluated
FALSE	never evaluated

__result == 0	Description
TRUE	never evaluated
FALSE	never evaluated

__s2_len > 0	Description
TRUE	never evaluated
FALSE	never evaluated

__result == 0	Description
TRUE	never evaluated
FALSE	never evaluated

__s2_len > 1	Description
TRUE	never evaluated
FALSE	never evaluated

__result == 0	Description
TRUE	never evaluated
FALSE	never evaluated

__s2_len > 2	Description
TRUE	never evaluated
FALSE	never evaluated

__result == 0	Description
TRUE	never evaluated
FALSE	never evaluated

0-3

1387

error (0, 0,

executed 3 times by 1 test:

nl_error (0, 0, dcgettext (((void *)0), "warning: %s is a zero multiplier; " "use %s if that is intended" , 5) , quote_n (0, "0x"), quote_n (1, "00x"));

Executed by:

1388

_("warning: %s is a zero multiplier; "

executed 3 times by 1 test:

nl_error (0, 0, dcgettext (((void *)0), "warning: %s is a zero multiplier; " "use %s if that is intended" , 5) , quote_n (0, "0x"), quote_n (1, "00x"));

Executed by:

1389

"use %s if that is intended"),

executed 3 times by 1 test:

nl_error (0, 0, dcgettext (((void *)0), "warning: %s is a zero multiplier; " "use %s if that is intended" , 5) , quote_n (0, "0x"), quote_n (1, "00x"));

Executed by:

1390

quote_n (0, "0x"), quote_n (1, "00x"));

executed 3 times by 1 test:

nl_error (0, 0, dcgettext (((void *)0), "warning: %s is a zero multiplier; " "use %s if that is intended" , 5) , quote_n (0, "0x"), quote_n (1, "00x"));

Executed by:

1391 -

1392 n *= multiplier; -

1393

}

executed 3 times by 1 test: end of block

Executed by:

1394

else if (e != LONGINT_OK)

e != LONGINT_OK	Description
TRUE	never evaluated
FALSE	evaluated 1180 times by 1 test Evaluated by: dd

0-1180

1395 { -

1396 *invalid = e; -

1397

return 0;

never executed: return 0;

1398 } -

1399 -

1400

return n;

executed 1183 times by 1 test: return n;

Executed by:

1183

1401 } -

1402 -

1403 /* OPERAND is of the form "X=...". Return true if X is NAME. */ -

1404 -

1405 static bool _GL_ATTRIBUTE_PURE -

1406 operand_is (char const *operand, char const *name) -

1407 { -

1408

return operand_matches (operand, name, '=');

executed 23932 times by 1 test: return operand_matches (operand, name, '=');

Executed by:

23932

1409 } -

1410 -

1411 static void -

1412 scanargs (int argc, char *const *argv) -

1413 { -

1414 size_t blocksize = 0; -

1415 uintmax_t count = (uintmax_t) -1; -

1416 uintmax_t skip = 0; -

1417 uintmax_t seek = 0; -

1418 -

1419

for (int i = optind; i < argc; i++)

i < argc	Description
TRUE	evaluated 4360 times by 1 test Evaluated by: dd
FALSE	evaluated 629 times by 1 test Evaluated by: dd

629-4360

1420 { -

1421 char const *name = argv[i]; -

1422

char const *val = strchr (name, '=');

__builtin_constant_p ( '=' )	Description
TRUE	evaluated 4360 times by 1 test Evaluated by: dd
FALSE	never evaluated

!__builtin_constant_p ( name )	Description
TRUE	evaluated 4360 times by 1 test Evaluated by: dd
FALSE	never evaluated

( '=' ) == '\0'	Description
TRUE	never evaluated
FALSE	evaluated 4360 times by 1 test Evaluated by: dd

0-4360

1423 -

1424

if (val == NULL)

val == ((void *)0)	Description
TRUE	never evaluated
FALSE	evaluated 4360 times by 1 test Evaluated by: dd

0-4360

1425 { -

1426 error (0, 0, _("unrecognized operand %s"), -

1427 quote (name)); -

1428 usage (EXIT_FAILURE); -

1429

}

never executed: end of block

1430 val++; -

1431 -

1432

if (operand_is (name, "if"))

operand_is (name, "if")	Description
TRUE	evaluated 562 times by 1 test Evaluated by: dd
FALSE	evaluated 3798 times by 1 test Evaluated by: dd

562-3798

1433

input_file = val;

executed 562 times by 1 test: input_file = val;

Executed by:

562

1434

else if (operand_is (name, "of"))

operand_is (name, "of")	Description
TRUE	evaluated 563 times by 1 test Evaluated by: dd
FALSE	evaluated 3235 times by 1 test Evaluated by: dd

563-3235

1435

output_file = val;

executed 563 times by 1 test: output_file = val;

Executed by:

563

1436

else if (operand_is (name, "conv"))

operand_is (name, "conv")	Description
TRUE	evaluated 508 times by 1 test Evaluated by: dd
FALSE	evaluated 2727 times by 1 test Evaluated by: dd

508-2727

1437

conversions_mask |= parse_symbols (val, conversions, false,

executed 508 times by 1 test: conversions_mask |= parse_symbols (val, conversions, 0 , "invalid conversion");

Executed by:

508

1438

N_("invalid conversion"));

executed 508 times by 1 test: conversions_mask |= parse_symbols (val, conversions, 0 , "invalid conversion");

Executed by:

508

1439

else if (operand_is (name, "iflag"))

operand_is (name, "iflag")	Description
TRUE	evaluated 517 times by 1 test Evaluated by: dd
FALSE	evaluated 2210 times by 1 test Evaluated by: dd

517-2210

1440

input_flags |= parse_symbols (val, flags, false,

executed 517 times by 1 test: input_flags |= parse_symbols (val, flags, 0 , "invalid input flag");

Executed by:

517

1441

N_("invalid input flag"));

executed 517 times by 1 test: input_flags |= parse_symbols (val, flags, 0 , "invalid input flag");

Executed by:

517

1442

else if (operand_is (name, "oflag"))

operand_is (name, "oflag")	Description
TRUE	evaluated 497 times by 1 test Evaluated by: dd
FALSE	evaluated 1713 times by 1 test Evaluated by: dd

497-1713

1443

output_flags |= parse_symbols (val, flags, false,

executed 497 times by 1 test: output_flags |= parse_symbols (val, flags, 0 , "invalid output flag");

Executed by:

497

1444

N_("invalid output flag"));

executed 497 times by 1 test: output_flags |= parse_symbols (val, flags, 0 , "invalid output flag");

Executed by:

497

1445

else if (operand_is (name, "status"))

operand_is (name, "status")	Description
TRUE	evaluated 533 times by 1 test Evaluated by: dd
FALSE	evaluated 1180 times by 1 test Evaluated by: dd

533-1180

1446

status_level = parse_symbols (val, statuses, true,

executed 533 times by 1 test: status_level = parse_symbols (val, statuses, 1 , "invalid status level");

Executed by:

533

1447

N_("invalid status level"));

executed 533 times by 1 test: status_level = parse_symbols (val, statuses, 1 , "invalid status level");

Executed by:

533

1448 else -

1449 { -

1450 strtol_error invalid = LONGINT_OK; -

1451 uintmax_t n = parse_integer (val, &invalid); -

1452 uintmax_t n_min = 0; -

1453 uintmax_t n_max = UINTMAX_MAX; -

1454 -

1455

if (operand_is (name, "ibs"))

operand_is (name, "ibs")	Description
TRUE	evaluated 8 times by 1 test Evaluated by: dd
FALSE	evaluated 1172 times by 1 test Evaluated by: dd

8-1172

1456 { -

1457 n_min = 1; -

1458

n_max = MAX_BLOCKSIZE (INPUT_BLOCK_SLOP);

(((18446744073... 2 + 1))) ))))	Description
TRUE	never evaluated
FALSE	evaluated 8 times by 1 test Evaluated by: dd

((0x7fffffffff... * 2 + 1))) ))	Description
TRUE	never evaluated
FALSE	evaluated 8 times by 1 test Evaluated by: dd

0-8

1459 input_blocksize = n; -

1460

}

executed 8 times by 1 test: end of block

Executed by:

1461

else if (operand_is (name, "obs"))

operand_is (name, "obs")	Description
TRUE	evaluated 6 times by 1 test Evaluated by: dd
FALSE	evaluated 1166 times by 1 test Evaluated by: dd

6-1166

1462 { -

1463 n_min = 1; -

1464

n_max = MAX_BLOCKSIZE (OUTPUT_BLOCK_SLOP);

(((18446744073... 2 + 1))) ))))	Description
TRUE	never evaluated
FALSE	evaluated 6 times by 1 test Evaluated by: dd

((0x7fffffffff... * 2 + 1))) ))	Description
TRUE	never evaluated
FALSE	evaluated 6 times by 1 test Evaluated by: dd

0-6

1465 output_blocksize = n; -

1466

}

executed 6 times by 1 test: end of block

Executed by:

1467

else if (operand_is (name, "bs"))

operand_is (name, "bs")	Description
TRUE	evaluated 545 times by 1 test Evaluated by: dd
FALSE	evaluated 621 times by 1 test Evaluated by: dd

545-621

1468 { -

1469 n_min = 1; -

1470

n_max = MAX_BLOCKSIZE (INPUT_BLOCK_SLOP);

(((18446744073... 2 + 1))) ))))	Description
TRUE	never evaluated
FALSE	evaluated 545 times by 1 test Evaluated by: dd

((0x7fffffffff... * 2 + 1))) ))	Description
TRUE	never evaluated
FALSE	evaluated 545 times by 1 test Evaluated by: dd

0-545

1471 blocksize = n; -

1472

}

executed 545 times by 1 test: end of block

Executed by:

545

1473

else if (operand_is (name, "cbs"))

operand_is (name, "cbs")	Description
TRUE	evaluated 11 times by 1 test Evaluated by: dd
FALSE	evaluated 610 times by 1 test Evaluated by: dd

11-610

1474 { -

1475 n_min = 1; -

1476 n_max = SIZE_MAX; -

1477 conversion_blocksize = n; -

1478

}

executed 11 times by 1 test: end of block

Executed by:

1479

else if (operand_is (name, "skip"))

operand_is (name, "skip")	Description
TRUE	evaluated 28 times by 1 test Evaluated by: dd
FALSE	evaluated 582 times by 1 test Evaluated by: dd

28-582

1480

skip = n;

executed 28 times by 1 test: skip = n;

Executed by:

1481

else if (operand_is (name, "seek"))

operand_is (name, "seek")	Description
TRUE	evaluated 24 times by 1 test Evaluated by: dd
FALSE	evaluated 558 times by 1 test Evaluated by: dd

24-558

1482

seek = n;

executed 24 times by 1 test: seek = n;

Executed by:

1483

else if (operand_is (name, "count"))

operand_is (name, "count")	Description
TRUE	evaluated 558 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-558

1484

count = n;

executed 558 times by 1 test: count = n;

Executed by:

558

1485 else -

1486 { -

1487 error (0, 0, _("unrecognized operand %s"), -

1488 quote (name)); -

1489 usage (EXIT_FAILURE); -

1490

}

never executed: end of block

1491 -

1492

if (n < n_min)

n < n_min	Description
TRUE	never evaluated
FALSE	evaluated 1180 times by 1 test Evaluated by: dd

0-1180

1493

invalid = LONGINT_INVALID;

never executed: invalid = LONGINT_INVALID;

1494

else if (n_max < n)

n_max < n	Description
TRUE	never evaluated
FALSE	evaluated 1180 times by 1 test Evaluated by: dd

0-1180

1495

invalid = LONGINT_OVERFLOW;

never executed: invalid = LONGINT_OVERFLOW;

1496 -

1497

if (invalid != LONGINT_OK)

invalid != LONGINT_OK	Description
TRUE	never evaluated
FALSE	evaluated 1180 times by 1 test Evaluated by: dd

0-1180

1498

die (EXIT_FAILURE, invalid == LONGINT_OVERFLOW ? EOVERFLOW : 0,

never executed:

((!!sizeof (struct { _Static_assert ( 1 , "verify_expr (" "1" ", " "(error (1, invalid == LONGINT_OVERFLOW ? 75 : 0, \"%s: %s\", dcgettext (((void *)0), \"invalid number\", 5), quote (val)), assume (false))" ")"); int _gl_dummy; })) ? ((nl_error ( 1 , inv...umber" , 5) , quote (val)), (( 0 ) ? (void) 0 : __builtin_unreachable ()))) : ((nl_error ( 1 , invalid == LONGINT_OVERFLOW ? 75 : 0, "%s: %s", dcgettext (((void *)0), "invalid number" , 5) , quote (val)), (( 0 ) ? (void) 0 : __builtin_unreachable ())))) ;

1499

"%s: %s", _("invalid number"), quote (val));

never executed:

((!!sizeof (struct { _Static_assert ( 1 , "verify_expr (" "1" ", " "(error (1, invalid == LONGINT_OVERFLOW ? 75 : 0, \"%s: %s\", dcgettext (((void *)0), \"invalid number\", 5), quote (val)), assume (false))" ")"); int _gl_dummy; })) ? ((nl_error ( 1 , inv...umber" , 5) , quote (val)), (( 0 ) ? (void) 0 : __builtin_unreachable ()))) : ((nl_error ( 1 , invalid == LONGINT_OVERFLOW ? 75 : 0, "%s: %s", dcgettext (((void *)0), "invalid number" , 5) , quote (val)), (( 0 ) ? (void) 0 : __builtin_unreachable ())))) ;

1500

}

executed 1180 times by 1 test: end of block

Executed by:

1180

1501 } -

1502 -

1503

if (blocksize)

blocksize	Description
TRUE	evaluated 545 times by 1 test Evaluated by: dd
FALSE	evaluated 84 times by 1 test Evaluated by: dd

84-545

1504

input_blocksize = output_blocksize = blocksize;

executed 545 times by 1 test: input_blocksize = output_blocksize = blocksize;

Executed by:

545

1505 else -

1506 { -

1507 /* POSIX says dd aggregates partial reads into -

1508 output_blocksize if bs= is not specified. */ -

1509 conversions_mask |= C_TWOBUFS; -

1510

}

executed 84 times by 1 test: end of block

Executed by:

1511 -

1512

if (input_blocksize == 0)

input_blocksize == 0	Description
TRUE	evaluated 78 times by 1 test Evaluated by: dd
FALSE	evaluated 551 times by 1 test Evaluated by: dd

78-551

1513

input_blocksize = DEFAULT_BLOCKSIZE;

executed 78 times by 1 test: input_blocksize = 512;

Executed by:

1514

if (output_blocksize == 0)

output_blocksize == 0	Description
TRUE	evaluated 80 times by 1 test Evaluated by: dd
FALSE	evaluated 549 times by 1 test Evaluated by: dd

80-549

1515

output_blocksize = DEFAULT_BLOCKSIZE;

executed 80 times by 1 test: output_blocksize = 512;

Executed by:

1516

if (conversion_blocksize == 0)

conversion_blocksize == 0	Description
TRUE	evaluated 618 times by 1 test Evaluated by: dd
FALSE	evaluated 11 times by 1 test Evaluated by: dd

11-618

1517

conversions_mask &= ~(C_BLOCK | C_UNBLOCK);

executed 618 times by 1 test: conversions_mask &= ~(C_BLOCK | C_UNBLOCK);

Executed by:

618

1518 -

1519

if (input_flags & (O_DSYNC | O_SYNC))

input_flags & ...0 \| 04010000 )	Description
TRUE	never evaluated
FALSE	evaluated 629 times by 1 test Evaluated by: dd

0-629

1520

input_flags |= O_RSYNC;

never executed: input_flags |= 04010000 ;

1521 -

1522

if (output_flags & O_FULLBLOCK)

output_flags & O_FULLBLOCK	Description
TRUE	never evaluated
FALSE	evaluated 629 times by 1 test Evaluated by: dd

0-629

1523 { -

1524 error (0, 0, "%s: %s", _("invalid output flag"), quote ("fullblock")); -

1525 usage (EXIT_FAILURE); -

1526

}

never executed: end of block

1527 -

1528

if (input_flags & O_SEEK_BYTES)

input_flags & O_SEEK_BYTES	Description
TRUE	never evaluated
FALSE	evaluated 629 times by 1 test Evaluated by: dd

0-629

1529 { -

1530 error (0, 0, "%s: %s", _("invalid input flag"), quote ("seek_bytes")); -

1531 usage (EXIT_FAILURE); -

1532

}

never executed: end of block

1533 -

1534

if (output_flags & (O_COUNT_BYTES | O_SKIP_BYTES))

output_flags &... O_SKIP_BYTES)	Description
TRUE	never evaluated
FALSE	evaluated 629 times by 1 test Evaluated by: dd

0-629

1535 { -

1536 error (0, 0, "%s: %s", _("invalid output flag"), -

1537 quote (output_flags & O_COUNT_BYTES -

1538 ? "count_bytes" : "skip_bytes")); -

1539 usage (EXIT_FAILURE); -

1540

}

never executed: end of block

1541 -

1542

if (input_flags & O_SKIP_BYTES && skip != 0)

input_flags & O_SKIP_BYTES	Description
TRUE	evaluated 2 times by 1 test Evaluated by: dd
FALSE	evaluated 627 times by 1 test Evaluated by: dd

skip != 0	Description
TRUE	evaluated 2 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-627

1543 { -

1544 skip_records = skip / input_blocksize; -

1545 skip_bytes = skip % input_blocksize; -

1546

}

executed 2 times by 1 test: end of block

Executed by:

1547

else if (skip != 0)

skip != 0	Description
TRUE	evaluated 25 times by 1 test Evaluated by: dd
FALSE	evaluated 602 times by 1 test Evaluated by: dd

25-602

1548

skip_records = skip;

executed 25 times by 1 test: skip_records = skip;

Executed by:

1549 -

1550

if (input_flags & O_COUNT_BYTES && count != (uintmax_t) -1)

input_flags & O_COUNT_BYTES	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	evaluated 628 times by 1 test Evaluated by: dd

count != (uintmax_t) -1	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	never evaluated

0-628

1551 { -

1552 max_records = count / input_blocksize; -

1553 max_bytes = count % input_blocksize; -

1554

}

executed 1 time by 1 test: end of block

Executed by:

1555

else if (count != (uintmax_t) -1)

count != (uintmax_t) -1	Description
TRUE	evaluated 557 times by 1 test Evaluated by: dd
FALSE	evaluated 71 times by 1 test Evaluated by: dd

71-557

1556

max_records = count;

executed 557 times by 1 test: max_records = count;

Executed by:

557

1557 -

1558

if (output_flags & O_SEEK_BYTES && seek != 0)

output_flags & O_SEEK_BYTES	Description
TRUE	evaluated 3 times by 1 test Evaluated by: dd
FALSE	evaluated 626 times by 1 test Evaluated by: dd

seek != 0	Description
TRUE	evaluated 3 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-626

1559 { -

1560 seek_records = seek / output_blocksize; -

1561 seek_bytes = seek % output_blocksize; -

1562

}

executed 3 times by 1 test: end of block

Executed by:

1563

else if (seek != 0)

seek != 0	Description
TRUE	evaluated 20 times by 1 test Evaluated by: dd
FALSE	evaluated 606 times by 1 test Evaluated by: dd

20-606

1564

seek_records = seek;

executed 20 times by 1 test: seek_records = seek;

Executed by:

1565 -

1566 /* Warn about partial reads if bs=SIZE is given and iflag=fullblock -

1567 is not, and if counting or skipping bytes or using direct I/O. -

1568 This helps to avoid confusion with miscounts, and to avoid issues -

1569 with direct I/O on GNU/Linux. */ -

1570 warn_partial_read = -

1571

(! (conversions_mask & C_TWOBUFS) && ! (input_flags & O_FULLBLOCK)

! (conversions...k & C_TWOBUFS)	Description
TRUE	evaluated 545 times by 1 test Evaluated by: dd
FALSE	evaluated 84 times by 1 test Evaluated by: dd

! (input_flags & O_FULLBLOCK)	Description
TRUE	evaluated 61 times by 1 test Evaluated by: dd
FALSE	evaluated 484 times by 1 test Evaluated by: dd

61-545

1572

&& (skip_records

skip_records	Description
TRUE	evaluated 21 times by 1 test Evaluated by: dd
FALSE	evaluated 40 times by 1 test Evaluated by: dd

21-40

1573

|| (0 < max_records && max_records < (uintmax_t) -1)

0 < max_records	Description
TRUE	evaluated 36 times by 1 test Evaluated by: dd
FALSE	evaluated 4 times by 1 test Evaluated by: dd

max_records < (uintmax_t) -1	Description
TRUE	evaluated 7 times by 1 test Evaluated by: dd
FALSE	evaluated 29 times by 1 test Evaluated by: dd

4-36

1574

|| (input_flags | output_flags) & O_DIRECT));

(input_flags \|...lags) & 040000	Description
TRUE	evaluated 2 times by 1 test Evaluated by: dd
FALSE	evaluated 31 times by 1 test Evaluated by: dd

2-31

1575 -

1576

iread_fnc = ((input_flags & O_FULLBLOCK)

(input_flags & O_FULLBLOCK)	Description
TRUE	evaluated 493 times by 1 test Evaluated by: dd
FALSE	evaluated 136 times by 1 test Evaluated by: dd

136-493

1577 ? iread_fullblock -

1578 : iread); -

1579 input_flags &= ~O_FULLBLOCK; -

1580 -

1581

if (multiple_bits_set (conversions_mask & (C_ASCII | C_EBCDIC | C_IBM)))

multiple_bits_...CDIC \| C_IBM))	Description
TRUE	never evaluated
FALSE	evaluated 629 times by 1 test Evaluated by: dd

0-629

1582

die (EXIT_FAILURE, 0, _("cannot combine any two of {ascii,ebcdic,ibm}"));

never executed:

((!!sizeof (struct { _Static_assert ( 1 , "verify_expr (" "1" ", " "(error (1, 0, dcgettext (((void *)0), \"cannot combine any two of {ascii,ebcdic,ibm}\", 5)), assume (false))" ")"); int _gl_dummy; })) ? ((nl_error ( 1 , 0, dcgettext (((void *)0), "cannot combine any two of {ascii,ebcdic,ibm}" , 5) ), (( 0 ) ? (void) 0 : __builtin_unreachable ()))) : ((nl_error ( 1 , 0, dcgettext (((void *)0), "cannot combine any two of {ascii,ebcdic,ibm}" , 5) ), (( 0 ) ? (void) 0 : __builtin_unreachable ()))));

1583

if (multiple_bits_set (conversions_mask & (C_BLOCK | C_UNBLOCK)))

multiple_bits_... \| C_UNBLOCK))	Description
TRUE	never evaluated
FALSE	evaluated 629 times by 1 test Evaluated by: dd

0-629

1584

die (EXIT_FAILURE, 0, _("cannot combine block and unblock"));

never executed:

((!!sizeof (struct { _Static_assert ( 1 , "verify_expr (" "1" ", " "(error (1, 0, dcgettext (((void *)0), \"cannot combine block and unblock\", 5)), assume (false))" ")"); int _gl_dummy; })) ? ((nl_error ( 1 , 0, dcgettext (((void *)0), "cannot combine block and unblock" , 5) ), (( 0 ) ? (void) 0 : __builtin_unreachable ()))) : ((nl_error ( 1 , 0, dcgettext (((void *)0), "cannot combine block and unblock" , 5) ), (( 0 ) ? (void) 0 : __builtin_unreachable ()))));

1585

if (multiple_bits_set (conversions_mask & (C_LCASE | C_UCASE)))

multiple_bits_...SE \| C_UCASE))	Description
TRUE	never evaluated
FALSE	evaluated 629 times by 1 test Evaluated by: dd

0-629

1586

die (EXIT_FAILURE, 0, _("cannot combine lcase and ucase"));

never executed:

((!!sizeof (struct { _Static_assert ( 1 , "verify_expr (" "1" ", " "(error (1, 0, dcgettext (((void *)0), \"cannot combine lcase and ucase\", 5)), assume (false))" ")"); int _gl_dummy; })) ? ((nl_error ( 1 , 0, dcgettext (((void *)0), "cannot combine lcase and ucase" , 5) ), (( 0 ) ? (void) 0 : __builtin_unreachable ()))) : ((nl_error ( 1 , 0, dcgettext (((void *)0), "cannot combine lcase and ucase" , 5) ), (( 0 ) ? (void) 0 : __builtin_unreachable ()))));

1587

if (multiple_bits_set (conversions_mask & (C_EXCL | C_NOCREAT)))

multiple_bits_... \| C_NOCREAT))	Description
TRUE	never evaluated
FALSE	evaluated 629 times by 1 test Evaluated by: dd

0-629

1588

die (EXIT_FAILURE, 0, _("cannot combine excl and nocreat"));

never executed:

((!!sizeof (struct { _Static_assert ( 1 , "verify_expr (" "1" ", " "(error (1, 0, dcgettext (((void *)0), \"cannot combine excl and nocreat\", 5)), assume (false))" ")"); int _gl_dummy; })) ? ((nl_error ( 1 , 0, dcgettext (((void *)0), "cannot combine excl and nocreat" , 5) ), (( 0 ) ? (void) 0 : __builtin_unreachable ()))) : ((nl_error ( 1 , 0, dcgettext (((void *)0), "cannot combine excl and nocreat" , 5) ), (( 0 ) ? (void) 0 : __builtin_unreachable ()))));

1589

if (multiple_bits_set (input_flags & (O_DIRECT | O_NOCACHE))

multiple_bits_... \| O_NOCACHE))	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	evaluated 628 times by 1 test Evaluated by: dd

1-628

1590

|| multiple_bits_set (output_flags & (O_DIRECT | O_NOCACHE)))

multiple_bits_... \| O_NOCACHE))	Description
TRUE	never evaluated
FALSE	evaluated 628 times by 1 test Evaluated by: dd

0-628

1591

die (EXIT_FAILURE, 0, _("cannot combine direct and nocache"));

executed 1 time by 1 test:

((!!sizeof (struct { _Static_assert ( 1 , "verify_expr (" "1" ", " "(error (1, 0, dcgettext (((void *)0), \"cannot combine direct and nocache\", 5)), assume (false))" ")"); int _gl_dummy; })) ? ((nl_error ( 1 , 0, dcgettext (((void *)0), "cannot combine direct and nocache" , 5) ), (( 0 ) ? (void) 0 : __builtin_unreachable ()))) : ((nl_error ( 1 , 0, dcgettext (((void *)0), "cannot combine direct and nocache" , 5) ), (( 0 ) ? (void) 0 : __builtin_unreachable ()))));

Executed by:

1592 -

1593

if (input_flags & O_NOCACHE)

input_flags & O_NOCACHE	Description
TRUE	evaluated 11 times by 1 test Evaluated by: dd
FALSE	evaluated 617 times by 1 test Evaluated by: dd

11-617

1594 { -

1595 i_nocache = true; -

1596

i_nocache_eof = (max_records == 0 && max_bytes == 0);

max_records == 0	Description
TRUE	evaluated 4 times by 1 test Evaluated by: dd
FALSE	evaluated 7 times by 1 test Evaluated by: dd

max_bytes == 0	Description
TRUE	evaluated 4 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-7

1597 input_flags &= ~O_NOCACHE; -

1598

}

executed 11 times by 1 test: end of block

Executed by:

1599

if (output_flags & O_NOCACHE)

output_flags & O_NOCACHE	Description
TRUE	evaluated 5 times by 1 test Evaluated by: dd
FALSE	evaluated 623 times by 1 test Evaluated by: dd

5-623

1600 { -

1601 o_nocache = true; -

1602

o_nocache_eof = (max_records == 0 && max_bytes == 0);

max_records == 0	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	evaluated 4 times by 1 test Evaluated by: dd

max_bytes == 0	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	never evaluated

0-4

1603 output_flags &= ~O_NOCACHE; -

1604

}

executed 5 times by 1 test: end of block

Executed by:

1605

}

executed 628 times by 1 test: end of block

Executed by:

628

1606 -

1607 /* Fix up translation table. */ -

1608 -

1609 static void -

1610 apply_translations (void) -

1611 { -

1612 int i; -

1613 -

1614

if (conversions_mask & C_ASCII)

conversions_mask & C_ASCII	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	evaluated 627 times by 1 test Evaluated by: dd

1-627

1615

translate_charset (ebcdic_to_ascii);

executed 1 time by 1 test: translate_charset (ebcdic_to_ascii);

Executed by:

1616 -

1617

if (conversions_mask & C_UCASE)

conversions_mask & C_UCASE	Description
TRUE	never evaluated
FALSE	evaluated 628 times by 1 test Evaluated by: dd

0-628

1618 { -

1619

for (i = 0; i < 256; i++)

i < 256	Description
TRUE	never evaluated
FALSE	never evaluated

1620

trans_table[i] = toupper (trans_table[i]);

never executed:

trans_table[i] = (__extension__ ({ int __res; if (sizeof ( trans_table[i] ) > 1) { if (__builtin_constant_p ( trans_table[i] )) { int __c = ( trans_table[i] ); __res = __c < -128 || __c > 255 ? __c : (*__ctype_toupper_loc ())[__c]; } else __res = toupper ( trans_table[i] ); } else __res = (*__ctype_toupper_loc ())[(int) ( trans_table[i] )]; __res; })) ;

never executed: end of block

never executed: __res = toupper ( trans_table[i] );

never executed: __res = (*__ctype_toupper_loc ())[(int) ( trans_table[i] )];

sizeof ( trans_table[i] ) > 1	Description
TRUE	never evaluated
FALSE	never evaluated

__builtin_cons...ans_table[i] )	Description
TRUE	never evaluated
FALSE	never evaluated

__c < -128	Description
TRUE	never evaluated
FALSE	never evaluated

__c > 255	Description
TRUE	never evaluated
FALSE	never evaluated

1621 translation_needed = true; -

1622

}

never executed: end of block

1623

else if (conversions_mask & C_LCASE)

conversions_mask & C_LCASE	Description
TRUE	never evaluated
FALSE	evaluated 628 times by 1 test Evaluated by: dd

0-628

1624 { -

1625

for (i = 0; i < 256; i++)

i < 256	Description
TRUE	never evaluated
FALSE	never evaluated

1626

trans_table[i] = tolower (trans_table[i]);

never executed:

trans_table[i] = (__extension__ ({ int __res; if (sizeof ( trans_table[i] ) > 1) { if (__builtin_constant_p ( trans_table[i] )) { int __c = ( trans_table[i] ); __res = __c < -128 || __c > 255 ? __c : (*__ctype_tolower_loc ())[__c]; } else __res = tolower ( trans_table[i] ); } else __res = (*__ctype_tolower_loc ())[(int) ( trans_table[i] )]; __res; })) ;

never executed: end of block

never executed: __res = tolower ( trans_table[i] );

never executed: __res = (*__ctype_tolower_loc ())[(int) ( trans_table[i] )];

sizeof ( trans_table[i] ) > 1	Description
TRUE	never evaluated
FALSE	never evaluated

__builtin_cons...ans_table[i] )	Description
TRUE	never evaluated
FALSE	never evaluated

__c < -128	Description
TRUE	never evaluated
FALSE	never evaluated

__c > 255	Description
TRUE	never evaluated
FALSE	never evaluated

1627 translation_needed = true; -

1628

}

never executed: end of block

1629 -

1630

if (conversions_mask & C_EBCDIC)

conversions_mask & C_EBCDIC	Description
TRUE	never evaluated
FALSE	evaluated 628 times by 1 test Evaluated by: dd

0-628

1631 { -

1632 translate_charset (ascii_to_ebcdic); -

1633 newline_character = ascii_to_ebcdic['\n']; -

1634 space_character = ascii_to_ebcdic[' ']; -

1635

}

never executed: end of block

1636

else if (conversions_mask & C_IBM)

conversions_mask & C_IBM	Description
TRUE	never evaluated
FALSE	evaluated 628 times by 1 test Evaluated by: dd

0-628

1637 { -

1638 translate_charset (ascii_to_ibm); -

1639 newline_character = ascii_to_ibm['\n']; -

1640 space_character = ascii_to_ibm[' ']; -

1641

}

never executed: end of block

1642

}

executed 628 times by 1 test: end of block

Executed by:

628

1643 -

1644 /* Apply the character-set translations specified by the user -

1645 to the NREAD bytes in BUF. */ -

1646 -

1647 static void -

1648 translate_buffer (char *buf, size_t nread) -

1649 { -

1650 size_t i; -

1651 char *cp; -

1652

for (i = nread, cp = buf; i; i--, cp++)

i	Description
TRUE	evaluated 264 times by 1 test Evaluated by: dd
FALSE	evaluated 1 time by 1 test Evaluated by: dd

1-264

1653

*cp = trans_table[to_uchar (*cp)];

executed 264 times by 1 test: *cp = trans_table[to_uchar (*cp)];

Executed by:

264

1654

}

executed 1 time by 1 test: end of block

Executed by:

1655 -

1656 /* If true, the last char from the previous call to 'swab_buffer' -

1657 is saved in 'saved_char'. */ -

1658 static bool char_is_saved = false; -

1659 -

1660 /* Odd char from previous call. */ -

1661 static char saved_char; -

1662 -

1663 /* Swap NREAD bytes in BUF, plus possibly an initial char from the -

1664 previous call. If NREAD is odd, save the last char for the -

1665 next call. Return the new start of the BUF buffer. */ -

1666 -

1667 static char * -

1668 swab_buffer (char *buf, size_t *nread) -

1669 { -

1670 char *bufstart = buf; -

1671 -

1672 /* Is a char left from last time? */ -

1673

if (char_is_saved)

char_is_saved	Description
TRUE	never evaluated
FALSE	evaluated 1 time by 1 test Evaluated by: dd

0-1

1674 { -

1675 *--bufstart = saved_char; -

1676 (*nread)++; -

1677 char_is_saved = false; -

1678

}

never executed: end of block

1679 -

1680

if (*nread & 1)

*nread & 1	Description
TRUE	never evaluated
FALSE	evaluated 1 time by 1 test Evaluated by: dd

0-1

1681 { -

1682 /* An odd number of chars are in the buffer. */ -

1683 saved_char = bufstart[--*nread]; -

1684 char_is_saved = true; -

1685

}

never executed: end of block

1686 -

1687 /* Do the byte-swapping by moving every second character two -

1688 positions toward the end, working from the end of the buffer -

1689 toward the beginning. This way we only move half of the data. */ -

1690 -

1691 char *cp = bufstart + *nread; /* Start one char past the last. */ -

1692

for (size_t i = *nread / 2; i; i--, cp -= 2)

i	Description
TRUE	evaluated 7 times by 1 test Evaluated by: dd
FALSE	evaluated 1 time by 1 test Evaluated by: dd

1-7

1693

*cp = *(cp - 2);

executed 7 times by 1 test: *cp = *(cp - 2);

Executed by:

1694 -

1695

return ++bufstart;

executed 1 time by 1 test: return ++bufstart;

Executed by:

1696 } -

1697 -

1698 /* Add OFFSET to the input offset, setting the overflow flag if -

1699 necessary. */ -

1700 -

1701 static void -

1702 advance_input_offset (uintmax_t offset) -

1703 { -

1704 input_offset += offset; -

1705

if (input_offset < offset)

input_offset < offset	Description
TRUE	never evaluated
FALSE	evaluated 2944 times by 1 test Evaluated by: dd

0-2944

1706

input_offset_overflow = true;

never executed: input_offset_overflow = 1 ;

1707

}

executed 2944 times by 1 test: end of block

Executed by:

2944

1708 -

1709 /* This is a wrapper for lseek. It detects and warns about a kernel -

1710 bug that makes lseek a no-op for tape devices, even though the kernel -

1711 lseek return value suggests that the function succeeded. -

1712 -

1713 The parameters are the same as those of the lseek function, but -

1714 with the addition of FILENAME, the name of the file associated with -

1715 descriptor FDESC. The file name is used solely in the warning that's -

1716 printed when the bug is detected. Return the same value that lseek -

1717 would have returned, but when the lseek bug is detected, return -1 -

1718 to indicate that lseek failed. -

1719 -

1720 The offending behavior has been confirmed with an Exabyte SCSI tape -

1721 drive accessed via /dev/nst0 on both Linux 2.2.17 and 2.4.16 kernels. */ -

1722 -

1723 #if defined __linux__ && HAVE_SYS_MTIO_H -

1724 -

1725 # include <sys/mtio.h> -

1726 -

1727 # define MT_SAME_POSITION(P, Q) \ -

1728 ((P).mt_resid == (Q).mt_resid \ -

1729 && (P).mt_fileno == (Q).mt_fileno \ -

1730 && (P).mt_blkno == (Q).mt_blkno) -

1731 -

1732 static off_t -

1733 skip_via_lseek (char const *filename, int fdesc, off_t offset, int whence) -

1734 { -

1735 struct mtget s1; -

1736 struct mtget s2; -

1737 bool got_original_tape_position = (ioctl (fdesc, MTIOCGET, &s1) == 0); -

1738 /* known bad device type */ -

1739 /* && s.mt_type == MT_ISSCSI2 */ -

1740 -

1741 off_t new_position = lseek (fdesc, offset, whence); -

1742

if (0 <= new_position

0 <= new_position	Description
TRUE	evaluated 40 times by 1 test Evaluated by: dd
FALSE	evaluated 21 times by 1 test Evaluated by: dd

21-40

1743

&& got_original_tape_position

got_original_tape_position	Description
TRUE	never evaluated
FALSE	evaluated 40 times by 1 test Evaluated by: dd

0-40

1744

&& ioctl (fdesc, MTIOCGET, &s2) == 0

ioctl (fdesc, ...)) , &s2) == 0	Description
TRUE	never evaluated
FALSE	never evaluated

1745

&& MT_SAME_POSITION (s1, s2))

(s1).mt_resid == (s2).mt_resid	Description
TRUE	never evaluated
FALSE	never evaluated

(s1).mt_fileno...(s2).mt_fileno	Description
TRUE	never evaluated
FALSE	never evaluated

(s1).mt_blkno == (s2).mt_blkno	Description
TRUE	never evaluated
FALSE	never evaluated

1746 { -

1747

if (status_level != STATUS_NONE)

status_level != STATUS_NONE	Description
TRUE	never evaluated
FALSE	never evaluated

1748

error (0, 0, _("warning: working around lseek kernel bug for file "

never executed:

nl_error (0, 0, dcgettext (((void *)0), "warning: working around lseek kernel bug for file " "(%s)\n of mt_type=0x%0lx -- " "see <sys/mtio.h> for the list of types" , 5) , filename, s2.mt_type + 0Lu);

1749

"(%s)\n of mt_type=0x%0lx -- "

never executed:

nl_error (0, 0, dcgettext (((void *)0), "warning: working around lseek kernel bug for file " "(%s)\n of mt_type=0x%0lx -- " "see <sys/mtio.h> for the list of types" , 5) , filename, s2.mt_type + 0Lu);

1750

"see <sys/mtio.h> for the list of types"),

never executed:

nl_error (0, 0, dcgettext (((void *)0), "warning: working around lseek kernel bug for file " "(%s)\n of mt_type=0x%0lx -- " "see <sys/mtio.h> for the list of types" , 5) , filename, s2.mt_type + 0Lu);

1751

filename, s2.mt_type + 0Lu);

never executed:

nl_error (0, 0, dcgettext (((void *)0), "warning: working around lseek kernel bug for file " "(%s)\n of mt_type=0x%0lx -- " "see <sys/mtio.h> for the list of types" , 5) , filename, s2.mt_type + 0Lu);

1752 errno = 0; -

1753 new_position = -1; -

1754

}

never executed: end of block

1755 -

1756

return new_position;

executed 61 times by 1 test: return new_position;

Executed by:

1757 } -

1758 #else -

1759 # define skip_via_lseek(Filename, Fd, Offset, Whence) lseek (Fd, Offset, Whence) -

1760 #endif -

1761 -

1762 /* Throw away RECORDS blocks of BLOCKSIZE bytes plus BYTES bytes on -

1763 file descriptor FDESC, which is open with read permission for FILE. -

1764 Store up to BLOCKSIZE bytes of the data at a time in IBUF or OBUF, if -

1765 necessary. RECORDS or BYTES must be nonzero. If FDESC is -

1766 STDIN_FILENO, advance the input offset. Return the number of -

1767 records remaining, i.e., that were not skipped because EOF was -

1768 reached. If FDESC is STDOUT_FILENO, on return, BYTES is the -

1769 remaining bytes in addition to the remaining records. */ -

1770 -

1771 static uintmax_t -

1772 skip (int fdesc, char const *file, uintmax_t records, size_t blocksize, -

1773 size_t *bytes) -

1774 { -

1775 uintmax_t offset = records * blocksize + *bytes; -

1776 -

1777 /* Try lseek and if an error indicates it was an inappropriate operation -- -

1778 or if the file offset is not representable as an off_t -- -

1779 fall back on using read. */ -

1780 -

1781 errno = 0; -

1782

if (records <= OFF_T_MAX / blocksize

records <= ((o...)) / blocksize	Description
TRUE	evaluated 49 times by 1 test Evaluated by: dd
FALSE	evaluated 1 time by 1 test Evaluated by: dd

1-49

1783

&& 0 <= skip_via_lseek (file, fdesc, offset, SEEK_CUR))

0 <= skip_via_...c, offset, 1 )	Description
TRUE	evaluated 38 times by 1 test Evaluated by: dd
FALSE	evaluated 11 times by 1 test Evaluated by: dd

11-38

1784 { -

1785

if (fdesc == STDIN_FILENO)

fdesc == 0	Description
TRUE	evaluated 18 times by 1 test Evaluated by: dd
FALSE	evaluated 20 times by 1 test Evaluated by: dd

18-20

1786 { -

1787 struct stat st; -

1788

if (fstat (STDIN_FILENO, &st) != 0)

fstat ( 0 , &st) != 0	Description
TRUE	never evaluated
FALSE	evaluated 18 times by 1 test Evaluated by: dd

0-18

1789

die (EXIT_FAILURE, errno, _("cannot fstat %s"), quoteaf (file));

never executed:

((!!sizeof (struct { _Static_assert ( 1 , "verify_expr (" "1" ", " "(error (1, (*__errno_location ()), dcgettext (((void *)0), \"cannot fstat %s\", 5), quotearg_style (shell_escape_always_quoting_style, file)), assume (false))" ")"); int _gl_dummy; })) ? ...le)), (( 0 ) ? (void) 0 : __builtin_unreachable ()))) : ((nl_error ( 1 , (*__errno_location ()) , dcgettext (((void *)0), "cannot fstat %s" , 5) , quotearg_style (shell_escape_always_quoting_style, file)), (( 0 ) ? (void) 0 : __builtin_unreachable ()))));

1790

if (usable_st_size (&st) && st.st_size < input_offset + offset)

usable_st_size (&st)	Description
TRUE	evaluated 18 times by 1 test Evaluated by: dd
FALSE	never evaluated

st.st_size < i...ffset + offset	Description
TRUE	evaluated 5 times by 1 test Evaluated by: dd
FALSE	evaluated 13 times by 1 test Evaluated by: dd

0-18

1791 { -

1792 /* When skipping past EOF, return the number of _full_ blocks -

1793 * that are not skipped, and set offset to EOF, so the caller -

1794 * can determine the requested skip was not satisfied. */ -

1795 records = ( offset - st.st_size ) / blocksize; -

1796 offset = st.st_size - input_offset; -

1797

}

executed 5 times by 1 test: end of block

Executed by:

1798 else -

1799

records = 0;

executed 13 times by 1 test: records = 0;

Executed by:

1800 advance_input_offset (offset); -

1801

}

executed 18 times by 1 test: end of block

Executed by:

1802 else -

1803 { -

1804 records = 0; -

1805 *bytes = 0; -

1806

}

executed 20 times by 1 test: end of block

Executed by:

1807

return records;

executed 38 times by 1 test: return records;

Executed by:

1808 } -

1809 else -

1810 { -

1811 int lseek_errno = errno; -

1812 -

1813 /* The seek request may have failed above if it was too big -

1814 (> device size, > max file size, etc.) -

1815 Or it may not have been done at all (> OFF_T_MAX). -

1816 Therefore try to seek to the end of the file, -

1817 to avoid redundant reading. */ -

1818

if ((skip_via_lseek (file, fdesc, 0, SEEK_END)) >= 0)

(skip_via_lsee..., 0, 2 )) >= 0	Description
TRUE	evaluated 2 times by 1 test Evaluated by: dd
FALSE	evaluated 10 times by 1 test Evaluated by: dd

2-10

1819 { -

1820 /* File is seekable, and we're at the end of it, and -

1821 size <= OFF_T_MAX. So there's no point using read to advance. */ -

1822 -

1823

if (!lseek_errno)

!lseek_errno	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	evaluated 1 time by 1 test Evaluated by: dd

1824 { -

1825 /* The original seek was not attempted as offset > OFF_T_MAX. -

1826 We should error for write as can't get to the desired -

1827 location, even if OFF_T_MAX < max file size. -

1828 For read we're not going to read any data anyway, -

1829 so we should error for consistency. -

1830 It would be nice to not error for /dev/{zero,null} -

1831 for any offset, but that's not a significant issue. */ -

1832 lseek_errno = EOVERFLOW; -

1833

}

executed 1 time by 1 test: end of block

Executed by:

1834 -

1835

if (fdesc == STDIN_FILENO)

fdesc == 0	Description
TRUE	evaluated 2 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-2

1836

error (0, lseek_errno, _("%s: cannot skip"), quotef (file));

executed 2 times by 1 test:

nl_error (0, lseek_errno, dcgettext (((void *)0), "%s: cannot skip" , 5) , quotearg_n_style_colon (0, shell_escape_quoting_style, file));

Executed by:

1837 else -

1838

error (0, lseek_errno, _("%s: cannot seek"), quotef (file));

never executed:

nl_error (0, lseek_errno, dcgettext (((void *)0), "%s: cannot seek" , 5) , quotearg_n_style_colon (0, shell_escape_quoting_style, file));

1839 /* If the file has a specific size and we've asked -

1840 to skip/seek beyond the max allowable, then quit. */ -

1841 quit (EXIT_FAILURE); -

1842

}

never executed: end of block

1843 /* else file_size && offset > OFF_T_MAX or file ! seekable */ -

1844 -

1845 char *buf; -

1846

if (fdesc == STDIN_FILENO)

fdesc == 0	Description
TRUE	evaluated 7 times by 1 test Evaluated by: dd
FALSE	evaluated 3 times by 1 test Evaluated by: dd

3-7

1847 { -

1848 alloc_ibuf (); -

1849 buf = ibuf; -

1850

}

executed 5 times by 1 test: end of block

Executed by:

1851 else -

1852 { -

1853 alloc_obuf (); -

1854 buf = obuf; -

1855

}

executed 1 time by 1 test: end of block

Executed by:

1856 -

1857 do -

1858 { -

1859 ssize_t nread = iread_fnc (fdesc, buf, records ? blocksize : *bytes); -

1860

if (nread < 0)

nread < 0	Description
TRUE	never evaluated
FALSE	evaluated 15 times by 1 test Evaluated by: dd

0-15

1861 { -

1862

if (fdesc == STDIN_FILENO)

fdesc == 0	Description
TRUE	never evaluated
FALSE	never evaluated

1863 { -

1864 error (0, errno, _("error reading %s"), quoteaf (file)); -

1865

if (conversions_mask & C_NOERROR)

conversions_mask & C_NOERROR	Description
TRUE	never evaluated
FALSE	never evaluated

1866

print_stats ();

never executed: print_stats ();

1867

}

never executed: end of block

1868 else -

1869

error (0, lseek_errno, _("%s: cannot seek"), quotef (file));

never executed:

nl_error (0, lseek_errno, dcgettext (((void *)0), "%s: cannot seek" , 5) , quotearg_n_style_colon (0, shell_escape_quoting_style, file));

1870 quit (EXIT_FAILURE); -

1871

}

never executed: end of block

1872

else if (nread == 0)

nread == 0	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	evaluated 14 times by 1 test Evaluated by: dd

1-14

1873

break;

executed 1 time by 1 test: break;

Executed by:

1874

else if (fdesc == STDIN_FILENO)

fdesc == 0	Description
TRUE	evaluated 13 times by 1 test Evaluated by: dd
FALSE	evaluated 1 time by 1 test Evaluated by: dd

1-13

1875

advance_input_offset (nread);

executed 13 times by 1 test: advance_input_offset (nread);

Executed by:

1876 -

1877

if (records != 0)

records != 0	Description
TRUE	evaluated 14 times by 1 test Evaluated by: dd
FALSE	never evaluated

0-14

1878

records--;

executed 14 times by 1 test: records--;

Executed by:

1879 else -

1880

*bytes = 0;

never executed: *bytes = 0;

1881 } -

1882

while (records || *bytes);

records	Description
TRUE	evaluated 9 times by 1 test Evaluated by: dd
FALSE	evaluated 5 times by 1 test Evaluated by: dd

*bytes	Description
TRUE	never evaluated
FALSE	evaluated 5 times by 1 test Evaluated by: dd

0-9

1883 -

1884

return records;

executed 6 times by 1 test: return records;

Executed by:

1885 } -

1886 } -

1887 -

1888 /* Advance the input by NBYTES if possible, after a read error. -

1889 The input file offset may or may not have advanced after the failed -

1890 read; adjust it to point just after the bad record regardless. -

1891 Return true if successful, or if the input is already known to not -

1892 be seekable. */ -

1893 -

1894 static bool -

1895 advance_input_after_read_error (size_t nbytes) -

1896 { -

1897

if (! input_seekable)

! input_seekable	Description
TRUE	never evaluated
FALSE	never evaluated

1898 { -

1899

if (input_seek_errno == ESPIPE)

input_seek_errno == 29	Description
TRUE	never evaluated
FALSE	never evaluated

1900

return true;

never executed: return 1 ;

1901 errno = input_seek_errno; -

1902

}

never executed: end of block

1903 else -

1904 { -

1905 off_t offset; -

1906 advance_input_offset (nbytes); -

1907 input_offset_overflow |= (OFF_T_MAX < input_offset); -

1908

if (input_offset_overflow)

input_offset_overflow	Description
TRUE	never evaluated
FALSE	never evaluated

1909 { -

1910 error (0, 0, _("offset overflow while reading file %s"), -

1911 quoteaf (input_file)); -

1912

return false;

never executed: return 0 ;

1913 } -

1914 offset = lseek (STDIN_FILENO, 0, SEEK_CUR); -

1915

if (0 <= offset)

0 <= offset	Description
TRUE	never evaluated
FALSE	never evaluated

1916 { -

1917 off_t diff; -

1918

if (offset == input_offset)

offset == input_offset	Description
TRUE	never evaluated
FALSE	never evaluated

1919

return true;

never executed: return 1 ;

1920 diff = input_offset - offset; -

1921

if (! (0 <= diff && diff <= nbytes) && status_level != STATUS_NONE)

0 <= diff	Description
TRUE	never evaluated
FALSE	never evaluated

diff <= nbytes	Description
TRUE	never evaluated
FALSE	never evaluated

status_level != STATUS_NONE	Description
TRUE	never evaluated
FALSE	never evaluated

1922

error (0, 0, _("warning: invalid file offset after failed read"));

never executed: nl_error (0, 0, dcgettext (((void *)0), "warning: invalid file offset after failed read" , 5) );

1923

if (0 <= skip_via_lseek (input_file, STDIN_FILENO, diff, SEEK_CUR))

0 <= skip_via_... 0 , diff, 1 )	Description
TRUE	never evaluated
FALSE	never evaluated

1924

return true;

never executed: return 1 ;

1925

if (errno == 0)

(*__errno_location ()) == 0	Description
TRUE	never evaluated
FALSE	never evaluated

1926

error (0, 0, _("cannot work around kernel bug after all"));

never executed: nl_error (0, 0, dcgettext (((void *)0), "cannot work around kernel bug after all" , 5) );

1927

}

never executed: end of block

1928

}

never executed: end of block

1929 -

1930 error (0, errno, _("%s: cannot seek"), quotef (input_file)); -

1931

return false;

never executed: return 0 ;

1932 } -

1933 -

1934 /* Copy NREAD bytes of BUF, with no conversions. */ -

1935 -

1936 static void -

1937 copy_simple (char const *buf, size_t nread) -

1938 { -

1939 const char *start = buf; /* First uncopied char in BUF. */ -

1940 -

1941 do -

1942 { -

1943

size_t nfree = MIN (nread, output_blocksize - oc);

(( nread )<( o...cksize - oc ))	Description
TRUE	evaluated 25 times by 1 test Evaluated by: dd
FALSE	evaluated 760 times by 1 test Evaluated by: dd

25-760

1944 -

1945 memcpy (obuf + oc, start, nfree); -

1946 -

1947 nread -= nfree; /* Update the number of bytes left to copy. */ -

1948 start += nfree; -

1949 oc += nfree; -

1950

if (oc >= output_blocksize)

oc >= output_blocksize	Description
TRUE	evaluated 760 times by 1 test Evaluated by: dd
FALSE	evaluated 25 times by 1 test Evaluated by: dd

25-760

1951

write_output ();

executed 760 times by 1 test: write_output ();

Executed by:

760

1952

}

executed 785 times by 1 test: end of block

Executed by:

785

1953

while (nread != 0);

nread != 0	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	evaluated 784 times by 1 test Evaluated by: dd

1-784

1954

}

executed 784 times by 1 test: end of block

Executed by:

784

1955 -

1956 /* Copy NREAD bytes of BUF, doing conv=block -

1957 (pad newline-terminated records to 'conversion_blocksize', -

1958 replacing the newline with trailing spaces). */ -

1959 -

1960 static void -

1961 copy_with_block (char const *buf, size_t nread) -

1962 { -

1963

for (size_t i = nread; i; i--, buf++)

i	Description
TRUE	evaluated 30 times by 1 test Evaluated by: dd
FALSE	evaluated 3 times by 1 test Evaluated by: dd

3-30

1964 { -

1965

if (*buf == newline_character)

*buf == newline_character	Description
TRUE	evaluated 2 times by 1 test Evaluated by: dd
FALSE	evaluated 28 times by 1 test Evaluated by: dd

2-28

1966 { -

1967

if (col < conversion_blocksize)

col < conversion_blocksize	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	evaluated 1 time by 1 test Evaluated by: dd

1968 { -

1969 size_t j; -

1970

for (j = col; j < conversion_blocksize; j++)

j < conversion_blocksize	Description
TRUE	evaluated 2 times by 1 test Evaluated by: dd
FALSE	evaluated 1 time by 1 test Evaluated by: dd

1-2

1971

output_char (space_character);

never executed: write_output ();

executed 2 times by 1 test: end of block

Executed by:

oc >= output_blocksize	Description
TRUE	never evaluated
FALSE	evaluated 2 times by 1 test Evaluated by: dd

0-2

1972

}

executed 1 time by 1 test: end of block

Executed by:

1973 col = 0; -

1974

}

executed 2 times by 1 test: end of block

Executed by:

1975 else -

1976 { -

1977

if (col == conversion_blocksize)

col == conversion_blocksize	Description
TRUE	evaluated 1 time by 1 test Evaluated by: dd
FALSE	evaluated 27 times by 1 test Evaluated by: dd

1-27

1978

r_truncate++;

executed 1 time by 1 test: r_truncate++;

Executed by:

1979

else if (col < conversion_blocksize)

col < conversion_blocksize	Description
TRUE	evaluated 26 times by 1 test Evaluated by: dd
FALSE	evaluated 1 time by 1 test Evaluated by: dd

1-26

1980

output_char (*buf);

never executed: write_output ();

executed 26 times by 1 test: end of block

Executed by:

oc >= output_blocksize	Description
TRUE	never evaluated
FALSE	evaluated 26 times by 1 test Evaluated by: dd

0-26

1981 col++; -

1982

}

executed 28 times by 1 test: end of block

Executed by:

1983 } -

1984

}

executed 3 times by 1 test: end of block

Executed by:

1985 -

1986 /* Copy NREAD bytes of BUF, doing conv=unblock -

1987 (replace trailing spaces in 'conversion_blocksize'-sized records -

1988 with a newline). */ -

1989 -

1990 static void -

1991 copy_with_unblock (char const *buf, size_t nread) -

1992 { -

1993 static size_t pending_spaces = 0; -

1994 -

1995

for (size_t i = 0; i < nread; i++)

i < nread	Description
TRUE	evaluated 377 times by 1 test Evaluated by: dd
FALSE	evaluated 12 times by 1 test Evaluated by: dd

12-377

1996 { -

1997 char c = buf[i]; -

1998 -

1999

if (col++ >= conversion_blocksize)

col++ >= conversion_blocksize	Description
TRUE	evaluated 72 times by 1 test Evaluated by: dd
FALSE	evaluated 305 times by 1 test Evaluated by: dd

72-305

2000 { -

2001 col = pending_spaces = 0; /* Wipe out any pending spaces. */ -

2002 i--; /* Push the char back; get it later. */ -

2003

output_char (newline_character);

never executed: write_output ();

oc >= output_blocksize	Description
TRUE	never evaluated
FALSE	evaluated 72 times by 1 test Evaluated by: dd

0-72

2004

}

executed 72 times by 1 test: end of block

Executed by:

2005

else if (c == space_character)

c == space_character	Description
TRUE	evaluated 21 times by 1 test Evaluated by: dd
FALSE	evaluated 284 times by 1 test Evaluated by: dd

21-284

2006

pending_spaces++;

executed 21 times by 1 test: pending_spaces++;

Executed by: