void ExprSMTLIBPrinter::printUpdatesAndArray(const UpdateNode *un, const Array *root) { if (un != NULL) { *p << "(store "; p->pushIndent(); printSeperator(); // recurse to get the array or update that this store operations applies to printUpdatesAndArray(un->next, root); printSeperator(); // print index printExpression(un->index, SORT_BITVECTOR); printSeperator(); // print value that is assigned to this index of the array printExpression(un->value, SORT_BITVECTOR); p->popIndent(); printSeperator(); *p << ")"; } else { // The base case of the recursion *p << root->name; } }
void ExprSMTLIBPrinter::printSelectExpr(const ref<SelectExpr> &e, ExprSMTLIBPrinter::SMTLIB_SORT s) { // This is the if-then-else expression *p << "(" << getSMTLIBKeyword(e) << " "; p->pushIndent(); // add indent for recursive call // The condition printSeperator(); printExpression(e->getKid(0), SORT_BOOL); /* This operator is special in that the remaining children * can be of any sort. */ // if true printSeperator(); printExpression(e->getKid(1), s); // if false printSeperator(); printExpression(e->getKid(2), s); p->popIndent(); // pop indent added for recursive call printSeperator(); *p << ")"; }
void printSelectStatementInfo(SelectStatement* stmt, uintmax_t numIndent) { inprint("SelectStatement", numIndent); inprint("Fields:", numIndent+1); for (Expr* expr : *stmt->selectList) printExpression(expr, numIndent+2); inprint("Sources:", numIndent+1); printTableRefInfo(stmt->fromTable, numIndent+2); if (stmt->whereClause != NULL) { inprint("Search Conditions:", numIndent+1); printExpression(stmt->whereClause, numIndent+2); } if (stmt->unionSelect != NULL) { inprint("Union:", numIndent+1); printSelectStatementInfo(stmt->unionSelect, numIndent+2); } if (stmt->order != NULL) { inprint("OrderBy:", numIndent+1); printExpression(stmt->order->expr, numIndent+2); if (stmt->order->type == kOrderAsc) inprint("ascending", numIndent+2); else inprint("descending", numIndent+2); } if (stmt->limit != NULL) { inprint("Limit:", numIndent+1); inprint(stmt->limit->limit, numIndent+2); } }
void printOperatorExpression(Expr* expr, uintmax_t numIndent) { if (expr == NULL) { inprint("null", numIndent); return; } switch (expr->op_type) { case Expr::SIMPLE_OP: inprintC(expr->op_char, numIndent); break; case Expr::AND: inprint("AND", numIndent); break; case Expr::OR: inprint("OR", numIndent); break; case Expr::NOT: inprint("NOT", numIndent); break; default: inprintU(expr->op_type, numIndent); break; } printExpression(expr->expr, numIndent+1); if (expr->expr2 != NULL) printExpression(expr->expr2, numIndent+1); }
void printExpression(Expression e) { if (e->operator == CONSTANT) { printf ("%s", (e->atom==TRUE ? "true" :"false")); return; } if (e->operator == IDENTIFIER) { printf("%s", identifiers[e->atom]); return; } if (e->operator == NEG) { printf ("!"); printExpression(e->operand1); return; } printf("("); printExpression(e->operand1); switch(e->operator) { case EQUIV: printf (" <=> "); break; case IMPLIES: printf (" => "); break; case AND: printf ("*"); break; case OR: printf (" + "); break; } printExpression(e->operand2); printf(")"); }
void ExprSMTLIBPrinter::printNotEqualExpr(const ref<NeExpr> &e) { *p << "(not ("; p->pushIndent(); *p << "=" << " "; p->pushIndent(); printSeperator(); /* The "=" operators allows both sorts. We assume * that the second argument sort should be forced to be the same sort as the * first argument */ SMTLIB_SORT s = getSort(e->getKid(0)); printExpression(e->getKid(0), s); printSeperator(); printExpression(e->getKid(1), s); p->popIndent(); printSeperator(); *p << ")"; p->popIndent(); printSeperator(); *p << ")"; }
void printMoveStatement(FILE* file, IR_myStatement statement, int spaceNum) { fprintf(file, "Move("); printExpression(file, statement->u.move.dst, spaceNum + 2); indentAndPrintToFile(file, spaceNum, ", "); printExpression(file, statement->u.move.src, spaceNum + 2); indentAndPrintToFile(file, spaceNum, ")\n"); }
void printBinOperation(FILE* file, IR_myExp exp, int spaceNum) { fprintf(file, "BinOperation(%s, ", g_binOperatorStr[exp->u.binOperation.op]); printExpression(file, exp->u.binOperation.left, spaceNum + 2); indentAndPrintToFile(file, spaceNum, ", "); printExpression(file, exp->u.binOperation.right, spaceNum + 2); indentAndPrintToFile(file, spaceNum, ")\n"); }
void ExprSMTLIBPrinter::printCastToSort(const ref<Expr> &e, ExprSMTLIBPrinter::SMTLIB_SORT sort) { switch (sort) { case SORT_BITVECTOR: if (humanReadable) { p->breakLineI(); *p << ";Performing implicit bool to bitvector cast"; p->breakLine(); } // We assume the e is a bool that we need to cast to a bitvector sort. *p << "(ite"; p->pushIndent(); printSeperator(); printExpression(e, SORT_BOOL); printSeperator(); *p << "(_ bv1 1)"; printSeperator(); // printing the "true" bitvector *p << "(_ bv0 1)"; p->popIndent(); printSeperator(); // printing the "false" bitvector *p << ")"; break; case SORT_BOOL: { /* We make the assumption (might be wrong) that any bitvector whos unsigned *decimal value is * is zero is interpreted as "false", otherwise it is true. * * This may not be the interpretation we actually want! */ Expr::Width bitWidth = e->getWidth(); if (humanReadable) { p->breakLineI(); *p << ";Performing implicit bitvector to bool cast"; p->breakLine(); } *p << "(bvugt"; p->pushIndent(); printSeperator(); // We assume is e is a bitvector printExpression(e, SORT_BITVECTOR); printSeperator(); *p << "(_ bv0 " << bitWidth << ")"; p->popIndent(); printSeperator(); // Zero bitvector of required width *p << ")"; if (bitWidth != Expr::Bool) std::cerr << "ExprSMTLIBPrinter : Warning. Casting a bitvector (length " << bitWidth << ") to bool!" << std::endl; } break; default: assert(0 && "Unsupported cast!"); } }
void showExpSet(char *name, int size, Expression expset[]) { int i; printf("%s = [\n", name); for (i=0; i + 1 < size; i++) { printf(" "); printExpression(expset[i]); printf(" ;\n"); } printf(" "); printExpression(expset[i]); printf("\n]\n"); }
void Expression1::printExpression() { if(altNum == 1) { trm->printTrm(); } else if(altNum == 2){ trm->printTrm(); cout<<"+"; printExpression(); } else if(altNum ==3) { trm->printTrm(); cout<<"-"; printExpression(); } }
void printExpression( const LNZprogram* p, u32 expression, u32 level, const LNZprogram* names ){ u64 ind = indexHelper( p, expression, names ); if( ind && level ){ u64 len; const u8* name; if( names != NULL ) name = getName( names->names, ind, &len ); else name = getName( p->names, ind, &len ); for( u64 i = 0; i < len; ++i ) putchar( (int)name[ i ] ); }else{ if( p->heap[ expression ].type == LNZ_LAMBDA_TYPE ){ printf( "\\" ); ind = 0; while( p->heap[ expression ].type == LNZ_LAMBDA_TYPE && !ind ){ printf( "l%u", expression ); expression = p->heap[ expression ].data; ++level; ind = getIndex( p->pointers, (const u8*)( &expression ), sizeof( u32 ) ); if( p->heap[ expression ].type == LNZ_LAMBDA_TYPE && !ind ) printf( " " ); else{ printf( "." ); printExpression( p, expression, level + 1, names ); } } }else if( p->heap[ expression ].type == LNZ_APPLICATION_TYPE ){ u32 low = p->heap[ expression ].data & (u32)( -1 ); u32 high = p->heap[ expression ].data >> 32; ind = indexHelper( p, high, names ); u64 lind = indexHelper( p, low, names ); if( p->heap[ low ].type == LNZ_LAMBDA_TYPE && !lind ){ printf( "[" ); printExpression( p, low, level + 1, names ); printf( "]" ); }else printExpression( p, low, level + 1, names ); if( ( p->heap[ high ].type == LNZ_APPLICATION_TYPE || p->heap[ high ].type == LNZ_LAMBDA_TYPE ) && !ind ){ printf( " [" ); printExpression( p, high, level + 1, names ); printf( "]" ); }else{ printf( " " ); printExpression( p, high, level + 1, names ); } }else if( p->heap[ expression ].type == LNZ_STRING_TYPE ){
void printExpression(struct Expression *expr, int depth) { if (expr == NULL) { printf("%*sNothing\n", depth, ""); return; } if (expr->type == BRIDI) { printf("%*sbridi\n", depth, ""); printf("%*sPredicate:\n", depth, ""); printExpression(expr->pred, depth + 2); printf("%*sx1:\n", depth, ""); printExpression(expr->x1, depth + 2); printf("%*sx2:\n", depth, ""); printExpression(expr->x2, depth + 2); printf("%*sx3:\n", depth, ""); printExpression(expr->x3, depth + 2); printf("%*sx4:\n", depth, ""); printExpression(expr->x4, depth + 2); printf("%*sx5:\n", depth, ""); printExpression(expr->x5, depth + 2); } else if (expr->type == GISMU) { printf("%*sgismu: %s\n", depth, "", expr->word); } else if (expr->type == CMAVO) { printf("%*scmavo: %s\n", depth, "", expr->word); } else if (expr->type == TANRU) { printf("%*stanru\n", depth, ""); printf("%*stanru base:\n", depth, ""); printExpression(expr->tanru_base, depth + 2); printf("%*stanru descriptor:\n", depth, ""); printExpression(expr->tanru_desc, depth + 2); } }
int main() { char* strMid = "9+(3-1)*3+10/2+1000*10"; Sequence mid; initSequence(&mid); initMid(&mid, strMid); printExpression(&mid); Sequence post; initSequence(&post); initPost(&mid, &post); printExpression(&post); printf("Result=%d\n", calculate(&post)); return 0; }
void printJumpStatement(FILE* file, IR_myStatement statement, int spaceNum) { fprintf(file, "Jump("); printExpression(file, statement->u.jump.exp, spaceNum + 2); indentAndPrintToFile(file, spaceNum, ")\n"); }
void printCJumpStatement(FILE* file, IR_myStatement statement, int spaceNum) { fprintf(file, "CJump(%s, ", g_relOperatorStr[statement->u.cjump.op]); printExpression(file, statement->u.cjump.left, spaceNum + 2); indentAndPrintToFile(file, spaceNum, ", "); printExpression(file, statement->u.cjump.right, spaceNum + 2); indentAndPrintToFile(file, spaceNum, ", "); myLabel trueLabel = statement->u.cjump.trueLabel; fprintf(file, "%s, ", trueLabel == NULL ? "empty" : MySymbol_GetName(trueLabel)); myLabel falseLabel = statement->u.cjump.falseLabel; fprintf(file, "%s, ", falseLabel == NULL ? "empty" : MySymbol_GetName(falseLabel)); indentAndPrintToFile(file, spaceNum, ")\n"); }
void printMem(FILE* file, IR_myExp exp, int spaceNum) { fprintf(file, "Mem("); printExpression(file, exp->u.mem, spaceNum + 2); indentAndPrintToFile(file, spaceNum, ")\n"); }
void printCall(FILE* file, IR_myExp exp, int spaceNum) { fprintf(file, "Call("); printExpression(file, exp->u.call.func, spaceNum + 2); IR_myExpList exps = exp->u.call.args; while (exps) { indentAndPrintToFile(file, spaceNum, ", "); printExpression(file, exps->head, spaceNum + 2); exps = exps->tails; } indentAndPrintToFile(file, spaceNum, ")\n"); }
void printTableRefInfo(TableRef* table, uintmax_t numIndent) { switch (table->type) { case kTableName: inprint(table->name, numIndent); break; case kTableSelect: printSelectStatementInfo(table->select, numIndent); break; case kTableJoin: inprint("Join Table", numIndent); inprint("Left", numIndent+1); printTableRefInfo(table->join->left, numIndent+2); inprint("Right", numIndent+1); printTableRefInfo(table->join->right, numIndent+2); inprint("Join Condition", numIndent+1); printExpression(table->join->condition, numIndent+2); break; case kTableCrossProduct: for (TableRef* tbl : *table->list) printTableRefInfo(tbl, numIndent); break; } if (table->alias != NULL) { inprint("Alias", numIndent+1); inprint(table->alias, numIndent+2); } }
void ExprSMTLIBPrinter::printCastExpr(const ref<CastExpr> &e) { /* sign_extend and zero_extend behave slightly unusually in SMTLIBv2 * instead of specifying of what bit-width we would like to extend to * we specify how many bits to add to the child expression * * e.g * ((_ sign_extend 64) (_ bv5 32)) * * gives a (_ BitVec 96) instead of (_ BitVec 64) * * So we must work out how many bits we need to add. * * (e->width) is the desired number of bits * (e->src->getWidth()) is the number of bits in the child */ unsigned int numExtraBits = (e->width) - (e->src->getWidth()); *p << "((_ " << getSMTLIBKeyword(e) << " " << numExtraBits << ") "; p->pushIndent(); // add indent for recursive call printSeperator(); // recurse printExpression(e->src, SORT_BITVECTOR); p->popIndent(); // pop indent added for recursive call printSeperator(); *p << ")"; }
void printESeq(FILE* file, IR_myExp exp, int spaceNum) { fprintf(file, "Eseq("); printStatement(file, exp->u.eseq.statement, spaceNum + 2); indentAndPrintToFile(file, spaceNum, ", "); printExpression(file, exp->u.eseq.exp, spaceNum + 2); indentAndPrintToFile(file, spaceNum, ")\n"); }
double evaluateExpression(SuffixExpression expression){ int length = expression.size(); if(length == 2) return expression[0]; int i=0; while(i<length-1){//ignore the ending '#' #ifdef LOCAL_DEBUG printExpression(expression); #endif while(expression[i].type != Item::OPERATOR){ i++; } //found an operator int positionOfOperator = i; double a, b; i--; while(expression[i].type != Item::OPERAND){ i--; } a = expression[i]; expression[i].clear(); i--; while(expression[i].type != Item::OPERAND){ i--; } b = expression[i]; expression[i].clear(); //now operands found double result; switch(expression[positionOfOperator]){ case '+': result = b+a; break; case '-': result = b-a; break; case '*': result = b*a; break; case '/': result = b/a; break; default: throw "unknown operator"; } expression[positionOfOperator] = result; i = positionOfOperator + 1; } return expression[length-2]; }
void CodeGenerator::printOutput(const Node *outputNode) { ofs << "std::cout << "; Node *argument = outputNode->son; while(argument) { printExpression(argument); argument = argument->bro; if(argument) ofs << " << "; } ofs << ';' << std::endl; }
void CodeGenerator::printExpression(const Node *operatorNode) { if(!operatorNode) return; unsigned long long key; switch(operatorNode->kind) { case VAR: key = SymbolTable::hash(operatorNode->val.sVal); if(symbolTable.isInScopes(key)) ofs << operatorNode->val.sVal; else { std::cerr << "variable is not declared : " << operatorNode->val.sVal << std::endl; exit(-1); } break; case INT: ofs << operatorNode->val.iVal; break; case CHAR: ofs << operatorNode->val.cVal; break; case STRING: ofs << '\"' << operatorNode->val.sVal << '\"'; break; // case FUNCTION: // break; } printExpression(operatorNode->son); if(operatorNode->son) printExpression(operatorNode->son->bro); }
void ExprSMTLIBPrinter::printSortArgsExpr(const ref<Expr> &e, ExprSMTLIBPrinter::SMTLIB_SORT s) { *p << "(" << getSMTLIBKeyword(e) << " "; p->pushIndent(); // add indent for recursive call // loop over children and recurse into each expecting they are of sort "s" for (unsigned int i = 0; i < e->getNumKids(); i++) { printSeperator(); printExpression(e->getKid(i), s); } p->popIndent(); // pop indent added for recursive call printSeperator(); *p << ")"; }
void ExprSMTLIBPrinter::printReadExpr(const ref<ReadExpr> &e) { *p << "(" << getSMTLIBKeyword(e) << " "; p->pushIndent(); printSeperator(); // print array with updates recursively printUpdatesAndArray(e->updates.head, e->updates.root); // print index printSeperator(); printExpression(e->index, SORT_BITVECTOR); p->popIndent(); printSeperator(); *p << ")"; }
void ExprSMTLIBPrinter::printExtractExpr(const ref<ExtractExpr> &e) { unsigned int lowIndex = e->offset; unsigned int highIndex = lowIndex + e->width - 1; *p << "((_ " << getSMTLIBKeyword(e) << " " << highIndex << " " << lowIndex << ") "; p->pushIndent(); // add indent for recursive call printSeperator(); // recurse printExpression(e->getKid(0), SORT_BITVECTOR); p->popIndent(); // pop indent added for the recursive call printSeperator(); *p << ")"; }
void ExprSMTLIBPrinter::printQuery() { if (humanReadable) { *p << "; Query from solver turned into an assert"; p->breakLineI(); } p->pushIndent(); *p << "(assert"; p->pushIndent(); printSeperator(); printExpression(queryAssert, SORT_BOOL); p->popIndent(); printSeperator(); *p << ")"; p->popIndent(); p->breakLineI(); }
void ExprSMTLIBPrinter::printConstraints() { if (humanReadable) *o << "; Constraints" << endl; // Generate assert statements for each constraint for (ConstraintManager::const_iterator i = query->constraints.begin(); i != query->constraints.end(); i++) { *p << "(assert "; p->pushIndent(); printSeperator(); // recurse into Expression printExpression(*i, SORT_BOOL); p->popIndent(); printSeperator(); *p << ")"; p->breakLineI(); } }
void printInsertStatementInfo(InsertStatement* stmt, uintmax_t numIndent) { inprint("InsertStatment", numIndent); inprint(stmt->tableName, numIndent+1); if (stmt->columns != NULL) { inprint("Columns", numIndent+1); for (char* col_name : *stmt->columns) { inprint(col_name, numIndent+2); } } switch (stmt->type) { case InsertStatement::kInsertValues: inprint("Values", numIndent+1); for (Expr* expr : *stmt->values) { printExpression(expr, numIndent+2); } break; case InsertStatement::kInsertSelect: printSelectStatementInfo(stmt->select, numIndent+1); break; } }