Home | History | Annotate | Line # | Download | only in jot
jot.c revision 1.23 
      1 /*	$NetBSD: jot.c,v 1.23 2008/04/21 20:33:41 dsl Exp $	*/
      2 
      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 #include <sys/cdefs.h>
     33 #ifndef lint
     34 __COPYRIGHT("@(#) Copyright (c) 1993\n\
     35 	The Regents of the University of California.  All rights reserved.\n");
     36 #endif /* not lint */
     37 
     38 #ifndef lint
     39 #if 0
     40 static char sccsid[] = "@(#)jot.c	8.1 (Berkeley) 6/6/93";
     41 #endif
     42 __RCSID("$NetBSD: jot.c,v 1.23 2008/04/21 20:33:41 dsl Exp $");
     43 #endif /* not lint */
     44 
     45 /*
     46  * jot - print sequential or random data
     47  *
     48  * Author:  John Kunze, Office of Comp. Affairs, UCB
     49  */
     50 
     51 #include <ctype.h>
     52 #include <err.h>
     53 #include <limits.h>
     54 #include <math.h>
     55 #include <stdio.h>
     56 #include <stdlib.h>
     57 #include <string.h>
     58 #include <time.h>
     59 #include <unistd.h>
     60 
     61 #define	REPS_DEF	100
     62 #define	BEGIN_DEF	1
     63 #define	ENDER_DEF	100
     64 #define	STEP_DEF	1
     65 
     66 #define	is_default(s)	(strcmp((s), "-") == 0)
     67 
     68 static double	begin = BEGIN_DEF;
     69 static double	ender = ENDER_DEF;
     70 static double	step = STEP_DEF;
     71 static long	reps = REPS_DEF;
     72 static int	randomize;
     73 static int	boring;
     74 static int	prec = -1;
     75 static int	dox;
     76 static int	chardata;
     77 static int	nofinalnl;
     78 static const char *sepstring = "\n";
     79 static char	format[BUFSIZ];
     80 
     81 static void	getargs(int, char *[]);
     82 static void	getformat(void);
     83 static int	getprec(char *);
     84 static void	putdata(double, long);
     85 static void	usage(void) __dead;
     86 
     87 int
     88 main(int argc, char *argv[])
     89 {
     90 	double	x;
     91 	long	i;
     92 
     93 	getargs(argc, argv);
     94 	if (randomize) {
     95 		x = ender - begin;
     96 		if (x < 0) {
     97 			x = -x;
     98 			begin = ender;
     99 		}
    100 		if (dox == 0)
    101 			/*
    102 			 * We are printing floating point, generate random
    103 			 * number that include both supplied limits.
    104 			 * Due to FP routing for display the low and high
    105 			 * values are likely to occur half as often as all
    106 			 * the others.
    107 			 */
    108 			x /= (1u << 31) - 1.0;
    109 		else {
    110 			/*
    111 			 * We are printing integers increase the range by
    112 			 * one but ensure we never generate it.
    113 			 * This makes all the integer values equally likely.
    114 			 */
    115 			x += 1.0;
    116 			x /= (1u << 31);
    117 		}
    118 		srandom((unsigned long) step);
    119 		for (i = 1; i <= reps || reps == 0; i++)
    120 			putdata(random() * x + begin, reps - i);
    121 	} else {
    122 		/*
    123 		 * If we are going to display as integer, add 0.5 here
    124 		 * and use floor(x) later to get sane rounding.
    125 		 */
    126 		x = begin;
    127 		if (dox)
    128 			x += 0.5;
    129 		for (i = 1; i <= reps || reps == 0; i++, x += step)
    130 			putdata(x, reps - i);
    131 	}
    132 	if (!nofinalnl)
    133 		putchar('\n');
    134 	exit(0);
    135 }
    136 
    137 static void
    138 getargs(int argc, char *argv[])
    139 {
    140 	unsigned int have = 0;
    141 #define BEGIN	1
    142 #define	STEP	2	/* seed if -r */
    143 #define REPS	4
    144 #define	ENDER	8
    145 	int n = 0;
    146 	long t;
    147 	char *ep;
    148 
    149 	for (;;) {
    150 		switch (getopt(argc, argv, "b:cnp:rs:w:")) {
    151 		default:
    152 			usage();
    153 		case -1:
    154 			break;
    155 		case 'c':
    156 			chardata = 1;
    157 			continue;
    158 		case 'n':
    159 			nofinalnl = 1;
    160 			continue;
    161 		case 'p':
    162 			prec = strtol(optarg, &ep, 0);
    163 			if (*ep != 0 || prec < 0)
    164 				errx(EXIT_FAILURE, "Bad precision value");
    165 			continue;
    166 		case 'r':
    167 			randomize = 1;
    168 			continue;
    169 		case 's':
    170 			sepstring = optarg;
    171 			continue;
    172 		case 'b':
    173 			boring = 1;
    174 			/* FALLTHROUGH */
    175 		case 'w':
    176 			strlcpy(format, optarg, sizeof(format));
    177 			continue;
    178 		}
    179 		break;
    180 	}
    181 	argc -= optind;
    182 	argv += optind;
    183 
    184 	switch (argc) {	/* examine args right to left, falling thru cases */
    185 	case 4:
    186 		if (!is_default(argv[3])) {
    187 			step = strtod(argv[3], &ep);
    188 			if (*ep != 0)
    189 				errx(EXIT_FAILURE, "Bad step value:  %s",
    190 				    argv[3]);
    191 			have |= STEP;
    192 		}
    193 	case 3:
    194 		if (!is_default(argv[2])) {
    195 			if (!sscanf(argv[2], "%lf", &ender))
    196 				ender = argv[2][strlen(argv[2])-1];
    197 			have |= ENDER;
    198 			if (prec < 0)
    199 				n = getprec(argv[2]);
    200 		}
    201 	case 2:
    202 		if (!is_default(argv[1])) {
    203 			if (!sscanf(argv[1], "%lf", &begin))
    204 				begin = argv[1][strlen(argv[1])-1];
    205 			have |= BEGIN;
    206 			if (prec < 0)
    207 				prec = getprec(argv[1]);
    208 			if (n > prec)		/* maximum precision */
    209 				prec = n;
    210 		}
    211 	case 1:
    212 		if (!is_default(argv[0])) {
    213 			reps = strtoul(argv[0], &ep, 0);
    214 			if (*ep != 0 || reps < 0)
    215 				errx(EXIT_FAILURE, "Bad reps value:  %s",
    216 				    argv[0]);
    217 			have |= REPS;
    218 		}
    219 		break;
    220 	case 0:
    221 		usage();
    222 		break;
    223 	default:
    224 		errx(EXIT_FAILURE,
    225 		    "Too many arguments.  What do you mean by %s?", argv[4]);
    226 	}
    227 	getformat();
    228 
    229 	if (prec == -1)
    230 		prec = 0;
    231 
    232 	if (randomize) {
    233 		/* 'step' is the seed here, use pseudo-random default */
    234 		if (!(have & STEP))
    235 			step = time(NULL) * getpid();
    236 		/* Take the default values for everything else */
    237 		return;
    238 	}
    239 
    240 	/*
    241 	 * The loop we run uses begin/step/reps, so if we have been
    242 	 * given an end value (ender) we must use it to replace the
    243 	 * default values of the others.
    244 	 * We will assume a begin of 0 and step of 1 if necessary.
    245 	 */
    246 
    247 	switch (have) {
    248 
    249 	case ENDER | STEP:
    250 	case ENDER | STEP | BEGIN:
    251 		/* Calculate reps */
    252 		if (step == 0.0)
    253 			reps = 0;	/* ie infinite */
    254 		else {
    255 			reps = (ender - begin + step) / step;
    256 			if (reps <= 0)
    257 				errx(EXIT_FAILURE, "Impossible stepsize");
    258 		}
    259 		break;
    260 
    261 	case REPS | ENDER:
    262 	case REPS | ENDER | STEP:
    263 		/* Calculate begin */
    264 		if (reps == 0)
    265 			errx(EXIT_FAILURE,
    266 			    "Must specify begin if reps == 0");
    267 		begin = ender - reps * step + step;
    268 		break;
    269 
    270 	case REPS | BEGIN | ENDER:
    271 		/* Calculate step */
    272 		if (reps == 0)
    273 			errx(EXIT_FAILURE,
    274 			    "Infinite sequences cannot be bounded");
    275 		if (reps == 1)
    276 			step = 0.0;
    277 		else
    278 			step = (ender - begin) / (reps - 1);
    279 		break;
    280 
    281 	case REPS | BEGIN | ENDER | STEP:
    282 		/* reps given and implied - take smaller */
    283 		if (step == 0.0)
    284 			break;
    285 		t = (ender - begin + step) / step;
    286 		if (t <= 0)
    287 			errx(EXIT_FAILURE,
    288 			    "Impossible stepsize");
    289 		if (t < reps)
    290 			reps = t;
    291 		break;
    292 
    293 	default:
    294 		/* No values can be calculated, use defaults */
    295 		break;
    296 	}
    297 }
    298 
    299 static void
    300 putdata(double x, long notlast)
    301 {
    302 
    303 	if (boring)				/* repeated word */
    304 		printf("%s", format);
    305 	else if (dox)				/* scalar */
    306 		printf(format, (long)floor(x));
    307 	else					/* real */
    308 		printf(format, x);
    309 	if (notlast != 0)
    310 		fputs(sepstring, stdout);
    311 }
    312 
    313 __dead static void
    314 usage(void)
    315 {
    316 	(void)fprintf(stderr, "usage: %s [-cnr] [-b word] [-p precision] "
    317 	    "[-s string] [-w word] [reps [begin [end [step | seed]]]]\n",
    318 	    getprogname());
    319 	exit(1);
    320 }
    321 
    322 static int
    323 getprec(char *num_str)
    324 {
    325 
    326 	num_str = strchr(num_str, '.');
    327 	if (num_str == NULL)
    328 		return 0;
    329 	return strspn(num_str + 1, "0123456789");
    330 }
    331 
    332 static void
    333 getformat(void)
    334 {
    335 	char	*p;
    336 	size_t	sz;
    337 
    338 	if (boring)				/* no need to bother */
    339 		return;
    340 	for (p = format; *p; p++) {		/* look for '%' */
    341 		if (*p == '%') {
    342 			if (*(p+1) != '%')
    343 				break;
    344 			p++;		/* leave %% alone */
    345 		}
    346 	}
    347 	sz = sizeof(format) - strlen(format) - 1;
    348 	if (!*p) {
    349 		if (chardata || prec == 0) {
    350 			if (snprintf(p, sz, "%%%s", chardata ? "c" : "ld") >= sz)
    351 				errx(EXIT_FAILURE, "-w word too long");
    352 			dox = 1;
    353 		} else {
    354 			if (snprintf(p, sz, "%%.%df", prec) >= (int)sz)
    355 				errx(EXIT_FAILURE, "-w word too long");
    356 		}
    357 	} else if (!*(p+1)) {
    358 		if (sz <= 0)
    359 			errx(EXIT_FAILURE, "-w word too long");
    360 		strcat(format, "%");		/* cannot end in single '%' */
    361 	} else {
    362 		p++;				/* skip leading % */
    363 		for(; *p && !isalpha((unsigned char)*p); p++) {
    364 			/* allow all valid printf(3) flags, but deny '*' */
    365 			if (!strchr("0123456789#-+. ", *p))
    366 				break;
    367 		}
    368 		/* Allow 'l' prefix, but no other. */
    369 		if (*p == 'l')
    370 			p++;
    371 		switch (*p) {
    372 		case 'f': case 'e': case 'g': case '%':
    373 		case 'E': case 'G':
    374 			break;
    375 		case 's':
    376 			errx(EXIT_FAILURE,
    377 			    "cannot convert numeric data to strings");
    378 			break;
    379 		case 'd': case 'o': case 'x': case 'u':
    380 		case 'D': case 'O': case 'X': case 'U':
    381 		case 'c': case 'i':
    382 			dox = 1;
    383 			break;
    384 		default:
    385 			errx(EXIT_FAILURE, "unknown or invalid format `%s'",
    386 			    format);
    387 		}
    388 		/* Need to check for trailing stuff to print */
    389 		for (; *p; p++)		/* look for '%' */
    390 			if (*p == '%') {
    391 				if (*(p+1) != '%')
    392 					break;
    393 				p++;		/* leave %% alone */
    394 			}
    395 		if (*p)
    396 			errx(EXIT_FAILURE, "unknown or invalid format `%s'",
    397 			    format);
    398 	}
    399 }
    400