Exemple #1
0
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;
	}
}
Exemple #2
0
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;
}
Exemple #3
0
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;
}
Exemple #4
0
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;
}
Exemple #5
0
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;
}
Exemple #6
0
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);
}
Exemple #7
0
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--;
	}
}
Exemple #8
0
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);
}
Exemple #9
0
/*
 * 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;
}
Exemple #10
0
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;
}
Exemple #11
0
Fichier : address.c Projet : 8l/sam
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);
}
Exemple #12
0
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;
}
Exemple #13
0
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);
}
Exemple #14
0
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;
}
Exemple #15
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));
}
Exemple #16
0
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);
}
Exemple #17
0
//
// 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;
}
Exemple #18
0
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;
}
Exemple #19
0
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;
}
Exemple #20
0
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();
}
Exemple #21
0
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;
}
Exemple #22
0
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;
}
Exemple #23
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);
}
Exemple #24
0
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;
}
Exemple #25
0
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;
}
Exemple #26
0
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;
}
Exemple #27
0
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);
	}
}
Exemple #28
0
Fichier : mach.c Projet : kahrs/cda
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;
}
Exemple #29
0
/*
 *  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);
	}
}
Exemple #30
0
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;
}