DB_STATUS
adu_uuid_to_char(
ADF_CB *adf_scb,
DB_DATA_VALUE *dv1,
DB_DATA_VALUE *rdv)
{
char d[100];
DB_STATUS db_stat;
UUID u1;
UUID *uuid;
/* Verify the operand is a UUID */
if (dv1->db_datatype != DB_BYTE_TYPE)
{
db_stat = adu_error(adf_scb, E_AD9998_INTERNAL_ERROR, 2, 0 ,"uuid_to_char type");
return(db_stat);
}
if ((ME_ALIGN_MACRO((PTR)dv1->db_data, sizeof(ALIGN_RESTRICT))
!= (PTR)dv1->db_data) ||
(dv1->db_length != sizeof(UUID)))
{
uuid = &u1;
uuid_format(dv1, uuid);
}
else
uuid = (UUID *)dv1->db_data;
db_stat = IDuuid_to_string(uuid, d);
if (db_stat = adu_movestring(adf_scb, (u_char *)d,(i4) STlength(d), dv1->db_datatype, rdv))
return (db_stat);
return(E_DB_OK);
}
DB_STATUS
adu_copascii(
ADF_CB *adf_scb,
DB_DATA_VALUE *dv1,
DB_DATA_VALUE *rdv)
{
register char *p;
char temp[ADI_OUTMXFIELD];
i4 leftfill;
i4 plen;
i4 str_len;
i2 out_width;
p = temp;
switch(dv1->db_datatype)
{
case DB_INT_TYPE:
if (dv1->db_length == 8)
{
CVla8(*(i8 *) dv1->db_data, p);
}
else if (dv1->db_length == 4)
{
CVla(*(i4 *) dv1->db_data, p);
}
else if (dv1->db_length == 2)
{
CVla((i4) *(i2 *) dv1->db_data, p);
}
else
{
CVla(I1_CHECK_MACRO(*(i1 *) dv1->db_data), p);
}
break;
case DB_DEC_TYPE:
{
i4 pr = DB_P_DECODE_MACRO(dv1->db_prec);
i4 sc = DB_S_DECODE_MACRO(dv1->db_prec);
i4 available_width = rdv->db_length;
char decimal = (adf_scb->adf_decimal.db_decspec
? (char) adf_scb->adf_decimal.db_decimal
: '.'
);
if ( rdv->db_datatype == DB_VCH_TYPE
|| rdv->db_datatype == DB_TXT_TYPE
|| rdv->db_datatype == DB_LTXT_TYPE
)
available_width -= DB_CNTSIZE;
/* now convert to ascii: use formula from lenspec for length, get
** scale # of digits after decimal point, use left-justify
*/
if (CVpka((PTR)dv1->db_data, pr, sc, decimal,
AD_PS_TO_PRN_MACRO(pr, sc), sc, CV_PKLEFTJUST, p, &str_len)
== CV_OVERFLOW)
{
/* this should never happen */
return(adu_error(adf_scb, E_AD9999_INTERNAL_ERROR, 0));
}
if (str_len > available_width)
return(adu_error(adf_scb, E_AD1030_F_COPY_STR_TOOSHORT, 0));
}
break;
case DB_FLT_TYPE:
{
char decimal = (adf_scb->adf_decimal.db_decspec ?
(char) adf_scb->adf_decimal.db_decimal : '.');
i4 available_width = rdv->db_length;
if ( rdv->db_datatype == DB_VCH_TYPE
|| rdv->db_datatype == DB_TXT_TYPE
|| rdv->db_datatype == DB_LTXT_TYPE
)
available_width -= DB_CNTSIZE;
if (dv1->db_length == 4)
{
f8 f8tmp = (f8) *(f4 *) dv1->db_data;
/* BUG : b119968
**
** CVfa is a utility routine for both f8 and f4 floats.
** In the f4 case, the value is converted to f8 prior
** to call (as here).
**
** This works well except for the boundary case, where
** the f4 is FLT_MAX. In this case, an effective
** rounding up of the f8 that occurs as we convert to
** a string (eventually through fcvt) "overflows" the
** original f4 value.
**
** We bump down the last sig bit of the f4, and then
** we have no problems.
*/
if ( f8tmp == FLT_MAX )
{
f8tmp = FLT_MAX_ROUND;
}
else if ( f8tmp == -FLT_MAX )
{
f8tmp = -FLT_MAX_ROUND;
}
CVfa(f8tmp,
adf_scb->adf_outarg.ad_f4width,
adf_scb->adf_outarg.ad_f4prec,
adf_scb->adf_outarg.ad_f4style,
decimal, p, &out_width);
if (out_width > available_width)
return(adu_error(adf_scb, E_AD1030_F_COPY_STR_TOOSHORT, 0));
}
else
{
CVfa(*(f8 *)dv1->db_data,
adf_scb->adf_outarg.ad_f8width,
adf_scb->adf_outarg.ad_f8prec,
adf_scb->adf_outarg.ad_f8style,
decimal, p, &out_width);
if (out_width > available_width)
return(adu_error(adf_scb, E_AD1030_F_COPY_STR_TOOSHORT, 0));
}
}
break;
default:
return(adu_error(adf_scb, E_AD5002_BAD_NUMBER_TYPE, 0));
}
while (*p == ' ')
p++;
/*
** TEXT, VARCHAR, and LONGTEXT are variable length copies,
** so no need to pad on the left.
*/
if ( rdv->db_datatype == DB_TXT_TYPE
|| rdv->db_datatype == DB_VCH_TYPE
|| rdv->db_datatype == DB_LTXT_TYPE
)
{
return(adu_movestring(adf_scb, (u_char *) p,
(i4) STlength(p), dv1->db_datatype, rdv));
}
/*
** At this point the result type can be C or CHAR
*/
plen = min(STlength(p), rdv->db_length);
leftfill = rdv->db_length - plen;
MEfill(leftfill, ' ', rdv->db_data);
MEcopy((PTR)p, plen, (PTR)((char *)rdv->db_data + leftfill));
return(E_DB_OK);
}
DB_STATUS
adu_ascii(
ADF_CB *adf_scb,
register DB_DATA_VALUE *dv1,
DB_DATA_VALUE *rdv)
{
DB_STATUS db_stat = E_DB_OK;
register char *p;
char temp[ADI_OUTMXFIELD]; /* could probably be smaller */
u_char *str_addr;
i4 str_len;
i2 reswidth;
bool char_text = FALSE;
i8 i8_tmp = 0;
p = temp;
switch(dv1->db_datatype)
{
case DB_INT_TYPE:
if (dv1->db_length == 8)
{
CVla8(*(i8 *) dv1->db_data, p);
}
else if (dv1->db_length == 4)
{
CVla(*(i4 *) dv1->db_data, p);
}
else if (dv1->db_length == 2)
{
CVla((i4) (*(i2 *) dv1->db_data), p);
}
else
{
CVla(I1_CHECK_MACRO(*(i1 *) dv1->db_data), p);
}
break;
case DB_BOO_TYPE:
if (((DB_ANYTYPE *)dv1->db_data)->db_booltype == DB_FALSE)
STcopy("FALSE", p);
else
STcopy("TRUE", p);
break;
case DB_VCH_TYPE:
case DB_CHA_TYPE:
case DB_CHR_TYPE:
case DB_TXT_TYPE:
case DB_LTXT_TYPE:
case DB_BYTE_TYPE:
case DB_VBYTE_TYPE:
if ((db_stat = adu_3straddr(adf_scb, dv1, (char **) &str_addr)))
return(db_stat);
if ((db_stat = adu_size(adf_scb, dv1, &str_len)))
return(db_stat);
if ((db_stat = adu_movestring(adf_scb, str_addr, str_len,
dv1->db_datatype, rdv)))
return(db_stat);
char_text = TRUE;
break;
case DB_DEC_TYPE:
{
i4 pr = DB_P_DECODE_MACRO(dv1->db_prec);
i4 sc = DB_S_DECODE_MACRO(dv1->db_prec);
char decimal = (adf_scb->adf_decimal.db_decspec
? (char) adf_scb->adf_decimal.db_decimal
: '.'
);
/* now convert to ascii: use formula from lenspec for length, get
** scale # of digits after decimal point, use left-justify option
*/
if (CVpka((PTR)dv1->db_data, pr, sc, decimal,
AD_PS_TO_PRN_MACRO(pr, sc), sc, CV_PKLEFTJUST, p, &str_len)
== CV_OVERFLOW)
{
/* this should never happen */
return(adu_error(adf_scb, E_AD9999_INTERNAL_ERROR, 0));
}
}
break;
case DB_FLT_TYPE:
{
char decimal = (adf_scb->adf_decimal.db_decspec ?
(char) adf_scb->adf_decimal.db_decimal : '.');
if (dv1->db_length == 4)
{
CVfa((f8) *(f4 *) dv1->db_data,
adf_scb->adf_outarg.ad_f4width,
adf_scb->adf_outarg.ad_f4prec,
adf_scb->adf_outarg.ad_f4style,
decimal, p, &reswidth);
}
else
{
CVfa(*(f8 *)dv1->db_data,
adf_scb->adf_outarg.ad_f8width,
adf_scb->adf_outarg.ad_f8prec,
adf_scb->adf_outarg.ad_f8style,
decimal, p, &reswidth);
}
}
break;
case DB_DTE_TYPE:
case DB_ADTE_TYPE:
case DB_TMWO_TYPE:
case DB_TMW_TYPE:
case DB_TME_TYPE:
case DB_TSWO_TYPE:
case DB_TSW_TYPE:
case DB_TSTMP_TYPE:
case DB_INYM_TYPE:
case DB_INDS_TYPE:
return( adu_6datetostr( adf_scb, dv1, rdv));
case DB_MNY_TYPE:
return( adu_9mnytostr( adf_scb, dv1, rdv));
case DB_LVCH_TYPE:
case DB_LBYTE_TYPE:
case DB_GEOM_TYPE:
case DB_POINT_TYPE:
case DB_MPOINT_TYPE:
case DB_LINE_TYPE:
case DB_MLINE_TYPE:
case DB_POLY_TYPE:
case DB_MPOLY_TYPE:
case DB_GEOMC_TYPE:
case DB_LNVCHR_TYPE:
case DB_LCLOC_TYPE:
case DB_LBLOC_TYPE:
case DB_LNLOC_TYPE:
return( adu_lvch_move( adf_scb, dv1, rdv));
case DB_BIT_TYPE:
case DB_VBIT_TYPE:
return( adu_bit2str( adf_scb, dv1, rdv));
case DB_LOGKEY_TYPE:
case DB_TABKEY_TYPE:
return( adu_3logkeytostr( adf_scb, dv1, rdv));
default:
return(adu_error(adf_scb, E_AD2090_BAD_DT_FOR_STRFUNC, 0));
}
if (!char_text)
{
if ((db_stat = adu_movestring(adf_scb, (u_char *) p,
(i4) STlength(p),
dv1->db_datatype, rdv))
!= E_DB_OK
)
return(db_stat);
}
return(E_DB_OK);
}
