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