static char* op(int i) { static char x[20]; switch(i){ case Eap: return "Eap"; case Start: return "Start"; case Logoff: return "Logoff"; case Key: return "Key"; case AsfAlert: return "AsfAlert"; default: sprint(x, "%1d", i); return x; } }
int so_gethostbyname(char *host, char**hostv, int n) { int i; char buf[32]; unsigned char *p; struct hostent *hp; hp = gethostbyname(host); if(hp == 0) return 0; for(i = 0; hp->h_addr_list[i] && i < n; i++) { p = (unsigned char*)hp->h_addr_list[i]; sprint(buf, "%d.%d.%d.%d", p[0], p[1], p[2], p[3]); hostv[i] = strdup(buf); if(hostv[i] == 0) break; } return i; }
bool SMPDebugger::property(unsigned id, string &name, string &value) { unsigned n = 0; //$00f0 if(id == n++) { name = "$00f0"; value = ""; return true; } if(id == n++) { name = "Clock Speed"; value = clock_speed(); return true; } if(id == n++) { name = "Timers Enable"; value = timers_enable(); return true; } if(id == n++) { name = "RAM Disable"; value = ram_disable(); return true; } if(id == n++) { name = "RAM Writable"; value = ram_writable(); return true; } if(id == n++) { name = "Timers Disable"; value = timers_disable(); return true; } //$00f1 if(id == n++) { name = "$00f1"; value = ""; return true; } if(id == n++) { name = "IPLROM Enable"; value = iplrom_enable(); return true; } //$00f2 if(id == n++) { name = "$00f2"; value = ""; return true; } if(id == n++) { name = "DSP Address"; value = sprint("0x", strhex<2>(dsp_address())); return true; } return false; }
int pprint(char *fmt, ...) { ERRSTACK(1); int n; struct chan *c; Osenv *o; va_list arg; char buf[2 * PRINTSIZE]; n = sprint(buf, "%s %ld: ", up->text, up->pid); va_start(arg, fmt); n = vseprintf(buf + n, buf + sizeof(buf), fmt, arg) - buf; va_end(arg); o = up->env; if (o->fgrp == 0) { printd("%s", buf); return 0; } /* TODO: this is probably wrong (VFS hack) */ c = o->fgrp->fd[2]; if (c == 0 || (c->mode != OWRITE && c->mode != ORDWR)) { printd("%s", buf); return 0; } if (waserror()) { printd("%s", buf); poperror(); return 0; } devtab[c->type].write(c, buf, n, c->offset); poperror(); spin_lock(&c->lock); c->offset += n; spin_unlock(&c->lock); return n; }
std::string sprint(const cons_t* p, std::string& s, bool escape) { switch ( type_of(p) ) { case NIL: return s; case BOOLEAN: return s + to_s(p->boolean); case CHAR: return s + to_s(p->character, escape); case REAL: return s + to_s(p->number.real); case INTEGER: return s + to_s(p->number.integer); case RATIONAL: return s + to_s(p->number.rational); case CLOSURE: return s + (escape? to_s(p->closure) : ""); case SYMBOL: return s + *p->symbol; case STRING: return s + (escape? "\"" + encode_str(p->string) + "\"" : p->string); case VECTOR: return s + sprint(p->vector, s, escape); case BYTEVECTOR: return s + sprint(p->bytevector, s, escape); case CONTINUATION: return s + (escape? to_s(p->continuation) : ""); case SYNTAX: return s + sprint(p->syntax->transformer, s, escape); case PORT: return s + sprint(p->port, s, escape); case ENVIRONMENT: return s + sprint(p->environment, s, escape); case POINTER: return s + sprint(p->pointer, s, escape); case PAIR: { std::string head = sprint(car(p), s, escape); std::string tail = sprint(cdr(p), s, escape); bool paren = type_of(car(p))==PAIR; bool dotted = atomp(cdr(p)) && !nullp(cdr(p)) && !emptylistp(cadr(p)); return s + (paren? "(" : "") + head + (paren? ")" : "") + (!tail.empty() ? " " : "") + (dotted? ". " : "") + tail; }} return s; }
void init(void) { int i, fd, nr; Dir *pd; char buf[128]; if((fd = open(dir, OREAD)) < 0) return; nmap = nr = dirreadall(fd, &pd); map = emalloc(nr * sizeof(KbMap)); for(i=0; i<nr; i++){ sprint(buf, "%s/%s", dir, pd[i].name); map[i].file = estrdup(buf); map[i].name = estrdup(pd[i].name); map[i].current = 0; } free(pd); close(fd); }
void das(ulong *x, int n) { ulong pc; Instr i; char buf[128]; pc = (ulong)x; while(n > 0) { i.curr = buf; i.end = buf+sizeof(buf)-1; if(decode(pc, &i) < 0) sprint(buf, "???"); else (*opcodes[i.op].f)(&opcodes[i.op], &i); print("%.8lux %.8lux\t%s\n", pc, i.w, buf); pc += 2; n--; } }
void srvcreate(char *name, int fd) { char *srvname; int f; char buf[64]; srvname = strrchr(name, '/'); if(srvname) srvname++; else srvname = name; snprint(buf, sizeof buf, "#s/%s", srvname); f = create(buf, 1, 0666); if(f < 0) fatal(buf); sprint(buf, "%d", fd); if(write(f, buf, strlen(buf)) != strlen(buf)) fatal("write"); close(f); }
/* * Called only in exec.c:/^run(), from a different FD group */ Mntdir* fsysmount(Rune *dir, int ndir, Rune **incl, int nincl) { char buf[256]; Mntdir *m; /* close server side so don't hang if acme is half-exited */ close(sfd); m = fsysaddid(dir, ndir, incl, nincl); sprint(buf, "%d", m->id); if(mount(cfd, -1, "/mnt/acme", MREPL, buf) < 0) { fsysdelid(m); return nil; } close(cfd); bind("/mnt/acme", "/mnt/wsys", MREPL); if(bind("/mnt/acme", "/dev", MBEFORE) < 0) { fsysdelid(m); return nil; } return m; }
char* tkentrysh(Tk *tk) { TkEntry *tke = TKobj(TkEntry, tk); int dx, top, bot; char *val, *cmd, *v, *e; if(tke->xscroll == nil) return nil; bot = 0; top = Tkfpscalar; if(tke->text != 0 && tke->textlen != 0) { dx = tk->act.width - 2*xinset(tk); if (tke->xlen > dx) { bot = TKI2F(tke->x0) / tke->xlen; top = TKI2F(tke->x0 + dx) / tke->xlen; } } val = mallocz(Tkminitem, 0); if(val == nil) return TkNomem; v = tkfprint(val, bot); *v++ = ' '; tkfprint(v, top); cmd = mallocz(Tkminitem, 0); if(cmd == nil) { free(val); return TkNomem; } sprint(cmd, "%s %s", tke->xscroll, val); e = tkexec(tk->env->top, cmd, nil); free(cmd); free(val); return e; }
int filematch(File *f, String *r) { char *c, buf[STRSIZE+100]; String *t; c = Strtoc(&f->name); sprint(buf, "%c%c%c %s\n", " '"[f->state==Dirty], "-+"[f->rasp!=0], " ."[f==curfile], c); free(c); t = tmpcstr(buf); Strduplstr(&genstr, t); freetmpstr(t); /* A little dirty... */ if(menu == 0) (menu=Fopen())->state=Clean; Bdelete(menu->buf, 0, menu->buf->nrunes); Binsert(menu->buf, &genstr, 0); menu->nrunes = menu->buf->nrunes; compile(r); return execute(menu, 0, menu->nrunes); }
int plumbformat(Plumbmsg *m, int i) { char *addr, *data, *act; int n; data = (char*)plumbbuf[i].data; n = m->ndata; if(n == 0 || 2+n+2 >= READBUFSIZE){ plumbfree(m); return 0; } act = plumblookup(m->attr, "action"); if(act!=nil && strcmp(act, "showfile")!=0){ /* can't handle other cases yet */ plumbfree(m); return 0; } addr = plumblookup(m->attr, "addr"); if(addr){ if(addr[0] == '\0') addr = nil; else addr = strdup(addr); /* copy to safe storage; we'll overwrite data */ } memmove(data, "B ", 2); /* we know there's enough room for this */ memmove(data+2, m->data, n); n += 2; if(data[n-1] != '\n') data[n++] = '\n'; if(addr != nil){ if(n+strlen(addr)+1+1 <= READBUFSIZE) n += sprint(data+n, "%s\n", addr); free(addr); } plumbbuf[i].n = n; plumbfree(m); return 1; }
void center(Font *f, Point p, char *s, Image *color) { int i, n, dx; Rune rbuf[32]; char sbuf[32*UTFmax+1]; dx = stringwidth(f, s); if(dx > Facesize){ n = torune(rbuf, s, nelem(rbuf)); for(i=0; i<n; i++){ dx = runestringnwidth(f, rbuf, i+1); if(dx > Facesize) break; } sprint(sbuf, "%.*S", i, rbuf); s = sbuf; dx = stringwidth(f, s); } p.x += (Facesize-dx)/2; string(screen, p, color, ZP, f, s); }
int main(int argc, const char * argv[]) { int q; for(q=0;q<4000000;q++){ lib[q]=-1; } while (1) { int i=1; char s[1001]; sprint(s,itoa(memoFibo(i))); if(strlen(s)>=1000){ printf("%d\n", i); break; } } printf("%d\n", naiveFiboSum(4000000)); return 0; }
Runestr includefile(Rune *dir, Rune *file, int nfile) { int m, n; char *a; Rune *r; static Rune Lslash[] = { '/', 0 }; m = runestrlen(dir); a = emalloc((m+1+nfile)*UTFmax+1); sprint(a, "%S/%.*S", dir, nfile, file); n = access(a, 0); free(a); if(n < 0) return runestr(nil, 0); r = runemalloc(m+1+nfile); runemove(r, dir, m); runemove(r+m, Lslash, 1); runemove(r+m+1, file, nfile); free(file); return cleanrname(runestr(r, m+1+nfile)); }
int Nconv(Fmt *fp) { char str[STRINGSZ]; Adr *a; Sym *s; a = va_arg(fp->args, Adr*); s = a->sym; if(s == S) { sprint(str, "%lld", a->offset); goto out; } switch(a->name) { default: sprint(str, "GOK-name(%d)", a->name); break; case D_NONE: sprint(str, "%lld", a->offset); break; case D_EXTERN: sprint(str, "%s+%lld(SB)", s->name, a->offset); break; case D_STATIC: sprint(str, "%s<>+%lld(SB)", s->name, a->offset); break; case D_AUTO: sprint(str, "%s-%lld(SP)", s->name, -a->offset); break; case D_PARAM: sprint(str, "%s+%lld(FP)", s->name, a->offset); break; } out: return fmtstrcpy(fp, str); }
// // download a single message // static char* imap4fetch(Mailbox *mb, Message *m) { int i; char *p, *s, sdigest[2*SHA1dlen+1]; Imap *imap; imap = mb->aux; imap->size = 0; if(!isokay(s = imap4resp(imap))) return s; p = imap->base; if(p == nil) return "did not get message body"; removecr(p); free(m->start); m->start = p; m->end = p+strlen(p); m->bend = m->rbend = m->end; m->header = m->start; imap->base = nil; imap->data = nil; parse(m, 0, mb, 1); // digest headers sha1((uchar*)m->start, m->end - m->start, m->digest, nil); for(i = 0; i < SHA1dlen; i++) sprint(sdigest+2*i, "%2.2ux", m->digest[i]); m->sdigest = s_copy(sdigest); return nil; }
static void fault386(Ureg* ureg, void*) { ulong addr; int read, user, n, insyscall; char buf[ERRMAX]; addr = getcr2(); read = !(ureg->ecode & 2); user = (ureg->cs & 0xFFFF) == UESEL; if(!user){ if(vmapsync(addr)) return; if(addr >= USTKTOP) panic("kernel fault: bad address pc=0x%.8lux addr=0x%.8lux", ureg->pc, addr); if(up == nil) panic("kernel fault: no user process pc=0x%.8lux addr=0x%.8lux", ureg->pc, addr); } if(up == nil) panic("user fault: up=0 pc=0x%.8lux addr=0x%.8lux", ureg->pc, addr); insyscall = up->insyscall; up->insyscall = 1; n = fault(addr, read); if(n < 0){ if(!user){ dumpregs(ureg); panic("fault: 0x%lux", addr); } checkpages(); checkfault(addr, ureg->pc); sprint(buf, "sys: trap: fault %s addr=0x%lux", read ? "read" : "write", addr); postnote(up, 1, buf, NDebug); } up->insyscall = insyscall; }
int pprint(char *fmt, ...) { int n; Chan *c; Osenv *o; va_list arg; char buf[2*PRINTSIZE]; n = sprint(buf, "%s %ld: ", up->text, up->pid); va_start(arg, fmt); n = vseprint(buf+n, buf+sizeof(buf), fmt, arg) - buf; va_end(arg); o = up->env; if(o->fgrp == 0) { print("%s", buf); return 0; } c = o->fgrp->fd[2]; if(c==0 || (c->mode!=OWRITE && c->mode!=ORDWR)) { print("%s", buf); return 0; } if(waserror()) { print("%s", buf); return 0; } devtab[c->type]->write(c, buf, n, c->offset); poperror(); lock(c); c->offset += n; unlock(c); return n; }
void startpcs(void) { if ((pid = fork()) == 0) { pid = getpid(); msgpcs("hang"); doexec(); exits(0); } if (pid == -1) error("can't fork"); child++; sprint(procname, "/proc/%d/mem", pid); corfil = procname; msgpcs("waitstop"); bpwait(); if (adrflg) rput(cormap, mach->pc, adrval); while (rdc() != EOR) ; reread(); }
std::string sprint(const vector_t* v, std::string& r, bool) { const std::vector<cons_t*>& p = v->vector; std::string s; s += "#("; for ( std::vector<cons_t*>::const_iterator i = p.begin(); i != p.end(); ++i ) { if ( i != p.begin() ) s += " "; if ( listp(*i) ) s += "("; if ( nullp(*i) ) s += to_s(*i); else s += sprint(*i, r, true); if ( listp(*i) ) s += ")"; } s += ")"; return s; }
int main( void ) { printf("snoc list:\n"); char name[] = "Kate"; snoc_list res0 = snoc( snoc( snoc( snoc(NULL, name), name + 1), name + 2), name + 3); sprint( print_char, res0 ); printf("\n"); printf("\nntree :\n"); ntree res1 = br(snoc( snoc( NULL, lf(1) ), lfs( 3, 2, 3, 4 ))); nprint( res1 ); printf("\n"); return 0; }
void wikithread(void *v) { char tmp[40]; Event *e; Wiki *w; w = v; if(w->isnew){ sprint(tmp, "+new+%d", w->isnew); wikiname(w->win, tmp); if(w->arg){ winopenbody(w->win, OWRITE); Bprint(w->win->body, "%s\n\n", w->arg); } winclean(w->win); }else if(!w->special){ wikiget(w); wikiname(w->win, w->arg); if(w->addr) winselect(w->win, w->addr, 1); } fprint(w->win->ctl, "menu\n"); wintagwrite(w->win, "Get History Diff New", 4+8+4+4); winclean(w->win); while(!w->dead && (e = recvp(w->win->cevent))) acmeevent(w, e); windormant(w->win); unlink(w); free(w->win); free(w->arg); free(w); threadexits(nil); }
static uint dumpsome(char *ans, char *e, char *buf, int32_t count) { int i, printable; char *p; if(buf == nil){ seprint(ans, e, "<no data>"); return strlen(ans); } printable = 1; if(count > DUMPL) count = DUMPL; for(i=0; i<count && printable; i++) if((buf[i]<32 && buf[i] !='\n' && buf[i] !='\t') || (uint8_t)buf[i]>127) printable = 0; p = ans; *p++ = '\''; if(printable){ if(count > e-p-2) count = e-p-2; memmove(p, buf, count); p += count; }else{ if(2*count > e-p-2) count = (e-p-2)/2; for(i=0; i<count; i++){ if(i>0 && i%4==0) *p++ = ' '; sprint(p, "%2.2ux", buf[i]); p += 2; } } *p++ = '\''; *p = 0; return p - ans; }
char * rewritezone(char *z) { int mindiff; char s; Tm *tm; static char x[7]; tm = localtime(time(0)); mindiff = tm->tzoff/60; /* if not in my timezone, don't change anything */ if(strcmp(tm->zone, z) != 0) return z; if(mindiff < 0){ s = '-'; mindiff = -mindiff; } else s = '+'; sprint(x, "%c%.2d%.2d", s, mindiff/60, mindiff%60); return x; }
char* dm(Angle a) { static char buf[20]; double x; int sign, d, m, n; x = DEG(a); sign='+'; if(a<0){ sign='-'; x=-x; } x += 0.5/600.; /* round up half of tenth of arcminute */ d = floor(x); x -= d; x *= 60; m = floor(x); x -= m; x *= 10; n = floor(x); sprint(buf, "%c%d°%.2d.%.1d'", sign, d, m, n); return buf; }
void update1(Graph *g, uint64_t v, uint64_t vmax) { char buf[48]; int overflow; if(g->overflow && g->overtmp!=nil) draw(screen, g->overtmp->r, g->overtmp, nil, g->overtmp->r.min); draw(screen, g->r, screen, nil, Pt(g->r.min.x+1, g->r.min.y)); drawdatum(g, g->r.max.x-1, g->data[0], v, vmax); memmove(g->data+1, g->data, (g->ndata-1)*sizeof(g->data[0])); g->data[0] = v; g->overflow = 0; if(logscale) overflow = (v>10*vmax*scale); else overflow = (v>vmax*scale); if(overflow && g->overtmp!=nil){ g->overflow = 1; draw(g->overtmp, g->overtmp->r, screen, nil, g->overtmp->r.min); sprint(buf, "%llu", v); string(screen, g->overtmp->r.min, display->black, ZP, mediumfont, buf); } }
Tree * flatten(Tree *t) { static gensym; Sym *s; Tree *v; char buf[10]; v = 0; if (t == 0) return t; if (t->vis) { sprint(buf, "G%3.3d", gensym++); s = lookup(buf); s->exp = t; s->internal = 1; s->lval = 1; s->rval = 1; v = idnode(s, 0); } switch (t->op) { case C0: case C1: case ID: return t; case xor: case and: case or: t->right = flatten(t->right); case not: t->left = flatten(t->left); return t->vis ? v : t; default: yyerror("flatten: unknown op %d", t->op); } return t; }
/* * lookup a subnet and fill in anything we can */ static void recursesubnet(Ndb *db, uint8_t *mask, Ipinfo *iip, char *fs, char *gw, char *au) { Ndbs s; Ndbtuple *t; uint8_t submask[IPaddrlen]; char ip[Ndbvlen]; memmove(iip->ipmask, mask, 4); maskip(iip->ipaddr, iip->ipmask, iip->ipnet); sprint(ip, "%I", iip->ipnet); t = ndbsearch(db, &s, "ip", ip); print("%s->", ip); if(t){ /* look for a further subnet */ if(lookval(t, s.t, "ipmask", ip)){ parseip(submask, ip); /* recurse only if it has changed */ if(!equivip(submask, mask)) recursesubnet(db, submask, iip, fs, gw, au); } /* fill in what we don't have */ if(gw[0] == 0) lookval(t, s.t, "ipgw", gw); if(fs[0] == 0) lookval(t, s.t, "fs", fs); if(au[0] == 0) lookval(t, s.t, "auth", au); ndbfree(t); } }
char* plumbpack(Plumbmsg *m, int *np) { int n, ndata; char *buf, *p, *attr; ndata = m->ndata; if(ndata < 0) ndata = Strlen(m->data); attr = plumbpackattr(m->attr); n = Strlen(m->src)+1 + Strlen(m->dst)+1 + Strlen(m->wdir)+1 + Strlen(m->type)+1 + Strlen(attr)+1 + 16 + ndata; buf = malloc(n+1); /* +1 for '\0' */ if(buf == nil){ free(attr); return nil; } p = Strcpy(buf, m->src); *p++ = '\n'; p = Strcpy(p, m->dst); *p++ = '\n'; p = Strcpy(p, m->wdir); *p++ = '\n'; p = Strcpy(p, m->type); *p++ = '\n'; p = Strcpy(p, attr); *p++ = '\n'; p += sprint(p, "%d\n", ndata); memmove(p, m->data, ndata); *np = (p-buf)+ndata; buf[*np] = '\0'; /* null terminate just in case */ if(*np >= n+1) abort(); free(attr); return buf; }