BddNodeHandle BddManager::makeAnd(BddNodeHandle pFst, BddNodeHandle pSnd) { if (pFst == BDD_TRUE) return pSnd; if (pSnd == BDD_TRUE) return pFst; if (pFst == BDD_FALSE || pSnd == BDD_FALSE) return BDD_FALSE; BddNodeHandle pBddNode; #ifdef USE_AND_MAP if ((pBddNode = findHandleInPairMap(_mapAnd, pFst, pSnd)).valid()) return pBddNode; #endif assert(!pFst->isTerminal()); assert(!pSnd->isTerminal()); int topVar = max(pFst->getCurDecisionLevel(), pSnd->getCurDecisionLevel()); BddNodeHandle fp = pFst->getPosCofactor(pFst, topVar); BddNodeHandle fn = pFst->getNegCofactor(pFst, topVar); BddNodeHandle gp = pSnd->getPosCofactor(pSnd, topVar); BddNodeHandle gn = pSnd->getNegCofactor(pSnd, topVar); BddNodeHandle pT = makeAnd(fp ,gp); BddNodeHandle pE = makeAnd(fn ,gn); if (pT->isStructureEqual(pE)) { #ifdef USE_AND_MAP insertHandlePairInPairMap(_mapAnd, pFst, pSnd, pT); #endif return pT; } BddNodeHandle pR = makeBddNode(topVar, pT, pE); #ifdef USE_AND_MAP insertHandlePairInPairMap(_mapAnd, pFst, pSnd, pR); #endif return pR; }
Expr operator&&(Expr a, Expr b) { //assert(a.type() == Int(1) && b.type() == Int(1) && "Arguments to && must be bool"); a = cast(Int(1), a); b = cast(Int(1), b); Expr e(makeAnd(a.node(), b.node()), Int(1)); e.child(a); e.child(b); return e; }
BddNodeHandle BddManager::ite(BddNodeHandle pIf, BddNodeHandle pThen, BddNodeHandle pElse) { // !g = ite(g, 0, 1) if (pThen->isStructureEqual(BddNode::getConstZeroHandle()) && pElse ->isStructureEqual(BddNode::getConstOneHandle())) return makeNeg(pIf); // ite(A, B, C) = ite(!A, C, B) #if 1 // ite(f, g, 0) if (pElse->isStructureEqual(BddNode::getConstZeroHandle())) return makeAnd(pIf, pThen); // return apply(OP_AND, pIf, pThen); // ite(f, 0, g) if (pThen->isStructureEqual(BddNode::getConstZeroHandle())) { return ite(makeNeg(pIf), BddNode::getConstZeroHandle(), pElse); } // ite(f, 1, g) if (pThen->isStructureEqual(BddNode::getConstOneHandle())) { return makeNeg(ite(makeNeg(pIf), makeNeg(pElse), BddNode::getConstZeroHandle())); } // ite(f, g, 1) // ite(!f, 1, g) if (pElse->isStructureEqual(BddNode::getConstOneHandle())) { return ite(makeNeg(pIf), BddNode::getConstOneHandle(), pThen); } // ite(f, g, h) = // fg + f'h // ite(fg, 1, f'h) #endif return ite( makeAnd(pIf, pThen) , BddNode::getConstOneHandle() , makeAnd(makeNeg(pIf), pElse)); }
BddNodeHandle BddManager::makeXor(BddNodeHandle pFst, BddNodeHandle pSnd) { return makeOr(makeAnd(pFst, makeNeg(pSnd)), makeAnd(makeNeg(pFst), pSnd)); }
BddNodeHandle BddManager::makeEq(BddNodeHandle pFst, BddNodeHandle pSnd) { return makeAnd(makeImply(pFst, pSnd), makeImply(pSnd, pFst)); }
/** Parse with one token worth of look-ahead, return the expression object representing the syntax parsed. @param tok next token from the input. @param fp file subsequent tokens are being read from. @return the expression object constructed from the input. */ Expr *parse( char *tok, FILE *fp ) { // Create a literal token for anything that looks like a number. { long dummy; int pos; // See if the whole token parses as a long int. if ( sscanf( tok, "%ld%n", &dummy, &pos ) == 1 && pos == strlen( tok ) ) { // Copy the literal to a dynamically allocated string, since makeLiteral wants // a string it can keep. char *str = (char *) malloc( strlen( tok ) + 1 ); return makeLiteral( strcpy( str, tok ) ); } } // Create a literal token for a quoted string, without the quotes. if ( tok[ 0 ] == '"' ) { // Same as above, make a dynamically allocated copy of the token that the literal // expression can keep as long as at wants to. int len = strlen( tok ); char *str = (char *) malloc( len - 1 ); strncpy( str, tok + 1, len - 2 ); str[ len - 2 ] = '\0'; return makeLiteral( str ); } // Handle compound statements if ( strcmp( tok, "{" ) == 0 ) { int len = 0; int cap = INITIAL_CAPACITY; Expr **eList = (Expr **) malloc( cap * sizeof( Expr * ) ); // Keep parsing subexpressions until we hit the closing curly bracket. while ( strcmp( expectToken( tok, fp ), "}" ) != 0 ) { if ( len >= cap ) eList = (Expr **) realloc( eList, ( cap *= 2 ) * sizeof( Expr * ) ); eList[ len++ ] = parse( tok, fp ); } return makeCompound( eList, len ); } // Handle language operators (reserved words) if ( strcmp( tok, "print" ) == 0 ) { // Parse the one argument to print, and create a print expression. Expr *arg = parse( expectToken( tok, fp ), fp ); return makePrint( arg ); } if ( strcmp( tok, "set" ) == 0 ) { // Parse the two operands, then make a set expression with them. char *str = expectToken( tok, fp ); int len = strlen( str ); char *name = (char *) malloc( len + 1 ); strcpy( name, str ); name[ len ] = '\0'; if ( !isalpha(name[0]) || strlen( name ) > MAX_VAR || strchr( name, LEFT_BRACKET ) || strchr( name, RIGHT_BRACKET ) || strchr( name, POUND ) ) { // Complain if we can't make sense of the variable. fprintf( stderr, "line %d: invalid variable name \"%s\"\n", linesRead(), name ); exit( EXIT_FAILURE ); } Expr *expr = parse( expectToken( tok, fp ), fp ); Expr *set = makeSet ( name, expr ); free(name); return set; } if ( strcmp( tok, "add" ) == 0 ) { // Parse the two operands, then make an add expression with them. Expr *op1 = parse( expectToken( tok, fp ), fp ); Expr *op2 = parse( expectToken( tok, fp ), fp ); return makeAdd( op1, op2 ); } if ( strcmp( tok, "sub" ) == 0 ) { // Parse the two operands, then make a sub expression with them. Expr *op1 = parse( expectToken( tok, fp ), fp ); Expr *op2 = parse( expectToken( tok, fp ), fp ); return makeSub( op1, op2 ); } if ( strcmp( tok, "mul" ) == 0 ) { // Parse the two operands, then make a mul expression with them. Expr *op1 = parse( expectToken( tok, fp ), fp ); Expr *op2 = parse( expectToken( tok, fp ), fp ); return makeMul( op1, op2 ); } if ( strcmp( tok, "div" ) == 0 ) { // Parse the two operands, then make a div expression with them. Expr *op1 = parse( expectToken( tok, fp ), fp ); Expr *op2 = parse( expectToken( tok, fp ), fp ); return makeDiv ( op1, op2 ); } if ( strcmp( tok, "equal" ) == 0 ) { // Parse the two operands, then make an equal expression with them. Expr *op1 = parse( expectToken( tok, fp ), fp ); Expr *op2 = parse( expectToken( tok, fp ), fp ); return makeEqual ( op1, op2 ); } if ( strcmp( tok, "less" ) == 0 ) { // Parse the two operands, then make a less expression with them. Expr *op1 = parse( expectToken( tok, fp ), fp ); Expr *op2 = parse( expectToken( tok, fp ), fp ); return makeLess ( op1, op2 ); } if ( strcmp( tok, "not" ) == 0 ) { // Parse the operand, then make a not expression with it. Expr *op = parse( expectToken( tok, fp ), fp ); return makeNot ( op ); } if ( strcmp( tok, "and" ) == 0 ) { // Parse the two operands, then make an and expression with them. Expr *op1 = parse( expectToken( tok, fp ), fp ); Expr *op2 = parse( expectToken( tok, fp ), fp ); return makeAnd ( op1, op2 ); } if ( strcmp( tok, "or" ) == 0 ) { // Parse the two operands, then make an or expression with them. Expr *op1 = parse( expectToken( tok, fp ), fp ); Expr *op2 = parse( expectToken( tok, fp ), fp ); return makeOr ( op1, op2 ); } if ( strcmp( tok, "if" ) == 0 ) { // Parse the two operands, then make an if expression with them. Expr *op1 = parse( expectToken( tok, fp ), fp ); Expr *op2 = parse( expectToken( tok, fp ), fp ); return makeIf ( op1, op2 ); } if ( strcmp( tok, "while" ) == 0 ) { // Parse the two operands, then make a while expression with them. Expr *op1 = parse( expectToken( tok, fp ), fp ); Expr *op2 = parse( expectToken( tok, fp ), fp ); return makeWhile ( op1, op2 ); } if ( strcmp( tok, "concat" ) == 0 ) { // Parse the two operands, then make a concatenation expression with them. Expr *op1 = parse( expectToken( tok, fp ), fp ); Expr *op2 = parse( expectToken( tok, fp ), fp ); return makeConcat ( op1, op2 ); } if ( strcmp( tok, "substr" ) == 0 ) { // Parse the three operands, then make a substring expression with them. Expr *op1 = parse( expectToken( tok, fp ), fp ); Expr *op2 = parse( expectToken( tok, fp ), fp ); Expr *op3 = parse( expectToken( tok, fp ), fp ); return makeSubstr ( op1, op2, op3 ); } // Handle variables if ( isalpha(tok[0]) && strlen( tok ) <= MAX_VAR && !strchr( tok, LEFT_BRACKET ) && !strchr( tok, RIGHT_BRACKET ) && !strchr( tok, POUND ) ) { // Parse the variable name and make a variable expression. char *str = tok; int len = strlen( str ); char *name = (char *) malloc( len + 1 ); strcpy( name, str ); name[ len ] = '\0'; Expr *var = makeVariable( name ); free(name); return var; } // Complain if we can't make sense of the token. fprintf( stderr, "line %d: invalid token \"%s\"\n", linesRead(), tok ); exit( EXIT_FAILURE ); // Never reached. return NULL; }