44 int i, num = AC.cbufList.num;
46 for ( i = 0; i < num; i++, C++ ) {
47 if ( C->
Buffer == 0 )
break;
49 if ( i >= num ) C = (
CBUF *)FromList(&AC.cbufList);
56 C->
lhs = (WORD **)Malloc1(C->maxlhs*
sizeof(WORD *),
"compiler buffer");
60 C->
rhs = (WORD **)Malloc1(C->maxrhs*(
sizeof(WORD *)+2*
sizeof(LONG)+2*
sizeof(WORD)),
"compiler buffer");
69 RedoTree(C,C->maxrhs);
79 void finishcbuf(WORD num)
83 if ( C->
rhs ) M_free(C->
rhs,
"compiler buffer");
84 if ( C->
lhs ) M_free(C->
lhs,
"compiler buffer");
92 C->numlhs = C->numrhs = C->maxlhs = C->maxrhs = C->mnumlhs =
93 C->mnumrhs = C->numtree = C->rootnum = C->MaxTreeSize = 0;
101 void clearcbuf(WORD num)
106 C->numrhs = C->numlhs = 0;
111 C->numtree = C->rootnum = C->MaxTreeSize = 0;
112 RedoTree(C,C->maxrhs);
121 WORD *DoubleCbuffer(
int num, WORD *w)
123 CBUF *C = cbuf + num;
125 WORD *newbuffer = (WORD *)Malloc1(newsize*
sizeof(WORD),
"compiler buffer");
128 w1 = C->
Buffer; w2 = newbuffer;
131 while ( --j >= 0 ) *w2++ = *w1++;
134 *w2++ = *w1++; *w2++ = *w1++; *w2++ = *w1++; *w2++ = *w1++;
135 *w2++ = *w1++; *w2++ = *w1++; *w2++ = *w1++; *w2++ = *w1++;
137 offset = newbuffer - C->
Buffer;
138 for ( i = 0; i <= C->numlhs; i++ ) C->
lhs[i] += offset;
139 for ( i = 1; i <= C->numrhs; i++ ) C->
rhs[i] += offset;
142 C->
Top = newbuffer + newsize;
145 M_free(w1,
"DoubleCbuffer");
154 WORD *AddLHS(
int num)
156 CBUF *C = cbuf + num;
158 if ( C->numlhs >= (C->maxlhs-2) ) {
159 WORD ***ppp = &(C->
lhs);
160 if ( DoubleList((VOID ***)ppp,&(C->maxlhs),
sizeof(WORD *),
161 "statement lists") ) Terminate(-1);
164 C->
lhs[C->numlhs+1] = 0;
173 WORD *AddRHS(
int num,
int type)
175 LONG fullsize, *lold, newsize;
181 if ( C->numrhs >= (C->maxrhs-2) ) {
182 if ( C->maxrhs == 0 ) newsize = 100;
183 else newsize = C->maxrhs * 2;
184 if ( newsize > MAXCOMBUFRHS ) newsize = MAXCOMBUFRHS;
185 if ( newsize == C->maxrhs ) {
186 if ( AC.tablefilling ) {
187 TABLES T = functions[AC.tablefilling].tabl;
193 WORD *nbufs = (WORD *)Malloc1(new1*
sizeof(WORD),
"Table compile buffers");
196 for ( ; i < new1; i++ ) nbufs[i] = 0;
197 M_free(T->
buffers,
"Table compile buffers");
202 AC.cbufnum = num = T->
bufnum;
206 MesPrint(
"@Compiler buffer overflow. Try to make modules smaller");
211 fullsize = newsize * (
sizeof(WORD *) + 2*
sizeof(LONG) + 2*
sizeof(WORD));
212 C->
rhs = (WORD **)Malloc1(fullsize,
"subexpression lists");
213 for ( i = 0; i < C->maxrhs; i++ ) C->
rhs[i] = old[i];
215 for ( i = 0; i < C->maxrhs; i++ ) C->
CanCommu[i] = lold[i];
217 for ( i = 0; i < C->maxrhs; i++ ) C->
NumTerms[i] = lold[i];
219 for ( i = 0; i < C->maxrhs; i++ ) C->
numdum[i] = wold[i];
221 for ( i = 0; i < C->maxrhs; i++ ) C->
dimension[i] = wold[i];
222 if ( old ) M_free(old,
"subexpression lists");
224 if ( type == 0 ) RedoTree(C,C->maxrhs);
240 int AddNtoL(
int n, WORD *array)
243 CBUF *C = cbuf+AC.cbufnum;
245 MesPrint(
"LH: %a",n,array);
249 for ( i = 0; i < n; i++ ) *(C->
Pointer)++ = *array++;
261 int AddNtoC(
int bufnum,
int n, WORD *array)
265 CBUF *C = cbuf+bufnum;
267 MesPrint(
"RH: %a",n,array);
271 for ( i = 0; i < n; i++ ) *w++ = *array++;
297 static COMPTREE comptreezero = {0,0,0,0,0,0};
299 int InsTree(
int bufnum,
int h)
301 CBUF *C = cbuf + bufnum;
306 if ( C->numtree + 1 >= C->MaxTreeSize ) {
307 if ( C->MaxTreeSize == 0 ) {
309 C->MaxTreeSize = 125;
321 for ( ip = 1; ip < C->MaxTreeSize; ip++ ) { C->
boomlijst[ip] = comptreezero; }
324 is = C->MaxTreeSize * 2;
326 for ( ip = 0; ip < C->MaxTreeSize; ip++ ) { s[ip] = C->
boomlijst[ip]; }
327 for ( ip = C->MaxTreeSize; ip <= is; ip++ ) { s[ip] = comptreezero; }
333 q = boomlijst + C->rootnum;
336 if ( q->right == -1 ) {
338 s = boomlijst+C->numtree;
339 q->right = C->numtree;
340 s->parent = C->rootnum;
341 s->left = s->right = -1;
350 v1 = C->
rhs[p->value]; v2 = v3 = C->
rhs[h];
351 while ( *v3 ) v3 += *v3;
352 while ( *v1 == *v2 && v2 < v3 ) { v1++; v2++; }
355 if ( iq >= 0 ) { ip = iq; }
361 s->
parent = ip; s->left = s->right = -1;
362 s->blnce = 0; s->value = h; s->usage = 1;
364 if ( p->blnce == 0 )
return(h);
368 else if ( *v1 < *v2 ) {
370 if ( iq >= 0 ) { ip = iq; }
376 s->parent = ip; s->left = s->right = -1;
377 s->blnce = 0; s->value = h; s->usage = 1;
379 if ( p->blnce == 0 )
return(h);
388 MesPrint(
"We vallen uit de boom!");
395 if ( iq == C->rootnum )
break;
397 if ( ip == q->left ) q->
blnce--;
399 if ( q->blnce == 0 )
break;
400 if ( q->blnce == -2 ) {
401 if ( p->blnce == -1 ) {
404 p->parent = q->parent;
406 if ( boomlijst[p->parent].
left == iq ) boomlijst[p->parent].
left = ip;
407 else boomlijst[p->parent].
right = ip;
408 if ( q->left >= 0 ) boomlijst[q->left].
parent = iq;
409 q->blnce = p->blnce = 0;
417 if ( p->right >= 0 ) boomlijst[p->right].
parent = ip;
418 if ( q->left >= 0 ) boomlijst[q->left].
parent = iq;
419 s->parent = q->parent;
422 if ( boomlijst[s->parent].
left == iq )
423 boomlijst[s->parent].
left = is;
424 else boomlijst[s->parent].
right = is;
425 if ( s->blnce > 0 ) { q->blnce = s->blnce = 0; p->blnce = -1; }
426 else if ( s->blnce < 0 ) { p->blnce = s->blnce = 0; q->blnce = 1; }
427 else { p->blnce = s->blnce = q->blnce = 0; }
431 else if ( q->blnce == 2 ) {
432 if ( p->blnce == 1 ) {
435 p->parent = q->parent;
437 if ( boomlijst[p->parent].
left == iq ) boomlijst[p->parent].
left = ip;
438 else boomlijst[p->parent].
right = ip;
439 if ( q->right >= 0 ) boomlijst[q->right].
parent = iq;
440 q->blnce = p->blnce = 0;
448 if ( p->left >= 0 ) boomlijst[p->left].
parent = ip;
449 if ( q->right >= 0 ) boomlijst[q->right].
parent = iq;
450 s->parent = q->parent;
453 if ( boomlijst[s->parent].
left == iq ) boomlijst[s->parent].
left = is;
454 else boomlijst[s->parent].
right = is;
455 if ( s->blnce < 0 ) { q->blnce = s->blnce = 0; p->blnce = 1; }
456 else if ( s->blnce > 0 ) { p->blnce = s->blnce = 0; q->blnce = -1; }
457 else { p->blnce = s->blnce = q->blnce = 0; }
477 int FindTree(
int bufnum, WORD *subexpr)
479 CBUF *C = cbuf + bufnum;
487 v1 = C->
rhs[p->value]; v2 = v3 = subexpr;
488 while ( *v3 ) v3 += *v3;
489 while ( *v1 == *v2 && v2 < v3 ) { v1++; v2++; }
492 if ( iq >= 0 ) { ip = iq; }
495 else if ( *v1 < *v2 ) {
497 if ( iq >= 0 ) { ip = iq; }
513 void RedoTree(
CBUF *C,
int size)
517 newboomlijst = (
COMPTREE *)Malloc1((size+1)*
sizeof(
COMPTREE),
"newboomlijst");
519 if ( C->MaxTreeSize > size ) C->MaxTreeSize = size;
520 for ( i = 0; i < C->MaxTreeSize; i++ ) newboomlijst[i] = C->
boomlijst[i];
524 C->MaxTreeSize = size;
532 void ClearTree(
int i)
560 CBUF *C = cbuf + bufnum;
564 C->maxrhs = AM.fbuffersize;
565 C->MaxTreeSize = AM.fbuffersize;
572 if ( C->
rhs ) M_free(C->
rhs,
"IniFbuffer-rhs");
584 for ( i = 1; i < C->MaxTreeSize; i++ ) { C->
boomlijst[i] = comptreezero; }
586 fullsize = (C->maxrhs+1) * (
sizeof(WORD *) + 2*
sizeof(LONG) + 2*
sizeof(WORD));
587 C->
rhs = (WORD **)Malloc1(fullsize,
"IniFbuffer-rhs");
603 LONG numcommute(WORD *terms, LONG *numterms)
613 if ( *t >= FUNCTION ) {
614 if ( functions[*t-FUNCTION].commute ) { num++;
break; }
618 terms = terms + *terms;