static void print_integer(Logger& logger, int base, TT integer, const char* prefix = nullptr, typename Traits::enable_if<Traits::is_signed<TT>>::type* = nullptr)
{
if (integer < 0)
{
logger.write('-');
}
if (prefix)
{
logger.write(prefix);
}
TT tmp = integer / base;
if (tmp < 0)
{
if (integer <= -base)
{
print_integer(logger, base, typename Traits::to_unsigned<TT>::type(-tmp));
}
logger.write(base_char[-(integer % base)]);
}
else
{
if (integer >= base)
{
print_integer(logger, base, typename Traits::to_unsigned<TT>::type(tmp));
}
logger.write(base_char[(integer % base)]);
}
}
/*
* 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);
}
void sonar() //initialize sonar pins and triggering sonar
{
overflow = 0;
PORTC|=(1<<PC0);
_delay_us(50);
PORTC&=~(1<<PC0);
while(!(PINC&(1<<PC1)));
TCNT2 = 0;
while ((PINC&(1<<PC1))&&TCNT2<245);
print_integer(overflow);
counter = overflow*256 + TCNT2;
time = counter*(1024/16);
clear_display();
print_integer(counter);
_delay_ms(200);
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_s_purchase(void *pSrc)
{
struct S_PURCHASE_TBL *r;
char szKey[RS_BKEY + 1];
if (pSrc == NULL)
r = &g_s_purchase;
else
r = pSrc;
print_start(S_PURCHASE);
print_key(S_PURCHASE_ID, r->kID, 1);
mk_bkey(szKey, r->kID, 0);
mk_bkey(szKey, r->kStoreID, 0);
print_varchar(S_PURCHASE_STORE_ID, szKey, 1);
mk_bkey(szKey, r->kCustomerID, 0);
print_varchar(S_PURCHASE_CUSTOMER_ID, szKey, 1);
print_date(S_PURCHASE_DATE, r->dtPurchaseDate.julian, 1);
print_integer(S_PURCHASE_TIME, r->nPurchaseTime, 1);
print_integer(S_PURCHASE_REGISTER, r->nRegister, 1);
print_integer(S_PURCHASE_CLERK, r->nClerk, 1);
print_varchar(S_PURCHASE_COMMENT, r->szComment, 0);
print_end(S_PURCHASE);
return(0);
}
void print_object (STREAM stream, D instance, BOOL escape_p, int print_depth) {
enum dylan_type_enum type = dylan_type(instance);
switch (type) {
case integer_type:
print_integer(stream, instance, escape_p, print_depth); break;
case character_type:
print_character(stream, instance, escape_p, print_depth); break;
case float_type:
print_float (stream, instance, escape_p, print_depth); break;
case dylan_boolean_type:
print_boolean(stream, instance, escape_p, print_depth); break;
case string_type:
print_string (stream, instance, escape_p, print_depth); break;
case vector_type:
print_vector(stream, instance, escape_p, print_depth); break;
case pair_type:
print_pair(stream, instance, escape_p, print_depth); break;
case empty_list_type:
print_empty_list(stream, instance, escape_p, print_depth); break;
case symbol_type:
print_symbol(stream, instance, escape_p, print_depth); break;
case simple_condition_type:
print_simple_condition(stream, instance, escape_p, print_depth); break;
case class_type:
print_class(stream, instance, escape_p, print_depth); break;
case function_type:
print_function(stream, instance, escape_p, print_depth); break;
case unknown_type:
format(stream, "?%lx", instance); break;
default:
print_user_defined(stream, instance, escape_p, print_depth); break;
}
}
/* useful for printing structure when debugging. */
static void
recurse(FILE* fp, const json_value* v)
{
switch(v->type) {
case json_object:
print_object(fp, v);
break;
case json_array:
print_array(fp, v->u.array.values, v->u.array.length);
break;
case json_integer:
print_integer(fp, v);
break;
case json_double:
print_double(fp, v);
break;
case json_string:
fprintf(fp, "string!\n");
break;
case json_boolean:
fprintf(fp, "boolean!\n");
break;
case json_none:
fprintf(fp, "none?!\n");
assert(false);
break;
default: assert(false);
}
}
/*
* 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);
}
int main()
{
int a = sum_i(6, 0, 1, 2, 3, 4, 5);
print_integer(a);
return a;
}
/*
* 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 main()
{
int a = 0;
a = test1();
print_integer(a); // a = 2
return a;
}
void coordinate_update() //updating coordinates on reaching node
{
switch(dir)
{
case 0:
Y++;
break;
case 1:
X++;
break;
case 2:
Y--;
break;
case 3:
X--;
break;
}
print_string("X=");
print_integer(X);
print_string(",Y=");
print_integer(Y);
}
int test_nolld2()
{
bool pass = true;
int a = 0;
a = test_alloc(); // 31
print_integer(a); // a = 1
if (a != 31) pass = false;
return pass;
}
int main (int argc, char *argv[])
{
cfg_t *cfg;
cfg = parse_conf(argc > 1 ? argv[1] : "/etc/example.conf");
if (!cfg)
return 1;
print_bool (cfg, "syslog");
print_integer(cfg, "period");
print_integer(cfg, "startup-delay");
print_integer(cfg, "forced-update");
print_bool (cfg, "wildcard");
print_string (cfg, "bind", 0);
print_systems(cfg);
cfg_free(cfg);
return 0;
}
void dump(Logger& logger) const
{
unsigned int actual_base = base_;
if (base_ < 1 || base_ >= kstrlen(base_char))
{
actual_base = logger.getDefaultNumberBase();
}
const char* prefix = logger.getBasePrefix(actual_base);
print_integer(logger, actual_base, i_, prefix);
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_w_customer(void *row)
{
struct W_CUSTOMER_TBL *r;
if (row == NULL)
r = &g_w_customer;
else
r = row;
print_start(CUSTOMER);
print_key(C_CUSTOMER_SK, r->c_customer_sk, 1);
print_varchar(C_CUSTOMER_ID, r->c_customer_id, 1);
print_key(C_CURRENT_CDEMO_SK, r->c_current_cdemo_sk, 1);
print_key(C_CURRENT_HDEMO_SK, r->c_current_hdemo_sk, 1);
print_key(C_CURRENT_ADDR_SK, r->c_current_addr_sk, 1);
print_integer(C_FIRST_SHIPTO_DATE_ID, r->c_first_shipto_date_id, 1);
print_integer(C_FIRST_SALES_DATE_ID, r->c_first_sales_date_id, 1);
print_varchar(C_SALUTATION, r->c_salutation, 1);
print_varchar(C_FIRST_NAME, r->c_first_name, 1);
print_varchar(C_LAST_NAME, r->c_last_name, 1);
print_boolean(C_PREFERRED_CUST_FLAG, r->c_preferred_cust_flag, 1);
print_integer(C_BIRTH_DAY, r->c_birth_day, 1);
print_integer(C_BIRTH_MONTH, r->c_birth_month, 1);
print_integer(C_BIRTH_YEAR, r->c_birth_year, 1);
print_varchar(C_BIRTH_COUNTRY, r->c_birth_country, 1);
print_varchar(C_LOGIN, &r->c_login[0], 1);
print_varchar(C_EMAIL_ADDRESS, &r->c_email_address[0], 1);
print_integer(C_LAST_REVIEW_DATE, r->c_last_review_date, 0);
print_end(CUSTOMER);
return(0);
}
void cut_init(const char *prog_name, int brkpoint )
{
breakpoint = brkpoint;
count = 0;
program = prog_name;
if( brkpoint >= 0 )
{
print_string( "Breakpoint at test " );
print_integer( brkpoint );
new_line();
}
}
static void print_integer(Logger& logger, int base, TT integer, const char* prefix = nullptr, typename Traits::disable_if<Traits::is_signed<TT>>::type* = nullptr)
{
if (prefix)
{
logger.write(prefix);
}
if (integer >= base)
{
print_integer(logger, base, integer / base);
}
logger.write(base_char[integer % base]);
}
/*
* 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);
}
static int print_node(state_t *state, bithenge_node_t *tree)
{
switch (bithenge_node_type(tree)) {
case BITHENGE_NODE_INTERNAL:
return print_internal(state, tree);
case BITHENGE_NODE_BOOLEAN:
return print_boolean(state, tree);
case BITHENGE_NODE_INTEGER:
return print_integer(state, tree);
case BITHENGE_NODE_STRING:
return print_string(state, tree);
case BITHENGE_NODE_BLOB:
return print_blob(state, tree);
}
return ENOTSUP;
}
// Render a value to text.
static char *print_value(cJSON *item,int depth,int fmt)
{
char *out=0;
if (!item) return 0;
switch ((item->type)&255)
{
case cJSON_NULL: out=cJSON_strdup("null"); break;
case cJSON_False: out=cJSON_strdup("false");break;
case cJSON_True: out=cJSON_strdup("true"); break;
case cJSON_Int: out=print_integer(item);break;
case cJSON_Float: out=print_float(item);break;
case cJSON_String: out=print_string(item);break;
case cJSON_Array: out=print_array(item,depth,fmt);break;
case cJSON_Object: out=print_object(item,depth,fmt);break;
}
return out;
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_s_warehouse(void *pSrc)
{
struct W_WAREHOUSE_TBL *r;
if (pSrc == NULL)
r = &g_w_warehouse;
else
r = pSrc;
print_start(S_WAREHOUSE);
print_varchar(W_WAREHOUSE_ID, r->w_warehouse_id, 1);
print_varchar(W_WAREHOUSE_NAME, &r->w_warehouse_name[0], 1);
print_integer(W_WAREHOUSE_SQ_FT, r->w_warehouse_sq_ft, 0);
print_end(S_WAREHOUSE);
return(0);
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_s_catalog(void *pSrc)
{
struct S_CATALOG_TBL *r;
if (pSrc == NULL)
r = &g_s_catalog;
else
r = pSrc;
print_start(S_CATALOG);
print_key(S_CATALOG_NUMBER, r->s_catalog_number, 1);
print_date(S_CATALOG_START_DATE, r->s_catalog_start_date.julian, 1);
print_date(S_CATALOG_END_DATE, r->s_catalog_end_date.julian, 1);
print_varchar(S_CATALOG_DESC, r->s_catalog_catalog_desc, 1);
print_integer(S_CATALOG_TYPE, r->s_catalog_catalog_type, 0);
print_end(S_CATALOG);
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);
}
void do_integer_value(int64_t value) override
{
begin_value();
print_integer(value,bos_);
end_value();
}
/*
* 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);
}
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() << ">>";
}
int main(int argc, char* argv[]) {
clear_screen();
print_string("\nExamen de ETC de ensamblador\n");
while (true) {
print_string("\n\n 1. Lectura de enteros por teclado\n 2. Cálculo del Máximo Común divisor (MCD)\n 3. Lectura de fracciones por teclado\n 4. Simplificación de fracciones\n 5. Suma de dos fracciones\n 6. Suma de un array de fracciones\n 7. Salir\n\nElige una opción: ");
char opc = read_character();
print_string("\n\n");
if (opc == '1') {
int n = preguntar_entero("Introduce un entero: ");
print_string("\nEl entero leído ha sido: ");
print_integer(n);
print_string("\n");
} else if (opc == '2') {
int a = preguntar_entero("Introduce un número (a): ");
int b = preguntar_entero("Introduce otro número (b): ");
print_string("\nEl MCD de a y b es: ");
print_integer(mcd(a, b));
print_string("\n");
} else if (opc == '3') {
Fraccion f;
preguntar_fraccion(&f);
print_string("\nLa fraccion leída ha sido: ");
print_fraccion(&f);
print_string("\n");
} else if (opc == '4') {
Fraccion f;
preguntar_fraccion(&f);
print_string("\nLa fraccion leída ha sido: ");
print_fraccion(&f);
simplificar_fraccion(&f);
print_string("\nLa fraccion simplificada es: ");
print_fraccion(&f);
print_string("\n");
} else if (opc == '5') {
Fraccion fa;
print_string("\nLeyendo la primera fracción:\n");
preguntar_fraccion(&fa);
print_string("La primera fraccion leída ha sido: ");
print_fraccion(&fa);
Fraccion fb;
print_string("\nLeyendo la segunda fracción:\n");
preguntar_fraccion(&fb);
print_string("La segunda fraccion leída ha sido: ");
print_fraccion(&fb);
Fraccion fc;
sumar_fracciones(&fc, &fa, &fb);
print_string("\nLa suma es: ");
print_fraccion(&fc);
simplificar_fraccion(&fc);
print_string("\nLa suma simplificada es: ");
print_fraccion(&fc);
print_string("\n");
} else if (opc == '6') {
print_string("\n");
for (int i = 0; i < NUM_FRACCIONES - 1; ++i) {
print_fraccion(&fracciones[i]);
print_string(" + ");
}
print_fraccion(&fracciones[NUM_FRACCIONES - 1]);
print_string(" = ");
Fraccion fr;
sumar_fracciones_array(&fr, fracciones, NUM_FRACCIONES);
print_fraccion(&fr);
print_string("\n");
} else if (opc == '7') {
print_string("¡Adiós!\n");
mips_exit(0);
} else {
print_string("Opción incorrecta. Pulse cualquier tecla para seguir.\n");
read_character();
}
}
}
void print_fraccion(Fraccion* f) {
print_integer(f->numerador);
print_character('/');
print_integer(f->denominador);
}
/*
* Routine:
* Purpose:
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
pr_w_date(void *row)
{
char sQuarterName[7];
struct W_DATE_TBL *r;
if (row == NULL)
r = &g_w_date;
else
r = row;
print_start(DATE);
print_key(D_DATE_SK, r->d_date_sk, 1);
print_varchar(D_DATE_ID, r->d_date_id, 1);
/* output the same information in a different format */
print_date(D_DATE_SK, r->d_date_sk, 1);
print_integer(D_MONTH_SEQ, r->d_month_seq, 1);
print_integer(D_WEEK_SEQ, r->d_week_seq, 1);
print_integer(D_QUARTER_SEQ, r->d_quarter_seq, 1);
print_integer(D_YEAR, r->d_year, 1);
print_integer(D_DOW, r->d_dow, 1);
print_integer(D_MOY, r->d_moy, 1);
print_integer(D_DOM, r->d_dom, 1);
print_integer(D_QOY, r->d_qoy, 1);
print_integer(D_FY_YEAR, r->d_fy_year, 1);
print_integer(D_FY_QUARTER_SEQ, r->d_fy_quarter_seq, 1);
print_integer(D_FY_WEEK_SEQ, r->d_fy_week_seq, 1);
print_varchar(D_DAY_NAME, r->d_day_name, 1);
sprintf(sQuarterName, "%4dQ%d", r->d_year, r->d_qoy);
print_varchar(D_QUARTER_NAME, sQuarterName, 1);
print_boolean(D_HOLIDAY, r->d_holiday, 1);
print_boolean(D_WEEKEND, r->d_weekend, 1);
print_boolean(D_FOLLOWING_HOLIDAY, r->d_following_holiday, 1);
print_integer(D_FIRST_DOM, r->d_first_dom, 1);
print_integer(D_LAST_DOM, r->d_last_dom, 1);
print_integer(D_SAME_DAY_LY, r->d_same_day_ly, 1);
print_integer(D_SAME_DAY_LQ, r->d_same_day_lq, 1);
print_boolean(D_CURRENT_DAY, r->d_current_day, 1);
print_boolean(D_CURRENT_WEEK, r->d_current_week, 1);
print_boolean(D_CURRENT_MONTH, r->d_current_month, 1);
print_boolean(D_CURRENT_QUARTER, r->d_current_quarter, 1);
print_boolean(D_CURRENT_YEAR, r->d_current_year, 0);
print_end(DATE);
return(0);
}
void print_float(CL_FORM *base)
{
COPY(ARG(0), ARG(2));
Fminusp(ARG(2));
if(CL_TRUEP(ARG(2)))
{
LOAD_CHAR(ARG(2), '-', ARG(2));
COPY(ARG(1), ARG(3));
write_char1(ARG(2));
mv_count = 1;
COPY(ARG(0), ARG(2));
Fminus(ARG(2), 1);
COPY(ARG(2), ARG(0));
}
COPY(ARG(0), ARG(2));
Fzerop(ARG(2));
if(CL_TRUEP(ARG(2)))
{
LOAD_SMSTR((CL_FORM *)&Kprint_float[0], ARG(2)); /* 0.0 */
COPY(ARG(2), ARG(3));
COPY(ARG(1), ARG(4));
LOAD_FIXNUM(ARG(5), 0, ARG(5));
COPY(ARG(2), ARG(6));
Flength(ARG(6));
write_string1(ARG(3));
COPY(ARG(3), ARG(0));
}
else
{
LOAD_FIXNUM(ARG(2), 10, ARG(2));
COPY(ARG(0), ARG(2));
LOAD_FIXNUM(ARG(3), 10, ARG(3));
rt_log(ARG(2));
LOAD_FIXNUM(ARG(3), 1, ARG(3));
LOAD_FIXNUM(ARG(3), 1, ARG(3));
rt_floor(ARG(2));
mv_count = 1;
COPY(ARG(0), ARG(3));
GEN_FLOAT(ARG(4), 10.0, ARG(4));
LOAD_FIXNUM(ARG(5), -1, ARG(5));
COPY(ARG(2), ARG(6));
Fminus(ARG(5), 2);
COPY(ARG(5), ARG(6));
Fminusp(ARG(6));
if(CL_TRUEP(ARG(6)))
{
LOAD_FIXNUM(ARG(6), 1, ARG(6));
COPY(ARG(4), ARG(7));
COPY(ARG(5), ARG(8));
Fminus(ARG(8), 1);
Fexpt(ARG(7));
Fdiv(ARG(6), 2);
COPY(ARG(6), ARG(4));
}
else
{
rt_expt(ARG(4));
}
Fmult(ARG(3), 2);
LOAD_NIL(ARG(4));
COPY(SYMVAL(Slisp, 2), ARG(5)); /* SHORT-FLOAT-EPSILON */
LOAD_NIL(ARG(6));
COPY(ARG(3), ARG(7));
LOAD_FIXNUM(ARG(8), 1, ARG(8));
COPY(ARG(5), ARG(9));
Fminus(ARG(8), 2);
Fge(ARG(7), 2);
if(CL_TRUEP(ARG(7)))
{
GEN_FLOAT(ARG(7), 0.1, ARG(3));
F1plus(ARG(2));
}
COPY(ARG(2), ARG(7));
LOAD_FIXNUM(ARG(8), 7, ARG(8));
Fgt(ARG(7), 2);
if(CL_TRUEP(ARG(7)))
{
goto THEN1;
}
else
{
COPY(ARG(2), ARG(8));
LOAD_FIXNUM(ARG(9), -3, ARG(9));
Flt(ARG(8), 2);
}
if(CL_TRUEP(ARG(8)))
{
THEN1:;
LOAD_FIXNUM(ARG(7), 0, ARG(4));
}
else
{
COPY(ARG(2), ARG(4));
LOAD_FIXNUM(ARG(7), 0, ARG(2));
}
COPY(ARG(4), ARG(7));
Fminusp(ARG(7));
if(CL_TRUEP(ARG(7)))
{
LOAD_CHAR(ARG(7), '0', ARG(7));
COPY(ARG(1), ARG(8));
write_char1(ARG(7));
mv_count = 1;
LOAD_CHAR(ARG(7), '.', ARG(7));
COPY(ARG(1), ARG(8));
write_char1(ARG(7));
mv_count = 1;
LOAD_FIXNUM(ARG(7), 0, ARG(7));
M1_1:;
COPY(ARG(7), ARG(8));
COPY(ARG(4), ARG(9));
Fminus(ARG(9), 1);
F1minus(ARG(9));
Fge(ARG(8), 2);
if(CL_TRUEP(ARG(8)))
{
goto RETURN1;
}
LOAD_CHAR(ARG(8), '0', ARG(8));
COPY(ARG(1), ARG(9));
write_char1(ARG(8));
mv_count = 1;
F1plus(ARG(7));
goto M1_1;
RETURN1:;
LOAD_FIXNUM(ARG(7), -1, ARG(4));
}
M2_1:;
COPY(ARG(5), ARG(7));
LOAD_FIXNUM(ARG(8), 10, ARG(8));
Fmult(ARG(7), 2);
COPY(ARG(7), ARG(5));
LOAD_FIXNUM(ARG(7), 10, ARG(7));
COPY(ARG(3), ARG(8));
Fmult(ARG(7), 2);
LOAD_FIXNUM(ARG(8), 1, ARG(8));
LOAD_FIXNUM(ARG(8), 1, ARG(8));
rt_truncate(ARG(7));
COPY(&mv_buf[0], ARG(8));
{
int nargs;
nargs = 2;
mv_count = 1;
{
switch(nargs)
{
case 0:
LOAD_NIL(ARG(7));
case 1:
LOAD_NIL(ARG(8));
nargs = 2;
}
COPY(ARG(7), ARG(6));
COPY(ARG(8), ARG(3));
}
}
COPY(ARG(3), ARG(7));
LOAD_FIXNUM(ARG(8), 1, ARG(8));
COPY(ARG(5), ARG(9));
Fminus(ARG(8), 2);
Fge(ARG(7), 2);
if(CL_TRUEP(ARG(7)))
{
goto THEN2;
}
else
{
COPY(ARG(3), ARG(8));
COPY(ARG(5), ARG(9));
Fle(ARG(8), 2);
}
if(CL_TRUEP(ARG(8)))
{
THEN2:;
goto RETURN2;
}
COPY(ARG(6), ARG(7));
LOAD_FIXNUM(ARG(8), 10, ARG(8));
digit_char1(ARG(7));
COPY(ARG(1), ARG(8));
write_char1(ARG(7));
mv_count = 1;
COPY(ARG(4), ARG(7));
Fzerop(ARG(7));
if(CL_TRUEP(ARG(7)))
{
LOAD_CHAR(ARG(7), '.', ARG(7));
COPY(ARG(1), ARG(8));
write_char1(ARG(7));
mv_count = 1;
}
F1minus(ARG(4));
goto M2_1;
RETURN2:;
COPY(ARG(3), ARG(7));
GEN_FLOAT(ARG(8), 0.5, ARG(8));
Fge(ARG(7), 2);
if(CL_TRUEP(ARG(7)))
{
F1plus(ARG(6));
}
COPY(ARG(6), ARG(7));
LOAD_FIXNUM(ARG(8), 10, ARG(8));
digit_char1(ARG(7));
COPY(ARG(1), ARG(8));
write_char1(ARG(7));
mv_count = 1;
COPY(ARG(4), ARG(7));
LOAD_FIXNUM(ARG(8), 0, ARG(8));
Fge(ARG(7), 2);
if(CL_TRUEP(ARG(7)))
{
LOAD_FIXNUM(ARG(7), 0, ARG(7));
M3_1:;
COPY(ARG(7), ARG(8));
COPY(ARG(4), ARG(9));
Fge(ARG(8), 2);
if(CL_TRUEP(ARG(8)))
{
goto RETURN3;
}
LOAD_CHAR(ARG(8), '0', ARG(8));
COPY(ARG(1), ARG(9));
write_char1(ARG(8));
mv_count = 1;
F1plus(ARG(7));
goto M3_1;
RETURN3:;
LOAD_CHAR(ARG(7), '.', ARG(7));
COPY(ARG(1), ARG(8));
write_char1(ARG(7));
mv_count = 1;
LOAD_CHAR(ARG(7), '0', ARG(7));
COPY(ARG(1), ARG(8));
write_char1(ARG(7));
mv_count = 1;
}
COPY(ARG(2), ARG(7));
Fzerop(ARG(7));
if(CL_TRUEP(ARG(7)))
{
}
else
{
LOAD_CHAR(ARG(7), 'E', ARG(7));
COPY(ARG(1), ARG(8));
write_char1(ARG(7));
mv_count = 1;
COPY(ARG(2), ARG(7));
COPY(ARG(1), ARG(8));
print_integer(ARG(7));
mv_count = 1;
}
LOAD_NIL(ARG(0));
}
}
