scanner::token scanner::read_quoted_symbol() { SASSERT(curr() == '|'); bool escape = false; m_string.reset(); next(); while (true) { char c = curr(); if (c == EOF) { throw scanner_exception("unexpected end of quoted symbol", m_line, m_spos); } else if (c == '\n') { new_line(); } else if (c == '|' && !escape) { next(); m_string.push_back(0); m_id = m_string.begin(); TRACE("scanner", tout << "new quoted symbol: " << m_id << "\n";); return SYMBOL_TOKEN; }
void scanner::read_comment_block() { unsigned nesting = 1; while (true) { char c = curr(); check_not_eof("unexpected end of comment block"); next(); if (c == '/') { if (curr() == '-') { next(); nesting++; } } else if (c == '-') { if (curr() == '/') { next(); nesting--; if (nesting == 0) return; } } } }
char scanner::read_quoted_char(char const * error_msg) { lean_assert(curr() == '\\'); next(); check_not_eof(error_msg); char c = curr(); if (c != '\\' && c != '\"' && c != 'n' && c != '\'' && c != 'x') throw_exception("invalid escape sequence"); if (c == 'n') { return '\n'; } else if (c == 'x') { next(); char c = curr(); unsigned v = hex_to_unsigned(c); next(); c = curr(); v = 16*v + hex_to_unsigned(c); return static_cast<char>(v); } else { return c; } }
/** ==================== Decl ============================================= Grammar: decl : type id ';' */ static TreeDecl p_decl(void) { TreeDecl decl = 0; // set null by default TokenCode code = curr()->code; // body TreeType l0type = p_type(); TreeId l1id = p_id(); eat(';'); decl = t_decl_type(l0type, l1id); return decl; }
/** ==================== Block ============================================ Grammar: block : '{' decls stmts '}' */ static TreeBlock p_block(void) { TreeBlock block = 0; // set null by default TokenCode code = curr()->code; // body eat('{'); TreeDecls l1decls = p_decls(); TreeStmts l2stmts = p_stmts(); eat('}'); block = t_block_decls(l1decls, l2stmts); return block; }
// // Stop all movies // void StopMovies() { for (NList<Cineractive>::Iterator curr(&cineractives); *curr; curr++) { Cineractive *cin = *curr; if (cin->moviePrim) { delete cin->moviePrim; cin->moviePrim = NULL; } } }
bool proof_checker::check(proof* p, expr_ref_vector& side_conditions) { proof_ref curr(m); m_todo.push_back(p); bool result = true; while (result && !m_todo.empty()) { curr = m_todo.back(); m_todo.pop_back(); result = check1(curr.get(), side_conditions); if (!result) { IF_VERBOSE(0, ast_ll_pp(verbose_stream() << "Proof check failed\n", m, curr.get());); UNREACHABLE(); }
void GR_skigImp::loadDataset(const string &path) { train.push_back(vector< Ptr<Object> >()); test.push_back(vector< Ptr<Object> >()); validation.push_back(vector< Ptr<Object> >()); for (unsigned int i=1; i<=6; ++i) { char number[2]; sprintf(number, "%u", i); string pathDatasetRgb(path + "subject" + number + "_rgb/"); string pathDatasetDep(path + "subject" + number + "_dep/"); vector<string> fileNames; getDirList(pathDatasetRgb, fileNames); for (vector<string>::iterator it=fileNames.begin(); it!=fileNames.end(); ++it) { string &file = *it; Ptr<GR_skigObj> curr(new GR_skigObj); curr->rgb = pathDatasetRgb + file; curr->dep = file; curr->dep[0] = 'K'; curr->dep = pathDatasetDep + curr->dep; size_t posPerson = file.find("person_"); size_t posBackground = file.find("backgroud_"); size_t posIllumination = file.find("illumination_"); size_t posPose = file.find("pose_"); size_t posType = file.find("actionType_"); if (string::npos != posPerson && string::npos != posBackground && string::npos != posIllumination && string::npos != posPose && string::npos != posType) { curr->person = (unsigned char)atoi( file.substr(posPerson + strlen("person_"), 1).c_str() ); curr->background = (backgroundType)atoi( file.substr(posBackground + strlen("backgroud_"), 1).c_str() ); curr->illumination = (illuminationType)atoi( file.substr(posIllumination + strlen("illumination_"), 1).c_str() ); curr->pose = (poseType)atoi( file.substr(posPose + strlen("pose_"), 1).c_str() ); curr->type = (actionType)atoi( file.substr(posType + strlen("actionType_"), 2).c_str() ); train.back().push_back(curr); } else { printf("incorrect file name: %s", file.c_str()); } } } }
void IpoptData::SetTrialBoundMultipliersFromStep(Number alpha, const Vector& delta_z_L, const Vector& delta_z_U, const Vector& delta_v_L, const Vector& delta_v_U) { DBG_ASSERT(have_prototypes_); SmartPtr<IteratesVector> newvec = trial()->MakeNewContainer(); newvec->create_new_z_L(); newvec->z_L_NonConst()->AddTwoVectors(1., *curr()->z_L(), alpha, delta_z_L, 0.); newvec->create_new_z_U(); newvec->z_U_NonConst()->AddTwoVectors(1., *curr()->z_U(), alpha, delta_z_U, 0.); newvec->create_new_v_L(); newvec->v_L_NonConst()->AddTwoVectors(1., *curr()->v_L(), alpha, delta_v_L, 0.); newvec->create_new_v_U(); newvec->v_U_NonConst()->AddTwoVectors(1., *curr()->v_U(), alpha, delta_v_U, 0.); set_trial(newvec); }
void firstAndOthers(const string &line, string &first, string &others) { // skip whitespace before first string::const_iterator curr(line.begin()), cue(line.end()); for(; (curr!=cue) && (*curr<=' '); curr++); // find the end of first string::const_iterator fbeg=curr; for(; (curr!=cue) && (*curr>' '); curr++); first=string(fbeg, curr); // skip the whitespace before others for(; (curr!=cue) && (*curr<=' '); curr++); others=string(curr, cue); }
static ssize_t store_charge_property(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct charge_control *control = (struct charge_control*)(attr); unsigned int val; if (sscanf(buf, "%u", &val) != 1) return -EINVAL; switch (control->type) { case INPUT: curr(control->index).input_current_limit = val; break; case CHARGE: curr(control->index).fast_charging_current = val; break; default: break; } return count; }
DiskLoc RocksRecordStore::Iterator::getNext() { if ( !_iterator->Valid() ) { return DiskLoc(); } DiskLoc toReturn = curr(); if ( _forward() ) _iterator->Next(); else _iterator->Prev(); return toReturn; }
vector<vector<int>> generate(int numRows) { if (numRows < 1) { return result; } for (int i = 0; i < numRows; ++i) { vector<int> curr(1, 1); if (i > 0) { for (int j = 0; j < result[i - 1].size() - 1; ++j) { curr.push_back(result[i - 1][j] + result[i - 1][j + 1]); } curr.push_back(1); } result.push_back(curr); } return result; }
/// Return number of matching keys, and pos of first one as arg int c4_View::Locate(const c4_RowRef& crit_, int* pos_) const { // Dec 2001: fixed a problem with searching of partial rows. // // There is an *extremely* tricky issue in here, in that the // comparison operator for rows is not symmetric. So in the // general case, "a == b" is not euivalent to "b == a". This // is without doubt a design mistake (and should have at least // been named differently). // // The reason is that the number of properties in both rowrefs // need not be the same. Only the properties of the leftmost // rowref are compared against the other one. This also applies // to the other comparisons, i.e. !=, <, >, <=, and >=. // // All Compare calls below have been changed to use comparisons // in the proper order and now use "rowref <op> rowref" syntax. c4_Cursor curr (*(c4_Sequence*) _seq, 0); // loses const int l = -1, u = GetSize(); while (l + 1 != u) { curr._index = (l + u) >> 1; if (crit_ > *curr) l = curr._index; else u = curr._index; } if (pos_ != 0) *pos_ = u; // only look for more if the search hit an exact match curr._index = u; if (u == GetSize() || crit_ != *curr) return 0; // as Jon Bentley wrote in DDJ Apr 2000, setting l2 to -1 is better than u int l2 = -1, u2 = GetSize(); while (l2 + 1 != u2) { curr._index = (l2 + u2) >> 1; if (crit_ >= *curr) l2 = curr._index; else u2 = curr._index; } return u2 - u; }
TemplateTracker::Result TemplateTracker::track(const Img8u &image, const Result *initialResult, std::vector<Result> *allResults){ Result last = initialResult ? *initialResult : data->lastResult; if(last.pos == Point32f(-1,-1)){ last.pos = Point(image.getWidth()/2,image.getHeight()/2); } const double angle = last.angle; const int X = last.pos.x; const int Y = last.pos.y; const int lutSize = (int)data->lut.size(); const int angleIndex = angle / (2*M_PI) * (lutSize-1); const int ROI = getPropertyValue("tracking.position range"); const float rotationRange = getPropertyValue("tracking.rotation range"); const int step1 = getPropertyValue("tracking.coarse steps"); //const int step2 = getPropertyValue("tracking.fine steps"); //const float angleStepSize = 360./lutSize; const Rect roi(X - ROI/2, Y-ROI/2, ROI, ROI); SmartPtr<const Img8u> roiImageTmp = image.shallowCopy(roi); SmartPtr<Img8u> roiImage = roiImageTmp->deepCopyROI(); const int stepRadius = lutSize * rotationRange/720; Result bestResult = last; for(int i = -stepRadius; i <= stepRadius; i+= step1){ int curIndex = angleIndex + i; while(curIndex >= lutSize) curIndex -= lutSize; while(curIndex < 0) curIndex += lutSize; data->prox->apply(roiImage.get(),data->lut.at(curIndex).get(),&data->buf); Point maxPos; float maxValue = data->buf->getMax(0,&maxPos); Result curr(maxPos+last.pos, (float(curIndex)/lutSize) * 2 * M_PI, maxValue, data->lut.at(curIndex).get()); if(curr.proximityValue > bestResult.proximityValue){ bestResult = curr; } if(allResults) allResults->push_back(curr); } data->lastResult = bestResult; return bestResult; }
bool poseTracker::newPose(tf::StampedTransform transform){ Eigen::Vector3f curr(transform.getOrigin().x(), transform.getOrigin().y(), transform.getOrigin().z()); pose.push(curr); if(pose.size() < 50){ return true; } float squaredNorm = (pose.front() - curr).squaredNorm(); pose.pop(); bool tmp = squaredNorm > 0.2; std::cout << tmp << " Max: " << squaredNorm << std::endl; return squaredNorm > 0.2; }
vector<Action> Board::GetPossibleActions(Turn turn) { vector<Action> actions; for (int y=0 ; y<kStageHeight ; y++) { for (int x=0 ; x<kStageWidth ; x++) { if ( IsMovableUnit(stage[y][x], turn) ) { Pos curr(x,y); vector<Pos> candidates = GetMovableCanditates(curr); for (Pos p : candidates) actions.push_back(Action(curr, p)); } } } return actions; }
/// run all tests void run_tests(void) throw() { printf("\nTesting...\n"); for(detail::TestBase *curr(detail::TestBase::first_test); 0 != curr; curr = curr->next) { curr->run_test(); } printf("\n"); printf("Number of tests: %u\n", detail::TestBase::num_tests); printf(" passed: %u\n", detail::TestBase::num_passed); printf(" failed: %u\n\n", detail::TestBase::num_failed); }
int main(int, char**){ test curr = tests[0]; int i = 0; std::cout << "Running tests" << std::endl; while (curr != NULL) { curr(); ++i; curr = tests[i]; std::cout << "."; } std::cout << std::endl; std::cout << "Ran " << i << " tests" << std::endl; return 0; }
void splittext(const char *text, u32t width, TStrings &lst, u32t flags) { lst.Clear(); if (!text || width<8) return; const char *ps = text, *pps; char softcr = flags&SplitText_HelpMode?'&':0; int ln = 0; spstr linehead; lst.Add(spstr()); do { while (*ps && (strchr(AllowSet,*ps) || *ps==softcr)) { register char cr=*ps++; if (cr!=' ') { if (cr==softcr) { pps = ps; if (*pps) pps++; while (*pps==' ' || *pps=='\t') pps++; /* get 1 char after eol and all spaces after it and use result as a header for all next lines until real cr */ linehead = spstr(ps, pps-ps).expandtabs(4); ps = pps; } else { lst.Add(spstr()); if (cr=='\r' && *ps=='\n') ps++; linehead.clear(); if (lst[ln].lastchar()==' ') lst[ln].dellast(); ln++; } } } if (*ps==0) break; pps = strpbrk(ps, softcr ? CarrySet AllowSet "&" : CarrySet AllowSet); int carry = pps&&strchr(CarrySet,*pps)?1:0; spstr curr(ps,pps?pps-ps+carry:0), sum; sum = lst[ln]+curr; sum.expandtabs(4); if ((flags&SplitText_NoAnsi?strlen:str_length)(sum())<width-2) lst[ln]=sum; else { lst.Add(linehead+curr); if (lst[ln].lastchar()==' ') lst[ln].dellast(); ln++; } if (!carry||pps&&pps[1]==' ') lst[ln]+=' '; ps=pps; if (carry) ps++; } while (pps); }
int64_t Problem71::solve() { Fraction limit(3, 7); Fraction max(0, 1); Primes primes(PROBLEM_SIZE); for(int i = 8; i <= PROBLEM_SIZE; ++i) { Fraction curr(limit * i, i); if(curr < max) continue; else if(curr.isProperFraction(primes)) max = curr; } return max.getNumerator(); }
/** ==================== Stmts ============================================ Grammar: stmts : stmt stmts | e */ static TreeStmts p_stmts(void) { TreeStmts stmts = 0; // set null by default TokenCode code = curr()->code; // body TreeStmt l0stmt = p_stmt() // check if we have next production if ( l0stmt == 0 ) return stmts; TreeStmts l1stmts = p_stmts(); stmts = t_stmts_stmt(l0stmt, l1stmts); return stmts; }
bool FlingAnimator::update() { JNIEnv* env = m_javaScroller.env(); if (!env->CallBooleanMethod(m_javaScroller.obj(), m_computeMethodId)) { CheckException(env); stop(); return false; } WebCore::IntSize curr(env->CallIntMethod(m_javaScroller.obj(), m_getXMethodId), env->CallIntMethod(m_javaScroller.obj(), m_getYMethodId)); CheckException(env); m_scrollController->scrollBy(curr - m_last); m_last = curr; return true; }
bool DropScriptTarget::OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames) { size_t nFiles = filenames.GetCount(); for ( size_t n = 0; n < nFiles; n++ ) { wxFileName curr(filenames[n]); if( (curr.GetExt().CmpNoCase(_T("smil")) == 0) || (curr.GetExt().CmpNoCase(_T("apml")) == 0) ) { m_pOwner->LoadScriptFile(curr); return true; } } return false; }
void BVH::buildAccelStructure(const std::vector<Shape*>& sceneData){ Assert(scene.empty()); //Get bounding boxes for each shape scene.reserve(sceneData.size()); //Reserve space ahead of time to avoid realloc's for(size_t i = 0; i < sceneData.size(); i++){ //Bound current primitive BoundingBox currBBox = sceneData[i]->worldSpaceBound(); //Add bbox and shape to list BVH::ShapeWBound curr(sceneData[i], currBBox); scene.push_back(curr); } //Build tree recursively in a top down manner root = buildTreeRecursive(0, scene.begin(), scene.end()); }
/** ==================== Decls ============================================ Grammar: decls : decl decls | e */ static TreeDecls p_decls(void) { TreeDecls decls = 0; // set null by default TokenCode code = curr()->code; // body TreeDecl l0decl = p_decl() // check if we have next production if ( l0decl == 0 ) return decls; TreeDecls l1decls = p_decls(); decls = t_decls_decl(l0decl, l1decls); return decls; }
inline void TR_charsImp::convert(vector<int> &from, vector< Ptr<Object> > &to, vector<int> &allLabels, vector<string> &allNames) { for (vector<int>::iterator it=from.begin(); it!=from.end(); ++it) { if (*it>=(int)allNames.size() || *it>=(int)allLabels.size()) { printf("incorrect index: %u\n", *it); continue; } Ptr<TR_charsObj> curr(new TR_charsObj); curr->imgName = allNames[*it]; curr->label = allLabels[*it]; to.push_back(curr); } }
int uniquePaths(int m, int n) { if (m==0||n==0) return 0; vector<int> prev(m); prev[0]=1; for (int i=1; i<n; i++) { vector<int> curr(m); for (int j=0; j<m; j++) { if (j>0) curr[j]+=prev[j-1]; if (j<m-1) curr[j]+=prev[j+1]; curr+=prev[j]; } prev=curr; } return prev[0]; }
void scanner::move_back(unsigned offset, unsigned u_offset) { lean_assert(m_uskip == 0); if (offset != 0) { if (curr() == EOF) { m_curr = 0; m_spos--; m_upos--; offset--; u_offset--; } if (offset != 0) { m_spos -= offset; m_upos -= u_offset; } next(); } }
void DictEngine::getDicts() { QMap<QString, QString> theHash; m_tcpSocket->readAll(); QByteArray ret; m_tcpSocket->write(QByteArray("SHOW DB\n"));; m_tcpSocket->flush(); m_tcpSocket->waitForReadyRead(); while (!ret.contains("250")) { m_tcpSocket->waitForReadyRead(); ret += m_tcpSocket->readAll(); } QList<QByteArray> retLines = ret.split('\n'); QString tmp1, tmp2; while (!retLines.empty()) { QString curr(retLines.takeFirst()); if (curr.startsWith(QLatin1String("554"))) { //TODO: What happens if no DB available? //TODO: Eventually there will be functionality to change the server... break; } // ignore status code and empty lines if (curr.startsWith(QLatin1String("250")) || curr.startsWith(QLatin1String("110")) || curr.isEmpty()) { continue; } if (!curr.startsWith('-') && !curr.startsWith('.')) { curr = curr.trimmed(); tmp1 = curr.section(' ', 0, 0); tmp2 = curr.section(' ', 1); // theHash.insert(tmp1, tmp2); //qDebug() << tmp1 + " " + tmp2; setData(QStringLiteral("list-dictionaries"), tmp1, tmp2); } } m_tcpSocket->disconnectFromHost(); // setData("list-dictionaries", "dictionaries", QByteArray(theHash); }