static void ipclose(Chan* c) { Fs *f; f = ipfs[c->dev]; switch(TYPE(c->qid)) { default: break; case Qlog: if(c->flag & COPEN) netlogclose(f); break; case Qdata: case Qctl: case Qerr: if(c->flag & COPEN) closeconv(f->p[PROTO(c->qid)]->conv[CONV(c->qid)]); break; case Qsnoop: if(c->flag & COPEN) decref(&f->p[PROTO(c->qid)]->conv[CONV(c->qid)]->snoopers); break; } free(((IPaux*)c->aux)->owner); free(c->aux); }
int prepare_default_response(char *filename, uint16_t port, uint16_t proto) { int answer_fd, ccopy; u_char buffer[100]; FILE* answer_file = NULL; def_resp *last_response, *new_response; /* allocate memory for new response */ if ((new_response = (def_resp *) malloc(sizeof(struct def_resp))) == NULL) { perror(" Error - Unable to allocate memory"); return(-1); } else { new_response->port = port; new_response->proto = proto; new_response->size = 0; new_response->response = NULL; new_response->next = NULL; } if (!response_list) response_list = new_response; else { /* spool to end of the list and attach new response */ last_response = response_list; while (last_response->next) last_response = last_response->next; last_response->next = new_response; } /* read response */ if ((proto != TCP) && (proto != UDP)) { fprintf(stderr, " Error - Protocol %u is not supported.\n", proto); return(-1); } DEBUG_FPRINTF(stdout, " Loading default response for port %u/%s.\n", port, PROTO(proto)); if (((answer_fd = open(filename, O_NOCTTY | O_RDONLY, 0640)) == -1) || (!(answer_file = fopen(filename, "rb")))) { DEBUG_FPRINTF(stdout, " Warning - Unable to open file '%s'\n", filename); } else { ccopy = 0; while((ccopy = fread(buffer, 1, 100, answer_file))) { if ((new_response->response = (u_char *) realloc(new_response->response, new_response->size + ccopy)) == NULL) { perror(" Error - Unable to allocate memory"); return(-1); } else { memcpy(new_response->response + new_response->size, buffer, ccopy); new_response->size += ccopy; } } if (new_response->size != 0) { DEBUG_FPRINTF(stdout, " Default response string for port %u/%s successfully loaded.\n", port, PROTO(proto)); } else DEBUG_FPRINTF(stdout, " Warning - Default response file '%s' is empty.\n", filename); } fclose(answer_file); close(answer_fd); return(0); }
long ipread(Chan *ch, void *a, long n, vlong offset) { int r; Conv *c; Proto *x; uchar ip[4]; char buf[128], *p; /*print("ipread %s %lux\n", c2name(ch), (long)ch->qid.path);*/ p = a; switch(TYPE(ch->qid)) { default: error(Eperm); case Qcs: return csread(ch, a, n, offset); case Qprotodir: case Qtopdir: case Qconvdir: return devdirread(ch, a, n, 0, 0, ipgen); case Qctl: sprint(buf, "%d", CONV(ch->qid)); return readstr(offset, p, n, buf); case Qremote: c = proto[PROTO(ch->qid)].conv[CONV(ch->qid)]; hnputl(ip, c->raddr); sprint(buf, "%I!%d\n", ip, c->rport); return readstr(offset, p, n, buf); case Qlocal: c = proto[PROTO(ch->qid)].conv[CONV(ch->qid)]; hnputl(ip, c->laddr); sprint(buf, "%I!%d\n", ip, c->lport); return readstr(offset, p, n, buf); case Qstatus: x = &proto[PROTO(ch->qid)]; c = x->conv[CONV(ch->qid)]; sprint(buf, "%s/%d %d %s \n", c->p->name, c->x, c->r.ref, c->state); return readstr(offset, p, n, buf); case Qdata: c = proto[PROTO(ch->qid)].conv[CONV(ch->qid)]; r = so_recv(c->sfd, a, n, 0); if(r < 0){ oserrstr(); nexterror(); } return r; } }
static long ipbwrite(Chan* ch, Block* bp, ulong offset) { Conv *c; Proto *x; Fs *f; int n; switch(TYPE(ch->qid)){ case Qdata: f = ipfs[ch->dev]; x = f->p[PROTO(ch->qid)]; c = x->conv[CONV(ch->qid)]; if(c->wq == nil) error(Eperm); if(bp->next) bp = concatblock(bp); n = BLEN(bp); qbwrite(c->wq, bp); return n; default: return devbwrite(ch, bp, offset); } }
static int ipwstat(Chan *c, uchar *dp, int n) { Dir d; Conv *cv; Fs *f; Proto *p; f = ipfs[c->dev]; switch(TYPE(c->qid)) { default: error(Eperm); break; case Qctl: case Qdata: break; } n = convM2D(dp, n, &d, nil); if(n > 0){ p = f->p[PROTO(c->qid)]; cv = p->conv[CONV(c->qid)]; if(!iseve() && strcmp(ATTACHER(c), cv->owner) != 0) error(Eperm); if(d.uid[0]) kstrdup(&cv->owner, d.uid); cv->perm = d.mode & 0777; } return n; }
void ipclose(Chan *c) { Conv *cc; switch(TYPE(c->qid)) { case Qcs: csclose(c); break; case Qdata: case Qctl: if((c->flag & COPEN) == 0) break; cc = proto[PROTO(c->qid)].conv[CONV(c->qid)]; if(decref(&cc->r) != 0) break; strcpy(cc->owner, "network"); cc->perm = 0666; cc->state = "Closed"; cc->laddr = 0; cc->raddr = 0; cc->lport = 0; cc->rport = 0; close(cc->sfd); break; } }
static int ip2gen(Chan *c, int i, Dir *dp) { Qid q; switch(i) { case Qclone: mkqid(&q, QID(PROTO(c->qid), 0, Qclone), 0, QTFILE); devdir(c, q, "clone", 0, network, 0666, dp); return 1; case Qstats: mkqid(&q, QID(PROTO(c->qid), 0, Qstats), 0, QTFILE); devdir(c, q, "stats", 0, network, 0444, dp); return 1; } return -1; }
static int ip3gen(Chan *c, int i, Dir *dp) { Qid q; Conv *cv; char *p; cv = ipfs[c->dev]->p[PROTO(c->qid)]->conv[CONV(c->qid)]; if(cv->owner == nil) kstrdup(&cv->owner, eve); mkqid(&q, QID(PROTO(c->qid), CONV(c->qid), i), 0, QTFILE); switch(i) { default: return -1; case Qctl: devdir(c, q, "ctl", 0, cv->owner, cv->perm, dp); return 1; case Qdata: devdir(c, q, "data", qlen(cv->rq), cv->owner, cv->perm, dp); return 1; case Qerr: devdir(c, q, "err", qlen(cv->eq), cv->owner, cv->perm, dp); return 1; case Qlisten: devdir(c, q, "listen", 0, cv->owner, cv->perm, dp); return 1; case Qlocal: p = "local"; break; case Qremote: p = "remote"; break; case Qsnoop: if(strcmp(cv->p->name, "ipifc") != 0) return -1; devdir(c, q, "snoop", qlen(cv->sq), cv->owner, 0400, dp); return 1; case Qstatus: p = "status"; break; } devdir(c, q, p, 0, cv->owner, 0444, dp); return 1; }
static void ipclose(Chan *c) { Fs *f; f = ipfs[c->dev]; switch(TYPE(c->qid)) { case Qdata: case Qctl: if(c->flag & COPEN) closeconv(f->p[PROTO(c->qid)]->conv[CONV(c->qid)]); break; } }
static Block* ipbread(Chan* ch, long n, ulong offset) { Conv *c; Proto *x; Fs *f; switch(TYPE(ch->qid)){ case Qdata: f = ipfs[ch->dev]; x = f->p[PROTO(ch->qid)]; c = x->conv[CONV(ch->qid)]; return qbread(c->rq, n); default: return devbread(ch, n, offset); } }
static int ipwstat(Chan *c, uchar *dp, int n) { Dir *d; Conv *cv; Proto *p; Fs *f; f = ipfs[c->dev]; switch(TYPE(c->qid)) { default: error(Eperm); break; case Qctl: case Qdata: break; } d = smalloc(sizeof(*d)+n); if(waserror()){ free(d); nexterror(); } n = convM2D(dp, n, d, (char*)&d[1]); if(n == 0) error(Eshortstat); p = f->p[PROTO(c->qid)]; cv = p->conv[CONV(c->qid)]; if(!iseve() && strcmp(up->env->user, cv->owner) != 0) error(Eperm); if(!emptystr(d->uid)) kstrdup(&cv->owner, d->uid); if(d->mode != ~0UL) cv->perm = d->mode & 0777; poperror(); free(d); return n; }
{STRKEY("SEEK_SET"), INT(SEEK_SETValue)}, {STRKEY("SEEK_CUR"), INT(SEEK_CURValue)}, {STRKEY("SEEK_END"), INT(SEEK_ENDValue)}, {STRKEY("BUFSIZ"), INT(BUFSIZValue)}, {STRKEY("FILENAME_MAX"), INT(FILENAME_MAXValue)}, {STRKEY("_IOFBF"), INT(_IOFBFValue)}, {STRKEY("_IOLBF"), INT(_IOLBFValue)}, {STRKEY("_IONBF"), INT(_IONBFValue)}, {STRKEY("L_tmpnam"), INT(L_tmpnamValue)}, {STRKEY("GETS_MAX"), INT(GETS_MAXValue)}, {NILKEY, NILVAL} }; /* all stdio functions */ const PICOC_REG_TYPE StdioFunctions[] = { { FUNC(StdioFopen), PROTO("FILE *fopen(char *, char *);") }, { FUNC(StdioFreopen), PROTO("FILE *freopen(char *, char *, FILE *);") }, { FUNC(StdioFclose), PROTO("int fclose(FILE *);") }, { FUNC(StdioFread), PROTO("int fread(void *, int, int, FILE *);") }, { FUNC(StdioFwrite), PROTO("int fwrite(void *, int, int, FILE *);") }, { FUNC(StdioFgetc), PROTO("int fgetc(FILE *);") }, { FUNC(StdioFgetc), PROTO("int getc(FILE *);") }, { FUNC(StdioFgets), PROTO("char *fgets(char *, int, FILE *);") }, { FUNC(StdioFputc), PROTO("int fputc(int, FILE *);") }, { FUNC(StdioFputs), PROTO("int fputs(char *, FILE *);") }, { FUNC(StdioRemove), PROTO("int remove(char *);") }, { FUNC(StdioRename), PROTO("int rename(char *, char *);") }, { FUNC(StdioRewind), PROTO("void rewind(FILE *);") }, { FUNC(StdioTmpfile), PROTO("FILE *tmpfile();") }, { FUNC(StdioClearerr), PROTO("void clearerr(FILE *);") }, { FUNC(StdioFeof), PROTO("int feof(FILE *);") },
static int ipgen(Chan *c, char *name, Dirtab *tab, int x, int s, Dir *dp) { Qid q; Conv *cv; Fs *f; USED(name); USED(tab); USED(x); f = ipfs[c->dev]; switch(TYPE(c->qid)) { case Qtopdir: if(s == DEVDOTDOT){ mkqid(&q, QID(0, 0, Qtopdir), 0, QTDIR); sprint(up->genbuf, "#I%lud", c->dev); devdir(c, q, up->genbuf, 0, network, 0555, dp); return 1; } if(s < f->np) { /* if(f->p[s]->connect == nil) return 0; /* protocol with no user interface */ mkqid(&q, QID(s, 0, Qprotodir), 0, QTDIR); devdir(c, q, f->p[s]->name, 0, network, 0555, dp); return 1; } s -= f->np; return ip1gen(c, s+Qtopbase, dp); case Qarp: case Qndb: /* case Qiproute: case Qiprouter: case Qipselftab: */ return ip1gen(c, TYPE(c->qid), dp); case Qprotodir: if(s == DEVDOTDOT){ mkqid(&q, QID(0, 0, Qtopdir), 0, QTDIR); sprint(up->genbuf, "#I%lud", c->dev); devdir(c, q, up->genbuf, 0, network, 0555, dp); return 1; } if(s < f->p[PROTO(c->qid)]->ac) { cv = f->p[PROTO(c->qid)]->conv[s]; sprint(up->genbuf, "%d", s); mkqid(&q, QID(PROTO(c->qid), s, Qconvdir), 0, QTDIR); devdir(c, q, up->genbuf, 0, cv->owner, 0555, dp); return 1; } s -= f->p[PROTO(c->qid)]->ac; return ip2gen(c, s+Qprotobase, dp); case Qclone: case Qstats: return ip2gen(c, TYPE(c->qid), dp); case Qconvdir: if(s == DEVDOTDOT){ s = PROTO(c->qid); mkqid(&q, QID(s, 0, Qprotodir), 0, QTDIR); devdir(c, q, f->p[s]->name, 0, network, 0555, dp); return 1; } return ip3gen(c, s+Qconvbase, dp); case Qctl: case Qdata: case Qlisten: case Qlocal: case Qremote: case Qstatus: return ip3gen(c, TYPE(c->qid), dp); } return -1; }
int ipgen(Chan *c, char *nname, Dirtab *d, int nd, int s, Dir *dp) { Qid q; Conv *cv; char *p; USED(nname); q.vers = 0; q.type = 0; switch(TYPE(c->qid)) { case Qtopdir: if(s >= 1+np) return -1; if(s == 0){ q.path = QID(s, 0, Qcs); devdir(c, q, "cs", 0, "network", 0666, dp); }else{ s--; q.path = QID(s, 0, Qprotodir); q.type = QTDIR; devdir(c, q, proto[s].name, 0, "network", DMDIR|0555, dp); } return 1; case Qprotodir: if(s < proto[PROTO(c->qid)].nc) { cv = proto[PROTO(c->qid)].conv[s]; sprint(up->genbuf, "%d", s); q.path = QID(PROTO(c->qid), s, Qconvdir); q.type = QTDIR; devdir(c, q, up->genbuf, 0, cv->owner, DMDIR|0555, dp); return 1; } s -= proto[PROTO(c->qid)].nc; switch(s) { default: return -1; case 0: p = "clone"; q.path = QID(PROTO(c->qid), 0, Qclonus); break; } devdir(c, q, p, 0, "network", 0555, dp); return 1; case Qconvdir: cv = proto[PROTO(c->qid)].conv[CONV(c->qid)]; switch(s) { default: return -1; case 0: q.path = QID(PROTO(c->qid), CONV(c->qid), Qdata); devdir(c, q, "data", 0, cv->owner, cv->perm, dp); return 1; case 1: q.path = QID(PROTO(c->qid), CONV(c->qid), Qctl); devdir(c, q, "ctl", 0, cv->owner, cv->perm, dp); return 1; case 2: p = "status"; q.path = QID(PROTO(c->qid), CONV(c->qid), Qstatus); break; case 3: p = "remote"; q.path = QID(PROTO(c->qid), CONV(c->qid), Qremote); break; case 4: p = "local"; q.path = QID(PROTO(c->qid), CONV(c->qid), Qlocal); break; case 5: p = "listen"; q.path = QID(PROTO(c->qid), CONV(c->qid), Qlisten); break; } devdir(c, q, p, 0, cv->owner, 0444, dp); return 1; } return -1; }
long ipwrite(Chan *ch, void *a, long n, vlong offset) { Conv *c; Proto *x; int r, nf; char *p, *fields[3], buf[128]; switch(TYPE(ch->qid)) { default: error(Eperm); case Qcs: return cswrite(ch, a, n, offset); case Qctl: x = &proto[PROTO(ch->qid)]; c = x->conv[CONV(ch->qid)]; if(n > sizeof(buf)-1) n = sizeof(buf)-1; memmove(buf, a, n); buf[n] = '\0'; nf = tokenize(buf, fields, 3); if(strcmp(fields[0], "connect") == 0){ switch(nf) { default: error("bad args to connect"); case 2: p = setraddrport(c, fields[1]); if(p != 0) error(p); break; case 3: p = setraddrport(c, fields[1]); if(p != 0) error(p); c->lport = atoi(fields[2]); setlport(c); break; } so_connect(c->sfd, c->raddr, c->rport); setladdr(c); c->state = "Established"; return n; } if(strcmp(fields[0], "announce") == 0) { switch(nf){ default: error("bad args to announce"); case 2: setladdrport(c, fields[1]); break; } so_listen(c->sfd); c->state = "Announced"; return n; } if(strcmp(fields[0], "bind") == 0){ switch(nf){ default: error("bad args to bind"); case 2: c->lport = atoi(fields[1]); break; } setlport(c); return n; } error("bad control message"); case Qdata: x = &proto[PROTO(ch->qid)]; c = x->conv[CONV(ch->qid)]; r = so_send(c->sfd, a, n, 0); if(r < 0){ oserrstr(); nexterror(); } return r; } return n; }
EXPORT ptr Sinvoke2_stdcall(ptr code, ptr x1, iptr x2) { return (*((ptr (__stdcall *) PROTO((ptr, iptr)))Sforeign_callable_entry_point(code)))(x1, x2); }
static long ipread(Chan *ch, void *a, long n, vlong off) { Conv *c; Proto *x; char *buf, *p; long rv; Fs *f; ulong offset = off; f = ipfs[ch->dev]; p = a; switch(TYPE(ch->qid)) { default: error(Eperm); case Qtopdir: case Qprotodir: case Qconvdir: return devdirread(ch, a, n, 0, 0, ipgen); case Qarp: return arpread(f->arp, a, offset, n); case Qbootp: return bootpread(a, offset, n); case Qndb: return readstr(offset, a, n, f->ndb); case Qiproute: return routeread(f, a, offset, n); case Qipselftab: return ipselftabread(f, a, offset, n); case Qlog: return netlogread(f, a, offset, n); case Qctl: buf = smalloc(16); snprint(buf, 16, "%lud", CONV(ch->qid)); rv = readstr(offset, p, n, buf); free(buf); return rv; case Qremote: buf = smalloc(Statelen); x = f->p[PROTO(ch->qid)]; c = x->conv[CONV(ch->qid)]; if(x->remote == nil) { snprint(buf, Statelen, "%I!%d\n", c->raddr, c->rport); } else { (*x->remote)(c, buf, Statelen-2); } rv = readstr(offset, p, n, buf); free(buf); return rv; case Qlocal: buf = smalloc(Statelen); x = f->p[PROTO(ch->qid)]; c = x->conv[CONV(ch->qid)]; if(x->local == nil) { snprint(buf, Statelen, "%I!%d\n", c->laddr, c->lport); } else { (*x->local)(c, buf, Statelen-2); } rv = readstr(offset, p, n, buf); free(buf); return rv; case Qstatus: buf = smalloc(Statelen); x = f->p[PROTO(ch->qid)]; c = x->conv[CONV(ch->qid)]; (*x->state)(c, buf, Statelen-2); rv = readstr(offset, p, n, buf); free(buf); return rv; case Qdata: c = f->p[PROTO(ch->qid)]->conv[CONV(ch->qid)]; return qread(c->rq, a, n); case Qerr: c = f->p[PROTO(ch->qid)]->conv[CONV(ch->qid)]; return qread(c->eq, a, n); case Qsnoop: c = f->p[PROTO(ch->qid)]->conv[CONV(ch->qid)]; return qread(c->sq, a, n); case Qstats: x = f->p[PROTO(ch->qid)]; if(x->stats == nil) error("stats not implemented"); buf = smalloc(Statelen); (*x->stats)(x, buf, Statelen); rv = readstr(offset, p, n, buf); free(buf); return rv; } }
{ r->Val->Identifier = MACRO_NAME(ALCOR_CPU); } // picoc: boardname = pd_board(); static void pd_board(pstate *p, val *r, val **param, int n) { r->Val->Identifier = MACRO_NAME(ALCOR_BOARD); } #define MIN_OPT_LEVEL 2 #include "rodefs.h" // list of all library functions and their prototypes const PICOC_REG_TYPE pd_library[] = { {FUNC(pd_platform), PROTO("char *pd_platform(void);")}, {FUNC(pd_board), PROTO("char *pd_board(void);")}, {FUNC(pd_cpu), PROTO("char *pd_cpu(void);")}, {NILFUNC, NILPROTO} }; // init library extern void pd_library_init(void) { REGISTER("pd.h", NULL, &pd_library[0]); } #endif // ALCOR_LANG_PICOC #if defined ALCOR_LANG_LUA
static long ipread(Chan *ch, void *a, long n, vlong off) { int r; Conv *c; Proto *x; char *p, *s; Fs *f; ulong offset = off; f = ipfs[ch->dev]; p = a; switch(TYPE(ch->qid)) { default: error(Eperm); case Qprotodir: case Qtopdir: case Qconvdir: return devdirread(ch, a, n, 0, 0, ipgen); case Qarp: error(Eperm); /* TO DO */ case Qndb: return readstr(off, a, n, f->ndb); case Qctl: sprint(up->genbuf, "%lud", CONV(ch->qid)); return readstr(offset, p, n, up->genbuf); case Qremote: x = f->p[PROTO(ch->qid)]; c = x->conv[CONV(ch->qid)]; sprint(up->genbuf, "%I!%d\n", c->raddr, c->rport); return readstr(offset, p, n, up->genbuf); case Qlocal: x = f->p[PROTO(ch->qid)]; c = x->conv[CONV(ch->qid)]; sprint(up->genbuf, "%I!%d\n", c->laddr, c->lport); return readstr(offset, p, n, up->genbuf); case Qstatus: x = f->p[PROTO(ch->qid)]; c = x->conv[CONV(ch->qid)]; s = smalloc(Statelen); if(waserror()){ free(s); nexterror(); } snprint(s, Statelen, "%s\n", ipstates[c->state]); n = readstr(offset, p, n, s); poperror(); free(s); return n; case Qdata: x = f->p[PROTO(ch->qid)]; c = x->conv[CONV(ch->qid)]; if(c->sfd < 0) error(Ehungup); if(c->headers) { if(n < c->headers) error(Ebadarg); p = a; r = so_recv(c->sfd, p + c->headers, n - c->headers, p, c->headers); if(r > 0) r += c->headers; } else r = so_recv(c->sfd, a, n, nil, 0); if(r < 0) oserror(); return r; case Qstats: error("stats not implemented"); return n; } }
static Chan * ipopen(Chan *c, int omode) { Conv *cv, *nc; Proto *p; uchar raddr[IPaddrlen]; ushort rport; int perm, sfd; Fs *f; perm = m2p[omode&3]; f = ipfs[c->dev]; switch(TYPE(c->qid)) { default: break; case Qtopdir: case Qprotodir: case Qconvdir: case Qstatus: case Qremote: case Qlocal: case Qstats: /* case Qipselftab: */ if(omode != OREAD) error(Eperm); break; case Qndb: if(omode & (OWRITE|OTRUNC) && !iseve()) error(Eperm); if((omode & (OWRITE|OTRUNC)) == (OWRITE|OTRUNC)){ f->ndb[0] = 0; f->ndbvers++; } break; case Qclone: p = f->p[PROTO(c->qid)]; cv = protoclone(p, up->env->user, -1); if(cv == 0) error(Enodev); mkqid(&c->qid, QID(p->x, cv->x, Qctl), 0, QTFILE); break; case Qdata: case Qctl: p = f->p[PROTO(c->qid)]; qlock(&p->l); cv = p->conv[CONV(c->qid)]; qlock(&cv->l); if(waserror()){ qunlock(&cv->l); qunlock(&p->l); nexterror(); } if((perm & (cv->perm>>6)) != perm) { if(strcmp(up->env->user, cv->owner) != 0) error(Eperm); if((perm & cv->perm) != perm) error(Eperm); } cv->inuse++; if(cv->inuse == 1) { kstrdup(&cv->owner, up->env->user); cv->perm = 0660; if(cv->sfd < 0) cv->sfd = so_socket(p->stype); } poperror(); qunlock(&cv->l); qunlock(&p->l); break; case Qlisten: p = f->p[PROTO(c->qid)]; cv = p->conv[CONV(c->qid)]; if((perm & (cv->perm>>6)) != perm){ if(strcmp(up->env->user, cv->owner) != 0) error(Eperm); if((perm & cv->perm) != perm) error(Eperm); } if(cv->state != Announced) error("not announced"); qlock(&cv->listenq); if(waserror()){ qunlock(&cv->listenq); nexterror(); } sfd = so_accept(cv->sfd, raddr, &rport); nc = protoclone(p, up->env->user, sfd); if(nc == 0) { so_close(sfd); error(Enodev); } memmove(nc->raddr, raddr, IPaddrlen); nc->rport = rport; setladdr(nc); nc->state = Connected; mkqid(&c->qid, QID(PROTO(c->qid), nc->x, Qctl), 0, QTFILE); poperror(); qunlock(&cv->listenq); break; } c->mode = openmode(omode); c->flag |= COPEN; c->offset = 0; return c; }
static long ipwrite(Chan* ch, void *v, long n, vlong off) { Conv *c; Proto *x; char *p; Cmdbuf *cb; uchar ia[IPaddrlen], ma[IPaddrlen]; Fs *f; char *a; ulong offset = off; a = v; f = ipfs[ch->dev]; switch(TYPE(ch->qid)){ default: error(Eperm); case Qdata: x = f->p[PROTO(ch->qid)]; c = x->conv[CONV(ch->qid)]; if(c->wq == nil) error(Eperm); qwrite(c->wq, a, n); break; case Qarp: return arpwrite(f, a, n); case Qiproute: return routewrite(f, ch, a, n); case Qlog: netlogctl(f, a, n); return n; case Qndb: return ndbwrite(f, a, offset, n); break; case Qctl: x = f->p[PROTO(ch->qid)]; c = x->conv[CONV(ch->qid)]; cb = parsecmd(a, n); qlock(c); if(waserror()) { qunlock(c); free(cb); nexterror(); } if(cb->nf < 1) error("short control request"); if(strcmp(cb->f[0], "connect") == 0) connectctlmsg(x, c, cb); else if(strcmp(cb->f[0], "announce") == 0) announcectlmsg(x, c, cb); else if(strcmp(cb->f[0], "bind") == 0) bindctlmsg(x, c, cb); else if(strcmp(cb->f[0], "ttl") == 0) ttlctlmsg(c, cb); else if(strcmp(cb->f[0], "tos") == 0) tosctlmsg(c, cb); else if(strcmp(cb->f[0], "ignoreadvice") == 0) c->ignoreadvice = 1; else if(strcmp(cb->f[0], "addmulti") == 0){ if(cb->nf < 2) error("addmulti needs interface address"); if(cb->nf == 2){ if(!ipismulticast(c->raddr)) error("addmulti for a non multicast address"); if (parseip(ia, cb->f[1]) == -1) error(Ebadip); ipifcaddmulti(c, c->raddr, ia); } else { if (parseip(ia, cb->f[1]) == -1 || parseip(ma, cb->f[2]) == -1) error(Ebadip); if(!ipismulticast(ma)) error("addmulti for a non multicast address"); ipifcaddmulti(c, ma, ia); } } else if(strcmp(cb->f[0], "remmulti") == 0){ if(cb->nf < 2) error("remmulti needs interface address"); if(!ipismulticast(c->raddr)) error("remmulti for a non multicast address"); if (parseip(ia, cb->f[1]) == -1) error(Ebadip); ipifcremmulti(c, c->raddr, ia); } else if(strcmp(cb->f[0], "maxfragsize") == 0){ if(cb->nf < 2) error("maxfragsize needs size"); c->maxfragsize = (int)strtol(cb->f[1], nil, 0); } else if(x->ctl != nil) { p = x->ctl(c, cb->f, cb->nf); if(p != nil) error(p); } else error("unknown control request"); qunlock(c); free(cb); poperror(); } return n; }
} #define MIN_OPT_LEVEL 2 #include "rodefs.h" #if PICOC_TINYRAM_ON const PICOC_RO_TYPE term_variables[] = { {STRKEY("term_WAIT"), INT(wait)}, {STRKEY("term_NOWAIT"), INT(no_wait)}, {NILKEY, NILVAL} }; #endif // List of all library functions and their prototypes const PICOC_REG_TYPE term_library[] = { {FUNC(pterm_clrscr), PROTO("void term_clrscr(void);")}, {FUNC(pterm_clreol), PROTO("void term_clreol(void);")}, {FUNC(pterm_moveto), PROTO("void term_moveto(unsigned int, unsigned int);")}, {FUNC(pterm_moveup), PROTO("void term_moveup(unsigned int);")}, {FUNC(pterm_movedown), PROTO("void term_movedown(unsigned int);")}, {FUNC(pterm_moveleft), PROTO("void term_moveleft(unsigned int);")}, {FUNC(pterm_moveright), PROTO("void term_moveright(unsigned int);")}, {FUNC(pterm_getlines), PROTO("unsigned int term_getlines(void);")}, {FUNC(pterm_getcols), PROTO("unsigned int term_getcols(void);")}, {FUNC(pterm_puts), PROTO("unsigned long term_puts(unsigned int, unsigned int, char *);")}, {FUNC(pterm_putch), PROTO("unsigned int term_putch(char);")}, {FUNC(pterm_getcx), PROTO("unsigned int term_getcx(void);")}, {FUNC(pterm_getcy), PROTO("unsigned int term_getcy(void);")}, {FUNC(pterm_getchar), PROTO("int term_getchar(int);")}, {FUNC(pterm_decode), PROTO("int term_decode(char *);")}, {NILFUNC, NILPROTO}
printf("History saved to %s.\n", fname); else if (res == LINENOISE_HISTORY_NOT_ENABLED) printf("Linenoise not enabled for picoc.\n"); else if (res == LINENOISE_HISTORY_EMPTY) printf("History empty, nothing to save.\n"); else printf("Unable to save history to %s.\n", fname); ReturnValue->Val->Integer = 0; #else ProgramFail(NULL, "Linenoise support was not enabled."); ReturnValue->Val->Integer = -1; #endif /* #ifdef BUILD_LINENOISE */ } #define MIN_OPT_LEVEL 2 #include "rodefs.h" /* list of all library functions and their prototypes */ const PICOC_REG_TYPE picoc_library[] = { /* picoc platform functions */ {FUNC(picoc_version), PROTO("char *picoc_version(void);")}, {FUNC(picoc_save_history), PROTO("int picoc_save_history(char *);")}, {NILFUNC, NILPROTO} }; /* init library */ extern void picoc_platform_library_init(void) { REGISTER("picoc.h", NULL, &picoc_library[0]); }
int quot, rem; \ } div_t; \ \ typedef struct { \ int quot, rem; \ } ldiv_t; \ "; #endif #define MIN_OPT_LEVEL 2 #include "rodefs.h" /* all stdlib.h functions */ const PICOC_REG_TYPE StdlibFunctions[] = { #ifndef NO_FP { FUNC(StdlibAtof), PROTO("float atof(char *);") }, { FUNC(StdlibStrtod), PROTO("float strtod(char *,char **);") }, #endif { FUNC(StdlibAtoi), PROTO("int atoi(char *);") }, { FUNC(StdlibAtol), PROTO("int atol(char *);") }, { FUNC(StdlibStrtol), PROTO("int strtol(char *,char **,int);") }, { FUNC(StdlibStrtoul), PROTO("int strtoul(char *,char **,int);") }, { FUNC(StdlibMalloc), PROTO("void *malloc(int);") }, { FUNC(StdlibCalloc), PROTO("void *calloc(int,int);") }, { FUNC(StdlibRealloc), PROTO("void *realloc(void *,int);") }, { FUNC(StdlibFree), PROTO("void free(void *);") }, { FUNC(StdlibRand), PROTO("int rand();") }, { FUNC(StdlibSrand), PROTO("void srand(int);") }, { FUNC(StdlibAbort), PROTO("void abort();") }, { FUNC(StdlibExit), PROTO("void exit(int);") }, { FUNC(StdlibGetenv), PROTO("char *getenv(char *);") },
static long ipwrite(Chan *ch, void *a, long n, vlong off) { Conv *c; Proto *x; char *p; Cmdbuf *cb; Fs *f; f = ipfs[ch->dev]; switch(TYPE(ch->qid)) { default: error(Eperm); case Qdata: x = f->p[PROTO(ch->qid)]; c = x->conv[CONV(ch->qid)]; if(c->sfd < 0) error(Ehungup); qlock(&c->wlock); if(waserror()){ qunlock(&c->wlock); nexterror(); } if(c->headers) { if(n < c->headers) error(Eshort); p = a; n = so_send(c->sfd, p + c->headers, n - c->headers, p, c->headers); if(n >= 0) n += c->headers; } else n = so_send(c->sfd, a, n, nil, 0); poperror(); qunlock(&c->wlock); if(n < 0) oserror(); break; case Qarp: return arpwrite(a, n); case Qndb: if(off > strlen(f->ndb)) error(Eio); if(off+n >= sizeof(f->ndb)-1) error(Eio); memmove(f->ndb+off, a, n); f->ndb[off+n] = 0; f->ndbvers++; f->ndbmtime = seconds(); break; case Qctl: x = f->p[PROTO(ch->qid)]; c = x->conv[CONV(ch->qid)]; cb = parsecmd(a, n); qlock(&c->l); if(waserror()){ qunlock(&c->l); free(cb); nexterror(); } if(cb->nf < 1) error("short control request"); if(strcmp(cb->f[0], "connect") == 0) connectctlmsg(x, c, cb); else if(strcmp(cb->f[0], "announce") == 0) announcectlmsg(x, c, cb); else if(strcmp(cb->f[0], "bind") == 0) bindctlmsg(x, c, cb); else if(strcmp(cb->f[0], "ttl") == 0){ /* ignored */ } else if(strcmp(cb->f[0], "tos") == 0){ /* ignored */ } else if(strcmp(cb->f[0], "ignoreadvice") == 0){ /* ignored */ } else if(strcmp(cb->f[0], "headers4") == 0){ if(c->p->stype != S_UDP) error(Enoctl); c->headers = OUdphdrlenv4; } else if(strcmp(cb->f[0], "oldheaders") == 0){ if(c->p->stype != S_UDP) error(Enoctl); c->headers = OUdphdrlen; } else if(strcmp(cb->f[0], "headers") == 0){ if(c->p->stype != S_UDP) error(Enoctl); c->headers = Udphdrlen; } else if(strcmp(cb->f[0], "hangup") == 0){ if(c->p->stype != S_TCP) error(Enoctl); qunlock(&c->l); if(waserror()){ qlock(&c->l); nexterror(); } /* TO DO: check fd status if socket close/hangup interrupted */ if(c->sfd >= 0 && so_hangup(c->sfd, 1) < 0) oserror(); qlock(&c->l); poperror(); c->sfd = -1; c->state = Hungup; } else if(strcmp(cb->f[0], "keepalive") == 0){ if(c->p->stype != S_TCP) error(Enoctl); if(c->sfd < 0) error("not connected"); so_keepalive(c->sfd, cb->nf>1? atoi(cb->f[1]): 0); } else error(Enoctl); poperror(); qunlock(&c->l); free(cb); break; } return n; }
Chan * ipopen(Chan *c, int omode) { Proto *p; ulong raddr; ushort rport; int perm, sfd; Conv *cv, *lcv; omode &= 3; perm = 0; switch(omode) { case OREAD: perm = 4; break; case OWRITE: perm = 2; break; case ORDWR: perm = 6; break; } switch(TYPE(c->qid)) { default: break; case Qtopdir: case Qprotodir: case Qconvdir: case Qstatus: case Qremote: case Qlocal: if(omode != OREAD) error(Eperm); break; case Qclonus: p = &proto[PROTO(c->qid)]; cv = protoclone(p, up->user, -1); if(cv == 0) error(Enodev); c->qid.path = QID(p->x, cv->x, Qctl); c->qid.vers = 0; break; case Qdata: case Qctl: p = &proto[PROTO(c->qid)]; lock(&p->l); cv = p->conv[CONV(c->qid)]; lock(&cv->r.lk); if((perm & (cv->perm>>6)) != perm) { if(strcmp(up->user, cv->owner) != 0 || (perm & cv->perm) != perm) { unlock(&cv->r.lk); unlock(&p->l); error(Eperm); } } cv->r.ref++; if(cv->r.ref == 1) { memmove(cv->owner, up->user, KNAMELEN); cv->perm = 0660; } unlock(&cv->r.lk); unlock(&p->l); break; case Qlisten: p = &proto[PROTO(c->qid)]; lcv = p->conv[CONV(c->qid)]; sfd = so_accept(lcv->sfd, &raddr, &rport); cv = protoclone(p, up->user, sfd); if(cv == 0) { close(sfd); error(Enodev); } cv->raddr = raddr; cv->rport = rport; setladdr(cv); cv->state = "Established"; c->qid.path = QID(p->x, cv->x, Qctl); break; } c->mode = openmode(omode); c->flag |= COPEN; c->offset = 0; return c; }
Int2 Main_old (void) { AsnIoPtr aip; BioseqPtr fake_bsp = NULL, fake_subject_bsp = NULL, query_bsp = NULL, subject_bsp = NULL; BioseqPtr bsp1, bsp2; BLAST_KarlinBlkPtr ka_params=NULL, ka_params_gap=NULL; BLAST_OptionsBlkPtr options=NULL; Boolean seq1_is_na, seq2_is_na; CharPtr params_buffer=NULL; DbtagPtr dbtagptr; Uint1 align_type; Uint4 align_options; SeqAlignPtr seqalign; SeqAnnotPtr seqannot; SeqEntryPtr sep = NULL, sep1 = NULL; CharPtr program_name, blast_outputfile; FILE *outfp; ValNodePtr mask_loc, mask_loc_start, vnp, other_returns=NULL, error_returns=NULL; BLAST_MatrixPtr matrix; Int4Ptr PNTR txmatrix; int (LIBCALLBACK *handle_results)PROTO((VoidPtr search)) = NULL; Boolean entrez_lookup = FALSE; Boolean html, seqannot_output, believe_query; Uint1 tabular_output; Boolean gapped_calculation; entrez_lookup = (Boolean) myargs[ARG_ACCN].intvalue; html = (Boolean) myargs[ARG_HTML].intvalue; seqannot_output = (myargs[ARG_ASNOUT].strvalue != NULL); blast_outputfile = myargs [ARG_OUT].strvalue; program_name = StringSave(myargs[ARG_PROGRAM].strvalue); if (StringCmp(program_name, "blastn") && StringCmp(program_name, "blastp") && StringCmp(program_name, "blastx") && StringCmp(program_name, "tblastn") && StringCmp(program_name, "tblastx")) { ErrPostEx(SEV_FATAL, 1, 0, "Program name must be blastn, blastp, blastx, tblastn or tblastx\n"); return (1); } align_type = BlastGetTypes(program_name, &seq1_is_na, &seq2_is_na); if ((outfp = FileOpen(blast_outputfile, "w")) == NULL) { ErrPostEx(SEV_FATAL, 1, 0, "blast: Unable to open output file %s\n", blast_outputfile); return (1); } gapped_calculation = (Boolean) myargs[ARG_GAPPED].intvalue; believe_query = (seqannot_output || entrez_lookup); options = BLASTOptionNewEx(program_name, gapped_calculation, (Boolean) myargs[ARG_USEMEGABLAST].intvalue); if (BL2SEQ_GetSequences(seq1_is_na, seq2_is_na, &query_bsp, &subject_bsp, &sep, &sep1, &(options->query_lcase_mask), believe_query) == FALSE) { ErrPostEx(SEV_FATAL, 1, 0, "blast: Unable to get sequences"); return (1); } if (!entrez_lookup) { if (!believe_query) fake_bsp = BlastMakeFakeBioseq(query_bsp, NULL); fake_subject_bsp = BioseqNew(); fake_subject_bsp->descr = subject_bsp->descr; fake_subject_bsp->repr = subject_bsp->repr; fake_subject_bsp->mol = subject_bsp->mol; fake_subject_bsp->length = subject_bsp->length; fake_subject_bsp->seq_data = subject_bsp->seq_data; fake_subject_bsp->seq_data_type = subject_bsp->seq_data_type; dbtagptr = DbtagNew(); dbtagptr->db = StringSave("BL_ORD_ID"); dbtagptr->tag = ObjectIdNew(); if (BioseqGetTitle(subject_bsp) != NULL) dbtagptr->tag->str = StringSave(BioseqGetTitle(subject_bsp)); else dbtagptr->tag->str = StringSave("No definition line found"); ValNodeAddPointer(&fake_subject_bsp->id, SEQID_GENERAL, dbtagptr); bsp1 = (believe_query ? query_bsp : fake_bsp); bsp2 = fake_subject_bsp; } else { bsp1 = query_bsp; bsp2 = subject_bsp; } tabular_output = (Uint1) myargs[ARG_FORMAT].intvalue; if (myargs[ARG_SEARCHSP].floatvalue) options->searchsp_eff = (Nlm_FloatHi) myargs[ARG_SEARCHSP].floatvalue; options->filter_string = StringSave(myargs[ARG_FILTER].strvalue); options->expect_value = (Nlm_FloatHi) myargs [ARG_EVALUE].floatvalue; if (StringICmp("blastn", program_name) == 0) { options->penalty = myargs[ARG_MISMATCH].intvalue; options->reward = myargs[ARG_MATCH].intvalue; } options->db_length = (Int8) myargs[ARG_DBSIZE].floatvalue; options->discontinuous = FALSE; if (myargs[ARG_XDROP].intvalue != 0) { options->gap_x_dropoff = myargs[ARG_XDROP].intvalue; } if (myargs[ARG_WORDSIZE].intvalue != 0) options->wordsize = (Int2) myargs[ARG_WORDSIZE].intvalue; if (options->is_megablast_search) { options->cutoff_s2 = options->wordsize*options->reward; } options->matrix = MemFree(options->matrix); BLASTOptionSetGapParams(options, myargs[ARG_MATRIX].strvalue, 0, 0); if (myargs[ARG_GAPOPEN].intvalue != -1) options->gap_open = myargs[ARG_GAPOPEN].intvalue; if (myargs[ARG_GAPEXT].intvalue != -1) options->gap_extend = myargs[ARG_GAPEXT].intvalue; options->strand_option = myargs[ARG_STRAND].intvalue; /* Input longest intron length is in nucleotide scale; in the lower level code it will be used in protein scale */ if (myargs[ARG_INTRON].intvalue > 0) options->longest_intron = myargs[ARG_INTRON].intvalue; if (!myargs[ARG_LOC1].strvalue && !myargs[ARG_LOC2].strvalue) { seqalign = BlastTwoSequencesWithCallback(bsp1, bsp2, program_name, options, &other_returns, &error_returns, handle_results); } else { SeqLocPtr slp1=NULL, slp2=NULL; if (BL2SEQ_MakeSeqLoc(bsp1, bsp2, &slp1, &slp2, options->strand_option) == FALSE) return 1; seqalign = BlastTwoSequencesByLocWithCallback(slp1, slp2, program_name, options, &other_returns, &error_returns, handle_results, NULL); SeqLocFree(slp1); SeqLocFree(slp2); } if (error_returns) { BlastErrorPrint(error_returns); for (vnp = error_returns; vnp; vnp = vnp->next) { BlastDestroyErrorMessage((BlastErrorMsgPtr)vnp->data.ptrvalue); } ValNodeFree(error_returns); } ka_params = NULL; ka_params_gap = NULL; params_buffer = NULL; mask_loc = NULL; matrix = NULL; txmatrix = NULL; for (vnp=other_returns; vnp; vnp = vnp->next) { switch (vnp->choice) { case TXKABLK_NOGAP: ka_params = vnp->data.ptrvalue; break; case TXKABLK_GAP: ka_params_gap = vnp->data.ptrvalue; break; case TXPARAMETERS: params_buffer = vnp->data.ptrvalue; break; case TXMATRIX: matrix = vnp->data.ptrvalue; if (matrix && !tabular_output) txmatrix = BlastMatrixToTxMatrix(matrix); break; case SEQLOC_MASKING_NOTSET: case SEQLOC_MASKING_PLUS1: case SEQLOC_MASKING_PLUS2: case SEQLOC_MASKING_PLUS3: case SEQLOC_MASKING_MINUS1: case SEQLOC_MASKING_MINUS2: case SEQLOC_MASKING_MINUS3: ValNodeAddPointer(&mask_loc, vnp->choice, vnp->data.ptrvalue); break; default: break; } } if (!tabular_output || seqannot_output) { align_options = 0; align_options += TXALIGN_MATRIX_VAL; align_options += TXALIGN_SHOW_QS; align_options += TXALIGN_COMPRESS; align_options += TXALIGN_END_NUM; if (StringICmp("blastx", program_name) == 0) { align_options += TXALIGN_BLASTX_SPECIAL; } if (html) align_options += TXALIGN_HTML; seqannot = SeqAnnotNew(); seqannot->type = 2; AddAlignInfoToSeqAnnot(seqannot, align_type); seqannot->data = seqalign; aip = NULL; if (seqannot_output) aip = AsnIoOpen (myargs[ARG_ASNOUT].strvalue,"w"); if (aip && seqannot) { SeqAnnotAsnWrite((SeqAnnotPtr) seqannot, aip, NULL); AsnIoReset(aip); aip = AsnIoClose(aip); } } if (!tabular_output) { AcknowledgeBlastQuery(query_bsp, 70, outfp, believe_query, html); ShowTextAlignFromAnnot(seqannot, 60, outfp, NULL, NULL, align_options, txmatrix, mask_loc, FormatScoreFunc); seqannot = SeqAnnotFree(seqannot); if (txmatrix) txmatrix = TxMatrixDestruct(txmatrix); init_buff_ex(85); if (ka_params) { PrintKAParameters(ka_params->Lambda, ka_params->K, ka_params->H, 70, outfp, FALSE); } if (ka_params_gap) { PrintKAParameters(ka_params_gap->Lambda, ka_params_gap->K, ka_params_gap->H, 70, outfp, TRUE); } PrintTildeSepLines(params_buffer, 70, outfp); free_buff(); } else { PrintTabularOutputHeader(NULL, query_bsp, NULL, program_name, 0, believe_query, outfp); BlastPrintTabulatedResults(seqalign, query_bsp, NULL, 1, program_name, !gapped_calculation, believe_query, 0, 0, outfp, FALSE); SeqAlignSetFree(seqalign); } matrix = BLAST_MatrixDestruct(matrix); MemFree(ka_params); MemFree(ka_params_gap); MemFree(params_buffer); mask_loc_start = mask_loc; while (mask_loc) { SeqLocSetFree(mask_loc->data.ptrvalue); mask_loc = mask_loc->next; } ValNodeFree(mask_loc_start); fake_bsp = BlastDeleteFakeBioseq(fake_bsp); other_returns = ValNodeFree(other_returns); options->query_lcase_mask = SeqLocSetFree(options->query_lcase_mask); options = BLASTOptionDelete(options); MemFree(program_name); FileClose(outfp); if (entrez_lookup) { BioseqFree(query_bsp); BioseqFree(subject_bsp); } else { SeqEntryFree(sep); SeqEntryFree(sep1); } return 0; }
static Chan* ipopen(Chan* c, int omode) { Conv *cv, *nc; Proto *p; int perm; Fs *f; perm = m2p[omode&3]; f = ipfs[c->dev]; switch(TYPE(c->qid)) { default: break; case Qndb: if(omode & (OWRITE|OTRUNC) && !iseve()) error(Eperm); if((omode & (OWRITE|OTRUNC)) == (OWRITE|OTRUNC)) f->ndb[0] = 0; break; case Qlog: netlogopen(f); break; case Qiproute: case Qarp: if(omode != OREAD && !iseve()) error(Eperm); break; case Qtopdir: case Qprotodir: case Qconvdir: case Qstatus: case Qremote: case Qlocal: case Qstats: case Qbootp: case Qipselftab: if(omode != OREAD) error(Eperm); break; case Qsnoop: if(omode != OREAD) error(Eperm); p = f->p[PROTO(c->qid)]; cv = p->conv[CONV(c->qid)]; if(strcmp(ATTACHER(c), cv->owner) != 0 && !iseve()) error(Eperm); incref(&cv->snoopers); break; case Qclone: p = f->p[PROTO(c->qid)]; qlock(p); if(waserror()){ qunlock(p); nexterror(); } cv = Fsprotoclone(p, ATTACHER(c)); qunlock(p); poperror(); if(cv == nil) { error(Enodev); break; } mkqid(&c->qid, QID(p->x, cv->x, Qctl), 0, QTFILE); break; case Qdata: case Qctl: case Qerr: p = f->p[PROTO(c->qid)]; qlock(p); cv = p->conv[CONV(c->qid)]; qlock(cv); if(waserror()) { qunlock(cv); qunlock(p); nexterror(); } if((perm & (cv->perm>>6)) != perm) { if(strcmp(ATTACHER(c), cv->owner) != 0) error(Eperm); if((perm & cv->perm) != perm) error(Eperm); } cv->inuse++; if(cv->inuse == 1){ kstrdup(&cv->owner, ATTACHER(c)); cv->perm = 0660; } qunlock(cv); qunlock(p); poperror(); break; case Qlisten: cv = f->p[PROTO(c->qid)]->conv[CONV(c->qid)]; if((perm & (cv->perm>>6)) != perm) { if(strcmp(ATTACHER(c), cv->owner) != 0) error(Eperm); if((perm & cv->perm) != perm) error(Eperm); } if(cv->state != Announced) error("not announced"); if(waserror()){ closeconv(cv); nexterror(); } qlock(cv); cv->inuse++; qunlock(cv); nc = nil; while(nc == nil) { /* give up if we got a hangup */ if(qisclosed(cv->rq)) error("listen hungup"); qlock(&cv->listenq); if(waserror()) { qunlock(&cv->listenq); nexterror(); } /* wait for a connect */ sleep(&cv->listenr, incoming, cv); qlock(cv); nc = cv->incall; if(nc != nil){ cv->incall = nc->next; mkqid(&c->qid, QID(PROTO(c->qid), nc->x, Qctl), 0, QTFILE); kstrdup(&cv->owner, ATTACHER(c)); } qunlock(cv); qunlock(&cv->listenq); poperror(); } closeconv(cv); poperror(); break; } c->mode = openmode(omode); c->flag |= COPEN; c->offset = 0; return c; }
// extern __thread jmp_buf jumpBuf; int VM::call(Value A, int nEffArgs, Value *regs, Stack *stack) { Vector<RetInfo> retInfo; // only used if FAST_CALL if (!(IS_O_TYPE(A, O_FUNC) || IS_CF(A) || IS_O_TYPE(A, O_CFUNC))) { return -1; } regs = stack->maybeGrow(regs, 256); int nExpectedArgs = IS_O_TYPE(A, O_FUNC) ? ((Func *)GET_OBJ(A))->proto->nArgs : NARGS_CFUNC; nEffArgs = prepareStackForCall(regs, nExpectedArgs, nEffArgs, gc); if (IS_CF(A) || IS_O_TYPE(A, O_CFUNC)) { if (IS_CF(A)) { tfunc f = GET_CF(A); *regs = f(this, CFunc::CFUNC_CALL, 0, regs, nEffArgs); } else { ((CFunc *) GET_OBJ(A))->call(this, regs, nEffArgs); } return 0; } unsigned code = 0; Value B; Value *ptrC; Func *activeFunc = (Func *) GET_OBJ(A); unsigned *pc = (unsigned *) activeFunc->proto->code.buf(); static void *dispatch[] = { #define _(name) &&name #include "opcodes.inc" #undef _ }; assert(sizeof(dispatch)/sizeof(dispatch[0]) == N_OPCODES); copyUpvals(activeFunc, regs); STEP; JMP: pc += OD(code); STEP; JT: if (!IS_FALSE(*ptrC)) { pc += OD(code); } STEP; JF: if ( IS_FALSE(*ptrC)) { pc += OD(code); } STEP; JLT: if (lessThan(A, B)) { pc += OSC(code); } STEP; JNIS: if (A != B) { pc += OSC(code); } STEP; FOR: A = *(ptrC + 1); B = *(ptrC + 2); if (!IS_NUM(A) || !IS_NUM(B)) { goto error; } // E_FOR_NOT_NUMBER *ptrC = B; if (!(GET_NUM(B) < GET_NUM(A))) { pc += OD(code); } STEP; LOOP: { const double counter = GET_NUM(*ptrC) + 1; if (counter < GET_NUM(*(ptrC+1))) { pc += OD(code); } *ptrC = VAL_NUM(counter); STEP; } FUNC: assert(IS_PROTO(A)); *ptrC = VAL_OBJ(Func::alloc(gc, PROTO(A), regs + 256, regs, OB(code))); STEP; // index, A[B] GETI: *ptrC = types->type(A)->indexGet(A, B); if (*ptrC == VERR) { goto error; } STEP; GETF: *ptrC = types->type(A)->fieldGet(A, B); if (*ptrC == VERR) { goto error; } STEP; SETI: if (!types->type(*ptrC)->indexSet(*ptrC, A, B)) { goto error; } STEP; SETF: if (!types->type(*ptrC)->fieldSet(*ptrC, A, B)) { goto error; } STEP; /* const int oa = OA(code); const int ob = OB(code); int top = max(oa, ob) + 1; top = max(top, activeFunc->proto->localsTop); Value *base = regs + top; printf("top %d\n", top); base[0] = A; base[1] = B; int cPos = ptrC - regs; DO_CALL(v, 2, regs, base, stack); regs[cPos] = base[0]; break; if (*ptrC == VERR) { goto error; } */ GETS: *ptrC = getSlice(gc, A, B, regs[OB(code)+1]); if (*ptrC==VERR) { goto error; } STEP; SETS: if (setSlice(*ptrC, A, regs[OA(code)+1], B)) { goto error; } STEP; RET: { regs[0] = A; Value *root = stack->base; gc->maybeCollect(root, regs - root + 1); #if FAST_CALL if (!retInfo.size()) { return 0; } RetInfo *ri = retInfo.top(); pc = ri->pc; regs = stack->base + ri->base; activeFunc = ri->func; retInfo.pop(); copyUpvals(activeFunc, regs); STEP; #else return 0; #endif } CALL: { if (!IS_OBJ(A) && !IS_CF(A)) { goto error; } // E_CALL_NOT_FUNC int nEffArgs = OSB(code); assert(nEffArgs != 0); Value *base = ptrC; #if FAST_CALL if (IS_O_TYPE(A, O_FUNC)) { Func *f = (Func *) GET_OBJ(A); Proto *proto = f->proto; prepareStackForCall(base, proto->nArgs, nEffArgs, gc); RetInfo *ret = retInfo.push(); ret->pc = pc; ret->base = regs - stack->base; ret->func = activeFunc; regs = stack->maybeGrow(base, 256); copyUpvals(f, regs); pc = proto->code.buf(); activeFunc = f; } else { #endif int ret = DO_CALL(A, nEffArgs, regs, base, stack); if (ret) { goto error; } #if FAST_CALL } #endif STEP; } MOVEUP: { const int slot = regs + 256 - ptrC; activeFunc->setUp(slot, A); } MOVE_R: *ptrC = A; STEP; MOVE_I: *ptrC = VAL_NUM(OD(code)); STEP; MOVE_V: { int id = OA(code); *ptrC = id == CONST_NIL ? VNIL : id == CONST_EMPTY_STRING ? EMPTY_STRING : id == CONST_EMPTY_ARRAY ? VAL_OBJ(emptyArray->copy(gc)) : VAL_OBJ(emptyMap->copy(gc)); STEP; } MOVE_C: { Value v = *pc | (((u64) *(pc+1)) << 32); pc += 2; if (IS_ARRAY(v)) { v = VAL_OBJ(ARRAY(v)->copy(gc)); } else if (IS_MAP(v)) { v = VAL_OBJ(MAP(v)->copy(gc)); } *ptrC = v; STEP; } LEN: *ptrC = VAL_NUM(len(A)); STEP; NOTL: *ptrC = IS_FALSE(A) ? TRUE : FALSE; STEP; // notb: *ptrC = IS_INT(A)? VAL_INT(~getInteger(A)):ERROR(E_WRONG_TYPE); STEP; ADD: *ptrC = doAdd(gc, A, B); if (*ptrC == VERR) { goto error; } STEP; SUB: *ptrC = BINOP(-, A, B); STEP; MUL: *ptrC = BINOP(*, A, B); STEP; DIV: *ptrC = BINOP(/, A, B); STEP; MOD: *ptrC = doMod(A, B); if (*ptrC == VERR) { goto error; } STEP; POW: *ptrC = doPow(A, B); if (*ptrC == VERR) { goto error; } STEP; AND: *ptrC = BITOP(&, A, B); STEP; OR: *ptrC = BITOP(|, A, B); STEP; XOR: *ptrC = BITOP(^, A, B); STEP; SHL_RR: ERR(!IS_NUM(B), E_WRONG_TYPE); *ptrC = doSHL(A, (int)GET_NUM(B)); STEP; SHR_RR: ERR(!IS_NUM(B), E_WRONG_TYPE); *ptrC = doSHR(A, (int)GET_NUM(B)); STEP; SHL_RI: *ptrC = doSHL(A, OSB(code)); STEP; SHR_RI: *ptrC = doSHR(A, OSB(code)); STEP; EQ: *ptrC = equals(A, B) ? TRUE : FALSE; STEP; NEQ: *ptrC = !equals(A, B) ? TRUE : FALSE; STEP; IS: *ptrC = A == B ? TRUE : FALSE; STEP; NIS: *ptrC = A != B ? TRUE : FALSE; STEP; LT: *ptrC = lessThan(A, B) ? TRUE : FALSE; STEP; LE: *ptrC = (equals(A, B) || lessThan(A, B)) ? TRUE : FALSE; STEP; error: return pc - (unsigned *) activeFunc->proto->code.buf(); }
if (i < bcnt + startidx) arr[i] = adc_get_processed_sample(id); else // zero-out values where we don't have enough samples arr[i] = 0; } } #endif // #if defined (BUF_ENABLE_ADC) #define MIN_OPT_LEVEL 2 #include "rodefs.h" // List of all library functions and their prototypes const PICOC_REG_TYPE adc_library[] = { {FUNC(adc_maxval), PROTO("unsigned long adc_maxval(unsigned int);")}, {FUNC(adc_setclock), PROTO("unsigned long adc_setclock(unsigned int, long, unsigned int);")}, {FUNC(adc_isdone), PROTO("unsigned int adc_isdone(unsigned int);")}, {FUNC(adc_setblocking), PROTO("void adc_setblocking(unsigned int, unsigned int);")}, {FUNC(adc_setsmoothing), PROTO("unsigned int adc_setsmoothing(unsigned int, unsigned int);")}, {FUNC(adc_sample), PROTO("int adc_sample(unsigned int, unsigned int);")}, {FUNC(adc_getsample), PROTO("int adc_getsample(unsigned int);")}, #if defined (BUF_ENABLE_ADC) {FUNC(adc_getsamples), PROTO("void adc_getsamples(int, unsigned int, int *);")}, {FUNC(adc_insertsamples), PROTO("void adc_insertsamples(unsigned int,\ int *, unsigned int, unsigned int);")}, #endif {NILFUNC, NILPROTO} }; // Init library.