Context Navigation

source: trunk/third/rs/rs.c @ 24143

Visit:

Revision 24143, 12.1 KB checked in by broder, 15 years ago (diff)
In rs: * Rename getline to rs_getline to avoid conflicting with the getline in <stdio.h>.

Rev	Line
[9070]	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.
[23442]	13	* 3. Neither the name of the University nor the names of its contributors
[9070]	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
[9110]	88	void usage(char , char );
	89	void getargs(int, char *[]);
	90	void getfile(void);
[24143]	91	int rs_getline(void);
[9110]	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);
[9070]	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--) {
[24143]	131	rs_getline();
[9070]	132	if (flags & SKIPPRINT)
	133	puts(curline);
	134	}
[24143]	135	rs_getline();
[9070]	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	}
[24143]	181	} while (rs_getline() != EOF);
[9070]	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	{
[9110]	235	fprintf(stderr, "rs: ");
	236	fprintf(stderr, msg, s);
[9070]	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) {
[9110]	264	fprintf(stderr, "rs: Display width %d is less than column width %d\n", owidth, colw);
[9070]	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	}
[9110]	285	if (!(colwidths = (short ) malloc(ocols sizeof(short)))) {
	286	fprintf(stderr, "rs: malloc: No gutter space\n");
	287	exit(1);
	288	}
[9070]	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
[24143]	337	rs_getline() /* get line; maintain curline, curlen; manage storage */
[9070]	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);/
[9110]	356	if (!(curline = (char *) malloc(BSIZE))) {
	357	fprintf(stderr, "rs: File too large\n");
	358	exit(1);
	359	}
[9070]	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 *));
[9110]	379	if (p == (char **)0) {
	380	fprintf(stderr, "rs: no memory\n");
	381	exit(1);
	382	}
[9070]	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)
[9110]	426	usage("Width must be a positive %s", "integer");
[9070]	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:
[9110]	496	usage("Too many %s.", "arguments");
[9070]	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	}
[9110]	517	if (!(list = (short ) malloc(count * sizeof(short)))) {
	518	fprintf(stderr, "rs: No list space\n");
	519	exit(1);
	520	}
[9070]	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	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: