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.
