int isequal(Node *a, Node *b) { if (!a && !b) return 1; if (!a || !b) { if (!a) { if (b->ntyp == TRUE) return 1; } else { if (a->ntyp == TRUE) return 1; } return 0; } if (a->ntyp != b->ntyp) return 0; if (a->sym && b->sym && strcmp(a->sym->name, b->sym->name) != 0) return 0; if (isequal(a->lft, b->lft) && isequal(a->rgt, b->rgt)) return 1; return sameform(a, b); }
static int all_bucky(State *a, State *b) { Transition *s, *t; int found, result = 0; for (s = a->trans; s; s = s->nxt) { if (s->redundant) continue; found = 0; for (t = b->trans; t; t = t->nxt) { if (t->redundant) continue; if (isequal(s->cond, t->cond)) { if (strcmp(s->name->name, b->name->name) == 0 && strcmp(t->name->name, a->name->name) == 0) { found = 1; /* they point to each other */ t->marked = 1; break; } if (strcmp(s->name->name, t->name->name) == 0 && strcmp(s->name->name, "accept_all") == 0) { found = 1; t->marked = 1; break; /* same exit from which there is no return */ } } } if (!found) goto done; } for (s = b->trans; s; s = s->nxt) { if (s->redundant || s->marked) continue; found = 0; for (t = a->trans; t; t = t->nxt) { if (t->redundant) continue; if (isequal(s->cond, t->cond)) { if (strcmp(s->name->name, a->name->name) == 0 && strcmp(t->name->name, b->name->name) == 0) { found = 1; t->marked = 1; break; } if (strcmp(s->name->name, t->name->name) == 0 && strcmp(s->name->name, "accept_all") == 0) { found = 1; t->marked = 1; break; } } } if (!found) goto done; } result = 1; done: for (s = b->trans; s; s = s->nxt) s->marked = 0; return result; }
var_type max(var_type p1,var_type p2){ if(!isnumeric(p1) || !isnumeric(p2)) return NULL; else if(isequal(p1,TYPE_FLOAT) || isequal(p2,TYPE_FLOAT)) return TYPE_FLOAT; else if(isequal(p1,TYPE_INT) || isequal(p2,TYPE_INT)) return TYPE_INT; else return TYPE_CHAR; }
static int sametrans(Transition *s, Transition *t) { if (strcmp(s->name->name, t->name->name) != 0) return 0; return isequal(s->cond, t->cond); }
/* * There are two problems here, both resulting from rd and rs conflicts: * 1. rr is used to store the initial value of rs * 2. rd == rs, then conflict. */ static void mgeni (v_reg_type rd, v_reg_type rs, v_reg_type t, int x) { char *p = mlookup[x]; v_reg_type rr, t2 = 0, lastr; int equal; demand(x, bogus value); if (x >= LSIZE) { v_mulii(rd, rs, x); return; } p++; lastr = rd; if((equal = isequal(rd,rs))) { if(v_getreg(&rd, V_I, V_TEMP) < 0) v_fatal("mgen: out of registers\n"); t2 = rd; } rr = rs; while(1) { switch(*p++) { case NEGATE: if(*p == DONE) rd = lastr; v_negi(rd, rr); break; case SHIFT_ADD: v_lshii(t, rr, *p++); if(*p == DONE) rd = lastr; v_addi(rd, t, rs); break; case SHIFT_SUB: v_lshii(t, rr, *p++); if(*p == DONE) rd = lastr; v_subi(rd, t, rs); break; case SHIFT_REV: v_lshii(t, rr, *p++); if(*p == DONE) rd = lastr; v_subi(rd, rs, t); break; case FACTOR_ADD: v_lshii(t, rr, *p++); if(*p == DONE) v_addi(lastr, t, rd); else v_addi(rd, t, rd); break; case FACTOR_SUB: v_lshii(t, rr, *p++); if(*p == DONE) v_subi(lastr, t, rd); else v_subi(rd, t, rd); break; case FACTOR_REV: v_lshii(t, rr, *p++); if(*p == DONE) v_subi(lastr, rd, t); else v_subi(rd, rd, t); break; case SHIFT: if(p[1] == DONE) rd = lastr; v_lshii(rd, rr, *p++); break; case DONE: goto quit; default: demand(0, bogus op); } rr = rd; } quit: if(equal) v_putreg(t2, V_I ); }
void* gencthreadfunc(void* thearg){ gencstruct* arg=(gencstruct*)thearg; gencreturnstruct* ret=&arg->ret; aprioriset tset; aprioriset* pset=&tset; int i, j=0, k, flag, ccount=0; ret->num=0; for(i=arg->num;i<arg->l->num;i++){ flag=0; if(numofmatch(&arg->l->valuelist[i], arg->s)==arg->length-1){ mergeset(pset, &arg->l->valuelist[i], arg->s); pset->length=arg->length+1; for(k=0;k<j;k++){ if(isequal(pset, &ret->valuelist[k])){ flag=1; break; } } if(flag){ deleteaprioriset(&pset); } else{ ret->valuelist[j]=*pset; ret->proper[j]=isproper(&ret->valuelist[j], arg->l); ret->num++; j++; } } } }
int already_done(Node *p) /* finds the id of the node, if already explored */ { int i; for(i = 1; i<node_id; i++) if (isequal(p, label[i])) return i; return -1; }
/** * @brief isequal * @param Tree one and tree two to compare * @return 0 if they are not structurally identical */ int isequal(const node* t1, const node *t2){ /* Both Empty -> True */ if ( t1 == NULL && t2 == NULL) { return 1 ; } else if( t1!= NULL && t2 != NULL){ if( strcmp(t1->name,t2->name)==0 && strcmp(t1->name,"value")){ return (t1->value == t2->value); } else { return ( strcmp(t1->name,t2->name)==0 && isequal(t1->left,t2->left) && isequal(t1->right,t2->right)); } } /* One tree is empty, other is not */ else return 0; }
banlrec *Banlist_ban(char *ban) { banlrec *b; for(b=Banlist->banlist; b!=NULL; b=b->next) if(isequal(b->ban,ban)) return b; return NULL; }
bool contains(HASHTABLE<KEY,VALUE> *ht, KEY k){ //tmp point to the root HASHTABLE<KEY,VALUE> *tmp; for (tmp = ht[hashfunc(ht,k)].next; tmp != NULL; tmp=tmp->next) { if(isequal(k,tmp->key)) return true; } return false; }
/* copies upvalues between lua states' stacks */ static int luaproc_copyupvalues( lua_State *Lfrom, lua_State *Lto, int funcindex ) { int i = 1; const char *str; size_t len; /* test the type of each upvalue and, if it's supported, copy it */ while ( lua_getupvalue( Lfrom, funcindex, i ) != NULL ) { switch ( lua_type( Lfrom, -1 )) { case LUA_TBOOLEAN: lua_pushboolean( Lto, lua_toboolean( Lfrom, -1 )); break; case LUA_TNUMBER: copynumber( Lto, Lfrom, -1 ); break; case LUA_TSTRING: { str = lua_tolstring( Lfrom, -1, &len ); lua_pushlstring( Lto, str, len ); break; } case LUA_TNIL: lua_pushnil( Lto ); break; /* if upvalue is a table, check whether it is the global environment (_ENV) from the source state Lfrom. in case so, push in the stack of the destination state Lto its own global environment to be set as the corresponding upvalue; otherwise, treat it as a regular non-supported upvalue type. */ case LUA_TTABLE: lua_pushglobaltable( Lfrom ); if ( isequal( Lfrom, -1, -2 )) { lua_pop( Lfrom, 1 ); lua_pushglobaltable( Lto ); break; } lua_pop( Lfrom, 1 ); /* FALLTHROUGH */ default: /* value type not supported: table, function, userdata, etc. */ lua_pushnil( Lfrom ); lua_pushfstring( Lfrom, "failed to copy upvalue of unsupported type " "'%s'", luaL_typename( Lfrom, -2 )); return FALSE; } lua_pop( Lfrom, 1 ); if ( lua_setupvalue( Lto, 1, i ) == NULL ) { lua_pushnil( Lfrom ); lua_pushstring( Lfrom, "failed to set upvalue" ); return FALSE; } i++; } return TRUE; }
NT2_TEST_CASE_TPL( cov_scalar, NT2_REAL_TYPES ) { T x = nt2::cov(T(42)); NT2_TEST_EQUAL( x, T(0) ); x = nt2::cov(T(42),1); NT2_TEST_EQUAL( x, T(0) ); nt2::table<T> y = nt2::cov(T(42),T(1)); NT2_TEST( isequal(y, nt2::zeros(2, 2, nt2::meta::as_<T>()))); }
int any_term(Node *srch, Node *in) { if (!in) return 0; if (in->ntyp == AND) return any_term(srch, in->lft) || any_term(srch, in->rgt); return isequal(in, srch); }
int any_lor(Node *srch, Node *in) { if (!in) return 0; if (in->ntyp == OR) return any_lor(srch, in->lft) || any_lor(srch, in->rgt); return isequal(in, srch); }
Node * in_cache(Node *n) { Cache *d; int nr=0; for (d = stored; d; d = d->nxt, nr++) if (isequal(d->before, n)) { CacheHits++; if (d->same && ismatch(n, d->before)) return n; return dupnode(d->after); } return ZN; }
void add(aprioristruct* data, aprioriset* value, int equal){ int i; if(equal){ for(i=0;i<data->num;i++){ if(isequal(value, &data->valuelist[i])){ deleteaprioriset(&value); return; } } } data->valuelist[data->num]=*value; data->num++; }
int isequal(genpt a,genpt b){ genpt temp_a=a,temp_b=b; while(temp_a!=NULL && temp_b!=NULL){ if(isequalnode(temp_a,temp_b)) return -1; if(temp_a->tag==sublist){ genpt la=temp_a->u.list; genpt lb=temp_b->u.list; if(isequal(la,lb)) return -1; } temp_a=temp_a->link; temp_b=temp_b->link; } return 0; }
VALUE get(HASHTABLE<KEY,VALUE> *ht, KEY k){ HASHTABLE<KEY,VALUE> *tmp = ht[hashfunc(ht,k)].next; if (contains(ht,k)) { while(tmp!=NULL){ if (isequal(tmp->key,k)) return tmp->value; tmp = tmp->next; } }else{ cout <<"Cannot be found!\n"; VALUE z_v; return z_v; } }
static int implies(Node *a, Node *b, int *cnt, char *uform, int *tl_yychar, Miscellaneous *miscell) { return (isequal(a,b, cnt, uform, tl_yychar, miscell) || b->ntyp == TRUE || a->ntyp == FALSE || (b->ntyp == AND && implies(a, b->lft, cnt, uform, tl_yychar, miscell) && implies(a, b->rgt, cnt, uform, tl_yychar, miscell)) || (a->ntyp == OR && implies(a->lft, b, cnt, uform, tl_yychar, miscell) && implies(a->rgt, b, cnt, uform, tl_yychar, miscell)) || (a->ntyp == AND && (implies(a->lft, b, cnt, uform, tl_yychar, miscell) || implies(a->rgt, b, cnt, uform, tl_yychar, miscell))) || (b->ntyp == OR && (implies(a, b->lft, cnt, uform, tl_yychar, miscell) || implies(a, b->rgt, cnt, uform, tl_yychar, miscell))) || (b->ntyp == U_OPER && implies(a, b->rgt, cnt, uform, tl_yychar, miscell)) || (a->ntyp == V_OPER && implies(a->rgt, b, cnt, uform, tl_yychar, miscell)) || (a->ntyp == U_OPER && implies(a->lft, b, cnt, uform, tl_yychar, miscell) && implies(a->rgt, b, cnt, uform, tl_yychar, miscell)) || (b->ntyp == V_OPER && implies(a, b->lft, cnt, uform, tl_yychar, miscell) && implies(a, b->rgt, cnt, uform, tl_yychar, miscell)) || ((a->ntyp == U_OPER || a->ntyp == V_OPER) && a->ntyp == b->ntyp && implies(a->lft, b->lft, cnt, uform, tl_yychar, miscell) && implies(a->rgt, b->rgt, cnt, uform, tl_yychar, miscell))); }
static cmdrec_t *cmdrec_cmd(cmdrec_t **list, cmdrec_t **last, char *name) { cmdrec_t *c, *lastchecked = NULL; for(c=*list; c!=NULL; c=c->next) { if(isequal(c->name,name)) { /* found it. do a movetofront. */ cmdrec_movetofront(list,last,lastchecked,c); return c; } lastchecked = c; } return NULL; }
static int implies(Node *a, Node *b) { return (isequal(a,b) || b->ntyp == TRUE || a->ntyp == FALSE || (b->ntyp == AND && implies(a, b->lft) && implies(a, b->rgt)) || (a->ntyp == OR && implies(a->lft, b) && implies(a->rgt, b)) || (a->ntyp == AND && (implies(a->lft, b) || implies(a->rgt, b))) || (b->ntyp == OR && (implies(a, b->lft) || implies(a, b->rgt))) || (b->ntyp == U_OPER && implies(a, b->rgt)) || (a->ntyp == V_OPER && implies(a->rgt, b)) || (a->ntyp == U_OPER && implies(a->lft, b) && implies(a->rgt, b)) || (b->ntyp == V_OPER && implies(a, b->lft) && implies(a, b->rgt)) || ((a->ntyp == U_OPER || a->ntyp == V_OPER) && a->ntyp == b->ntyp && implies(a->lft, b->lft) && implies(a->rgt, b->rgt))); }
void v_cmuli (v_reg_type rd, v_reg_type rs, int x) { v_reg_type t1; if(!x) { v_seti(rd, 0); return; } else if(x == 1) { if(isequal(rd, rs)) return; v_movi(rd, rs); return; } v_getreg(&t1, V_I, V_TEMP); if(x >= 0) { mgeni(rd, rs, t1, x); } else { mgeni(rd, rs, t1, -x); v_negi(rd, rd); } v_putreg(t1, V_I); }
void v_cmulu (v_reg_type rd, v_reg_type rs, unsigned x) { v_reg_type t1; if(!x) { v_setu(rd, 0); return; } else if(x == 1) { if(isequal(rd, rs)) return; v_movu(rd, rs); return; } v_getreg(&t1, V_U, V_TEMP); if(x >= 0) { mgenu(rd, rs, t1, x); } else { mgenu(rd, rs, t1, -x); v_negu(rd, rd); } v_putreg(t1, V_U); }
banlrec *Banlist_match(char *ban, chanrec *chan) { banlrec *bl; for(bl=Banlist->banlist; bl!=NULL; bl=bl->next) { if(bl->chan == NULL) { if(wild_match(bl->ban,ban) || wild_match(ban,bl->ban)) return bl; } else if(isequal(bl->chan->name,chan->name)) { if(wild_match(bl->ban,ban) || wild_match(ban,bl->ban)) return bl; } } return NULL; }
NT2_TEST_CASE_TPL( tsxfun_1, NT2_TYPES) { nt2::table<T> a = nt2::rif(nt2::of_size(3, 1), nt2::meta::as_<T>()), b = nt2::cif(nt2::of_size(1, 3), nt2::meta::as_<T>()), c = nt2::ones(3, 3, nt2::meta::as_<T>()), d, e; NT2_DISPLAY(a); NT2_DISPLAY(b); NT2_DISPLAY(c); d = nt2::bsxfun(nt2::functor<nt2::tag::plus_>(), nt2::bsxfun(nt2::functor<nt2::tag::multiplies_>(), a, b), c); NT2_DISPLAY(d); e = tsxfun(nt2::functor<nt2::tag::fma_>(), a, b, c); NT2_DISPLAY(e); NT2_TEST(isequal(e, d)); // for(unsigned int i=1; i <= length(a); i++) // { // for(unsigned int j=1; j <= length(a); j++) // { // NT2_TEST_EQUAL(e(i, j), d(i, j)); // } // } }
int isproper(aprioriset* set, aprioristruct* str){ aprioriset* tset; int strcount; int setcount=set->length-1; initaprioriset(&tset, setcount); int i; for(i=0;i<set->length-1;i++){ if(i==setcount) continue; else if(i<setcount){ tset->value[i]=set->value[i]; } else{ tset->value[i-1]=set->value[i]; } } for(strcount=0;strcount<str->num;strcount++){ if(isequal(tset, &str->valuelist[strcount])){ if(setcount==0) return 1; else{ setcount--; for(i=0;i<set->length;i++){ if(i==setcount) continue; else if(i<setcount){ tset->value[i]=set->value[i]; } else{ tset->value[i-1]=set->value[i]; } } } } } return 0; }
static int implies(Node *a, Node *b) { return (isequal(a,b) || b->ntyp == TRUE || a->ntyp == FALSE || (b->ntyp == AND && implies(a, b->lft) && implies(a, b->rgt)) || (a->ntyp == OR && implies(a->lft, b) && implies(a->rgt, b)) || (a->ntyp == AND && (implies(a->lft, b) || implies(a->rgt, b))) || (b->ntyp == OR && (implies(a, b->lft) || implies(a, b->rgt))) || (b->ntyp == U_OPER && implies(a, b->rgt)) || (a->ntyp == V_OPER && implies(a->rgt, b)) || (a->ntyp == U_OPER && implies(a->lft, b) && implies(a->rgt, b)) || (b->ntyp == V_OPER && implies(a, b->lft) && implies(a, b->rgt)) || ((a->ntyp == U_OPER || a->ntyp == V_OPER) && a->ntyp == b->ntyp && implies(a->lft, b->lft) && implies(a->rgt, b->rgt)) #ifdef NXT || (b->ntyp == NEXT && is_G(a) && implies(a, b->lft)) || (a->ntyp == NEXT && is_F(b) && implies(a->lft, b)) || (a->ntyp == NEXT && b->ntyp == NEXT && implies(a->lft, b->lft))); #else );
// main void main(){ int i; FILE *fp; // Obtain output of ASM and inline using test vectors for verification for (i = 0; i < NUM_INPUTS ; i++) { a0[i] = exp2(a[i]); } for (i = 0; i < NUM_INPUTS ; i++) { a1[i] = exp2dp(a[i]); } for (i = 0; i < NUM_INPUTS; i++) { a2[i] = exp2dp_c(a[i]); } for (i = 0; i < NUM_INPUTS ; i++) { a3[i] = exp2dp_i(a[i]); } exp2dp_v(a, a4, NUM_INPUTS); // Random Data // Load in a new random number seed from seedfile, or if seedfile // does not exist, pick an initial fixed seed. Then seed rand(). // intialize seed if the file does not exist seed = 0x2A3A4A5A; // if the seed file exist read and seed the value to seed if ((fp = fopen(seed_fname,"r")) != NULL) /* open seed file */ { fscanf(fp,"%d",&seed); /* get current seed */ fclose(fp); } srand(seed); // Generate random test vectors. arg = array0; for (i = 0 ; i < BUF_SIZE; i++) { arg[i] = gimme_random(); } // Compute the overhead of calling clock twice to get timing info t_start = clock(); t_stop = clock(); t_offset = t_stop - t_start; output0 = array1; output1 = array2; output2 = array3; output3 = array4; output4 = array5; // Time the RTS function t_start = clock(); for (i = 0; i < BUF_SIZE; i++) { output0[i] = exp2(arg[i]); } t_stop = clock(); clockdata[0] = t_stop - t_start - t_offset; clockdata[0] = clockdata[0] / BUF_SIZE; // Time the fastRTS ASM function t_start = clock(); for (i = 0; i < BUF_SIZE; i++) { output1[i] = exp2dp(arg[i]); } t_stop = clock(); clockdata[1] = t_stop - t_start - t_offset; clockdata[1] = clockdata[1] / BUF_SIZE; // Time the fastRTS C intrinsic function t_start = clock(); for (i = 0; i < BUF_SIZE; i++) { output2[i] = exp2dp_c(arg[i]); } t_stop = clock(); clockdata[2] = t_stop - t_start - t_offset; clockdata[2] = clockdata[2] / BUF_SIZE; // Time the fastRTS inlined function t_start = clock(); for (i = 0; i < BUF_SIZE; i++) { output3[i] = exp2dp_i(arg[i]); } t_stop = clock(); clockdata[3] = t_stop - t_start - t_offset; clockdata[3] = clockdata[3] / BUF_SIZE; // Time the fastRTS vector function t_start = clock(); exp2dp_v(arg, output4, BUF_SIZE); t_stop = clock(); clockdata[4] = t_stop - t_start - t_offset; clockdata[4] = clockdata[4] / BUF_SIZE; // Display Test Vector Verificaition Results printf ("Verification Results:\n"); printf ("-------------------------------------------------------------------------------------------------------\n"); printf ("Predefined Test Vector: "); pass_flag1 = (isequal(a0, a1, NUM_INPUTS, RET_VAL_TOL)) && (isequal(a0, a2, NUM_INPUTS, RET_VAL_TOL)) && (isequal(a0, a3, NUM_INPUTS, RET_VAL_TOL)) && (isequal(a0, a4, NUM_INPUTS, RET_VAL_TOL)); if (pass_flag1){ printf ("Passed\n"); } else{ printf ("Failed\n"); } // Display Random Test Vector Results printf ("Random Test Vector (seed = %d): ", seed); pass_flag2 = (isequal(output0, output1, BUF_SIZE, RET_VAL_TOL)) && (isequal(output0, output2, BUF_SIZE, RET_VAL_TOL)) && (isequal(output0, output3, BUF_SIZE, RET_VAL_TOL)) && (isequal(output0, output4, BUF_SIZE, RET_VAL_TOL)); if (pass_flag2) { printf ("Passed\n"); } else{ printf ("Failed\n"); } if (pass_flag2) { seed = rand(); /* get next seed */ if (!(fp = fopen(seed_fname,"w"))) /* open seed file */ { printf("failure writing seed file \"%s\"\n", seed_fname); exit(1); } fprintf(fp,"%d\n",seed); /* set next seed */ fclose(fp); } printf ("-------------------------------------------------------------------------------------------------------\n"); // Display average clock for RTS, ASM, Inlined and Vector methods printf ("\n"); printf ("Number of Clocks for exp2:\n"); printf ("-------------------------------------------------------------------------------------------------------\n"); printf ("RTS\t\tASM\t\tC\t\tInlined\t\tVector \n"); printf ("-------------------------------------------------------------------------------------------------------\n"); printf ("%d\t\t%d\t\t%d\t\t%d\t\t%d\n", (int)clockdata[0], (int)clockdata[1], (int)clockdata[2], (int)clockdata[3], (int)clockdata[4]); }
static Node * bin_simpler(Node *ptr) { Node *a, *b; if (ptr) switch (ptr->ntyp) { case U_OPER: #ifndef NO_OPT if (ptr->rgt->ntyp == TRUE || ptr->rgt->ntyp == FALSE || ptr->lft->ntyp == FALSE) { ptr = ptr->rgt; break; } if (isequal(ptr->lft, ptr->rgt)) { /* p U p = p */ ptr = ptr->rgt; break; } if (ptr->lft->ntyp == U_OPER && isequal(ptr->lft->lft, ptr->rgt)) { /* (p U q) U p = (q U p) */ ptr->lft = ptr->lft->rgt; break; } if (ptr->rgt->ntyp == U_OPER && ptr->rgt->lft->ntyp == TRUE) { /* p U (T U q) = (T U q) */ ptr = ptr->rgt; break; } #ifdef NXT /* X p U X q == X (p U q) */ if (ptr->rgt->ntyp == NEXT && ptr->lft->ntyp == NEXT) { ptr = tl_nn(NEXT, tl_nn(U_OPER, ptr->lft->lft, ptr->rgt->lft), ZN); } #endif #endif break; case V_OPER: #ifndef NO_OPT if (ptr->rgt->ntyp == FALSE || ptr->rgt->ntyp == TRUE || ptr->lft->ntyp == TRUE) { ptr = ptr->rgt; break; } if (isequal(ptr->lft, ptr->rgt)) { /* p V p = p */ ptr = ptr->rgt; break; } /* F V (p V q) == F V q */ if (ptr->lft->ntyp == FALSE && ptr->rgt->ntyp == V_OPER) { ptr->rgt = ptr->rgt->rgt; break; } /* p V (F V q) == F V q */ if (ptr->rgt->ntyp == V_OPER && ptr->rgt->lft->ntyp == FALSE) { ptr->lft = False; ptr->rgt = ptr->rgt->rgt; break; } #endif break; case IMPLIES: #ifndef NO_OPT if (isequal(ptr->lft, ptr->rgt)) { ptr = True; break; } #endif ptr = tl_nn(OR, Not(ptr->lft), ptr->rgt); ptr = rewrite(ptr); break; case EQUIV: #ifndef NO_OPT if (isequal(ptr->lft, ptr->rgt)) { ptr = True; break; } #endif a = rewrite(tl_nn(AND, dupnode(ptr->lft), dupnode(ptr->rgt))); b = rewrite(tl_nn(AND, Not(ptr->lft), Not(ptr->rgt))); ptr = tl_nn(OR, a, b); ptr = rewrite(ptr); break; case AND: #ifndef NO_OPT /* p && (q U p) = p */ if (ptr->rgt->ntyp == U_OPER && isequal(ptr->rgt->rgt, ptr->lft)) { ptr = ptr->lft; break; } if (ptr->lft->ntyp == U_OPER && isequal(ptr->lft->rgt, ptr->rgt)) { ptr = ptr->rgt; break; } /* p && (q V p) == q V p */ if (ptr->rgt->ntyp == V_OPER && isequal(ptr->rgt->rgt, ptr->lft)) { ptr = ptr->rgt; break; } if (ptr->lft->ntyp == V_OPER && isequal(ptr->lft->rgt, ptr->rgt)) { ptr = ptr->lft; break; } /* (p U q) && (r U q) = (p && r) U q*/ if (ptr->rgt->ntyp == U_OPER && ptr->lft->ntyp == U_OPER && isequal(ptr->rgt->rgt, ptr->lft->rgt)) { ptr = tl_nn(U_OPER, tl_nn(AND, ptr->lft->lft, ptr->rgt->lft), ptr->lft->rgt); break; } /* (p V q) && (p V r) = p V (q && r) */ if (ptr->rgt->ntyp == V_OPER && ptr->lft->ntyp == V_OPER && isequal(ptr->rgt->lft, ptr->lft->lft)) { ptr = tl_nn(V_OPER, ptr->rgt->lft, tl_nn(AND, ptr->lft->rgt, ptr->rgt->rgt)); break; } #ifdef NXT /* X p && X q == X (p && q) */ if (ptr->rgt->ntyp == NEXT && ptr->lft->ntyp == NEXT) { ptr = tl_nn(NEXT, tl_nn(AND, ptr->rgt->lft, ptr->lft->lft), ZN); break; } #endif if (isequal(ptr->lft, ptr->rgt) /* (p && p) == p */ || ptr->rgt->ntyp == FALSE /* (p && F) == F */ || ptr->lft->ntyp == TRUE) /* (T && p) == p */ { ptr = ptr->rgt; break; } if (ptr->rgt->ntyp == TRUE /* (p && T) == p */ || ptr->lft->ntyp == FALSE) /* (F && p) == F */ { ptr = ptr->lft; break; } /* (p V q) && (r U q) == p V q */ if (ptr->rgt->ntyp == U_OPER && ptr->lft->ntyp == V_OPER && isequal(ptr->lft->rgt, ptr->rgt->rgt)) { ptr = ptr->lft; break; } #endif break; case OR: #ifndef NO_OPT /* p || (q U p) == q U p */ if (ptr->rgt->ntyp == U_OPER && isequal(ptr->rgt->rgt, ptr->lft)) { ptr = ptr->rgt; break; } /* p || (q V p) == p */ if (ptr->rgt->ntyp == V_OPER && isequal(ptr->rgt->rgt, ptr->lft)) { ptr = ptr->lft; break; } /* (p U q) || (p U r) = p U (q || r) */ if (ptr->rgt->ntyp == U_OPER && ptr->lft->ntyp == U_OPER && isequal(ptr->rgt->lft, ptr->lft->lft)) { ptr = tl_nn(U_OPER, ptr->rgt->lft, tl_nn(OR, ptr->lft->rgt, ptr->rgt->rgt)); break; } if (isequal(ptr->lft, ptr->rgt) /* (p || p) == p */ || ptr->rgt->ntyp == FALSE /* (p || F) == p */ || ptr->lft->ntyp == TRUE) /* (T || p) == T */ { ptr = ptr->lft; break; } if (ptr->rgt->ntyp == TRUE /* (p || T) == T */ || ptr->lft->ntyp == FALSE) /* (F || p) == p */ { ptr = ptr->rgt; break; } /* (p V q) || (r V q) = (p || r) V q */ if (ptr->rgt->ntyp == V_OPER && ptr->lft->ntyp == V_OPER && isequal(ptr->lft->rgt, ptr->rgt->rgt)) { ptr = tl_nn(V_OPER, tl_nn(OR, ptr->lft->lft, ptr->rgt->lft), ptr->rgt->rgt); break; } /* (p V q) || (r U q) == r U q */ if (ptr->rgt->ntyp == U_OPER && ptr->lft->ntyp == V_OPER && isequal(ptr->lft->rgt, ptr->rgt->rgt)) { ptr = ptr->rgt; break; } #endif break; } return ptr; }
Node * Canonical(Node *n) { Node *m, *p, *k1, *k2, *prev, *dflt = ZN; int tok; if (!n) return n; tok = n->ntyp; if (tok != AND && tok != OR) return n; can = ZN; addcan(tok, n); #if 0 Debug("\nA0: "); Dump(can); Debug("\nA1: "); Dump(n); Debug("\n"); #endif releasenode(1, n); /* mark redundant nodes */ if (tok == AND) { for (m = can; m; m = (m->ntyp == AND) ? m->rgt : ZN) { k1 = (m->ntyp == AND) ? m->lft : m; if (k1->ntyp == TRUE) { marknode(AND, m); dflt = True; continue; } if (k1->ntyp == FALSE) { releasenode(1, can); can = False; goto out; } } for (m = can; m; m = (m->ntyp == AND) ? m->rgt : ZN) for (p = can; p; p = (p->ntyp == AND) ? p->rgt : ZN) { if (p == m || p->ntyp == -1 || m->ntyp == -1) continue; k1 = (m->ntyp == AND) ? m->lft : m; k2 = (p->ntyp == AND) ? p->lft : p; if (isequal(k1, k2)) { marknode(AND, p); continue; } if (anywhere(OR, k1, k2)) { marknode(AND, p); continue; } } } if (tok == OR) { for (m = can; m; m = (m->ntyp == OR) ? m->rgt : ZN) { k1 = (m->ntyp == OR) ? m->lft : m; if (k1->ntyp == FALSE) { marknode(OR, m); dflt = False; continue; } if (k1->ntyp == TRUE) { releasenode(1, can); can = True; goto out; } } for (m = can; m; m = (m->ntyp == OR) ? m->rgt : ZN) for (p = can; p; p = (p->ntyp == OR) ? p->rgt : ZN) { if (p == m || p->ntyp == -1 || m->ntyp == -1) continue; k1 = (m->ntyp == OR) ? m->lft : m; k2 = (p->ntyp == OR) ? p->lft : p; if (isequal(k1, k2)) { marknode(OR, p); continue; } if (anywhere(AND, k1, k2)) { marknode(OR, p); continue; } } } for (m = can, prev = ZN; m; ) /* remove marked nodes */ { if (m->ntyp == -1) { k2 = m->rgt; releasenode(0, m); if (!prev) { m = can = can->rgt; } else { m = prev->rgt = k2; /* if deleted the last node in a chain */ if (!prev->rgt && prev->lft && (prev->ntyp == AND || prev->ntyp == OR)) { k1 = prev->lft; prev->ntyp = prev->lft->ntyp; prev->sym = prev->lft->sym; prev->rgt = prev->lft->rgt; prev->lft = prev->lft->lft; releasenode(0, k1); } } continue; } prev = m; m = m->rgt; } out: #if 0 Debug("A2: "); Dump(can); Debug("\n"); #endif if (!can) { if (!dflt) fatal("cannot happen, Canonical", (char *) 0); return dflt; } return can; }