int main(){
int pid, ret, i;
switch(pid=fork()){
case 0:
signal(SIGUSR1, happy);
do{
getcount(SIGUSR1);
getcount(SIGSTOP);
getcount(SIGCONT);
getcount(SIGWINCH);
getcount(SIGURG);
sleep(10);
}while(1);
break;
default:
ret = sigcounter(pid);
while(1){
sleep(10);
ret = kill(pid, SIGUSR1);
ret = kill(pid, SIGSTOP);
ret = kill(pid, SIGCONT);
ret = kill(pid, SIGWINCH);
ret = kill(pid, SIGURG);
}
}
return 0;
}
int main(){
int a, b, max, temp, i;
while(scanf("%d %d",&a,&b) == 2){
max = 1;
if (a > 0 && b < 1000000){
if (a<b){
for(i = a; i <= b; i++){
temp = getcount(i);
if(max < temp)
max = temp;
}
printf("%d %d %d\n",a, b, max);
}
else{
for(i = b; i <= a; i++){
temp = getcount(i);
if(max < temp)
max = temp;
}
printf("%d %d %d\n",a, b, max);
}
}
}
return 0;
}
// pos is the position in TCHARs, not bytes.
void StringList::delbypos(int pos)
{
TCHAR *s=(TCHAR*) m_gr.get();
int len=_tcslen(s+pos)+1;
if (pos+len < getcount())
{
// Move everything after the string position to the current position.
memcpy(s+pos,s+pos+len, (getcount()-pos+len)*sizeof(TCHAR));
}
m_gr.resize(m_gr.getlen()-len*sizeof(TCHAR));
}
std::vector<uint256> stledgerentry::getowners ()
{
std::vector<uint256> owners;
account account;
for (int i = 0, fields = getcount (); i < fields; ++i)
{
auto const& fc = getfieldstype (i);
if ((fc == sfaccount) || (fc == sfowner))
{
auto entry = dynamic_cast<const staccount*> (peekatpindex (i));
if ((entry != nullptr) && entry->getvalueh160 (account))
owners.push_back (getaccountrootindex (account));
}
if ((fc == sflowlimit) || (fc == sfhighlimit))
{
auto entry = dynamic_cast<const stamount*> (peekatpindex (i));
if ((entry != nullptr))
{
auto issuer = entry->getissuer ();
if (issuer.isnonzero ())
owners.push_back (getaccountrootindex (issuer));
}
}
}
return owners;
}
arr () {
++count;
getcount();
if (arr::count==3) {
throw 1;
}
};
int
main(int argc, char *argv[])
{
printf(1, "The number of the context switches: %d\n",
getcount());
exit();
}
// use 2 for case sensitive end-of-string matches too
int StringList::find(const TCHAR *str, int case_sensitive, int *idx/*=NULL*/) const // returns -1 if not found
{
const TCHAR *s=get();
int ml=getcount();
int offs=0;
size_t str_slen = _tcslen(str);
size_t offs_slen;
if (idx) *idx=0;
while (offs < ml)
{
// Check if the whole string matches str.
if ((case_sensitive && !_tcscmp(s+offs,str)) ||
(!case_sensitive && !_tcsicmp(s+offs,str)))
{
return offs;
}
offs_slen = _tcslen(s+offs);
// Check if just the end of the string matches str.
if (case_sensitive==2 &&
str_slen < offs_slen && // check for end of string
!_tcscmp(s + offs + offs_slen - str_slen,str))
{
return offs + offs_slen - str_slen;
}
offs += offs_slen + 1;
if (idx) (*idx)++;
}
return -1;
}
void evaldeadgroupeye(int s,int g,int c){
int s1,s2,e1,e2;
int rn,ldrno;
int ptr;
if(eyerec[mvs[grpieces[g]]] != 0)return; /* already did this eye */
rn = gtflist(&eyefreelist);
for(ptr = grpieces[g]; ptr != -1; ptr = mvnext[ptr]){
eyerec[mvs[ptr]] = rn;
addlist(mvs[ptr],&eyeptr[rn]);
}
ldrno = NUMGROUPS+NUMCONNS+mvs[grpieces[g]];
if(gralive[g] == DEAD)
eyetype[rn] = DEADEYE;
else
eyetype[rn] = THRTEYE;
if(grsize[g] == 1)
evaloneptdeadeye(s,g,c,rn,ldrno);
else if(grsize[g] == 2){
s1 = mvs[grpieces[g]];
s2 = mvs[mvnext[grpieces[g]]];
e1 = c8[getcount(s1,c,rn,FALSE,ldrno)];
e2 = c8[getcount(s2,c,rn,FALSE,ldrno)];
if(e1 + e2 == 16)
eyepot[rn] = eyeval[rn] = eyemin[rn] = 8;
else if(e1 + e2 == 12){
eyepot[rn] = 8;
eyeval[rn] = 4;
eyemin[rn] = 4;
if(e1 == 4)getcount(s1,c,rn,TRUE,ldrno); /* fix vital point */
else getcount(s2,c,rn,TRUE,ldrno);
}
}
else if(grsize[g] == 3){
eyepot[rn] = eyeval[rn] = eyemin[rn] = 8;
}
else if(grsize[g] < 7){
deadshape(g,rn);
}
else{
eyepot[rn] = eyeval[rn] = eyemin[rn] = 16;
}
}
int
main (int argc, char* argv[]) {
int n = 23;
int counts[n];
printf(1, "Hello world!\n");
getcount(counts, n);
printf(1, "count 0: %d\n", counts[22]);
exit();
}
// idx corresponds to the nth string in the list.
int StringList::idx2pos(int idx) const
{
TCHAR *s=(TCHAR*) m_gr.get();
int offs=0;
int cnt=0;
if (idx>=0) while (offs < getcount())
{
if (cnt++ == idx) return offs;
offs+=_tcslen(s+offs)+1;
}
return -1;
}
void* work(void * id)
{
int i = 10;
while (i--) {
acquire();
printf("#%d acquired sema at %d\n", *(int*)id, getcount());
usleep(rand() % 4000000); /* sleep 2 sec on average */
release();
usleep(0); /* effectively yield */
}
return 0;
}
/*******************************************************************************
This function evaluates the "count" function by traversing the data tree and
incrementing a counter for each node that satisifies the conditions of the
search.
*******************************************************************************/
static int
getcount(Datanode *dataptr, long fldbits, int depth, int maxdepth)
{
int c = 0;
if (dataptr->leftptr != NULL)
c += getcount(dataptr->leftptr, fldbits, depth, maxdepth);
if (!(fldbits & 1L<<(long)depth) || (curfldvalptrtbl[depth] != NULL &&
dataptr->argptr == &(curfldvalptrtbl[depth]->arg))) {
if (depth == maxdepth)
c += dataptr->count;
else if (dataptr->orthogptr != NULL)
c += getcount(dataptr->orthogptr, fldbits, depth+1, maxdepth);
}
if (dataptr->rightptr != NULL)
c += getcount(dataptr->rightptr, fldbits, depth, maxdepth);
return c;
}
void evalonepteye(int s,int c){
int rn,count;
rn = gtflist(&eyefreelist);
eyerec[s] = rn;
eyetype[rn] = ONEPOINTEYE;
addlist(s,&eyeptr[rn]);
count = getcount(s,c,rn,TRUE,NUMGROUPS+NUMCONNS+s);
eyepot[rn] = opt1[count];
eyeval[rn] = opt2[count];
eyemin[rn] = opt3[count];
}
void evalmanyeyespots(int rn,int sopen,int c,int numopenspots,int numenemyspots,int ldrno){
int sn2,eye_pot, count,opp_can_fill,flag,ptr2;
/* first see what happens if opponent moves in sopen */
if(numopenspots == 0){
mvcolor[msptr] = 1-c;
mvs[msptr] = sopen;
opp_can_fill = lupdate(msptr);
ldndate(msptr);
}
else opp_can_fill = TRUE;
if(opp_can_fill){
addlist(sopen,&eyevital[rn]);
addlist(rn,&eyevitrec[sopen]);
}
/* now see how many eyes we can make */
mvcolor[msptr] = c;
mvs[msptr] = sopen;
flag = lupdate(msptr);
upldrflags(msptr,ldrno);
++msptr;
eye_pot = 0;
for(ptr2 = eyeptr[rn]; ptr2 != EOL; ptr2 = links[ptr2]){
sn2 = list[ptr2];
count = getcount(sn2,c,rn,FALSE,ldrno);
eye_pot += cpot[count];
}
--msptr;
ldndate(msptr);
eyepot[rn] = eye_pot;
if(!opp_can_fill){
eyeval[rn] = eye_pot;
eyemin[rn] = eye_pot;
}
else if(eye_pot >= 16){ /* can make two eyes */
if(numopenspots > 1 || numenemyspots != 0)
eyeval[rn] = 0;
else
eyeval[rn] = 8;
if(numopenspots == 0 && numenemyspots == 0)
eyemin[rn] = eyeval[rn];
else eyemin[rn] = 0;
}
else if(ld[sopen] == 6 && eye_pot > 0){ /* enclosed 3 space eye */
eyeval[rn] = 8;
eyemin[rn] = 0;
}
}
int StringList::getnum() const
{
TCHAR *s=(TCHAR*) m_gr.get();
int ml=getcount();
int offs=0;
int idx=0;
while (offs < ml)
{
offs+=_tcslen(s+offs)+1;
idx++;
}
return idx;
}
int thefirstcommon(struct node * head1, struct node * head2)
{
int count1 = getcount(head1);
int count2 = getcount(head2);
if(count1 > count2)
{
int diff = abs(count1, count2);
_thefirstcommon(head1, head2, diff);
}
else
{
int diff = abs(count2,count1);
_thefirstcommon(head2, head1, diff);
}
int _thefirstcommon(struct head1, struct head2, int diff)
{
int count = diff;
while(count != 0)
{
head1 = head1 -> next;
--count;
}
while(head1 != NULL && head2 != NULL)
{
if(head1 -> data == head2 ->data)
return head1 -> data;
else
{
head1 = head1 -> next;
head2 = head2 -> next;
}
}
return 0;
}
void postStats() {
int i=0, n=0;
int totempty;
rewind(fppost);
totempty=0;
for( i=0; i<20; i++) {
printf("size:%ld ", LISTSIZE[i]);
n = getcount(i);
printf(" count:%d\n", n);
totempty += LISTSIZE[i] * n;
}
printf("ExtFragm: %d empty slots, 4(?) bytes each\n", totempty);
printf("growth factor:%g\n", GF);
}
char *removechar(char *str,char *rm)
{
int *count = getcount(rm);
int i,ip=0,r=0;
for(i=0;*(str+i);i++)
{
if(count[*(str+i)]==0)
{
*(str+r)=*(str+ip);
r++;
}
ip++;
}
*(str+r) = '\0';
return str;
}
void solve(){
int s,t,x,i;
for(s=1; s<=n; ++s){
scanf("%d",&t);
x = root(t);
if(x <= m){
erase(x-1,1);
++nextfree[x];
}
str[0]=s;
insert(t-1, 1, str);
}
n = getcount();
get();
while(n && str[n-1]==0)--n;
printf("%d\n",n);
printf("%d",str[0]);
for(i=1; i<n; ++i)printf(" %d",str[i]);
printf("\n");
}
void eval_line_eye(int s,int sopen,int c){
int rn,length,sn,sold,ptr,cn,vlength,potlength,cn2,corner=NOSQUARE;
int ldrno;
rn = gtflist(&eyefreelist);
eyerec[s] = rn;
eyetype[rn] = LINEEYE;
addlist(s,&eyeptr[rn]);
ldrno = NUMGROUPS+NUMCONNS+s;
sn = sopen; /* find end of line */
sold = s;
length = 1;
do {
addlist(sn,&eyeptr[rn]);
eyerec[sn] = rn;
if(edge[sn] == 0)corner = sn;
for(ptr = nblbp[sn]; ptr != EOL; ptr = links[ptr])
if(list[ptr] != sold){
sold = sn;
sn = list[ptr];
break;
}
++length;
} while(lnbn[sn] == 2 && lnbf[sn][1-c] == 0);
/* points from s to sold inclusive are included in eye and length */
if(lnbn[sn] == 1 && lnbf[sn][1-c] == 0){ /* closed off end */
addlist(sn,&eyeptr[rn]);
eyerec[sn] = rn;
sold = sn;
length++; /* measure full length */
vlength = length;
potlength = length;
cn = getcount(sn,c,rn,TRUE,ldrno);
if(cn == 3)length--;
else if(cn < 6){
length -= 2;
potlength -= 1;
addlist(sn,&eyevital[rn]);
addlist(rn,&eyevitrec[sn]);
}
cn2 = getcount(s,c,rn,TRUE,ldrno);
if(cn2 == 3)length--;
else if(cn2 < 6){
potlength -= 1;
length -= 2;
addlist(s,&eyevital[rn]);
addlist(rn,&eyevitrec[s]);
}
if(cn < 6 && cn2 < 6)potlength--;
if(length == 3 && vlength == 3){
addlist(sopen,&eyevital[rn]);
addlist(rn,&eyevitrec[sopen]);
potlength++;
}
if(length < 0)length = 0;
if(length > 5)length = 5;
if(potlength < 0)potlength = 0;
if(potlength > 5)potlength = 5;
eyeval[rn] = lineval[length];
eyepot[rn] = lineval[potlength];
eyemin[rn] = linemin[length];
if(eyeval[rn] != eyemin[rn]){ /* check if can atari inside */
if(grlibs[lgr[sopen]] == 2){
eyeval[rn] = eyemin[rn];
if(eyeval[rn] != eyepot[rn]){
addlist(sopen,&eyevital[rn]);
addlist(rn,&eyevitrec[sopen]);
}
}
if(grlibs[lgr[sold]] == 2){
eyeval[rn] = eyemin[rn];
if(eyeval[rn] != eyepot[rn]){
addlist(sold,&eyevital[rn]);
addlist(rn,&eyevitrec[sold]);
}
}
}
if(eyeval[rn] != eyepot[rn] && corner != NOSQUARE){
addlist(corner,&eyevital[rn]);
addlist(rn,&eyevitrec[corner]);
}
}
else { /* open ended line. s to sold in line. sn is past end */
/* for open ended line, length is best potential line length */
if(lnbf[sn][1-c] != 0 && lnbf[sn][c] == 0){
/* enemy can hane or throw in */
length--;
addlist(sold,&eyevital[rn]);
addlist(rn,&eyevitrec[sold]);
}
if(lnbn[sn] == 1 && lnbf[sn][1-c] >= 1 && lnbf[sn][c] != 0){ /*enemy can push in */
addlist(sn,&eyevital[rn]);
addlist(rn,&eyevitrec[sn]);
}
else if(lnbf[sn][1-c] == 0){
addlist(sn,&eyevital[rn]);
addlist(rn,&eyevitrec[sn]);
}
if(lnbf[sn][1-c] == 0)
for(ptr = nblbp[sn]; ptr != EOL; ptr = links[ptr])
if(ld[list[ptr]] == NEUTRALLD){
addlist(list[ptr],&eyevital[rn]);
addlist(rn,&eyevitrec[list[ptr]]);
}
cn = getcount(s,c,rn,TRUE,ldrno);
if(cn == 3 || cn == 5)length--;
else if(cn < 6){
length -= 2;
addlist(s,&eyevital[rn]);
addlist(rn,&eyevitrec[s]);
if(edge[list[nblbp[s]]] == 0 &&
grlibs[board[s+s-list[nblbp[s]]]] == 1)length--;
}
if(length > 5)length = 5;
if(length < 0)length = 0;
eyepot[rn] = lineval[length];
if(length < 1)length = 1;
eyeval[rn] = lineval[length-1];
if(length < 2)length = 2;
eyemin[rn] = lineval[length-2];
if(eyeval[rn] != eyepot[rn]){
if(corner != NOSQUARE){
addlist(corner,&eyevital[rn]);
addlist(rn,&eyevitrec[corner]);
}
addlist(sold,&eyevital[rn]);
addlist(rn,&eyevitrec[sold]);
}
}
}
int main(void)
{
int current, pos;
celt_int16 * sample_buffer;
unsigned char * encoded_buffer;
double * out_buffer;
int sample_rate;
int sample_bits;
int sample_channels;
int sample_buffer_size;
int sample;
int sample_msec;
int sample_size;
FILE * fd;
int j, k;
uint32_t frames; // FIXME! 4 byte!
uint64_t start;
struct sockaddr_in si_other;
int s, i, slen=sizeof(si_other);
char buf[BUFLEN];
CELTMode * cm;
CELTEncoder * ce;
int * error;
int compressed;
int jitter = 0;
int64_t t;
//struct cs * packets;
double dr = 0, de = 0;
srand(time(NULL));
if ((s=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP))==-1)
diep("socket");
memset((char *) &si_other, 0, sizeof(si_other));
si_other.sin_family = AF_INET;
si_other.sin_port = htons(PORT);
if (inet_aton(SRV_IP, &si_other.sin_addr)==0) {
fprintf(stderr, "inet_aton() failed\n");
exit(1);
}
fd = fopen("else.wav", "rb");
fseek(fd, 40, SEEK_SET);
fread(&frames, sizeof(uint64_t), 1, fd);
frames = 800000000;
printf("%d\n", frames);
// Hardcoded parameters for DSP
sample_rate = 44100; // Desc. frequency, Hz
sample_bits = 16; // Bits per sample
sample_channels = 2; // Stereo
// sample_msec = 10; // Size of sample, 100 ms for 10 Hz FFT freq. resolution
sample_size = 1024;
//sample_size = (int)(sample_rate * (sample_msec / 1000.0F));
sample_buffer_size = sample_size * sample_bits/8 * sample_channels;
sample_buffer = (celt_int16 *) calloc(sample_buffer_size, sizeof(char));
encoded_buffer = (unsigned char *) calloc(sample_buffer_size, sizeof(char));
out_buffer = (double *) calloc(sample_buffer_size / (sample_bits/8), sizeof(double));
cm = celt_mode_create(sample_rate, sample_size, NULL);
//printf("1\n");
ce = celt_encoder_create(cm, sample_channels, NULL);
celt_encoder_ctl(ce, CELT_SET_COMPLEXITY(10));
celt_encoder_ctl(ce, CELT_SET_PREDICTION(2));
celt_encoder_ctl(ce, CELT_SET_VBR_RATE(120000));
for (i = 0; i < 5000; ++i) {
read_sample_into_buffer(fd, (char *)sample_buffer, sample_size);
printf("%d %d \n", (sample_rate / sample_size) * (frames / (sample_rate * sample_channels * (sample_bits / 8))) , i);
printf("Sample_buffer_size: %d\n", sample_buffer_size);
compressed = celt_encode(ce, sample_buffer, NULL, encoded_buffer, 1024);
printf("Compressed bytes: %d, bitrate: %d kbps\n", compressed, (int)((sample_rate * sample_bits * sample_channels / 1024) * (compressed * 1.0F / sample_buffer_size)));
*((uint16_t *)packets[i].data) = compressed;
memcpy((char *)(packets[i].data + 2), encoded_buffer, compressed);
packets[i].length = compressed;
}
for (i = 0; i < (sample_rate / sample_size) * (frames / (sample_rate * sample_channels * (sample_bits / 8))); ++i) {
start = getcount();
printf("Sending packet %d\n", i);
if (sendto(s, packets[i].data, packets[i].length, 0, &si_other, slen) == -1)
diep("sendto()");
usleep(sample_size * 1000000 / sample_rate + jitter);
//usleep(sample_size * 950000 / sample_rate);
printf("Planned time: %.2f ms, real time: %.2f ms, needed time: %.2f\n", (sample_size * 1000000 / sample_rate + jitter) / 1000.0F, (getcount() - start) / 1000.0F,
(sample_size * 1000000 / sample_rate) / 1000.0F);
dr += (getcount() - start) / 1000.0F;
de += (sample_size * 1000000 / sample_rate) / 1000.0F;
if ((abs(t = ((sample_size * 1000000 / sample_rate) - (getcount() - start))) > (int)(1E-4 * (sample_size * 1000000 / sample_rate) )) ){//|| (fabs(dr - de) > 1E-6 * de)) {
if (t > 0 || (de > dr)) {
jitter += 1;
printf("Sending packes too fast, increasing jitter: %d\n", jitter);
} else {
jitter -= 1;
printf("Sending packes too slow, decreasing jitter: %d\n", jitter);
}
} //else// {
//jitter = 0;
//}
}
close(s);
return 0;
}
int main(void)
{
int memCounter = 0;
char input;
int numCountRef, firstNumRef, secondNumRef, intRestRef;
printf("CS 350 Lab 8, Andrey Danilkovich\nFull SDC Simulator\n\n");
initCPU();
readMemory();
printf("\nBeginning execution:\n");
printf("At the > prompt, press return to execute the next instruction (or q to quit or h or ? for help).\n");
char prompt[] = "> ";
printf("%s", prompt);
char command[80];
fgets(command, sizeof command, stdin); // Read past end of current line.
scanf("%c", &input);
do
{
while(input != '\n' && getchar() != '\n' ){ /* Do Nothing to clear \n from a char */ } // clear out the extra space after the char
numCountRef = getcount(mem, memCounter);
firstNumRef = getfirst(mem, memCounter, numCountRef);
secondNumRef = getsecond(mem, memCounter, numCountRef);
intRestRef = getrest(mem, memCounter, numCountRef);
if(firstNumRef == 0)
{
memCounter++;
}
else if(input == '\r' | input == '\n')
{
instruction_cycle(mem, regs, memCounter);
memCounter++;
printf("%s", prompt);
scanf("%c", &input);
if(firstNumRef == 8 & regs[secondNumRef] > 0)
{
memCounter = intRestRef;
}
}
else if(input == 'h')
{
helpMsg(); // call help message
printf("%s", prompt);
scanf("%c", &input);
}
else if(input == 'q')
{
printf("Quitting program.\n");
}
else
{
printf("Unknown command; ignoring it.\n");
printf("%s", prompt);
scanf("%c", &input);
}
}
while (memCounter != 99 & input != 'q');
// Finish Program
// Print Halting message, diplay registers and memory
printf("At 00 instr 0 0 00: HALT\n\nHalting\n");
printf("\nRegisters:\n");
dumpRegisters(regs);
printf("\nMemory:\n");
dumpMemory(mem);
}
void eval2pointeye(int s,int sopen,int c){
int sn,tmplist,ptr2,gnbr,rn,count1,count2,index,ldrno;
rn = gtflist(&eyefreelist);
eyerec[s] = rn;
eyerec[sopen] = rn;
eyetype[rn] = TWOPOINTEYE;
addlist(s,&eyeptr[rn]);
addlist(sopen,&eyeptr[rn]);
ldrno = NUMGROUPS+NUMCONNS+s;
count1 = getcount(s,c,rn,FALSE,ldrno);
count2 = getcount(sopen,c,rn,FALSE,ldrno);
index = ind1[count1] + ind2[count2];
eyepot[rn] = tpt1[index];
eyeval[rn] = tpt2[index];
eyemin[rn] = tpt3[index];
if(eyeval[rn] == 0 && eyepot[rn] == 8){
count1 = getcount(s,c,rn,TRUE,ldrno);
count2 = getcount(sopen,c,rn,TRUE,ldrno);
}
if(ind1[count1] == 0 && (ind2[count2] == 12 || ind2[count2] == 8)){
addlist(s,&eyevital[rn]);
addlist(rn,&eyevitrec[s]);
}
if((ind1[count1] == 2 || ind1[count1] == 3) && ind2[count2] == 0){
addlist(sopen,&eyevital[rn]);
addlist(rn,&eyevitrec[sopen]);
}
if(eyeval[rn] == 4){ /* need more reading */
eyeval[rn] = 8;
sn = sopen;
if(ind1[count2] == 3){
sn = s;
}
mvs[msptr] = sn;
mvcolor[msptr] = 1-c;
lupdate(msptr);
upldrflags(msptr,ldrno);
++msptr;
/* put down throw in stone */
tmplist = EOL;
cpylist(grnbp[board[sn]],&tmplist);
for(ptr2 = tmplist; ptr2 != EOL; ptr2 = links[ptr2]){
gnbr = list[ptr2];
if(grlibs[gnbr] == 1){ /* throwin is atari? */
if(list[grlbp[gnbr]] == list[grlbp[board[sn]]]){
eyeval[rn] = 0;
addlist(sn,&eyevital[rn]);
addlist(rn,&eyevitrec[sn]);
break;
}
else {
mvs[msptr] = list[grlbp[gnbr]];
mvcolor[msptr] = c;
lupdate(msptr);
upldrflags(msptr,ldrno);
if(grlibs[board[mvs[msptr]]] == 1){
eyeval[rn] = 0;
addlist(sn,&eyevital[rn]);
addlist(rn,&eyevitrec[sn]);
}
ldndate(msptr);
}
}
}
killist(&tmplist);
--msptr;
ldndate(msptr);
}
}
static void mainloop(void)
{
int step = srows / PAGESTEPS;
int hstep = scols / PAGESTEPS;
int c;
term_setup();
signal(SIGCONT, sigcont);
loadpage(num);
srow = prow;
scol = -scols / 2;
draw();
while ((c = readkey()) != -1) {
if (c == 'q')
break;
if (c == 'e' && reload())
break;
switch (c) { /* commands that do not require redrawing */
case 'o':
numdiff = num - getcount(num);
break;
case 'Z':
zoom_def = getcount(zoom);
break;
case 'i':
printinfo();
break;
case 27:
count = 0;
break;
case 'm':
setmark(readkey());
break;
case 'd':
sleep(getcount(1));
break;
default:
if (isdigit(c))
count = count * 10 + c - '0';
}
switch (c) { /* commands that require redrawing */
case CTRLKEY('f'):
case 'J':
if (!loadpage(num + getcount(1)))
srow = prow;
break;
case CTRLKEY('b'):
case 'K':
if (!loadpage(num - getcount(1)))
srow = prow;
break;
case 'G':
setmark('\'');
if (!loadpage(getcount(doc_pages(doc) - numdiff) + numdiff))
srow = prow;
break;
case 'O':
numdiff = num - getcount(num);
setmark('\'');
if (!loadpage(num + numdiff))
srow = prow;
break;
case 'z':
zoom_page(getcount(zoom_def));
break;
case 'w':
zoom_page(pcols ? zoom * scols / pcols : zoom);
break;
case 'W':
if (lmargin() < rmargin())
zoom_page(zoom * (scols - hstep) /
(rmargin() - lmargin()));
break;
case 'f':
zoom_page(prows ? zoom * srows / prows : zoom);
break;
case 'r':
rotate = getcount(0);
if (!loadpage(num))
srow = prow;
break;
case '`':
case '\'':
jmpmark(readkey(), c == '`');
break;
case 'j':
srow += step * getcount(1);
break;
case 'k':
srow -= step * getcount(1);
break;
case 'l':
scol += hstep * getcount(1);
break;
case 'h':
scol -= hstep * getcount(1);
break;
case 'H':
srow = prow;
break;
case 'L':
srow = prow + prows - srows;
break;
case 'M':
srow = prow + prows / 2 - srows / 2;
break;
case 'C':
scol = -scols / 2;
break;
case ' ':
case CTRLKEY('d'):
srow += srows * getcount(1) - step;
break;
case 127:
case CTRLKEY('u'):
srow -= srows * getcount(1) - step;
break;
case '[':
scol = pcol;
break;
case ']':
scol = pcol + pcols - scols;
break;
case '{':
scol = pcol + lmargin() - hstep / 2;
break;
case '}':
scol = pcol + rmargin() + hstep / 2 - scols;
break;
case CTRLKEY('l'):
break;
case 'I':
invert = !invert;
loadpage(num);
break;
default: /* no need to redraw */
continue;
}
srow = MAX(prow - srows + MARGIN, MIN(prow + prows - MARGIN, srow));
scol = MAX(pcol - scols + MARGIN, MIN(pcol + pcols - MARGIN, scol));
draw();
}
term_cleanup();
}
void evaloneptdeadeye(int s,int g,int c,int rn,int ldrno){
int nbflag, nbgr, ptr2, sopen, eyespots, numeyespots, j;
int numopenspots, ldtm2, sn2, count, flag, numenemyspots;
nbflag = FALSE;
for(ptr2 = grnbp[g]; ptr2 != EOL; ptr2 = links[ptr2])
if(grlibs[list[ptr2]] == 1){
nbflag = TRUE;
nbgr = list[ptr2];
break;
}
if(nbflag){ /* nbr in atari */
if(list[grlbp[nbgr]] == kosquare){
return;
}
}
if(grlibs[g] == 1){
sopen = list[grlbp[g]];
eyespots = EOL;
numeyespots = 0;
numopenspots = 0;
numenemyspots = 0;
j = fdir[sopen];
for(ldtm2 = ldir[j]; j != ldtm2; ++j){
sn2 = sopen + nbr[j];
if(lnbn[sn2] == 1 &&
(ld[sn2] != 0 && ld[sn2] != NEUTRALLD && grcolor[lgr[sn2]] == c ||
ld[sn2] == 0 && grcolor[lgr[sn2]] != c && grsize[lgr[sn2]]
== 1 && grlibs[lgr[sn2]] == 1)){
if(eyerec[sn2] != 0 && eyerec[sn2] != rn)
deallocate_eye(eyerec[sn2]);
addlist(sn2,&eyeptr[rn]);
eyerec[sn2] = rn;
adflist(sn2,&eyespots);
numeyespots++;
}
else if(grcolor[board[sn2]] == 1-c)++numenemyspots;
else if(board[sn2] == NOGROUP)++numopenspots;
}
if(numeyespots > 1){
evalmanyeyespots(rn,sopen,c,numopenspots,numenemyspots,ldrno);
}
else{ /* ony one eyespot */
if(gralive[g] == DEAD){
count = getcount(s,c,rn,TRUE,ldrno);
eyeval[rn] = odead2[count];
eyemin[rn] = odead3[count];
}
mvcolor[msptr] = c;
mvs[msptr] = sopen;
flag = lupdate(msptr);
if(flag){
upldrflags(msptr,ldrno);
++msptr;
count = getcount(s,c,rn,FALSE,ldrno);
--msptr;
}
else count = 0;
if(gralive[g] != DEAD){
eyepot[rn] = othr1[count];
eyeval[rn] = othr2[count];
eyemin[rn] = othr3[count];
addlist(sopen,&eyevital[rn]);
addlist(rn,&eyevitrec[sopen]);
}
else {
eyepot[rn] = odead2[count];
if(eyepot[rn] != eyeval[rn]){
addlist(sopen,&eyevital[rn]);
addlist(rn,&eyevitrec[sopen]);
}
}
ldndate(msptr);
}
killist(&eyespots);
}
else { /* one stone group w more than one liberty */
if(gralive[g] == DEAD){
count = getcount(s,c,rn,TRUE,ldrno);
eyepot[rn] = odead1[count];
eyeval[rn] = odead2[count];
eyemin[rn] = odead3[count];
}
else if(edge[mvs[grpieces[g]]] <= 2){ /* special case for stone on 2 line */
eyepot[rn] = 8;
eyeval[rn] = 8;
eyemin[rn] = 0;
}
else {
count = getcount(s,c,rn,FALSE,ldrno);
eyepot[rn] = othr1[count];
eyeval[rn] = othr2[count];
eyemin[rn] = othr3[count];
}
}
}
bool readvalue(const bsreq* hint_type, bool create) {
bool need_identifier = false;
buffer[0] = 0;
value = 0;
value_type = 0;
value_object = 0;
if(p[0] == '-' || (p[0] >= '0' && p[0] <= '9')) {
value = sz2num(p, &p);
value_type = number_type;
} else if(p[0] == '\'') {
p++;
readstring('\'');
value_type = text_type;
need_identifier = true;
} else if(p[0] == '\"') {
p++;
readstring('\"');
value_type = text_type;
} else if(readidentifier()) {
value_type = text_type;
need_identifier = true;
} else
return false; // Not found value tag
if(need_identifier) {
auto value_data = bsdata::find(hint_type);
if(!value_data) {
for(value_data = bsdata::first; value_data; value_data = value_data->next) {
auto f = value_data->fields->getkey();
if(!f)
continue;
value_object = value_data->find(f, buffer);
if(value_object)
break;
}
} else
value_object = value_data->find(value_data->fields->getkey(), buffer);
// If not find create this
if(!value_object && value_data && create) {
auto f = value_data->fields->getkey();
if(f) {
value_object = value_data->add();
f->set(f->ptr(value_object), (int)szdup(buffer));
}
}
if(value_data)
value_type = value_data->fields;
else
value_type = number_type;
if(value_object && value_data)
value = value_data->indexof(value_object);
if(!value_object)
warning(ErrorNotFoundIdentifier1p, buffer);
} else if(create && hint_type && value_type == number_type) {
auto value_data = bsdata::find(hint_type);
value_type = hint_type;
if(value_data) {
if(value < (int)value_data->getmaxcount()) {
if(value >= (int)value_data->getcount())
value_data->setcount(value + 1);
value_object = value_data->get(value);
}
}
}
skipws();
return true;
}
void evalbigeye(int s,int sopen,int c){
int i,ldtmp,sn,j,sn2,ldtm2,flag,count,numeyespots,ldrno;
int tmpli,ptr,rn,numopenspots,numenemyspots;
if(eyerec[s] != 0)return; /* already evaluated */
rn = gtflist(&eyefreelist);
eyerec[s] = rn;
eyetype[rn] = BIGEYE;
addlist(s,&eyeptr[rn]);
ldrno = NUMGROUPS+NUMCONNS+s;
/* find other eyespots sharing same sopen */
numeyespots = numopenspots = numenemyspots = 0;
j = fdir[sopen];
for(ldtm2 = ldir[j]; j != ldtm2; ++j){
sn2 = sopen + nbr[j];
if(lnbn[sn2] == 1 &&
(ld[sn2] > 1 && grcolor[lgr[sn2]] == c ||
ld[sn2] == 0 && grcolor[lgr[sn2]] != c && grsize[lgr[sn2]]
== 1 && grlibs[lgr[sn2]] == 1)){
if(eyerec[sn2] != 0 && eyerec[sn2] != rn)
deallocate_eye(eyerec[sn2]);
addlist(sn2,&eyeptr[rn]);
eyerec[sn2] = rn;
numeyespots++;
}
else if(grcolor[board[sn2]] == 1-c)++numenemyspots;
else if(board[sn2] == NOGROUP)++numopenspots;
}
if(numeyespots > 1){
evalmanyeyespots(rn,sopen,c,numopenspots,numenemyspots,ldrno);
}
else{ /* ony one eyespot */
/* put down stone to make eye and see if it is eye */
mvs[msptr] = sopen;
mvcolor[msptr] = c;
flag = lupdate(msptr);
upldrflags(msptr,ldrno);
++msptr;
count = getcount(s,c,rn,TRUE,ldrno);
eyepot[rn] = onesp1[count];
if(eyepot[rn] == 8){
addlist(sopen,&eyevital[rn]);
addlist(rn,&eyevitrec[sopen]);
}
if(eyepot[rn] != 0 && count != 7){
i = fdir[s];
for(ldtmp = ldiag[i]; i < ldtmp; ++i)
if(board[s+diags[i]] == NOGROUP){
addlist(s+diags[i],&eyevital[rn]);
addlist(rn,&eyevitrec[s+diags[i]]);
}
}
/* this code conflicts with the code in getarmytv_pot for extra eye potential
* if(eyepot[rn] == 8)
* for(ptr = nblbp[sopen]; ptr != EOL; ptr = links[ptr])
* if(list[ptr] != s && lnbn[list[ptr]] == 1 &&
* lnbf[list[ptr]][1-c] == 0 &&
* lnbf[list[nblbp[list[ptr]]]][1-c] == 0)
* eyepot[rn] += 4;
*/
--msptr;
ldndate(msptr);
if(eyepot[rn] >= 4 && lnbf[sopen][1-c] == 0){
mvcolor[msptr] = 1-c; /* put down enemy stone */
flag = lupdate(msptr);
upldrflags(msptr,ldrno);
++msptr;
if(lnbn[sopen] == 2){
for(ptr = nblbp[sopen]; ptr != EOL; ptr = links[ptr])
if(list[ptr] != s)break;
mvcolor[msptr] = c;
mvs[msptr] = list[ptr];
flag = lupdate(msptr);
upldrflags(msptr,ldrno);
++msptr;
for(ptr = grnbp[board[sopen]]; ptr != EOL;
ptr = links[ptr])
if(grlibs[list[ptr]] == 1){
flag = FALSE;
break;
}
if(flag){
tmpli = c7[getcount(sopen,c,rn,FALSE,ldrno)];
if(tmpli > 1){
if(eyepot[rn] == 8)
eyeval[rn] = 8;
else {
eyepot[rn] = 8;
}
}
}
--msptr;
ldndate(msptr);
}
else {
if(iscaptured(board[sopen],9,playlevel,quicklibs,c,
ldrno)){
tmpli = c7[getcount(sopen,c,rn,FALSE,ldrno)];
if(tmpli > 1){
if(eyepot[rn] == 8)
eyeval[rn] = 8;
else {
eyepot[rn] = 8;
}
}
}
else if(eyepot[rn] == 4)eyepot[rn] = 0;
}
--msptr;
ldndate(msptr);
}
else if(eyepot[rn] == 4)eyepot[rn] = 0;
if(eyeval[rn] == 8){ /* check if eye can be killed by putting group in atari */
i = fdir[s];
for(ldtmp = ldir[i]; i < ldtmp; ++i){
sn = s + nbr[i];
if(board[sn] != NOGROUP && grlibs[board[sn]] == 2){
sn2 = list[grlbp[board[sn]]];
if(sn2 == s)sn2 = list[links[grlbp[board[sn]]]];
if(lnbn[sn2] > 1 || lnbf[sn2][1-c] != 0 && !onelibnbr(board[sn])){
eyeval[rn] = 0;
addlist(sn2,&eyevital[rn]);
addlist(rn,&eyevitrec[sn2]);
break;
}
}
}
}
}
}
/*******************************************************************************
This function is called to sequence through "blocks" of statements. The entire
program is the outer-most block, and each foreach statement begins another one.
That is, this function is RECURSIVE!!!
*******************************************************************************/
Exprnode
doblock(int begstmtidx, int endstmtidx)
{
Exprnode *lhsexprptr, result;
int newdepth, i;
int stmtidx;
stmtidx = begstmtidx;
while (stmtidx <= endstmtidx) {
curstmtidx = stmtidx; /* global, for error messages */
switch (stmts[stmtidx].typ) {
case PRINTF: case SPRINTF:
printfmt(stmtidx);
stmtidx++;
break;
case FOREACH:
newdepth = stmts[stmtidx].s.foreach.fldidx;
for (i=axistbl[newdepth].first; i<=axistbl[newdepth].last; i++){
curfldvalptrtbl[newdepth] = axistbl[newdepth].array[i];
/* this skips "outer joins" where there is no data */
if (stmts[stmtidx].s.foreach.restrictflag) {
chk4badflds(stmts[stmtidx].s.foreach.fldbits,
stmts[stmtidx].s.foreach.maxdepth);
if (getcount(datarootptr,
stmts[stmtidx].s.foreach.fldbits, 0,
stmts[stmtidx].s.foreach.maxdepth) == 0)
continue; /* skip doblock */
}
doblock(stmtidx+1, stmts[stmtidx].s.foreach.next-1);
}
curfldvalptrtbl[newdepth] = NULL;
stmtidx = stmts[stmtidx].s.foreach.next;
break;
case WHILE:
result = *(stmts[stmtidx].s.while_.exprptr);
evalexpr(&result);
while (result.arg.ival) {
doblock(stmtidx+1, stmts[stmtidx].s.while_.next-1);
result = *(stmts[stmtidx].s.while_.exprptr);
evalexpr(&result);
}
stmtidx = stmts[stmtidx].s.while_.next;
break;
case DO:
result = *(stmts[stmtidx].s.dowhile.exprptr);
evalexpr(&result);
if (result.arg.ival)
stmtidx = stmts[stmtidx].s.dowhile.next;
else
stmtidx++;
break;
case IF:
result = *(stmts[stmtidx].s.if_.exprptr);
evalexpr(&result);
if (result.arg.ival)
stmtidx++;
else
stmtidx = stmts[stmtidx].s.if_.next;
break;
case ELSE:
stmtidx = stmts[stmtidx].s.else_.next;
break;
case ASSIGNOP: /* assign ops are STATMENTS */
switch (stmts[stmtidx].s.assign.lhsexprptr->typ) {
case UFNCPARAMEXPR:
lhsexprptr = &argstk[botargstkidx]+stmts[stmtidx].s.
assign.lhsexprptr->arg.ival;
break;
case ARRAYVAREXPR:
lhsexprptr = rtgetarrvaraddr(
stmts[stmtidx].s.assign.lhsexprptr);
break;
default: /* an "ordinary" variable */
lhsexprptr = stmts[stmtidx].s.assign.lhsexprptr;
break;
}
assignop(lhsexprptr, stmts[stmtidx].s.assign.optyp,
stmts[stmtidx].s.assign.rhsexprptr);
stmtidx++;
break;
case SORT:
newdepth = stmts[stmtidx].s.sort.fldidx;
sortaxisarray(stmts[stmtidx].s.sort.exprptr, newdepth,
stmts[stmtidx].s.sort.reverseflag);
stmtidx++;
break;
case FIRST:
newdepth = stmts[stmtidx].s.fstlst.fldidx;
result = *(stmts[stmtidx].s.fstlst.exprptr);
evalexpr(&result);
axistbl[newdepth].last =
MIN(axistbl[newdepth].first+result.arg.ival-1,
axistbl[newdepth].last);
stmtidx++;
break;
case LAST:
newdepth = stmts[stmtidx].s.fstlst.fldidx;
result = *(stmts[stmtidx].s.fstlst.exprptr);
evalexpr(&result);
axistbl[newdepth].first =
MAX(axistbl[newdepth].last-result.arg.ival+1,
axistbl[newdepth].first);
stmtidx++;
break;
case SYSTEM:
result = *(stmts[stmtidx].s.system_.exprptr);
evalexpr(&result);
if (result.typ == STRING) {
(void) system(result.arg.sval);
} else {
fprintf(stderr,
"`system' must be called with a string argument");
}
stmtidx++;
break;
case RETURN:
if (stmts[stmtidx].s.return_.exprptr != NULL) {
result = *(stmts[stmtidx].s.return_.exprptr);
evalexpr(&result);
} else {
result.typ = NORETVALEXPR;
}
return result;
case EXPRSTMT:
result = *(stmts[stmtidx].s.expr.exprptr);
evalexpr(&result);
stmtidx++;
break;
case TRAP:
updatetraptbl(stmts[stmtidx].s.trap.linnumexprptr,
stmts[stmtidx].s.trap.ufncexprptr);
stmtidx++;
break;
default:
fatalerrlin("doblock: illegal statement type");
stmtidx++;
break;
}
}
result.typ = NORETVALEXPR;
return result;
}
/*******************************************************************************
This function evaluates an expression. It is passed a pointer to an expression
node to evaluate (results are also put here), and it evaluates the expression
tree.
Note: the argument stack is used for user function calls. Even though it looks
cumbersome, indices have been used instead of stack pointers. This is because
this is a recursive function, and it is neccessary to save previous stack
information AND the stack is dynamically resizable - that is - it can move at
any time. Hence, any pointers saved on previous invocations of this function
would be pointing to where the stack USED to be, not where it NOW is.
*******************************************************************************/
void
evalexpr(Exprnode *exprptr)
{
extern Field *aggrfldtbl, *fldtbl;
extern Opmode opmode; /* report or selrej mode */
extern Statsinfofld *statsinfofldtbl;
Exprnode lresult, rresult;
Exprptrlistnode *exprptrlistptr;
int tmpidx, argctr, intval, savebotargstkidx;
float floatval;
switch (exprptr->typ) {
case INTEGER: case FLOAT: case STRING:
break;
case FIELD:
if (opmode == REPORTMODE) {
if (curfldvalptrtbl[exprptr->arg.ival] == NULL) {
fprintf(stderr, "field `%s'",
aggrfldtbl[exprptr->arg.ival].name);
fatalerrlin(" is referenced outside a foreach loop");
}
exprptr->typ = aggrfldtbl[exprptr->arg.ival].typ;
switch (exprptr->typ) {
case STRING:
exprptr->arg.sval =
curfldvalptrtbl[exprptr->arg.ival]->arg.sval;
break;
case INTEGER:
exprptr->arg.ival =
curfldvalptrtbl[exprptr->arg.ival]->arg.ival;
break;
case FLOAT:
exprptr->arg.fval =
curfldvalptrtbl[exprptr->arg.ival]->arg.fval;
break;
default: fatalerror("evalexpr: SNARK!");
break;
}
} else { /* selrej mode */
evalselrejfld(exprptr);
}
break;
case UFNCCALLEXPR:
argctr = exprptr->arg.ufnc.argctr;
if (argstkctr + argctr > maxargstkctr) { /* enlarge stk if nec */
maxargstkctr = MAX(maxargstkctr*ARGSTKMULTFACTOR,
argstkctr+argctr);
argstk = (Exprnode*)realloc((void*)argstk,
(size_t)maxargstkctr*sizeof(Exprnode));
}
/* eval all args & push them on the stk */
exprptrlistptr = exprptr->arg.ufnc.exprptrlistptr;
while (exprptrlistptr != NULL) { /* eval all args */
lresult = *exprptrlistptr->exprptr;
evalexpr(&lresult);
*(argstk+argstkctr++) = lresult; /* & push on stk */
exprptrlistptr = exprptrlistptr->next;
}
savebotargstkidx = botargstkidx;
botargstkidx = argstkctr-argctr;
tmpidx = exprptr->arg.ufnc.begstmtidx; /* call user func */
*exprptr = doblock(tmpidx+1, stmts[tmpidx].s.ufncdef.endstmtidx);
argstkctr -= argctr;
botargstkidx = savebotargstkidx;
break;
case UFNCPARAMEXPR:
if (botargstkidx+exprptr->arg.ival >= argstkctr)
fatalerror(STKERRMSG);
*exprptr = *(&argstk[botargstkidx]+exprptr->arg.ival);
break;
case UNARYOPEXPR:
lresult = *(exprptr->leftptr); evalexpr(&lresult);
switch (lresult.typ) {
case INTEGER:
exprptr->arg.ival =
iunaryop(exprptr->arg.optyp, lresult.arg.ival);
break;
case FLOAT:
exprptr->arg.fval =
funaryop(exprptr->arg.optyp, lresult.arg.fval);
break;
default:
fatalerrlin("evalexpr: unary operation on illegal type");
break;
}
exprptr->typ = lresult.typ;
break;
case BINARYOPEXPR:
lresult = *(exprptr->leftptr); evalexpr(&lresult);
rresult = *(exprptr->rightptr); evalexpr(&rresult);
if ((lresult.typ == INTEGER)&&(rresult.typ == INTEGER)) {
exprptr->arg.ival = ibinop(lresult.arg.ival,
exprptr->arg.optyp, rresult.arg.ival);
exprptr->typ = INTEGER;
} else if (lresult.typ == INTEGER && rresult.typ == FLOAT) {
if ((exprptr->typ=fbinop((float)lresult.arg.ival,
exprptr->arg.optyp, rresult.arg.fval,
&floatval, &intval)) == FLOAT)
exprptr->arg.fval = floatval;
else
exprptr->arg.ival = intval;
} else if (lresult.typ == FLOAT && rresult.typ == INTEGER) {
if ((exprptr->typ=fbinop(lresult.arg.fval,
exprptr->arg.optyp, (float)rresult.arg.ival,
&floatval, &intval)) == FLOAT)
exprptr->arg.fval = floatval;
else
exprptr->arg.ival = intval;
} else if (lresult.typ == FLOAT && rresult.typ == FLOAT) {
if ((exprptr->typ=fbinop(lresult.arg.fval,
exprptr->arg.optyp, rresult.arg.fval,
&floatval, &intval)) == FLOAT)
exprptr->arg.fval = floatval;
else
exprptr->arg.ival = intval;
} else if (lresult.typ == STRING && rresult.typ == STRING) {
sbinop(lresult.arg.sval, rresult.arg.sval, exprptr);
} else {
fatalerrlin( "evalexpr: illegal binary op argument type(s)");
}
break;
case COUNT:
if (exprptr->arg.tdbfnc.maxdepth != INVALIDFLDIDX) {
chk4badflds(exprptr->arg.tdbfnc.fldbits,
exprptr->arg.tdbfnc.maxdepth);
exprptr->arg.ival = getcount(datarootptr,
exprptr->arg.tdbfnc.fldbits, 0,
exprptr->arg.tdbfnc.maxdepth);
} else {
exprptr->arg.ival = getcount(datarootptr,
exprptr->arg.tdbfnc.fldbits, 0, 0);
}
exprptr->typ = INTEGER;
break;
case NUMBER:
chk4badflds(exprptr->arg.tdbfnc.fldbits,
exprptr->arg.tdbfnc.maxdepth);
exprptr->arg.ival = getnumber(datarootptr,
exprptr->arg.tdbfnc.fldbits,
exprptr->arg.tdbfnc.depth, exprptr->arg.tdbfnc.maxdepth);
exprptr->typ = INTEGER;
break;
case SUM:
intval = statsinfofldtbl[exprptr->arg.tdbfnc.depth].typ;
switch (intval) {
case INTEGER:
if (exprptr->arg.tdbfnc.maxdepth != INVALIDFLDIDX) {
chk4badflds(exprptr->arg.tdbfnc.fldbits,
exprptr->arg.tdbfnc.maxdepth);
exprptr->arg.ival = getintsum(datarootptr,
exprptr->arg.tdbfnc.fldbits, 0,
exprptr->arg.tdbfnc.maxdepth,
exprptr->arg.tdbfnc.depth);
} else {
exprptr->arg.ival = getintsum(datarootptr,
exprptr->arg.tdbfnc.fldbits, 0,
0, exprptr->arg.tdbfnc.depth);
}
break;
case FLOAT:
if (exprptr->arg.tdbfnc.maxdepth != INVALIDFLDIDX) {
chk4badflds(exprptr->arg.tdbfnc.fldbits,
exprptr->arg.tdbfnc.maxdepth);
exprptr->arg.fval = getfltsum(datarootptr,
exprptr->arg.tdbfnc.fldbits, 0,
exprptr->arg.tdbfnc.maxdepth,
exprptr->arg.tdbfnc.depth);
} else {
exprptr->arg.fval = getfltsum(datarootptr,
exprptr->arg.tdbfnc.fldbits, 0,
0, exprptr->arg.tdbfnc.depth);
}
break;
default:
fatalerrlin("evalexpr: illegal SUM field type");
break;
}
exprptr->typ = intval;
break;
case SUMSQRD:
intval = statsinfofldtbl[exprptr->arg.tdbfnc.depth].typ;
switch (intval) {
case INTEGER:
if (exprptr->arg.tdbfnc.maxdepth != INVALIDFLDIDX) {
chk4badflds(exprptr->arg.tdbfnc.fldbits,
exprptr->arg.tdbfnc.maxdepth);
exprptr->arg.ival = getintsumsqrd(datarootptr,
exprptr->arg.tdbfnc.fldbits, 0,
exprptr->arg.tdbfnc.maxdepth,
exprptr->arg.tdbfnc.depth);
} else {
exprptr->arg.ival = getintsumsqrd(datarootptr,
exprptr->arg.tdbfnc.fldbits, 0,
0, exprptr->arg.tdbfnc.depth);
}
break;
case FLOAT:
if (exprptr->arg.tdbfnc.maxdepth != INVALIDFLDIDX) {
chk4badflds(exprptr->arg.tdbfnc.fldbits,
exprptr->arg.tdbfnc.maxdepth);
exprptr->arg.fval = getfltsumsqrd(datarootptr,
exprptr->arg.tdbfnc.fldbits, 0,
exprptr->arg.tdbfnc.maxdepth,
exprptr->arg.tdbfnc.depth);
} else {
exprptr->arg.fval = getfltsumsqrd(datarootptr,
exprptr->arg.tdbfnc.fldbits, 0,
0, exprptr->arg.tdbfnc.depth);
}
break;
default:
fatalerrlin("evalexpr: illegal SUM field type");
break;
}
exprptr->typ = intval;
break;
case TYPE:
lresult = *(exprptr->leftptr); evalexpr(&lresult);
switch (lresult.typ) {
case INTEGER: /* we've got an integer, make a ... */
if (exprptr->arg.casttyp == FLOAT) {
exprptr->arg.fval = (float)lresult.arg.ival;
exprptr->typ = FLOAT;
} else { /* an integer */
exprptr->arg.ival = lresult.arg.ival;
exprptr->typ = INTEGER;
}
break;
case FLOAT: /* we've got a float, make an ... */
if (exprptr->arg.casttyp == FLOAT) {
exprptr->arg.fval = lresult.arg.fval;
exprptr->typ = FLOAT;
} else { /* an integer */
exprptr->arg.ival = (int)lresult.arg.fval;
exprptr->typ = INTEGER;
}
break;
default:
fatalerrlin("evalexpr: illegal type cast");
break;
}
break;
case REPORTDT: /* get the report date or time */
exprptr->arg.ival = getreportdt(exprptr->arg.ival);
exprptr->typ = INTEGER;
break;
case FORMATDT: /* format a date or time */
lresult = *(exprptr->leftptr); evalexpr(&lresult);
rresult = *(exprptr->rightptr); evalexpr(&rresult);
exprptr->arg.sval = formatdt(exprptr->arg.ival, &lresult, &rresult);
exprptr->typ = STRING;
break;
case STRFUNCEXPR:
strfunc(exprptr);
break;
case ATOI:
lresult = *(exprptr->leftptr); evalexpr(&lresult);
if (lresult.typ != STRING)
fatalerrlin("evalexpr: atoi of non-string expression");
exprptr->arg.ival = atoi(lresult.arg.sval);
exprptr->typ = INTEGER;
break;
case ATOF:
lresult = *(exprptr->leftptr); evalexpr(&lresult);
if (lresult.typ != STRING)
fatalerrlin("evalexpr: atof of non-string expression");
exprptr->arg.fval = (float) atof(lresult.arg.sval);
exprptr->typ = FLOAT;
break;
case MATHFUNC:
lresult = *(exprptr->leftptr); evalexpr(&lresult);
switch (lresult.typ) {
case INTEGER:
exprptr->arg.fval =
mathfunc(exprptr->arg.optyp, (double)lresult.arg.ival);
break;
case FLOAT:
exprptr->arg.fval =
mathfunc(exprptr->arg.optyp, (double)lresult.arg.fval);
break;
default:
fatalerrlin("evalexpr: math function on illegal type");
break;
}
exprptr->typ = FLOAT;
break;
case ARRAYVAREXPR:
evalarrvar(exprptr);
break;
case NEED:
lresult = *(exprptr->leftptr); evalexpr(&lresult);
exprptr->typ = INTEGER;
exprptr->arg.ival = need(&lresult);
break;
case UNDEFVAREXPR:
fprintf(stderr, "evalexpr: variable `%s'",exprptr->varptr->name);
fatalerrlin(" is undefined");
break;
case NORETVALEXPR:
fatalerrlin("function returns no value (one is required)");
break;
default:
fatalerrlin("evalexpr: illegal expr type");
break;
}
}
~arr() {
--count;
getcount();
};
