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(); };