1 | /*- |
---|
2 | * Copyright (c) 1993 |
---|
3 | * The Regents of the University of California. All rights reserved. |
---|
4 | * |
---|
5 | * Redistribution and use in source and binary forms, with or without |
---|
6 | * modification, are permitted provided that the following conditions |
---|
7 | * are met: |
---|
8 | * 1. Redistributions of source code must retain the above copyright |
---|
9 | * notice, this list of conditions and the following disclaimer. |
---|
10 | * 2. Redistributions in binary form must reproduce the above copyright |
---|
11 | * notice, this list of conditions and the following disclaimer in the |
---|
12 | * documentation and/or other materials provided with the distribution. |
---|
13 | * 3. Neither the name of the University nor the names of its contributors |
---|
14 | * may be used to endorse or promote products derived from this software |
---|
15 | * without specific prior written permission. |
---|
16 | * |
---|
17 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
---|
18 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
---|
19 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
---|
20 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
---|
21 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
---|
22 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
---|
23 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
---|
24 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
---|
25 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
---|
26 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
---|
27 | * SUCH DAMAGE. |
---|
28 | */ |
---|
29 | |
---|
30 | #ifndef lint |
---|
31 | static char copyright[] = |
---|
32 | "@(#) Copyright (c) 1993\n\ |
---|
33 | The Regents of the University of California. All rights reserved.\n"; |
---|
34 | #endif /* not lint */ |
---|
35 | |
---|
36 | #ifndef lint |
---|
37 | static char sccsid[] = "@(#)rs.c 8.1 (Berkeley) 6/6/93"; |
---|
38 | #endif /* not lint */ |
---|
39 | |
---|
40 | /* |
---|
41 | * rs - reshape a data array |
---|
42 | * Author: John Kunze, Office of Comp. Affairs, UCB |
---|
43 | * BEWARE: lots of unfinished edges |
---|
44 | */ |
---|
45 | |
---|
46 | #include <ctype.h> |
---|
47 | #include <stdio.h> |
---|
48 | #include <stdlib.h> |
---|
49 | #include <string.h> |
---|
50 | |
---|
51 | long flags; |
---|
52 | #define TRANSPOSE 000001 |
---|
53 | #define MTRANSPOSE 000002 |
---|
54 | #define ONEPERLINE 000004 |
---|
55 | #define ONEISEPONLY 000010 |
---|
56 | #define ONEOSEPONLY 000020 |
---|
57 | #define NOTRIMENDCOL 000040 |
---|
58 | #define SQUEEZE 000100 |
---|
59 | #define SHAPEONLY 000200 |
---|
60 | #define DETAILSHAPE 000400 |
---|
61 | #define RIGHTADJUST 001000 |
---|
62 | #define NULLPAD 002000 |
---|
63 | #define RECYCLE 004000 |
---|
64 | #define SKIPPRINT 010000 |
---|
65 | #define ICOLBOUNDS 020000 |
---|
66 | #define OCOLBOUNDS 040000 |
---|
67 | #define ONEPERCHAR 0100000 |
---|
68 | #define NOARGS 0200000 |
---|
69 | |
---|
70 | short *colwidths; |
---|
71 | short *cord; |
---|
72 | short *icbd; |
---|
73 | short *ocbd; |
---|
74 | int nelem; |
---|
75 | char **elem; |
---|
76 | char **endelem; |
---|
77 | char *curline; |
---|
78 | int allocsize = BUFSIZ; |
---|
79 | int curlen; |
---|
80 | int irows, icols; |
---|
81 | int orows, ocols; |
---|
82 | int maxlen; |
---|
83 | int skip; |
---|
84 | int propgutter; |
---|
85 | char isep = ' ', osep = ' '; |
---|
86 | int owidth = 80, gutter = 2; |
---|
87 | |
---|
88 | void usage(char *, char *); |
---|
89 | void getargs(int, char *[]); |
---|
90 | void getfile(void); |
---|
91 | int getline(void); |
---|
92 | char *getlist(short **, char *); |
---|
93 | char *getnum(int *, char *, int); |
---|
94 | char **getptrs(char **); |
---|
95 | void prepfile(void); |
---|
96 | void prints(char *, int); |
---|
97 | void putfile(void); |
---|
98 | |
---|
99 | #define INCR(ep) do { \ |
---|
100 | if (++ep >= endelem) \ |
---|
101 | ep = getptrs(ep); \ |
---|
102 | } while(0) |
---|
103 | |
---|
104 | int |
---|
105 | main(argc, argv) |
---|
106 | int argc; |
---|
107 | char *argv[]; |
---|
108 | { |
---|
109 | getargs(argc, argv); |
---|
110 | getfile(); |
---|
111 | if (flags & SHAPEONLY) { |
---|
112 | printf("%d %d\n", irows, icols); |
---|
113 | exit(0); |
---|
114 | } |
---|
115 | prepfile(); |
---|
116 | putfile(); |
---|
117 | exit(0); |
---|
118 | } |
---|
119 | |
---|
120 | void |
---|
121 | getfile() |
---|
122 | { |
---|
123 | register char *p; |
---|
124 | register char *endp; |
---|
125 | register char **ep = 0; |
---|
126 | int multisep = (flags & ONEISEPONLY ? 0 : 1); |
---|
127 | int nullpad = flags & NULLPAD; |
---|
128 | char **padto; |
---|
129 | |
---|
130 | while (skip--) { |
---|
131 | getline(); |
---|
132 | if (flags & SKIPPRINT) |
---|
133 | puts(curline); |
---|
134 | } |
---|
135 | getline(); |
---|
136 | if (flags & NOARGS && curlen < owidth) |
---|
137 | flags |= ONEPERLINE; |
---|
138 | if (flags & ONEPERLINE) |
---|
139 | icols = 1; |
---|
140 | else /* count cols on first line */ |
---|
141 | for (p = curline, endp = curline + curlen; p < endp; p++) { |
---|
142 | if (*p == isep && multisep) |
---|
143 | continue; |
---|
144 | icols++; |
---|
145 | while (*p && *p != isep) |
---|
146 | p++; |
---|
147 | } |
---|
148 | ep = getptrs(elem); |
---|
149 | p = curline; |
---|
150 | do { |
---|
151 | if (flags & ONEPERLINE) { |
---|
152 | *ep = curline; |
---|
153 | INCR(ep); /* prepare for next entry */ |
---|
154 | if (maxlen < curlen) |
---|
155 | maxlen = curlen; |
---|
156 | irows++; |
---|
157 | continue; |
---|
158 | } |
---|
159 | for (p = curline, endp = curline + curlen; p < endp; p++) { |
---|
160 | if (*p == isep && multisep) |
---|
161 | continue; /* eat up column separators */ |
---|
162 | if (*p == isep) /* must be an empty column */ |
---|
163 | *ep = ""; |
---|
164 | else /* store column entry */ |
---|
165 | *ep = p; |
---|
166 | while (p < endp && *p != isep) |
---|
167 | p++; /* find end of entry */ |
---|
168 | *p = '\0'; /* mark end of entry */ |
---|
169 | if (maxlen < p - *ep) /* update maxlen */ |
---|
170 | maxlen = p - *ep; |
---|
171 | INCR(ep); /* prepare for next entry */ |
---|
172 | } |
---|
173 | irows++; /* update row count */ |
---|
174 | if (nullpad) { /* pad missing entries */ |
---|
175 | padto = elem + irows * icols; |
---|
176 | while (ep < padto) { |
---|
177 | *ep = ""; |
---|
178 | INCR(ep); |
---|
179 | } |
---|
180 | } |
---|
181 | } while (getline() != EOF); |
---|
182 | *ep = 0; /* mark end of pointers */ |
---|
183 | nelem = ep - elem; |
---|
184 | } |
---|
185 | |
---|
186 | void |
---|
187 | putfile() |
---|
188 | { |
---|
189 | register char **ep; |
---|
190 | register int i, j, n; |
---|
191 | |
---|
192 | ep = elem; |
---|
193 | if (flags & TRANSPOSE) { |
---|
194 | for (i = 0; i < orows; i++) { |
---|
195 | for (j = i; j < nelem; j += orows) |
---|
196 | prints(ep[j], (j - i) / orows); |
---|
197 | putchar('\n'); |
---|
198 | } |
---|
199 | } else { |
---|
200 | for (n = 0, i = 0; i < orows && n < nelem; i++) { |
---|
201 | for (j = 0; j < ocols; j++) { |
---|
202 | if (n++ >= nelem) |
---|
203 | break; |
---|
204 | prints(*ep++, j); |
---|
205 | } |
---|
206 | putchar('\n'); |
---|
207 | } |
---|
208 | } |
---|
209 | } |
---|
210 | |
---|
211 | void |
---|
212 | prints(s, col) |
---|
213 | char *s; |
---|
214 | int col; |
---|
215 | { |
---|
216 | register int n; |
---|
217 | register char *p = s; |
---|
218 | |
---|
219 | while (*p) |
---|
220 | p++; |
---|
221 | n = (flags & ONEOSEPONLY ? 1 : colwidths[col] - (p - s)); |
---|
222 | if (flags & RIGHTADJUST) |
---|
223 | while (n-- > 0) |
---|
224 | putchar(osep); |
---|
225 | for (p = s; *p; p++) |
---|
226 | putchar(*p); |
---|
227 | while (n-- > 0) |
---|
228 | putchar(osep); |
---|
229 | } |
---|
230 | |
---|
231 | void |
---|
232 | usage(msg, s) |
---|
233 | char *msg, *s; |
---|
234 | { |
---|
235 | fprintf(stderr, "rs: "); |
---|
236 | fprintf(stderr, msg, s); |
---|
237 | fprintf(stderr, |
---|
238 | "Usage: rs [ -[csCS][x][kKgGw][N]tTeEnyjhHm ] [ rows [ cols ] ]\n"); |
---|
239 | exit(1); |
---|
240 | } |
---|
241 | |
---|
242 | void |
---|
243 | prepfile() |
---|
244 | { |
---|
245 | register char **ep; |
---|
246 | register int i; |
---|
247 | register int j; |
---|
248 | char **lp; |
---|
249 | int colw; |
---|
250 | int max = 0; |
---|
251 | int n; |
---|
252 | |
---|
253 | if (!nelem) |
---|
254 | exit(0); |
---|
255 | gutter += maxlen * propgutter / 100.0; |
---|
256 | colw = maxlen + gutter; |
---|
257 | if (flags & MTRANSPOSE) { |
---|
258 | orows = icols; |
---|
259 | ocols = irows; |
---|
260 | } |
---|
261 | else if (orows == 0 && ocols == 0) { /* decide rows and cols */ |
---|
262 | ocols = owidth / colw; |
---|
263 | if (ocols == 0) { |
---|
264 | fprintf(stderr, "rs: Display width %d is less than column width %d\n", owidth, colw); |
---|
265 | ocols = 1; |
---|
266 | } |
---|
267 | if (ocols > nelem) |
---|
268 | ocols = nelem; |
---|
269 | orows = nelem / ocols + (nelem % ocols ? 1 : 0); |
---|
270 | } |
---|
271 | else if (orows == 0) /* decide on rows */ |
---|
272 | orows = nelem / ocols + (nelem % ocols ? 1 : 0); |
---|
273 | else if (ocols == 0) /* decide on cols */ |
---|
274 | ocols = nelem / orows + (nelem % orows ? 1 : 0); |
---|
275 | lp = elem + orows * ocols; |
---|
276 | while (lp > endelem) { |
---|
277 | getptrs(elem + nelem); |
---|
278 | lp = elem + orows * ocols; |
---|
279 | } |
---|
280 | if (flags & RECYCLE) { |
---|
281 | for (ep = elem + nelem; ep < lp; ep++) |
---|
282 | *ep = *(ep - nelem); |
---|
283 | nelem = lp - elem; |
---|
284 | } |
---|
285 | if (!(colwidths = (short *) malloc(ocols * sizeof(short)))) { |
---|
286 | fprintf(stderr, "rs: malloc: No gutter space\n"); |
---|
287 | exit(1); |
---|
288 | } |
---|
289 | if (flags & SQUEEZE) { |
---|
290 | if (flags & TRANSPOSE) |
---|
291 | for (ep = elem, i = 0; i < ocols; i++) { |
---|
292 | for (j = 0; j < orows; j++) |
---|
293 | if ((n = strlen(*ep++)) > max) |
---|
294 | max = n; |
---|
295 | colwidths[i] = max + gutter; |
---|
296 | } |
---|
297 | else |
---|
298 | for (i = 0; i < ocols; i++) { |
---|
299 | for (j = i; j < nelem; j += ocols) |
---|
300 | if ((n = strlen(ep[j])) > max) |
---|
301 | max = n; |
---|
302 | colwidths[i] = max + gutter; |
---|
303 | } |
---|
304 | } |
---|
305 | /* for (i = 0; i < orows; i++) { |
---|
306 | for (j = i; j < nelem; j += orows) |
---|
307 | prints(ep[j], (j - i) / orows); |
---|
308 | putchar('\n'); |
---|
309 | } |
---|
310 | else |
---|
311 | for (i = 0; i < orows; i++) { |
---|
312 | for (j = 0; j < ocols; j++) |
---|
313 | prints(*ep++, j); |
---|
314 | putchar('\n'); |
---|
315 | }*/ |
---|
316 | else |
---|
317 | for (i = 0; i < ocols; i++) |
---|
318 | colwidths[i] = colw; |
---|
319 | if (!(flags & NOTRIMENDCOL)) { |
---|
320 | if (flags & RIGHTADJUST) |
---|
321 | colwidths[0] -= gutter; |
---|
322 | else |
---|
323 | colwidths[ocols - 1] = 0; |
---|
324 | } |
---|
325 | n = orows * ocols; |
---|
326 | if (n > nelem && (flags & RECYCLE)) |
---|
327 | nelem = n; |
---|
328 | /*for (i = 0; i < ocols; i++) |
---|
329 | fprintf(stderr, "%d ",colwidths[i]); |
---|
330 | fprintf(stderr, "is colwidths, nelem %d\n", nelem);*/ |
---|
331 | } |
---|
332 | |
---|
333 | #define BSIZE 2048 |
---|
334 | char ibuf[BSIZE]; /* two screenfuls should do */ |
---|
335 | |
---|
336 | int |
---|
337 | getline() /* get line; maintain curline, curlen; manage storage */ |
---|
338 | { |
---|
339 | static int putlength; |
---|
340 | static char *endblock = ibuf + BSIZE; |
---|
341 | register char *p; |
---|
342 | register int c, i; |
---|
343 | |
---|
344 | if (!irows) { |
---|
345 | curline = ibuf; |
---|
346 | putlength = flags & DETAILSHAPE; |
---|
347 | } |
---|
348 | else if (skip <= 0) { /* don't waste storage */ |
---|
349 | curline += curlen + 1; |
---|
350 | if (putlength) /* print length, recycle storage */ |
---|
351 | printf(" %d line %d\n", curlen, irows); |
---|
352 | } |
---|
353 | if (!putlength && endblock - curline < BUFSIZ) { /* need storage */ |
---|
354 | /*ww = endblock-curline; tt += ww;*/ |
---|
355 | /*printf("#wasted %d total %d\n",ww,tt);*/ |
---|
356 | if (!(curline = (char *) malloc(BSIZE))) { |
---|
357 | fprintf(stderr, "rs: File too large\n"); |
---|
358 | exit(1); |
---|
359 | } |
---|
360 | endblock = curline + BSIZE; |
---|
361 | /*printf("#endb %d curline %d\n",endblock,curline);*/ |
---|
362 | } |
---|
363 | for (p = curline, i = 1; i < BUFSIZ; *p++ = c, i++) |
---|
364 | if ((c = getchar()) == EOF || c == '\n') |
---|
365 | break; |
---|
366 | *p = '\0'; |
---|
367 | curlen = i - 1; |
---|
368 | return(c); |
---|
369 | } |
---|
370 | |
---|
371 | char ** |
---|
372 | getptrs(sp) |
---|
373 | char **sp; |
---|
374 | { |
---|
375 | register char **p; |
---|
376 | |
---|
377 | allocsize += allocsize; |
---|
378 | p = (char **)realloc(elem, allocsize * sizeof(char *)); |
---|
379 | if (p == (char **)0) { |
---|
380 | fprintf(stderr, "rs: no memory\n"); |
---|
381 | exit(1); |
---|
382 | } |
---|
383 | |
---|
384 | sp += (p - elem); |
---|
385 | endelem = (elem = p) + allocsize; |
---|
386 | return(sp); |
---|
387 | } |
---|
388 | |
---|
389 | void |
---|
390 | getargs(ac, av) |
---|
391 | int ac; |
---|
392 | char *av[]; |
---|
393 | { |
---|
394 | register char *p; |
---|
395 | |
---|
396 | if (ac == 1) { |
---|
397 | flags |= NOARGS | TRANSPOSE; |
---|
398 | } |
---|
399 | while (--ac && **++av == '-') |
---|
400 | for (p = *av+1; *p; p++) |
---|
401 | switch (*p) { |
---|
402 | case 'T': |
---|
403 | flags |= MTRANSPOSE; |
---|
404 | case 't': |
---|
405 | flags |= TRANSPOSE; |
---|
406 | break; |
---|
407 | case 'c': /* input col. separator */ |
---|
408 | flags |= ONEISEPONLY; |
---|
409 | case 's': /* one or more allowed */ |
---|
410 | if (p[1]) |
---|
411 | isep = *++p; |
---|
412 | else |
---|
413 | isep = '\t'; /* default is ^I */ |
---|
414 | break; |
---|
415 | case 'C': |
---|
416 | flags |= ONEOSEPONLY; |
---|
417 | case 'S': |
---|
418 | if (p[1]) |
---|
419 | osep = *++p; |
---|
420 | else |
---|
421 | osep = '\t'; /* default is ^I */ |
---|
422 | break; |
---|
423 | case 'w': /* window width, default 80 */ |
---|
424 | p = getnum(&owidth, p, 0); |
---|
425 | if (owidth <= 0) |
---|
426 | usage("Width must be a positive %s", "integer"); |
---|
427 | break; |
---|
428 | case 'K': /* skip N lines */ |
---|
429 | flags |= SKIPPRINT; |
---|
430 | case 'k': /* skip, do not print */ |
---|
431 | p = getnum(&skip, p, 0); |
---|
432 | if (!skip) |
---|
433 | skip = 1; |
---|
434 | break; |
---|
435 | case 'm': |
---|
436 | flags |= NOTRIMENDCOL; |
---|
437 | break; |
---|
438 | case 'g': /* gutter space */ |
---|
439 | p = getnum(&gutter, p, 0); |
---|
440 | break; |
---|
441 | case 'G': |
---|
442 | p = getnum(&propgutter, p, 0); |
---|
443 | break; |
---|
444 | case 'e': /* each line is an entry */ |
---|
445 | flags |= ONEPERLINE; |
---|
446 | break; |
---|
447 | case 'E': |
---|
448 | flags |= ONEPERCHAR; |
---|
449 | break; |
---|
450 | case 'j': /* right adjust */ |
---|
451 | flags |= RIGHTADJUST; |
---|
452 | break; |
---|
453 | case 'n': /* null padding for missing values */ |
---|
454 | flags |= NULLPAD; |
---|
455 | break; |
---|
456 | case 'y': |
---|
457 | flags |= RECYCLE; |
---|
458 | break; |
---|
459 | case 'H': /* print shape only */ |
---|
460 | flags |= DETAILSHAPE; |
---|
461 | case 'h': |
---|
462 | flags |= SHAPEONLY; |
---|
463 | break; |
---|
464 | case 'z': /* squeeze col width */ |
---|
465 | flags |= SQUEEZE; |
---|
466 | break; |
---|
467 | /*case 'p': |
---|
468 | ipagespace = atoi(++p); (default is 1) |
---|
469 | break;*/ |
---|
470 | case 'o': /* col order */ |
---|
471 | p = getlist(&cord, p); |
---|
472 | break; |
---|
473 | case 'b': |
---|
474 | flags |= ICOLBOUNDS; |
---|
475 | p = getlist(&icbd, p); |
---|
476 | break; |
---|
477 | case 'B': |
---|
478 | flags |= OCOLBOUNDS; |
---|
479 | p = getlist(&ocbd, p); |
---|
480 | break; |
---|
481 | default: |
---|
482 | usage("Bad flag: %.1s", p); |
---|
483 | } |
---|
484 | /*if (!osep) |
---|
485 | osep = isep;*/ |
---|
486 | switch (ac) { |
---|
487 | /*case 3: |
---|
488 | opages = atoi(av[2]);*/ |
---|
489 | case 2: |
---|
490 | ocols = atoi(av[1]); |
---|
491 | case 1: |
---|
492 | orows = atoi(av[0]); |
---|
493 | case 0: |
---|
494 | break; |
---|
495 | default: |
---|
496 | usage("Too many %s.", "arguments"); |
---|
497 | } |
---|
498 | } |
---|
499 | |
---|
500 | char * |
---|
501 | getlist(list, p) |
---|
502 | short **list; |
---|
503 | char *p; |
---|
504 | { |
---|
505 | register int count = 1; |
---|
506 | register char *t; |
---|
507 | |
---|
508 | for (t = p + 1; *t; t++) { |
---|
509 | if (!isdigit(*t)) |
---|
510 | usage("Option %.1s requires a list of unsigned numbers separated by commas", t); |
---|
511 | count++; |
---|
512 | while (*t && isdigit(*t)) |
---|
513 | t++; |
---|
514 | if (*t != ',') |
---|
515 | break; |
---|
516 | } |
---|
517 | if (!(*list = (short *) malloc(count * sizeof(short)))) { |
---|
518 | fprintf(stderr, "rs: No list space\n"); |
---|
519 | exit(1); |
---|
520 | } |
---|
521 | count = 0; |
---|
522 | for (t = p + 1; *t; t++) { |
---|
523 | (*list)[count++] = atoi(t); |
---|
524 | printf("++ %d ", (*list)[count-1]); |
---|
525 | fflush(stdout); |
---|
526 | while (*t && isdigit(*t)) |
---|
527 | t++; |
---|
528 | if (*t != ',') |
---|
529 | break; |
---|
530 | } |
---|
531 | (*list)[count] = 0; |
---|
532 | return(t - 1); |
---|
533 | } |
---|
534 | |
---|
535 | char * |
---|
536 | getnum(num, p, strict) /* num = number p points to; if (strict) complain */ |
---|
537 | int *num, strict; /* returns pointer to end of num */ |
---|
538 | char *p; |
---|
539 | { |
---|
540 | register char *t = p; |
---|
541 | |
---|
542 | if (!isdigit(*++t)) { |
---|
543 | if (strict || *t == '-' || *t == '+') |
---|
544 | usage("Option %.1s requires an unsigned integer", p); |
---|
545 | *num = 0; |
---|
546 | return(p); |
---|
547 | } |
---|
548 | *num = atoi(t); |
---|
549 | while (*++t) |
---|
550 | if (!isdigit(*t)) |
---|
551 | break; |
---|
552 | return(--t); |
---|
553 | } |
---|