PrimeTable(T limit) { limit = (limit+31) / 32 * 32; array.resize(limit / 32, -1); setf(0); setf(1); T d, n; for (d=2; d*d<limit; ++d) if(isPrime(d)) { for (n=d+d; n<limit; n+=d) {setf(n);} } plist.push_back(0); for (n=1; n<limit; ++n) { if (isPrime(n)) {plist.push_back(n);} } }
inline void set_timezone(timezone tz) { if (tz == timezone::local) setf(uses_local); else unsetf(uses_local); }
void Shape_GetCenter(avm *vm) { word w; long off = newtable(vm, ZEN_INITIALTABLESIZE); long tindex = TOTinsert(vm, off); ctable* tbl = (ctable*)getdata(vm->hp.heap, off); word index, source; sets(&index, newstring(vm, "X")); setf(&source, sfShape_GetCenterX(getint(vm, 0))); IA(vm, tbl, tindex, &index, &source); sets(&index, newstring(vm, "Y")); setf(&source, sfShape_GetCenterY(getint(vm, 0))); IA(vm, tbl, tindex, &index, &source); sett(&w, tindex); returnv(vm, &w); }
inline void set_duration_style(duration_style style) { if (style == duration_style::symbol) setf(uses_symbol); else unsetf(uses_symbol); }
MyAVIError::MyAVIError(const char *s, uint32 avierr) { const char *err = "(Unknown)"; switch(avierr) { case AVIERR_UNSUPPORTED: err = "unsupported"; break; case AVIERR_BADFORMAT: err = "bad format"; break; case AVIERR_MEMORY: err = "out of memory"; break; case AVIERR_INTERNAL: err = "internal error"; break; case AVIERR_BADFLAGS: err = "bad flags"; break; case AVIERR_BADPARAM: err = "bad parameters"; break; case AVIERR_BADSIZE: err = "bad size"; break; case AVIERR_BADHANDLE: err = "bad AVIFile handle"; break; case AVIERR_FILEREAD: err = "file read error"; break; case AVIERR_FILEWRITE: err = "file write error"; break; case AVIERR_FILEOPEN: err = "file open error"; break; case AVIERR_COMPRESSOR: err = "compressor error"; break; case AVIERR_NOCOMPRESSOR: err = "compressor not available"; break; case AVIERR_READONLY: err = "file marked read-only"; break; case AVIERR_NODATA: err = "no data (?)"; break; case AVIERR_BUFFERTOOSMALL: err = "buffer too small"; break; case AVIERR_CANTCOMPRESS: err = "can't compress (?)"; break; case AVIERR_USERABORT: err = "aborted by user"; break; case AVIERR_ERROR: err = "error (?)"; break; } setf("%s error: %s (%08lx)", s, err, avierr); }
void abstract_broker::init_broker() { CAF_LOG_TRACE(""); setf(is_initialized_flag); // launch backends now, because user-defined initialization // might call functions like add_connection for (auto& kvp : doormen_) kvp.second->launch(); }
void Shape_GetPointPosition(avm *vm) { float X, Y; sfShape_GetPointPosition(getint(vm, 0), getint(vm, 1), &X, &Y); word w; long off = newtable(vm, ZEN_INITIALTABLESIZE); long tindex = TOTinsert(vm, off); ctable* tbl = (ctable*)getdata(vm->hp.heap, off); word index, source; sets(&index, newstring(vm, "X")); setf(&source, X); IA(vm, tbl, tindex, &index, &source); sets(&index, newstring(vm, "Y")); setf(&source, Y); IA(vm, tbl, tindex, &index, &source); sett(&w, tindex); returnv(vm, &w); }
R_API void r_anal_hint_del (RAnal *a, ut64 addr, int size) { char key[128]; if (size>1) { eprintf ("TODO: r_anal_hint_del: in range\n"); } else { setf (key, "hint.0x%08"PFMT64x, addr); sdb_unset (a->sdb_hints, key, 0); } }
R_API RAnalHint *r_anal_hint_get(RAnal *a, ut64 addr) { char key[64]; setf (key, "hint.0x%08"PFMT64x, addr); const char *s = sdb_const_get (DB, key, 0); if (!s) { return NULL; } return r_anal_hint_from_string (a, addr, s); }
void Foam::functionObjects::writeFile::writeHeader ( Ostream& os, const string& str ) const { os << setw(1) << "#" << setw(1) << ' ' << setf(ios_base::left) << setw(charWidth() - 2) << str.c_str() << nl; }
iostream::iostream( streambuf *sb ) { /***********************************/ // Public constructor, making an iostream with a streambuf attached. // No point in calling non-default constructors since there are // multiply-inherited derived classes that will only call the default // constructors anyway. ios::init( sb ); setf( ios::skipws ); }
static void unsetHint(RAnal *a, const char *type, ut64 addr) { int idx; char key[128]; setf (key, "hint.0x%08"PFMT64x, addr); idx = sdb_array_indexof (DB, key, type, 0); if (idx != -1) { sdb_array_delete (DB, key, idx, 0); sdb_array_delete (DB, key, idx, 0); } }
MyICError::MyICError(uint32 icErr, const char *format, ...) { char tmpbuf[1024]; va_list val; va_start(val, format); tmpbuf[(sizeof tmpbuf) - 1] = 0; _vsnprintf(tmpbuf, (sizeof tmpbuf) - 1, format, val); va_end(val); setf(tmpbuf, GetVCMErrorString(icErr)); }
MyInternalError::MyInternalError(const char *format, ...) { char buf[1024]; va_list val; va_start(val, format); _vsnprintf(buf, (sizeof buf) - 1, format, val); buf[1023] = 0; va_end(val); setf("Internal error: %s", buf); }
void Foam::functionObjects::writeFile::writeHeaderValue ( Ostream& os, const string& property, const Type& value ) const { os << setw(1) << '#' << setw(1) << ' ' << setf(ios_base::left) << setw(charWidth() - 2) << property.c_str() << setw(1) << ':' << setw(1) << ' ' << value << nl; }
R_API RAnalHint *r_anal_hint_get(RAnal *a, ut64 addr) { char key[128]; const char *s; RAnalHint *hint; setf (key, "hint.0x%"PFMT64x, addr); s = sdb_const_get (DB, key, 0); if (!s) { return NULL; } hint = r_anal_hint_from_string (a, addr, s); return hint; }
TimeF::TimeF( const t_longf time , const t_longf secondsPerCycle) : m_timer(new osg::Timer()) , m_secondsPerCycle(secondsPerCycle) , m_mode(M_Pausing) , m_offset(0.f) , m_lastModeChangeTime(0.f) , m_utcOffset(0) { initialize(); setf(time, true); }
static void setHint (RAnal *a, const char *type, ut64 addr, const char *s, ut64 ptr) { int idx; char key[128], val[128], *nval = NULL; setf (key, "hint.0x%"PFMT64x, addr); idx = sdb_array_indexof (DB, key, type, 0); if (s) nval = sdb_encode ((const ut8*)s, -1); else nval = sdb_itoa (ptr, val, 16); if (idx != -1) { if (!s) nval = sdb_itoa (ptr, val, 16); sdb_array_set (DB, key, idx+1, nval, 0); } else { sdb_array_push (DB, key, nval, 0); sdb_array_push (DB, key, type, 0); } if (s) free (nval); }
Foam::ensightFile::ensightFile ( const fileName& pathname, IOstream::streamFormat format ) : OFstream(pathname, format) { // ascii formatting specs setf ( ios_base::scientific, ios_base::floatfield ); precision(5); }
MyCrashError::MyCrashError(const char *format, uint32 dwExceptionCode) { const char *s = "(Unknown Exception)"; switch(dwExceptionCode) { case EXCEPTION_ACCESS_VIOLATION: s = "Access Violation"; break; case EXCEPTION_PRIV_INSTRUCTION: s = "Privileged Instruction"; break; case EXCEPTION_INT_DIVIDE_BY_ZERO: s = "Integer Divide By Zero"; break; case EXCEPTION_BREAKPOINT: s = "User Breakpoint"; break; } setf(format, s); }
int main(){ int n; for(int i=1;i<=n;i++) for(int m=1;m<=5;m++) scanf("%d",stu[i][m]); for(int k=1;k<=5;k++){ for(int i=1;i<=9;i++){ int cnt=1; int equ[1001]; for(int m=1;m<=n;m++){ if(stu[m][k]==i) { equ[cnt++]=k; } } setf(equ); } } cntf(); }
MyMMIOError::MyMMIOError(const char *s, uint32 mmioerr) { const char *err = "(Unknown)"; switch(mmioerr) { case MMIOERR_FILENOTFOUND: err = "file not found"; break; case MMIOERR_OUTOFMEMORY: err = "out of memory"; break; case MMIOERR_CANNOTOPEN: err = "couldn't open"; break; case MMIOERR_CANNOTCLOSE: err = "couldn't close"; break; case MMIOERR_CANNOTREAD: err = "couldn't read"; break; case MMIOERR_CANNOTWRITE: err = "couldn't write"; break; case MMIOERR_CANNOTSEEK: err = "couldn't seek"; break; case MMIOERR_CANNOTEXPAND: err = "couldn't expand"; break; case MMIOERR_CHUNKNOTFOUND: err = "chunk not found"; break; case MMIOERR_UNBUFFERED: err = "unbuffered"; break; case MMIOERR_PATHNOTFOUND: err = "path not found"; break; case MMIOERR_ACCESSDENIED: err = "access denied"; break; case MMIOERR_SHARINGVIOLATION: err = "sharing violation"; break; case MMIOERR_NETWORKERROR: err = "network error"; break; case MMIOERR_TOOMANYOPENFILES: err = "too many open files"; break; case MMIOERR_INVALIDFILE: err = "invalid file"; break; } setf("%s error: %s (%ld)", s, err, mmioerr); }
iostream::iostream() { setf( ios::skipws ); }
MyICError::MyICError(const char *s, uint32 icErr) { setf("%s error: %s (error code %ld)", s, GetVCMErrorString(icErr), icErr); }
MyWin32Error::MyWin32Error(const char *format, uint32 err, ...) : mWin32Error(err) { char szError[1024]; char szTemp[1024]; va_list val; va_start(val, err); szError[(sizeof szError)-1] = 0; _vsnprintf(szError, (sizeof szError)-1, format, val); va_end(val); // Determine the position of the last %s, and escape everything else. This doesn't // track escaped % signs properly, but it works for the strings that we receive (and at // worst just produces a funny message). const char *keep = strstr(szError, "%s"); if (keep) { for(;;) { const char *test = strstr(keep + 1, "%s"); if (!test) break; keep = test; } } char *t = szTemp; char *end = szTemp + (sizeof szTemp) - 1; const char *s = szError; while(char c = *s++) { if (c == '%') { // We allow one %s to go through. Everything else gets escaped. if (s-1 != keep) { if (t >= end) break; *t++ = '%'; } } if (t >= end) break; *t++ = c; } *t = 0; if (!FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), szError, sizeof szError, NULL)) { szError[0] = 0; } if (szError[0]) { long l = strlen(szError); if (l>1 && szError[l-2] == '\r') szError[l-2] = 0; else if (szError[l-1] == '\n') szError[l-1] = 0; } setf(szTemp, szError); }
PSR& operator=(uint32 data) { setf(data), sets(data), setx(data), setc(data); return *this; }
static int copen(int startfd, char *fname, int filemode, int createmode) { struct pathname pn; vnode_t *vp, *sdvp; file_t *fp, *startfp; enum vtype type; int error; int fd, dupfd; vnode_t *startvp; proc_t *p = curproc; if (startfd == AT_FDCWD) { /* * Regular open() */ startvp = NULL; } else { /* * We're here via openat() */ char startchar; if (copyin(fname, &startchar, sizeof (char))) return (set_errno(EFAULT)); /* * if startchar is / then startfd is ignored */ if (startchar == '/') startvp = NULL; else { if ((startfp = getf(startfd)) == NULL) return (set_errno(EBADF)); startvp = startfp->f_vnode; VN_HOLD(startvp); releasef(startfd); } } if (filemode & FXATTR) { /* * Make sure we have a valid request. * We must either have a real fd or AT_FDCWD */ if (startfd != AT_FDCWD && startvp == NULL) { error = EINVAL; goto out; } if (error = pn_get(fname, UIO_USERSPACE, &pn)) { goto out; } if (startfd == AT_FDCWD) { mutex_enter(&p->p_lock); startvp = PTOU(p)->u_cdir; VN_HOLD(startvp); mutex_exit(&p->p_lock); } /* * Verify permission to put attributes on file */ if ((VOP_ACCESS(startvp, VREAD, 0, CRED()) != 0) && (VOP_ACCESS(startvp, VWRITE, 0, CRED()) != 0) && (VOP_ACCESS(startvp, VEXEC, 0, CRED()) != 0)) { error = EACCES; pn_free(&pn); goto out; } if ((startvp->v_vfsp->vfs_flag & VFS_XATTR) != 0) { error = VOP_LOOKUP(startvp, "", &sdvp, &pn, LOOKUP_XATTR|CREATE_XATTR_DIR, rootvp, CRED()); } else { error = EINVAL; } pn_free(&pn); if (error != 0) goto out; VN_RELE(startvp); startvp = sdvp; } if ((filemode & (FREAD|FWRITE)) != 0) { if ((filemode & (FNONBLOCK|FNDELAY)) == (FNONBLOCK|FNDELAY)) filemode &= ~FNDELAY; error = falloc((vnode_t *)NULL, filemode, &fp, &fd); if (error == 0) { #ifdef C2_AUDIT if (audit_active) audit_setfsat_path(1); #endif /* C2_AUDIT */ /* * Last arg is a don't-care term if * !(filemode & FCREAT). */ error = vn_openat(fname, UIO_USERSPACE, filemode, (int)(createmode & MODEMASK), &vp, CRCREAT, u.u_cmask, startvp); if (startvp != NULL) VN_RELE(startvp); if (error == 0) { #ifdef C2_AUDIT if (audit_active) audit_copen(fd, fp, vp); #endif /* C2_AUDIT */ if ((vp->v_flag & VDUP) == 0) { fp->f_vnode = vp; mutex_exit(&fp->f_tlock); /* * We must now fill in the slot * falloc reserved. */ setf(fd, fp); return (fd); } else { /* * Special handling for /dev/fd. * Give up the file pointer * and dup the indicated file descriptor * (in v_rdev). This is ugly, but I've * seen worse. */ unfalloc(fp); dupfd = getminor(vp->v_rdev); type = vp->v_type; mutex_enter(&vp->v_lock); vp->v_flag &= ~VDUP; mutex_exit(&vp->v_lock); VN_RELE(vp); if (type != VCHR) return (set_errno(EINVAL)); if ((fp = getf(dupfd)) == NULL) { setf(fd, NULL); return (set_errno(EBADF)); } mutex_enter(&fp->f_tlock); fp->f_count++; mutex_exit(&fp->f_tlock); setf(fd, fp); releasef(dupfd); } return (fd); } else { setf(fd, NULL); unfalloc(fp); return (set_errno(error)); } } } else { error = EINVAL; } out: if (startvp != NULL) VN_RELE(startvp); return (set_errno(error)); }
String (F64 value) { setf("%g", value); }
String (S32 value) { setf("%d", value); }
void Foam::printMeshStats(const polyMesh& mesh, const bool allTopology) { Info<< "Mesh stats" << nl << " points: " << returnReduce(mesh.points().size(), sumOp<label>()) << nl; label nInternalPoints = returnReduce ( mesh.nInternalPoints(), sumOp<label>() ); if (nInternalPoints != -Pstream::nProcs()) { Info<< " internal points: " << nInternalPoints << nl; if (returnReduce(mesh.nInternalPoints(), minOp<label>()) == -1) { WarningIn("Foam::printMeshStats(const polyMesh&, const bool)") << "Some processors have their points sorted into internal" << " and external and some do not." << endl << "This can cause problems later on." << endl; } } if (allTopology && nInternalPoints != -Pstream::nProcs()) { label nEdges = returnReduce(mesh.nEdges(), sumOp<label>()); label nInternalEdges = returnReduce ( mesh.nInternalEdges(), sumOp<label>() ); label nInternal1Edges = returnReduce ( mesh.nInternal1Edges(), sumOp<label>() ); label nInternal0Edges = returnReduce ( mesh.nInternal0Edges(), sumOp<label>() ); Info<< " edges: " << nEdges << nl << " internal edges: " << nInternalEdges << nl << " internal edges using one boundary point: " << nInternal1Edges-nInternal0Edges << nl << " internal edges using two boundary points: " << nInternalEdges-nInternal1Edges << nl; } label nFaces = returnReduce(mesh.faces().size(), sumOp<label>()); label nIntFaces = returnReduce(mesh.faceNeighbour().size(), sumOp<label>()); label nCells = returnReduce(mesh.cells().size(), sumOp<label>()); Info<< " faces: " << nFaces << nl << " internal faces: " << nIntFaces << nl << " cells: " << nCells << nl << " faces per cell: " << scalar(nFaces + nIntFaces)/max(1, nCells) << nl << " boundary patches: " << mesh.boundaryMesh().size() << nl << " point zones: " << mesh.pointZones().size() << nl << " face zones: " << mesh.faceZones().size() << nl << " cell zones: " << mesh.cellZones().size() << nl << endl; // Construct shape recognizers hexMatcher hex; prismMatcher prism; wedgeMatcher wedge; pyrMatcher pyr; tetWedgeMatcher tetWedge; tetMatcher tet; // Counters for different cell types label nHex = 0; label nWedge = 0; label nPrism = 0; label nPyr = 0; label nTet = 0; label nTetWedge = 0; label nUnknown = 0; Map<label> polyhedralFaces; for (label cellI = 0; cellI < mesh.nCells(); cellI++) { if (hex.isA(mesh, cellI)) { nHex++; } else if (tet.isA(mesh, cellI)) { nTet++; } else if (pyr.isA(mesh, cellI)) { nPyr++; } else if (prism.isA(mesh, cellI)) { nPrism++; } else if (wedge.isA(mesh, cellI)) { nWedge++; } else if (tetWedge.isA(mesh, cellI)) { nTetWedge++; } else { nUnknown++; polyhedralFaces(mesh.cells()[cellI].size())++; } } reduce(nHex,sumOp<label>()); reduce(nPrism,sumOp<label>()); reduce(nWedge,sumOp<label>()); reduce(nPyr,sumOp<label>()); reduce(nTetWedge,sumOp<label>()); reduce(nTet,sumOp<label>()); reduce(nUnknown,sumOp<label>()); Info<< "Overall number of cells of each type:" << nl << " hexahedra: " << nHex << nl << " prisms: " << nPrism << nl << " wedges: " << nWedge << nl << " pyramids: " << nPyr << nl << " tet wedges: " << nTetWedge << nl << " tetrahedra: " << nTet << nl << " polyhedra: " << nUnknown << endl; if (nUnknown > 0) { Pstream::mapCombineGather(polyhedralFaces, plusEqOp<label>()); Info<< " Breakdown of polyhedra by number of faces:" << nl << " faces" << " number of cells" << endl; const labelList sortedKeys = polyhedralFaces.sortedToc(); forAll(sortedKeys, keyI) { const label nFaces = sortedKeys[keyI]; Info<< setf(std::ios::right) << setw(13) << nFaces << " " << polyhedralFaces[nFaces] << nl; } }