Parser::Parser(int ac, char **tab, std::string const &usage, bool n) : m_arg(tab), m_usage(usage), m_name(getArgument("-n", n)), m_port(getArgument("-p", true)), m_host(getArgument("-h", false)){ try { for (int i = 1;i < ac ;++i){ if (this->m_arg[i] && this->m_arg[i - 1] && this->m_arg[i][0] == '-' && std::string(this->m_arg[i - 1]) != "-n" && !checkTab(std::string(this->m_arg[i]))) throw ErrorClient(this->m_usage, "Parser"); } if (this->m_arg[ac - 1] && std::string(this->m_arg[ac - 1]) == "-d") std::cout << "Name : " << this->m_name << std::endl << "Port : " << this->m_port << std::endl << "Host : " << this->m_host << std::endl; } catch (ErrorClient const &e) { throw ErrorClient(e.what(), "Parser"); } }
/******************************************************************* * Function: ArrayIndexAnalysis::computeOutSet * Purpose : a helper function to compute the out set an expression * Initial : Nurudeen A. Lameed on July 21, 2009 ******************************************************************** Revisions and bug fixes: */ void ArrayIndexAnalysis::computeOutSet(const Expression* expr, FlowSet& out) { // what kind of expression? switch (expr->getExprType()) { case Expression::PARAM: { // Convert it to a parameter type const ParamExpr* paramExpr = dynamic_cast<const ParamExpr*>(expr); // array/matrix symbol SymbolExpr* symbol = paramExpr->getSymExpr(); const Expression::ExprVector& args = paramExpr->getArguments(); // build a table of checks for the indices std::vector< std::bitset<2> > checkTab(args.size()); TypeInfo::DimVector bounds(args.size(), 0); ArrayBoundsMap::const_iterator it = arrayBoundsMap.find(symbol); if ( it != arrayBoundsMap.end() ) // already defined, get it { bounds = it->second; // get the bounds } // insert the indexes for (size_t j = 0, size = args.size(); j < size; ++j) { // checks for the current index // bit 0 represents lower check while bit 1 represents upper check std::bitset<2> checks; // if it is a const, check against the bounds table, 1 >= index <= its dimension bound // remove all checks for the current index // if the index is greater than the bound from the table, update the // bound for the dimension with this index value ... // form an <index, dimension> pair IndexKey iKey = {args[j], j}; bool mustCheck = false; // are checks necessary for this access? // remove check for lower bound if ( out.erase( FlowFact(symbol, iKey, FlowFact::LOWER_BOUND)) > 0 ) { checks.set(0); // a mandatory check mustCheck = true; // a mandatory check must be performed for this access } // remove check for upper bound if ( out.erase( FlowFact(symbol, iKey, FlowFact::UPPER_BOUND)) > 0 ) { checks.set(1); // a mandatory check mustCheck = true; // a mandatory check must be performed for this access } // generate others ... if ( mustCheck && args[j]->getExprType() == Expression::INT_CONST ) { size_t subscript = (dynamic_cast<const IntConstExpr*>(args[j]))->getValue(); // replace the bound for the array dimension for the subscript with the subscript bounds[j] = subscript; // must be greater than the current value // update flow set updateFlowSet(symbol, bounds, out); } // insert the table checkTab[j] = checks; // update the table arrayBoundsMap[symbol] = bounds; } // insert a table of checks for the indices of this array access factTable[paramExpr] = checkTab; } break; case Expression::BINARY_OP: { // convert to binary operator type const BinaryOpExpr* bOpExpr = dynamic_cast<const BinaryOpExpr*>(expr); // analyse right expr first computeOutSet(bOpExpr->getRightExpr(), out); // analyse left expr computeOutSet(bOpExpr->getLeftExpr(), out); } break; case Expression::UNARY_OP: { const UnaryOpExpr* uOpExpr = dynamic_cast<const UnaryOpExpr*>(expr); // analyse the operand computeOutSet(uOpExpr->getOperand(), out); } break; default: // do nothing { } } }
bool vpDot::connexe(const vpImage<unsigned char>& I,unsigned int u,unsigned int v, double &mean_value, double &u_cog, double &v_cog, double &n) { std::vector<bool> checkTab(I.getWidth()*I.getHeight(),false); return connexe(I,u,v,mean_value,u_cog,v_cog,n,checkTab); }