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); }