int
pkgsrc_mkstemp(char *path)
{
int fd;
return (gettemp(path, &fd, 0) ? fd : -1);
}
void rofreq()
{
int val;
int last;
int t;
/* reset into debug mode, so this will always work */
tdc->DCTL = TDC_DCTL_REQ;
tdc->CS = TDC_CS_RST;
while(!(tdc->DCTL & TDC_DCTL_ACK));
while(!readchar_nonblock()) {
t = gettemp();
printf("%d.%04d", t/16, (t%16)*625);
do {
tdc->FCC = TDC_FCC_ST;
while(!(tdc->FCC & TDC_FCC_RDY));
val = tdc->FCR;
printf(",%d", val);
last = tdc->CSEL & TDC_CSEL_LAST;
tdc->CSEL = TDC_CSEL_NEXT;
} while(!last);
printf("\n");
}
tdc->DCTL = 0;
tdc->CS = TDC_CS_RST;
}
Cell *cat(Node **a, int q) /* a[0] cat a[1] */
{
Cell *x, *y, *z;
int n1, n2;
char *s;
x = execute(a[0]);
y = execute(a[1]);
getsval(x);
getsval(y);
n1 = strlen(x->sval);
n2 = strlen(y->sval);
s = (char *) malloc(n1 + n2 + 1);
if (s == NULL)
ERROR "out of space concatenating %.15s... and %.15s...",
x->sval, y->sval FATAL;
strcpy(s, x->sval);
strcpy(s+n1, y->sval);
tempfree(y);
z = gettemp();
z->sval = s;
z->tval = STR;
tempfree(x);
return(z);
}
Cell *closefile(Node **a, int n)
{
Cell *x;
int i, stat;
n = n;
x = execute(a[0]);
getsval(x);
stat = -1;
for (i = 0; i < nfiles; i++) {
if (files[i].fname && strcmp(x->sval, files[i].fname) == 0) {
if (ferror(files[i].fp))
WARNING( "i/o error occurred on %s", files[i].fname );
if (files[i].mode == '|' || files[i].mode == LE)
stat = pclose(files[i].fp);
else
stat = fclose(files[i].fp);
if (stat == EOF)
WARNING( "i/o error occurred closing %s", files[i].fname );
if (i > 2) /* don't do /dev/std... */
xfree(files[i].fname);
files[i].fname = NULL; /* watch out for ref thru this */
files[i].fp = NULL;
}
}
tempfree(x);
x = gettemp();
setfval(x, (Awkfloat) stat);
return(x);
}
int main(void) {
char status[100];
int l = 0;
if (!(dpy = XOpenDisplay(NULL))) {
fprintf(stderr, "Cannot open display.\n");
return 1;
}
for (;;sleep(2)) {
l = getcpu(status, sizeof(status));
l += gettemp(status + l, sizeof(status) - l);
l += getmem(status + l, sizeof(status) - l);
l += getnetwork(status + l, sizeof(status) - l);
l += getbattery(status + l, sizeof(status) - l);
l += getvol(status + l, sizeof(status) - l);
l += getdatetime(status + l, sizeof(status) - l);
setstatus(status);
}
free(status);
XCloseDisplay(dpy);
return 0;
}
Cell *sindex(Node **a, int nnn) /* index(a[0], a[1]) */
{
Cell *x, *y, *z;
char *s1, *s2, *p1, *p2, *q;
Awkfloat v = 0.0;
x = execute(a[0]);
s1 = getsval(x);
y = execute(a[1]);
s2 = getsval(y);
z = gettemp();
for (p1 = s1; *p1 != '\0'; p1++) {
for (q=p1, p2=s2; *p2 != '\0' && *q == *p2; q++, p2++)
;
if (*p2 == '\0') {
v = (Awkfloat) (p1 - s1 + 1); /* origin 1 */
break;
}
}
tempfree(x);
tempfree(y);
setfval(z, v);
return(z);
}
Cell *substr(Node **a, int nnn) /* substr(a[0], a[1], a[2]) */
{
int k, m, n;
char *s;
int temp;
Cell *x, *y, *z = 0;
x = execute(a[0]);
y = execute(a[1]);
if (a[2] != 0)
z = execute(a[2]);
s = getsval(x);
k = strlen(s) + 1;
if (k <= 1) {
tempfree(x);
tempfree(y);
if (a[2] != 0) {
tempfree(z);
}
x = gettemp();
setsval(x, "");
return(x);
}
m = (int) getfval(y);
if (m <= 0)
m = 1;
else if (m > k)
m = k;
tempfree(y);
if (a[2] != 0) {
n = (int) getfval(z);
tempfree(z);
} else
n = k - 1;
if (n < 0)
n = 0;
else if (n > k - m)
n = k - m;
dprintf( ("substr: m=%d, n=%d, s=%s\n", m, n, s) );
y = gettemp();
temp = s[n+m-1]; /* with thanks to John Linderman */
s[n+m-1] = '\0';
setsval(y, s + m - 1);
s[n+m-1] = temp;
tempfree(x);
return(y);
}
void show_received_data(){
ow_process_resdata = NULL;
temp_readed = gettemp();
if(temp_readed == ERR_TEMP_VAL){
if(delete_notexistant){
erase_saved_ROM(starting_val);
}
}
temp_ready = 1;
}
int main () {
Temp t;
while (gettemp (&t) != EOF) {
convert (&t);
printf ("%f %c\n", t.value, (t.type == 'c' || t.type == 'C') ? 'F' : 'C');
}
return 0;
}
int qUo( char op, int op1 ){ /* ret := op op1, jump to op1, parm op1 */
Type tp1; int trg; int qud;
switch (op) {
case 'M':
if(tp(op1)==ITP) { trg = gettemp( ITP ); }
if(tp(op1)==RTP) { trg = gettemp( RTP ); }
gen(op,op1,-1,trg); return trg;
case 'N':
trg = gettemp(ITP);
gen(op,op1,-1,trg); return trg;
case 'z':
qud = nextQ();
gen(op,op1,-1,-1); return qud;
case 'j':
qud = nextQ();
gen(op,-1,-1,-1); return qud;
case 'I':
trg = gettemp(ITP);
gen(op,op1,-1,trg); return trg;
case 'R':
trg = gettemp(RTP);
gen(op,op1,-1,trg); return trg;
case '&':
trg = gettemp(ITP);
gen(op,op1,-1,trg); return trg;
default: yyerror("bad qUo");
}
}
Cell *awkgetline(Node **a, int n) /* get next line from specific input */
{ /* a[0] is variable, a[1] is operator, a[2] is filename */
Cell *r, *x;
extern Cell **fldtab;
FILE *fp;
char *buf;
int bufsize = recsize;
int mode;
if ((buf = (char *) malloc(bufsize)) == NULL)
FATAL("out of memory in getline");
fflush(stdout); /* in case someone is waiting for a prompt */
r = gettemp();
if (a[1] != NULL) { /* getline < file */
x = execute(a[2]); /* filename */
mode = ptoi(a[1]);
if (mode == '|') /* input pipe */
mode = LE; /* arbitrary flag */
fp = openfile(mode, getsval(x));
tempfree(x);
if (fp == NULL)
n = -1;
else
n = readrec(&buf, &bufsize, fp);
if (n <= 0) {
;
} else if (a[0] != NULL) { /* getline var <file */
x = execute(a[0]);
setsval(x, buf);
tempfree(x);
} else { /* getline <file */
setsval(fldtab[0], buf);
if (is_number(fldtab[0]->sval)) {
fldtab[0]->fval = atof(fldtab[0]->sval);
fldtab[0]->tval |= NUM;
}
}
} else { /* bare getline; use current input */
if (a[0] == NULL) /* getline */
n = getrec(&record, &recsize, 1);
else { /* getline var */
n = getrec(&buf, &bufsize, 0);
x = execute(a[0]);
setsval(x, buf);
tempfree(x);
}
}
setfval(r, (Awkfloat) n);
free(buf);
return r;
}
Cell *copycell(Cell *x) /* make a copy of a cell in a temp */
{
Cell *y;
y = gettemp();
y->csub = CCOPY; /* prevents freeing until call is over */
y->nval = x->nval;
y->sval = x->sval ? tostring(x->sval) : NULL;
y->fval = x->fval;
y->tval = x->tval & ~(CON|FLD|REC|DONTFREE); /* copy is not constant or field */
/* is DONTFREE right? */
return y;
}
Cell *arith(Node **a, int n) /* a[0] + a[1], etc. also -a[0] */
{
Awkfloat i, j = 0;
double v;
Cell *x, *y, *z;
x = execute(a[0]);
i = getfval(x);
tempfree(x);
if (n != UMINUS) {
y = execute(a[1]);
j = getfval(y);
tempfree(y);
}
z = gettemp();
switch (n) {
case ADD:
i += j;
break;
case MINUS:
i -= j;
break;
case MULT:
i *= j;
break;
case DIVIDE:
if (j == 0)
ERROR "division by zero" FATAL;
i /= j;
break;
case MOD:
if (j == 0)
ERROR "division by zero in mod" FATAL;
modf(i/j, &v);
i = i - j * v;
break;
case UMINUS:
i = -i;
break;
case POWER:
if (j >= 0 && modf(j, &v) == 0.0) /* pos integer exponent */
i = ipow(i, (int) j);
else
i = errcheck(pow(i, j), "pow");
break;
default: /* can't happen */
ERROR "illegal arithmetic operator %d", n FATAL;
}
setfval(z, i);
return(z);
}
/*****************************************************************************
*
* mapcase maps the case tree, tptr.
*
*****************************************************************************/
PUBLIC void mapcase (treenode * tptr)
{
treenode *selector_exp;
treenode *selectionlist = RHSOf (tptr);
mapexp (LHSAddr (tptr));
selector_exp = LHSOf (tptr);
if (!issimplelocal (selector_exp, be_lexlevel)) {
selector_exp = gettemp (selector_exp, NM_WORKSPACE);
SetLHS (tptr, selector_exp);
}
if (nodetypeoftag (TagOf (selector_exp)) == NAMENODE) /* bug INSdi01959 06/04/93 */
upusecount (selector_exp, 4);
mapconstruction (selectionlist, mapprocess);
}
Cell *awksprintf(Node **a, int n) /* sprintf(a[0]) */
{
Cell *x;
Node *y;
char buf[3*RECSIZE];
y = a[0]->nnext;
x = execute(a[0]);
if (format(buf, sizeof buf, getsval(x), y) == -1)
ERROR "sprintf string %.30s... too long", buf FATAL;
tempfree(x);
x = gettemp();
x->sval = tostring(buf);
x->tval = STR;
return(x);
}
Cell *getline(Node **a, int n) /* get next line from specific input */
{ /* a[0] is variable, a[1] is operator, a[2] is filename */
Cell *r, *x;
char buf[RECSIZE];
FILE *fp;
fflush(stdout); /* in case someone is waiting for a prompt */
r = gettemp();
if (a[1] != NULL) { /* getline < file */
x = execute(a[2]); /* filename */
if ((int) a[1] == '|') /* input pipe */
a[1] = (Node *) LE; /* arbitrary flag */
fp = openfile((int) a[1], getsval(x));
tempfree(x);
if (fp == NULL)
n = -1;
else
n = readrec(buf, sizeof(buf), fp);
if (n <= 0) {
;
} else if (a[0] != NULL) { /* getline var <file */
setsval(execute(a[0]), buf);
} else { /* getline <file */
if (!(recloc->tval & DONTFREE))
xfree(recloc->sval);
strcpy(record, buf);
recloc->sval = record;
recloc->tval = REC | STR | DONTFREE;
if (isnumber(recloc->sval)) {
recloc->fval = atof(recloc->sval);
recloc->tval |= NUM;
}
donerec = 1; donefld = 0;
}
} else { /* bare getline; use current input */
if (a[0] == NULL) /* getline */
n = getrec(record);
else { /* getline var */
n = getrec(buf);
setsval(execute(a[0]), buf);
}
}
setfval(r, (Awkfloat) n);
return r;
}
Cell *awksprintf(Node **a, int n) /* sprintf(a[0]) */
{
Cell *x;
Node *y;
char *buf;
int bufsz=3*recsize;
if ((buf = (char *) malloc(bufsz)) == NULL)
FATAL("out of memory in awksprintf");
y = a[0]->nnext;
x = execute(a[0]);
if (format(&buf, &bufsz, getsval(x), y) == -1)
FATAL("sprintf string %.30s... too long. can't happen.", buf);
tempfree(x);
x = gettemp();
x->sval = buf;
x->tval = STR;
return(x);
}
Cell *incrdecr(Node **a, int n) /* a[0]++, etc. */
{
Cell *x, *z;
int k;
Awkfloat xf;
x = execute(a[0]);
xf = getfval(x);
k = (n == PREINCR || n == POSTINCR) ? 1 : -1;
if (n == PREINCR || n == PREDECR) {
setfval(x, xf + k);
return(x);
}
z = gettemp();
setfval(z, xf);
setfval(x, xf + k);
tempfree(x);
return(z);
}
int
main(void)
{
char *status;
/*char *avgs;*/
char *tmcentral;
char *cpu;
char *battery;
char *ifaddr;
char *temp;
int i = 0;
if (!(dpy = XOpenDisplay(NULL))) {
fprintf(stderr, "dwmstatus: cannot open display.\n");
return 1;
}
/* Clear old_stats for cpu usage*/
for(i = 0; i < 10; ++i)
old_stats[i] = 0;
for (;;sleep(1)) {
/*avgs = loadavg();*/
cpu = cpu_usage();
tmcentral = mktimes("%Y-%m-%d %H:%M:%S", tzcentral);
battery = getbattery();
ifaddr = getifaddr();
temp = gettemp();
status = smprintf("%s | %s BAT %s | CPU %s | %s",
temp, ifaddr, battery, cpu, tmcentral);
setstatus(status);
/*free(avgs);*/
free(tmcentral);
free(status);
free(ifaddr);
}
XCloseDisplay(dpy);
return 0;
}
int main(int argc, char *argv[])
{
// Check input arguments
if(argc>2){
printf("Too many arguments!\n");
exit(1);
}
else if(argc<2){
printf("Usage: (Start command) /path/to/target/file\n");
exit(1);
}
// Get user input file path.
char *path = argv[1];
// Read and write loop.
while (true){
gettemp();
writetemp(path);
sleep(INTERVAL);
}
}
Cell *matchop(Node **a, int n) /* ~ and match() */
{
Cell *x, *y;
char *s, *t;
int i;
fa *pfa;
int (*mf)(fa *, char *) = match, mode = 0;
if (n == MATCHFCN) {
mf = pmatch;
mode = 1;
}
x = execute(a[1]); /* a[1] = target text */
s = getsval(x);
if (a[0] == 0) /* a[1] == 0: already-compiled reg expr */
i = (*mf)((fa *) a[2], s);
else {
y = execute(a[2]); /* a[2] = regular expr */
t = getsval(y);
pfa = makedfa(t, mode);
i = (*mf)(pfa, s);
tempfree(y);
}
tempfree(x);
if (n == MATCHFCN) {
int start = patbeg - s + 1;
if (patlen < 0)
start = 0;
setfval(rstartloc, (Awkfloat) start);
setfval(rlengthloc, (Awkfloat) patlen);
x = gettemp();
x->tval = NUM;
x->fval = start;
return x;
} else if ((n == MATCH && i == 1) || (n == NOTMATCH && i == 0))
return(true);
else
return(false);
}
int main (void)
{
CURL *curl=NULL;
char data[32]="";
int i;
i=gettemp();
if(i==-1)
{
printf("get temp data error!");
return -1;
}
sprintf(data,"{\"value\":%d}",i);
CURLcode res;
curl_global_init(CURL_GLOBAL_ALL);
curl=curl_easy_init();//初始化
if(curl != NULL)
{
curl_easy_setopt(curl,CURLOPT_URL,"http://api.yeelink.net/v1.0/device/343257/sensor/382812/datapoints");//前一个数字为设备号，后一个数字为传感器号。
struct curl_slist *plist = curl_slist_append(NULL,"U-ApiKey:225b4a9d7cfa28197eba45c23a920728");//api-key换成自己的。
curl_slist_append(plist,"Content-Type:application/json");
curl_easy_setopt(curl,CURLOPT_HTTPHEADER,plist);
curl_easy_setopt(curl,CURLOPT_POSTFIELDS,data);
res = curl_easy_perform(curl);
if(res != CURLE_OK)
{
printf("%s\n\n",curl_easy_strerror(res));
}
curl_easy_cleanup(curl);
}
curl_global_cleanup();//清空，结束。
return 0;
}
static int
mkstemp(char *path, isc_boolean_t binary) {
int fd;
return (gettemp(path, binary, &fd) ? fd : -1);
}
Cell *bltin(Node **a, int n) /* builtin functions. a[0] is type, a[1] is arg list */
{
Cell *x, *y;
Awkfloat u;
int t;
Awkfloat tmp;
char *p, *buf;
Node *nextarg;
FILE *fp;
void flush_all(void);
t = ptoi(a[0]);
x = execute(a[1]);
nextarg = a[1]->nnext;
switch (t) {
case FLENGTH:
if (isarr(x))
u = ((Array *) x->sval)->nelem; /* GROT. should be function*/
else
u = strlen(getsval(x));
break;
case FLOG:
u = errcheck(log(getfval(x)), "log"); break;
case FINT:
modf(getfval(x), &u); break;
case FEXP:
u = errcheck(exp(getfval(x)), "exp"); break;
case FSQRT:
u = errcheck(sqrt(getfval(x)), "sqrt"); break;
case FSIN:
u = sin(getfval(x)); break;
case FCOS:
u = cos(getfval(x)); break;
case FATAN:
if (nextarg == 0) {
WARNING("atan2 requires two arguments; returning 1.0");
u = 1.0;
} else {
y = execute(a[1]->nnext);
u = atan2(getfval(x), getfval(y));
tempfree(y);
nextarg = nextarg->nnext;
}
break;
case FSYSTEM:
fflush(stdout); /* in case something is buffered already */
u = (Awkfloat) system(getsval(x)) / 256; /* 256 is unix-dep */
break;
case FRAND:
/* in principle, rand() returns something in 0..RAND_MAX */
u = (Awkfloat) (rand() % RAND_MAX) / RAND_MAX;
break;
case FSRAND:
if (isrec(x)) /* no argument provided */
u = time((time_t *)0);
else
u = getfval(x);
tmp = u;
srand((unsigned int) u);
u = srand_seed;
srand_seed = tmp;
break;
case FTOUPPER:
case FTOLOWER:
buf = tostring(getsval(x));
if (t == FTOUPPER) {
for (p = buf; *p; p++)
if (islower((uschar) *p))
*p = toupper((uschar)*p);
} else {
for (p = buf; *p; p++)
if (isupper((uschar) *p))
*p = tolower((uschar)*p);
}
tempfree(x);
x = gettemp();
setsval(x, buf);
free(buf);
return x;
case FFLUSH:
if (isrec(x) || strlen(getsval(x)) == 0) {
flush_all(); /* fflush() or fflush("") -> all */
u = 0;
} else if ((fp = openfile(FFLUSH, getsval(x))) == NULL)
u = EOF;
else
u = fflush(fp);
break;
default: /* can't happen */
FATAL("illegal function type %d", t);
break;
}
tempfree(x);
x = gettemp();
setfval(x, u);
if (nextarg != 0) {
WARNING("warning: function has too many arguments");
for ( ; nextarg; nextarg = nextarg->nnext)
execute(nextarg);
}
return(x);
}
Cell *gsub(Node **a, int nnn) /* global substitute */
{
Cell *x, *y;
char *rptr, *sptr, *t, *pb, *q;
char *buf;
fa *pfa;
int mflag, tempstat, num;
int bufsz = recsize;
if ((buf = (char *) malloc(bufsz)) == NULL)
FATAL("out of memory in gsub");
mflag = 0; /* if mflag == 0, can replace empty string */
num = 0;
x = execute(a[3]); /* target string */
t = getsval(x);
if (a[0] == 0) /* 0 => a[1] is already-compiled regexpr */
pfa = (fa *) a[1]; /* regular expression */
else {
y = execute(a[1]);
pfa = makedfa(getsval(y), 1);
tempfree(y);
}
y = execute(a[2]); /* replacement string */
if (pmatch(pfa, t)) {
tempstat = pfa->initstat;
pfa->initstat = 2;
pb = buf;
rptr = getsval(y);
do {
if (patlen == 0 && *patbeg != 0) { /* matched empty string */
if (mflag == 0) { /* can replace empty */
num++;
sptr = rptr;
while (*sptr != 0) {
adjbuf(&buf, &bufsz, 5+pb-buf, recsize, &pb, "gsub");
if (*sptr == '\\') {
backsub(&pb, &sptr);
} else if (*sptr == '&') {
sptr++;
adjbuf(&buf, &bufsz, 1+patlen+pb-buf, recsize, &pb, "gsub");
for (q = patbeg; q < patbeg+patlen; )
*pb++ = *q++;
} else
*pb++ = *sptr++;
}
}
if (*t == 0) /* at end */
goto done;
adjbuf(&buf, &bufsz, 2+pb-buf, recsize, &pb, "gsub");
*pb++ = *t++;
if (pb > buf + bufsz) /* BUG: not sure of this test */
FATAL("gsub result0 %.30s too big; can't happen", buf);
mflag = 0;
}
else { /* matched nonempty string */
num++;
sptr = t;
adjbuf(&buf, &bufsz, 1+(patbeg-sptr)+pb-buf, recsize, &pb, "gsub");
while (sptr < patbeg)
*pb++ = *sptr++;
sptr = rptr;
while (*sptr != 0) {
adjbuf(&buf, &bufsz, 5+pb-buf, recsize, &pb, "gsub");
if (*sptr == '\\') {
backsub(&pb, &sptr);
} else if (*sptr == '&') {
sptr++;
adjbuf(&buf, &bufsz, 1+patlen+pb-buf, recsize, &pb, "gsub");
for (q = patbeg; q < patbeg+patlen; )
*pb++ = *q++;
} else
*pb++ = *sptr++;
}
t = patbeg + patlen;
if (patlen == 0 || *t == 0 || *(t-1) == 0)
goto done;
if (pb > buf + bufsz)
FATAL("gsub result1 %.30s too big; can't happen", buf);
mflag = 1;
}
} while (pmatch(pfa,t));
sptr = t;
adjbuf(&buf, &bufsz, 1+strlen(sptr)+pb-buf, 0, &pb, "gsub");
while ((*pb++ = *sptr++) != 0)
;
done: if (pb < buf + bufsz)
*pb = '\0';
else if (*(pb-1) != '\0')
FATAL("gsub result2 %.30s truncated; can't happen", buf);
setsval(x, buf); /* BUG: should be able to avoid copy + free */
pfa->initstat = tempstat;
}
tempfree(x);
tempfree(y);
x = gettemp();
x->tval = NUM;
x->fval = num;
free(buf);
return(x);
}
static int mkstemp (char *path)
{
int fd;
return (gettemp (path, &fd) ? fd : -1);
}
Cell *split(Node **a, int nnn) /* split(a[0], a[1], a[2]); a[3] is type */
{
Cell *x = 0, *y, *ap;
char *s;
int sep;
char *t, temp, num[10], *fs = 0;
int n, tempstat;
y = execute(a[0]); /* source string */
s = getsval(y);
if (a[2] == 0) /* fs string */
fs = *FS;
else if ((int) a[3] == STRING) { /* split(str,arr,"string") */
x = execute(a[2]);
fs = getsval(x);
} else if ((int) a[3] == REGEXPR)
fs = (char*) "(regexpr)"; /* split(str,arr,/regexpr/) */
else
ERROR "illegal type of split()" FATAL;
sep = *fs;
ap = execute(a[1]); /* array name */
freesymtab(ap);
dprintf( ("split: s=|%s|, a=%s, sep=|%s|\n", s, ap->nval, fs) );
ap->tval &= ~STR;
ap->tval |= ARR;
ap->sval = (char *) makesymtab(NSYMTAB);
n = 0;
if ((*s != '\0' && strlen(fs) > 1) || (int) a[3] == REGEXPR) { /* reg expr */
fa *pfa;
if ((int) a[3] == REGEXPR) { /* it's ready already */
pfa = (fa *) a[2];
} else {
pfa = makedfa(fs, 1);
}
if (nematch(pfa,s)) {
tempstat = pfa->initstat;
pfa->initstat = 2;
do {
n++;
sprintf((char *)num, "%d", n);
temp = *patbeg;
*patbeg = '\0';
if (isnumber(s))
setsymtab(num, s, atof((char *)s), STR|NUM, (Array *) ap->sval);
else
setsymtab(num, s, 0.0, STR, (Array *) ap->sval);
*patbeg = temp;
s = patbeg + patlen;
if (*(patbeg+patlen-1) == 0 || *s == 0) {
n++;
sprintf((char *)num, "%d", n);
setsymtab(num, "", 0.0, STR, (Array *) ap->sval);
pfa->initstat = tempstat;
goto spdone;
}
} while (nematch(pfa,s));
}
n++;
sprintf((char *)num, "%d", n);
if (isnumber(s))
setsymtab(num, s, atof((char *)s), STR|NUM, (Array *) ap->sval);
else
setsymtab(num, s, 0.0, STR, (Array *) ap->sval);
spdone:
pfa = NULL;
} else if (sep == ' ') {
for (n = 0; ; ) {
while (*s == ' ' || *s == '\t' || *s == '\n')
s++;
if (*s == 0)
break;
n++;
t = s;
do
s++;
while (*s!=' ' && *s!='\t' && *s!='\n' && *s!='\0');
temp = *s;
*s = '\0';
sprintf((char *)num, "%d", n);
if (isnumber(t))
setsymtab(num, t, atof((char *)t), STR|NUM, (Array *) ap->sval);
else
setsymtab(num, t, 0.0, STR, (Array *) ap->sval);
*s = temp;
if (*s != 0)
s++;
}
} else if (sep == 0) { /* new: split(s, a, "") => 1 char/elem */
for (n = 0; *s != 0; s++) {
char buf[2];
n++;
sprintf((char *)num, "%d", n);
buf[0] = *s;
buf[1] = 0;
if (isdigit(buf[0]))
setsymtab(num, buf, atof(buf), STR|NUM, (Array *) ap->sval);
else
setsymtab(num, buf, 0.0, STR, (Array *) ap->sval);
}
} else if (*s != 0) {
for (;;) {
n++;
t = s;
while (*s != sep && *s != '\n' && *s != '\0')
s++;
temp = *s;
*s = '\0';
sprintf((char *)num, "%d", n);
if (isnumber(t))
setsymtab(num, t, atof((char *)t), STR|NUM, (Array *) ap->sval);
else
setsymtab(num, t, 0.0, STR, (Array *) ap->sval);
*s = temp;
if (*s++ == 0)
break;
}
}
tempfree(ap);
tempfree(y);
if (a[2] != 0 && (int) a[3] == STRING)
tempfree(x);
x = gettemp();
x->tval = NUM;
x->fval = n;
return(x);
}
int qOp( char op, int op1, int op2){ /* ret := op1 op op2 */
Type tp1,tp2; int trg; int n;
/*printf("qOp %c\n",op);*/
switch(op){
case '+': case '-': case '*': case '/': case '>': case '<': case 'E':
if(tp(op1)==ITP && tp(op2)==ITP) { trg = gettemp( ITP ); gen(op,op1,op2,trg); return trg;}
if(tp(op1)==RTP && tp(op2)==RTP) { trg = gettemp( RTP ); gen(op,op1,op2,trg); return trg;}
if(tp(op1)==ITP && tp(op2)==RTP) { op1 = qUo('R', op1); trg = gettemp( RTP ); gen(op,op1,op2,trg); return trg;}
if(tp(op1)==RTP && tp(op2)==ITP) { op2 = qUo('R', op2); trg = gettemp( RTP ); gen(op,op1,op2,trg); return trg;}
yyerror("Operands are not the same type!");
case 'A': case 'O':
trg = gettemp( ITP );
gen(op,op1,op2,trg); return trg;
case '%':
if(tp(op1)==ITP && tp(op2)==ITP) { trg = gettemp( ITP ); gen(op,op1,op2,trg); return trg;}
yyerror("Operand are not integer!");
case 'V':
if(op2 == -1){
trg = gettemp(ITP);
gen(op,op1,-1,trg); return trg;
}
else{
trg = gettemp(RTP);
gen(op,op1,op2,trg); return trg;
}
case '@':
if(op2 == -1){
n = tp(op1);
switch(n){
case ITP: trg = gettemp( ITP );
case RTP: trg = gettemp( RTP );
}
}
else{
n = tp(op2);
switch(n){
case ITP: trg = gettemp( ITP );
case RTP: trg = gettemp( RTP );
}
}
gen(op,op1,op2,trg); return trg;
default: yyerror("bad qOp");
}
}
Cell *call(Node **a, int n) /* function call. very kludgy and fragile */
{
static Cell newcopycell = { OCELL, CCOPY, 0, (char *) "", 0.0, NUM|STR|DONTFREE };
int i, ncall, ndef;
Node *x;
Cell *args[NARGS], *oargs[NARGS], *y, *z, *fcn;
char *s;
fcn = execute(a[0]); /* the function itself */
s = fcn->nval;
if (!isfunc(fcn))
ERROR "calling undefined function %s", s FATAL;
if (frame == NULL) {
fp = frame = (struct Frame *) calloc(nframe += 100, sizeof(struct Frame));
if (frame == NULL)
ERROR "out of space for stack frames calling %s", s FATAL;
}
for (ncall = 0, x = a[1]; x != NULL; x = x->nnext) /* args in call */
ncall++;
ndef = (int) fcn->fval; /* args in defn */
dprintf( ("calling %s, %d args (%d in defn), fp=%d\n", s, ncall, ndef, fp-frame) );
if (ncall > ndef)
ERROR "function %s called with %d args, uses only %d",
s, ncall, ndef WARNING;
if (ncall + ndef > NARGS)
ERROR "function %s has %d arguments, limit %d", s, ncall+ndef, NARGS FATAL;
for (i = 0, x = a[1]; x != NULL; i++, x = x->nnext) { /* get call args */
dprintf( ("evaluate args[%d], fp=%d:\n", i, fp-frame) );
y = execute(x);
oargs[i] = y;
dprintf( ("args[%d]: %s %f <%s>, t=%o\n",
i, y->nval, y->fval, isarr(y) ? "(array)" : (char*) y->sval, y->tval) );
if (isfunc(y))
ERROR "can't use function %s as argument in %s", y->nval, s FATAL;
if (isarr(y))
args[i] = y; /* arrays by ref */
else
args[i] = copycell(y);
tempfree(y);
}
for ( ; i < ndef; i++) { /* add null args for ones not provided */
args[i] = gettemp();
*args[i] = newcopycell;
}
fp++; /* now ok to up frame */
if (fp >= frame + nframe) {
int dfp = fp - frame; /* old index */
frame = (struct Frame *)
realloc((char *) frame, (nframe += 100) * sizeof(struct Frame));
if (frame == NULL)
ERROR "out of space for stack frames in %s", s FATAL;
fp = frame + dfp;
}
fp->fcncell = fcn;
fp->args = args;
fp->nargs = ndef; /* number defined with (excess are locals) */
fp->retval = gettemp();
dprintf( ("start exec of %s, fp=%d\n", s, fp-frame) );
y = execute((Node *)(fcn->sval)); /* execute body */
dprintf( ("finished exec of %s, fp=%d\n", s, fp-frame) );
for (i = 0; i < ndef; i++) {
Cell *t = fp->args[i];
if (isarr(t)) {
if (t->csub == CCOPY) {
if (i >= ncall) {
freesymtab(t);
t->csub = CTEMP;
} else {
oargs[i]->tval = t->tval;
oargs[i]->tval &= ~(STR|NUM|DONTFREE);
oargs[i]->sval = t->sval;
tempfree(t);
}
}
} else if (t != y) { /* kludge to prevent freeing twice */
t->csub = CTEMP;
tempfree(t);
}
}
tempfree(fcn);
if (isexit(y) || isnext(y) || isnextfile(y))
return y;
tempfree(y); /* this can free twice! */
z = fp->retval; /* return value */
dprintf( ("%s returns %g |%s| %o\n", s, getfval(z), getsval(z), z->tval) );
fp--;
return(z);
}
Cell *split(Node **a, int nnn) /* split(a[0], a[1], a[2]); a[3] is type */
{
Cell *x = 0, *y, *ap;
char *s, *origs;
int sep;
char *t, temp, num[50], *fs = 0;
int n, tempstat, arg3type;
y = execute(a[0]); /* source string */
origs = s = strdup(getsval(y));
arg3type = ptoi(a[3]);
if (a[2] == 0) /* fs string */
fs = *FS;
else if (arg3type == STRING) { /* split(str,arr,"string") */
x = execute(a[2]);
fs = getsval(x);
} else if (arg3type == REGEXPR)
fs = "(regexpr)"; /* split(str,arr,/regexpr/) */
else
FATAL("illegal type of split");
sep = *fs;
ap = execute(a[1]); /* array name */
freesymtab(ap);
dprintf( ("split: s=|%s|, a=%s, sep=|%s|\n", s, NN(ap->nval), fs) );
ap->tval &= ~STR;
ap->tval |= ARR;
ap->sval = (char *) makesymtab(NSYMTAB);
n = 0;
if (arg3type == REGEXPR && strlen((char*)((fa*)a[2])->restr) == 0) {
/* split(s, a, //); have to arrange that it looks like empty sep */
arg3type = 0;
fs = "";
sep = 0;
}
if (*s != '\0' && (strlen(fs) > 1 || arg3type == REGEXPR)) { /* reg expr */
fa *pfa;
if (arg3type == REGEXPR) { /* it's ready already */
pfa = (fa *) a[2];
} else {
pfa = makedfa(fs, 1);
}
if (nematch(pfa,s)) {
tempstat = pfa->initstat;
pfa->initstat = 2;
do {
n++;
sprintf(num, "%d", n);
temp = *patbeg;
*patbeg = '\0';
if (is_number(s))
setsymtab(num, s, atof(s), STR|NUM, (Array *) ap->sval);
else
setsymtab(num, s, 0.0, STR, (Array *) ap->sval);
*patbeg = temp;
s = patbeg + patlen;
if (*(patbeg+patlen-1) == 0 || *s == 0) {
n++;
sprintf(num, "%d", n);
setsymtab(num, "", 0.0, STR, (Array *) ap->sval);
pfa->initstat = tempstat;
goto spdone;
}
} while (nematch(pfa,s));
pfa->initstat = tempstat; /* bwk: has to be here to reset */
/* cf gsub and refldbld */
}
n++;
sprintf(num, "%d", n);
if (is_number(s))
setsymtab(num, s, atof(s), STR|NUM, (Array *) ap->sval);
else
setsymtab(num, s, 0.0, STR, (Array *) ap->sval);
spdone:
pfa = NULL;
} else if (sep == ' ') {
for (n = 0; ; ) {
while (*s == ' ' || *s == '\t' || *s == '\n')
s++;
if (*s == 0)
break;
n++;
t = s;
do
s++;
while (*s!=' ' && *s!='\t' && *s!='\n' && *s!='\0');
temp = *s;
*s = '\0';
sprintf(num, "%d", n);
if (is_number(t))
setsymtab(num, t, atof(t), STR|NUM, (Array *) ap->sval);
else
setsymtab(num, t, 0.0, STR, (Array *) ap->sval);
*s = temp;
if (*s != 0)
s++;
}
} else if (sep == 0) { /* new: split(s, a, "") => 1 char/elem */
for (n = 0; *s != 0; s++) {
char buf[2];
n++;
sprintf(num, "%d", n);
buf[0] = *s;
buf[1] = 0;
if (isdigit((uschar)buf[0]))
setsymtab(num, buf, atof(buf), STR|NUM, (Array *) ap->sval);
else
setsymtab(num, buf, 0.0, STR, (Array *) ap->sval);
}
} else if (*s != 0) {
for (;;) {
n++;
t = s;
while (*s != sep && *s != '\n' && *s != '\0')
s++;
temp = *s;
*s = '\0';
sprintf(num, "%d", n);
if (is_number(t))
setsymtab(num, t, atof(t), STR|NUM, (Array *) ap->sval);
else
setsymtab(num, t, 0.0, STR, (Array *) ap->sval);
*s = temp;
if (*s++ == 0)
break;
}
}
tempfree(ap);
tempfree(y);
free(origs);
if (a[2] != 0 && arg3type == STRING) {
tempfree(x);
}
x = gettemp();
x->tval = NUM;
x->fval = n;
return(x);
}
