/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_s_item(void *pSrc)
{
struct W_ITEM_TBL *r;
if (pSrc == NULL)
r = &g_w_item;
else
r = pSrc;
print_start(S_ITEM);
print_varchar(S_ITEM_ID, r->i_item_id, 1);
print_varchar(S_ITEM_DESC, r->i_item_desc, 1);
print_decimal(S_ITEM_LIST_PRICE, &r->i_current_price, 1);
print_decimal(S_ITEM_WHOLESALE_COST, &r->i_wholesale_cost, 1);
print_varchar(S_ITEM_SIZE, r->i_size, 1);
print_varchar(S_ITEM_FORMULATION, r->i_formulation, 1);
print_varchar(S_ITEM_FLAVOR, r->i_color, 1);
print_varchar(S_ITEM_UNITS, r->i_units, 1);
print_varchar(S_ITEM_CONTAINER, r->i_container, 1);
print_key(S_ITEM_MANAGER_ID, r->i_manager_id, 0);
print_end(S_ITEM);
return(0);
}
//*****************************************************************************************
//
// Function : print_time
// Description : Print time format to buffer e.g. 01:23:45
//
//*****************************************************************************************
void print_time ( BYTE *ptr, BYTE *time, BYTE cursor )
{
BYTE i;
// show setting cursor when enter to setting mode
if ( cursor == 0 )
{
if ( time [ 0 ] )
{
time++;
for ( i=0; i<3; i++ )
{
if ( (i+2) == cursor )
{
*ptr++ = ASCII_CURSOR;
}
else if ( i > 0 )
{
*ptr++ = ':';
}
ptr = print_decimal ( ptr, 2, *time++ );
}
}
else
{
ptr = my_strcpy ( ptr, (PGM_P)str_disable );
}
}
else
{
if ( cursor == 1 )
{
*ptr++ = ASCII_CURSOR;
// show Enable/Disable send temparature to server
if ( time [ 0 ] )
ptr = my_strcpy ( ptr, (PGM_P)str_enable );
else
ptr = my_strcpy ( ptr, (PGM_P)str_disable );
}
else
{
time++;
for ( i=0; i<3; i++ )
{
if ( (i+2) == cursor )
{
*ptr++ = ASCII_CURSOR;
}
else if ( i > 0 )
{
*ptr++ = ':';
}
ptr = print_decimal ( ptr, 2, *time++ );
}
}
}
*ptr = '\0';
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_w_store_returns(void *row)
{
struct W_STORE_RETURNS_TBL *r;
if (row == NULL)
r = &g_w_store_returns;
else
r = row;
print_start(STORE_RETURNS);
print_key(SR_RETURNED_DATE_SK, r->sr_returned_date_sk, 1);
print_key(SR_RETURNED_TIME_SK, r->sr_returned_time_sk, 1);
print_key(SR_ITEM_SK, r->sr_item_sk, 1);
print_key(SR_CUSTOMER_SK, r->sr_customer_sk, 1);
print_key(SR_CDEMO_SK, r->sr_cdemo_sk, 1);
print_key(SR_HDEMO_SK, r->sr_hdemo_sk, 1);
print_key(SR_ADDR_SK, r->sr_addr_sk, 1);
print_key(SR_STORE_SK, r->sr_store_sk, 1);
print_key(SR_REASON_SK, r->sr_reason_sk, 1);
print_key(SR_TICKET_NUMBER, r->sr_ticket_number, 1);
print_integer(SR_PRICING_QUANTITY, r->sr_pricing.quantity, 1);
print_decimal(SR_PRICING_NET_PAID, &r->sr_pricing.net_paid, 1);
print_decimal(SR_PRICING_EXT_TAX, &r->sr_pricing.ext_tax, 1);
print_decimal(SR_PRICING_NET_PAID_INC_TAX, &r->sr_pricing.net_paid_inc_tax, 1);
print_decimal(SR_PRICING_FEE, &r->sr_pricing.fee, 1);
print_decimal(SR_PRICING_EXT_SHIP_COST, &r->sr_pricing.ext_ship_cost, 1);
print_decimal(SR_PRICING_REFUNDED_CASH, &r->sr_pricing.refunded_cash, 1);
print_decimal(SR_PRICING_REVERSED_CHARGE, &r->sr_pricing.reversed_charge, 1);
print_decimal(SR_PRICING_STORE_CREDIT, &r->sr_pricing.store_credit, 1);
print_decimal(SR_PRICING_NET_LOSS, &r->sr_pricing.net_loss, 0);
print_end(STORE_RETURNS);
return(0);
}
//*****************************************************************************************
//
// Function : print_temp
// Description : Print ADC0 and temparature to buffer
//
//*****************************************************************************************
void print_temp ( BYTE *dest )
{
WORD adc0_value;
BYTE temp_value;
adc0_value = adc_read ( 0 );
temp_value = adc_read_temp ( );
dest = print_decimal ( dest, 4, adc0_value );
*dest++ = ',';
dest = print_decimal ( dest, 2, temp_value );
*dest++ = ASCII_DEGREE;
*dest++ = 'C';
*dest = '\0';
}
//
// Function : print_timeout
// Description : Print timeout display light
//
//*****************************************************************************************
void print_timeout (BYTE *ptr, BYTE cursor )
{
BYTE digit;
if ( screen_timeout > 99 )
digit = 3;
else if ( screen_timeout > 9 )
digit = 2;
else
digit = 1;
*ptr = ASCII_CURSOR;
ptr++;
if(screen_timeout==0){
*ptr++ = 'N';
*ptr++ = 'e';
*ptr++ = 'v';
*ptr++ = 'e';
*ptr++ = 'r';
}else{
ptr = print_decimal ( ptr, digit, screen_timeout );
*ptr++ = ' ';
*ptr++ = 's';
*ptr++ = 'e';
*ptr++ = 'c';
*ptr++ = 'o';
*ptr++ = 'n';
*ptr++ = 'd';
}
*ptr = '\0';
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_s_promotion(void *pSrc)
{
struct W_PROMOTION_TBL *r;
if (pSrc == NULL)
r = &g_w_promotion;
else
r = pSrc;
print_start(S_PROMOTION);
print_varchar(P_PROMO_ID, r->p_promo_id, 1);
print_varchar(P_PROMO_NAME, &r->p_promo_name[0], 1);
print_date(P_START_DATE_ID, r->p_start_date_id, 1);
print_date(P_START_DATE_ID, r->p_end_date_id, 1);
print_decimal(P_COST, &r->p_cost, 1);
print_integer(P_RESPONSE_TARGET, r->p_response_target, 1);
print_boolean(P_CHANNEL_DMAIL, r->p_channel_dmail, 1);
print_boolean(P_CHANNEL_EMAIL, r->p_channel_email, 1);
print_boolean(P_CHANNEL_CATALOG, r->p_channel_catalog, 1);
print_boolean(P_CHANNEL_TV, r->p_channel_tv, 1);
print_boolean(P_CHANNEL_RADIO, r->p_channel_radio, 1);
print_boolean(P_CHANNEL_PRESS, r->p_channel_press, 1);
print_boolean(P_CHANNEL_EVENT, r->p_channel_event, 1);
print_boolean(P_CHANNEL_DEMO, r->p_channel_demo, 1);
print_varchar(P_CHANNEL_DETAILS, &r->p_channel_details[0], 1);
print_varchar(P_PURPOSE, r->p_purpose, 1);
print_boolean(P_DISCOUNT_ACTIVE, r->p_discount_active, 0);
print_end(S_PROMOTION);
return(0);
}
int dispvar(char **format, va_list ap)
{
int wr;
t_args *arg;
wr = 0;
arg = (t_args*)malloc(sizeof(t_args));
*format += 1;
if (**format != 0)
{
init_arg(&arg);
while (is_flag(**format))
{
check_flags(format, &arg);
check_field(format, &arg, ap);
check_prec(format, &arg, ap);
check_length(format, &arg);
}
wr += print_char(format, &arg, ap);
wr += print_hexa(format, &arg, ap);
wr += print_decimal(format, &arg, ap);
wr += print_octal(format, &arg, ap);
}
free(arg);
return (wr);
}
//*****************************************************************************************
//
// Function : print_ip
// Description : Print ip address format to buffer e.g. 10.1.1.1
//
//*****************************************************************************************
void print_ip ( BYTE *ptr, BYTE *ip, BYTE cursor )
{
BYTE i, digit, temp;
for ( i=0; i<4; i++ )
{
temp = ip [ i ];
if ( temp > 99 )
digit = 3;
else if ( temp > 9 )
digit = 2;
else
digit = 1;
if ( (i+1) == cursor )
{
*ptr = ASCII_CURSOR;
ptr++;
}
else if ( i > 0 )
{
*ptr = '.';
ptr++;
}
ptr = print_decimal ( ptr, digit, temp );
}
*ptr = '\0';
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_s_web_return(void *pSrc)
{
struct S_WEB_RETURNS_TBL *r;
if (pSrc == NULL)
r = &g_s_web_returns;
else
r = pSrc;
print_start(S_WEB_RETURNS);
print_id(S_WRET_SITE_ID, r->kSiteID, 1);
print_key(S_WRET_ORDER_ID,r->kOrderID, 1);
print_integer(S_WRET_LINE_NUMBER, r->nLineNumber, 1);
print_id(S_WRET_ITEM_ID, r->kItemID, 1);
print_id(S_WRET_RETURN_CUST_ID, r->kReturningCustomerID, 1);
print_id(S_WRET_REFUND_CUST_ID,r->kRefundedCustomerID, 1);
print_date(S_WRET_RETURN_DATE, r->dtReturnDate.julian, 1);
print_time(S_WRET_RETURN_TIME, r->kReturnTime, 1);
print_integer(S_WRET_PRICING, r->Pricing.quantity, 1);
print_decimal(S_WRET_PRICING, &r->Pricing.ext_sales_price, 1);
print_decimal(S_WRET_PRICING, &r->Pricing.ext_tax, 1);
print_decimal(S_WRET_PRICING, &r->Pricing.fee, 1);
print_decimal(S_WRET_PRICING, &r->Pricing.ext_ship_cost, 1);
print_decimal(S_WRET_PRICING, &r->Pricing.refunded_cash, 1);
print_decimal(S_WRET_PRICING, &r->Pricing.reversed_charge, 1);
print_decimal(S_WRET_PRICING, &r->Pricing.store_credit, 1);
print_id(S_WRET_REASON_ID, r->kReasonID, 0);
print_end(S_WEB_RETURNS);
return(0);
}
inline void print_field_value(byte *value, ulint len, field_def_t *field) {
switch (field->type) {
case FT_INTERNAL:
break;
case FT_CHAR:
case FT_TEXT:
print_string((char*)value, len, field);
break;
case FT_UINT:
printf("%llu", get_uint_value(field, value));
break;
case FT_INT:
printf("%lli", get_int_value(field, value));
break;
case FT_FLOAT:
printf("%f", mach_float_read(value));
break;
case FT_DOUBLE:
printf("%lf", mach_double_read(value));
break;
case FT_DATETIME:
print_datetime(make_longlong(mach_read_from_8(value)));
break;
case FT_DATE:
print_date(mach_read_from_3(value));
break;
case FT_TIME:
print_time(mach_read_from_3(value));
break;
case FT_ENUM:
print_enum(mach_read_from_1(value), field);
break;
case FT_DECIMAL:
print_decimal(value, field);
break;
default:
printf("undef(%d)", field->type);
}
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_w_item(void *row)
{
struct W_ITEM_TBL *r;
if (row == NULL)
r = &g_w_item;
else
r = row;
print_start(ITEM);
print_key(I_ITEM_SK, r->i_item_sk, 1);
print_varchar(I_ITEM_ID, r->i_item_id, 1);
print_date(I_REC_START_DATE_ID, r->i_rec_start_date_id, 1);
print_date(I_REC_END_DATE_ID, r->i_rec_end_date_id, 1);
print_varchar(I_ITEM_DESC, r->i_item_desc, 1);
print_decimal(I_CURRENT_PRICE, &r->i_current_price, 1);
print_decimal(I_WHOLESALE_COST, &r->i_wholesale_cost, 1);
print_key(I_BRAND_ID, r->i_brand_id, 1);
print_varchar(I_BRAND, r->i_brand, 1);
print_key(I_CLASS_ID, r->i_class_id, 1);
print_varchar(I_CLASS, r->i_class, 1);
print_key(I_CATEGORY_ID, r->i_category_id, 1);
print_varchar(I_CATEGORY, r->i_category, 1);
print_key(I_MANUFACT_ID, r->i_manufact_id, 1);
print_varchar(I_MANUFACT, r->i_manufact, 1);
print_varchar(I_SIZE, r->i_size, 1);
print_varchar(I_FORMULATION, r->i_formulation, 1);
print_varchar(I_COLOR, r->i_color, 1);
print_varchar(I_UNITS, r->i_units, 1);
print_varchar(I_CONTAINER, r->i_container, 1);
print_key(I_MANAGER_ID, r->i_manager_id, 1);
print_varchar(I_PRODUCT_NAME, r->i_product_name, 0);
print_end(ITEM);
return(0);
}
void
convert_all_links (void)
{
double secs;
int file_count = 0;
struct ptimer *timer = ptimer_new ();
convert_links_in_hashtable (downloaded_html_set, 0, &file_count);
convert_links_in_hashtable (downloaded_css_set, 1, &file_count);
secs = ptimer_measure (timer);
logprintf (LOG_VERBOSE, _("Converted %d files in %s seconds.\n"),
file_count, print_decimal (secs));
ptimer_destroy (timer);
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_s_customer (void *pSrc)
{
struct S_CUSTOMER_TBL *r;
char szTemp[6];
if (pSrc == NULL)
r = &g_s_customer;
else
r = pSrc;
print_start (S_CUSTOMER);
print_id (S_CUST_ID, r->kID, 1);
print_varchar (S_CUST_SALUTATION, r->pSalutation, 1);
print_varchar (S_CUST_LAST_NAME, r->pLastName, 1);
print_varchar (S_CUST_FIRST_NAME, r->pFirstName, 1);
print_boolean (S_CUST_PREFERRED_FLAG, r->bPreferredFlag, 1);
print_date (S_CUST_BIRTH_DATE, r->dtBirthDate.julian, 1);
print_varchar (S_CUST_BIRTH_COUNTRY, r->pBirthCountry, 1);
print_varchar (S_CUST_LOGIN, r->szLogin, 1);
print_varchar (S_CUST_EMAIL, r->szEmail, 1);
print_date (S_CUST_LAST_LOGIN, r->dtLastLogin.julian, 1);
print_date (S_CUST_FIRST_SHIPTO_DATE, r->dtFirstShipToDate.julian, 1);
print_date (S_CUST_FIRST_PURCHASE_DATE, r->dtFirstPurchaseDate.julian, 1);
print_date (S_CUST_LAST_REVIEW, r->dtReview.julian, 1);
print_varchar (S_CUST_PRIMARY_MACHINE, r->szPrimaryMachine, 1);
print_varchar (S_CUST_SECONDARY_MACHINE, r->szSecondaryMachine, 1);
print_integer (S_CUST_ADDRESS_STREET_NUM,
g_w_customer_address.ca_address.street_num, 1);
print_varchar (S_CUST_ADDRESS_SUITE_NUM,
g_w_customer_address.ca_address.suite_num, 1);
print_varchar (S_CUST_ADDRESS_STREET_NAME1,
g_w_customer_address.ca_address.street_name1, 1);
print_varchar (S_CUST_ADDRESS_STREET_NAME2,
g_w_customer_address.ca_address.street_name2, 1);
print_varchar (S_CUST_ADDRESS_STREET_TYPE,
g_w_customer_address.ca_address.street_type, 1);
print_varchar (S_CUST_ADDRESS_CITY, g_w_customer_address.ca_address.city,
1);
sprintf (szTemp, "%05d", g_w_customer_address.ca_address.zip);
print_varchar (S_CUST_ADDRESS_ZIP, szTemp, 1);
print_varchar (S_CUST_ADDRESS_COUNTY,
g_w_customer_address.ca_address.county, 1);
print_varchar (S_CUST_ADDRESS_STATE, g_w_customer_address.ca_address.state,
1);
print_varchar (S_CUST_ADDRESS_COUNTRY,
g_w_customer_address.ca_address.country, 1);
print_varchar (S_CUST_LOCATION_TYPE, r->pLocationType, 1);
print_varchar (S_CUST_GENDER, r->sGender, 1);
print_varchar (S_CUST_MARITAL_STATUS, r->pMaritalStatus, 1);
print_varchar (S_CUST_EDUCATION, r->pEducation, 1);
print_varchar (S_CUST_CREDIT_RATING, r->pCreditRating, 1);
print_integer (S_CUST_PURCHASE_ESTIMATE, r->nPurchaseEstimate, 1);
print_varchar (S_CUST_BUY_POTENTIAL, r->pBuyPotential, 1);
print_integer (S_CUST_DEPENDENT_CNT, r->nDependents, 1);
print_integer (S_CUST_EMPLOYED_CNT, r->nEmployed, 1);
print_integer (S_CUST_COLLEGE_CNT, r->nCollege, 1);
print_integer (S_CUST_VEHICLE_CNT, r->nVehicle, 1);
print_decimal (S_CUST_INCOME, &r->dIncome, 0);
print_end (S_CUSTOMER);
return (0);
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_w_web_sales(void *row)
{
struct W_WEB_SALES_TBL *r;
if (row == NULL)
r = &g_w_web_sales;
else
r = row;
print_start(WEB_SALES);
print_key(WS_SOLD_DATE_SK, r->ws_sold_date_sk, 1);
print_key(WS_SOLD_TIME_SK, r->ws_sold_time_sk, 1);
print_key(WS_SHIP_DATE_SK, r->ws_ship_date_sk, 1);
print_key(WS_ITEM_SK, r->ws_item_sk, 1);
print_key(WS_BILL_CUSTOMER_SK, r->ws_bill_customer_sk, 1);
print_key(WS_BILL_CDEMO_SK, r->ws_bill_cdemo_sk, 1);
print_key(WS_BILL_HDEMO_SK, r->ws_bill_hdemo_sk, 1);
print_key(WS_BILL_ADDR_SK, r->ws_bill_addr_sk, 1);
print_key(WS_SHIP_CUSTOMER_SK, r->ws_ship_customer_sk, 1);
print_key(WS_SHIP_CDEMO_SK, r->ws_ship_cdemo_sk, 1);
print_key(WS_SHIP_HDEMO_SK, r->ws_ship_hdemo_sk, 1);
print_key(WS_SHIP_ADDR_SK, r->ws_ship_addr_sk, 1);
print_key(WS_WEB_PAGE_SK, r->ws_web_page_sk, 1);
print_key(WS_WEB_SITE_SK, r->ws_web_site_sk, 1);
print_key(WS_SHIP_MODE_SK, r->ws_ship_mode_sk, 1);
print_key(WS_WAREHOUSE_SK, r->ws_warehouse_sk, 1);
print_key(WS_PROMO_SK, r->ws_promo_sk, 1);
print_key(WS_ORDER_NUMBER, r->ws_order_number, 1);
print_integer(WS_PRICING_QUANTITY, r->ws_pricing.quantity, 1);
print_decimal(WS_PRICING_WHOLESALE_COST, &r->ws_pricing.wholesale_cost, 1);
print_decimal(WS_PRICING_LIST_PRICE, &r->ws_pricing.list_price, 1);
print_decimal(WS_PRICING_SALES_PRICE, &r->ws_pricing.sales_price, 1);
print_decimal(WS_PRICING_EXT_DISCOUNT_AMT, &r->ws_pricing.ext_discount_amt, 1);
print_decimal(WS_PRICING_EXT_SALES_PRICE, &r->ws_pricing.ext_sales_price, 1);
print_decimal(WS_PRICING_EXT_WHOLESALE_COST, &r->ws_pricing.ext_wholesale_cost, 1);
print_decimal(WS_PRICING_EXT_LIST_PRICE, &r->ws_pricing.ext_list_price, 1);
print_decimal(WS_PRICING_EXT_TAX, &r->ws_pricing.ext_tax, 1);
print_decimal(WS_PRICING_COUPON_AMT, &r->ws_pricing.coupon_amt, 1);
print_decimal(WS_PRICING_EXT_SHIP_COST, &r->ws_pricing.ext_ship_cost, 1);
print_decimal(WS_PRICING_NET_PAID, &r->ws_pricing.net_paid, 1);
print_decimal(WS_PRICING_NET_PAID_INC_TAX, &r->ws_pricing.net_paid_inc_tax, 1);
print_decimal(WS_PRICING_NET_PAID_INC_SHIP, &r->ws_pricing.net_paid_inc_ship, 1);
print_decimal(WS_PRICING_NET_PAID_INC_SHIP_TAX, &r->ws_pricing.net_paid_inc_ship_tax, 1);
print_decimal(WS_PRICING_NET_PROFIT, &r->ws_pricing.net_profit, 0);
print_end(WEB_SALES);
return(0);
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_w_store_sales(void *row)
{
struct W_STORE_SALES_TBL *r;
if (row == NULL)
r = &g_w_store_sales;
else
r = row;
print_start(STORE_SALES);
print_key(SS_SOLD_DATE_SK, r->ss_sold_date_sk, 1);
print_key(SS_SOLD_TIME_SK, r->ss_sold_time_sk, 1);
print_key(SS_SOLD_ITEM_SK, r->ss_sold_item_sk, 1);
print_key(SS_SOLD_CUSTOMER_SK, r->ss_sold_customer_sk, 1);
print_key(SS_SOLD_CDEMO_SK, r->ss_sold_cdemo_sk, 1);
print_key(SS_SOLD_HDEMO_SK, r->ss_sold_hdemo_sk, 1);
print_key(SS_SOLD_ADDR_SK, r->ss_sold_addr_sk, 1);
print_key(SS_SOLD_STORE_SK, r->ss_sold_store_sk, 1);
print_key(SS_SOLD_PROMO_SK, r->ss_sold_promo_sk, 1);
print_key(SS_TICKET_NUMBER, r->ss_ticket_number, 1);
print_integer(SS_PRICING_QUANTITY, r->ss_pricing.quantity, 1);
print_decimal(SS_PRICING_WHOLESALE_COST, &r->ss_pricing.wholesale_cost, 1);
print_decimal(SS_PRICING_LIST_PRICE, &r->ss_pricing.list_price, 1);
print_decimal(SS_PRICING_SALES_PRICE, &r->ss_pricing.sales_price, 1);
print_decimal(SS_PRICING_COUPON_AMT, &r->ss_pricing.coupon_amt, 1);
print_decimal(SS_PRICING_EXT_SALES_PRICE, &r->ss_pricing.ext_sales_price, 1);
print_decimal(SS_PRICING_EXT_WHOLESALE_COST, &r->ss_pricing.ext_wholesale_cost, 1);
print_decimal(SS_PRICING_EXT_LIST_PRICE, &r->ss_pricing.ext_list_price, 1);
print_decimal(SS_PRICING_EXT_TAX, &r->ss_pricing.ext_tax, 1);
print_decimal(SS_PRICING_COUPON_AMT, &r->ss_pricing.coupon_amt, 1);
print_decimal(SS_PRICING_NET_PAID, &r->ss_pricing.net_paid, 1);
print_decimal(SS_PRICING_NET_PAID_INC_TAX, &r->ss_pricing.net_paid_inc_tax, 1);
print_decimal(SS_PRICING_NET_PROFIT, &r->ss_pricing.net_profit, 0);
print_end(STORE_SALES);
return(0);
}
int main(int argc, char** argv)
{
// error case
if (argc != 2)
return 1;
// Seed random
int seed = atoi(argv[1]);
srand(seed);
int byte0 = 0;
unsigned char p[8];
// Populate our array with random numbers
int i;
for (i = 0; i < 8; i++)
{
int num = (rand() % 256);
p[i] = num;
}
// Can generate from [0 - 255]
byte0 = rand() % 256;
printf("The initial array in decimal is: \n");
print_decimal(p);
printf("Byte 0 in decimal is: %d\n", byte0);
printf("-----------------------------------------------------------------------------------------------------------------------------------------------------------\n");
printf("The initial array in bianary is: \n");
print_bin(p);
printf("Byte 0 in bianary is: ");
PRINTBIN(byte0);
printf("\n");
printf("-----------------------------------------------------------------------------------------------------------------------------------------------------------\n");
// Call setlsbs
setlsbs(p, byte0);
printf("The modified array in decimal is: \n");
print_decimal(p);
printf("-----------------------------------------------------------------------------------------------------------------------------------------------------------\n");
printf("The modified array in bianary is: \n");
print_bin(p);
printf("-----------------------------------------------------------------------------------------------------------------------------------------------------------\n");
// Get back our value
unsigned char r = getlsbs(p);
printf("The returned value from getlsbs is decimal is: %d\n", r);
printf("The returned value from getlsbs in bianary is: ");
PRINTBIN(r);
printf("\n");
return 0;
}
void Print( const Value* value, std::ostream& result )
{
// TODO: switch on typeid?
if( !value )
{
return;
}
const IntegerValue* integervalue = dynamic_cast<const IntegerValue*>(
value );
if( integervalue )
{
print_integer( integervalue, result );
return;
}
const DecimalValue* decimalvalue = dynamic_cast<const DecimalValue*>(
value );
if( decimalvalue )
{
print_decimal( decimalvalue, result );
return;
}
const StringValue* stringvalue = dynamic_cast<const StringValue*>(
value );
if( stringvalue )
{
print_string( stringvalue, result );
return;
}
const TrueValue* truevalue = dynamic_cast<const TrueValue*>(
value );
if( truevalue )
{
print_true( truevalue, result );
return;
}
const FalseValue* falsevalue = dynamic_cast<const FalseValue*>(
value );
if( falsevalue )
{
print_false( falsevalue, result );
return;
}
const NilValue* nilvalue = dynamic_cast<const NilValue*>(
value );
if( nilvalue )
{
print_nil( nilvalue, result );
return;
}
const CombinationValue* combovalue = dynamic_cast<
const CombinationValue*>( value );
if( combovalue )
{
print_combination( combovalue, result );
return;
}
const SymbolValue* symbolvalue = dynamic_cast<
const SymbolValue*>( value );
if( symbolvalue )
{
print_symbol( symbolvalue, result );
return;
}
const NativeFunctionValue* fnvalue = dynamic_cast<
const NativeFunctionValue*>( value );
if( fnvalue )
{
print_built_in_procedure( fnvalue, result );
return;
}
const CompoundProcedureValue* procvalue = dynamic_cast<
const CompoundProcedureValue*>( value );
if( procvalue )
{
print_compound_procedure( procvalue, result );
return;
}
const PairValue* pairvalue = dynamic_cast<
const PairValue*>( value );
if( pairvalue )
{
print_pair( pairvalue, result );
return;
}
result << "<<UNPRINTABLE TYPE " << typeid(value).name() << ">>";
}
