real pickdist(real eta, real sigma) { static real eta0 = -1.0, sigcorr; int niter; real x, y, q; if (eta != eta0) { sigcorr = rsqrt(8 * eta / (bessel_K(0.75, 1/(32*eta)) / bessel_K(0.25, 1/(32*eta)) - 1)); eprintf("[%s: sigma correction factor = %f]\n", getargv0(), sigcorr); eta0 = eta; } niter = 0; do { x = xrandom(-1.0, 1.0); y = xrandom(0.0, YMAX); q = rexp(- 0.5 * rsqr(fmap(x)) - eta * rsqr(rsqr(fmap(x)))) * (1 + x*x) / rsqr(1 - x*x); if (q > YMAX) /* should not ever happen */ error("%s: guess out of bounds\n x = %f q = %f > %f\n", getargv0(), x, q, YMAX); niter++; if (niter > 1000) error("%s: 1000 iterations without success\n", getargv0()); } while (y > q || x*x == 1); /* 2nd test prevents infty */ return (sigcorr * sigma * fmap(x)); }
static int promia_get(CHAR *fc, CHAR *fs) { uint nc, ns, *mc; uchar *ms; mc = fmap(fc, &nc); ms = fmap(fs, &ns); if(mc && ms) promia_get_local(mc, nc, ms, ns); mem_free(ms); mem_free(mc); return 0; }
reaver::despayre::expression reaver::despayre::_v1::parse_expression(reaver::despayre::context & ctx) { auto expr = parse_simple_expression(ctx); auto peeked = peek(ctx); auto start = get<0>(fmap(expr, [](auto && expr){ return expr.range.start(); })); if (peeked && (peeked->type == token_type::plus || peeked->type == token_type::minus)) { auto operations = parse_operations(ctx); return expression{ range_type{ start, operations.back().range.end() }, std::move(expr), std::move(operations) }; } auto end = get<0>(fmap(expr, [](auto && expr){ return expr.range.end(); })); return expression{ range_type{ start, end }, std::move(expr), {} }; }
void do_map (CHAR_DATA * ch, char *argument) { char arg[MSL]; refresh(ch->in_room); argument = one_argument (argument, arg); if (!strcmp (arg, "forced")) fmap(ch,TRUE,FALSE," "); else if (!strcmp (arg, "range")) fmap(ch,FALSE,TRUE," "); else fmap(ch,FALSE,FALSE," "); }
// Open a file (or directory), // returning the file descriptor index on success, < 0 on failure. int open(const char *path, int mode) { // Find an unused file descriptor page using fd_alloc. // Then send a message to the file server to open a file // using a function in fsipc.c. // (fd_alloc does not allocate a page, it just returns an // unused fd address. Do you need to allocate a page? Look // at fsipc.c if you aren't sure.) // Then map the file data (you may find fmap() helpful). // Return the file descriptor index. // If any step fails, use fd_close to free the file descriptor. // LAB 5: Your code here. int r; struct Fd *fd; if ((r = fd_alloc(&fd)) < 0) return r; if ((r = fsipc_open(path, mode, fd)) < 0){ fd_close(fd, 0); return r; } if ((r = fmap(fd, 0, fd->fd_file.file.f_size) ) < 0){ fd_close(fd, 0); return r; } return fd2num(fd); }
// calculates the "male optimal" stable marriage (i.e. there // is no stable marriage where any man prefers his match // over the one given here) a female optimal matching can be // found by swapping men and women // mpref: vector i is the list of i's preferred partners, in // *decreasing* order of preference (0 indexed) // fpref: as above, but for women // match: a vector (passed in with any size) filled so that // position i gives the man matched with woman i void stable_marriage(const vvi& mpref, const vvi& fpref, vi& match) { // initially no one matched match.resize(mpref.size(), -1); // get a map from (w, m) to w's "rank" for m vvi fmap(match.size(), vi(match.size())); for(int i = 0; i < match.size(); ++i) for(int j = 0; j < match.size(); ++j) fmap[i][fpref[i][j]] = j; vi next_prop(match.size(), 0); queue<int> mfree; for(int i = 0; i < match.size(); ++i) mfree.push(i); while(!mfree.empty()) { const int m = mfree.front(); const int w = mpref[m][next_prop[m]]; mfree.pop(); if(match[w] == -1) { match[w] = m; } else if(fmap[w][match[w]] > fmap[w][m]) { mfree.push(match[w]); match[w] = m; } else if(++next_prop[m] < match.size()) { mfree.push(m); } } }
cli_ctx *convenience_ctx(int fd) { cli_ctx *ctx; struct cl_engine *engine; ctx = malloc(sizeof(*ctx)); if(!ctx){ printf("ctx malloc failed\n"); return NULL; } ctx->engine = engine = cl_engine_new(); if(!(ctx->engine)){ printf("engine malloc failed\n"); free(ctx); return NULL; } ctx->fmap = cli_malloc(sizeof(struct F_MAP *)); if(!(ctx->fmap)){ printf("fmap malloc failed\n"); free(engine); free(ctx); return NULL; } if(!(*ctx->fmap = fmap(fd, 0, 0))){ printf("fmap failed\n"); free(ctx->fmap); free(engine); free(ctx); return NULL; } return ctx; }
TEST(FixedSet, begin_end) { { FixedMap<size_t, size_t, kMax> fmap; fmap = {{0ul, 0ul}, {1ul, 1ul}}; auto it = fmap.begin(); EXPECT_TRUE(it->first == 0ul && it->second == 0ul); } { FixedMap<size_t, size_t, kMax> fmap; fmap = {{0ul, 0ul}, {1ul, 1ul}}; auto it = fmap.begin(); auto it_end = fmap.end(); size_t fssize = fmap.size(); EXPECT_EQ(fssize, 2); EXPECT_EQ(std::distance(it, it_end), fssize); } { FixedMap<size_t, size_t, kMax> fmap(std::begin(vec), std::end(vec)); auto it = fmap.begin(); auto it_end = fmap.end(); EXPECT_TRUE(std::equal( it, it_end, std::begin(vec), [](std::pair<const size_t, size_t>& lhs, std::pair<size_t, size_t>& rhs) { return lhs.first == rhs.first && lhs.second == rhs.second; })); } }
static int promia_put(CHAR *fc, CHAR *fs, FILE *fo) { uint nc, *mc; if(mc = fmap(fc, &nc)) promia_put_local(mc, nc, fo); if(fo = FOPENW(fs)) { fwrite(mc, 1, nc, fo); fclose(fo); } mem_free(mc); return 0; }
void testFmap() { std::shared_ptr<int> a(new int(-4)); std::function<int(int)> f = IntAbs; std::shared_ptr<int> sabs = fmap(f, a); std::cout << "fmap(IntAbs, -4): " << *sabs << std::endl; }
ArrayRef<ncclComm_t> _get_communicators(TensorList inputs) { static auto get_device = [](const at::Tensor& t) -> int { return t.get_device(); }; device_list devices = fmap(inputs, get_device); auto it = _communicators.find(devices); if (it == _communicators.end()) std::tie(it, std::ignore) = _communicators.emplace(devices, devices); return it->second.ref(); }
static constexpr auto apply(X x) { return to<Map>(fmap( [=](auto k_f) { using P = datatype_t<decltype(k_f)>; return make_product<P>(first(k_f), second(k_f)(x)); }, members<R> )); }
constexpr auto operator()(F f, Xs ...xs) const { static_assert(sizeof...(xs) >= 1, "boost::hana::ap must be called with two arguments or more"); return detail::left_folds::variadic( *this, fmap(curry<sizeof...(xs)>, f), xs... ); }
UMachDebugInfo::UMachDebugInfo(Project *uproject) { //first we read temporary the number / file assoziation QFile fmap( uproject->getProjectDir()->absoluteFilePath(QString(uproject->getName() + ".umx.fmap")) ); if (!fmap.open(QIODevice::ReadOnly)) throw (QString("Failed to open file")); QMap <uint32_t,IUasmFile*>fmapTable; QTextStream in(&fmap); QString fmapLine; QStringList fmapParseList; uint32_t fileId; IUasmFile *uasmFile; while (!(fmapLine = in.readLine()).isEmpty()) { fmapParseList = fmapLine.split(" "); //file Number fileId = (uint32_t)fmapParseList.at(0).toInt(); //file ponter uasmFile = uproject->getFileByAbsPath(fmapParseList.at(1)); if (!uasmFile) throw (QString("File not in Project!")); //ad to temp map fmapTable.insert(fileId, uasmFile); } fmap.close(); //now we read in binary data from debug and insert it into the overall table QFile debug( uproject->getProjectDir()->absoluteFilePath(QString(uproject->getName() + ".umx.debug")) ); if (!debug.open(QIODevice::ReadOnly)) throw (QString("Failed to open file")); //BIG-ENDIAN //<FILE-ID><LINE-NO><ADDRESS> uint32_t debugDatum[3]; while (debug.read((char*)debugDatum, 12)) { //swap endianess to little uasmFile = fmapTable.value(swap_uint32(debugDatum[0])); uint32_t address = swap_uint32(debugDatum[2]); m_addressTable.insert(address, (new debugAddressEntry(uasmFile, swap_uint32(debugDatum[1]), address, NULL))); } debug.close(); }
int pclear(int err, t_data *d, t_map *m, char *msg) { l1(1, (m->path + ft_strlen(MAP_DIR) - 2), msg); ft_strdel(&m->path); (m->fd > 0) ? close(m->fd) : 0; m->fd = 0; m->x = 0; m->status = (err == 1) ? 0 : -1; (err == 1) ? (fmap(d, -1, 0)) : 0; (err == 1 && d->menu.open == 0) ? (d->menu.open = 1) : 0; return (1); }
int limitSeabotix(int speed){ /* if (speed>SEABOTIX_LIMIT) speed=SEABOTIX_LIMIT; else if(speed<-SEABOTIX_LIMIT) speed=-SEABOTIX_LIMIT; return speed; */ int out=(int)fmap(speed,0,255,24,255); return out; }
END_TEST #endif START_TEST(test_screnc_nullterminate) { int fd = open_testfile("input/screnc_test"); fmap_t *map; fail_unless(mkdir(dir, 0700) == 0,"mkdir failed"); map = fmap(fd, 0, 0); fail_unless(!!map, "fmap failed"); fail_unless(html_screnc_decode(map, dir) == 1, "html_screnc_decode failed"); funmap(map); fail_unless(cli_rmdirs(dir) == 0, "rmdirs failed"); close(fd); }
std::vector<reaver::despayre::operation> reaver::despayre::_v1::parse_operations(reaver::despayre::context & ctx) { auto peeked = peek(ctx); std::vector<operation> operations; while (peeked && (peeked->type == token_type::plus || peeked->type == token_type::minus)) { operation_type operation = expect(ctx, peeked->type).type == token_type::plus ? operation_type::addition : operation_type::removal; auto operand = parse_simple_expression(ctx); auto end = get<0>(fmap(operand, [](auto && op){ return op.range.end(); })); operations.push_back({ range_type{ peeked->range.start(), end }, operation, std::move(operand) }); peeked = peek(ctx); } return operations; }
TEST(FixedSet, ctor_dtor) { size_t i = 0; std::generate(std::begin(vec), std::end(vec), [&i]() { ++i; return std::make_pair(i, i); }); FixedMap<size_t, size_t, kMax> fmap(std::begin(vec), std::end(vec)); FixedMap<size_t, size_t, kMax> fmap1(fmap); FixedMap<size_t, size_t, kMax> fmap2({{0ul, 0ul}, {1ul, 1ul}}); FixedMap<size_t, size_t, kMax, std::greater<size_t>> fmap3( std::greater<size_t>()); FixedMap<size_t, size_t, kMax, std::greater<size_t>> fmap4(std::begin(vec), std::end(vec)); }
static void read_links() { FileMapping fmap("db/wikilinks"); Reader rd(fmap.data(), fmap.size()); rd.assert_u32(0x4b4e494c); n_articles = rd.read_u32(); int alloc_edges = 1024; outdeg = talloc_array(NULL, int, n_articles); edges = talloc_array(NULL, edge, alloc_edges); assert(outdeg && edges); memset(outdeg, 0, sizeof(int)*n_articles); for(int u=0; u<n_articles; u++) { outdeg[u] = rd.read_u16(); for(int i=0; i<outdeg[u]; i++) { int v = rd.read_u32(); if(n_edges == alloc_edges) { alloc_edges += 10 * 1048576; // 10 * 2^20 edges = talloc_realloc(NULL, edges, edge, alloc_edges); assert(edges); } edges[n_edges].from = u; edges[n_edges].to = v; n_edges++; } } assert(rd.eof()); printf("articles: %d, edges: %d (alloc %d)\n", n_articles, n_edges, alloc_edges); std::sort(edges, edges+n_edges); }
// Truncate or extend an open file to 'size' bytes static int file_trunc(struct Fd *fd, off_t newsize) { int r; off_t oldsize; uint32_t fileid; if (newsize > MAXFILESIZE) return -E_NO_DISK; fileid = fd->fd_file.id; oldsize = fd->fd_file.file.f_size; if ((r = fsipc_set_size(fileid, newsize)) < 0) return r; assert(fd->fd_file.file.f_size == newsize); if ((r = fmap(fd, oldsize, newsize)) < 0) return r; funmap(fd, oldsize, newsize, 0); return 0; }
static void test_with_string(void) { using string = mtr::string; auto to_lower_case = [](char c)->char { return c >= 'A' && c <= 'Z' ? c-'A'+'a' : c; }; auto to_upper_case = [](char c)->char { return c >= 'a' && c <= 'z' ? c-'a'+'A' : c; }; auto mixed_case_string = string("Hello World"); auto lower_case_string = string("hello world"); auto upper_case_string = string("HELLO WORLD"); auto fmap = mixed_case_string.fmap(); auto lower_case = fmap(to_lower_case); SHOULD_BE_EQ((int) lower_case.length(), 11, "Resulting string should be same length as original"); SHOULD_BE_EQ(lower_case, lower_case_string, "String should be all lower case"); SHOULD_NOT_BE_EQ(lower_case, upper_case_string, "String should not be upper case"); auto upper_case = fmap(to_upper_case); SHOULD_BE_EQ((int) upper_case.length(), 11, "Resulting string should be same length as original"); SHOULD_BE_EQ(upper_case, upper_case_string, "String should be all upper case"); SHOULD_NOT_BE_EQ(upper_case, lower_case_string, "String should not be lower case"); }
TEST(FixedSet, assign_operator) { { FixedMap<size_t, size_t, kMax> fmap; fmap = {{0ul, 0ul}, {1ul, 1ul}}; } { FixedMap<size_t, size_t, kMax> fmap(std::begin(vec), std::end(vec)); FixedMap<size_t, size_t, kMax> fmap1; fmap1 = fmap; } { FixedMap<size_t, size_t, kMax> fmap; fmap = FixedMap<size_t, size_t, kMax>(std::begin(vec), std::end(vec)); } { FixedMap<size_t, size_t, kMax> fmap; std::map<size_t, size_t> smap(std::begin(vec), std::end(vec)); fmap = smap; } { FixedMap<size_t, size_t, kMax> fmap; fmap = std::map<size_t, size_t>(std::begin(vec), std::end(vec)); } }
int testMonad() { Susp<int> x = mjoin(fmap(ints(1, 4), sum)); Susp<int> y = mbind(ints(1, 4), sum); return y.get(); }
void add_file(xirang::zip::reader_writer& zip, const xirang::file_path& file){ xirang::io::file_reader f(file); xirang::iref<xirang::io::read_map> fmap(f); zip.append(fmap.get<xirang::io::read_map>(), file.filename()); }
int Decompose_Cresting_BFS( SWIFT_Tri_Mesh* m, SWIFT_Array<int>& piece_ids, SWIFT_Array< SWIFT_Array<int> >& mfs, SWIFT_Array< SWIFT_Array<SWIFT_Tri_Face> >& vfs ) { // Start performing BFS on the dual graph maintaining a convex hull along // the way. cerr << endl << "Starting cresting BFS decomposition" << endl; const unsigned int max_faces_in_a_chull = (m->Num_Vertices() - 2) << 1; int i, j, k, l; int created_faces = 0; int front, id; bool add_children; SWIFT_Tri_Edge* e; SWIFT_Tri_Vertex* v; SWIFT_Array<SWIFT_Tri_Face*> qfs; // The queue SWIFT_Array<SWIFT_Tri_Face*> qfs_parents; SWIFT_Array<int> qmap; SWIFT_Array<int> qmap_idx; SWIFT_Array<SWIFT_Tri_Face*> mark_failed; SWIFT_Array<SWIFT_Tri_Face> chull; SWIFT_Array<SWIFT_Tri_Face*> cfs; SWIFT_Array<bool> fallowed; SWIFT_Array<bool> cvs; SWIFT_Array<int> cvs_idx; SWIFT_Array<int> addedfs; SWIFT_Array<int> temp_mfs_1d; SWIFT_Array< SWIFT_Array<int> > temp_mfs_2d; // The priority queue SWIFT_Array<int> lengths( m->Num_Faces() ); SWIFT_Array<int> bmap( m->Num_Faces() ); SWIFT_Array<int> fmap( m->Num_Faces() ); qfs.Create( m->Num_Faces() ); qfs_parents.Create( m->Num_Faces() ); qmap.Create( m->Num_Faces() ); qmap_idx.Create( m->Num_Faces() ); mark_failed.Create( m->Num_Faces() ); chull.Create( max_faces_in_a_chull ); cfs.Create( max_faces_in_a_chull ); fallowed.Create( m->Num_Faces() ); cvs.Create( m->Num_Vertices() ); cvs_idx.Create( m->Num_Vertices() ); addedfs.Create( m->Num_Faces() ); temp_mfs_1d.Create( m->Num_Faces() ); temp_mfs_2d.Create( m->Num_Faces() ); vfs.Create( m->Num_Faces() ); piece_ids.Create( m->Num_Faces() ); Prepare_Mesh_For_Decomposition( m ); cvs_idx.Set_Length( 0 ); qmap_idx.Set_Length( 0 ); for( i = 0; i < m->Num_Vertices(); i++ ) { cvs[i] = false; } for( i = 0; i < m->Num_Faces(); i++ ) { fallowed[i] = true; piece_ids[i] = -1; qmap[i] = -1; bmap[i] = fmap[i] = i; if( m->Faces()[i].Edge1().Unmarked() || m->Faces()[i].Edge2().Unmarked() || m->Faces()[i].Edge3().Unmarked() ) { lengths[i] = 0; qmap_idx.Add( i ); } else { lengths[i] = -1; } } id = 0; // Calculate distances for each face and create priority queue if( !qmap_idx.Empty() ) { // This is a convex object for( i = 0; i < qmap_idx.Max_Length(); i++ ) { if( m->Faces()[qmap_idx[i]].Edge1().Twin() != NULL ) { k = m->Face_Id( m->Faces()[qmap_idx[i]].Edge1().Twin()->Adj_Face() ); if( lengths[k] == -1 ) { lengths[k] = lengths[qmap_idx[i]]+1; qmap_idx.Add( k ); } } if( m->Faces()[qmap_idx[i]].Edge2().Twin() != NULL ) { k = m->Face_Id( m->Faces()[qmap_idx[i]].Edge2().Twin()->Adj_Face() ); if( lengths[k] == -1 ) { lengths[k] = lengths[qmap_idx[i]]+1; qmap_idx.Add( k ); } } if( m->Faces()[qmap_idx[i]].Edge3().Twin() != NULL ) { k = m->Face_Id( m->Faces()[qmap_idx[i]].Edge3().Twin()->Adj_Face() ); if( lengths[k] == -1 ) { lengths[k] = lengths[qmap_idx[i]]+1; qmap_idx.Add( k ); } } } Build_Heap( lengths, bmap, fmap ); } qmap_idx.Set_Length( 0 ); // Process the priority queue by doing BFS while( !lengths.Empty() ) { i = bmap[0]; // Unset all the qmappings for( j = 0; j < qmap_idx.Length(); j++ ) { qmap[qmap_idx[j]] = -1; } qmap_idx.Set_Length( 0 ); qfs.Set_Length( 0 ); qfs_parents.Set_Length( 0 ); front = 0; if( m->Faces()[i].Edge1().Marked() && m->Faces()[i].Edge1().Twin()->Adj_Face()->Unmarked() ) { j = m->Face_Id( m->Faces()[i].Edge1().Twin()->Adj_Face() ); qmap_idx.Add( j ); qmap[j] = qfs.Length(); qfs.Add( m->Faces()(j) ); m->Faces()(j)->Mark(); qfs_parents.Add( m->Faces()(i) ); } if( m->Faces()[i].Edge2().Marked() && m->Faces()[i].Edge2().Twin()->Adj_Face()->Unmarked() ) { j = m->Face_Id( m->Faces()[i].Edge2().Twin()->Adj_Face() ); qmap_idx.Add( j ); qmap[j] = qfs.Length(); qfs.Add( m->Faces()(j) ); m->Faces()(j)->Mark(); qfs_parents.Add( m->Faces()(i) ); } if( m->Faces()[i].Edge3().Marked() && m->Faces()[i].Edge3().Twin()->Adj_Face()->Unmarked() ) { j = m->Face_Id( m->Faces()[i].Edge3().Twin()->Adj_Face() ); qmap_idx.Add( j ); qmap[j] = qfs.Length(); qfs.Add( m->Faces()(j) ); m->Faces()(j)->Mark(); qfs_parents.Add( m->Faces()(i) ); } mark_failed.Set_Length( 0 ); temp_mfs_1d.Set_Length( 0 ); Create_First_Face( m->Faces()(i), chull, cfs ); // Unset all the vertex membership flags for( j = 0; j < cvs_idx.Length(); j++ ) { cvs[cvs_idx[j]] = false; } cvs_idx.Set_Length( 0 ); // Mark the first three vertices as added to the hull cvs_idx.Add( m->Vertex_Id( m->Faces()[i].Edge1().Origin() ) ); cvs_idx.Add( m->Vertex_Id( m->Faces()[i].Edge2().Origin() ) ); cvs_idx.Add( m->Vertex_Id( m->Faces()[i].Edge3().Origin() ) ); cvs[cvs_idx[0]] = true; cvs[cvs_idx[1]] = true; cvs[cvs_idx[2]] = true; // Add the first face piece_ids[i] = id; m->Faces()[i].Mark(); temp_mfs_1d.Add( i ); l = 1; addedfs.Set_Length( 1 ); addedfs[0] = i; fallowed[i] = false; // The strategy here is a bit different from that of DFS. Whatever // is at the front of the queue is tested for validity and if so, it // is added and the unmarked neighbors are placed at the end of the // queue. while( front < qfs.Length() ) { if( qmap[ m->Face_Id( qfs[front] ) ] >= 0 ) { if( qfs[front]->Edge1().Twin() != NULL && qfs_parents[front] == qfs[front]->Edge1().Twin()->Adj_Face() ) { e = qfs[front]->Edge1().Twin(); v = qfs[front]->Edge3().Origin(); } else if( qfs[front]->Edge2().Twin() != NULL && qfs_parents[front] == qfs[front]->Edge2().Twin()->Adj_Face() ) { e = qfs[front]->Edge2().Twin(); v = qfs[front]->Edge1().Origin(); } else { e = qfs[front]->Edge3().Twin(); v = qfs[front]->Edge2().Origin(); } add_children = Add_To_Convex_Hull( m, chull, cfs, fallowed, cvs, addedfs, qfs[front], e, v ); if( add_children ) { // Add the face to the current piece cvs_idx.Add( m->Vertex_Id( v ) ); // Mark all the faces that were added to the chull for( j = l; j < addedfs.Length(); j++ ) { fallowed[addedfs[j]] = false; if( piece_ids[addedfs[j]] == -1 ) { // Remove faces that were added if they exist in q if( qmap[addedfs[j]] == -1 ) { qmap_idx.Add( addedfs[j] ); } qmap[addedfs[j]] = -2; piece_ids[addedfs[j]] = id; temp_mfs_1d.Add( addedfs[j] ); Delete_From_Heap( lengths, bmap, fmap, fmap[addedfs[j]] ); } } l = addedfs.Length(); } } else { add_children = true; } if( add_children ) { // Expand the front by adding unmarked neighbors to the queue if( qfs[front]->Edge1().Marked() && qfs[front]->Edge1().Twin()->Adj_Face()->Unmarked() ) { j = m->Face_Id( qfs[front]->Edge1().Twin()->Adj_Face() ); if( qmap[j] == -2 ) { qmap[j] = -1; } else { qmap[j] = qfs.Length(); qmap_idx.Add( j ); } qfs.Add( m->Faces()(j) ); m->Faces()(j)->Mark(); qfs_parents.Add( qfs[front] ); } if( qfs[front]->Edge2().Marked() && qfs[front]->Edge2().Twin()->Adj_Face()->Unmarked() ) { j = m->Face_Id( qfs[front]->Edge2().Twin()->Adj_Face() ); if( qmap[j] == -2 ) { qmap[j] = -1; } else { qmap[j] = qfs.Length(); qmap_idx.Add( j ); } qfs.Add( m->Faces()(j) ); m->Faces()(j)->Mark(); qfs_parents.Add( qfs[front] ); } if( qfs[front]->Edge3().Marked() && qfs[front]->Edge3().Twin()->Adj_Face()->Unmarked() ) { j = m->Face_Id( qfs[front]->Edge3().Twin()->Adj_Face() ); if( qmap[j] == -2 ) { qmap[j] = -1; } else { qmap[j] = qfs.Length(); qmap_idx.Add( j ); } qfs.Add( m->Faces()(j) ); m->Faces()(j)->Mark(); qfs_parents.Add( qfs[front] ); } } else { mark_failed.Add( qfs[front] ); } front++; } // Unmark all the failed faces. for( j = 0; j < mark_failed.Length(); j++ ) { mark_failed[j]->Unmark(); } // Copy the virtual faces for this piece for( j = 0, k = 0; j < chull.Length(); j++ ) { if( chull[j].Unmarked() && cfs[j] == NULL ) { k++; } } created_faces += k; vfs[id].Create( k ); for( j = 0, k = 0; j < chull.Length(); j++ ) { if( chull[j].Unmarked() && cfs[j] == NULL ) { vfs[id][k].Set_Normal_N( chull[j].Normal() ); vfs[id][k].Set_Distance( chull[j].Distance() ); vfs[id][k].Edge1().Set_Direction_N( chull[j].Edge1().Direction() ); vfs[id][k].Edge2().Set_Direction_N( chull[j].Edge2().Direction() ); vfs[id][k].Edge3().Set_Direction_N( chull[j].Edge3().Direction() ); vfs[id][k].Edge1().Set_Length( chull[j].Edge1().Length() ); vfs[id][k].Edge2().Set_Length( chull[j].Edge2().Length() ); vfs[id][k].Edge3().Set_Length( chull[j].Edge3().Length() ); vfs[id][k].Edge1().Set_Origin( chull[j].Edge1().Origin() ); vfs[id][k].Edge2().Set_Origin( chull[j].Edge2().Origin() ); vfs[id][k].Edge3().Set_Origin( chull[j].Edge3().Origin() ); vfs[id][k].Edge1().Set_Twin( chull[j].Edge1().Twin() ); vfs[id][k].Edge2().Set_Twin( chull[j].Edge2().Twin() ); vfs[id][k].Edge3().Set_Twin( chull[j].Edge3().Twin() ); chull[j].Edge1().Twin()->Set_Twin( vfs[id][k].Edge1P() ); chull[j].Edge2().Twin()->Set_Twin( vfs[id][k].Edge2P() ); chull[j].Edge3().Twin()->Set_Twin( vfs[id][k].Edge3P() ); k++; } } // Copy the model faces for this piece temp_mfs_2d[id].Copy_Length( temp_mfs_1d ); id++; // Remove this face from the priority queue Delete_From_Heap( lengths, bmap, fmap, fmap[i] ); } temp_mfs_2d.Set_Length( id ); vfs.Set_Length( id ); // Unmark all the faces and edges for( i = 0; i < m->Num_Faces(); i++ ) { m->Faces()[i].Unmark(); m->Faces()[i].Edge1().Unmark(); m->Faces()[i].Edge2().Unmark(); m->Faces()[i].Edge3().Unmark(); } // Copy the mfs mfs.Copy_Length( temp_mfs_2d ); for( i = 0; i < temp_mfs_2d.Length(); i++ ) { temp_mfs_2d[i].Nullify(); } cerr << "Created " << id << " pieces" << endl; cerr << "Original faces = " << m->Num_Faces() << endl; cerr << "Created virtual faces = " << created_faces << endl << endl; return id; }
int main(int argc, char *argv[]) { FILE *f; struct cli_bc *bc; struct cli_bc_ctx *ctx; int rc, dbgargc, bc_stats=0; struct optstruct *opts; const struct optstruct *opt; unsigned funcid=0, i; struct cli_all_bc bcs; int fd = -1; unsigned tracelevel; if(check_flevel()) exit(1); opts = optparse(NULL, argc, argv, 1, OPT_CLAMBC, 0, NULL); if (!opts) { fprintf(stderr, "ERROR: Can't parse command line options\n"); exit(1); } if(optget(opts, "version")->enabled) { printf("Clam AntiVirus Bytecode Testing Tool %s\n", get_version()); cl_init(CL_INIT_DEFAULT); cli_bytecode_printversion(); optfree(opts); exit(0); } if(optget(opts, "help")->enabled || !opts->filename) { optfree(opts); help(); exit(0); } f = fopen(opts->filename[0], "r"); if (!f) { fprintf(stderr, "Unable to load %s\n", argv[1]); optfree(opts); exit(2); } bc = malloc(sizeof(*bc)); if (!bc) { fprintf(stderr, "Out of memory\n"); optfree(opts); exit(3); } if (optget(opts,"debug")->enabled) { cl_debug(); debug_flag=1; } rc = cl_init(CL_INIT_DEFAULT); if (rc != CL_SUCCESS) { fprintf(stderr,"Unable to init libclamav: %s\n", cl_strerror(rc)); optfree(opts); exit(4); } dbgargc=1; while (opts->filename[dbgargc]) dbgargc++; if (dbgargc > 1) cli_bytecode_debug(dbgargc, opts->filename); if (optget(opts, "force-interpreter")->enabled) { bcs.engine = NULL; } else { rc = cli_bytecode_init(&bcs); if (rc != CL_SUCCESS) { fprintf(stderr,"Unable to init bytecode engine: %s\n", cl_strerror(rc)); optfree(opts); exit(4); } } bcs.all_bcs = bc; bcs.count = 1; if((opt = optget(opts, "statistics"))->enabled) { while(opt) { if (!strcasecmp(opt->strarg, "bytecode")) bc_stats=1; opt = opt->nextarg; } } rc = cli_bytecode_load(bc, f, NULL, optget(opts, "trust-bytecode")->enabled, bc_stats); if (rc != CL_SUCCESS) { fprintf(stderr,"Unable to load bytecode: %s\n", cl_strerror(rc)); optfree(opts); exit(4); } fclose(f); if (bc->state == bc_skip) { fprintf(stderr,"bytecode load skipped\n"); exit(0); } if (debug_flag) printf("[clambc] Bytecode loaded\n"); if (optget(opts, "info")->enabled) { cli_bytecode_describe(bc); } else if (optget(opts, "printsrc")->enabled) { print_src(opts->filename[0]); } else if (optget(opts, "printbcir")->enabled) { cli_bytetype_describe(bc); cli_bytevalue_describe(bc, 0); cli_bytefunc_describe(bc, 0); } else { cli_ctx cctx; struct cl_engine *engine = cl_engine_new(); fmap_t *map = NULL; memset(&cctx, 0, sizeof(cctx)); if (!engine) { fprintf(stderr,"Unable to create engine\n"); optfree(opts); exit(3); } rc = cl_engine_compile(engine); if (rc) { fprintf(stderr,"Unable to compile engine: %s\n", cl_strerror(rc)); optfree(opts); exit(4); } rc = cli_bytecode_prepare2(engine, &bcs, BYTECODE_ENGINE_MASK); if (rc != CL_SUCCESS) { fprintf(stderr,"Unable to prepare bytecode: %s\n", cl_strerror(rc)); optfree(opts); exit(4); } if (debug_flag) printf("[clambc] Bytecode prepared\n"); ctx = cli_bytecode_context_alloc(); if (!ctx) { fprintf(stderr,"Out of memory\n"); exit(3); } ctx->ctx = &cctx; cctx.engine = engine; cctx.fmap = cli_calloc(sizeof(fmap_t*), engine->maxreclevel+2); if (!cctx.fmap) { fprintf(stderr,"Out of memory\n"); exit(3); } memset(&dbg_state, 0, sizeof(dbg_state)); dbg_state.file = "<libclamav>"; dbg_state.line = 0; dbg_state.col = 0; dbg_state.showline = !optget(opts, "no-trace-showsource")->enabled; tracelevel = optget(opts, "trace")->numarg; cli_bytecode_context_set_trace(ctx, tracelevel, tracehook, tracehook_op, tracehook_val, tracehook_ptr); if (opts->filename[1]) { funcid = atoi(opts->filename[1]); } cli_bytecode_context_setfuncid(ctx, bc, funcid); if (debug_flag) printf("[clambc] Running bytecode function :%u\n", funcid); if (opts->filename[1]) { i=2; while (opts->filename[i]) { rc = cli_bytecode_context_setparam_int(ctx, i-2, atoi(opts->filename[i])); if (rc != CL_SUCCESS) { fprintf(stderr,"Unable to set param %u: %s\n", i-2, cl_strerror(rc)); } i++; } } if ((opt = optget(opts,"input"))->enabled) { fd = open(opt->strarg, O_RDONLY); if (fd == -1) { fprintf(stderr, "Unable to open input file %s: %s\n", opt->strarg, strerror(errno)); optfree(opts); exit(5); } map = fmap(fd, 0, 0); if (!map) { fprintf(stderr, "Unable to map input file %s\n", opt->strarg); exit(5); } rc = cli_bytecode_context_setfile(ctx, map); if (rc != CL_SUCCESS) { fprintf(stderr, "Unable to set file %s: %s\n", opt->strarg, cl_strerror(rc)); optfree(opts); exit(5); } } /* for testing */ ctx->hooks.match_counts = deadbeefcounts; ctx->hooks.match_offsets = deadbeefcounts; rc = cli_bytecode_run(&bcs, bc, ctx); if (rc != CL_SUCCESS) { fprintf(stderr,"Unable to run bytecode: %s\n", cl_strerror(rc)); } else { uint64_t v; if (debug_flag) printf("[clambc] Bytecode run finished\n"); v = cli_bytecode_context_getresult_int(ctx); if (debug_flag) printf("[clambc] Bytecode returned: 0x%llx\n", (long long)v); } cli_bytecode_context_destroy(ctx); if (map) funmap(map); cl_engine_free(engine); free(cctx.fmap); } cli_bytecode_destroy(bc); cli_bytecode_done(&bcs); free(bc); optfree(opts); if (fd != -1) close(fd); if (debug_flag) printf("[clambc] Exiting\n"); cl_cleanup_crypto(); return 0; }
int cli_chm_open(int fd, const char *dirname, chm_metadata_t *metadata, cli_ctx *ctx) { struct stat statbuf; int retval; cli_dbgmsg("in cli_chm_open\n"); if ((retval = chm_init_metadata(metadata)) != CL_SUCCESS) { return retval; } if (fstat(fd, &statbuf) == 0) { if (statbuf.st_size < CHM_ITSF_MIN_LEN) { return CL_ESTAT; } metadata->m_length = statbuf.st_size; metadata->map = fmap(fd, 0, metadata->m_length); if (!metadata->map) { return CL_EMAP; } } else { char err[128]; cli_warnmsg("fstat() failed: %s\n", cli_strerror(errno, err, sizeof(err))); return CL_ESTAT; } if (!itsf_read_header(metadata)) { goto abort; } itsf_print_header(&metadata->itsf_hdr); if (!itsp_read_header(metadata, metadata->itsf_hdr.dir_offset)) { goto abort; } itsp_print_header(&metadata->itsp_hdr); metadata->chunk_offset = metadata->itsf_hdr.dir_offset+CHM_ITSP_LEN; /* TODO: need to check this first calculation, currently have no files of this type */ if (metadata->itsp_hdr.index_head > 0) { metadata->chunk_offset += metadata->itsp_hdr.index_head * metadata->itsp_hdr.block_len; } metadata->num_chunks = metadata->itsp_hdr.index_tail - metadata->itsp_hdr.index_head + 1; /* Versions before 3 didn't have a data_offset */ /* TODO: need to check this calculation, currently have no files of this type */ if (metadata->itsf_hdr.version < 3) { metadata->itsf_hdr.data_offset = metadata->itsf_hdr.dir_offset + CHM_ITSP_LEN + (metadata->itsp_hdr.block_len*metadata->itsp_hdr.num_blocks); } while (metadata->num_chunks) { if (read_chunk(metadata) != CL_SUCCESS) { cli_dbgmsg("read_chunk failed\n"); goto abort; } if (read_control_entries(metadata) == FALSE) { goto abort; } metadata->num_chunks--; metadata->chunk_offset += metadata->itsp_hdr.block_len; } if (!metadata->sys_content.length || !metadata->sys_control.length || !metadata->sys_reset.length) { cli_dbgmsg("sys file missing\n"); goto abort; } metadata->ufd = chm_decompress_stream(fd, metadata, dirname, ctx); if (metadata->ufd == -1) { goto abort; } metadata->chunk_entries = 0; metadata->chunk_data = NULL; metadata->chunk_offset = metadata->itsf_hdr.dir_offset+CHM_ITSP_LEN; metadata->num_chunks = metadata->itsp_hdr.index_tail - metadata->itsp_hdr.index_head + 1; return CL_SUCCESS; abort: funmap(metadata->map); return CL_EFORMAT; }
void Main(int argc, char** argv) { std::vector<Patterns> patterns; std::vector<std::string> types; std::string file; std::string algName = "run"; int repCount = 10; ITester::Algorithm alg; for (--argc, ++argv; argc; --argc, ++argv) { if (!strcmp(*argv, "-t") && argc >= 2) { types.push_back(argv[1]); patterns.push_back(Patterns()); --argc, ++argv; } else if (!strcmp(*argv, "-f") && argc >= 2) { file = argv[1]; --argc, ++argv; } else if (!strcmp(*argv, "-a") && argc >= 2) { algName = argv[1]; --argc, ++argv; } else if (!strcmp(*argv, "-c") && argc >= 2) { repCount = Pire::FromString<int>(argv[1]); --argc, ++argv; } else if (!strcmp(*argv, "-e") && argc >= 2) { if (patterns.empty()) throw usage; patterns.back().push_back(argv[1]); --argc, ++argv; } else { if (patterns.empty()) throw usage; patterns.back().push_back(*argv); } } if (types.empty() || file.empty() || patterns.back().empty()) throw usage; if (algName == "run") alg = ITester::DefaultRun; else if (algName == "shortestprefix") alg = ITester::ShortestPrefix; else if (algName == "longestprefix") alg = ITester::LongestPrefix; else throw usage; std::unique_ptr<ITester> tester(CreateTester(types)); tester->Prepare(alg, patterns); FileMmap fmap(file.c_str()); // Run the benchmark multiple times std::ostringstream stream; for (std::vector<std::string>::iterator j = types.begin(), je = types.end(); j != je; ++j) stream << *j << " "; std::string typesName = stream.str(); for (int i = 0; i < repCount; ++i) { Timer timer(typesName, fmap.Size()); tester->Run(fmap.Begin(), fmap.End()); } }
/** Return all servers in cluster */ std::vector<remote::Host> cluster::servers () {return fmap (_host, filter (_isServer, members));}