19 |
|
#include <sys/mman.h> |
20 |
|
#endif |
21 |
|
|
22 |
+ |
static char delims[] = " \t\n\r\f"; |
23 |
+ |
|
24 |
|
#define MAXLEVELS 16 /* max RxC.. block pairs */ |
25 |
|
|
26 |
|
typedef struct { |
31 |
|
|
32 |
|
typedef struct { |
33 |
|
int nw_rec; /* number of words per record */ |
34 |
< |
long nrecs; /* number of records we found */ |
34 |
> |
ssize_t nrecs; /* number of records we found */ |
35 |
|
char *rec[1]; /* record array (extends struct) */ |
36 |
|
} RECINDEX; |
37 |
|
|
38 |
< |
int warnings = 1; /* report warnings? */ |
38 |
> |
int warnings = 1; /* report warnings? */ |
39 |
|
|
40 |
+ |
char *fmtid = NULL; /* format id */ |
41 |
+ |
int comp_size = 0; /* binary bytes/channel */ |
42 |
+ |
int n_comp = 0; /* components/record */ |
43 |
+ |
int ni_columns = 0; /* number of input columns */ |
44 |
+ |
int ni_rows = 0; /* number of input rows */ |
45 |
+ |
int no_columns = 0; /* number of output columns */ |
46 |
+ |
int no_rows = 0; /* number of output rows */ |
47 |
+ |
int transpose = 0; /* transpose rows & cols? */ |
48 |
+ |
int i_header = 1; /* input header? */ |
49 |
+ |
int o_header = 1; /* output header? */ |
50 |
+ |
int outArray[MAXLEVELS][2]; /* output block nesting */ |
51 |
+ |
int outLevels = 0; /* number of blocking levels */ |
52 |
+ |
int check = 0; /* force data check? */ |
53 |
+ |
|
54 |
|
/* free loaded file */ |
55 |
|
static void |
56 |
|
free_load(MEMLOAD *mp) |
103 |
|
return(mp->len > 0); |
104 |
|
} |
105 |
|
|
106 |
+ |
#if defined(_WIN32) || defined(_WIN64) |
107 |
+ |
/* too difficult to fix this */ |
108 |
+ |
#define load_file load_stream |
109 |
+ |
#else |
110 |
|
/* load a file into memory */ |
111 |
|
static int |
112 |
|
load_file(MEMLOAD *mp, FILE *fp) |
113 |
|
{ |
114 |
|
int fd; |
115 |
|
off_t skip, flen, fpos; |
96 |
– |
|
97 |
– |
#if defined(_WIN32) || defined(_WIN64) |
98 |
– |
/* too difficult to fix this */ |
99 |
– |
return load_stream(mp, fp); |
100 |
– |
#endif |
116 |
|
if (mp == NULL) |
117 |
|
return(-1); |
118 |
|
mp->mapped = NULL; |
127 |
|
return((int)(flen - skip)); |
128 |
|
mp->len = (size_t)(flen - skip); |
129 |
|
#ifdef MAP_FILE |
130 |
< |
if (mp->len > 1L<<20) { /* map file if > 1 MByte */ |
130 |
> |
if (mp->len >= 1L<<20) { /* map file if >= 1 MByte */ |
131 |
|
mp->mapped = mmap(NULL, flen, PROT_READ, MAP_PRIVATE, fd, 0); |
132 |
|
if (mp->mapped != MAP_FAILED) { |
133 |
|
mp->base = (char *)mp->mapped + skip; |
153 |
|
} |
154 |
|
return(1); |
155 |
|
} |
156 |
+ |
#endif |
157 |
|
|
158 |
|
/* free a record index */ |
159 |
|
#define free_records(rp) free(rp) |
199 |
|
break; /* got requisite # words */ |
200 |
|
do { /* else find next word */ |
201 |
|
if (*cp == '\n') { |
202 |
< |
fprintf(stderr, |
187 |
< |
"Unexpected EOL in record!\n"); |
202 |
> |
fputs("Unexpected EOL in record!\n", stderr); |
203 |
|
free_records(rp); |
204 |
|
return(NULL); |
205 |
|
} |
233 |
|
|
234 |
|
/* copy nth record from index to stdout */ |
235 |
|
static int |
236 |
< |
print_record(const RECINDEX *rp, long n) |
236 |
> |
print_record(const RECINDEX *rp, ssize_t n) |
237 |
|
{ |
238 |
|
int words2go = rp->nw_rec; |
239 |
|
char *scp; |
241 |
|
if ((n < 0) | (n >= rp->nrecs)) |
242 |
|
return(0); |
243 |
|
scp = rp->rec[n]; |
244 |
+ |
|
245 |
+ |
if (check && !isfltd(scp, delims)) |
246 |
+ |
goto formerr; |
247 |
|
do { |
248 |
|
putc(*scp++, stdout); |
249 |
|
if (!*scp | isspace(*scp)) { |
254 |
|
if (++scp >= rp->rec[n+1]) |
255 |
|
break; |
256 |
|
while (!*scp | isspace(*scp)); |
257 |
+ |
|
258 |
+ |
if (check && !isfltd(scp, delims)) |
259 |
+ |
goto formerr; |
260 |
|
} |
261 |
|
} while (scp < rp->rec[n+1]); |
262 |
|
/* caller adds record sep. */ |
263 |
|
return(1); |
264 |
+ |
formerr: |
265 |
+ |
fputs("Badly formed number: ", stderr); |
266 |
+ |
while (*scp && !isspace(*scp)) |
267 |
+ |
fputc(*scp++, stderr); |
268 |
+ |
fputc('\n', stderr); |
269 |
+ |
return(0); |
270 |
|
} |
271 |
|
|
272 |
|
/* copy a stream to stdout */ |
308 |
|
return(buf); |
309 |
|
} |
310 |
|
|
284 |
– |
char *fmtid = NULL; /* format id */ |
285 |
– |
int comp_size = 0; /* binary bytes/channel */ |
286 |
– |
int n_comp = 0; /* components/record */ |
287 |
– |
int ni_columns = 0; /* number of input columns */ |
288 |
– |
int ni_rows = 0; /* number of input rows */ |
289 |
– |
int no_columns = 0; /* number of output columns */ |
290 |
– |
int no_rows = 0; /* number of output rows */ |
291 |
– |
int transpose = 0; /* transpose rows & cols? */ |
292 |
– |
int i_header = 1; /* input header? */ |
293 |
– |
int o_header = 1; /* output header? */ |
294 |
– |
int outArray[MAXLEVELS][2]; /* output block nesting */ |
295 |
– |
int outLevels = 0; /* number of blocking levels */ |
296 |
– |
int check = 0; /* force data check? */ |
297 |
– |
|
311 |
|
/* parse RxCx... string */ |
312 |
|
static int |
313 |
|
get_array(const char *spec, int blklvl[][2], int nlvls) |
373 |
|
} |
374 |
|
|
375 |
|
/* call to compute block input position */ |
376 |
< |
static long |
376 |
> |
static ssize_t |
377 |
|
get_block_pos(int r, int c, int blklvl[][2], int nlvls) |
378 |
|
{ |
379 |
< |
long n = 0; |
379 |
> |
ssize_t n = 0; |
380 |
|
|
381 |
|
while (nlvls > 1) { |
382 |
|
int sr = r/blklvl[1][0]; |
392 |
|
} |
393 |
|
|
394 |
|
/* return input offset based on array ordering and transpose option */ |
395 |
< |
static long |
395 |
> |
static ssize_t |
396 |
|
get_input_pos(int r, int c) |
397 |
|
{ |
398 |
< |
long n; |
398 |
> |
ssize_t n; |
399 |
|
|
400 |
|
if (outLevels > 1) { /* block reordering */ |
401 |
|
n = get_block_pos(r, c, outArray, outLevels); |
402 |
|
if (transpose) { |
403 |
|
r = n/ni_rows; |
404 |
|
c = n - r*ni_rows; |
405 |
< |
n = (long)c*ni_columns + r; |
405 |
> |
n = (ssize_t)c*ni_columns + r; |
406 |
|
} |
407 |
|
} else if (transpose) /* transpose only */ |
408 |
< |
n = (long)c*ni_columns + r; |
408 |
> |
n = (ssize_t)c*ni_columns + r; |
409 |
|
else /* XXX should never happen! */ |
410 |
< |
n = (long)r*no_columns + c; |
410 |
> |
n = (ssize_t)r*no_columns + c; |
411 |
|
return(n); |
412 |
|
} |
413 |
|
|
417 |
|
{ |
418 |
|
static const char tabEOL[2] = {'\t','\n'}; |
419 |
|
RECINDEX *rp = NULL; |
420 |
< |
long nrecords; |
420 |
> |
ssize_t nrecords; |
421 |
|
int i, j; |
422 |
|
/* propogate sizes */ |
423 |
|
if (ni_rows <= 0) |
432 |
|
ni_columns = count_columns(rp); |
433 |
|
nrecords = rp->nrecs; |
434 |
|
} else if ((ni_rows > 0) & (ni_columns > 0)) { |
435 |
< |
nrecords = ni_rows*ni_columns; |
435 |
> |
nrecords = (ssize_t)ni_rows*ni_columns; |
436 |
|
if (nrecords > mp->len/(n_comp*comp_size)) { |
437 |
|
fputs("Input too small for specified size and type\n", |
438 |
|
stderr); |
445 |
|
ni_rows = nrecords/ni_columns; |
446 |
|
else if ((ni_columns <= 0) & (ni_rows > 0)) |
447 |
|
ni_columns = nrecords/ni_rows; |
448 |
< |
if (nrecords != ni_rows*ni_columns) |
448 |
> |
if (nrecords != (ssize_t)ni_rows*ni_columns) |
449 |
|
goto badspec; |
450 |
|
if (transpose) { |
451 |
|
if (no_columns <= 0) |
469 |
|
if (o_header) { /* finish header? */ |
470 |
|
printf("NROWS=%d\n", no_rows); |
471 |
|
printf("NCOLS=%d\n", no_columns); |
472 |
+ |
fputformat(fmtid, stdout); |
473 |
|
fputc('\n', stdout); |
474 |
|
} |
475 |
|
/* reorder records */ |
476 |
|
for (i = 0; i < no_rows; i++) { |
477 |
|
for (j = 0; j < no_columns; j++) { |
478 |
< |
long n = get_input_pos(i, j); |
478 |
> |
ssize_t n = get_input_pos(i, j); |
479 |
|
if (n >= nrecords) { |
480 |
|
fputs("Index past end-of-file\n", stderr); |
481 |
|
return(0); |
482 |
|
} |
483 |
|
if (rp != NULL) { /* ASCII output */ |
484 |
< |
print_record(rp, n); |
484 |
> |
if (!print_record(rp, n)) |
485 |
> |
return(0); |
486 |
|
putc(tabEOL[j >= no_columns-1], stdout); |
487 |
|
} else { /* binary output */ |
488 |
|
putbinary((char *)mp->base + (n_comp*comp_size)*n, |
490 |
|
} |
491 |
|
} |
492 |
|
if (ferror(stdout)) { |
493 |
< |
fprintf(stderr, "Error writing to stdout\n"); |
493 |
> |
fputs("Error writing to stdout\n", stderr); |
494 |
|
return(0); |
495 |
|
} |
496 |
|
} |
498 |
|
free_records(rp); |
499 |
|
return(1); |
500 |
|
badspec: |
501 |
< |
fprintf(stderr, "Bad dimension(s)\n"); |
501 |
> |
fputs("Bad dimension(s)\n", stderr); |
502 |
|
return(0); |
503 |
|
} |
504 |
|
|
506 |
|
static int |
507 |
|
do_resize(FILE *fp) |
508 |
|
{ |
509 |
< |
long records2go = ni_rows*ni_columns; |
509 |
> |
ssize_t records2go = ni_rows*ni_columns; |
510 |
|
int columns2go = no_columns; |
511 |
|
char word[256]; |
512 |
|
|
515 |
|
printf("NROWS=%d\n", no_rows); |
516 |
|
if (no_columns > 0) |
517 |
|
printf("NCOLS=%d\n", no_columns); |
518 |
+ |
fputformat(fmtid, stdout); |
519 |
|
fputc('\n', stdout); |
520 |
|
} |
521 |
|
/* sanity checks */ |
523 |
|
(no_columns == ni_columns) & (no_rows == ni_rows)) |
524 |
|
return(output_stream(fp)); /* no-op -- just copy */ |
525 |
|
if (no_columns <= 0) { |
526 |
< |
fprintf(stderr, "Missing -oc specification\n"); |
526 |
> |
fputs("Missing -oc specification\n", stderr); |
527 |
|
return(0); |
528 |
|
} |
529 |
|
if ((records2go <= 0) & (no_rows > 0)) |
543 |
|
break; |
544 |
|
goto done; /* normal EOD */ |
545 |
|
} |
546 |
+ |
if (check && !isfltd(word, delims)) { |
547 |
+ |
fputs("Badly formed number: ", stderr); |
548 |
+ |
fputs(word, stderr); |
549 |
+ |
fputc('\n', stderr); |
550 |
+ |
return(0); |
551 |
+ |
} |
552 |
|
fputs(word, stdout); |
553 |
|
if (n) { /* mid-record? */ |
554 |
|
int c = getc(fp); |
559 |
|
} |
560 |
|
} |
561 |
|
if (n >= 0) { |
562 |
< |
fprintf(stderr, "Incomplete record / unexpected EOF\n"); |
562 |
> |
fputs("Incomplete record / unexpected EOF\n", stderr); |
563 |
|
return(0); |
564 |
|
} |
565 |
|
if (--columns2go <= 0) { /* time to end output row? */ |
570 |
|
} while (--records2go); /* expected EOD? */ |
571 |
|
done: |
572 |
|
if (warnings && columns2go != no_columns) |
573 |
< |
fprintf(stderr, "Warning -- incomplete final row\n"); |
573 |
> |
fputs("Warning -- incomplete final row\n", stderr); |
574 |
|
if (warnings && fget_word(word, fp) != NULL) |
575 |
< |
fprintf(stderr, "Warning -- characters beyond expected EOD\n"); |
575 |
> |
fputs("Warning -- characters beyond expected EOD\n", stderr); |
576 |
|
return(1); |
577 |
|
} |
578 |
|
|
724 |
|
SET_FILE_BINARY(stdin); |
725 |
|
SET_FILE_BINARY(stdout); |
726 |
|
} |
727 |
+ |
#ifdef getc_unlocked /* avoid stupid semaphores */ |
728 |
+ |
flockfile(stdin); |
729 |
+ |
flockfile(stdout); |
730 |
+ |
#endif |
731 |
|
/* check for no-op */ |
732 |
|
if (!transpose & !check & (outLevels <= 1) & (i_header == o_header) && |
733 |
|
(no_columns == ni_columns) & (no_rows == ni_rows)) { |
754 |
|
newheader("RADIANCE", stdout); |
755 |
|
printargs(a, argv, stdout); |
756 |
|
printf("NCOMP=%d\n", n_comp); |
731 |
– |
fputformat(fmtid, stdout); |
757 |
|
} |
758 |
|
if (transpose | check | (outLevels > 1) || (o_header && no_rows <= 0)) { |
759 |
|
MEMLOAD myMem; /* need to map into memory */ |