/* Help functionality to print out sorted list of test names and suite names */
static void print_targets(testentry_t tests[], int count) {
char**array;
char *previous;
int i;
array=(char**)calloc(sizeof(char*),count);
/* Sort the test names and print unique entries*/
for(i=0;i<count;i++) array[i]=tests[i].name;
qsort(array,count,sizeof(array[0]),mystrcmp);
printf("\nValid tests : all");
for(i=0,previous="";i<count; i++) if(!eql(previous,array[i])) printf(" %s",(previous=array[i]));
/* Sort the suite names and print unique entries*/
for(i=0;i<count;i++) array[i]=tests[i].suite;
qsort(array, count,sizeof(array[0]),mystrcmp);
printf("\nValid suites:");
for(i=0,previous="";i<count; i++) if(!eql(previous,array[i])) printf(" %s",(previous=array[i]));
printf("\nValid strategies: all ");
for(i=1;i<5;i++)
printf("%s ",strategy_name(i));
printf("\n");
}
/*
* Main entry point for test harness
*/
int
run_testrunner(int argc, const char **argv, testentry_t tests[], int test_count)
{
const char *test_name, *target;
int i;
stats_t stats;
int target_matched, max_errors_before_quit, redirect_stdouterr;
memset(&stats, 0, sizeof(stats));
max_errors_before_quit = 1;
redirect_stdouterr = 0;
assert(tests != NULL);
assert(test_count > 0);
assert(argc > 0 && argv && *argv);
while (true) {
target = argc > 1 ? argv[1] : "";
assert(target);
if (*target != '-')
break;
argc--;
argv++;
if (target[1] == 'f' && target[2])
max_errors_before_quit = atoi(target + 1);
else if (target[1] == 'r')
redirect_stdouterr = 1;
}
target_matched = false;
for (i = 0;
i < test_count && (max_errors_before_quit < 1
|| stats.failed != max_errors_before_quit);
i++) {
test_name = tests[i].name;
assert(test_name);
assert(tests[i].suite);
assert(tests[i].test_function);
if (eql(target, test_name) || eql(target, "all")
|| eql(target, tests[i].suite)) {
if (!target_matched)
printf("Running tests...\n");
target_matched = true;
run_one_test(&stats, &tests[i], redirect_stdouterr, argc - 1,
argv + 1);
}
}
if (!target_matched) {
fprintf(stderr, "Test '%s' not found",
(strlen(target) > 0 ? target : "(empty)"));
print_targets(tests, test_count);
} else {
printf("\nTest Results:%d tests,%d passed,%d failed.\n", stats.ran,
stats.passed, stats.failed);
}
return stats.passed == stats.ran && target_matched ? 0 : 1;
}
void cmp_tests() {
int a = 1, b = 2;
/* greater tests */
gtl((char *)&a, (char *)&b); assert(*(int32_t *)ecx == 0);
gtl((char *)&b, (char *)&a); assert(*(int32_t *)ecx == 1);
gel((char *)&a, (char *)&b); assert(*(int32_t *)ecx == 0);
gel((char *)&a, (char *)&a); assert(*(int32_t *)ecx == 1);
gel((char *)&b, (char *)&a); assert(*(int32_t *)ecx == 1);
/* less tests */
ltl((char *)&a, (char *)&b); assert(*(int32_t *)ecx == 1);
ltl((char *)&b, (char *)&a); assert(*(int32_t *)ecx == 0);
lel((char *)&a, (char *)&b); assert(*(int32_t *)ecx == 1);
lel((char *)&a, (char *)&a); assert(*(int32_t *)ecx == 1);
lel((char *)&b, (char *)&a); assert(*(int32_t *)ecx == 0);
/* (not) equal tests */
eql((char *)&a, (char *)&b); assert(*(int32_t *)ecx == 0);
eql((char *)&b, (char *)&b); assert(*(int32_t *)ecx == 1);
nel((char *)&a, (char *)&b); assert(*(int32_t *)ecx == 1);
nel((char *)&a, (char *)&a); assert(*(int32_t *)ecx == 0);
/* and/or tests */
a = 0, b = 1;
andl((char *)&a, (char *)&a); assert(*(int32_t *)ecx == 0);
andl((char *)&a, (char *)&b); assert(*(int32_t *)ecx == 0);
andl((char *)&b, (char *)&b); assert(*(int32_t *)ecx == 1);
orl((char *)&a, (char *)&a); assert(*(int32_t *)ecx == 0);
orl((char *)&a, (char *)&b); assert(*(int32_t *)ecx == 1);
orl((char *)&b, (char *)&b); assert(*(int32_t *)ecx == 1);
}
/* dotest2 - call a test function with two arguments */
int dotest2 P3C(LVAL, arg1, LVAL, arg2, LVAL, fun)
{
FRAMEP newfp;
/* Speedup for default case TAA MOD */
if (fun == getfunction(s_eql))
return (eql(arg1,arg2));
/* Speedup for EQ and EQUAL for hash tables */
if (fun == getfunction(s_eq))
return (arg1 == arg2);
if (fun == getfunction(s_equal))
return (equal(arg1,arg2));
/* create the new call frame */
newfp = xlsp;
pusharg(cvfixnum((FIXTYPE)(newfp - xlfp)));
pusharg(fun);
pusharg(cvfixnum((FIXTYPE)2));
pusharg(arg1);
pusharg(arg2);
xlfp = newfp;
/* return the result of applying the test function */
return (xlapply(2) != NIL);
}
Obj delete_eql (Obj item, Obj list, Obj count)
{
Obj g;
sint32 g_1;
Obj g_2, g_3, g_4;
g = list;
g_1 = 0;
g_2 = (Obj)NULL;
g_3 = (Obj)NULL;
g_4 = g;
while (g_4!=NULL) {
g_3 = CDR(g_4);
if (eql(CAR(g_4),item)!=NULL) {
if (g_2!=NULL)
CDR(g_2) = g_3;
else
g = g_3;
if (count!=NULL) {
g_1 = (g_1+1);
if (g_1>=UNBOXFIX(count))
return g;
}
}
else
g_2 = g_4;
g_4 = g_3;
}
return g;
}
int equal(NODE *arg1, NODE *arg2)
{
if (eql(arg1,arg2))
return (1);
else if (((arg1) && (arg1)->n_type == 3) && ((arg2) && (arg2)->n_type == 3))
return (equal(((arg1)->n_info.n_xlist.xl_car),((arg2)->n_info.n_xlist.xl_car)) && equal(((arg1)->n_info.n_xlist.xl_cdr),((arg2)->n_info.n_xlist.xl_cdr)));
else
return (0);
}
Obj member_eql (Obj item, Obj list)
{
Obj g;
g = list;
for (;g!=NULL;g = CDR(g)) {
if (eql(item,CAR(g))!=NULL)
return g;
}
return (Obj)NULL;
}
int
search (char *term)
{
register int n;
for (n = 0; n < 255; n++)
if (hashtable[n].string && eql (hashtable[n].string, term))
return hashtable[n].o;
return 0;
}
/* xeql - are these equal? */
LVAL xeql(void)
{
LVAL arg1,arg2;
/* get the two arguments */
arg1 = xlgetarg();
arg2 = xlgetarg();
xllastarg();
/* compare the arguments */
return (eql(arg1,arg2) ? s_true : NIL);
}
Obj assoc_eql (Obj item, Obj alist)
{
Obj g, g_1;
g = alist;
for (;g!=NULL;g = CDR(g)) {
g_1 = CAR(g);
if (eql(CAR(g_1),item)!=NULL)
return g_1;
}
return (Obj)NULL;
}
double levenshtein_distance (const unsigned char *s1, const unsigned char *s2) {
const size_t len1 = min(strlen(s1), STRLEN_MAX-1),
len2 = min(strlen(s2), STRLEN_MAX-1);
int cost, i, j;
for (i = 1; i <= len1; ++i) d[i][0] = i;
for (i = 1; i <= len2; ++i) d[0][i] = i;
for (i = 1; i <= len1; ++i) {
for (j = 1; j <= len2; ++j) {
cost = (eql(s1[i-1], s2[j-1]) ? 0 : 1);
d[i][j] = min(min(
d[i-1][j ] + 1, /* deletion */
d[i ][j-1] + 1), /* insertion */
d[i-1][j-1] + cost); /* substitution */
if (i > 1 && j > 1 && eql(s1[i-1], s2[j-2]) && eql(s1[i-2], s2[j-1])) {
d[i][j] = min( d[i][j],
d[i-2][j-2] + cost ); /* transposition */
}
}
}
return (d[len1][len2] / (double) max(len1, len2));
}
int main() {
int i;
string r, t;
INITIALIZE("%d \t %s \t %s\n", i, t.c_str(), r.c_str());
set(r, "a");
i = len(r);
while(unknown()) {
PRINT_VARS();
t = unknown_s(1);
set(r, cat(r, t));
}
PRINT_VARS();
assert(eql(sub(r, 0, i), "a"));
return 0;
}
void testController(){
/* Initally values */
bus clk ("P"); // Clock pulse
bus rst ("0");
bus go("P");
bus gtr("1");
bus eql("0");
bus les("0");
bus en_quo, ready;
DividerController * DC = new DividerController(clk, rst, go, gtr, eql, les, en_quo, ready);
std::cout << "The inital values:\n";
DC->printValues();
DC->eval();
std::cout << "\nAfter evaluation:\n";
DC->printValues();
DC->eval();
std::cout << "\nAfter evaluation:\n";
DC->printValues();
/* Next values */
clk = "P";
rst = "0";
go = "0";
gtr = "0";
eql = "1";
les = "0";
DC->eval();
std::cout << "\nAfter evaluation:\n";
DC->printValues();
}
bool lte(double a, double b) { return lt(a, b) || eql(a, b); }
static void L15()
{register object *base=vs_base;
register object *sup=base+VM15; VC15
vs_check;
{object V19;
object V20;
object V21;
check_arg(3);
V19=(base[0]);
V20=(base[1]);
V21=(base[2]);
vs_top=sup;
goto TTL;
TTL:;
{object V22;
object V23;
object V24;
object V25;
{register object x= VV[4],V26= (V20);
while(V26!=Cnil)
if(x==(V26->c.c_car)){
V22= V26;
goto T62;
}else V26=V26->c.c_cdr;
V22= Cnil;}
goto T62;
T62:;
if((V22)==Cnil){
V23= Cnil;
goto T63;}
base[7]= (V20);
base[8]= (V22);
vs_top=(vs_base=base+7)+2;
Lldiff();
vs_top=sup;
V23= vs_base[0];
goto T63;
T63:;
if(((V22))==Cnil){
goto T68;}
V24= append((V23),VV[9]);
goto T66;
goto T68;
T68:;
V24= (V20);
goto T66;
T66:;
{register object x= VV[11],V28= (V19);
while(V28!=Cnil)
if(eql(x,V28->c.c_car)){
goto T74;
}else V28=V28->c.c_cdr;
goto T73;}
goto T74;
T74:;
V27= VV[12];
goto T71;
goto T73;
T73:;
V27= Cnil;
goto T71;
T71:;
V29= list(3,VV[13],(V24),list(4,VV[14],Cnil,VV[15],(V21)));
V30= make_cons(/* INLINE-ARGS */V29,Cnil);
V25= listA(3,VV[10],(V19),append(V27,/* INLINE-ARGS */V30));
if(((VV[2]->s.s_dbind))==Cnil){
goto T77;}
base[7]= list(2,VV[16],(V25));
goto T75;
goto T77;
T77:;
base[8]= (V25);
vs_top=(vs_base=base+8)+1;
(void) (*Lnk178)();
vs_top=sup;
base[7]= vs_base[0];
goto T75;
T75:;
base[8]= Cnil;
vs_top=(vs_base=base+7)+2;
return;}
}
}
static void L16()
{register object *base=vs_base;
register object *sup=base+VM16; VC16
vs_check;
{object V31;
object V32;
register object V33;
check_arg(3);
V31=(base[0]);
V32=(base[1]);
V33=(base[2]);
vs_top=sup;
goto TTL;
TTL:;
if(((VV[2]->s.s_dbind))!=Cnil){
goto T81;}
if(((VV[3]->s.s_dbind))==Cnil){
goto T81;}
base[3]= (V31);
base[4]= (V32);
base[5]= (V33);
vs_top=(vs_base=base+3)+3;
(void) (*Lnk179)();
return;
goto T81;
T81:;
{register object V34;
register object V35;
object V36;
object V37;
object V38;
object V39;
V37= (*(LnkLI180))(VV[17]);
V38= (((V31))==(VV[0])?Ct:Cnil);
V39= (*(LnkLI181))((V33),VV[18],VV[19]);
V34= Cnil;
V35= Cnil;
V36= Cnil;
{object V41= V31;
if((V41!= VV[0]))goto T93;
V34= (*(LnkLI182))(small_fixnum(0));
V35= make_cons((V34),Cnil);
goto T92;
goto T93;
T93:;
if((V41!= VV[1]))goto T97;
V34= (*(LnkLI182))(small_fixnum(1));
V42= (*(LnkLI182))(small_fixnum(0));
V35= list(2,/* INLINE-ARGS */V42,(V34));
goto T92;
goto T97;
T97:;
base[3]= VV[20];
base[4]= VV[21];
base[5]= VV[22];
base[6]= VV[23];
base[7]= V31;
base[8]= VV[24];
base[9]= VV[25];
base[10]= VV[26];
base[11]= VV[27];
vs_top=(vs_base=base+3)+9;
(void) (*Lnk183)();
vs_top=sup;}
goto T92;
T92:;
{object V44= V32;
if(!eql(V44,VV[28]))goto T111;
V36= VV[29];
goto T110;
goto T111;
T111:;
if(!eql(V44,VV[30]))goto T113;
V36= VV[31];
goto T110;
goto T113;
T113:;
base[3]= VV[20];
base[4]= VV[21];
base[5]= VV[22];
base[6]= VV[23];
base[7]= V32;
base[8]= VV[24];
base[9]= VV[32];
base[10]= VV[26];
base[11]= VV[33];
vs_top=(vs_base=base+3)+9;
(void) (*Lnk183)();
vs_top=sup;}
goto T110;
T110:;
base[3]= (V36);
base[4]= (V35);
if(((V33))!=Cnil){
goto T129;}
V45= VV[35];
goto T127;
goto T129;
T129:;
V45= Cnil;
goto T127;
T127:;
V46= list(2,VV[38],(V34));
if(((V33))!=Cnil){
goto T133;}
V48= list(3,VV[39],VV[19],list(2,VV[40],(V34)));
V47= make_cons(/* INLINE-ARGS */V48,Cnil);
goto T131;
goto T133;
T133:;
V47= Cnil;
goto T131;
T131:;
V49= list(2,VV[41],(V34));
V50= make_cons(/* INLINE-ARGS */V49,Cnil);
V51= append(V47,/* INLINE-ARGS */V50);
V52= make_cons(/* INLINE-ARGS */V46,/* INLINE-ARGS */V51);
V53= list(2,VV[42],(V34));
if(((V33))!=Cnil){
goto T137;}
V55= list(3,VV[39],VV[19],list(2,VV[43],(V34)));
V54= make_cons(/* INLINE-ARGS */V55,Cnil);
goto T135;
goto T137;
T137:;
V54= Cnil;
goto T135;
T135:;
V56= list(2,VV[44],(V34));
V57= make_cons(/* INLINE-ARGS */V56,Cnil);
V58= append(V54,/* INLINE-ARGS */V57);
V59= list(2,VV[36],list(3,VV[37],/* INLINE-ARGS */V52,make_cons(/* INLINE-ARGS */V53,/* INLINE-ARGS */V58)));
if(((V38))==Cnil){
goto T141;}
V60= VV[45];
goto T139;
goto T141;
T141:;
V60= Cnil;
goto T139;
T139:;
V61= make_cons(/* INLINE-ARGS */V59,V60);
V62= append(V45,/* INLINE-ARGS */V61);
V63= list(2,VV[49],list(3,VV[50],VV[36],(V37)));
if(!(eql(small_fixnum(2),(V32)))){
goto T145;}
V64= VV[53];
goto T143;
goto T145;
T145:;
V64= Cnil;
goto T143;
T143:;
V65= list(2,VV[51],listA(3,VV[47],VV[52],V64));
if(((V38))==Cnil){
goto T149;}
V67= list(3,VV[54],VV[55],list(3,VV[39],VV[56],(V39)));
V66= make_cons(/* INLINE-ARGS */V67,Cnil);
goto T147;
goto T149;
T149:;
V66= Cnil;
goto T147;
T147:;
V68= listA(5,VV[47],VV[48],/* INLINE-ARGS */V63,/* INLINE-ARGS */V65,V66);
V69= listA(3,VV[57],VV[11],(V35));
if(((V38))==Cnil){
goto T153;}
V70= VV[56];
goto T151;
goto T153;
T153:;
V70= list(3,VV[58],(V39),CMPcar((V35)));
goto T151;
T151:;
base[5]= list(3,VV[34],/* INLINE-ARGS */V62,list(4,VV[46],/* INLINE-ARGS */V68,/* INLINE-ARGS */V69,V70));
vs_top=(vs_base=base+3)+3;
(void) (*Lnk176)();
return;}
}
}
/* Callback function for qsort on strings */
static int mystrcmp( const void *p1, const void *p2) {
return eql( ( char*)p1, ( char*)p2);
}
void executeInstruction()
{
switch(ir.op)
{
case 1:
lit();
break;
case 2:
opr();
break;
case 3:
lod();
break;
case 4:
sto();
break;
case 5:
cal();
break;
case 6:
inc();
break;
case 7:
jmp();
break;
case 8:
jpc();
break;
case 9:
sio();
default:
break;
}
void opr()
{
switch ( ir.m)
{
//rtn
case 0:
ret();
break;
//neg
case 1:
neg();
break;
//add
case 2:
add();
break;
//sub
case 3:
sub();
break;
//mul
case 4:
mul();
break;
//div
case 5:
divid();
break;
//odd
case 6:
odd();
break;
//mod
case 7:
mod();
break;
//eql
case 8:
eql();
break;
//neq
case 9:
neq();
break;
//lss
case 10:
lss();
break;
//leq
case 11:
leq();
break;
//gtr
case 12:
gtr();
break;
//geq
case 13:
geq();
break;
default:
fprintf(output, "OP code input was invalid. ");
halt = 1;
break;
}
}
}
void opr()
{
switch ( ir.m)
{
//rtn
case 0:
ret();
break;
//neg
case 1:
neg();
break;
//add
case 2:
add();
break;
//sub
case 3:
sub();
break;
//mul
case 4:
mul();
break;
//div
case 5:
divid();
break;
//odd
case 6:
odd();
break;
//mod
case 7:
mod();
break;
//eql
case 8:
eql();
break;
//neq
case 9:
neq();
break;
//lss
case 10:
lss();
break;
//leq
case 11:
leq();
break;
//gtr
case 12:
gtr();
break;
//geq
case 13:
geq();
break;
default:
fprintf(output, "OP code input was invalid. ");
sio3();
}
}
static void L1()
{register object *base=vs_base;
register object *sup=base+VM1; VC1
vs_check;
{register object V1;
object V2;
object V3;
if(vs_top-vs_base<1) too_few_arguments();
if(vs_top-vs_base>3) too_many_arguments();
V1=(base[0]);
vs_base=vs_base+1;
if(vs_base>=vs_top){vs_top=sup;goto T1;}
V2=(base[1]);
vs_base++;
if(vs_base>=vs_top){vs_top=sup;goto T2;}
V3=(base[2]);
vs_top=sup;
goto T3;
goto T1;
T1:;
V2= Cnil;
goto T2;
T2:;
V3= Cnil;
goto T3;
T3:;
{object V4;
{register object x= (V1),V6= (V2);
while(V6!=Cnil)
if(eql(x,V6->c.c_car->c.c_car) &&V6->c.c_car != Cnil){
V5= (V6->c.c_car);
goto T7;
}else V6=V6->c.c_cdr;
V5= Cnil;}
goto T7;
T7:;
V4= CMPcadr(V5);
if(((V4))==Cnil){
goto T9;}
base[3]= (V4);
base[4]= Cnil;
base[5]= Cnil;
base[6]= Cnil;
vs_top=(vs_base=base+3)+4;
return;
goto T9;
T9:;
{object V7;
register object V8;
if(!(type_of((V1))==t_cons||((V1))==Cnil)){
goto T17;}
base[3]= (V1);
vs_top=(vs_base=base+3)+1;
(void) (*Lnk51)();
goto T15;
goto T17;
T17:;
base[3]= Cnil;
base[5]= (V1);
vs_top=(vs_base=base+5)+1;
(void) (*Lnk52)(Lclptr52);
vs_top=sup;
base[4]= vs_base[0];
vs_top=(vs_base=base+3)+2;
goto T15;
T15:;
if(vs_base>=vs_top){vs_top=sup;goto T23;}
V7= vs_base[0];
vs_base++;
if(vs_base>=vs_top){vs_top=sup;goto T24;}
V8= vs_base[0];
vs_top=sup;
goto T25;
goto T23;
T23:;
V7= Cnil;
goto T24;
T24:;
V8= Cnil;
goto T25;
T25:;
{register object V9;
if((V8)==Cnil){
V9= Cnil;
goto T26;}
V9= (*(LnkLI53))((V8));
goto T26;
T26:;
if(((V8))==Cnil){
goto T28;}
if(((V9))==Cnil){
goto T27;}
if(((V3))==Cnil){
goto T28;}
goto T27;
T27:;
{object V10;
object V11;
if(((V9))==Cnil){
goto T36;}
V10= (*(LnkLI54))((V9),(V3));
goto T34;
goto T36;
T36:;
V10= Cnil;
goto T34;
T34:;
if(((V9))==Cnil){
goto T40;}
if(((V10))==Cnil){
goto T40;}
V11= (*(LnkLI55))((V9),(V10));
goto T38;
goto T40;
T40:;
V11= Cnil;
goto T38;
T38:;
base[6]= (V7);
base[7]= Ct;
base[8]= (V8);
base[9]= (V11);
vs_top=(vs_base=base+6)+4;
return;}
goto T28;
T28:;
if((V7)!=Cnil){
base[4]= (V7);
goto T48;}
if(!(type_of((V1))==t_cons||((V1))==Cnil)){
goto T50;}
{object V13;
V13= (*(LnkLI56))((V8));
(CMPcdr(V1))->c.c_car = (V13);
(void)(CMPcdr(V1));
base[4]= (V13);
goto T48;}
goto T50;
T50:;
base[5]= (V1);
vs_top=(vs_base=base+5)+1;
(void) (*Lnk57)(Lclptr57);
vs_top=sup;
base[4]= vs_base[0];
goto T48;
T48:;
base[5]= Ct;
base[6]= Cnil;
base[7]= Cnil;
vs_top=(vs_base=base+4)+4;
return;}}}
}
}
bool eql(P a, P b) { return eql(a.Y, b.Y) && eql(a.X, b.X); }
