VOID
adu_2prvalue(
i4 (*fcn)(char *, ...),
DB_DATA_VALUE *db_dv)
{
char num_buf[64];
i2 flt_wid;
f8 f8_tmp;
AD_DTUNION *dp;
DB_TAB_LOGKEY_INTERNAL *tab_logkey;
DB_OBJ_LOGKEY_INTERNAL *obj_logkey;
DB_DT_ID bdt;
i4 blen;
i4 prec;
char *data;
char fmt[16];
i4 tmp;
i4 tcnt;
i4 i;
i4 res_wid;
i8 i8_tmp;
f4 f4_tmp;
i4 i4_tmp;
i2 i2_tmp, i2_tmp2;
i1 i1_tmp;
char stbuf[2048];
if (db_dv == NULL)
{
(*fcn)(STprintf(stbuf,"< Pointer to DB_DATA_VALUE is NULL >\n"));
return;
}
bdt = abs(db_dv->db_datatype);
blen = db_dv->db_length - (db_dv->db_datatype < 0);
prec = db_dv->db_prec;
data = db_dv->db_data;
dp = (AD_DTUNION*)data;
if (data == NULL)
{
(*fcn)(STprintf(stbuf,"< pointer to data is NULL >\n"));
}
else if (ADI_ISNULL_MACRO(db_dv))
{
(*fcn)(STprintf(stbuf,"< NULL >\n"));
}
else
{
switch (bdt)
{
case DB_LOGKEY_TYPE:
obj_logkey = (DB_OBJ_LOGKEY_INTERNAL *) data;
(*fcn)(STprintf(stbuf, "olk_db_id = %x\tolk_rel_id = %x\n",
obj_logkey->olk_db_id, obj_logkey->olk_rel_id));
(*fcn)(STprintf(stbuf, "olk_high_id = %x\tolk_low_id = %x\n",
obj_logkey->olk_high_id, obj_logkey->olk_low_id));
break;
case DB_TABKEY_TYPE:
tab_logkey = (DB_TAB_LOGKEY_INTERNAL *) data;
(*fcn)(STprintf(stbuf, "tlk_high_id = %x\ttlk_low_id = %x\n",
tab_logkey->tlk_high_id, tab_logkey->tlk_low_id));
break;
case DB_CHA_TYPE:
case DB_CHR_TYPE:
case DB_BYTE_TYPE:
if (blen == 0)
{
(*fcn)(STprintf(stbuf,"''"));
break;
}
(*fcn)(STprintf(stbuf, "'%*s'", blen, (u_char *) data));
break;
case DB_DTE_TYPE:
(*fcn)(STprintf(stbuf,
"dn_status = %x\tdn_highday = %d\tdn_time = %d\n",
dp->ing_date.dn_status, dp->ing_date.dn_highday, dp->ing_date.dn_time));
(*fcn)(STprintf(stbuf,
"dn_year = %d\tdn_month = %d\tdn_lowday = %d",
dp->ing_date.dn_year, dp->ing_date.dn_month, dp->ing_date.dn_lowday));
break;
case DB_ADTE_TYPE:
(*fcn)(STprintf(stbuf,"dn_year = %d\tdn_month = %d\tdn_day = %d\n",
dp->adate.dn_year, dp->adate.dn_month, dp->adate.dn_day));
break;
case DB_TMWO_TYPE:
case DB_TMW_TYPE:
case DB_TME_TYPE:
(*fcn)(STprintf(stbuf,"dn_seconds = %d\tdn_nsecond = %d\n",
dp->atime.dn_seconds, dp->atime.dn_nsecond));
(*fcn)(STprintf(stbuf,"dn_tzoffset = %d\n",
AD_TZ_OFFSET(&dp->atime)));
break;
case DB_INYM_TYPE:
(*fcn)(STprintf(stbuf,"dn_years = %d\tdn_months = %d\n",
dp->aintym.dn_years, dp->aintym.dn_months));
break;
case DB_INDS_TYPE:
(*fcn)(STprintf(stbuf,"dn_days = %d\tdn_seconds = %d\tdn_nseconds = %d\n",
dp->aintds.dn_days, dp->aintds.dn_seconds, dp->aintds.dn_nseconds));
break;
case DB_TSWO_TYPE:
case DB_TSW_TYPE:
case DB_TSTMP_TYPE:
(*fcn)(STprintf(stbuf,"dn_year = %d\tdn_month = %d\tdn_day = %d\n",
dp->atimestamp.dn_year, dp->atimestamp.dn_month, dp->atimestamp.dn_day));
(*fcn)(STprintf(stbuf,"dn_seconds = %d\tdn_nsecond = %d\n",
dp->atimestamp.dn_seconds, dp->atimestamp.dn_nsecond));
(*fcn)(STprintf(stbuf,"dn_tzoffset = %d\n",
AD_TZ_OFFSET(&dp->atimestamp)));
break;
case DB_DEC_TYPE:
CVpka(data,
(i4)DB_P_DECODE_MACRO(prec),
(i4)DB_S_DECODE_MACRO(prec),
'.',
(i4)DB_P_DECODE_MACRO(prec) + 5,
(i4)DB_S_DECODE_MACRO(prec),
CV_PKLEFTJUST,
num_buf,
&res_wid);
tmp = res_wid;
i = 0;
fmt[i++] = '%';
if (tmp >= 10)
{
fmt[i++] = (tmp / 10) + '0';
tmp = tmp % 10;
}
fmt[i++] = tmp + '0';
fmt[i++] = 's';
fmt[i] = EOS;
(*fcn)(STprintf(stbuf, fmt, num_buf));
break;
case DB_FLT_TYPE:
if (blen == 4)
{
F4ASSIGN_MACRO(*data, f4_tmp);
f8_tmp = f4_tmp;
}
else
F8ASSIGN_MACRO(*data, f8_tmp);
CVfa(f8_tmp, (i4) sizeof(num_buf), (i4) 4, 'f', '.', num_buf, &flt_wid);
(*fcn)(STprintf(stbuf, "%*s", flt_wid, (u_char *)num_buf));
break;
case DB_INT_TYPE:
if (blen == 4)
{
I4ASSIGN_MACRO(*data, i4_tmp);
}
else if (blen == 2)
{
I2ASSIGN_MACRO(*data, i2_tmp);
i4_tmp = i2_tmp;
}
else if (blen == 1)
{
i4_tmp = I1_CHECK_MACRO(*(i1 *)data);
}
else /* blen == 8 */
{
/* Depending on host, printing i8's might be %ld (lp64)
** or %lld (lpi32). Avoid issues by converting to string.
*/
I8ASSIGN_MACRO(*data,i8_tmp);
CVla8(i8_tmp,&num_buf[0]);
(*fcn)(num_buf);
break;
}
(*fcn)(STprintf(stbuf, "%d", i4_tmp));
break;
case DB_MNY_TYPE:
f8_tmp = ((AD_MONEYNTRNL *) data)->mny_cents / 100.0;
CVfa(f8_tmp, 32, 2, 'f', '.', num_buf, &flt_wid);
tmp = flt_wid;
i = 0;
fmt[i++] = '%';
if (flt_wid >= 100)
{
fmt[i++] = (tmp / 100) + '0';
tmp = tmp % 100;
}
if (flt_wid >= 10)
{
fmt[i++] = (tmp / 10) + '0';
tmp = tmp % 10;
}
fmt[i++] = tmp + '0';
fmt[i++] = 's';
fmt[i] = EOS;
(*fcn)(STprintf(stbuf, fmt, num_buf));
break;
case DB_VCH_TYPE:
case DB_TXT_TYPE:
case DB_LTXT_TYPE:
case DB_VBYTE_TYPE:
I2ASSIGN_MACRO(((DB_TEXT_STRING *)data)->db_t_count, i2_tmp);
if (i2_tmp == 0)
{
(*fcn)(STprintf(stbuf,"''"));
break;
}
(*fcn)(STprintf(stbuf, "'%*s'", i2_tmp, ((DB_TEXT_STRING *) data)->db_t_text));
break;
case DB_BOO_TYPE:
if (*((bool *) data))
(*fcn)(STprintf(stbuf,"TRUE"));
else
(*fcn)(STprintf(stbuf,"FALSE"));
break;
case DB_NCHR_TYPE:
for(i=0; i< blen/2; i++)
{
I2ASSIGN_MACRO(data[2*i], i2_tmp);
i4_tmp = i2_tmp;
(*fcn)(STprintf(stbuf,"%x ", i4_tmp));
}
break;
case DB_NVCHR_TYPE:
case DB_PAT_TYPE:
I2ASSIGN_MACRO(((DB_NVCHR_STRING *)data)->count, i2_tmp);
if (bdt == DB_PAT_TYPE)
i2_tmp = 4;
for(i=0; i< i2_tmp; i++)
{
I2ASSIGN_MACRO(((DB_NVCHR_STRING *)data)->element_array[i], i2_tmp2);
i4_tmp = i2_tmp2;
(*fcn)(STprintf(stbuf,"%x ", i4_tmp));
}
break;
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:
{
ADP_PERIPHERAL *p = (ADP_PERIPHERAL *) data;
ADP_COUPON *cpn;
(*fcn)(STprintf(stbuf, "%s/length = (%d., %0d.): ",
(p->per_tag == ADP_P_COUPON ? "ADP_P_COUPON" :
"ADP_P_DATA"),
p->per_length0, p->per_length1));
if (p->per_tag == ADP_P_COUPON)
{
cpn = &p->per_value.val_coupon;
#if defined(axp_osf) || defined(ris_u64) || defined(LP64) || \
defined(axp_lnx)
(*fcn)(STprintf(stbuf, "(%d.,%d.,%d.,%d.,%d.,%d.)",
cpn->cpn_id[0],cpn->cpn_id[1],
cpn->cpn_id[2],cpn->cpn_id[3],
cpn->cpn_id[4],cpn->cpn_id[5]));
#else
(*fcn)(STprintf(stbuf, "(%d.,%d.,%d.,%d.,%d.)",
cpn->cpn_id[0],cpn->cpn_id[1],
cpn->cpn_id[2],cpn->cpn_id[3],
cpn->cpn_id[4]));
#endif
}
else
{
(*fcn)(STprintf(stbuf, "(first %d. of value) '%t'",
min(100, p->per_length1),
min(100, p->per_length1),
p->per_value.val_value));
}
}
break;
default:
(*fcn)(STprintf(stbuf,
"< unknown type: don't know how to interpret data >"));
break;
}
}
return;
}
VOID
adu_prdv(
DB_DATA_VALUE *db_dv)
{
DB_DT_ID dt;
DB_DT_ID bdt;
i4 len;
i4 blen;
PTR data;
if (db_dv == NULL)
{
TRdisplay("< Pointer to DB_DATA_VALUE is NULL >\n");
return;
}
dt = bdt = db_dv->db_datatype;
len = blen = db_dv->db_length;
data = db_dv->db_data;
if (dt < 0)
{
bdt = -dt;
blen--;
}
TRdisplay("type: %d (", (i4) dt);
adu_prtype(db_dv);
TRdisplay("); prec: [%d,%d] length: %d\n",
(i4)DB_P_DECODE_MACRO(db_dv->db_prec),
(i4)DB_S_DECODE_MACRO(db_dv->db_prec),
(i4) len);
if (data == NULL)
{
TRdisplay("< pointer to data is NULL >\n");
}
else if (ADI_ISNULL_MACRO(db_dv))
{
TRdisplay("value: < NULL >\n");
}
else
{
switch (bdt)
{
case DB_CHA_TYPE:
case DB_CHR_TYPE:
case DB_DEC_TYPE:
case DB_FLT_TYPE:
case DB_INT_TYPE:
case DB_MNY_TYPE:
case DB_BOO_TYPE:
case DB_LOGKEY_TYPE:
case DB_TABKEY_TYPE:
case DB_BYTE_TYPE:
case DB_NCHR_TYPE:
TRdisplay("value: ");
break;
case DB_VCH_TYPE:
TRdisplay("varchar count: %d\n",
((DB_TEXT_STRING *) data)->db_t_count);
break;
case DB_VBYTE_TYPE:
TRdisplay("varbyte count: %d\n",
((DB_TEXT_STRING *) data)->db_t_count);
break;
case DB_PAT_TYPE:
TRdisplay("pattern length: %d\n",
((DB_TEXT_STRING *) data)->db_t_count);
break;
case DB_TXT_TYPE:
TRdisplay("text count: %d\n",
((DB_TEXT_STRING *) data)->db_t_count);
break;
case DB_LTXT_TYPE:
TRdisplay("longtext count: %d\n",
((DB_TEXT_STRING *) data)->db_t_count);
break;
case DB_NVCHR_TYPE:
TRdisplay("nvarchar count: %d\n",
((DB_NVCHR_STRING *) data)->count);
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:
default:
break;
}
adu_prvalue(db_dv);
TRdisplay("\n");
}
return;
}
/*{
** Name: adu_rdm2_finish - Finish Redeeming an ADF_COUPON
**
** Description:
** This routine completes the action of redeeming a coupon.
** If running in test mode, this routine makes sure that the
** varchar field is padded out with the appropriate amount of
** garbage.
**
** In general, it places the "closing remarks" in the
** data stream. This means that it will place the final segment
** indicator (saying "no more") in the stream if the stream is
** destined for GCA. If the datatype is nullable, then the null
** bit is set/cleared as appropriate. If there is insufficient
** room to make these closing remarks (or to supply the correct
** amount of garbage in the test case), then the fip_state is set
** to ADW_F_DONE_NEED_NULL, and an incomplete status is returned.
** This status will set up the main redeem call to call this
** routine again with a new buffer, repeating this action until
** all is done.
**
** Inputs:
** adf_scb Standard ADF SCB Ptr
** result_dv Ptr to output area DB_DATA_VALUE
** coupon_dv PTR to input area DB_DATA_VALUE
** work Ptr to ADP_LO_WKSP in which work
** is done.
** ->adw_shared Contains the result of the action
** so far
** ->adw_fip Contains more such results
** for_gca Nat indicating whether the result
** is destined for GCA
** transmission.
**
** Outputs:
** adf_scb->adf_error Filled as appropriate.
** result_dv->db_length Set correctly.
** work->adw_fip.fip_state Set to indicate whether to
** return.
** work->adw_fip.fip_test* Set to control the garbage
** returned for the test cases.
**
** Returns:
** DB_STATUS
** Exceptions:
** None
**
** Side Effects:
** None
**
** History:
** 07-dec-1989 (fred)
** Prototyped.
** 06-oct-1992 (fred)
** Altered to work with timezone integration. As a temporary measure,
** this routine was using the ADF_CB.adf_4rsvd field to store
** some context across calls. In that this field disappeared, a new,
** more appropriately named field was added (adf_lo_context). This
** new ADF_CB field is now used in this file.
** 30-Oct-1992 (fred)
** Fixed to correctly handle being called with a length too short
** for the original header.
** 20-Nov-1992 (fred)
** Rewritten for better clarity & better delineation of
** function in support of OME large objects.
[@history_template@]...
*/
DB_STATUS static
adu_rdm2_finish(ADF_CB *adf_scb,
DB_DATA_VALUE *result_dv,
DB_DATA_VALUE *coupon_dv,
ADP_LO_WKSP *work,
i4 for_gca)
{
DB_STATUS status = E_DB_OK;
i4 zero = 0;
if (work->adw_shared.shd_l1_check != work->adw_fip.fip_l1_value)
{
/* Fix_me -- get more detailed error message to log (log_key, */
/* what's wrong, etc. */
/* Then we are sending an inconsistent blob */
status = adu_error(adf_scb, E_AD7004_ADP_BAD_BLOB,0);
}
else if (result_dv->db_length >=
(work->adw_shared.shd_o_used + (for_gca * sizeof(i4)) +
work->adw_fip.fip_null_bytes))
{
if (for_gca)
{
I4ASSIGN_MACRO(zero,
result_dv->db_data[work->adw_shared.shd_o_used]);
work->adw_shared.shd_o_used += sizeof(i4);
}
if (work->adw_fip.fip_test_mode)
{
work->adw_fip.fip_test_sent += sizeof(i4);
if (work->adw_fip.fip_test_sent <=
(work->adw_fip.fip_test_length -
work->adw_fip.fip_null_bytes))
{
/* Then there isn't enough to fill the varchar() */
if (result_dv->db_length <
(work->adw_fip.fip_test_length
- work->adw_fip.fip_test_sent))
{
/*
** This is for test purposes only.
**
** We need to send a true VARCHAR() datatype.
** Thus, if the blob os smaller than that, then we
** need to pad it out with garbage bytes. To do
** so, we will increment test_sent by the
** remainder of the buffer, and happily return,
** knowing that we will arrive here with an empty
** buffer in the relatively near future.
**
** To set test_sent appropriately, we must first
** decrement it by the amount it was incremented
** before arriving here. Then we increment as
** appropriate.
*/
work->adw_fip.fip_test_sent -=
work->adw_shared.shd_o_used;
work->adw_fip.fip_test_sent += result_dv->db_length;
work->adw_fip.fip_state = ADW_F_DONE_NEED_NULL;
adf_scb->adf_errcb.ad_errcode = E_AD0002_INCOMPLETE;
status = E_DB_INFO;
}
}
}
if (status == E_DB_OK)
{
result_dv->db_length = work->adw_shared.shd_o_used +
work->adw_fip.fip_null_bytes;
if (work->adw_fip.fip_null_bytes)
{
/*
** Then the datatype was nullable. Copy the NULL byte
** from the coupon.
*/
if (ADI_ISNULL_MACRO(coupon_dv))
{
ADF_SETNULL_MACRO(result_dv);
}
else
{
ADF_CLRNULL_MACRO(result_dv);
}
}
adf_scb->adf_errcb.ad_errcode = E_DB_OK;
}
}
else
{
/*
** In this case, we are at the end of data, but the "closing
** remarks" (no more strings (if gca) and null bytes) doesn't
** fit in the buffer.
**
** We mark this fact by setting the state to ADW_F_DONE_NEED_NULL.
*/
result_dv->db_length = work->adw_shared.shd_o_used;
work->adw_fip.fip_state = ADW_F_DONE_NEED_NULL;
adf_scb->adf_errcb.ad_errcode = E_AD0002_INCOMPLETE;
status = E_DB_INFO;
}
return(status);
}
STATUS
adu_sc930prtdataval(
i4 msg_type,
char *parameter_name,
i4 parameter_no,
DB_DATA_VALUE *db_dv,
ADF_CB *tzcb,
PTR file)
{
char num_buf[64];
i2 flt_wid;
f8 f8_tmp;
AD_NEWDTNTRNL dateval;
AD_NEWDTNTRNL *datep=&dateval;
DB_TAB_LOGKEY_INTERNAL *tab_logkey;
DB_OBJ_LOGKEY_INTERNAL *obj_logkey;
DB_DT_ID bdt;
DB_STATUS db_stat;
i4 blen;
i4 prec;
char *data;
char fmt[16];
i4 tmp;
i4 tcnt;
i4 i;
i4 res_wid;
f4 f4_tmp;
i4 i4_tmp;
i2 i2_tmp, i2_tmp2;
i1 i1_tmp;
u_char u_tmp_i1;
char stbuf[SC930_DATAVAL_BUFSIZE];
AD_DTUNION *dp;
i8 i8_tmp;
char *c_tmp,*c_buf_end;
if (db_dv == NULL)
{
SIfprintf(file, "< Pointer to DB_DATA_VALUE is NULL >\n");
return E_DB_ERROR;
}
if (parameter_name)
{
STprintf(stbuf,"%d:%d(%s)=",
db_dv->db_datatype,
parameter_no,
parameter_name);
} else
{
STprintf(stbuf,"%d:%d=",
db_dv->db_datatype,
parameter_no);
}
/* output the PARM/PARMEXEC 'header' to the trace file */
switch (msg_type)
{
case SC930_LTYPE_PARM:
SIfprintf(file,"PARM:%s",stbuf);
break;
case SC930_LTYPE_PARMEXEC:
SIfprintf(file,"PARMEXEC:%s",stbuf);
break;
default:
SIfprintf(file,"UNKNOWN:%s",stbuf);
}
bdt = abs(db_dv->db_datatype);
blen = db_dv->db_length - (db_dv->db_datatype < 0);
prec = db_dv->db_prec;
data = db_dv->db_data;
if (data == NULL)
{
SIfprintf(file, "< pointer to data is NULL >\n");
return E_DB_ERROR;
}
else if (ADI_ISNULL_MACRO(db_dv))
{
SIfprintf(file, "< NULL >\n");
return OK;
}
else
{
switch (bdt)
{
case DB_LOGKEY_TYPE:
obj_logkey = (DB_OBJ_LOGKEY_INTERNAL *) data;
SIfprintf(file, "olk_high_id = %x\tolk_low_id = %x\t"
"olk_rel_id = %d\tolk_db_id = %d\n" ,
obj_logkey->olk_high_id, obj_logkey->olk_low_id,
obj_logkey->olk_rel_id, obj_logkey->olk_db_id);
break;
case DB_TABKEY_TYPE:
tab_logkey = (DB_TAB_LOGKEY_INTERNAL *) data;
SIfprintf(file, "tlk_high_id = %x\ttlk_low_id = %x\n",
tab_logkey->tlk_high_id, tab_logkey->tlk_low_id);
break;
case DB_CHA_TYPE:
case DB_CHR_TYPE:
if (blen == 0)
SIfprintf(file, "''\n");
else
SIfprintf(file, "'%*s'\n", blen, (u_char *) data);
break;
case DB_DTE_TYPE:
db_stat = adu_6to_dtntrnl (tzcb, db_dv, datep);
if (datep->dn_status == 0)
{
SIfprintf(file, "''\n");
break;
}
SIfprintf(file,
"(%s) %d/%d/%d %d:%d:%d.%.3d (%d)\n",
(datep->dn_status & AD_DN_ABSOLUTE)?
((datep->dn_status & AD_DN_TIMESPEC)?"DATETIME":"DATE")
:"INTERVAL",
(i2)datep->dn_year,(i2)datep->dn_month,datep->dn_day,
datep->dn_seconds / AD_39DTE_ISECPERHOUR,
(datep->dn_seconds / AD_10DTE_ISECPERMIN) % 60,
datep->dn_seconds % 60,
(datep->dn_nsecond % AD_29DTE_NSPERMS), AD_TZ_OFFSETNEW(datep));
break;
case DB_ADTE_TYPE:
dp = (AD_DTUNION*)data;
SIfprintf(file,"%d/%d/%d\n",
dp->adate.dn_year, dp->adate.dn_month, dp->adate.dn_day);
break;
case DB_TMWO_TYPE:
case DB_TMW_TYPE:
case DB_TME_TYPE:
dp = (AD_DTUNION*)data;
SIfprintf(file,"%d,%d +/- %d\n",
dp->atime.dn_seconds, dp->atime.dn_nsecond,
AD_TZ_OFFSET(&dp->atime));
break;
case DB_INYM_TYPE:
dp = (AD_DTUNION*)data;
SIfprintf(file,"%d %d\n",dp->aintym.dn_years, dp->aintym.dn_months);
break;
case DB_INDS_TYPE:
dp = (AD_DTUNION*)data;
SIfprintf(file,"%d %d %d\n", dp->aintds.dn_days,
dp->aintds.dn_seconds, dp->aintds.dn_nseconds);
break;
case DB_TSWO_TYPE:
case DB_TSW_TYPE:
case DB_TSTMP_TYPE:
dp = (AD_DTUNION*)data;
SIfprintf(file,"%d/%d/%d %d %d (%d)\n",
dp->atimestamp.dn_year, dp->atimestamp.dn_month,
dp->atimestamp.dn_day,
dp->atimestamp.dn_seconds, dp->atimestamp.dn_nsecond,
AD_TZ_OFFSET(&dp->atimestamp));
break;
case DB_DEC_TYPE:
CVpka(data,
(i4)DB_P_DECODE_MACRO(prec),
(i4)DB_S_DECODE_MACRO(prec),
'.',
(i4)DB_P_DECODE_MACRO(prec) + 5,
(i4)DB_S_DECODE_MACRO(prec),
CV_PKLEFTJUST,
num_buf,
&res_wid);
tmp = res_wid;
i = 0;
fmt[i++] = '%';
if (tmp >= 10)
{
fmt[i++] = (tmp / 10) + '0';
tmp = tmp % 10;
}
fmt[i++] = tmp + '0';
fmt[i++] = 's';
fmt[i++] = '\n';
fmt[i] = EOS;
SIfprintf(file, fmt, num_buf);
break;
case DB_FLT_TYPE:
if (blen == 4)
{
F4ASSIGN_MACRO(*data, f4_tmp);
f8_tmp = f4_tmp;
}
else
F8ASSIGN_MACRO(*data, f8_tmp);
CVfa(f8_tmp, (i4) sizeof(num_buf), (i4) 4, 'f', '.', num_buf, &flt_wid);
SIfprintf(file, "%*s\n", flt_wid, (u_char *) num_buf);
break;
case DB_INT_TYPE:
if (blen == 4)
{
I4ASSIGN_MACRO(*data, i4_tmp);
}
else if (blen == 2)
{
I2ASSIGN_MACRO(*data, i2_tmp);
i4_tmp = i2_tmp;
}
else if (blen == 1)
{
i4_tmp = I1_CHECK_MACRO(*(i1 *)data);
} else /* blen == 8 */
{
I8ASSIGN_MACRO(*data,i8_tmp);
CVla8(i8_tmp,num_buf);
SIfprintf(file, "%s\n", num_buf);
break;
}
SIfprintf(file, "%d\n", i4_tmp);
break;
case DB_MNY_TYPE:
f8_tmp = ((AD_MONEYNTRNL *) data)->mny_cents / 100.0;
CVfa(f8_tmp, 32, 2, 'f', '.', num_buf, &flt_wid);
tmp = flt_wid;
i = 0;
fmt[i++] = '%';
if (flt_wid >= 100)
{
fmt[i++] = (tmp / 100) + '0';
tmp = tmp % 100;
}
if (flt_wid >= 10)
{
fmt[i++] = (tmp / 10) + '0';
tmp = tmp % 10;
}
fmt[i++] = tmp + '0';
fmt[i++] = 's';
fmt[i++] = '\n';
fmt[i] = EOS;
SIfprintf(file, fmt, num_buf);
break;
case DB_VCH_TYPE:
case DB_TXT_TYPE:
case DB_LTXT_TYPE:
I2ASSIGN_MACRO(((DB_TEXT_STRING *)data)->db_t_count, i2_tmp);
if (i2_tmp == 0)
{
SIfprintf(file, "''\n");
}
else
{
SIfprintf(file, "'%*s'\n", i2_tmp, ((DB_TEXT_STRING *) data)->db_t_text);
}
break;
case DB_BOO_TYPE:
if (*((bool *) data))
SIfprintf(file,"TRUE\n");
else
SIfprintf(file,"FALSE\n");
break;
case DB_VBYTE_TYPE:
I2ASSIGN_MACRO(((DB_TEXT_STRING *)data)->db_t_count, i2_tmp);
blen=i2_tmp;
data = ((DB_TEXT_STRING *)data)->db_t_text;
case DB_BYTE_TYPE:
c_tmp=stbuf;
c_buf_end=c_tmp + SC930_DATAVAL_BUFSIZE - 10;
STprintf(c_tmp,"%d:",blen);
c_tmp += STlength(c_tmp);
for(i=0; i< blen; i++)
{
u_tmp_i1=(u_char) data[i];
STprintf(c_tmp,"%02x ", u_tmp_i1);
c_tmp += 3;
if (c_tmp > c_buf_end )
{
SIfprintf(file,stbuf);
c_tmp=stbuf;
stbuf[0]=EOS;
}
}
SIfprintf(file,"%s\n",stbuf);
break;
case DB_NCHR_TYPE:
stbuf[0] = EOS;
c_tmp = stbuf;
c_buf_end=c_tmp + SC930_DATAVAL_BUFSIZE - 10;
for(i=0; i< blen/2; i++)
{
I2ASSIGN_MACRO(data[2*i], i2_tmp);
i4_tmp = i2_tmp;
STprintf(c_tmp,"%x ", i4_tmp);
c_tmp += STlength(c_tmp);
if (c_tmp > c_buf_end )
{
SIfprintf(file,stbuf);
c_tmp=stbuf;
stbuf[0]=EOS;
}
}
SIfprintf(file,"%s\n",stbuf);
break;
case DB_NVCHR_TYPE:
I2ASSIGN_MACRO(((DB_NVCHR_STRING *)data)->count, i2_tmp);
stbuf[0] = EOS;
c_tmp = stbuf;
c_buf_end=c_tmp + SC930_DATAVAL_BUFSIZE - 10;
for(i=0; i< i2_tmp; i++)
{
I2ASSIGN_MACRO(((DB_NVCHR_STRING *)data)->element_array[i], i2_tmp2);
i4_tmp = i2_tmp2;
STprintf(c_tmp,"%x ", i4_tmp);
c_tmp += STlength(c_tmp);
if (c_tmp > c_buf_end )
{
SIfprintf(file,stbuf);
c_tmp=stbuf;
stbuf[0]=EOS;
}
}
SIfprintf(file,"%s\n",stbuf);
break;
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:
{
ADP_PERIPHERAL *p = (ADP_PERIPHERAL *) data;
ADP_COUPON *cpn;
DB_DATA_VALUE dv_work;
char tmp_val[DB_MAXSTRING + 1] = {0};
i4 i;
dv_work.db_datatype = DB_CHA_TYPE;
dv_work.db_length = DB_MAXSTRING;
dv_work.db_data = tmp_val;
adu_lvch_move(tzcb, db_dv, &dv_work);
i = DB_MAXSTRING;
while (dv_work.db_data[i] == ' ')
dv_work.db_data[i--] = EOS;
SIfprintf(file, "(%d/%d):'%s'\n",p->per_length0,p->per_length1,
dv_work.db_data);
}
break;
default:
SIfprintf(file,
"< unknown type: don't know how to interpret data >\n");
return E_DB_ERROR;
}
}
return OK;
}
/*{
** Name: adu_rdm1_setup - Setup for Redeem an ADF_COUPON
**
** Description:
** This routine performs the initialization for the redeeming of
** a coupon. This amount primarily to initializing the
** ADP_LO_WKSP function instance private and shared (adw_fip &
** adw_shared, respectively). This routine also moves the
** appropriate peripheral header into the output area.
**
** Since this routine moves the peripheral header to the output
** area, in the case where the original call to this routine has
** insufficient space for the output header, this routine may be
** called more than once. We note this since it is "unusual" for
** the initialization routine to be called more than one time for
** an object. In the case where the original space is of
** insufficent size, then this routine will return an indication
** that the output area is full, and will move nothing into it.
** Thus, this routine considers it a call-protocol error to be
** called a second time with insufficient space.
**
** Inputs:
** adf_scb The session's control block (ptr).
** result_dv Pointer to DB_DATA_VALUE for
** result.
** coupon_dv Pointer to DB_DATA_VALUE
** describing the input coupon to
** be redeemed.
** workspace_dv Pointer to DB_DATA_VALUE
** describing redeem's workspace.
** continuation Continuation indicator. 0
** indicates the first call, else
** not the first call.
**
** Outputs:
** adf_scb->adf_error Filled as appropriate.
** *result_dv->db_data Setup with beginning of peripheral
** data type.
** *workspace_dv->db_data Initialized for ongoing redeem work.
** Returns:
** DB_STATUS
** Exceptions:
** None.
**
** Side Effects:
** None.
**
** History:
** 02-dec-1992 (fred)
** Coded. Created from adu_redeem prototype in support of
** OME large objects.
** 8-Apr-1993 (fred)
** Fixed bug in zero length large object handling. For large
** objects of zero length which are not nullable, the length
** should not include the null-value-byte.
** 12-Oct-1993 (fred)
** Removed call to ADP_INFORMATION -- subsumed by
** adi_per_under().
** 10-sep-1998 (schte01)
** Modified I4ASSIGN for axp_osf to pass the value, not the address
** of the value, to be assigned. This worked under the -oldc
** compiler option and got compile errors under -newc.
** 28-jul-1999 (thaju02)
** If the coupon stipulates that the data is not null, then
** the minimum result buffer length must be large enough to
** hold one byte of data along with all necessary info
** (ADP_HDR_SIZE + nextsegmarker(i4) + 2byteseglenindicator
** + 1byteofdata). Given a buffer with only 18 bytes of space
** available, 12 bytes are filled with peripheral header info
** in adu_rdm1_setup and 4 bytes are filled with the next
** segment marker in adu_redeem. In adc_lvch_xform, the 2
** byte segment length indicator is initially set to zero
** in the result buffer. If there is no space left in the
** result buffer for segment data, we flush the buffer. In
** the front end, upon receiving this result buffer, the
** next segment marker indicates that there is data following,
** yet the length is zero; terminal monitor infinitely loops.
** (b98104)
** 12-aug-99 (stial01)
** adu_rdm1_setup() 'blob_work' arg to adi_per_under should be
** NULL before redeem.
** 24-may-2000 (stial01)
** adu_rdm1_setup() clear null indicator if not null (B101656)
**
[@history_template@]...
*/
DB_STATUS static
adu_rdm1_setup(ADF_CB *adf_scb,
DB_DATA_VALUE *result_dv,
DB_DATA_VALUE *coupon_dv,
ADP_LO_WKSP *work,
i4 for_gca)
{
DB_STATUS status;
ADP_PERIPHERAL *p = (ADP_PERIPHERAL *) result_dv->db_data;
DB_DT_ID dtid =
ADI_DT_MAP_MACRO(abs(result_dv->db_datatype));
i4 min_size;
bool isnull = 0;
if (coupon_dv->db_datatype < 0)
work->adw_fip.fip_null_bytes = 1;
else
work->adw_fip.fip_null_bytes = 0;
if (ult_check_macro(&Adf_globs->Adf_trvect, ADF_011_RDM_TO_V_STYLE,
&dummy1, &dummy2))
{
work->adw_fip.fip_test_mode = 1;
work->adw_fip.fip_test_length = ADP_TST_VLENGTH +
work->adw_fip.fip_null_bytes;
work->adw_fip.fip_test_sent = 0;
}
else
{
work->adw_fip.fip_test_mode = 0;
}
work->adw_shared.shd_exp_action = ADW_START;
work->adw_fip.fip_done = FALSE;
/*
** Fool the main routine into getting us an input segment. Make
** look like the input segement is all used up.
*/
work->adw_shared.shd_type = coupon_dv->db_datatype;
work->adw_shared.shd_i_area = (char *) 0;
work->adw_shared.shd_i_used = work->adw_shared.shd_i_length = 0;
work->adw_shared.shd_o_used = ADP_HDR_SIZE;
work->adw_shared.shd_o_length = result_dv->db_length;
work->adw_shared.shd_o_area = (char *) result_dv->db_data;
if (work->adw_shared.shd_o_length > MAXI2)
{
TRdisplay("adu_rdm1_setup shd_o_length %d MAX %d\n",
work->adw_shared.shd_o_length, MAXI2);
return(adu_error(adf_scb, E_AD9999_INTERNAL_ERROR, 0));
}
work->adw_shared.shd_l0_check = work->adw_shared.shd_l1_check = 0;
work->adw_fip.fip_pop_cb.pop_continuation = ADP_C_BEGIN_MASK;
work->adw_fip.fip_pop_cb.pop_user_arg = (PTR) 0;
work->adw_fip.fip_pop_cb.pop_type = (ADP_POP_TYPE);
work->adw_fip.fip_pop_cb.pop_length = sizeof(ADP_POP_CB);
work->adw_fip.fip_pop_cb.pop_ascii_id = ADP_POP_ASCII_ID;
work->adw_fip.fip_pop_cb.pop_temporary = ADP_POP_PERMANENT;
work->adw_fip.fip_pop_cb.pop_coupon = coupon_dv;
work->adw_fip.fip_pop_cb.pop_segment = &work->adw_fip.fip_seg_dv;
work->adw_fip.fip_pop_cb.pop_underdv = &work->adw_fip.fip_under_dv;
status = adi_per_under(adf_scb,
result_dv->db_datatype,
&work->adw_fip.fip_under_dv);
if (status)
{
return(adu_error(adf_scb, E_AD7000_ADP_BAD_INFO, 0));
}
STRUCT_ASSIGN_MACRO(work->adw_fip.fip_under_dv,
work->adw_fip.fip_seg_dv);
work->adw_fip.fip_seg_dv.db_data = (char *) ((char *) work +
sizeof(ADP_LO_WKSP));
if (ADI_ISNULL_MACRO(coupon_dv) ||
((((ADP_PERIPHERAL *)coupon_dv->db_data)->per_length0 == 0)
&& (((ADP_PERIPHERAL *) coupon_dv->db_data)->per_length1 == 0)))
isnull = 1;
if (isnull)
/* hdr + segment indicator + sizeof(null byte) */
min_size = ADP_HDR_SIZE + sizeof(i4) + work->adw_fip.fip_null_bytes;
else
/* hdr + segment indicator + segment length + segment single byte */
min_size = ADP_HDR_SIZE + sizeof(i4) + sizeof(i2) + sizeof(char);
if (result_dv->db_length >= min_size)
{
if (for_gca)
work->adw_shared.shd_out_tag = ADP_P_GCA;
else
work->adw_shared.shd_out_tag = ADP_P_DATA;
I4ASSIGN_MACRO(work->adw_shared.shd_out_tag, p->per_tag);
work->adw_shared.shd_out_segmented =
(work->adw_shared.shd_out_tag != ADP_P_DATA);
I4ASSIGN_MACRO( ((ADP_PERIPHERAL *)
coupon_dv->db_data)->per_tag,
work->adw_shared.shd_inp_tag);
work->adw_shared.shd_inp_segmented =
(work->adw_shared.shd_inp_tag != ADP_P_DATA);
I4ASSIGN_MACRO( ((ADP_PERIPHERAL *)
coupon_dv->db_data)->per_length0,
p->per_length0);
I4ASSIGN_MACRO(p->per_length0, work->adw_fip.fip_l0_value);
I4ASSIGN_MACRO(((ADP_PERIPHERAL *)
coupon_dv->db_data)->per_length1,
p->per_length1);
I4ASSIGN_MACRO(p->per_length1, work->adw_fip.fip_l1_value);
work->adw_fip.fip_state = ADW_F_RUNNING;
}
else if (work->adw_fip.fip_state != ADW_F_STARTING)
{
work->adw_fip.fip_state = ADW_F_STARTING;
result_dv->db_length = 0;
adf_scb->adf_errcb.ad_errcode = E_AD0002_INCOMPLETE;
return(E_DB_INFO);
}
else
{
return(adu_error(adf_scb, E_AD9999_INTERNAL_ERROR, 0));
}
if (isnull)
{
if (work->adw_fip.fip_test_mode)
{
((DB_TEXT_STRING *) p)->db_t_count = (i2) 0;
if (result_dv->db_length >=
(work->adw_fip.fip_test_length -
work->adw_fip.fip_test_sent))
{
result_dv->db_length = work->adw_fip.fip_test_length -
work->adw_fip.fip_test_sent;
work->adw_fip.fip_test_sent = work->adw_fip.fip_test_length;
}
else
{
work->adw_fip.fip_state = ADW_F_DONE_NEED_NULL;
work->adw_fip.fip_test_sent += result_dv->db_length;
adf_scb->adf_errcb.ad_errcode = E_AD0002_INCOMPLETE;
return(E_DB_INFO);
}
}
else
{
i4 zero = 0;
/*
** Insert GCA mark that says there is no segment.
*/
#if defined(axp_osf) || defined(ris_u64) || defined(LP64) || \
defined(axp_lnx)
/*
** We want to init the GCA field after the header, but
** on axp_osf this is not the same as the start of the
** coupon, because 8-byte alignment causes a slack 4-byte
** integer to be between the header and the coupon. See
** adu_redeem above for a different way this field is set
** to 1 when we have real data (not null). The addressing
** of this field should really be standardized in such a
** way that contiguous layout of 4-byte aligned fields is
** not assumed.
*/
I4ASSIGN_MACRO(zero,*((char *)p + ADP_HDR_SIZE));
#endif
I4ASSIGN_MACRO(zero, p->per_value);
result_dv->db_length = ADP_NULL_PERIPH_SIZE;
if (work->adw_shared.shd_type > 0)
result_dv->db_length -= 1;
}
if (ADI_ISNULL_MACRO(coupon_dv))
ADF_SETNULL_MACRO(result_dv);
else
ADF_CLRNULL_MACRO(result_dv);
adf_scb->adf_errcb.ad_errcode = E_DB_OK;
work->adw_fip.fip_done = TRUE;
return(E_DB_OK);
}
if (work->adw_fip.fip_test_mode)
{
i4 segment_count;
i4 length1;
i2 count;
I4ASSIGN_MACRO(p->per_length1, length1);
I4ASSIGN_MACRO(p->per_length0, segment_count);
if (!segment_count)
segment_count = ADP_TST_SEG_CNT;
count = min( ADP_TST_VLENGTH,
(i2) (length1
+ (segment_count *
(sizeof(i4) + sizeof(i2)))
+ sizeof(i4) /* no more segments */
+ work->adw_shared.shd_o_used)
) - sizeof(i2);
I2ASSIGN_MACRO(count, ((DB_TEXT_STRING *) p)->db_t_count);
}
return(E_DB_OK);
}
