jot/jot.c

   1 /*      $NetBSD: jot.c,v 1.4 1997/10/19 03:34:49 lukem 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. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *      This product includes software developed by the University of
  18  *      California, Berkeley and its contributors.
  19  * 4. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36 #include <sys/cdefs.h>
  37 #ifndef lint
  38 __COPYRIGHT("@(#) Copyright (c) 1993\n\
  39         The Regents of the University of California.  All rights reserved.\n");
  40 #endif /* not lint */
  41
  42 #ifndef lint
  43 #if 0
  44 static char sccsid[] = "@(#)jot.c       8.1 (Berkeley) 6/6/93";
  45 #endif
  46 __RCSID("$NetBSD: jot.c,v 1.4 1997/10/19 03:34:49 lukem Exp $");
  47 #endif /* not lint */
  48
  49 /*
  50  * jot - print sequential or random data
  51  *
  52  * Author:  John Kunze, Office of Comp. Affairs, UCB
  53  */
  54
  55 #include <ctype.h>
  56 #include <err.h>
  57 #include <limits.h>
  58 #include <stdio.h>
  59 #include <stdlib.h>
  60 #include <string.h>
  61 #include <time.h>
  62
  63 #define REPS_DEF        100
  64 #define BEGIN_DEF       1
  65 #define ENDER_DEF       100
  66 #define STEP_DEF        1
  67
  68 #define isdefault(s)    (strcmp((s), "-") == 0)
  69
  70 double  begin;
  71 double  ender;
  72 double  s;
  73 long    reps;
  74 int     randomize;
  75 int     infinity;
  76 int     boring;
  77 int     prec;
  78 int     dox;
  79 int     chardata;
  80 int     nofinalnl;
  81 char    sepstring[BUFSIZ] = "\n";
  82 char    format[BUFSIZ];
  83
  84 void    error __P((char *, char *));
  85 void    getargs __P((int, char *[]));
  86 void    getformat __P((void));
  87 int     getprec __P((char *));
  88 int     main __P((int, char **));
  89 void    putdata __P((double, long));
  90
  91 int
  92 main(argc, argv)
  93         int argc;
  94         char *argv[];
  95 {
  96         double  xd, yd;
  97         long    id;
  98         double  *x = &xd;
  99         double  *y = &yd;
 100         long    *i = &id;
 101
 102         getargs(argc, argv);
 103         if (randomize) {
 104                 *x = (ender - begin) * (ender > begin ? 1 : -1);
 105                 srandom((int) s);
 106                 for (*i = 1; *i <= reps || infinity; (*i)++) {
 107                         *y = (double) random() / INT_MAX;
 108                         putdata(*y * *x + begin, reps - *i);
 109                 }
 110         }
 111         else
 112                 for (*i = 1, *x = begin; *i <= reps || infinity; (*i)++, *x += s)
 113                         putdata(*x, reps - *i);
 114         if (!nofinalnl)
 115                 putchar('\n');
 116         exit(0);
 117 }
 118
 119 void
 120 getargs(ac, av)
 121         int ac;
 122         char *av[];
 123 {
 124         unsigned int    mask = 0;
 125         int             n = 0;
 126
 127         while (--ac && **++av == '-' && !isdefault(*av))
 128                 switch ((*av)[1]) {
 129                 case 'r':
 130                         randomize = 1;
 131                         break;
 132                 case 'c':
 133                         chardata = 1;
 134                         break;
 135                 case 'n':
 136                         nofinalnl = 1;
 137                         break;
 138                 case 'b':
 139                         boring = 1;
 140                 case 'w':
 141                         if ((*av)[2])
 142                                 strcpy(format, *av + 2);
 143                         else if (!--ac)
 144                                 error("Need context word after -w or -b", "");
 145                         else
 146                                 strcpy(format, *++av);
 147                         break;
 148                 case 's':
 149                         if ((*av)[2])
 150                                 strcpy(sepstring, *av + 2);
 151                         else if (!--ac)
 152                                 error("Need string after -s", "");
 153                         else
 154                                 strcpy(sepstring, *++av);
 155                         break;
 156                 case 'p':
 157                         if ((*av)[2])
 158                                 prec = atoi(*av + 2);
 159                         else if (!--ac)
 160                                 error("Need number after -p", "");
 161                         else
 162                                 prec = atoi(*++av);
 163                         if (prec <= 0)
 164                                 error("Bad precision value", "");
 165                         break;
 166                 default:
 167                         error("Unknown option %s", *av);
 168                 }
 169
 170         switch (ac) {   /* examine args right to left, falling thru cases */
 171         case 4:
 172                 if (!isdefault(av[3])) {
 173                         if (!sscanf(av[3], "%lf", &s))
 174                                 error("Bad s value:  %s", av[3]);
 175                         mask |= 01;
 176                 }
 177         case 3:
 178                 if (!isdefault(av[2])) {
 179                         if (!sscanf(av[2], "%lf", &ender))
 180                                 ender = av[2][strlen(av[2])-1];
 181                         mask |= 02;
 182                         if (!prec)
 183                                 n = getprec(av[2]);
 184                 }
 185         case 2:
 186                 if (!isdefault(av[1])) {
 187                         if (!sscanf(av[1], "%lf", &begin))
 188                                 begin = av[1][strlen(av[1])-1];
 189                         mask |= 04;
 190                         if (!prec)
 191                                 prec = getprec(av[1]);
 192                         if (n > prec)           /* maximum precision */
 193                                 prec = n;
 194                 }
 195         case 1:
 196                 if (!isdefault(av[0])) {
 197                         if (!sscanf(av[0], "%ld", &reps))
 198                                 error("Bad reps value:  %s", av[0]);
 199                         mask |= 010;
 200                 }
 201                 break;
 202         case 0:
 203                 error("jot - print sequential or random data", "");
 204         default:
 205                 error("Too many arguments.  What do you mean by %s?", av[4]);
 206         }
 207         getformat();
 208         while (mask)    /* 4 bit mask has 1's where last 4 args were given */
 209                 switch (mask) { /* fill in the 0's by default or computation */
 210                 case 001:
 211                         reps = REPS_DEF;
 212                         mask = 011;
 213                         break;
 214                 case 002:
 215                         reps = REPS_DEF;
 216                         mask = 012;
 217                         break;
 218                 case 003:
 219                         reps = REPS_DEF;
 220                         mask = 013;
 221                         break;
 222                 case 004:
 223                         reps = REPS_DEF;
 224                         mask = 014;
 225                         break;
 226                 case 005:
 227                         reps = REPS_DEF;
 228                         mask = 015;
 229                         break;
 230                 case 006:
 231                         reps = REPS_DEF;
 232                         mask = 016;
 233                         break;
 234                 case 007:
 235                         if (randomize) {
 236                                 reps = REPS_DEF;
 237                                 mask = 0;
 238                                 break;
 239                         }
 240                         if (s == 0.0) {
 241                                 reps = 0;
 242                                 mask = 0;
 243                                 break;
 244                         }
 245                         reps = (ender - begin + s) / s;
 246                         if (reps <= 0)
 247                                 error("Impossible stepsize", "");
 248                         mask = 0;
 249                         break;
 250                 case 010:
 251                         begin = BEGIN_DEF;
 252                         mask = 014;
 253                         break;
 254                 case 011:
 255                         begin = BEGIN_DEF;
 256                         mask = 015;
 257                         break;
 258                 case 012:
 259                         s = (randomize ? time(0) : STEP_DEF);
 260                         mask = 013;
 261                         break;
 262                 case 013:
 263                         if (randomize)
 264                                 begin = BEGIN_DEF;
 265                         else if (reps == 0)
 266                                 error("Must specify begin if reps == 0", "");
 267                         begin = ender - reps * s + s;
 268                         mask = 0;
 269                         break;
 270                 case 014:
 271                         s = (randomize ? time(0) : STEP_DEF);
 272                         mask = 015;
 273                         break;
 274                 case 015:
 275                         if (randomize)
 276                                 ender = ENDER_DEF;
 277                         else
 278                                 ender = begin + reps * s - s;
 279                         mask = 0;
 280                         break;
 281                 case 016:
 282                         if (randomize)
 283                                 s = time(0);
 284                         else if (reps == 0)
 285                                 error("Infinite sequences cannot be bounded",
 286                                     "");
 287                         else if (reps == 1)
 288                                 s = 0.0;
 289                         else
 290                                 s = (ender - begin) / (reps - 1);
 291                         mask = 0;
 292                         break;
 293                 case 017:               /* if reps given and implied, */
 294                         if (!randomize && s != 0.0) {
 295                                 long t = (ender - begin + s) / s;
 296                                 if (t <= 0)
 297                                         error("Impossible stepsize", "");
 298                                 if (t < reps)           /* take lesser */
 299                                         reps = t;
 300                         }
 301                         mask = 0;
 302                         break;
 303                 default:
 304                         error("Bad mask", "");
 305                 }
 306         if (reps == 0)
 307                 infinity = 1;
 308 }
 309
 310 void
 311 putdata(x, notlast)
 312         double x;
 313         long notlast;
 314 {
 315         long    d = x;
 316         long    *dp = &d;
 317
 318         if (boring)                             /* repeated word */
 319                 printf("%s", format);
 320         else if (dox)                           /* scalar */
 321                 printf(format, *dp);
 322         else                                    /* real */
 323                 printf(format, x);
 324         if (notlast != 0)
 325                 fputs(sepstring, stdout);
 326 }
 327
 328 void
 329 error(msg, s)
 330         char *msg, *s;
 331 {
 332         warnx(msg, s);
 333         fprintf(stderr,
 334             "\nusage:  jot [ options ] [ reps [ begin [ end [ s ] ] ] ]\n");
 335         if (strncmp("jot - ", msg, 6) == 0)
 336                 fprintf(stderr, "Options:\n\t%s\t%s\t%s\t%s\t%s\t%s\t%s",
 337                         "-r             random data\n",
 338                         "-c             character data\n",
 339                         "-n             no final newline\n",
 340                         "-b word                repeated word\n",
 341                         "-w word                context word\n",
 342                         "-s string      data separator\n",
 343                         "-p precision   number of characters\n");
 344         exit(1);
 345 }
 346
 347 int
 348 getprec(s)
 349         char *s;
 350 {
 351         char    *p;
 352         char    *q;
 353
 354         for (p = s; *p; p++)
 355                 if (*p == '.')
 356                         break;
 357         if (!*p)
 358                 return (0);
 359         for (q = ++p; *p; p++)
 360                 if (!isdigit(*p))
 361                         break;
 362         return (p - q);
 363 }
 364
 365 void
 366 getformat()
 367 {
 368         char    *p;
 369
 370         if (boring)                             /* no need to bother */
 371                 return;
 372         for (p = format; *p; p++)               /* look for '%' */
 373                 if (*p == '%' && *(p+1) != '%') /* leave %% alone */
 374                         break;
 375         if (!*p && !chardata)
 376                 sprintf(p, "%%.%df", prec);
 377         else if (!*p && chardata) {
 378                 strcpy(p, "%c");
 379                 dox = 1;
 380         }
 381         else if (!*(p+1))
 382                 strcat(format, "%");            /* cannot end in single '%' */
 383         else {
 384                 while (!isalpha(*p))
 385                         p++;
 386                 switch (*p) {
 387                 case 'f': case 'e': case 'g': case '%':
 388                         break;
 389                 case 's':
 390                         error("Cannot convert numeric data to strings", "");
 391                         break;
 392                 /* case 'd': case 'o': case 'x': case 'D': case 'O': case 'X':
 393                 case 'c': case 'u': */
 394                 default:
 395                         dox = 1;
 396                         break;
 397                 }
 398         }
 399 }