47WORD 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 ) {
73 case SPECTATOREXPRESSION:
75 case HIDDENLEXPRESSION:
77 AC.exprnames->namenode[e_in->node].type = CDELETE;
79 if ( e_in->status != HIDDENLEXPRESSION )
80 ClearBracketIndex(e_in-Expressions);
84 case GLOBALEXPRESSION:
85 case HIDDENGEXPRESSION:
91 if (
PF_BroadcastExpr(e_in, e_in->status == HIDDENGEXPRESSION ? AR.hidefile : AR.outfile) )
return -1;
92 if ( PF.me == MASTER ) {
98 if ( e_in->status == HIDDENGEXPRESSION ) {
99 if ( e->status == HIDDENGEXPRESSION
100 || e->status == HIDDENLEXPRESSION )
break;
103 if ( e->status == GLOBALEXPRESSION
104 || e->status == LOCALEXPRESSION )
break;
118 DIFPOS(length,e->onfile,e_in->onfile);
121 FILEHANDLE *f = e_in->status == HIDDENGEXPRESSION ? AR.hidefile : AR.outfile;
123 SETBASELENGTH(length,TOLONG(f->POfull)
124 - TOLONG(f->PObuffer)
125 - BASEPOSITION(e_in->onfile));
128 SeekFile(f->
handle,&(f->filesize),SEEK_SET);
129 DIFPOS(length,f->filesize,e_in->onfile);
132 if ( ToStorage(e_in,&length) ) {
133 return(MesCall(
"CleanExpr"));
135 e_in->status = STOREDEXPRESSION;
136 if ( e_in->status != HIDDENGEXPRESSION )
137 ClearBracketIndex(e_in-Expressions);
140 case SKIPLEXPRESSION:
141 case DROPLEXPRESSION:
142 case DROPHLEXPRESSION:
143 case DROPGEXPRESSION:
144 case DROPHGEXPRESSION:
145 case STOREDEXPRESSION:
146 case DROPSPECTATOREXPRESSION:
147 if ( e_out != e_in ) {
148 node = AC.exprnames->namenode + e_in->node;
149 node->number = e_out - Expressions;
151 e_out->onfile = e_in->onfile;
152 e_out->size = e_in->size;
153 e_out->printflag = 0;
154 if ( par ) e_out->status = STOREDEXPRESSION;
155 else e_out->status = e_in->status;
156 e_out->name = e_in->name;
157 e_out->node = e_in->node;
158 e_out->renum = e_in->renum;
160 e_out->counter = e_in->counter;
161 e_out->hidelevel = e_in->hidelevel;
162 e_out->inmem = e_in->inmem;
163 e_out->bracketinfo = e_in->bracketinfo;
164 e_out->newbracketinfo = e_in->newbracketinfo;
165 e_out->numdummies = e_in->numdummies;
166 e_out->numfactors = e_in->numfactors;
167 e_out->vflags = e_in->vflags;
168 e_out->sizeprototype = e_in->sizeprototype;
176 case DROPPEDEXPRESSION:
179 AC.exprnames->namenode[e_in->node].type = CDELETE;
184 }
while ( --n > 0 ); }
187 if ( numhid == 0 && AR.hidefile->PObuffer ) {
188 if ( AR.hidefile->handle >= 0 ) {
189 CloseFile(AR.hidefile->handle);
190 remove(AR.hidefile->name);
191 AR.hidefile->handle = -1;
193 AR.hidefile->POfull =
194 AR.hidefile->POfill = AR.hidefile->PObuffer;
195 PUTZERO(AR.hidefile->POposition);
216 retval = CleanExpr(1);
219 if ( AC.DidClean ) CompactifyTree(AC.exprnames,EXPRNAMES);
221 AC.CodesFlag = AM.gCodesFlag;
222 AC.NamesFlag = AM.gNamesFlag;
223 AC.StatsFlag = AM.gStatsFlag;
224 AC.OldFactArgFlag = AM.gOldFactArgFlag;
225 AC.TokensWriteFlag = AM.gTokensWriteFlag;
226 AC.extrasymbols = AM.gextrasymbols;
227 if ( AC.extrasym ) { M_free(AC.extrasym,
"extrasym"); AC.extrasym = 0; }
228 i = 1; s = AM.gextrasym;
while ( *s ) { s++; i++; }
229 AC.extrasym = (UBYTE *)Malloc1(i*
sizeof(UBYTE),
"extrasym");
230 for ( j = 0; j < i; j++ ) AC.extrasym[j] = AM.gextrasym[j];
231 AO.NoSpacesInNumbers = AM.gNoSpacesInNumbers;
232 AO.IndentSpace = AM.gIndentSpace;
233 AC.lUnitTrace = AM.gUnitTrace;
234 AC.lDefDim = AM.gDefDim;
235 AC.lDefDim4 = AM.gDefDim4;
237 if ( AC.ncmod == AM.gncmod && AC.modmode == AM.gmodmode ) {
240 if ( AC.cmod[j] != AM.gcmod[j] )
break;
243 M_free(AC.halfmod,
"halfmod");
244 AC.halfmod = 0; AC.nhalfmod = 0;
248 M_free(AC.halfmod,
"halfmod");
249 AC.halfmod = 0; AC.nhalfmod = 0;
252 if ( AC.modinverses ) {
253 if ( AC.ncmod == AM.gncmod && AC.modmode == AM.gmodmode ) {
256 if ( AC.cmod[j] != AM.gcmod[j] )
break;
259 M_free(AC.modinverses,
"modinverses");
264 M_free(AC.modinverses,
"modinverses");
268 AN.ncmod = AC.ncmod = AM.gncmod;
269 AC.npowmod = AM.gnpowmod;
270 AC.modmode = AM.gmodmode;
271 if ( ( ( AC.modmode & INVERSETABLE ) != 0 ) && ( AC.modinverses == 0 ) )
273 AC.funpowers = AM.gfunpowers;
274 AC.lPolyFun = AM.gPolyFun;
275 AC.lPolyFunInv = AM.gPolyFunInv;
276 AC.lPolyFunType = AM.gPolyFunType;
277 AC.lPolyFunExp = AM.gPolyFunExp;
278 AR.PolyFunVar = AC.lPolyFunVar = AM.gPolyFunVar;
279 AC.lPolyFunPow = AM.gPolyFunPow;
280 AC.parallelflag = AM.gparallelflag;
281 AC.ProcessBucketSize = AC.mProcessBucketSize = AM.gProcessBucketSize;
282 AC.properorderflag = AM.gproperorderflag;
283 AC.ThreadBucketSize = AM.gThreadBucketSize;
284 AC.ThreadStats = AM.gThreadStats;
285 AC.FinalStats = AM.gFinalStats;
286 AC.OldGCDflag = AM.gOldGCDflag;
287 AC.WTimeStatsFlag = AM.gWTimeStatsFlag;
288 AC.ThreadsFlag = AM.gThreadsFlag;
289 AC.ThreadBalancing = AM.gThreadBalancing;
290 AC.ThreadSortFileSynch = AM.gThreadSortFileSynch;
291 AC.ProcessStats = AM.gProcessStats;
292 AC.OldParallelStats = AM.gOldParallelStats;
293 AC.IsFortran90 = AM.gIsFortran90;
294 AC.SizeCommuteInSet = AM.gSizeCommuteInSet;
295 PruneExtraSymbols(AM.gnumextrasym);
297 if ( AC.Fortran90Kind ) {
298 M_free(AC.Fortran90Kind,
"Fortran90 Kind");
299 AC.Fortran90Kind = 0;
301 if ( AM.gFortran90Kind ) {
302 AC.Fortran90Kind = strDup1(AM.gFortran90Kind,
"Fortran90 Kind");
304 if ( AC.ThreadsFlag && AM.totalnumberofthreads > 1 ) AS.MultiThreaded = 1;
316 if ( MakeModTable() ) {
317 MesPrint(
"===No printing in powers of generator");
329 AC.Cnumpows = AM.gCnumpows;
330 AC.OutputMode = AM.gOutputMode;
331 AC.OutputSpaces = AM.gOutputSpaces;
332 AC.OutNumberType = AM.gOutNumberType;
333 AR.SortType = AC.SortType = AM.gSortType;
334 AC.ShortStatsMax = AM.gShortStatsMax;
338 for ( i = 0; i < NumFunctions; i++ ) functions[i].flags &= ~COULDCOMMUTE;
339 if ( AC.CommuteInSet ) {
345 if ( *gg <= GAMMASEVEN && *gg >= GAMMA ) {
346 functions[GAMMA-FUNCTION].flags |= COULDCOMMUTE;
347 functions[GAMMAI-FUNCTION].flags |= COULDCOMMUTE;
348 functions[GAMMAFIVE-FUNCTION].flags |= COULDCOMMUTE;
349 functions[GAMMASIX-FUNCTION].flags |= COULDCOMMUTE;
350 functions[GAMMASEVEN-FUNCTION].flags |= COULDCOMMUTE;
353 functions[*gg-FUNCTION].flags |= COULDCOMMUTE;
361 for ( i = AO.NumDictionaries-1; i >= AO.gNumDictionaries; i-- ) {
362 RemoveDictionary(AO.Dictionaries[i]);
363 M_free(AO.Dictionaries[i],
"Dictionary");
365 for( ; i >= 0; i-- ) {
366 ShrinkDictionary(AO.Dictionaries[i]);
368 AO.NumDictionaries = AO.gNumDictionaries;
384 AM.gCodesFlag = AC.CodesFlag;
385 AM.gNamesFlag = AC.NamesFlag;
386 AM.gStatsFlag = AC.StatsFlag;
387 AM.gOldFactArgFlag = AC.OldFactArgFlag;
388 AM.gextrasymbols = AC.extrasymbols;
389 if ( AM.gextrasym ) { M_free(AM.gextrasym,
"extrasym"); AM.gextrasym = 0; }
390 i = 1; s = AC.extrasym;
while ( *s ) { s++; i++; }
391 AM.gextrasym = (UBYTE *)Malloc1(i*
sizeof(UBYTE),
"extrasym");
392 for ( j = 0; j < i; j++ ) AM.gextrasym[j] = AC.extrasym[j];
393 AM.gTokensWriteFlag= AC.TokensWriteFlag;
394 AM.gNoSpacesInNumbers = AO.NoSpacesInNumbers;
395 AM.gIndentSpace = AO.IndentSpace;
396 AM.gUnitTrace = AC.lUnitTrace;
397 AM.gDefDim = AC.lDefDim;
398 AM.gDefDim4 = AC.lDefDim4;
399 AM.gncmod = AC.ncmod;
400 AM.gnpowmod = AC.npowmod;
401 AM.gmodmode = AC.modmode;
402 AM.gCnumpows = AC.Cnumpows;
403 AM.gOutputMode = AC.OutputMode;
404 AM.gOutputSpaces = AC.OutputSpaces;
405 AM.gOutNumberType = AC.OutNumberType;
406 AM.gfunpowers = AC.funpowers;
407 AM.gPolyFun = AC.lPolyFun;
408 AM.gPolyFunInv = AC.lPolyFunInv;
409 AM.gPolyFunType = AC.lPolyFunType;
410 AM.gPolyFunExp = AC.lPolyFunExp;
411 AM.gPolyFunVar = AC.lPolyFunVar;
412 AM.gPolyFunPow = AC.lPolyFunPow;
413 AM.gparallelflag = AC.parallelflag;
414 AM.gProcessBucketSize = AC.ProcessBucketSize;
415 AM.gproperorderflag = AC.properorderflag;
416 AM.gThreadBucketSize = AC.ThreadBucketSize;
417 AM.gThreadStats = AC.ThreadStats;
418 AM.gFinalStats = AC.FinalStats;
419 AM.gOldGCDflag = AC.OldGCDflag;
420 AM.gWTimeStatsFlag = AC.WTimeStatsFlag;
421 AM.gThreadsFlag = AC.ThreadsFlag;
422 AM.gThreadBalancing = AC.ThreadBalancing;
423 AM.gThreadSortFileSynch = AC.ThreadSortFileSynch;
424 AM.gProcessStats = AC.ProcessStats;
425 AM.gOldParallelStats = AC.OldParallelStats;
426 AM.gIsFortran90 = AC.IsFortran90;
427 AM.gSizeCommuteInSet = AC.SizeCommuteInSet;
428 AM.gnumextrasym = (cbuf+AM.sbufnum)->numrhs;
429 if ( AM.gFortran90Kind ) {
430 M_free(AM.gFortran90Kind,
"Fortran 90 Kind");
431 AM.gFortran90Kind = 0;
433 if ( AC.Fortran90Kind ) {
434 AM.gFortran90Kind = strDup1(AC.Fortran90Kind,
"Fortran 90 Kind");
448 AM.gSortType = AC.SortType;
449 AM.gShortStatsMax = AC.ShortStatsMax;
451 if ( AO.CurrentDictionary > 0 || AP.OpenDictionary > 0 ) {
452 Warning(
"You cannot have an open or selected dictionary at a .global. Dictionary closed.");
453 AP.OpenDictionary = 0;
454 AO.CurrentDictionary = 0;
457 AO.gNumDictionaries = AO.NumDictionaries;
458 for ( i = 0; i < AO.NumDictionaries; i++ ) {
459 AO.Dictionaries[i]->gnumelements = AO.Dictionaries[i]->numelements;
461 if ( AM.NumSpectatorFiles > 0 ) {
462 for ( i = 0; i < AM.SizeForSpectatorFiles; i++ ) {
463 if ( AM.SpectatorFiles[i].name != 0 )
464 AM.SpectatorFiles[i].flags |= GLOBALSPECTATORFLAG;
478 for ( j = 0, e = Expressions; j < NumExpressions; j++, e++ ) {
479 switch ( e->status ) {
480 case SKIPLEXPRESSION:
481 e->status = LOCALEXPRESSION;
483 case UNHIDELEXPRESSION:
484 e->status = LOCALEXPRESSION;
485 ClearBracketIndex(j);
486 e->bracketinfo = e->newbracketinfo; e->newbracketinfo = 0;
488 case HIDELEXPRESSION:
489 e->status = HIDDENLEXPRESSION;
491 case SKIPGEXPRESSION:
492 e->status = GLOBALEXPRESSION;
494 case UNHIDEGEXPRESSION:
495 e->status = GLOBALEXPRESSION;
496 ClearBracketIndex(j);
497 e->bracketinfo = e->newbracketinfo; e->newbracketinfo = 0;
499 case HIDEGEXPRESSION:
500 e->status = HIDDENGEXPRESSION;
502 case DROPLEXPRESSION:
503 case DROPGEXPRESSION:
504 case DROPHLEXPRESSION:
505 case DROPHGEXPRESSION:
506 case DROPSPECTATOREXPRESSION:
507 e->status = DROPPEDEXPRESSION;
508 ClearBracketIndex(j);
509 e->bracketinfo = e->newbracketinfo; e->newbracketinfo = 0;
510 if ( e->replace >= 0 ) {
511 Expressions[e->replace].replace = REGULAREXPRESSION;
512 AC.exprnames->namenode[e->node].number = e->replace;
513 e->replace = REGULAREXPRESSION;
516 AC.exprnames->namenode[e->node].type = CDELETE;
520 case LOCALEXPRESSION:
521 case GLOBALEXPRESSION:
522 ClearBracketIndex(j);
523 e->bracketinfo = e->newbracketinfo; e->newbracketinfo = 0;
525 case HIDDENLEXPRESSION:
526 case HIDDENGEXPRESSION:
528 case INTOHIDELEXPRESSION:
529 ClearBracketIndex(j);
530 e->bracketinfo = e->newbracketinfo; e->newbracketinfo = 0;
531 e->status = HIDDENLEXPRESSION;
533 case INTOHIDEGEXPRESSION:
534 ClearBracketIndex(j);
535 e->bracketinfo = e->newbracketinfo; e->newbracketinfo = 0;
536 e->status = HIDDENGEXPRESSION;
539 ClearBracketIndex(j);
543 if ( e->replace == NEWLYDEFINEDEXPRESSION ) e->replace = REGULAREXPRESSION;
552void PutInVflags(WORD nexpr)
559 if ( AS.OldOnFile == 0 ) {
560 AS.NumOldOnFile = 20;
561 AS.OldOnFile = (
POSITION *)Malloc1(AS.NumOldOnFile*
sizeof(
POSITION),
"file pointers");
563 else if ( nexpr >= AS.NumOldOnFile ) {
565 AS.OldOnFile = (
POSITION *)Malloc1(2*AS.NumOldOnFile*
sizeof(
POSITION),
"file pointers");
566 for ( i = 0; i < AS.NumOldOnFile; i++ ) AS.OldOnFile[i] = old[i];
567 AS.NumOldOnFile = 2*AS.NumOldOnFile;
568 M_free(old,
"process file pointers");
570 if ( AS.OldNumFactors == 0 ) {
571 AS.NumOldNumFactors = 20;
572 AS.OldNumFactors = (WORD *)Malloc1(AS.NumOldNumFactors*
sizeof(WORD),
"numfactors pointers");
573 AS.Oldvflags = (WORD *)Malloc1(AS.NumOldNumFactors*
sizeof(WORD),
"vflags pointers");
575 else if ( nexpr >= AS.NumOldNumFactors ) {
576 oldw = AS.OldNumFactors;
577 AS.OldNumFactors = (WORD *)Malloc1(2*AS.NumOldNumFactors*
sizeof(WORD),
"numfactors pointers");
578 for ( i = 0; i < AS.NumOldNumFactors; i++ ) AS.OldNumFactors[i] = oldw[i];
579 M_free(oldw,
"numfactors pointers");
581 AS.Oldvflags = (WORD *)Malloc1(2*AS.NumOldNumFactors*
sizeof(WORD),
"vflags pointers");
582 for ( i = 0; i < AS.NumOldNumFactors; i++ ) AS.Oldvflags[i] = oldw[i];
583 AS.NumOldNumFactors = 2*AS.NumOldNumFactors;
584 M_free(oldw,
"vflags pointers");
589 if ( nexpr >= AS.NumOldOnFile || nexpr >= AS.NumOldNumFactors )
goto restart;
590 AS.OldOnFile[nexpr] = e->onfile;
591 AS.OldNumFactors[nexpr] = e->numfactors;
592 AS.Oldvflags[nexpr] = e->vflags;
600WORD DoExecute(WORD par, WORD skip)
604 int i, oldmultithreaded = AS.MultiThreaded;
609 SpecialCleanup(BHEAD0);
610 if ( skip )
goto skipexec;
611 if ( AC.IfLevel > 0 ) {
612 MesPrint(
" %d endif statement(s) missing",AC.IfLevel);
615 if ( AC.WhileLevel > 0 ) {
616 MesPrint(
" %d endwhile statement(s) missing",AC.WhileLevel);
619 if ( AC.arglevel > 0 ) {
620 MesPrint(
" %d endargument statement(s) missing",AC.arglevel);
623 if ( AC.termlevel > 0 ) {
624 MesPrint(
" %d endterm statement(s) missing",AC.termlevel);
627 if ( AC.insidelevel > 0 ) {
628 MesPrint(
" %d endinside statement(s) missing",AC.insidelevel);
631 if ( AC.inexprlevel > 0 ) {
632 MesPrint(
" %d endinexpression statement(s) missing",AC.inexprlevel);
635 if ( AC.NumLabels > 0 ) {
636 for ( i = 0; i < AC.NumLabels; i++ ) {
637 if ( AC.Labels[i] < 0 ) {
638 MesPrint(
" -->Label %s missing",AC.LabelNames[i]);
643 if ( AC.SwitchLevel > 0 ) {
644 MesPrint(
" %d endswitch statement(s) missing",AC.SwitchLevel);
647 if ( AC.dolooplevel > 0 ) {
648 MesPrint(
" %d enddo statement(s) missing",AC.dolooplevel);
651 if ( AP.OpenDictionary > 0 ) {
652 MesPrint(
" Dictionary %s has not been closed.",
653 AO.Dictionaries[AP.OpenDictionary-1]->name);
654 AP.OpenDictionary = 0;
657 if ( RetCode )
return(RetCode);
658 AR.Cnumlhs = cbuf[AM.rbufnum].numlhs;
660 if ( ( AS.ExecMode = par ) == GLOBALMODULE ) AS.ExecMode = 0;
669 if ( NumPotModdollars >= 0 ) {
670 for ( i = 0; i < NumExpressions; i++ ) {
671 if ( Expressions[i].partodo ) { AC.partodoflag = 1;
break; }
675 if ( AC.partodoflag > 0 && PF.numtasks < 3 ) {
679 if ( AC.partodoflag > 0 || ( NumPotModdollars > 0 && AC.mparallelflag == PARALLELFLAG ) ) {
680 if ( NumPotModdollars > NumModOptdollars ) {
681 AC.mparallelflag |= NOPARALLEL_DOLLAR;
683 AS.MultiThreaded = 0;
688 for ( i = 0; i < NumPotModdollars; i++ ) {
689 for ( j = 0; j < NumModOptdollars; j++ )
690 if ( PotModdollars[i] == ModOptdollars[j].number )
break;
691 if ( j >= NumModOptdollars ) {
692 AC.mparallelflag |= NOPARALLEL_DOLLAR;
694 AS.MultiThreaded = 0;
699 switch ( ModOptdollars[j].type ) {
706 AC.mparallelflag |= NOPARALLEL_DOLLAR;
707 AS.MultiThreaded = 0;
714 else if ( ( AC.mparallelflag & NOPARALLEL_USER ) != 0 ) {
716 AS.MultiThreaded = 0;
720 if ( AC.partodoflag == 0 ) {
721 for ( i = 0; i < NumExpressions; i++ ) {
722 Expressions[i].partodo = 0;
725 else if ( AC.partodoflag == -1 ) {
733 if ( AC.RhsExprInModuleFlag && (AC.mparallelflag == PARALLELFLAG || AC.partodoflag) ) {
734 if (PF.rhsInParallel) {
737 PF.slavebuf.PObuffer=(WORD *)Malloc1(AM.ScratSize*
sizeof(WORD),
"PF inbuf");
738 PF.slavebuf.POsize=AM.ScratSize*
sizeof(WORD);
739 PF.slavebuf.POfull = PF.slavebuf.POfill = PF.slavebuf.PObuffer;
740 PF.slavebuf.POstop= PF.slavebuf.PObuffer+AM.ScratSize;
741 PUTZERO(PF.slavebuf.POposition);
745 AC.mparallelflag |= NOPARALLEL_RHS;
747 for ( i = 0; i < NumExpressions; i++ ) {
748 Expressions[i].partodo = 0;
755 if ( (AC.mparallelflag == PARALLELFLAG || AC.partodoflag) && PF.me != MASTER ) {
756 for ( i = 0; i < NumModOptdollars; i++ ) {
757 if ( ModOptdollars[i].type == MODSUM ) {
758 DOLLARS d = Dollars + ModOptdollars[i].number;
760 if ( d->where && d->where != &AM.dollarzero ) M_free(d->where,
"old content of dollar");
761 d->where = &AM.dollarzero;
763 CleanDollarFactors(d);
768 AR.SortType = AC.SortType;
770 if ( PF.me == MASTER )
773 if ( AC.SetupFlag ) WriteSetup();
774 if ( AC.NamesFlag || AC.CodesFlag ) WriteLists();
776 if ( par == GLOBALMODULE ) MakeGlobal();
777 if ( RevertScratch() )
return(-1);
778 if ( AC.ncmod ) SetMods();
783 if ( PF.me == MASTER )
786 if ( !AC.ThreadsFlag || AC.mparallelflag & NOPARALLEL_USER ) {
789 else if ( AC.mparallelflag & NOPARALLEL_DOLLAR ) {
790 if ( AC.WarnFlag >= 2 ) {
793 s = strDup1((UBYTE *)
"",
"NOPARALLEL_DOLLAR s");
795 j = NumPotModdollars;
796 for ( i = 0; i < j; i++ ) {
797 for ( k = 0; k < NumModOptdollars; k++ )
798 if ( ModOptdollars[k].number == PotModdollars[i] )
break;
799 if ( k >= NumModOptdollars ) {
802 s = AddToString(s,(UBYTE *)
", ",0);
803 s = AddToString(s,(UBYTE *)
"$",0);
804 s = AddToString(s,DOLLARNAME(Dollars,PotModdollars[i]),0);
808 s1 = strDup1((UBYTE *)
"This module is forced to run in sequential mode due to $-variable",
"NOPARALLEL_DOLLAR s1");
810 s1 = AddToString(s1,(UBYTE *)
"s",0);
811 s1 = AddToString(s1,(UBYTE *)
": ",0);
812 s1 = AddToString(s1,s,0);
813 HighWarning((
char *)s1);
814 M_free(s,
"NOPARALLEL_DOLLAR s");
815 M_free(s1,
"NOPARALLEL_DOLLAR s1");
818 else if ( AC.mparallelflag & NOPARALLEL_RHS ) {
819 HighWarning(
"This module is forced to run in sequential mode due to RHS expression names");
821 else if ( AC.mparallelflag & NOPARALLEL_CONVPOLY ) {
822 HighWarning(
"This module is forced to run in sequential mode due to conversion to extra symbols");
824 else if ( AC.mparallelflag & NOPARALLEL_SPECTATOR ) {
825 HighWarning(
"This module is forced to run in sequential mode due to tospectator/copyspectator");
827 else if ( AC.mparallelflag & NOPARALLEL_TBLDOLLAR ) {
828 HighWarning(
"This module is forced to run in sequential mode due to $-variable assignments in tables");
830 else if ( AC.mparallelflag & NOPARALLEL_NPROC ) {
831 HighWarning(
"This module is forced to run in sequential mode because there is only one processor");
843 if ( AP.preError == 0 && (
Processor() || WriteAll() ) ) RetCode = -1;
850 if ( AC.ncmod ) UnSetMods();
851 AS.MultiThreaded = oldmultithreaded;
857 if ( NumPotModdollars > 0 ) {
859 if ( RetCode )
return RetCode;
861 if ( RetCode )
return RetCode;
864 if ( AC.numpfirstnum > 0 ) {
866 if ( RetCode )
return RetCode;
869 if ( AC.topolynomialflag & TOPOLYNOMIALFLAG ) {
871 if ( RetCode )
return RetCode;
878 if ( RetCode )
return RetCode;
883 if ( PF.me != MASTER && AR.hidefile->PObuffer ) {
884 if ( AR.hidefile->handle >= 0 ) {
885 CloseFile(AR.hidefile->handle);
886 AR.hidefile->handle = -1;
887 remove(AR.hidefile->name);
889 AR.hidefile->POfull = AR.hidefile->POfill = AR.hidefile->PObuffer;
890 PUTZERO(AR.hidefile->POposition);
894 for ( j = 0; j < NumModOptdollars; j++ ) {
895 if ( ModOptdollars[j].dstruct ) {
899 for ( i = 0; i < AM.totalnumberofthreads; i++ ) {
900 if ( ModOptdollars[j].dstruct[i].size > 0 ) {
901 CleanDollarFactors(&(ModOptdollars[j].dstruct[i]));
902 M_free(ModOptdollars[j].dstruct[i].where,
"Local dollar value");
908 M_free(ModOptdollars[j].dstruct,
"Local DOLLARS");
909 ModOptdollars[j].dstruct = 0;
930 if ( ModOptdollars ) M_free(ModOptdollars,
"ModOptdollars pointer");
931 if ( PotModdollars ) M_free(PotModdollars,
"PotModdollars pointer");
934 AC.ModOptDolList.lijst = NULL;
936 AC.PotModDolList.lijst = NULL;
938 NumPotModdollars = 0;
939 NumModOptdollars = 0;
946if ( AC.SwitchInArray > 0 ) {
947 for ( i = 0; i < AC.SwitchInArray; i++ ) {
948 SWITCH *sw = AC.SwitchArray + i;
949 if ( sw->table ) M_free(sw->table,
"Switch table");
951 sw->defaultcase.ncase = 0;
952 sw->defaultcase.value = 0;
953 sw->defaultcase.compbuffer = 0;
954 sw->endswitch.ncase = 0;
955 sw->endswitch.value = 0;
956 sw->endswitch.compbuffer = 0;
967 AC.SwitchInArray = 0;
974 AC.PolyRatFunChanged = 0;
976 if ( par == STOREMODULE || par == CLEARMODULE ) {
978 if ( par == STOREMODULE && PopVariables() ) RetCode = -1;
979 if ( AR.infile->handle >= 0 ) {
980 CloseFile(AR.infile->handle);
981 remove(AR.infile->name);
982 AR.infile->handle = -1;
984 AR.infile->POfill = AR.infile->PObuffer;
985 PUTZERO(AR.infile->POposition);
986 AR.infile->POfull = AR.infile->PObuffer;
987 if ( AR.outfile->handle >= 0 ) {
988 CloseFile(AR.outfile->handle);
989 remove(AR.outfile->name);
990 AR.outfile->handle = -1;
993 AR.outfile->POfill = AR.outfile->PObuffer;
994 PUTZERO(AR.outfile->POposition);
995 if ( AR.hidefile->handle >= 0 ) {
996 CloseFile(AR.hidefile->handle);
997 remove(AR.hidefile->name);
998 AR.hidefile->handle = -1;
1000 AR.hidefile->POfull =
1001 AR.hidefile->POfill = AR.hidefile->PObuffer;
1002 PUTZERO(AR.hidefile->POposition);
1004 if ( par == CLEARMODULE ) {
1005 if ( DeleteStore(0) < 0 ) {
1006 MesPrint(
"Cannot restart the storage file");
1012 AM.gProcessBucketSize = AM.hProcessBucketSize;
1013 AM.gparallelflag = PARALLELFLAG;
1014 AM.gnumextrasym = AM.ggnumextrasym;
1015 PruneExtraSymbols(AM.ggnumextrasym);
1018 ClearSpectators(par);
1021 if ( CleanExpr(0) ) RetCode = -1;
1022 if ( AC.DidClean ) CompactifyTree(AC.exprnames,EXPRNAMES);
1027 if ( AC.MultiBracketBuf != 0 ) {
1028 for ( i = 0; i < MAXMULTIBRACKETLEVELS; i++ ) {
1029 if ( AC.MultiBracketBuf[i] ) {
1030 M_free(AC.MultiBracketBuf[i],
"bracket buffer i");
1031 AC.MultiBracketBuf[i] = 0;
1034 AC.MultiBracketLevels = 0;
1035 M_free(AC.MultiBracketBuf,
"multi bracket buffer");
1036 AC.MultiBracketBuf = 0;
1063WORD PutBracket(PHEAD WORD *termin)
1066 WORD *t, *t1, *b, i, j, *lastfun;
1068 WORD *bStop, *bb, *bf, *tStop;
1069 WORD *term1,*term2, *m1, *m2, *tStopa;
1070 WORD *bbb = 0, *bind, *binst = 0, bwild = 0, *bss = 0, *bns = 0, bset = 0;
1071 term1 = AT.WorkPointer+1;
1072 term2 = (WORD *)(((UBYTE *)(term1)) + AM.MaxTer);
1073 if ( ( (WORD *)(((UBYTE *)(term2)) + AM.MaxTer) ) > AT.WorkTop )
return(MesWork());
1074 if ( AR.BracketOn < 0 ) {
1075 t2 = term1; t1 = term2;
1078 t1 = term1; t2 = term2;
1080 b = AT.BrackBuf; bStop = b+*b; b++;
1081 while ( b < bStop ) {
1082 if ( *b == INDEX ) { bwild = 1; bbb = b+2; binst = b + b[1]; }
1083 if ( *b == SETSET ) { bset = 1; bss = b+2; bns = b + b[1]; }
1087 t = termin; tStopa = t + *t; i = *(t + *t -1); i = ABS(i);
1088 if ( AR.PolyFun && AT.PolyAct ) tStop = termin + AT.PolyAct;
1089 else tStop = tStopa - i;
1091 if ( AR.BracketOn < 0 ) {
1093 while ( t < tStop && *t >= FUNCTION
1094 && functions[*t-FUNCTION].commute ) {
1096 while ( b < bStop ) {
1099 while ( t < tStop && *t >= FUNCTION
1100 && functions[*t-FUNCTION].commute ) t += t[1];
1108 if ( b[1] == CFUNCTION ) {
1109 SETS set = Sets+b[0]; WORD i;
1110 for ( i = set->first; i < set->last; i++ ) {
1111 if ( SetElements[i] == *t ) {
1113 while ( t < tStop && *t >= FUNCTION
1114 && functions[*t-FUNCTION].commute ) t += t[1];
1122 if ( bwild && *t >= FUNCTION && functions[*t-FUNCTION].spec ) {
1127 while ( bind < binst ) {
1128 if ( *bind == *s2 ) {
1130 while ( t < tStop && *t >= FUNCTION
1131 && functions[*t-FUNCTION].commute ) t += t[1];
1144 while ( s1 < lastfun ) *t2++ = *s1++;
1145 while ( s1 < t ) *t1++ = *s1++;
1148 while ( s1 < t ) *t2++ = *s1++;
1154 while ( t < tStop && *t >= FUNCTION
1155 && functions[*t-FUNCTION].commute ) {
1157 while ( b < bStop ) {
1158 if ( *b == *t ) { lastfun = t + t[1];
goto NextNcom; }
1164 if ( b[1] == CFUNCTION ) {
1165 SETS set = Sets+b[0]; WORD i;
1166 for ( i = set->first; i < set->last; i++ ) {
1167 if ( SetElements[i] == *t ) {
1176 if ( bwild && *t >= FUNCTION && functions[*t-FUNCTION].spec ) {
1181 while ( bind < binst ) {
1182 if ( *bind == *s2 ) { lastfun = t + t[1];
goto NextNcom; }
1192 while ( s1 < lastfun ) *t1++ = *s1++;
1193 while ( s1 < t ) *t2++ = *s1++;
1198 b = AT.BrackBuf + 1;
1199 while ( b < bStop && *b >= FUNCTION
1200 && ( *b < FUNCTION || functions[*b-FUNCTION].commute ) ) {
1205 while ( t < tStop && ( bf < bStop || bwild || bset ) ) {
1207 while ( b < bStop && *b != *t ) { b += b[1]; }
1209 if ( *t >= FUNCTION ) {
1210 if ( b < bStop && *b == *t )
goto FunBrac;
1214 if ( b[1] == CFUNCTION ) {
1215 SETS set = Sets+b[0]; WORD i;
1216 for ( i = set->first; i < set->last; i++ ) {
1217 if ( SetElements[i] == *t )
goto FunBrac;
1223 if ( bwild && *t >= FUNCTION && functions[*t-FUNCTION].spec ) {
1228 while ( bind < binst ) {
1229 if ( *bind == *s2 )
goto FunBrac;
1237FunBrac: NCOPY(t1,t,i);
1243 if ( *t == DELTA ) {
1244 if ( b < bStop && *b == DELTA ) {
1248 else { NCOPY(t2,t,i); }
1250 else if ( *t == INDEX ) {
1253 *t1++ = *t; t1++; *t2++ = *t; t2++;
1257 while ( --j >= 0 ) {
1258 while ( *bind < *t && bind < binst ) bind++;
1259 if ( *bind == *t && bind < binst ) {
1264 while ( b3 < bns ) {
1265 if ( b3[1] == CVECTOR ) {
1266 SETS set = Sets+b3[0]; WORD i;
1267 for ( i = set->first; i < set->last; i++ ) {
1268 if ( SetElements[i] == *t ) {
1281 m1[1] = WORDDIF(t1,m1);
1282 if ( m1[1] == 2 ) t1 = m1;
1283 m2[1] = WORDDIF(t2,m2);
1284 if ( m2[1] == 2 ) t2 = m2;
1288 *t1++ = *t; t1++; *t2++ = *t; t2++;
1291 while ( --j >= 0 ) {
1293 while ( b3 < bns ) {
1294 if ( b3[1] == CVECTOR ) {
1295 SETS set = Sets+b3[0]; WORD i;
1296 for ( i = set->first; i < set->last; i++ ) {
1297 if ( SetElements[i] == *t ) {
1308 m1[1] = WORDDIF(t1,m1);
1309 if ( m1[1] == 2 ) t1 = m1;
1310 m2[1] = WORDDIF(t2,m2);
1311 if ( m2[1] == 2 ) t2 = m2;
1317 else if ( *t == VECTOR ) {
1318 if ( ( b < bStop && *b == VECTOR ) || bwild ) {
1319 if ( b < bStop && *b == VECTOR ) {
1320 bb = b + b[1]; b += 2;
1324 m1 = t1; m2 = t2; *t1++ = *t; *t2++ = *t; t1++; t2++; t += 2;
1327 while ( b < bb && ( *b < *t ||
1328 ( *b == *t && b[1] < t[1] ) ) ) b += 2;
1329 if ( b < bb && ( *t == *b && t[1] == b[1] ) ) {
1330 *t1++ = *t++; *t1++ = *t++;
goto nextvec;
1334 while ( bind < binst ) {
1335 if ( *t == *bind || t[1] == *bind ) {
1336 *t1++ = *t++; *t1++ = *t++;
1344 while ( b3 < bns ) {
1345 if ( b3[1] == CVECTOR ) {
1346 SETS set = Sets+b3[0]; WORD i;
1347 for ( i = set->first; i < set->last; i++ ) {
1348 if ( SetElements[i] == *t ) {
1349 *t1++ = *t++; *t1++ = *t++;
1357 *t2++ = *t++; *t2++ = *t++;
1360 m1[1] = WORDDIF(t1,m1);
1361 if ( m1[1] == 2 ) t1 = m1;
1362 m2[1] = WORDDIF(t2,m2);
1363 if ( m2[1] == 2 ) t2 = m2;
1366 m1 = t1; *t1++ = *t; t1++;
1367 m2 = t2; *t2++ = *t; t2++;
1371 while ( b3 < bns ) {
1372 if ( b3[1] == CVECTOR ) {
1373 SETS set = Sets+b3[0]; WORD i;
1374 for ( i = set->first; i < set->last; i++ ) {
1375 if ( SetElements[i] == *t ) {
1376 *t1++ = *t++; *t1++ = *t++;
1383 *t2++ = *t++; *t2++ = *t++;
1386 m1[1] = WORDDIF(t1,m1);
1387 if ( m1[1] == 2 ) t1 = m1;
1388 m2[1] = WORDDIF(t2,m2);
1389 if ( m2[1] == 2 ) t2 = m2;
1395 else if ( *t == DOTPRODUCT ) {
1396 if ( ( b < bStop && *b == *t ) || bwild ) {
1397 m1 = t1; *t1++ = *t; t1++;
1398 m2 = t2; *t2++ = *t; t2++;
1399 if ( b >= bStop || *b != *t ) { bb = b; s1 = b; }
1401 s1 = b + b[1]; bb = b + 2;
1404 while ( t < s2 && ( bb < s1 || bwild || bset ) ) {
1405 while ( bb < s1 && ( *bb < *t ||
1406 ( *bb == *t && bb[1] < t[1] ) ) ) bb += 3;
1407 if ( bb < s1 && *bb == *t && bb[1] == t[1] ) {
1408 *t1++ = *t++; *t1++ = *t++; *t1++ = *t++; bb += 3;
1413 while ( bind < binst ) {
1414 if ( *bind == *t || *bind == t[1] ) {
1415 *t1++ = *t++; *t1++ = *t++; *t1++ = *t++;
1423 while ( b3 < bns ) {
1424 if ( b3[1] == CVECTOR ) {
1425 SETS set = Sets+b3[0]; WORD i;
1426 for ( i = set->first; i < set->last; i++ ) {
1427 if ( SetElements[i] == *t || SetElements[i] == t[1] ) {
1428 *t1++ = *t++; *t1++ = *t++; *t1++ = *t++;
1436 *t2++ = *t++; *t2++ = *t++; *t2++ = *t++;
1439 while ( t < s2 ) *t2++ = *t++;
1440 m1[1] = WORDDIF(t1,m1);
1441 if ( m1[1] == 2 ) t1 = m1;
1442 m2[1] = WORDDIF(t2,m2);
1443 if ( m2[1] == 2 ) t2 = m2;
1446 m1 = t1; *t1++ = *t; t1++;
1447 m2 = t2; *t2++ = *t; t2++;
1451 while ( b3 < bns ) {
1452 if ( b3[1] == CVECTOR ) {
1453 SETS set = Sets+b3[0]; WORD i;
1454 for ( i = set->first; i < set->last; i++ ) {
1455 if ( SetElements[i] == *t || SetElements[i] == t[1] ) {
1456 *t1++ = *t++; *t1++ = *t++; *t1++ = *t++;
1463 *t2++ = *t++; *t2++ = *t++; *t2++ = *t++;
1466 m1[1] = WORDDIF(t1,m1);
1467 if ( m1[1] == 2 ) t1 = m1;
1468 m2[1] = WORDDIF(t2,m2);
1469 if ( m2[1] == 2 ) t2 = m2;
1471 else { NCOPY(t2,t,i); }
1473 else if ( *t == SYMBOL ) {
1474 if ( b < bStop && *b == *t ) {
1475 m1 = t1; *t1++ = *t; t1++;
1476 m2 = t2; *t2++ = *t; t2++;
1477 s1 = b + b[1]; bb = b+2;
1479 while ( bb < s1 && t < s2 ) {
1480 while ( bb < s1 && *bb < *t ) bb += 2;
1482 if ( bset )
goto TrySymbolSet;
1485 if ( *bb == *t ) { *t1++ = *t++; *t1++ = *t++; }
1490 while ( bbb < bns ) {
1491 if ( bbb[1] == CSYMBOL ) {
1492 SETS set = Sets+bbb[0]; WORD i;
1493 for ( i = set->first; i < set->last; i++ ) {
1494 if ( SetElements[i] == *t ) {
1495 *t1++ = *t++; *t1++ = *t++;
1502 *t2++ = *t++; *t2++ = *t++;
1504 else { *t2++ = *t++; *t2++ = *t++; }
1507 while ( t < s2 ) *t2++ = *t++;
1508 m1[1] = WORDDIF(t1,m1);
1509 if ( m1[1] == 2 ) t1 = m1;
1510 m2[1] = WORDDIF(t2,m2);
1511 if ( m2[1] == 2 ) t2 = m2;
1515 m1 = t1; *t1++ = *t; t1++;
1516 m2 = t2; *t2++ = *t; t2++;
1520 while ( bbb < bns ) {
1521 if ( bbb[1] == CSYMBOL ) {
1522 SETS set = Sets+bbb[0]; WORD i;
1523 for ( i = set->first; i < set->last; i++ ) {
1524 if ( SetElements[i] == *t ) {
1525 *t1++ = *t++; *t1++ = *t++;
1532 *t2++ = *t++; *t2++ = *t++;
1535 m1[1] = WORDDIF(t1,m1);
1536 if ( m1[1] == 2 ) t1 = m1;
1537 m2[1] = WORDDIF(t2,m2);
1538 if ( m2[1] == 2 ) t2 = m2;
1540 else { NCOPY(t2,t,i); }
1546 if ( ( i = WORDDIF(tStop,t) ) > 0 ) NCOPY(t2,t,i);
1547 if ( AR.BracketOn < 0 ) {
1548 s1 = t1; t1 = t2; t2 = s1;
1550 do { *t2++ = *t++; }
while ( t < (WORD *)tStopa );
1552 i = WORDDIF(t1,term1);
1553 *t++ = 4 + i + WORDDIF(t2,term2);
1558 i = WORDDIF(t2,term2);
1560 if ( i > 0 ) NCOPY(t,t1,i);
1572VOID SpecialCleanup(PHEAD0)
1575 if ( AT.previousEfactor ) M_free(AT.previousEfactor,
"Efactor cache");
1576 AT.previousEfactor = 0;
1589 if ( AN.cmod != 0 ) M_free(AN.cmod,
"AN.cmod");
1591 AN.cmod = (UWORD *)Malloc1(
sizeof(WORD)*n,
"AN.cmod");
1592 for ( i = 0; i < n; i++ ) AN.cmod[i] = AC.cmod[i];
1606 if ( AN.cmod != 0 ) M_free(AN.cmod,
"AN.cmod");
1619void ExchangeExpressions(
int num1,
int num2)
1622 WORD node1, node2, namesize, TMproto[SUBEXPSIZE];
1628 e1 = Expressions + num1;
1629 e2 = Expressions + num2;
1632 AC.exprnames->namenode[node1].number = num2;
1633 AC.exprnames->namenode[node2].number = num1;
1634 a = e1->name; e1->name = e2->name; e2->name = a;
1635 namesize = e1->namesize; e1->namesize = e2->namesize; e2->namesize = namesize;
1638 if ( e1->status == STOREDEXPRESSION ) {
1642 TMproto[0] = EXPRESSION;
1643 TMproto[1] = SUBEXPSIZE;
1646 {
int ie;
for ( ie = 4; ie < SUBEXPSIZE; ie++ ) TMproto[ie] = 0; }
1647 AT.TMaddr = TMproto;
1648 ind = FindInIndex(num1,&AR.StoreData,0,0);
1649 s1 = (SBYTE *)(AC.exprnames->namebuffer+e1->name);
1654 SeekFile(AR.StoreData.Handle,&(e1->onfile),SEEK_SET);
1655 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)ind,
1657 MesPrint(
"File error while exchanging expressions");
1660 FlushFile(AR.StoreData.Handle);
1662 if ( e2->status == STOREDEXPRESSION ) {
1666 TMproto[0] = EXPRESSION;
1667 TMproto[1] = SUBEXPSIZE;
1670 {
int ie;
for ( ie = 4; ie < SUBEXPSIZE; ie++ ) TMproto[ie] = 0; }
1671 AT.TMaddr = TMproto;
1672 ind = FindInIndex(num1,&AR.StoreData,0,0);
1673 s1 = (SBYTE *)(AC.exprnames->namebuffer+e2->name);
1678 SeekFile(AR.StoreData.Handle,&(e2->onfile),SEEK_SET);
1679 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)ind,
1681 MesPrint(
"File error while exchanging expressions");
1684 FlushFile(AR.StoreData.Handle);
1693int GetFirstBracket(WORD *term,
int num)
1704 WORD type, *oldcomppointer, oldonefile, numword;
1707 oldcomppointer = AR.CompressPointer;
1708 type = Expressions[num].status;
1709 if ( type == STOREDEXPRESSION ) {
1710 WORD TMproto[SUBEXPSIZE];
1711 TMproto[0] = EXPRESSION;
1712 TMproto[1] = SUBEXPSIZE;
1715 {
int ie;
for ( ie = 4; ie < SUBEXPSIZE; ie++ ) TMproto[ie] = 0; }
1716 AT.TMaddr = TMproto;
1718 if ( ( renumber = GetTable(num,&position,0) ) == 0 ) {
1719 MesCall(
"GetFirstBracket");
1722 if ( GetFromStore(term,&position,renumber,&numword,num) < 0 ) {
1723 MesCall(
"GetFirstBracket");
1729 if ( renumber->
symb.
lo != AN.dummyrenumlist )
1730 M_free(renumber->
symb.
lo,
"VarSpace");
1731 M_free(renumber,
"Renumber");
1737 oldonefile = AR.GetOneFile;
1738 if ( type == HIDDENLEXPRESSION || type == HIDDENGEXPRESSION ) {
1739 AR.GetOneFile = 2; fi = AR.hidefile;
1742 AR.GetOneFile = 0; fi = AR.infile;
1745 PUTZERO(oldposition);
1751 SETBASEPOSITION(oldposition,fi->POfill-fi->PObuffer);
1753 position = AS.OldOnFile[num];
1754 if ( GetOneTerm(BHEAD term,fi,&position,1) < 0
1755 || ( GetOneTerm(BHEAD term,fi,&position,1) < 0 ) ) {
1756 MLOCK(ErrorMessageLock);
1757 MesCall(
"GetFirstBracket");
1758 MUNLOCK(ErrorMessageLock);
1773 fi->POfill = fi->PObuffer+BASEPOSITION(oldposition);
1775 AR.GetOneFile = oldonefile;
1777 AR.CompressPointer = oldcomppointer;
1779 tstop = term + *term; tstop -= ABS(tstop[-1]);
1781 while ( t < tstop ) {
1782 if ( *t == HAAKJE )
break;
1786 term[0] = 4; term[1] = 1; term[2] = 1; term[3] = 3;
1789 *t++ = 1; *t++ = 1; *t++ = 3; *term = t - term;
1793 term[0] = 4; term[1] = 1; term[2] = 1; term[3] = 3;
1803int GetFirstTerm(WORD *term,
int num)
1814 WORD type, *oldcomppointer, oldonefile, numword;
1816 oldcomppointer = AR.CompressPointer;
1817 type = Expressions[num].status;
1818 if ( type == STOREDEXPRESSION ) {
1819 WORD TMproto[SUBEXPSIZE];
1820 TMproto[0] = EXPRESSION;
1821 TMproto[1] = SUBEXPSIZE;
1824 {
int ie;
for ( ie = 4; ie < SUBEXPSIZE; ie++ ) TMproto[ie] = 0; }
1825 AT.TMaddr = TMproto;
1827 if ( ( renumber = GetTable(num,&position,0) ) == 0 ) {
1828 MesCall(
"GetFirstTerm");
1831 if ( GetFromStore(term,&position,renumber,&numword,num) < 0 ) {
1832 MesCall(
"GetFirstTerm");
1838 if ( renumber->
symb.
lo != AN.dummyrenumlist )
1839 M_free(renumber->
symb.
lo,
"VarSpace");
1840 M_free(renumber,
"Renumber");
1846 oldonefile = AR.GetOneFile;
1847 if ( type == HIDDENLEXPRESSION || type == HIDDENGEXPRESSION ) {
1848 AR.GetOneFile = 2; fi = AR.hidefile;
1852 if ( Expressions[num].replace == NEWLYDEFINEDEXPRESSION )
1854 else fi = AR.infile;
1857 PUTZERO(oldposition);
1863 SETBASEPOSITION(oldposition,fi->POfill-fi->PObuffer);
1865 position = AS.OldOnFile[num];
1866 if ( GetOneTerm(BHEAD term,fi,&position,1) < 0
1867 || ( GetOneTerm(BHEAD term,fi,&position,1) < 0 ) ) {
1868 MLOCK(ErrorMessageLock);
1869 MesCall(
"GetFirstTerm");
1870 MUNLOCK(ErrorMessageLock);
1885 fi->POfill = fi->PObuffer+BASEPOSITION(oldposition);
1887 AR.GetOneFile = oldonefile;
1889 AR.CompressPointer = oldcomppointer;
1898int GetContent(WORD *content,
int num)
1913 WORD type, *oldcomppointer, oldonefile, numword, *term, i;
1914 WORD *cbuffer = TermMalloc(
"GetContent");
1915 WORD *oldworkpointer = AT.WorkPointer;
1917 oldcomppointer = AR.CompressPointer;
1918 type = Expressions[num].status;
1919 if ( type == STOREDEXPRESSION ) {
1920 WORD TMproto[SUBEXPSIZE];
1921 TMproto[0] = EXPRESSION;
1922 TMproto[1] = SUBEXPSIZE;
1925 {
int ie;
for ( ie = 4; ie < SUBEXPSIZE; ie++ ) TMproto[ie] = 0; }
1926 AT.TMaddr = TMproto;
1928 if ( ( renumber = GetTable(num,&position,0) ) == 0 )
goto CalledFrom;
1929 if ( GetFromStore(cbuffer,&position,renumber,&numword,num) < 0 )
goto CalledFrom;
1931 term = oldworkpointer;
1932 AR.CompressPointer = oldcomppointer;
1933 if ( GetFromStore(term,&position,renumber,&numword,num) < 0 )
goto CalledFrom;
1934 if ( *term == 0 )
break;
1938 if ( ContentMerge(BHEAD cbuffer,term) < 0 )
goto CalledFrom;
1943 if ( renumber->
symb.
lo != AN.dummyrenumlist )
1944 M_free(renumber->
symb.
lo,
"VarSpace");
1945 M_free(renumber,
"Renumber");
1951 oldonefile = AR.GetOneFile;
1952 if ( type == HIDDENLEXPRESSION || type == HIDDENGEXPRESSION ) {
1953 AR.GetOneFile = 2; fi = AR.hidefile;
1957 if ( Expressions[num].replace == NEWLYDEFINEDEXPRESSION )
1959 else fi = AR.infile;
1962 PUTZERO(oldposition);
1968 SETBASEPOSITION(oldposition,fi->POfill-fi->PObuffer);
1970 position = AS.OldOnFile[num];
1971 if ( GetOneTerm(BHEAD cbuffer,fi,&position,1) < 0 )
goto CalledFrom;
1972 AR.CompressPointer = oldcomppointer;
1973 if ( GetOneTerm(BHEAD cbuffer,fi,&position,1) < 0 )
goto CalledFrom;
1982 term = oldworkpointer;
1983 AR.CompressPointer = oldcomppointer;
1984 if ( GetOneTerm(BHEAD term,fi,&position,1) < 0 )
goto CalledFrom;
1985 if ( *term == 0 )
break;
1989 if ( ContentMerge(BHEAD cbuffer,term) < 0 )
goto CalledFrom;
1992 fi->POfill = fi->PObuffer+BASEPOSITION(oldposition);
1994 AR.GetOneFile = oldonefile;
1996 AR.CompressPointer = oldcomppointer;
1997 for ( i = 0; i < *cbuffer; i++ ) content[i] = cbuffer[i];
1998 TermFree(cbuffer,
"GetContent");
1999 AT.WorkPointer = oldworkpointer;
2002 MLOCK(ErrorMessageLock);
2003 MesCall(
"GetContent");
2004 MUNLOCK(ErrorMessageLock);
2015int CleanupTerm(WORD *term)
2017 WORD *tstop, *t, *tfill, *tt;
2018 GETSTOP(term,tstop);
2020 while ( t < tstop ) {
2021 if ( *t >= FUNCTION && ( functions[*t-FUNCTION].commute || *t == DENOMINATOR ) ) {
2022 tfill = t; tt = t + t[1]; tstop = term + *term;
2023 while ( tt < tstop ) *tfill++ = *tt++;
2024 *term = tfill - term;
2025 tstop -= ABS(tfill[-1]);
2039WORD ContentMerge(PHEAD WORD *content, WORD *term)
2042 WORD *cstop, csize, crsize, sign = 1, numsize, densize, i, tnsize, tdsize;
2043 UWORD *num, *den, *tnum, *tden;
2044 WORD *outfill, *outb = TermMalloc(
"ContentMerge"), *ct;
2045 WORD *t, *tstop, tsize, trsize, *told;
2046 WORD *t1, *t2, *c1, *c2, i1, i2, *out1;
2047 WORD didsymbol = 0, diddotp = 0, tfirst;
2048 cstop = content + *content;
2050 if ( csize < 0 ) { sign = -sign; csize = -csize; }
2052 numsize = densize = crsize = (csize-1)/2;
2053 num = NumberMalloc(
"ContentMerge");
2054 den = NumberMalloc(
"ContentMerge");
2055 for ( i = 0; i < numsize; i++ ) num[i] = (UWORD)(cstop[i]);
2056 for ( i = 0; i < densize; i++ ) den[i] = (UWORD)(cstop[i+crsize]);
2057 while ( num[numsize-1] == 0 ) numsize--;
2058 while ( den[densize-1] == 0 ) densize--;
2062 tstop = term + *term;
2064 if ( tsize < 0 ) tsize = -tsize;
2066 tstop = tstop - tsize;
2067 tnsize = tdsize = trsize = (tsize-1)/2;
2068 tnum = (UWORD *)tstop; tden = (UWORD *)(tstop + trsize);
2069 while ( tnum[tnsize-1] == 0 ) tnsize--;
2070 while ( tden[tdsize-1] == 0 ) tdsize--;
2071 GcdLong(BHEAD num, numsize, tnum, tnsize, num, &numsize);
2072 if ( LcmLong(BHEAD den, densize, tden, tdsize, den, &densize) )
goto CalledFrom;
2076 while ( ct < cstop ) {
2081 while ( t < tstop && *t != *ct ) t += t[1];
2082 if ( t >= tstop )
break;
2083 t1 = t+2; t2 = t+t[1];
2084 c1 = ct+2; c2 = ct+ct[1];
2085 out1 = outfill; *outfill++ = *ct; outfill++;
2086 while ( c1 < c2 && t1 < t2 ) {
2088 if ( t1[1] <= c1[1] ) {
2089 *outfill++ = *t1++; *outfill++ = *t1++;
2093 *outfill++ = *c1++; *outfill++ = *c1++;
2097 else if ( *c1 < *t1 ) {
2099 *outfill++ = *c1++; *outfill++ = *c1++;
2105 *outfill++ = *t1++; *outfill++ = *t1++;
2111 if ( c1[1] < 0 ) { *outfill++ = c1[0]; *outfill++ = c1[1]; }
2115 if ( t1[1] < 0 ) { *outfill++ = t1[0]; *outfill++ = t1[1]; }
2118 out1[1] = outfill - out1;
2119 if ( out1[1] == 2 ) outfill = out1;
2124 while ( t < tstop && *t != *ct ) t += t[1];
2125 if ( t >= tstop )
break;
2126 t1 = t+2; t2 = t+t[1];
2127 c1 = ct+2; c2 = ct+ct[1];
2128 out1 = outfill; *outfill++ = *ct; outfill++;
2129 while ( c1 < c2 && t1 < t2 ) {
2130 if ( *c1 == *t1 && c1[1] == t1[1] ) {
2131 if ( t1[2] <= c1[2] ) {
2132 *outfill++ = *t1++; *outfill++ = *t1++; *outfill++ = *t1++;
2136 *outfill++ = *c1++; *outfill++ = *c1++; *outfill++ = *c1++;
2140 else if ( *c1 < *t1 || ( *c1 == *t1 && c1[1] < t1[1] ) ) {
2142 *outfill++ = *c1++; *outfill++ = *c1++; *outfill++ = *c1++;
2148 *outfill++ = *t1++; *outfill++ = *t1++; *outfill++ = *t1++;
2154 if ( c1[2] < 0 ) { *outfill++ = c1[0]; *outfill++ = c1[1]; *outfill++ = c1[1]; }
2158 if ( t1[2] < 0 ) { *outfill++ = t1[0]; *outfill++ = t1[1]; *outfill++ = t1[1]; }
2161 out1[1] = outfill - out1;
2162 if ( out1[1] == 2 ) outfill = out1;
2166 while ( t < tstop && *t != *ct ) t += t[1];
2167 if ( t >= tstop )
break;
2168 t1 = t+2; t2 = t+t[1];
2169 c1 = ct+2; c2 = ct+ct[1];
2170 out1 = outfill; *outfill++ = *ct; outfill++;
2171 while ( c1 < c2 && t1 < t2 ) {
2176 else if ( *c1 < *t1 ) { c1 += 1; }
2179 out1[1] = outfill - out1;
2180 if ( out1[1] == 2 ) outfill = out1;
2185 while ( t < tstop && *t != *ct ) t += t[1];
2186 if ( t >= tstop )
break;
2187 t1 = t+2; t2 = t+t[1];
2188 c1 = ct+2; c2 = ct+ct[1];
2189 out1 = outfill; *outfill++ = *ct; outfill++;
2190 while ( c1 < c2 && t1 < t2 ) {
2191 if ( *c1 == *t1 && c1[1] && t1[1] ) {
2192 *outfill++ = *c1++; *outfill++ = *c1++;
2195 else if ( *c1 < *t1 || ( *c1 == *t1 && c1[1] < t1[1] ) ) {
2202 out1[1] = outfill - out1;
2203 if ( out1[1] == 2 ) outfill = out1;
2209 while ( t < tstop ) {
2210 if ( *t != *ct ) { t += t[1];
continue; }
2211 if ( ct[1] != t[1] ) { t += t[1];
continue; }
2212 if ( ct[2] != t[2] ) { t += t[1];
continue; }
2213 t1 = t; t2 = ct; i1 = t1[1]; i2 = t2[1];
2215 if ( *t1 != *t2 )
break;
2218 if ( i1 != 0 ) { t += t[1];
continue; }
2220 for ( i = 0; i < i2; i++ ) { *outfill++ = *t++; }
2224 t1[2] |= SUBTERMUSED1;
2225 ct[2] |= SUBTERMUSED2;
2233 if ( diddotp == 0 ) {
2234 t = term+1;
while ( t < tstop && *t != DOTPRODUCT ) t += t[1];
2236 tfirst = 1; told = outfill;
2237 for ( i = 2; i < t[1]; i += 3 ) {
2239 if ( tfirst ) { *outfill++ = DOTPRODUCT; *outfill++ = 0; tfirst = 0; }
2240 *outfill++ = t[i]; *outfill++ = t[i+1]; *outfill++ = t[i+2];
2243 if ( outfill > told ) told[1] = outfill-told;
2246 if ( didsymbol == 0 ) {
2247 t = term+1;
while ( t < tstop && *t != SYMBOL ) t += t[1];
2249 tfirst = 1; told = outfill;
2250 for ( i = 2; i < t[1]; i += 2 ) {
2252 if ( tfirst ) { *outfill++ = SYMBOL; *outfill++ = 0; tfirst = 0; }
2253 *outfill++ = t[i]; *outfill++ = t[i+1];
2256 if ( outfill > told ) told[1] = outfill-told;
2262 if ( numsize < densize ) {
2263 for ( i = numsize; i < densize; i++ ) num[i] = 0;
2266 else if ( densize < numsize ) {
2267 for ( i = densize; i < numsize; i++ ) den[i] = 0;
2270 for ( i = 0; i < numsize; i++ ) *outfill++ = num[i];
2271 for ( i = 0; i < densize; i++ ) *outfill++ = den[i];
2272 csize = numsize+densize+1;
2273 if ( sign < 0 ) csize = -csize;
2275 *outb = outfill-outb;
2276 NumberFree(den,
"ContentMerge");
2277 NumberFree(num,
"ContentMerge");
2278 for ( i = 0; i < *outb; i++ ) content[i] = outb[i];
2279 TermFree(outb,
"ContentMerge");
2286 while ( t < tstop ) {
2287 if ( *t >= FUNCTION ) t[2] &= ~SUBTERMUSED1;
2292 MLOCK(ErrorMessageLock);
2293 MesCall(
"GetContent");
2294 MUNLOCK(ErrorMessageLock);
2303LONG TermsInExpression(WORD num)
2305 LONG x = Expressions[num].counter;
2306 if ( x >= 0 )
return(x);
2315LONG SizeOfExpression(WORD num)
2317 LONG x = (LONG)(DIVPOS(Expressions[num].size,
sizeof(WORD)));
2318 if ( x >= 0 )
return(x);
2327void UpdatePositions()
2333 if ( NumExpressions > 0 &&
2334 ( AS.OldOnFile == 0 || AS.NumOldOnFile < NumExpressions ) ) {
2335 if ( AS.OldOnFile ) {
2337 AS.OldOnFile = (
POSITION *)Malloc1(NumExpressions*
sizeof(
POSITION),
"file pointers");
2338 for ( i = 0; i < AS.NumOldOnFile; i++ ) AS.OldOnFile[i] = old[i];
2339 AS.NumOldOnFile = NumExpressions;
2340 M_free(old,
"process file pointers");
2343 AS.OldOnFile = (
POSITION *)Malloc1(NumExpressions*
sizeof(
POSITION),
"file pointers");
2344 AS.NumOldOnFile = NumExpressions;
2347 if ( NumExpressions > 0 &&
2348 ( AS.OldNumFactors == 0 || AS.NumOldNumFactors < NumExpressions ) ) {
2349 if ( AS.OldNumFactors ) {
2350 oldw = AS.OldNumFactors;
2351 AS.OldNumFactors = (WORD *)Malloc1(NumExpressions*
sizeof(WORD),
"numfactors pointers");
2352 for ( i = 0; i < AS.NumOldNumFactors; i++ ) AS.OldNumFactors[i] = oldw[i];
2353 M_free(oldw,
"numfactors pointers");
2354 oldw = AS.Oldvflags;
2355 AS.Oldvflags = (WORD *)Malloc1(NumExpressions*
sizeof(WORD),
"vflags pointers");
2356 for ( i = 0; i < AS.NumOldNumFactors; i++ ) AS.Oldvflags[i] = oldw[i];
2357 AS.NumOldNumFactors = NumExpressions;
2358 M_free(oldw,
"vflags pointers");
2361 AS.OldNumFactors = (WORD *)Malloc1(NumExpressions*
sizeof(WORD),
"numfactors pointers");
2362 AS.Oldvflags = (WORD *)Malloc1(NumExpressions*
sizeof(WORD),
"vflags pointers");
2363 AS.NumOldNumFactors = NumExpressions;
2366 for ( i = 0; i < NumExpressions; i++ ) {
2367 AS.OldOnFile[i] = e[i].onfile;
2368 AS.OldNumFactors[i] = e[i].numfactors;
2369 AS.Oldvflags[i] = e[i].vflags;
2381LONG CountTerms1(PHEAD0)
2384 POSITION oldposition, startposition;
2385 WORD *t, *m, *mstop, decr, i, *oldwork, retval;
2386 WORD *oldipointer = AR.CompressPointer;
2387 WORD oldGetOneFile = AR.GetOneFile, olddeferflag = AR.DeferFlag;
2390 oldwork = AT.WorkPointer;
2391 AT.WorkPointer = (WORD *)(((UBYTE *)(AT.WorkPointer)) + AM.MaxTer);
2393 startposition = AR.DefPosition;
2397 if ( AR.infile->handle >= 0 ) {
2398 PUTZERO(oldposition);
2404 SETBASEPOSITION(oldposition,AR.infile->POfill-AR.infile->PObuffer);
2405 AR.infile->POfill = (WORD *)((UBYTE *)(AR.infile->PObuffer)
2406 +BASEPOSITION(startposition));
2411 t = m = AR.CompressBuffer;
2413 mstop = t - ABS(t[-1]);
2415 while ( *m != HAAKJE && m < mstop ) m += m[1];
2418 AR.DeferFlag = olddeferflag;
2419 AT.WorkPointer = oldwork;
2420 AR.GetOneFile = oldGetOneFile;
2424 decr = WORDDIF(mstop,AR.CompressBuffer)-1;
2426 m = AR.CompressBuffer;
2427 t = AR.CompressPointer;
2439 AR.CompressPointer = oldipointer;
2442 retval = GetOneTerm(BHEAD AT.WorkPointer,AR.infile,&startposition,0);
2443 if ( retval >= 0 ) AR.CompressPointer = oldipointer;
2444 if ( retval <= 0 )
break;
2445 t = AR.CompressPointer;
2446 if ( *t < (1 + decr + ABS(*(t+*t-1))) )
break;
2448 m = AR.CompressBuffer+1;
2449 while ( m < mstop ) {
2450 if ( *m != *t )
goto Thatsit;
2458 AT.WorkPointer = oldwork;
2459 if ( AR.infile->handle >= 0 ) {
2465 AR.infile->POfill = AR.infile->PObuffer + BASEPOSITION(oldposition);
2467 AR.DeferFlag = olddeferflag;
2468 AR.GetOneFile = oldGetOneFile;
2484#define CURRENTBRACKET 1
2485#define BRACKETCURRENTEXPR 2
2486#define BRACKETOTHEREXPR 3
2487#define NOBRACKETACTIVE 4
2489LONG TermsInBracket(PHEAD WORD *term, WORD level)
2491 WORD *t, *tstop, *b, *tt, *n1, *n2;
2492 int type = 0, i, num;
2494 WORD *bracketbuffer = AT.WorkPointer;
2495 t = term; GETSTOP(t,tstop);
2496 t++; b = bracketbuffer;
2497 while ( t < tstop ) {
2498 if ( *t != TERMSINBRACKET ) { t += t[1];
continue; }
2499 if ( t[1] == FUNHEAD || (
2501 && t[FUNHEAD] == -SNUMBER
2502 && t[FUNHEAD+1] == 0
2504 if ( AC.ComDefer == 0 ) {
2505 type = NOBRACKETACTIVE;
2508 type = CURRENTBRACKET;
2513 if ( t[FUNHEAD] == -EXPRESSION ) {
2514 if ( t[FUNHEAD+2] < 0 ) {
2515 if ( ( t[FUNHEAD+2] <= -FUNCTION ) && ( t[1] == FUNHEAD+3 ) ) {
2516 type = BRACKETOTHEREXPR;
2517 *b++ = FUNHEAD+4; *b++ = -t[FUNHEAD+2]; *b++ = FUNHEAD;
2518 for ( i = 2; i < FUNHEAD; i++ ) *b++ = 0;
2519 *b++ = 1; *b++ = 1; *b++ = 3;
2522 else if ( ( t[FUNHEAD+2] > -FUNCTION ) && ( t[1] == FUNHEAD+4 ) ) {
2523 type = BRACKETOTHEREXPR;
2527 *b++ = 8; *b++ = SYMBOL; *b++ = 4; *b++ = tt[1];
2528 *b++ = 1; *b++ = 1; *b++ = 1; *b++ = 3;
2532 *b++ = 4; *b++ = 1; *b++ = 1; *b++ = 3;
2534 else goto IllBraReq;
2542 else if ( ( t[FUNHEAD+2] == (t[1]-FUNHEAD-2) ) &&
2543 ( t[FUNHEAD+2+ARGHEAD] == (t[FUNHEAD+2]-ARGHEAD) ) ) {
2544 type = BRACKETOTHEREXPR;
2545 tt = t + FUNHEAD + ARGHEAD; num = *tt;
2546 for ( i = 0; i < num; i++ ) *b++ = *tt++;
2551 if ( t[FUNHEAD] < 0 ) {
2552 if ( ( t[FUNHEAD] <= -FUNCTION ) && ( t[1] == FUNHEAD+1 ) ) {
2553 type = BRACKETCURRENTEXPR;
2554 *b++ = FUNHEAD+4; *b++ = -t[FUNHEAD+2]; *b++ = FUNHEAD;
2555 for ( i = 2; i < FUNHEAD; i++ ) *b++ = 0;
2556 *b++ = 1; *b++ = 1; *b++ = 3; *b = 0;
2559 else if ( ( t[FUNHEAD] > -FUNCTION ) && ( t[1] == FUNHEAD+2 ) ) {
2560 type = BRACKETCURRENTEXPR;
2564 *b++ = 8; *b++ = SYMBOL; *b++ = 4; *b++ = tt[1];
2565 *b++ = 1; *b++ = 1; *b++ = 1; *b++ = 3;
2569 *b++ = 4; *b++ = 1; *b++ = 1; *b++ = 3;
2571 else goto IllBraReq;
2579 else if ( ( t[FUNHEAD] == (t[1]-FUNHEAD) ) &&
2580 ( t[FUNHEAD+ARGHEAD] == (t[FUNHEAD]-ARGHEAD) ) ) {
2581 type = BRACKETCURRENTEXPR;
2582 tt = t + FUNHEAD + ARGHEAD; num = *tt;
2583 for ( i = 0; i < num; i++ ) *b++ = *tt++;
2588 MLOCK(ErrorMessageLock);
2589 MesPrint(
"Illegal bracket request in termsinbracket_ function.");
2590 MUNLOCK(ErrorMessageLock);
2597 if ( AT.WorkPointer + *term +4 > AT.WorkTop ) {
2598 MLOCK(ErrorMessageLock);
2600 MesPrint(
"Called from termsinbracket_ function.");
2601 MUNLOCK(ErrorMessageLock);
2608 case CURRENTBRACKET:
2614 numterms = CountTerms1(BHEAD0);
2616 case BRACKETCURRENTEXPR:
2620 MLOCK(ErrorMessageLock);
2621 MesPrint(
"termsinbracket_ function currently only handles Keep Brackets.");
2622 MUNLOCK(ErrorMessageLock);
2624 case BRACKETOTHEREXPR:
2625 MLOCK(ErrorMessageLock);
2626 MesPrint(
"termsinbracket_ function currently only handles Keep Brackets.");
2627 MUNLOCK(ErrorMessageLock);
2629 case NOBRACKETACTIVE:
2636 n1 = term; n2 = AT.WorkPointer; tstop = n1 + *n1;
2637 while ( n1 < t ) *n2++ = *n1++;
2638 i = numterms >> BITSINWORD;
2640 *n2++ = LNUMBER; *n2++ = 4; *n2++ = 1; *n2++ = (WORD)(numterms & WORDMASK);
2643 *n2++ = LNUMBER; *n2++ = 5; *n2++ = 2;
2644 *n2++ = (WORD)(numterms & WORDMASK); *n2++ = i;
2647 while ( n1 < tstop ) *n2++ = *n1++;
2648 AT.WorkPointer[0] = n2 - AT.WorkPointer;
2649 AT.WorkPointer = n2;
2651 AT.WorkPointer = bracketbuffer;
2652 MLOCK(ErrorMessageLock);
2653 MesPrint(
"Called from termsinbracket_ function.");
2654 MUNLOCK(ErrorMessageLock);
2660 AT.WorkPointer = bracketbuffer;
WORD Generator(PHEAD WORD *, WORD)
int PF_BroadcastRedefinedPreVars(void)
int PF_BroadcastExpFlags(void)
int PF_BroadcastModifiedDollars(void)
int PF_BroadcastCBuf(int bufnum)
int PF_CollectModifiedDollars(void)
int PF_BroadcastExpr(EXPRESSIONS e, FILEHANDLE *file)