Esempio n. 1
0
static void __lambda_22(void *data, int argc, object self_7375, object c_7311) {
  if( (boolean_f != Cyc_is_eof_object(c_7311)) ){ 
  
closureN_type c_73191;
c_73191.hdr.mark = gc_color_red;
 c_73191.hdr.grayed = 0;
c_73191.tag = closureN_tag;
 c_73191.fn = (function_type)__lambda_19;
c_73191.num_args = 1;
c_73191.num_elements = 1;
c_73191.elements = (object *)alloca(sizeof(object) * 1);
c_73191.elements[0] = ((closureN)self_7375)->elements[0];


make_string(c_73196, "\n");
return_closcall2(data,  __glo_display_scheme_write,  &c_73191, &c_73196);
} else { 
  
closureN_type c_73198;
c_73198.hdr.mark = gc_color_red;
 c_73198.hdr.grayed = 0;
c_73198.tag = closureN_tag;
 c_73198.fn = (function_type)__lambda_21;
c_73198.num_args = 1;
c_73198.num_elements = 1;
c_73198.elements = (object *)alloca(sizeof(object) * 1);
c_73198.elements[0] = ((closureN)self_7375)->elements[0];

return_closcall2(data,  __glo_write_scheme_write,  &c_73198, c_7311);}
; 
}
Esempio n. 2
0
static void __lambda_10(void *data, int argc, object self_7386, object k_7353) {
  if( (boolean_f != Cyc_is_pair(cell_get(((closureN)self_7386)->elements[0]))) ){ 
  
closureN_type c_73117;
c_73117.hdr.mark = gc_color_red;
 c_73117.hdr.grayed = 0;
c_73117.tag = closureN_tag;
 c_73117.fn = (function_type)__lambda_6;
c_73117.num_args = 0;
c_73117.num_elements = 1;
c_73117.elements = (object *)alloca(sizeof(object) * 1);
c_73117.elements[0] = ((closureN)self_7386)->elements[0];


closureN_type c_73153;
c_73153.hdr.mark = gc_color_red;
 c_73153.hdr.grayed = 0;
c_73153.tag = closureN_tag;
 c_73153.fn = (function_type)__lambda_9;
c_73153.num_args = 1;
c_73153.num_elements = 2;
c_73153.elements = (object *)alloca(sizeof(object) * 2);
c_73153.elements[0] = k_7353;
c_73153.elements[1] = ((closureN)self_7386)->elements[0];

return_closcall1(data,(closure)&c_73117,  &c_73153);
} else { 
  return_closcall2(data,  __glo_display_scheme_write,  k_7353, cell_get(((closureN)self_7386)->elements[0]));}
; 
}
Esempio n. 3
0
static void __lambda_8(void *data, int argc, object self_7388, object k_7357, object o_7314) {
  
closureN_type c_73158;
c_73158.hdr.mark = gc_color_red;
 c_73158.hdr.grayed = 0;
c_73158.tag = closureN_tag;
 c_73158.fn = (function_type)__lambda_7;
c_73158.num_args = 1;
c_73158.num_elements = 1;
c_73158.elements = (object *)alloca(sizeof(object) * 1);
c_73158.elements[0] = k_7357;

return_closcall2(data,  __glo_write_scheme_write,  &c_73158, o_7314);; 
}
Esempio n. 4
0
static void __lambda_4(void *data, int argc, object self_7392, object r_7364) {
  
closureN_type c_73125;
c_73125.hdr.mark = gc_color_red;
 c_73125.hdr.grayed = 0;
c_73125.tag = closureN_tag;
 c_73125.fn = (function_type)__lambda_3;
c_73125.num_args = 1;
c_73125.num_elements = 2;
c_73125.elements = (object *)alloca(sizeof(object) * 2);
c_73125.elements[0] = ((closureN)self_7392)->elements[0];
c_73125.elements[1] = ((closureN)self_7392)->elements[1];

return_closcall2(data,  __glo_display_scheme_write,  &c_73125, r_7364);; 
}
Esempio n. 5
0
static void __lambda_7(void *data, int argc, object self_7366, object r_7336) {
  
closureN_type c_7390;
c_7390.hdr.mark = gc_color_red;
 c_7390.hdr.grayed = 0;
c_7390.tag = closureN_tag;
 c_7390.fn = (function_type)__lambda_6;
c_7390.num_args = 2;
c_7390.num_elements = 2;
c_7390.elements = (object *)alloca(sizeof(object) * 2);
c_7390.elements[0] = ((closureN)self_7366)->elements[0];
c_7390.elements[1] = ((closureN)self_7366)->elements[2];

return_closcall2(data,(closure)&c_7390,  ((closureN)self_7366)->elements[1], r_7336);; 
}
Esempio n. 6
0
static void __lambda_25(void *data, int argc, closure _,object k_7332) {
  Cyc_st_add(data, "icyc.scm:repl");

closureN_type c_73183;
c_73183.hdr.mark = gc_color_red;
 c_73183.hdr.grayed = 0;
c_73183.tag = closureN_tag;
 c_73183.fn = (function_type)__lambda_24;
c_73183.num_args = 1;
c_73183.num_elements = 1;
c_73183.elements = (object *)alloca(sizeof(object) * 1);
c_73183.elements[0] = k_7332;


make_string(c_73203, "cyclone> ");
return_closcall2(data,  __glo_display_scheme_write,  &c_73183, &c_73203);; 
}
Esempio n. 7
0
static void __lambda_9(void *data, int argc, object self_7364, object r_7335) {
  
closureN_type c_7386;
c_7386.hdr.mark = gc_color_red;
 c_7386.hdr.grayed = 0;
c_7386.tag = closureN_tag;
 c_7386.fn = (function_type)__lambda_8;
c_7386.num_args = 1;
c_7386.num_elements = 4;
c_7386.elements = (object *)alloca(sizeof(object) * 4);
c_7386.elements[0] = ((closureN)self_7364)->elements[0];
c_7386.elements[1] = r_7335;
c_7386.elements[2] = ((closureN)self_7364)->elements[1];
c_7386.elements[3] = ((closureN)self_7364)->elements[2];

return_closcall2(data,  __glo_current_91input_91port_scheme_base,  &c_7386, quote__121param_91convert_125);; 
}
Esempio n. 8
0
static void __lambda_3(void *data, int argc, object self_7393, object r_7361) {
  
closureN_type c_73127;
c_73127.hdr.mark = gc_color_red;
 c_73127.hdr.grayed = 0;
c_73127.tag = closureN_tag;
 c_73127.fn = (function_type)__lambda_2;
c_73127.num_args = 1;
c_73127.num_elements = 2;
c_73127.elements = (object *)alloca(sizeof(object) * 2);
c_73127.elements[0] = ((closureN)self_7393)->elements[0];
c_73127.elements[1] = ((closureN)self_7393)->elements[1];


make_string(c_73140, ": ");
return_closcall2(data,  __glo_display_scheme_write,  &c_73127, &c_73140);; 
}
Esempio n. 9
0
static void __lambda_19(void *data, int argc, object self_7386, object r_7337) {
  
closureN_type c_73195;
c_73195.hdr.mark = gc_color_red;
 c_73195.hdr.grayed = 0;
c_73195.tag = closureN_tag;
 c_73195.fn = (function_type)__lambda_18;
c_73195.num_args = 1;
c_73195.num_elements = 4;
c_73195.elements = (object *)alloca(sizeof(object) * 4);
c_73195.elements[0] = ((closureN)self_7386)->elements[0];
c_73195.elements[1] = ((closureN)self_7386)->elements[1];
c_73195.elements[2] = ((closureN)self_7386)->elements[2];
c_73195.elements[3] = r_7337;

return_closcall2(data,  __glo_Cyc_91er_91rename_scheme_cyclone_util,  &c_73195, ((closureN)self_7386)->elements[1]);; 
}
Esempio n. 10
0
static void __lambda_18(void *data, int argc, closure _,object k_7342) {
  Cyc_st_add(data, "icyc.scm:repl:next-line");

closureN_type c_7399;
c_7399.hdr.mark = gc_color_red;
 c_7399.hdr.grayed = 0;
c_7399.tag = closureN_tag;
 c_7399.fn = (function_type)__lambda_0;
c_7399.num_args = 1;
c_7399.num_elements = 1;
c_7399.elements = (object *)alloca(sizeof(object) * 1);
c_7399.elements[0] = k_7342;


mclosure0(c_73102, (function_type)__lambda_17);c_73102.num_args = 1;
return_closcall2(data,  __glo_call_95cc_scheme_base,  &c_7399, &c_73102);; 
}
Esempio n. 11
0
static void __lambda_8(void *data, int argc, object self_7365, object r_7345) {
  
closureN_type c_7388;
c_7388.hdr.mark = gc_color_red;
 c_7388.hdr.grayed = 0;
c_7388.tag = closureN_tag;
 c_7388.fn = (function_type)__lambda_7;
c_7388.num_args = 1;
c_7388.num_elements = 3;
c_7388.elements = (object *)alloca(sizeof(object) * 3);
c_7388.elements[0] = ((closureN)self_7365)->elements[0];
c_7388.elements[1] = ((closureN)self_7365)->elements[1];
c_7388.elements[2] = ((closureN)self_7365)->elements[3];


port_type c_73110 = Cyc_io_open_input_file(data,((closureN)self_7365)->elements[2]);
return_closcall2(data,  r_7345,  &c_7388, &c_73110);; 
}
Esempio n. 12
0
static void __lambda_14(void *data, int argc, object self_7382, object obj_7313) {
  
closureN_type c_73108;
c_73108.hdr.mark = gc_color_red;
 c_73108.hdr.grayed = 0;
c_73108.tag = closureN_tag;
 c_73108.fn = (function_type)__lambda_13;
c_73108.num_args = 1;
c_73108.num_elements = 3;
c_73108.elements = (object *)alloca(sizeof(object) * 3);
c_73108.elements[0] = ((closureN)self_7382)->elements[0];
c_73108.elements[1] = ((closureN)self_7382)->elements[1];
c_73108.elements[2] = obj_7313;


make_string(c_73175, "Error: ");
return_closcall2(data,  __glo_display_scheme_write,  &c_73108, &c_73175);; 
}
Esempio n. 13
0
static void __lambda_21(void *data, int argc, object self_7384, object compiled_91macro_127_7312) {
  if( (boolean_f != ((closureN)self_7384)->elements[3]) ){ 
  if( (boolean_f != compiled_91macro_127_7312) ){ 
  
closureN_type c_73180;
c_73180.hdr.mark = gc_color_red;
 c_73180.hdr.grayed = 0;
c_73180.tag = closureN_tag;
 c_73180.fn = (function_type)__lambda_16;
c_73180.num_args = 1;
c_73180.num_elements = 3;
c_73180.elements = (object *)alloca(sizeof(object) * 3);
c_73180.elements[0] = ((closureN)self_7384)->elements[0];
c_73180.elements[1] = ((closureN)self_7384)->elements[1];
c_73180.elements[2] = ((closureN)self_7384)->elements[3];

return_closcall2(data,  __glo_Cyc_91er_91rename_scheme_cyclone_util,  &c_73180, ((closureN)self_7384)->elements[2]);
} else { 
  
closureN_type c_73191;
c_73191.hdr.mark = gc_color_red;
 c_73191.hdr.grayed = 0;
c_73191.tag = closureN_tag;
 c_73191.fn = (function_type)__lambda_20;
c_73191.num_args = 1;
c_73191.num_elements = 4;
c_73191.elements = (object *)alloca(sizeof(object) * 4);
c_73191.elements[0] = ((closureN)self_7384)->elements[0];
c_73191.elements[1] = ((closureN)self_7384)->elements[1];
c_73191.elements[2] = ((closureN)self_7384)->elements[2];
c_73191.elements[3] = ((closureN)self_7384)->elements[3];

return_closcall1(data,(closure)&c_73191,  quote_quote);}

} else { 
  
make_string(c_73211, "macro not found");
return_closcall3(data,  __glo_error_scheme_base,  ((closureN)self_7384)->elements[1], &c_73211, ((closureN)self_7384)->elements[0]);}
; 
}
Esempio n. 14
0
static void __lambda_2(void *data, int argc, closure _,object k_7323, object z_736) {
  Cyc_st_add(data, "scheme/complex.sld:angle");

make_string(c_7336, "Complex numbers are not supported at this time");
return_closcall2(data,  __glo_error_scheme_base,  k_7323, &c_7336);; 
}
Esempio n. 15
0
static void __lambda_4(void *data, int argc, closure _,object k_7317, object x_734, object y_733) {
  Cyc_st_add(data, "scheme/complex.sld:make-rectangular");

make_string(c_7342, "Complex numbers are not supported at this time");
return_closcall2(data,  __glo_error_scheme_base,  k_7317, &c_7342);; 
}
Esempio n. 16
0
static void __lambda_7(void *data, int argc, object self_7389, object r_7358) {
  
make_string(c_73161, " ");
return_closcall2(data,  __glo_display_scheme_write,  ((closureN)self_7389)->elements[0], &c_73161);; 
}
Esempio n. 17
0
static void __lambda_11(void *data, int argc, object self_7385, object r_7352) {
  return_closcall2(data,  ((closureN)self_7385)->elements[0],  ((closureN)self_7385)->elements[1], boolean_t);; 
}