47 WORD CleanExpr(WORD par)
57 e_in = e_out = Expressions;
59 e_in->vflags &= ~( TOBEFACTORED | TOBEUNFACTORED );
67 M_free(e_in->renum,
"Renumber"); e_in->renum = 0;
70 if ( e_in->status == HIDDENLEXPRESSION
71 || e_in->status == HIDDENGEXPRESSION ) numhid++;
72 switch ( e_in->status ) {
74 case HIDDENLEXPRESSION:
76 AC.exprnames->namenode[e_in->node].type = CDELETE;
78 if ( e_in->status != HIDDENLEXPRESSION )
79 ClearBracketIndex(e_in-Expressions);
82 case GLOBALEXPRESSION:
83 case HIDDENGEXPRESSION:
89 if (
PF_BroadcastExpr(e_in, e_in->status == HIDDENGEXPRESSION ? AR.hidefile : AR.outfile) )
return -1;
90 if ( PF.me == MASTER ) {
96 if ( e_in->status == HIDDENGEXPRESSION ) {
97 if ( e->status == HIDDENGEXPRESSION
98 || e->status == HIDDENLEXPRESSION )
break;
101 if ( e->status == GLOBALEXPRESSION
102 || e->status == LOCALEXPRESSION )
break;
116 DIFPOS(length,e->onfile,e_in->onfile);
119 FILEHANDLE *f = e_in->status == HIDDENGEXPRESSION ? AR.hidefile : AR.outfile;
121 SETBASELENGTH(length,TOLONG(f->POfull)
122 - TOLONG(f->PObuffer)
123 - BASEPOSITION(e_in->onfile));
126 SeekFile(f->
handle,&(f->filesize),SEEK_SET);
127 DIFPOS(length,f->filesize,e_in->onfile);
130 if ( ToStorage(e_in,&length) ) {
131 return(MesCall(
"CleanExpr"));
133 e_in->status = STOREDEXPRESSION;
134 if ( e_in->status != HIDDENGEXPRESSION )
135 ClearBracketIndex(e_in-Expressions);
138 case SKIPLEXPRESSION:
139 case DROPLEXPRESSION:
140 case DROPHLEXPRESSION:
141 case DROPGEXPRESSION:
142 case DROPHGEXPRESSION:
143 case STOREDEXPRESSION:
144 if ( e_out != e_in ) {
145 node = AC.exprnames->namenode + e_in->node;
146 node->
number = e_out - Expressions;
148 e_out->onfile = e_in->onfile;
149 e_out->printflag = 0;
150 if ( par ) e_out->status = STOREDEXPRESSION;
151 else e_out->status = e_in->status;
152 e_out->name = e_in->name;
153 e_out->node = e_in->node;
154 e_out->renum = e_in->renum;
156 e_out->counter = e_in->counter;
157 e_out->hidelevel = e_in->hidelevel;
158 e_out->inmem = e_in->inmem;
159 e_out->bracketinfo = e_in->bracketinfo;
160 e_out->newbracketinfo = e_in->newbracketinfo;
161 e_out->numdummies = e_in->numdummies;
162 e_out->numfactors = e_in->numfactors;
163 e_out->vflags = e_in->vflags;
171 case DROPPEDEXPRESSION:
174 AC.exprnames->namenode[e_in->node].type = CDELETE;
179 }
while ( --n > 0 ); }
182 if ( numhid == 0 && AR.hidefile->PObuffer ) {
183 if ( AR.hidefile->handle >= 0 ) {
184 CloseFile(AR.hidefile->handle);
185 remove(AR.hidefile->name);
186 AR.hidefile->handle = -1;
188 AR.hidefile->POfull =
189 AR.hidefile->POfill = AR.hidefile->PObuffer;
190 PUTZERO(AR.hidefile->POposition);
210 retval = CleanExpr(1);
213 if ( AC.DidClean ) CompactifyTree(AC.exprnames,EXPRNAMES);
215 AC.CodesFlag = AM.gCodesFlag;
216 AC.NamesFlag = AM.gNamesFlag;
217 AC.StatsFlag = AM.gStatsFlag;
218 AC.OldFactArgFlag = AM.gOldFactArgFlag;
219 AC.TokensWriteFlag = AM.gTokensWriteFlag;
220 AC.extrasymbols = AM.gextrasymbols;
221 if ( AC.extrasym ) { M_free(AC.extrasym,
"extrasym"); AC.extrasym = 0; }
222 i = 1; s = AM.gextrasym;
while ( *s ) { s++; i++; }
223 AC.extrasym = (UBYTE *)Malloc1(i*
sizeof(UBYTE),
"extrasym");
224 for ( j = 0; j < i; j++ ) AC.extrasym[j] = AM.gextrasym[j];
225 AO.NoSpacesInNumbers = AM.gNoSpacesInNumbers;
226 AO.IndentSpace = AM.gIndentSpace;
227 AC.lUnitTrace = AM.gUnitTrace;
228 AC.lDefDim = AM.gDefDim;
229 AC.lDefDim4 = AM.gDefDim4;
231 if ( AC.ncmod == AM.gncmod && AC.modmode == AM.gmodmode ) {
234 if ( AC.cmod[j] != AM.gcmod[j] )
break;
237 M_free(AC.halfmod,
"halfmod");
238 AC.halfmod = 0; AC.nhalfmod = 0;
242 M_free(AC.halfmod,
"halfmod");
243 AC.halfmod = 0; AC.nhalfmod = 0;
246 if ( AC.modinverses ) {
247 if ( AC.ncmod == AM.gncmod && AC.modmode == AM.gmodmode ) {
250 if ( AC.cmod[j] != AM.gcmod[j] )
break;
253 M_free(AC.modinverses,
"modinverses");
258 M_free(AC.modinverses,
"modinverses");
262 AN.ncmod = AC.ncmod = AM.gncmod;
263 AC.npowmod = AM.gnpowmod;
264 AC.modmode = AM.gmodmode;
265 if ( ( ( AC.modmode & INVERSETABLE ) != 0 ) && ( AC.modinverses == 0 ) )
267 AC.funpowers = AM.gfunpowers;
268 AC.lPolyFun = AM.gPolyFun;
269 AC.lPolyFunType = AM.gPolyFunType;
270 AC.parallelflag = AM.gparallelflag;
271 AC.ProcessBucketSize = AC.mProcessBucketSize = AM.gProcessBucketSize;
272 AC.properorderflag = AM.gproperorderflag;
273 AC.ThreadBucketSize = AM.gThreadBucketSize;
274 AC.ThreadStats = AM.gThreadStats;
275 AC.FinalStats = AM.gFinalStats;
276 AC.ThreadsFlag = AM.gThreadsFlag;
277 AC.ThreadBalancing = AM.gThreadBalancing;
278 AC.ThreadSortFileSynch = AM.gThreadSortFileSynch;
279 AC.ProcessStats = AM.gProcessStats;
280 AC.OldParallelStats = AM.gOldParallelStats;
281 AC.IsFortran90 = AM.gIsFortran90;
282 if ( AC.Fortran90Kind ) {
283 M_free(AC.Fortran90Kind,
"Fortran90 Kind");
284 AC.Fortran90Kind = 0;
286 if ( AM.gFortran90Kind ) {
287 AC.Fortran90Kind = strDup1(AM.gFortran90Kind,
"Fortran90 Kind");
289 if ( AC.ThreadsFlag && AM.totalnumberofthreads > 1 ) AS.MultiThreaded = 1;
301 if ( MakeModTable() ) {
302 MesPrint(
"===No printing in powers of generator");
314 AC.Cnumpows = AM.gCnumpows;
315 AC.OutputMode = AM.gOutputMode;
316 AC.OutputSpaces = AM.gOutputSpaces;
317 AC.OutNumberType = AM.gOutNumberType;
318 AR.SortType = AC.SortType = AM.gSortType;
319 AC.ShortStatsMax = AM.gShortStatsMax;
335 AM.gCodesFlag = AC.CodesFlag;
336 AM.gNamesFlag = AC.NamesFlag;
337 AM.gStatsFlag = AC.StatsFlag;
338 AM.gOldFactArgFlag = AC.OldFactArgFlag;
339 AM.gextrasymbols = AC.extrasymbols;
340 if ( AM.gextrasym ) { M_free(AM.gextrasym,
"extrasym"); AM.gextrasym = 0; }
341 i = 1; s = AC.extrasym;
while ( *s ) { s++; i++; }
342 AM.gextrasym = (UBYTE *)Malloc1(i*
sizeof(UBYTE),
"extrasym");
343 for ( j = 0; j < i; j++ ) AM.gextrasym[j] = AC.extrasym[j];
344 AM.gTokensWriteFlag= AC.TokensWriteFlag;
345 AM.gNoSpacesInNumbers = AO.NoSpacesInNumbers;
346 AM.gIndentSpace = AO.IndentSpace;
347 AM.gUnitTrace = AC.lUnitTrace;
348 AM.gDefDim = AC.lDefDim;
349 AM.gDefDim4 = AC.lDefDim4;
350 AM.gncmod = AC.ncmod;
351 AM.gnpowmod = AC.npowmod;
352 AM.gmodmode = AC.modmode;
353 AM.gCnumpows = AC.Cnumpows;
354 AM.gOutputMode = AC.OutputMode;
355 AM.gOutputSpaces = AC.OutputSpaces;
356 AM.gOutNumberType = AC.OutNumberType;
357 AM.gfunpowers = AC.funpowers;
358 AM.gPolyFun = AC.lPolyFun;
359 AM.gPolyFunType = AC.lPolyFunType;
360 AM.gparallelflag = AC.parallelflag;
361 AM.gProcessBucketSize = AC.ProcessBucketSize;
362 AM.gproperorderflag = AC.properorderflag;
363 AM.gThreadBucketSize = AC.ThreadBucketSize;
364 AM.gThreadStats = AC.ThreadStats;
365 AM.gFinalStats = AC.FinalStats;
366 AM.gThreadsFlag = AC.ThreadsFlag;
367 AM.gThreadBalancing = AC.ThreadBalancing;
368 AM.gThreadSortFileSynch = AC.ThreadSortFileSynch;
369 AM.gProcessStats = AC.ProcessStats;
370 AM.gOldParallelStats = AC.OldParallelStats;
371 AM.gIsFortran90 = AC.IsFortran90;
372 if ( AM.gFortran90Kind ) {
373 M_free(AM.gFortran90Kind,
"Fortran 90 Kind");
374 AM.gFortran90Kind = 0;
376 if ( AC.Fortran90Kind ) {
377 AM.gFortran90Kind = strDup1(AC.Fortran90Kind,
"Fortran 90 Kind");
391 AM.gSortType = AC.SortType;
392 AM.gShortStatsMax = AC.ShortStatsMax;
404 for ( j = 0, e = Expressions; j < NumExpressions; j++, e++ ) {
405 switch ( e->status ) {
406 case SKIPLEXPRESSION:
407 e->status = LOCALEXPRESSION;
409 case UNHIDELEXPRESSION:
410 e->status = LOCALEXPRESSION;
411 ClearBracketIndex(j);
412 e->bracketinfo = e->newbracketinfo; e->newbracketinfo = 0;
414 case HIDELEXPRESSION:
415 e->status = HIDDENLEXPRESSION;
417 case SKIPGEXPRESSION:
418 e->status = GLOBALEXPRESSION;
420 case UNHIDEGEXPRESSION:
421 e->status = GLOBALEXPRESSION;
422 ClearBracketIndex(j);
423 e->bracketinfo = e->newbracketinfo; e->newbracketinfo = 0;
425 case HIDEGEXPRESSION:
426 e->status = HIDDENGEXPRESSION;
428 case DROPLEXPRESSION:
429 case DROPGEXPRESSION:
430 case DROPHLEXPRESSION:
431 case DROPHGEXPRESSION:
432 e->status = DROPPEDEXPRESSION;
433 ClearBracketIndex(j);
434 e->bracketinfo = e->newbracketinfo; e->newbracketinfo = 0;
435 if ( e->replace >= 0 ) {
436 Expressions[e->replace].replace = REGULAREXPRESSION;
437 AC.exprnames->namenode[e->node].number = e->replace;
438 e->replace = REGULAREXPRESSION;
441 AC.exprnames->namenode[e->node].type = CDELETE;
445 case LOCALEXPRESSION:
446 case GLOBALEXPRESSION:
447 ClearBracketIndex(j);
448 e->bracketinfo = e->newbracketinfo; e->newbracketinfo = 0;
450 case HIDDENLEXPRESSION:
451 case HIDDENGEXPRESSION:
453 case INTOHIDELEXPRESSION:
454 e->status = HIDDENLEXPRESSION;
456 case INTOHIDEGEXPRESSION:
457 e->status = HIDDENGEXPRESSION;
460 ClearBracketIndex(j);
463 if ( e->replace == NEWLYDEFINEDEXPRESSION ) e->replace = REGULAREXPRESSION;
472 void PutInVflags(WORD nexpr)
479 if ( AS.OldOnFile == 0 ) {
480 AS.NumOldOnFile = 20;
481 AS.OldOnFile = (
POSITION *)Malloc1(AS.NumOldOnFile*
sizeof(
POSITION),
"file pointers");
483 else if ( nexpr >= AS.NumOldOnFile ) {
485 AS.OldOnFile = (
POSITION *)Malloc1(2*AS.NumOldOnFile*
sizeof(
POSITION),
"file pointers");
486 for ( i = 0; i < AS.NumOldOnFile; i++ ) AS.OldOnFile[i] = old[i];
487 AS.NumOldOnFile = 2*AS.NumOldOnFile;
488 M_free(old,
"proces file pointers");
490 if ( AS.OldNumFactors == 0 ) {
491 AS.NumOldNumFactors = 20;
492 AS.OldNumFactors = (WORD *)Malloc1(AS.NumOldNumFactors*
sizeof(WORD),
"numfactors pointers");
493 AS.Oldvflags = (WORD *)Malloc1(AS.NumOldNumFactors*
sizeof(WORD),
"vflags pointers");
495 else if ( nexpr >= AS.NumOldNumFactors ) {
496 oldw = AS.OldNumFactors;
497 AS.OldNumFactors = (WORD *)Malloc1(2*AS.NumOldNumFactors*
sizeof(WORD),
"numfactors pointers");
498 for ( i = 0; i < AS.NumOldNumFactors; i++ ) AS.OldNumFactors[i] = oldw[i];
499 M_free(oldw,
"numfactors pointers");
501 AS.Oldvflags = (WORD *)Malloc1(2*AS.NumOldNumFactors*
sizeof(WORD),
"vflags pointers");
502 for ( i = 0; i < AS.NumOldNumFactors; i++ ) AS.Oldvflags[i] = oldw[i];
503 AS.NumOldNumFactors = 2*AS.NumOldNumFactors;
504 M_free(oldw,
"vflags pointers");
509 if ( nexpr >= AS.NumOldOnFile || nexpr >= AS.NumOldNumFactors )
goto restart;
510 AS.OldOnFile[nexpr] = e->onfile;
511 AS.OldNumFactors[nexpr] = e->numfactors;
512 AS.Oldvflags[nexpr] = e->vflags;
520 WORD DoExecute(WORD par, WORD skip)
524 int i, oldmultithreaded = AS.MultiThreaded;
529 SpecialCleanup(BHEAD0);
530 if ( skip )
goto skipexec;
531 if ( AC.IfLevel > 0 ) {
532 MesPrint(
" %d endif statement(s) missing",AC.IfLevel);
535 if ( AC.WhileLevel > 0 ) {
536 MesPrint(
" %d endwhile statement(s) missing",AC.WhileLevel);
539 if ( AC.arglevel > 0 ) {
540 MesPrint(
" %d endargument statement(s) missing",AC.arglevel);
543 if ( AC.termlevel > 0 ) {
544 MesPrint(
" %d endterm statement(s) missing",AC.termlevel);
547 if ( AC.insidelevel > 0 ) {
548 MesPrint(
" %d endinside statement(s) missing",AC.insidelevel);
551 if ( AC.inexprlevel > 0 ) {
552 MesPrint(
" %d endinexpression statement(s) missing",AC.inexprlevel);
555 if ( AC.NumLabels > 0 ) {
556 for ( i = 0; i < AC.NumLabels; i++ ) {
557 if ( AC.Labels[i] < 0 ) {
558 MesPrint(
" -->Label %s missing",AC.LabelNames[i]);
563 if ( AC.dolooplevel > 0 ) {
564 MesPrint(
" %d enddo statement(s) missing",AC.dolooplevel);
567 if ( RetCode )
return(RetCode);
568 AR.Cnumlhs = cbuf[AM.rbufnum].numlhs;
570 if ( ( AS.ExecMode = par ) == GLOBALMODULE ) AS.ExecMode = 0;
576 if ( NumPotModdollars > 0 && AC.mparallelflag == PARALLELFLAG ) {
577 if ( NumPotModdollars > NumModOptdollars )
578 AC.mparallelflag |= NOPARALLEL_DOLLAR;
580 for ( i = 0; i < NumPotModdollars; i++ ) {
581 for ( j = 0; j < NumModOptdollars; j++ )
582 if ( PotModdollars[i] == ModOptdollars[j].number )
break;
583 if ( j >= NumModOptdollars ) {
584 AC.parallelflag |= NOPARALLEL_DOLLAR;
592 if ( AC.mparallelflag == PARALLELFLAG && PF.me != MASTER ) {
593 for ( i = 0; i < NumModOptdollars; i++ ) {
594 if ( ModOptdollars[i].type == MODSUM ) {
595 DOLLARS d = Dollars + ModOptdollars[i].number;
597 if ( d->where && d->where != &AM.dollarzero ) M_free(d->where,
"old content of dollar");
598 d->where = &AM.dollarzero;
600 CleanDollarFactors(d);
613 if ( NumPotModdollars >= 0 ) {
614 for ( i = 0; i < NumExpressions; i++ ) {
615 if ( Expressions[i].partodo ) { AC.partodoflag = 1;
break; }
618 if ( AC.partodoflag > 0 || ( NumPotModdollars > 0 && AC.mparallelflag == PARALLELFLAG ) ) {
619 if ( NumPotModdollars > NumModOptdollars ) {
620 AC.mparallelflag |= NOPARALLEL_DOLLAR;
621 AS.MultiThreaded = 0;
625 for ( i = 0; i < NumPotModdollars; i++ ) {
626 for ( j = 0; j < NumModOptdollars; j++ )
627 if ( PotModdollars[i] == ModOptdollars[j].number )
break;
628 if ( j >= NumModOptdollars ) {
629 AC.mparallelflag |= NOPARALLEL_DOLLAR;
630 AS.MultiThreaded = 0;
634 switch ( ModOptdollars[j].type ) {
641 AC.mparallelflag |= NOPARALLEL_DOLLAR;
642 AS.MultiThreaded = 0;
649 else if ( ( AC.mparallelflag & NOPARALLEL_USER ) != 0 ) {
650 AS.MultiThreaded = 0;
653 if ( AC.partodoflag == 0 ) {
654 for ( i = 0; i < NumExpressions; i++ ) {
655 Expressions[i].partodo = 0;
658 else if ( AC.partodoflag == -1 ) {
664 if ( AC.RhsExprInModuleFlag && AC.mparallelflag == PARALLELFLAG ) {
665 if (PF.rhsInParallel) {
668 PF.slavebuf.PObuffer=(WORD *)Malloc1(AM.ScratSize*
sizeof(WORD),
"PF inbuf");
669 PF.slavebuf.POsize=AM.ScratSize*
sizeof(WORD);
670 PF.slavebuf.POfull = PF.slavebuf.POfill = PF.slavebuf.PObuffer;
671 PF.slavebuf.POstop= PF.slavebuf.PObuffer+AM.ScratSize;
672 PUTZERO(PF.slavebuf.POposition);
676 AC.mparallelflag |= NOPARALLEL_RHS;
681 AR.SortType = AC.SortType;
683 if ( PF.me == MASTER )
686 if ( AC.SetupFlag ) WriteSetup();
687 if ( AC.NamesFlag || AC.CodesFlag ) WriteLists();
689 if ( par == GLOBALMODULE ) MakeGlobal();
690 if ( RevertScratch() )
return(-1);
694 if ( PF.numtasks >= 3 ) {
695 for ( i = 0; i < NumExpressions; i++ ) {
696 if ( Expressions[i].partodo > 0 ) { AC.partodoflag = 1;
break; }
700 for ( i = 0; i < NumExpressions; i++ ) {
701 Expressions[i].partodo = 0;
705 if ( AC.ncmod ) SetMods();
710 if ( PF.me == MASTER )
713 if ( !AC.ThreadsFlag || AC.mparallelflag & NOPARALLEL_USER ) {
716 else if ( AC.mparallelflag & NOPARALLEL_DOLLAR ) {
717 HighWarning(
"This module is forced to run in sequential mode due to $-variables");
719 else if ( AC.mparallelflag & NOPARALLEL_RHS ) {
720 HighWarning(
"This module is forced to run in sequential mode due to RHS expression names");
722 else if ( AC.mparallelflag & NOPARALLEL_CONVPOLY ) {
723 HighWarning(
"This module is forced to run in sequential mode due to topolynomial/frompolynomial");
725 else if ( AC.mparallelflag & NOPARALLEL_TBLDOLLAR ) {
726 HighWarning(
"This module is forced to run in sequential mode due to $-variable assignments in tables");
728 else if ( AC.mparallelflag & NOPARALLEL_NPROC ) {
729 HighWarning(
"This module is forced to run in sequential mode because there is only one processor");
741 if ( AP.preError == 0 && (
Processor() || WriteAll() ) ) RetCode = -1;
748 if ( AC.ncmod ) UnSetMods();
749 AS.MultiThreaded = oldmultithreaded;
755 if ( NumPotModdollars > 0 ) {
757 if ( RetCode )
return RetCode;
759 if ( RetCode )
return RetCode;
762 if ( AC.numpfirstnum > 0 ) {
764 if ( RetCode )
return RetCode;
767 if ( AC.topolynomialflag & TOPOLYNOMIALFLAG ) {
769 if ( RetCode )
return RetCode;
776 if ( RetCode )
return RetCode;
781 if ( PF.me != MASTER && AR.hidefile->PObuffer ) {
782 if ( AR.hidefile->handle >= 0 ) {
783 CloseFile(AR.hidefile->handle);
784 AR.hidefile->handle = -1;
785 remove(AR.hidefile->name);
787 AR.hidefile->POfull = AR.hidefile->POfill = AR.hidefile->PObuffer;
788 PUTZERO(AR.hidefile->POposition);
792 for ( j = 0; j < NumModOptdollars; j++ ) {
793 if ( ModOptdollars[j].dstruct ) {
797 for ( i = 0; i < AM.totalnumberofthreads; i++ ) {
798 if ( ModOptdollars[j].dstruct[i].size > 0 ) {
799 CleanDollarFactors(&(ModOptdollars[j].dstruct[i]));
800 M_free(ModOptdollars[j].dstruct[i].where,
"Local dollar value");
806 M_free(ModOptdollars[j].dstruct,
"Local DOLLARS");
807 ModOptdollars[j].dstruct = 0;
828 if ( ModOptdollars ) M_free(ModOptdollars,
"ModOptdollars pointer");
829 if ( PotModdollars ) M_free(PotModdollars,
"PotModdollars pointer");
832 AC.ModOptDolList.lijst = NULL;
834 AC.PotModDolList.lijst = NULL;
836 NumPotModdollars = 0;
837 NumModOptdollars = 0;
844 AC.PolyRatFunChanged = 0;
846 if ( par == STOREMODULE || par == CLEARMODULE ) {
848 if ( par == STOREMODULE && PopVariables() ) RetCode = -1;
849 if ( AR.infile->handle >= 0 ) {
850 CloseFile(AR.infile->handle);
851 remove(AR.infile->name);
852 AR.infile->handle = -1;
854 AR.infile->POfill = AR.infile->PObuffer;
855 PUTZERO(AR.infile->POposition);
856 AR.infile->POfull = AR.infile->PObuffer;
857 if ( AR.outfile->handle >= 0 ) {
858 CloseFile(AR.outfile->handle);
859 remove(AR.outfile->name);
860 AR.outfile->handle = -1;
863 AR.outfile->POfill = AR.outfile->PObuffer;
864 PUTZERO(AR.outfile->POposition);
865 if ( AR.hidefile->handle >= 0 ) {
866 CloseFile(AR.hidefile->handle);
867 remove(AR.hidefile->name);
868 AR.hidefile->handle = -1;
870 AR.hidefile->POfull =
871 AR.hidefile->POfill = AR.hidefile->PObuffer;
872 PUTZERO(AR.hidefile->POposition);
874 if ( par == CLEARMODULE ) {
875 if ( DeleteStore(0) < 0 ) {
876 MesPrint(
"Cannot restart the storage file");
882 AM.gProcessBucketSize = AM.hProcessBucketSize;
883 AM.gparallelflag = PARALLELFLAG;
888 if ( CleanExpr(0) ) RetCode = -1;
889 if ( AC.DidClean ) CompactifyTree(AC.exprnames,EXPRNAMES);
893 clearcbuf(AC.cbufnum);
894 if ( AC.MultiBracketBuf != 0 ) {
895 for ( i = 0; i < MAXMULTIBRACKETLEVELS; i++ ) {
896 if ( AC.MultiBracketBuf[i] ) {
897 M_free(AC.MultiBracketBuf[i],
"bracket buffer i");
898 AC.MultiBracketBuf[i] = 0;
901 AC.MultiBracketLevels = 0;
902 M_free(AC.MultiBracketBuf,
"multi bracket buffer");
903 AC.MultiBracketBuf = 0;
930 WORD PutBracket(
PHEAD WORD *termin)
933 WORD *t, *t1, *b, i, j, *lastfun;
935 WORD *bStop, *bb, *bf, *tStop;
936 WORD *term1,*term2, *m1, *m2, *tStopa;
937 WORD *bbb = 0, *bind, *binst = 0, bwild = 0;
938 term1 = AT.WorkPointer+1;
939 term2 = (WORD *)(((UBYTE *)(term1)) + AM.MaxTer);
940 if ( ( (WORD *)(((UBYTE *)(term2)) + AM.MaxTer) ) > AT.WorkTop )
return(MesWork());
941 if ( AR.BracketOn < 0 ) {
942 t2 = term1; t1 = term2;
945 t1 = term1; t2 = term2;
947 b = AT.BrackBuf; bStop = b+*b; b++;
948 while ( b < bStop ) {
949 if ( *b == INDEX ) { bwild = 1; bbb = b+2; binst = b + b[1];
break; }
953 t = termin; tStopa = t + *t; i = *(t + *t -1); i = ABS(i);
954 if ( AR.PolyFun && AT.PolyAct ) tStop = termin + AT.PolyAct;
955 else tStop = tStopa - i;
957 if ( AR.BracketOn < 0 ) {
959 while ( t < tStop && *t >= FUNCTION
960 && functions[*t-FUNCTION].commute ) {
962 while ( b < bStop ) {
965 while ( t < tStop && *t >= FUNCTION
966 && functions[*t-FUNCTION].commute ) t += t[1];
971 if ( bwild && *t >= FUNCTION && functions[*t-FUNCTION].spec ) {
976 while ( bind < binst ) {
977 if ( *bind == *s2 ) {
979 while ( t < tStop && *t >= FUNCTION
980 && functions[*t-FUNCTION].commute ) t += t[1];
993 while ( s1 < lastfun ) *t2++ = *s1++;
994 while ( s1 < t ) *t1++ = *s1++;
997 while ( s1 < t ) *t2++ = *s1++;
1003 while ( t < tStop && *t >= FUNCTION
1004 && functions[*t-FUNCTION].commute ) {
1006 while ( b < bStop ) {
1007 if ( *b == *t ) { lastfun = t + t[1];
goto NextNcom; }
1010 if ( bwild && *t >= FUNCTION && functions[*t-FUNCTION].spec ) {
1015 while ( bind < binst ) {
1016 if ( *bind == *s2 ) { lastfun = t + t[1];
goto NextNcom; }
1026 while ( s1 < lastfun ) *t1++ = *s1++;
1027 while ( s1 < t ) *t2++ = *s1++;
1032 b = AT.BrackBuf + 1;
1033 while ( b < bStop && *b >= FUNCTION
1034 && ( *b < FUNCTION || functions[*b-FUNCTION].commute ) ) {
1039 while ( t < tStop && ( bf < bStop || bwild ) ) {
1041 while ( b < bStop && *b != *t ) { b += b[1]; }
1043 if ( *t >= FUNCTION ) {
1044 if ( b < bStop && *b == *t )
goto FunBrac;
1045 if ( bwild && *t >= FUNCTION && functions[*t-FUNCTION].spec ) {
1050 while ( bind < binst ) {
1051 if ( *bind == *s2 )
goto FunBrac;
1059 FunBrac: NCOPY(t1,t,i);
1065 if ( *t == DELTA ) {
1066 if ( b < bStop && *b == DELTA ) {
1070 else { NCOPY(t2,t,i); }
1072 else if ( *t == INDEX ) {
1075 *t1++ = *t; t1++; *t2++ = *t; t2++;
1079 while ( --j >= 0 ) {
1080 while ( *bind < *t && bind < binst ) bind++;
1081 if ( *bind == *t && bind < binst ) {
1086 m1[1] = WORDDIF(t1,m1);
1087 if ( m1[1] == 2 ) t1 = m1;
1088 m2[1] = WORDDIF(t2,m2);
1089 if ( m2[1] == 2 ) t2 = m2;
1095 else if ( *t == VECTOR ) {
1096 if ( ( b < bStop && *b == VECTOR ) || bwild ) {
1097 if ( b < bStop && *b == VECTOR ) {
1098 bb = b + b[1]; b += 2;
1102 m1 = t1; m2 = t2; *t1++ = *t; *t2++ = *t; t1++; t2++; t += 2;
1105 while ( b < bb && ( *b < *t ||
1106 ( *b == *t && b[1] < t[1] ) ) ) b += 2;
1107 if ( b < bb && ( *t == *b && t[1] == b[1] ) ) {
1108 *t1++ = *t++; *t1++ = *t++;
goto nextvec;
1112 while ( bind < binst ) {
1113 if ( *t == *bind || t[1] == *bind ) {
1114 *t1++ = *t++; *t1++ = *t++;
1120 *t2++ = *t++; *t2++ = *t++;
1123 m1[1] = WORDDIF(t1,m1);
1124 if ( m1[1] == 2 ) t1 = m1;
1125 m2[1] = WORDDIF(t2,m2);
1126 if ( m2[1] == 2 ) t2 = m2;
1132 else if ( *t == DOTPRODUCT ) {
1133 if ( ( b < bStop && *b == *t ) || bwild ) {
1134 m1 = t1; *t1++ = *t; t1++;
1135 m2 = t2; *t2++ = *t; t2++;
1136 if ( b >= bStop || *b != *t ) { bb = b; s1 = b; }
1138 s1 = b + b[1]; bb = b + 2;
1141 while ( t < s2 && ( bb < s1 || bwild ) ) {
1142 while ( bb < s1 && ( *bb < *t ||
1143 ( *bb == *t && bb[1] < t[1] ) ) ) bb += 3;
1144 if ( bb < s1 && *bb == *t && bb[1] == t[1] ) {
1145 *t1++ = *t++; *t1++ = *t++; *t1++ = *t++; bb += 3;
1150 while ( bind < binst ) {
1151 if ( *bind == *t || *bind == t[1] ) {
1152 *t1++ = *t++; *t1++ = *t++; *t1++ = *t++;
1158 *t2++ = *t++; *t2++ = *t++; *t2++ = *t++;
1161 while ( t < s2 ) *t2++ = *t++;
1162 m1[1] = WORDDIF(t1,m1);
1163 if ( m1[1] == 2 ) t1 = m1;
1164 m2[1] = WORDDIF(t2,m2);
1165 if ( m2[1] == 2 ) t2 = m2;
1167 else { NCOPY(t2,t,i); }
1169 else if ( *t == SYMBOL ) {
1170 if ( b < bStop && *b == *t ) {
1171 m1 = t1; *t1++ = *t; t1++;
1172 m2 = t2; *t2++ = *t; t2++;
1173 s1 = b + b[1]; bb = b+2;
1175 while ( bb < s1 && t < s2 ) {
1176 while ( bb < s1 && *bb < *t ) bb += 2;
1177 if ( bb >= s1 )
break;
1178 if ( *bb == *t ) { *t1++ = *t++; *t1++ = *t++; }
1179 else { *t2++ = *t++; *t2++ = *t++; }
1181 while ( t < s2 ) *t2++ = *t++;
1182 m1[1] = WORDDIF(t1,m1);
1183 if ( m1[1] == 2 ) t1 = m1;
1184 m2[1] = WORDDIF(t2,m2);
1185 if ( m2[1] == 2 ) t2 = m2;
1187 else { NCOPY(t2,t,i); }
1193 if ( ( i = WORDDIF(tStop,t) ) > 0 ) NCOPY(t2,t,i);
1194 if ( AR.BracketOn < 0 ) {
1195 s1 = t1; t1 = t2; t2 = s1;
1197 do { *t2++ = *t++; }
while ( t < (WORD *)tStopa );
1199 i = WORDDIF(t1,term1);
1200 *t++ = 4 + i + WORDDIF(t2,term2);
1205 i = WORDDIF(t2,term2);
1207 if ( i > 0 ) NCOPY(t,t1,i);
1219 VOID SpecialCleanup(PHEAD0)
1222 if ( AT.previousEfactor ) M_free(AT.previousEfactor,
"Efactor cache");
1223 AT.previousEfactor = 0;
1231 #ifndef WITHPTHREADS 1236 if ( AN.cmod != 0 ) M_free(AN.cmod,
"AN.cmod");
1238 AN.cmod = (UWORD *)Malloc1(
sizeof(WORD)*n,
"AN.cmod");
1239 for ( i = 0; i < n; i++ ) AN.cmod[i] = AC.cmod[i];
1249 #ifndef WITHPTHREADS 1253 if ( AN.cmod != 0 ) M_free(AN.cmod,
"AN.cmod");
1266 void ExchangeExpressions(
int num1,
int num2)
1269 WORD node1, node2, namesize, TMproto[SUBEXPSIZE];
1275 e1 = Expressions + num1;
1276 e2 = Expressions + num2;
1279 AC.exprnames->namenode[node1].number = num2;
1280 AC.exprnames->namenode[node2].number = num1;
1281 a = e1->name; e1->name = e2->name; e2->name = a;
1282 namesize = e1->namesize; e1->namesize = e2->namesize; e2->namesize = namesize;
1285 if ( e1->status == STOREDEXPRESSION ) {
1289 TMproto[0] = EXPRESSION;
1290 TMproto[1] = SUBEXPSIZE;
1293 {
int ie;
for ( ie = 4; ie < SUBEXPSIZE; ie++ ) TMproto[ie] = 0; }
1294 AT.TMaddr = TMproto;
1295 ind = FindInIndex(num1,&AR.StoreData,0,0);
1296 s1 = (SBYTE *)(AC.exprnames->namebuffer+e1->name);
1301 SeekFile(AR.StoreData.Handle,&(e1->onfile),SEEK_SET);
1302 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)ind,
1304 MesPrint(
"File error while exchanging expressions");
1307 FlushFile(AR.StoreData.Handle);
1309 if ( e2->status == STOREDEXPRESSION ) {
1313 TMproto[0] = EXPRESSION;
1314 TMproto[1] = SUBEXPSIZE;
1317 {
int ie;
for ( ie = 4; ie < SUBEXPSIZE; ie++ ) TMproto[ie] = 0; }
1318 AT.TMaddr = TMproto;
1319 ind = FindInIndex(num1,&AR.StoreData,0,0);
1320 s1 = (SBYTE *)(AC.exprnames->namebuffer+e2->name);
1325 SeekFile(AR.StoreData.Handle,&(e2->onfile),SEEK_SET);
1326 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)ind,
1328 MesPrint(
"File error while exchanging expressions");
1331 FlushFile(AR.StoreData.Handle);
1340 int GetFirstBracket(WORD *term,
int num)
1351 WORD type, *oldcomppointer, oldonefile, numword;
1354 oldcomppointer = AR.CompressPointer;
1355 type = Expressions[num].status;
1356 if ( type == STOREDEXPRESSION ) {
1357 WORD TMproto[SUBEXPSIZE];
1358 TMproto[0] = EXPRESSION;
1359 TMproto[1] = SUBEXPSIZE;
1362 {
int ie;
for ( ie = 4; ie < SUBEXPSIZE; ie++ ) TMproto[ie] = 0; }
1363 AT.TMaddr = TMproto;
1365 if ( ( renumber = GetTable(num,&position,0) ) == 0 ) {
1366 MesCall(
"GetFirstBracket");
1369 if ( GetFromStore(term,&position,renumber,&numword,num) < 0 ) {
1370 MesCall(
"GetFirstBracket");
1376 if ( renumber->
symb.
lo != AN.dummyrenumlist )
1377 M_free(renumber->
symb.
lo,
"VarSpace");
1378 M_free(renumber,
"Renumber");
1384 oldonefile = AR.GetOneFile;
1385 if ( type == HIDDENLEXPRESSION || type == HIDDENGEXPRESSION ) {
1386 AR.GetOneFile = 2; fi = AR.hidefile;
1389 AR.GetOneFile = 0; fi = AR.infile;
1392 PUTZERO(oldposition);
1398 SETBASEPOSITION(oldposition,fi->POfill-fi->PObuffer);
1400 position = AS.OldOnFile[num];
1401 if ( GetOneTerm(BHEAD term,fi,&position,1) < 0
1402 || ( GetOneTerm(BHEAD term,fi,&position,1) < 0 ) ) {
1403 MLOCK(ErrorMessageLock);
1404 MesCall(
"GetFirstBracket");
1405 MUNLOCK(ErrorMessageLock);
1420 fi->POfill = fi->PObuffer+BASEPOSITION(oldposition);
1422 AR.GetOneFile = oldonefile;
1424 AR.CompressPointer = oldcomppointer;
1426 tstop = term + *term; tstop -= ABS(tstop[-1]);
1428 while ( t < tstop ) {
1429 if ( *t == HAAKJE )
break;
1433 term[0] = 4; term[1] = 1; term[2] = 1; term[3] = 3;
1436 *t++ = 1; *t++ = 1; *t++ = 3; *term = t - term;
1440 term[0] = 4; term[1] = 1; term[2] = 1; term[3] = 3;
1450 int GetFirstTerm(WORD *term,
int num)
1461 WORD type, *oldcomppointer, oldonefile, numword;
1463 oldcomppointer = AR.CompressPointer;
1464 type = Expressions[num].status;
1465 if ( type == STOREDEXPRESSION ) {
1466 WORD TMproto[SUBEXPSIZE];
1467 TMproto[0] = EXPRESSION;
1468 TMproto[1] = SUBEXPSIZE;
1471 {
int ie;
for ( ie = 4; ie < SUBEXPSIZE; ie++ ) TMproto[ie] = 0; }
1472 AT.TMaddr = TMproto;
1474 if ( ( renumber = GetTable(num,&position,0) ) == 0 ) {
1475 MesCall(
"GetFirstTerm");
1478 if ( GetFromStore(term,&position,renumber,&numword,num) < 0 ) {
1479 MesCall(
"GetFirstTerm");
1485 if ( renumber->
symb.
lo != AN.dummyrenumlist )
1486 M_free(renumber->
symb.
lo,
"VarSpace");
1487 M_free(renumber,
"Renumber");
1493 oldonefile = AR.GetOneFile;
1494 if ( type == HIDDENLEXPRESSION || type == HIDDENGEXPRESSION ) {
1495 AR.GetOneFile = 2; fi = AR.hidefile;
1499 if ( Expressions[num].replace == NEWLYDEFINEDEXPRESSION )
1501 else fi = AR.infile;
1504 PUTZERO(oldposition);
1510 SETBASEPOSITION(oldposition,fi->POfill-fi->PObuffer);
1512 position = AS.OldOnFile[num];
1513 if ( GetOneTerm(BHEAD term,fi,&position,1) < 0
1514 || ( GetOneTerm(BHEAD term,fi,&position,1) < 0 ) ) {
1515 MLOCK(ErrorMessageLock);
1516 MesCall(
"GetFirstTerm");
1517 MUNLOCK(ErrorMessageLock);
1532 fi->POfill = fi->PObuffer+BASEPOSITION(oldposition);
1534 AR.GetOneFile = oldonefile;
1536 AR.CompressPointer = oldcomppointer;
1545 int GetContent(WORD *content,
int num)
1560 WORD type, *oldcomppointer, oldonefile, numword, *term, i;
1561 WORD *cbuffer = TermMalloc(
"GetContent");
1562 WORD *oldworkpointer = AT.WorkPointer;
1564 oldcomppointer = AR.CompressPointer;
1565 type = Expressions[num].status;
1566 if ( type == STOREDEXPRESSION ) {
1567 WORD TMproto[SUBEXPSIZE];
1568 TMproto[0] = EXPRESSION;
1569 TMproto[1] = SUBEXPSIZE;
1572 {
int ie;
for ( ie = 4; ie < SUBEXPSIZE; ie++ ) TMproto[ie] = 0; }
1573 AT.TMaddr = TMproto;
1575 if ( ( renumber = GetTable(num,&position,0) ) == 0 )
goto CalledFrom;
1576 if ( GetFromStore(cbuffer,&position,renumber,&numword,num) < 0 )
goto CalledFrom;
1578 term = oldworkpointer;
1579 AR.CompressPointer = oldcomppointer;
1580 if ( GetFromStore(term,&position,renumber,&numword,num) < 0 )
goto CalledFrom;
1581 if ( *term == 0 )
break;
1585 if ( ContentMerge(BHEAD cbuffer,term) < 0 )
goto CalledFrom;
1590 if ( renumber->
symb.
lo != AN.dummyrenumlist )
1591 M_free(renumber->
symb.
lo,
"VarSpace");
1592 M_free(renumber,
"Renumber");
1598 oldonefile = AR.GetOneFile;
1599 if ( type == HIDDENLEXPRESSION || type == HIDDENGEXPRESSION ) {
1600 AR.GetOneFile = 2; fi = AR.hidefile;
1604 if ( Expressions[num].replace == NEWLYDEFINEDEXPRESSION )
1606 else fi = AR.infile;
1609 PUTZERO(oldposition);
1615 SETBASEPOSITION(oldposition,fi->POfill-fi->PObuffer);
1617 position = AS.OldOnFile[num];
1618 if ( GetOneTerm(BHEAD cbuffer,fi,&position,1) < 0 )
goto CalledFrom;
1619 AR.CompressPointer = oldcomppointer;
1620 if ( GetOneTerm(BHEAD cbuffer,fi,&position,1) < 0 )
goto CalledFrom;
1629 term = oldworkpointer;
1630 AR.CompressPointer = oldcomppointer;
1631 if ( GetOneTerm(BHEAD term,fi,&position,1) < 0 )
goto CalledFrom;
1632 if ( *term == 0 )
break;
1636 if ( ContentMerge(BHEAD cbuffer,term) < 0 )
goto CalledFrom;
1639 fi->POfill = fi->PObuffer+BASEPOSITION(oldposition);
1641 AR.GetOneFile = oldonefile;
1643 AR.CompressPointer = oldcomppointer;
1644 for ( i = 0; i < *cbuffer; i++ ) content[i] = cbuffer[i];
1645 TermFree(cbuffer,
"GetContent");
1646 AT.WorkPointer = oldworkpointer;
1649 MLOCK(ErrorMessageLock);
1650 MesCall(
"GetContent");
1651 MUNLOCK(ErrorMessageLock);
1662 int CleanupTerm(WORD *term)
1664 WORD *tstop, *t, *tfill, *tt;
1665 GETSTOP(term,tstop);
1667 while ( t < tstop ) {
1668 if ( *t >= FUNCTION && ( functions[*t-FUNCTION].commute || *t == DENOMINATOR ) ) {
1669 tfill = t; tt = t + t[1]; tstop = term + *term;
1670 while ( tt < tstop ) *tfill++ = *tt++;
1671 *term = tfill - term;
1672 tstop -= ABS(tfill[-1]);
1686 WORD ContentMerge(
PHEAD WORD *content, WORD *term)
1689 WORD *cstop, csize, crsize, sign = 1, numsize, densize, i, tnsize, tdsize;
1690 UWORD *num, *den, *tnum, *tden;
1691 WORD *outfill, *outb = TermMalloc(
"ContentMerge"), *ct;
1692 WORD *t, *tstop, tsize, trsize, *told;
1693 WORD *t1, *t2, *c1, *c2, i1, i2, *out1;
1694 cstop = content + *content;
1696 if ( csize < 0 ) { sign = -sign; csize = -csize; }
1698 numsize = densize = crsize = (csize-1)/2;
1699 num = NumberMalloc(
"ContentMerge");
1700 den = NumberMalloc(
"ContentMerge");
1701 for ( i = 0; i < numsize; i++ ) num[i] = (UWORD)(cstop[i]);
1702 for ( i = 0; i < densize; i++ ) den[i] = (UWORD)(cstop[i+crsize]);
1703 while ( num[numsize-1] == 0 ) numsize--;
1704 while ( den[densize-1] == 0 ) densize--;
1708 tstop = term + *term;
1710 if ( tsize < 0 ) tsize = -tsize;
1712 tstop = tstop - tsize;
1713 tnsize = tdsize = trsize = (tsize-1)/2;
1714 tnum = (UWORD *)tstop; tden = (UWORD *)(tstop + trsize);
1715 while ( tnum[tnsize-1] == 0 ) tnsize--;
1716 while ( tden[tdsize-1] == 0 ) tdsize--;
1717 GcdLong(BHEAD num, numsize, tnum, tnsize, num, &numsize);
1718 if ( LcmLong(BHEAD den, densize, tden, tdsize, den, &densize) )
goto CalledFrom;
1722 while ( ct < cstop ) {
1726 while ( t < tstop && *t != *ct ) t += t[1];
1727 if ( t >= tstop )
break;
1728 t1 = t+2; t2 = t+t[1];
1729 c1 = ct+2; c2 = ct+ct[1];
1730 out1 = outfill; *outfill++ = *ct; outfill++;
1731 while ( c1 < c2 && t1 < t2 ) {
1733 if ( t1[1] <= c1[1] ) {
1734 *outfill++ = *t1++; *outfill++ = *t1++;
1738 *outfill++ = *c1++; *outfill++ = *c1++;
1742 else if ( *c1 < *t1 ) {
1744 *outfill++ = *c1++; *outfill++ = *c1++;
1750 *outfill++ = *t1++; *outfill++ = *t1++;
1756 if ( c1[1] < 0 ) { *outfill++ = c1[0]; *outfill++ = c1[1]; }
1760 if ( t1[1] < 0 ) { *outfill++ = t1[0]; *outfill++ = t1[1]; }
1763 out1[1] = outfill - out1;
1764 if ( out1[1] == 2 ) outfill = out1;
1768 while ( t < tstop && *t != *ct ) t += t[1];
1769 if ( t >= tstop )
break;
1770 t1 = t+2; t2 = t+t[1];
1771 c1 = ct+2; c2 = ct+ct[1];
1772 out1 = outfill; *outfill++ = *ct; outfill++;
1773 while ( c1 < c2 && t1 < t2 ) {
1774 if ( *c1 == *t1 && c1[1] == t1[1] ) {
1775 if ( t1[2] <= c1[2] ) {
1776 *outfill++ = *t1++; *outfill++ = *t1++; *outfill++ = *t1++;
1780 *outfill++ = *c1++; *outfill++ = *c1++; *outfill++ = *c1++;
1784 else if ( *c1 < *t1 || ( *c1 == *t1 && c1[1] < t1[1] ) ) {
1786 *outfill++ = *c1++; *outfill++ = *c1++; *outfill++ = *c1++;
1792 *outfill++ = *t1++; *outfill++ = *t1++; *outfill++ = *t1++;
1798 if ( c1[2] < 0 ) { *outfill++ = c1[0]; *outfill++ = c1[1]; *outfill++ = c1[1]; }
1802 if ( t1[2] < 0 ) { *outfill++ = t1[0]; *outfill++ = t1[1]; *outfill++ = t1[1]; }
1805 out1[1] = outfill - out1;
1806 if ( out1[1] == 2 ) outfill = out1;
1810 while ( t < tstop && *t != *ct ) t += t[1];
1811 if ( t >= tstop )
break;
1812 t1 = t+2; t2 = t+t[1];
1813 c1 = ct+2; c2 = ct+ct[1];
1814 out1 = outfill; *outfill++ = *ct; outfill++;
1815 while ( c1 < c2 && t1 < t2 ) {
1820 else if ( *c1 < *t1 ) { c1 += 1; }
1823 out1[1] = outfill - out1;
1824 if ( out1[1] == 2 ) outfill = out1;
1829 while ( t < tstop && *t != *ct ) t += t[1];
1830 if ( t >= tstop )
break;
1831 t1 = t+2; t2 = t+t[1];
1832 c1 = ct+2; c2 = ct+ct[1];
1833 out1 = outfill; *outfill++ = *ct; outfill++;
1834 while ( c1 < c2 && t1 < t2 ) {
1835 if ( *c1 == *t1 && c1[1] && t1[1] ) {
1836 *outfill++ = *c1++; *outfill++ = *c1++;
1839 else if ( *c1 < *t1 || ( *c1 == *t1 && c1[1] < t1[1] ) ) {
1846 out1[1] = outfill - out1;
1847 if ( out1[1] == 2 ) outfill = out1;
1852 while ( *t < *ct && t < tstop ) t += t[1];
1853 if ( t >= tstop ) { t = told; }
1855 t1 = t; t2 = ct; i1 = t1[1]; i2 = t2[1];
1856 if ( i1 != i2 ) { t = told; }
1859 if ( *t1 != *t2 )
break;
1863 for ( i = 0; i < i2; i++ ) { *outfill++ = *t++; }
1875 if ( numsize < densize ) {
1876 for ( i = numsize; i < densize; i++ ) num[i] = 0;
1879 else if ( densize < numsize ) {
1880 for ( i = densize; i < numsize; i++ ) den[i] = 0;
1883 for ( i = 0; i < numsize; i++ ) *outfill++ = num[i];
1884 for ( i = 0; i < densize; i++ ) *outfill++ = den[i];
1885 csize = numsize+densize+1;
1886 if ( sign < 0 ) csize = -csize;
1888 *outb = outfill-outb;
1889 NumberFree(den,
"ContentMerge");
1890 NumberFree(num,
"ContentMerge");
1891 for ( i = 0; i < *outb; i++ ) content[i] = outb[i];
1892 TermFree(outb,
"ContentMerge");
1895 MLOCK(ErrorMessageLock);
1896 MesCall(
"GetContent");
1897 MUNLOCK(ErrorMessageLock);
1906 LONG TermsInExpression(WORD num)
1908 LONG x = Expressions[num].counter;
1909 if ( x >= 0 )
return(x);
1918 void UpdatePositions()
1924 if ( NumExpressions > 0 &&
1925 ( AS.OldOnFile == 0 || AS.NumOldOnFile < NumExpressions ) ) {
1926 if ( AS.OldOnFile ) {
1928 AS.OldOnFile = (
POSITION *)Malloc1(NumExpressions*
sizeof(
POSITION),
"file pointers");
1929 for ( i = 0; i < AS.NumOldOnFile; i++ ) AS.OldOnFile[i] = old[i];
1930 AS.NumOldOnFile = NumExpressions;
1931 M_free(old,
"proces file pointers");
1934 AS.OldOnFile = (
POSITION *)Malloc1(NumExpressions*
sizeof(
POSITION),
"file pointers");
1935 AS.NumOldOnFile = NumExpressions;
1938 if ( NumExpressions > 0 &&
1939 ( AS.OldNumFactors == 0 || AS.NumOldNumFactors < NumExpressions ) ) {
1940 if ( AS.OldNumFactors ) {
1941 oldw = AS.OldNumFactors;
1942 AS.OldNumFactors = (WORD *)Malloc1(NumExpressions*
sizeof(WORD),
"numfactors pointers");
1943 for ( i = 0; i < AS.NumOldNumFactors; i++ ) AS.OldNumFactors[i] = oldw[i];
1944 M_free(oldw,
"numfactors pointers");
1945 oldw = AS.Oldvflags;
1946 AS.Oldvflags = (WORD *)Malloc1(NumExpressions*
sizeof(WORD),
"vflags pointers");
1947 for ( i = 0; i < AS.NumOldNumFactors; i++ ) AS.Oldvflags[i] = oldw[i];
1948 AS.NumOldNumFactors = NumExpressions;
1949 M_free(oldw,
"vflags pointers");
1952 AS.OldNumFactors = (WORD *)Malloc1(NumExpressions*
sizeof(WORD),
"numfactors pointers");
1953 AS.Oldvflags = (WORD *)Malloc1(NumExpressions*
sizeof(WORD),
"vflags pointers");
1954 AS.NumOldNumFactors = NumExpressions;
1957 for ( i = 0; i < NumExpressions; i++ ) {
1958 AS.OldOnFile[i] = e[i].onfile;
1959 AS.OldNumFactors[i] = e[i].numfactors;
1960 AS.Oldvflags[i] = e[i].vflags;
1972 LONG CountTerms1(PHEAD0)
1975 POSITION oldposition, startposition;
1976 WORD *t, *m, *mstop, decr, i, *oldwork, retval;
1977 WORD *oldipointer = AR.CompressPointer;
1978 WORD oldGetOneFile = AR.GetOneFile, olddeferflag = AR.DeferFlag;
1981 oldwork = AT.WorkPointer;
1982 AT.WorkPointer = (WORD *)(((UBYTE *)(AT.WorkPointer)) + AM.MaxTer);
1984 startposition = AR.DefPosition;
1988 if ( AR.infile->handle >= 0 ) {
1989 PUTZERO(oldposition);
1995 SETBASEPOSITION(oldposition,AR.infile->POfill-AR.infile->PObuffer);
1996 AR.infile->POfill = (WORD *)((UBYTE *)(AR.infile->PObuffer)
1997 +BASEPOSITION(startposition));
2002 t = m = AR.CompressBuffer;
2004 mstop = t - ABS(t[-1]);
2006 while ( *m != HAAKJE && m < mstop ) m += m[1];
2009 AR.DeferFlag = olddeferflag;
2010 AT.WorkPointer = oldwork;
2011 AR.GetOneFile = oldGetOneFile;
2015 decr = WORDDIF(mstop,AR.CompressBuffer)-1;
2017 m = AR.CompressBuffer;
2018 t = AR.CompressPointer;
2030 AR.CompressPointer = oldipointer;
2033 retval = GetOneTerm(BHEAD AT.WorkPointer,AR.infile,&startposition,0);
2034 if ( retval <= 0 )
break;
2036 AR.CompressPointer = oldipointer;
2037 t = AR.CompressPointer;
2038 if ( *t < (1 + decr + ABS(*(t+*t-1))) )
break;
2040 m = AR.CompressBuffer+1;
2041 while ( m < mstop ) {
2042 if ( *m != *t )
goto Thatsit;
2050 AT.WorkPointer = oldwork;
2051 if ( AR.infile->handle >= 0 ) {
2057 AR.infile->POfill = AR.infile->PObuffer + BASEPOSITION(oldposition);
2059 AR.DeferFlag = olddeferflag;
2060 AR.GetOneFile = oldGetOneFile;
2076 #define CURRENTBRACKET 1 2077 #define BRACKETCURRENTEXPR 2 2078 #define BRACKETOTHEREXPR 3 2079 #define NOBRACKETACTIVE 4 2081 LONG TermsInBracket(
PHEAD WORD *term, WORD level)
2083 WORD *t, *tstop, *b, *tt, *n1, *n2;
2084 int type = 0, i, num;
2086 WORD *bracketbuffer = AT.WorkPointer;
2087 t = term; GETSTOP(t,tstop);
2088 t++; b = bracketbuffer;
2089 while ( t < tstop ) {
2090 if ( *t != TERMSINBRACKET ) { t += t[1];
continue; }
2091 if ( t[1] == FUNHEAD || (
2093 && t[FUNHEAD] == -SNUMBER
2094 && t[FUNHEAD+1] == 0
2096 if ( AC.ComDefer == 0 ) {
2097 type = NOBRACKETACTIVE;
2100 type = CURRENTBRACKET;
2105 if ( t[FUNHEAD] == -EXPRESSION ) {
2106 if ( t[FUNHEAD+2] < 0 ) {
2107 if ( ( t[FUNHEAD+2] <= -FUNCTION ) && ( t[1] == FUNHEAD+3 ) ) {
2108 type = BRACKETOTHEREXPR;
2109 *b++ = FUNHEAD+4; *b++ = -t[FUNHEAD+2]; *b++ = FUNHEAD;
2110 for ( i = 2; i < FUNHEAD; i++ ) *b++ = 0;
2111 *b++ = 1; *b++ = 1; *b++ = 3;
2114 else if ( ( t[FUNHEAD+2] > -FUNCTION ) && ( t[1] == FUNHEAD+4 ) ) {
2115 type = BRACKETOTHEREXPR;
2119 *b++ = 8; *b++ = SYMBOL; *b++ = 4; *b++ = tt[1];
2120 *b++ = 1; *b++ = 1; *b++ = 1; *b++ = 3;
2124 *b++ = 4; *b++ = 1; *b++ = 1; *b++ = 3;
2126 else goto IllBraReq;
2134 else if ( ( t[FUNHEAD+2] == (t[1]-FUNHEAD-2) ) &&
2135 ( t[FUNHEAD+2+ARGHEAD] == (t[FUNHEAD+2]-ARGHEAD) ) ) {
2136 type = BRACKETOTHEREXPR;
2137 tt = t + FUNHEAD + ARGHEAD; num = *tt;
2138 for ( i = 0; i < num; i++ ) *b++ = *tt++;
2143 if ( t[FUNHEAD] < 0 ) {
2144 if ( ( t[FUNHEAD] <= -FUNCTION ) && ( t[1] == FUNHEAD+1 ) ) {
2145 type = BRACKETCURRENTEXPR;
2146 *b++ = FUNHEAD+4; *b++ = -t[FUNHEAD+2]; *b++ = FUNHEAD;
2147 for ( i = 2; i < FUNHEAD; i++ ) *b++ = 0;
2148 *b++ = 1; *b++ = 1; *b++ = 3; *b = 0;
2151 else if ( ( t[FUNHEAD] > -FUNCTION ) && ( t[1] == FUNHEAD+2 ) ) {
2152 type = BRACKETCURRENTEXPR;
2156 *b++ = 8; *b++ = SYMBOL; *b++ = 4; *b++ = tt[1];
2157 *b++ = 1; *b++ = 1; *b++ = 1; *b++ = 3;
2161 *b++ = 4; *b++ = 1; *b++ = 1; *b++ = 3;
2163 else goto IllBraReq;
2171 else if ( ( t[FUNHEAD] == (t[1]-FUNHEAD) ) &&
2172 ( t[FUNHEAD+ARGHEAD] == (t[FUNHEAD]-ARGHEAD) ) ) {
2173 type = BRACKETCURRENTEXPR;
2174 tt = t + FUNHEAD + ARGHEAD; num = *tt;
2175 for ( i = 0; i < num; i++ ) *b++ = *tt++;
2180 MLOCK(ErrorMessageLock);
2181 MesPrint(
"Illegal bracket request in termsinbracket_ function.");
2182 MUNLOCK(ErrorMessageLock);
2189 if ( AT.WorkPointer + *term +4 > AT.WorkTop ) {
2190 MLOCK(ErrorMessageLock);
2192 MesPrint(
"Called from termsinbracket_ function.");
2193 MUNLOCK(ErrorMessageLock);
2200 case CURRENTBRACKET:
2206 numterms = CountTerms1(BHEAD0);
2208 case BRACKETCURRENTEXPR:
2212 MLOCK(ErrorMessageLock);
2213 MesPrint(
"termsinbracket_ function currently only handles Keep Brackets.");
2214 MUNLOCK(ErrorMessageLock);
2216 case BRACKETOTHEREXPR:
2217 MLOCK(ErrorMessageLock);
2218 MesPrint(
"termsinbracket_ function currently only handles Keep Brackets.");
2219 MUNLOCK(ErrorMessageLock);
2221 case NOBRACKETACTIVE:
2228 n1 = term; n2 = AT.WorkPointer; tstop = n1 + *n1;
2229 while ( n1 < t ) *n2++ = *n1++;
2230 i = numterms >> BITSINWORD;
2232 *n2++ = LNUMBER; *n2++ = 4; *n2++ = 1; *n2++ = (WORD)(numterms & WORDMASK);
2235 *n2++ = LNUMBER; *n2++ = 5; *n2++ = 2;
2236 *n2++ = (WORD)(numterms & WORDMASK); *n2++ = i;
2239 while ( n1 < tstop ) *n2++ = *n1++;
2240 AT.WorkPointer[0] = n2 - AT.WorkPointer;
2241 AT.WorkPointer = n2;
2243 AT.WorkPointer = bracketbuffer;
2244 MLOCK(ErrorMessageLock);
2245 MesPrint(
"Called from termsinbracket_ function.");
2246 MUNLOCK(ErrorMessageLock);
2252 AT.WorkPointer = bracketbuffer;
int PF_BroadcastCBuf(int bufnum)
int PF_BroadcastExpFlags(void)
int PF_BroadcastExpr(EXPRESSIONS e, FILEHANDLE *file)
int PF_BroadcastRedefinedPreVars(void)
int PF_CollectModifiedDollars(void)
WORD Generator(PHEAD WORD *, WORD)
int PF_BroadcastModifiedDollars(void)