/* Evaluate one level */
static int do_paren(void)
{
int op;
if (1 > parens--)
return E_ERROR;
do
{
if (SUCCESS > (op = do_op()))
break;
} while (getprec((char)op));
return op;
}
char * infixToPostfix(char postfix[], char infix[])
{
int i=0,p=0,type,prec;
char next;
struct char_stack stk;
stk.top=-1;
while(i<strlen(infix))
{
type=gettype(infix[i]);
switch(type)
{
case 1:
char_push(&stk,infix[i]);
break;
case 2:
while((next=char_pop(&stk))!='(')
postfix[p++]=next;
break;
case 3:
prec=getprec(infix[i]);
while(stk.top>-1 && prec <= getprec(stk.items[stk.top]))
postfix[p++]=char_pop(&stk);
char_push(&stk,infix[i]);
break;
case 4:
postfix[p++]=infix[i];
break;
}
i++;
}
while(stk.top>-1)
postfix[p++]=char_pop(&stk);
postfix[p]='\0';
return (postfix);
}
/* Get precedence of TOS token */
static int getTOSprec(void)
{
if (!op_sptr) return 0;
return getprec(op_stack[op_sptr - 1]);
}
/* Stack operations */
static void push_op(char op)
{
if (!getprec(op))
++parens;
op_stack[op_sptr++] = op;
}
int
main(int argc, char **argv)
{
bool have_format = false;
bool infinity = false;
bool nofinalnl = false;
bool randomize = false;
bool use_random = false;
int ch;
int mask = 0;
int n = 0;
double begin = BEGIN_DEF;
double divisor;
double ender = ENDER_DEF;
double s = STEP_DEF;
double x, y;
long i;
long reps = REPS_DEF;
while ((ch = getopt(argc, argv, "b:cnp:rs:w:")) != -1)
switch (ch) {
case 'b':
boring = true;
/* FALLTHROUGH */
case 'w':
if (strlcpy(format, optarg, sizeof(format)) >=
sizeof(format))
errx(1, "-%c word too long", ch);
have_format = true;
break;
case 'c':
chardata = true;
break;
case 'n':
nofinalnl = true;
break;
case 'p':
prec = atoi(optarg);
if (prec < 0)
errx(1, "bad precision value");
have_format = true;
break;
case 'r':
randomize = true;
break;
case 's':
sepstring = optarg;
break;
default:
usage();
}
argc -= optind;
argv += optind;
switch (argc) { /* examine args right to left, falling thru cases */
case 4:
if (!is_default(argv[3])) {
if (!sscanf(argv[3], "%lf", &s))
errx(1, "bad s value: %s", argv[3]);
mask |= HAVE_STEP;
if (randomize)
use_random = true;
}
/* FALLTHROUGH */
case 3:
if (!is_default(argv[2])) {
if (!sscanf(argv[2], "%lf", &ender))
ender = argv[2][strlen(argv[2])-1];
mask |= HAVE_ENDER;
if (prec < 0)
n = getprec(argv[2]);
}
/* FALLTHROUGH */
case 2:
if (!is_default(argv[1])) {
if (!sscanf(argv[1], "%lf", &begin))
begin = argv[1][strlen(argv[1])-1];
mask |= HAVE_BEGIN;
if (prec < 0)
prec = getprec(argv[1]);
if (n > prec) /* maximum precision */
prec = n;
}
/* FALLTHROUGH */
case 1:
if (!is_default(argv[0])) {
if (!sscanf(argv[0], "%ld", &reps))
errx(1, "bad reps value: %s", argv[0]);
mask |= HAVE_REPS;
}
break;
case 0:
usage();
default:
errx(1, "too many arguments. What do you mean by %s?",
argv[4]);
}
getformat();
if (prec == -1)
prec = 0;
while (mask) /* 4 bit mask has 1's where last 4 args were given */
switch (mask) { /* fill in the 0's by default or computation */
case HAVE_STEP:
case HAVE_ENDER:
case HAVE_ENDER | HAVE_STEP:
case HAVE_BEGIN:
case HAVE_BEGIN | HAVE_STEP:
reps = REPS_DEF;
mask |= HAVE_REPS;
break;
case HAVE_BEGIN | HAVE_ENDER:
s = ender > begin ? 1 : -1;
mask |= HAVE_STEP;
break;
case HAVE_BEGIN | HAVE_ENDER | HAVE_STEP:
if (randomize)
reps = REPS_DEF;
else if (s == 0.0)
reps = 0;
else
reps = (ender - begin + s) / s;
if (reps <= 0)
errx(1, "impossible stepsize");
mask = 0;
break;
case HAVE_REPS:
case HAVE_REPS | HAVE_STEP:
begin = BEGIN_DEF;
mask |= HAVE_BEGIN;
break;
case HAVE_REPS | HAVE_ENDER:
s = STEP_DEF;
mask = HAVE_REPS | HAVE_ENDER | HAVE_STEP;
break;
case HAVE_REPS | HAVE_ENDER | HAVE_STEP:
if (randomize)
begin = BEGIN_DEF;
else if (reps == 0)
errx(1, "must specify begin if reps == 0");
begin = ender - reps * s + s;
mask = 0;
break;
case HAVE_REPS | HAVE_BEGIN:
s = STEP_DEF;
mask = HAVE_REPS | HAVE_BEGIN | HAVE_STEP;
break;
case HAVE_REPS | HAVE_BEGIN | HAVE_STEP:
if (randomize)
ender = ENDER_DEF;
else
ender = begin + reps * s - s;
mask = 0;
break;
case HAVE_REPS | HAVE_BEGIN | HAVE_ENDER:
if (reps == 0)
errx(1, "infinite sequences cannot be bounded");
else if (reps == 1)
s = 0.0;
else
s = (ender - begin) / (reps - 1);
mask = 0;
break;
case HAVE_REPS | HAVE_BEGIN | HAVE_ENDER | HAVE_STEP:
/* if reps given and implied, */
if (!randomize && s != 0.0) {
long t = (ender - begin + s) / s;
if (t <= 0)
errx(1, "impossible stepsize");
if (t < reps) /* take lesser */
reps = t;
}
mask = 0;
break;
default:
errx(1, "bad mask");
}
if (reps == 0)
infinity = true;
if (randomize) {
if (use_random) {
srandom((unsigned long)s);
divisor = (double)INT32_MAX + 1;
} else
divisor = (double)UINT32_MAX + 1;
/*
* Attempt to DWIM when the user has specified an
* integer range within that of the random number
* generator: distribute the numbers equally in
* the range [begin .. ender]. Jot's default %.0f
* format would make the appearance of the first and
* last specified value half as likely as the rest.
*/
if (!have_format && prec == 0 &&
begin >= 0 && begin < divisor &&
ender >= 0 && ender < divisor) {
if (begin <= ender)
ender += 1;
else
begin += 1;
nosign = true;
intdata = true;
(void)strlcpy(format,
chardata ? "%c" : "%u", sizeof(format));
}
x = ender - begin;
for (i = 1; i <= reps || infinity; i++) {
if (use_random)
y = random() / divisor;
else
y = arc4random() / divisor;
if (putdata(y * x + begin, !(reps - i)))
errx(1, "range error in conversion");
}
} else
for (i = 1, x = begin; i <= reps || infinity; i++, x += s)
if (putdata(x, !(reps - i)))
errx(1, "range error in conversion");
if (!nofinalnl)
putchar('\n');
exit(0);
}
void simplifylist(char *var, statement *stmt, int start, int end)
{
int y = 0, channels = 0;
char tmp[MAX_STRING_LENGTH], *hex;
char *tmp1, *tmp2, *tmp3;
char *reorder[32]; int ctr = 0;
for (y=start; y<=end; y++) {
oppush(0);
if (get_sysvarname(stmt->metalist[y].operation)) {
sprintf(tmp, "%s", get_sysvarname(stmt->metalist[y].operation));
listpush(tmp);
} else if (get_fncname(stmt->metalist[y].operation)) {
if ((stmt->metalist[y].operation == OP_AND) ||
(stmt->metalist[y].operation == OP_OR) ||
(stmt->metalist[y].operation == OP_XOR)) goto blah;
sprintf(tmp, "%s(", get_fncname(stmt->metalist[y].operation));
if (stmt->metalist[y].intarg) {
for (ctr=0; ctr<stmt->metalist[y].intarg; ctr++) {
reorder[ctr] = SafeMalloc(MAX_STRING_LENGTH);
reorder[ctr] = listpop();
}
} else {
for (ctr=0; ctr<fnctable[get_fnc(get_fncname(stmt->metalist[y].
operation))].numparms; ctr++) {
reorder[ctr] = SafeMalloc(MAX_STRING_LENGTH);
reorder[ctr] = listpop();
}
}
for (ctr=ctr-1; ctr>=0; ctr--) {
strcat(tmp, reorder[ctr]);
if (ctr) strcat(tmp, ",");
}
strcat(tmp, ")");
listpush(tmp);
} else
blah:
switch(stmt->metalist[y].operation) {
case HEXSTRING:
hex = SafeMalloc(2+(stmt->metalist[y].intarg*2));
*hex = 0;
sprintf(tmp, "$");
for (ctr = 0; ctr < stmt->metalist[y].intarg; ctr++) {
sprintf(hex, "%X", stmt->metalist[y].stringarg[ctr]);
sprintf(hex, "%c%c", hex[strlen(hex)-2], hex[strlen(hex)-1]);
strcat(tmp, hex);
}
strcat(tmp, "$");
GC_free(hex);
listpush(tmp);
break;
case 0xF5:
if (stmt->opcode != CMD_DEFFN) listpush("<BEGINLIST>");
break;
case 0xF8:
if (stmt->opcode != CMD_DEFFN) {
ctr = 0;
do {
reorder[ctr] = SafeMalloc(MAX_STRING_LENGTH);
reorder[ctr] = listpop();
if (!strcmp(reorder[ctr], "<BEGINLIST>")) break;
ctr++;
} while(1);
sprintf(tmp, "%s(", listpop());
for (ctr = ctr-1; ctr >= 0; ctr--) {
strcat(tmp, reorder[ctr]);
if (ctr) strcat(tmp, ",");
}
strcat(tmp, ")");
listpush(tmp);
}
break;
case 0x8DC9:
listpush(gprog->userfunctions[stmt->metalist[y].shortarg].name);
break;
case 0xF1:
case 0xEC:
// workaround, LET handles its own commas
if (stmt->opcode != CMD_LET) {
sprintf(tmp, "%s,", listpop());
listpush(tmp);
for (ctr = 0; ctr < outcount; ctr++)
mysprintf(var, "%s", listpop());
}
break;
case 0xF4F1:
if (channels) mysprintf(var, ") ");
break;
case 0xE1:
channels = 1;
mysprintf(var, "(%s", listpop());
break;
case OP_OPT:
case OP_SEP:
case OP_SRT:
case OP_BNK:
case OP_DOM:
case OP_END:
case OP_IND:
case OP_IOL:
case OP_ISZ:
case OP_KEY:
case OP_SIZ:
case OP_TBL:
case OP_TIM:
case OP_ERR:
case OP_LEN:
case OP_PWD:
case OP_ATR:
if (channels)
mysprintf(var, ", %s=%s", get_symbol(stmt->metalist[y].operation), listpop());
else {
sprintf(tmp, "%s, %s=%s", listpop(), get_symbol(stmt->metalist[y].operation), listpop());
listpush(tmp);
}
break;
case LABELREF:
sprintf(tmp, "%s", get_labelname(stmt->metalist[y].shortarg));
listpush(tmp);
break;
case LINEREF:
sprintf(tmp, "%.5d", stmt->metalist[y].shortarg);
listpush(tmp);
break;
case MNEMONICREF:
sprintf(tmp, "\'%s\'", stmt->metalist[y].stringarg);
listpush(tmp);
break;
case 0xF7:
tmp2 = listpop();
sprintf(tmp, "@(%s,%s)", listpop(), tmp2);
listpush(tmp);
break;
case 0xF6:
sprintf(tmp, "@(%s)", listpop());
listpush(tmp);
break;
case FLOAT:
sprintf(tmp, "%s", flt2asc(stmt->metalist[y].floatarg));
listpush(tmp);
break;
case GETVAL_STRINGARRAY:
case SETVAL_STRINGARRAY:
case GETVAL_STRING:
case SETVAL_STRING:
ctr = stmt->metalist[y].shortarg;
tmp3 = SafeMalloc(MAX_STRING_LENGTH);
if (stmt->metalist[y].shortarg & 0x2000) {
ctr -= 0x2000;
sprintf(tmp3, "(%s)", listpop());
} else if (stmt->metalist[y].shortarg & 0x4000) {
ctr -= 0x4000;
tmp2 = listpop();
sprintf(tmp3, "(%s,%s)", listpop(), tmp2);
} else tmp3 = 0;
if (stmt->metalist[y].shortarg & 0x8000) {
ctr -= 0x8000;
if (stmt->metalist[y].operation == GETVAL_STRINGARRAY ||
stmt->metalist[y].operation == SETVAL_STRINGARRAY) {
tmp1 = listpop();
tmp2 = listpop();
sprintf(tmp, "[%s,%s,%s]", listpop(), tmp2, tmp1);
listpush(tmp);
} else {
sprintf(tmp, "[%s]", listpop());
listpush(tmp);
}
} else if (stmt->metalist[y].operation == GETVAL_STRINGARRAY ||
stmt->metalist[y].operation == SETVAL_STRINGARRAY) {
tmp1 = listpop();
sprintf(tmp, "[%s,%s]", listpop(), tmp1);
listpush(tmp);
} else listpush(""); // noarrayref
if (tmp3)
sprintf(tmp, "%s%s%s", get_symname(ctr), listpop(), tmp3);
else sprintf(tmp, "%s%s", get_symname(ctr), listpop());
GC_free(tmp3);
if ((stmt->metalist[y].operation == SETVAL_STRING) ||
(stmt->metalist[y].operation == SETVAL_STRINGARRAY)) {
if ((stmt->opcode == CMD_LET) || (stmt->opcode == CMD_FOR))
strcat(tmp, "=");
}
listpush(tmp);
break;
case GETVAL_NUMERIC:
case SETVAL_NUMERIC:
case GETVAL_NUMERICARRAY:
case SETVAL_NUMERICARRAY:
ctr = stmt->metalist[y].shortarg;
if (stmt->metalist[y].shortarg & 0x8000) {
ctr -= 0x8000;
if (stmt->metalist[y].operation == GETVAL_NUMERICARRAY ||
stmt->metalist[y].operation == SETVAL_NUMERICARRAY) {
tmp1 = listpop();
tmp2 = listpop();
sprintf(tmp, "[%s,%s,%s]", listpop(), tmp2, tmp1);
listpush(tmp);
} else {
sprintf(tmp, "[%s]", listpop());
listpush(tmp);
}
} else if (stmt->metalist[y].operation == GETVAL_NUMERICARRAY ||
stmt->metalist[y].operation == SETVAL_NUMERICARRAY) {
tmp1 = listpop();
sprintf(tmp, "[%s,%s]", listpop(), tmp1);
listpush(tmp);
} else listpush(""); // noarrayref
sprintf(tmp, "%s%s", get_symname(ctr), listpop());
if (stmt->metalist[y].operation == SETVAL_NUMERIC ||
stmt->metalist[y].operation == SETVAL_NUMERICARRAY)
if ((stmt->opcode == CMD_LET) || (stmt->opcode == CMD_FOR))
strcat(tmp, "=");
listpush(tmp);
break;
case SHORTLITERAL:
sprintf(tmp, "\"%s\"", stmt->metalist[y].stringarg);
listpush(tmp);
break;
case OP_NEGATE:
sprintf(tmp, "(-%s)", listpop());
listpush(tmp);
break;
case OP_STRCAT:
tmp2 = listpop();
sprintf(tmp, "%s+%s", listpop(), tmp2);
listpush(tmp);
break;
case OP_AND:
case OP_XOR:
case OP_OR:
case OP_LESSTHAN:
case OP_GREATTHAN:
case OP_NOTEQUAL:
case OP_EQUALSCMP:
case OP_LTEQ:
case OP_GTEQ:
case OP_ADD:
case OP_SUBTRACT:
case OP_MULTIPLY:
case OP_DIVIDE:
case OP_EXPONENT:
oppop();
if (oppop() >= getprec(get_symbol(stmt->metalist[y].operation))) {
tmp3 = listpop();
tmp1 = SafeMalloc(strlen(tmp3)+2);
sprintf(tmp1, "(%s)", tmp3);
} else tmp1 = listpop();
if (oppop() >= getprec(get_symbol(stmt->metalist[y].operation))) {
tmp3 = listpop();
tmp2 = SafeMalloc(strlen(tmp3)+2);
sprintf(tmp2, "(%s)", tmp3);
} else tmp2 = listpop();
oppush(getprec(get_symbol(stmt->metalist[y].operation)));
sprintf(tmp, "%s%s%s", tmp2, get_symbol(stmt->metalist[y].operation), tmp1);
listpush(tmp);
break;
}
}
}
int
main(int argc, char **argv)
{
double xd, yd;
long id;
double *x = &xd;
double *y = &yd;
long *i = &id;
unsigned int mask = 0;
int n = 0;
int ch;
while ((ch = getopt(argc, argv, "rb:w:cs:np:")) != -1)
switch ((char)ch) {
case 'r':
randomize = 1;
break;
case 'c':
chardata = 1;
break;
case 'n':
nofinalnl = 1;
break;
case 'b':
boring = 1;
/* FALLTHROUGH */
case 'w':
if (strlcpy(format, optarg, sizeof(format)) >=
sizeof(format))
errx(1, "-%c word too long", ch);
break;
case 's':
sepstring = optarg;
break;
case 'p':
prec = atoi(optarg);
if (prec <= 0)
errx(1, "bad precision value");
break;
default:
usage();
}
argc -= optind;
argv += optind;
switch (argc) { /* examine args right to left, falling thru cases */
case 4:
if (!is_default(argv[3])) {
if (!sscanf(argv[3], "%lf", &s))
errx(1, "bad s value: %s", argv[3]);
mask |= 01;
}
case 3:
if (!is_default(argv[2])) {
if (!sscanf(argv[2], "%lf", &ender))
ender = argv[2][strlen(argv[2])-1];
mask |= 02;
if (!prec)
n = getprec(argv[2]);
}
case 2:
if (!is_default(argv[1])) {
if (!sscanf(argv[1], "%lf", &begin))
begin = argv[1][strlen(argv[1])-1];
mask |= 04;
if (!prec)
prec = getprec(argv[1]);
if (n > prec) /* maximum precision */
prec = n;
}
case 1:
if (!is_default(argv[0])) {
if (!sscanf(argv[0], "%ld", &reps))
errx(1, "bad reps value: %s", argv[0]);
mask |= 010;
}
break;
case 0:
usage();
default:
errx(1, "too many arguments. What do you mean by %s?",
argv[4]);
}
getformat();
while (mask) /* 4 bit mask has 1's where last 4 args were given */
switch (mask) { /* fill in the 0's by default or computation */
case 001:
reps = REPS_DEF;
mask = 011;
break;
case 002:
reps = REPS_DEF;
mask = 012;
break;
case 003:
reps = REPS_DEF;
mask = 013;
break;
case 004:
reps = REPS_DEF;
mask = 014;
break;
case 005:
reps = REPS_DEF;
mask = 015;
break;
case 006:
reps = REPS_DEF;
mask = 016;
break;
case 007:
if (randomize) {
reps = REPS_DEF;
mask = 0;
break;
}
if (s == 0.0) {
reps = 0;
mask = 0;
break;
}
reps = (ender - begin + s) / s;
if (reps <= 0)
errx(1, "impossible stepsize");
mask = 0;
break;
case 010:
begin = BEGIN_DEF;
mask = 014;
break;
case 011:
begin = BEGIN_DEF;
mask = 015;
break;
case 012:
s = (randomize ? time(NULL) : STEP_DEF);
mask = 013;
break;
case 013:
if (randomize)
begin = BEGIN_DEF;
else if (reps == 0)
errx(1, "must specify begin if reps == 0");
begin = ender - reps * s + s;
mask = 0;
break;
case 014:
s = (randomize ? -1.0 : STEP_DEF);
mask = 015;
break;
case 015:
if (randomize)
ender = ENDER_DEF;
else
ender = begin + reps * s - s;
mask = 0;
break;
case 016:
if (randomize)
s = -1.0;
else if (reps == 0)
errx(1, "infinite sequences cannot be bounded");
else if (reps == 1)
s = 0.0;
else
s = (ender - begin) / (reps - 1);
mask = 0;
break;
case 017: /* if reps given and implied, */
if (!randomize && s != 0.0) {
long t = (ender - begin + s) / s;
if (t <= 0)
errx(1, "impossible stepsize");
if (t < reps) /* take lesser */
reps = t;
}
mask = 0;
break;
default:
errx(1, "bad mask");
}
if (reps == 0)
infinity = 1;
if (randomize) {
*x = (ender - begin) * (ender > begin ? 1 : -1);
for (*i = 1; *i <= reps || infinity; (*i)++) {
*y = arc4random() / (double)0xffffffffU;
if (putdata(*y * *x + begin, reps - *i))
errx(1, "range error in conversion");
}
} else
for (*i = 1, *x = begin; *i <= reps || infinity; (*i)++, *x += s)
if (putdata(*x, reps - *i))
errx(1, "range error in conversion");
if (!nofinalnl)
putchar('\n');
exit(0);
}
int
main(int argc, char *argv[])
{
double x;
double y;
long i;
unsigned int mask = 0;
int n = 0;
int ch;
const char *errstr;
while ((ch = getopt(argc, argv, "rb:w:cs:np:")) != -1)
switch (ch) {
case 'r':
randomize = true;
break;
case 'c':
chardata = true;
break;
case 'n':
finalnl = false;
break;
case 'b':
boring = true;
if (strlcpy(format, optarg, sizeof(format)) >=
sizeof(format))
errx(1, "-b word too long");
break;
case 'w':
if (strlcpy(format, optarg, sizeof(format)) >=
sizeof(format))
errx(1, "-w word too long");
break;
case 's':
if (strlcpy(sepstring, optarg, sizeof(sepstring)) >=
sizeof(sepstring))
errx(1, "-s word too long");
break;
case 'p':
prec = strtonum(optarg, 0, INT_MAX, &errstr);
if (errstr != NULL)
errx(1, "bad precision value, %s: %s", errstr,
optarg);
break;
default:
usage();
}
argc -= optind;
argv += optind;
switch (argc) { /* examine args right to left, falling thru cases */
case 4:
if (!is_default(argv[3])) {
if (!sscanf(argv[3], "%lf", &s))
errx(1, "Bad s value: %s", argv[3]);
mask |= 01;
if (randomize)
warnx("random seeding not supported");
}
case 3:
if (!is_default(argv[2])) {
if (!sscanf(argv[2], "%lf", &ender))
ender = argv[2][strlen(argv[2])-1];
mask |= 02;
if (prec == -1)
n = getprec(argv[2]);
}
case 2:
if (!is_default(argv[1])) {
if (!sscanf(argv[1], "%lf", &begin))
begin = argv[1][strlen(argv[1])-1];
mask |= 04;
if (prec == -1)
prec = getprec(argv[1]);
if (n > prec) /* maximum precision */
prec = n;
}
case 1:
if (!is_default(argv[0])) {
if (!sscanf(argv[0], "%ld", &reps))
errx(1, "Bad reps value: %s", argv[0]);
mask |= 010;
if (prec == -1)
prec = 0;
}
break;
case 0:
usage();
break;
default:
errx(1, "Too many arguments. What do you mean by %s?",
argv[4]);
}
getformat();
while (mask) /* 4 bit mask has 1's where last 4 args were given */
switch (mask) { /* fill in the 0's by default or computation */
case 001:
reps = REPS_DEF;
mask = 011;
break;
case 002:
reps = REPS_DEF;
mask = 012;
break;
case 003:
reps = REPS_DEF;
mask = 013;
break;
case 004:
reps = REPS_DEF;
mask = 014;
break;
case 005:
reps = REPS_DEF;
mask = 015;
break;
case 006:
reps = REPS_DEF;
mask = 016;
break;
case 007:
if (randomize) {
reps = REPS_DEF;
mask = 0;
break;
}
if (s == 0.0) {
reps = 0;
mask = 0;
break;
}
reps = (ender - begin + s) / s;
if (reps <= 0)
errx(1, "Impossible stepsize");
mask = 0;
break;
case 010:
begin = BEGIN_DEF;
mask = 014;
break;
case 011:
begin = BEGIN_DEF;
mask = 015;
break;
case 012:
s = STEP_DEF;
mask = 013;
break;
case 013:
if (randomize)
begin = BEGIN_DEF;
else if (reps == 0)
errx(1, "Must specify begin if reps == 0");
begin = ender - reps * s + s;
mask = 0;
break;
case 014:
s = STEP_DEF;
mask = 015;
break;
case 015:
if (randomize)
ender = ENDER_DEF;
else
ender = begin + reps * s - s;
mask = 0;
break;
case 016:
if (reps == 0)
errx(1, "Infinite sequences cannot be bounded");
else if (reps == 1)
s = 0.0;
else
s = (ender - begin) / (reps - 1);
mask = 0;
break;
case 017: /* if reps given and implied, */
if (!randomize && s != 0.0) {
long t = (ender - begin + s) / s;
if (t <= 0)
errx(1, "Impossible stepsize");
if (t < reps) /* take lesser */
reps = t;
}
mask = 0;
break;
default:
errx(1, "bad mask");
}
if (reps == 0)
infinity = true;
if (randomize) {
x = (ender - begin) * (ender > begin ? 1 : -1);
for (i = 1; i <= reps || infinity; i++) {
double v;
y = arc4random() / ((double)0xffffffff + 1);
v = y * x + begin;
if (putdata(v, reps == i && !infinity))
errx(1, "range error in conversion: %f", v);
}
}
else
for (i = 1, x = begin; i <= reps || infinity; i++, x += s)
if (putdata(x, reps == i && !infinity))
errx(1, "range error in conversion: %f", x);
if (finalnl)
putchar('\n');
exit(0);
}
