unsigned short disrus(
struct tcp_chan *chan,
int *retval)
{
int locret;
int negate;
unsigned value;
assert(retval != NULL);
locret = disrsi_(chan, &negate, &value, 1, pbs_tcp_timeout);
if (locret != DIS_SUCCESS)
{
value = 0;
}
else if (negate)
{
value = 0;
locret = DIS_BADSIGN;
}
else if (value > USHRT_MAX)
{
value = USHRT_MAX;
locret = DIS_OVERFLOW;
}
*retval = (tcp_rcommit(chan, locret == DIS_SUCCESS) < 0) ?
DIS_NOCOMMIT : locret;
return ((unsigned short)value);
}
char *disrst(
struct tcp_chan *chan,
int *retval)
{
int locret;
int negate;
unsigned int count;
char *value = NULL;
assert(retval != NULL);
locret = disrsi_(chan, &negate, &count, 1);
if (locret == DIS_SUCCESS)
{
if (negate)
{
locret = DIS_BADSIGN;
}
else
{
value = (char *)calloc(1, (size_t)count + 1);
if (value == NULL)
{
locret = DIS_NOMALLOC;
}
else
{
if (tcp_gets(chan, value, (size_t)count) != (int)count)
locret = DIS_PROTO;
#ifndef NDEBUG
else if (memchr(value, 0, (size_t)count))
locret = DIS_NULLSTR;
#endif
else
value[count] = '\0';
}
}
locret = (tcp_rcommit(chan, locret == DIS_SUCCESS) < 0) ? DIS_NOCOMMIT : locret;
}
*retval = locret;
if ((locret != DIS_SUCCESS) && (value != NULL))
{
free(value);
value = NULL;
}
return(value);
} /* END disrst() */
int disrfst(
struct tcp_chan *chan,
size_t achars,
char *value)
{
int locret;
/*int rc;*/
int negate;
unsigned count;
assert(value != NULL);
locret = disrsi_(chan, &negate, &count, 1, pbs_tcp_timeout);
if (locret == DIS_SUCCESS)
{
if (negate)
locret = DIS_BADSIGN;
else if (count > achars)
locret = DIS_OVERFLOW;
else if (tcp_gets(chan, value, (size_t)count, pbs_tcp_timeout) != (int)count)
locret = DIS_PROTO;
#ifndef NDEBUG
else if (memchr(value, 0, (size_t)count))
locret = DIS_NULLSTR;
#endif
else
value[count] = '\0';
}
/*
if (locret == DIS_SUCCESS)
rc = tcp_rcommit(chan,TRUE);
else
rc = tcp_rcommit(chan,FALSE);
locret = (rc != 0) ? rc : DIS_NOCOMMIT;
*/
locret = tcp_rcommit(chan, locret == DIS_SUCCESS) ?
DIS_NOCOMMIT :
locret;
if (locret != DIS_SUCCESS)
*value = '\0';
return(locret);
} /* END disrfst() */
char *disrcs(
struct tcp_chan *chan,
size_t *nchars,
int *retval)
{
int locret;
int negate;
unsigned count = 0;
char *value = NULL;
assert(nchars != NULL);
assert(retval != NULL);
locret = disrsi_(chan, &negate, &count, 1);
locret = negate ? DIS_BADSIGN : locret;
if (locret == DIS_SUCCESS)
{
value = (char *)calloc(1, (size_t)count + 1);
if (value == NULL)
locret = DIS_NOMALLOC;
else
{
if (tcp_gets(chan, value,
(size_t)count) != (int)count)
locret = DIS_PROTO;
else
value[count] = '\0';
}
}
locret = (tcp_rcommit(chan, locret == DIS_SUCCESS) < 0) ?
DIS_NOCOMMIT : locret;
if ((*retval = locret) != DIS_SUCCESS && value != NULL)
{
count = 0;
free(value);
value = NULL;
}
*nchars = count;
return (value);
}
int disrsi(
struct tcp_chan *chan,
int *retval)
{
int locret;
int negate;
int value = 0;
unsigned uvalue;
assert(retval != NULL);
switch (locret = disrsi_(chan, &negate, &uvalue, 1, pbs_tcp_timeout))
{
case DIS_SUCCESS:
if (negate ? uvalue <= (unsigned) - (INT_MIN + 1) + 1 : uvalue <= (unsigned)INT_MAX)
{
value = negate ? -uvalue : uvalue;
*retval = (tcp_rcommit(chan, locret == DIS_SUCCESS) < 0) ? DIS_NOCOMMIT : locret;
break;
}
else
{
locret = DIS_OVERFLOW;
*retval = locret;
}
case DIS_OVERFLOW:
value = negate ? INT_MIN : INT_MAX;
*retval = locret;
break;
default:
*retval = locret;
break;
}
return(value);
}
long disrsl(
struct tcp_chan *chan,
int *retval)
{
int locret;
int negate;
long value;
unsigned long uvalue;
assert(retval != NULL);
value = 0;
switch (locret = disrsl_(chan, &negate, &uvalue, 1))
{
case DIS_SUCCESS:
if (negate ? uvalue <= (unsigned long) - (LONG_MIN + 1) + 1 :
uvalue <= LONG_MAX)
{
value = negate ? -uvalue : uvalue;
break;
}
else
locret = DIS_OVERFLOW;
case DIS_OVERFLOW:
value = negate ? LONG_MIN : LONG_MAX;
}
*retval = (tcp_rcommit(chan, locret == DIS_SUCCESS) < 0) ?
DIS_NOCOMMIT : locret;
return (value);
}
short disrss(
struct tcp_chan *chan,
int *retval)
{
int locret;
int negate;
short value;
unsigned uvalue;
assert(retval != NULL);
value = 0;
switch (locret = disrsi_(chan, &negate, &uvalue, 1))
{
case DIS_SUCCESS:
if (negate ? (int) - uvalue >= SHRT_MIN : uvalue <= SHRT_MAX)
{
value = negate ? -uvalue : uvalue;
break;
}
else
locret = DIS_OVERFLOW;
case DIS_OVERFLOW:
value = negate ? SHRT_MIN : SHRT_MAX;
}
*retval = (tcp_rcommit(chan, locret == DIS_SUCCESS) < 0) ?
DIS_NOCOMMIT : locret;
return (value);
}
double disrd(
struct tcp_chan *chan,
int *retval)
{
int expon;
unsigned uexpon;
int locret;
int negate;
unsigned ndigs;
unsigned nskips;
dis_long_double_t ldval;
assert(retval != NULL);
ldval = 0.0L;
locret = disrl_(chan, &ldval, &ndigs, &nskips, DBL_DIG, 1);
if (locret == DIS_SUCCESS)
{
locret = disrsi_(chan, &negate, &uexpon, 1);
if (locret == DIS_SUCCESS)
{
expon = negate ? nskips - uexpon : nskips + uexpon;
if (expon + (int)ndigs > DBL_MAX_10_EXP)
{
if (expon + (int)ndigs > DBL_MAX_10_EXP + 1)
{
ldval = ldval < 0.0L ?
-HUGE_VAL : HUGE_VAL;
locret = DIS_OVERFLOW;
}
else
{
ldval *= disp10l_(expon - 1);
if (ldval > DBL_MAX / 10.0L)
{
ldval = ldval < 0.0L ?
-HUGE_VAL : HUGE_VAL;
locret = DIS_OVERFLOW;
}
else
ldval *= 10.0L;
}
}
else
{
if (expon < LDBL_MIN_10_EXP)
{
ldval *= disp10l_(expon + (int)ndigs);
ldval /= disp10l_((int)ndigs);
}
else
ldval *= disp10l_(expon);
}
}
}
if (tcp_rcommit(chan, locret == DIS_SUCCESS) < 0)
locret = DIS_NOCOMMIT;
*retval = locret;
return((double)ldval);
}
