void ExprSMTLIBPrinter::printArrayDeclarations() { // Assume scan() has been called if (humanReadable) *o << "; Array declarations" << endl; // Declare arrays in a deterministic order. std::vector<const Array *> sortedArrays(usedArrays.begin(), usedArrays.end()); std::sort(sortedArrays.begin(), sortedArrays.end(), ArrayPtrsByName()); for (std::vector<const Array *>::iterator it = sortedArrays.begin(); it != sortedArrays.end(); it++) { *o << "(declare-fun " << (*it)->name << " () " "(Array (_ BitVec " << (*it)->getDomain() << ") " "(_ BitVec " << (*it)->getRange() << ") ) )" << endl; } // Set array values for constant values if (haveConstantArray) { if (humanReadable) *o << "; Constant Array Definitions" << endl; const Array *array; // loop over found arrays for (std::vector<const Array *>::iterator it = sortedArrays.begin(); it != sortedArrays.end(); it++) { array = *it; int byteIndex = 0; if (array->isConstantArray()) { /*loop over elements in the array and generate an assert statement for each one */ for (vector<ref<ConstantExpr> >::const_iterator ce = array->constantValues.begin(); ce != array->constantValues.end(); ce++, byteIndex++) { *p << "(assert ("; p->pushIndent(); *p << "= "; p->pushIndent(); printSeperator(); *p << "(select " << array->name << " (_ bv" << byteIndex << " " << array->getDomain() << ") )"; printSeperator(); printConstant((*ce)); p->popIndent(); printSeperator(); *p << ")"; p->popIndent(); printSeperator(); *p << ")"; p->breakLineI(); } } } } }
void CodeGenerator::printVector(std::ostream &s, const std::string& name, const vector<double>& v) { s << "d " << name << "[] = {"; for (int i=0; i<v.size(); ++i) { if (i!=0) s << ", "; printConstant(s, v[i]); } s << "};" << endl; }
void ExprSMTLIBPrinter::printExpression( const ref<Expr> &e, ExprSMTLIBPrinter::SMTLIB_SORT expectedSort) { // check if casting might be necessary if (getSort(e) != expectedSort) { printCastToSort(e, expectedSort); return; } switch (e->getKind()) { case Expr::Constant: printConstant(cast<ConstantExpr>(e)); return; // base case case Expr::NotOptimized: // skip to child printExpression(e->getKid(0), expectedSort); return; case Expr::Read: printReadExpr(cast<ReadExpr>(e)); return; case Expr::Extract: printExtractExpr(cast<ExtractExpr>(e)); return; case Expr::SExt: case Expr::ZExt: printCastExpr(cast<CastExpr>(e)); return; case Expr::Ne: printNotEqualExpr(cast<NeExpr>(e)); return; case Expr::Select: // the if-then-else expression. printSelectExpr(cast<SelectExpr>(e), expectedSort); return; case Expr::Eq: /* The "=" operator is special in that it can take any sort but we must * enforce that both arguments are the same type. We do this a lazy way * by enforcing the second argument is of the same type as the first. */ printSortArgsExpr(e, getSort(e->getKid(0))); return; case Expr::And: case Expr::Or: case Expr::Xor: case Expr::Not: /* These operators have a bitvector version and a bool version. * For these operators only (e.g. wouldn't apply to bvult) if the expected * sort the * expression is T then that implies the arguments are also of type T. */ printLogicalOrBitVectorExpr(e, expectedSort); return; default: /* The remaining operators (Add,Sub...,Ult,Ule,..) * Expect SORT_BITVECTOR arguments */ printSortArgsExpr(e, SORT_BITVECTOR); return; } }
void ASTPrint( int lev, ASTNode node ) { if (! node) { indent( lev ); ec_stderr_printf( "NULL" ); return; } /* Simplify our lives ... */ if (currentScope) { if (currentScope->type == PackageScope) { currentPackage = currentScope->target; currentBytecode = EC_PACKAGECODE(currentScope->target); } else { currentBytecode = currentScope->target; } currentLiteral = EC_COMPILEDLFRAME(currentBytecode); } switch ( node->type ) { case nullType: indent( lev ); ec_stderr_printf( "<nullType>" ); break; case symbolType: printSymbol( lev, node ); break; case qualifiedSymbolType: printQualifiedSymbol( lev, node ); break; case constExprType: printConstant( lev, node ); break; case variableExprType: printVariable( lev, node ); break; case arrayConstructionExprType: printArrayCons( lev, node ); break; case hashConstructionExprType: printHashCons( lev, node ); break; case unaryExprType: printUnary( lev, node ); break; case binaryExprType: printBinary( lev, node ); break; case conditionalExprType: printConditional( lev, node ); break; case orExprType: printOr( lev, node ); break; case andExprType: printAnd( lev, node ); break; case assignExprType: printAssign( lev, node ); break; case simAssignExprType: printSimAssign( lev, node ); break; case arrayRefExprType: printArrayRef( lev, node ); break; case declNodeType: printDecl( lev, node ); break; case declAtomNodeType: printDeclAtom( lev, node ); break; case statementType: printStatement( lev, node ); break; case labeledStmtType: printLabeledStmt( lev, node ); break; case exprStmtType: printExprStmt( lev, node ); break; case ifStmtType: printIf( lev, node ); break; case whileStmtType: printWhile( lev, node ); break; case doStmtType: printDo( lev, node ); break; case forStmtType: printFor( lev, node ); break; case forInStmtType: printForIn( lev, node ); break; case breakStmtType: printBreak( lev, node ); break; case continueStmtType: printContinue( lev, node ); break; case gotoStmtType: printGoto( lev, node ); break; case tryStmtType: printTry( lev, node ); break; case catchStmtType: printCatch( lev, node ); break; case throwStmtType: printThrow( lev, node ); break; case importStmtType: printImport( lev, node ); break; case paramNodeType: printParam( lev, node ); break; case paramListType: printParamList( lev, node ); break; case callNodeType: printCall( lev, node ); break; case methodCallNodeType: printMethodCall( lev, node ); break; case stmtListType: printStmtList( lev, node ); break; case funcNodeType: printFunction( lev, node ); break; case returnNodeType: printReturn( lev, node ); break; case classNodeType: printClass( lev, node ); break; case methodNodeType: printMethod( lev, node ); break; case packageNodeType: printPackage( lev, node ); break; } }