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 ) {
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);
83 case GLOBALEXPRESSION:
84 case HIDDENGEXPRESSION:
90 if (
PF_BroadcastExpr(e_in, e_in->status == HIDDENGEXPRESSION ? AR.hidefile : AR.outfile) )
return -1;
91 if ( PF.me == MASTER ) {
97 if ( e_in->status == HIDDENGEXPRESSION ) {
98 if ( e->status == HIDDENGEXPRESSION
99 || e->status == HIDDENLEXPRESSION )
break;
102 if ( e->status == GLOBALEXPRESSION
103 || e->status == LOCALEXPRESSION )
break;
117 DIFPOS(length,e->onfile,e_in->onfile);
120 FILEHANDLE *f = e_in->status == HIDDENGEXPRESSION ? AR.hidefile : AR.outfile;
122 SETBASELENGTH(length,TOLONG(f->POfull)
123 - TOLONG(f->PObuffer)
124 - BASEPOSITION(e_in->onfile));
127 SeekFile(f->
handle,&(f->filesize),SEEK_SET);
128 DIFPOS(length,f->filesize,e_in->onfile);
131 if ( ToStorage(e_in,&length) ) {
132 return(MesCall(
"CleanExpr"));
134 e_in->status = STOREDEXPRESSION;
135 if ( e_in->status != HIDDENGEXPRESSION )
136 ClearBracketIndex(e_in-Expressions);
139 case SKIPLEXPRESSION:
140 case DROPLEXPRESSION:
141 case DROPHLEXPRESSION:
142 case DROPGEXPRESSION:
143 case DROPHGEXPRESSION:
144 case STOREDEXPRESSION:
145 case DROPSPECTATOREXPRESSION:
146 if ( e_out != e_in ) {
147 node = AC.exprnames->namenode + e_in->node;
148 node->
number = e_out - Expressions;
150 e_out->onfile = e_in->onfile;
151 e_out->size = e_in->size;
152 e_out->printflag = 0;
153 if ( par ) e_out->status = STOREDEXPRESSION;
154 else e_out->status = e_in->status;
155 e_out->name = e_in->name;
156 e_out->node = e_in->node;
157 e_out->renum = e_in->renum;
159 e_out->counter = e_in->counter;
160 e_out->hidelevel = e_in->hidelevel;
161 e_out->inmem = e_in->inmem;
162 e_out->bracketinfo = e_in->bracketinfo;
163 e_out->newbracketinfo = e_in->newbracketinfo;
164 e_out->numdummies = e_in->numdummies;
165 e_out->numfactors = e_in->numfactors;
166 e_out->vflags = e_in->vflags;
167 e_out->sizeprototype = e_in->sizeprototype;
175 case DROPPEDEXPRESSION:
178 AC.exprnames->namenode[e_in->node].type = CDELETE;
183 }
while ( --n > 0 ); }
186 if ( numhid == 0 && AR.hidefile->PObuffer ) {
187 if ( AR.hidefile->handle >= 0 ) {
188 CloseFile(AR.hidefile->handle);
189 remove(AR.hidefile->name);
190 AR.hidefile->handle = -1;
192 AR.hidefile->POfull =
193 AR.hidefile->POfill = AR.hidefile->PObuffer;
194 PUTZERO(AR.hidefile->POposition);
215 retval = CleanExpr(1);
218 if ( AC.DidClean ) CompactifyTree(AC.exprnames,EXPRNAMES);
220 AC.CodesFlag = AM.gCodesFlag;
221 AC.NamesFlag = AM.gNamesFlag;
222 AC.StatsFlag = AM.gStatsFlag;
223 AC.OldFactArgFlag = AM.gOldFactArgFlag;
224 AC.TokensWriteFlag = AM.gTokensWriteFlag;
225 AC.extrasymbols = AM.gextrasymbols;
226 if ( AC.extrasym ) { M_free(AC.extrasym,
"extrasym"); AC.extrasym = 0; }
227 i = 1; s = AM.gextrasym;
while ( *s ) { s++; i++; }
228 AC.extrasym = (UBYTE *)Malloc1(i*
sizeof(UBYTE),
"extrasym");
229 for ( j = 0; j < i; j++ ) AC.extrasym[j] = AM.gextrasym[j];
230 AO.NoSpacesInNumbers = AM.gNoSpacesInNumbers;
231 AO.IndentSpace = AM.gIndentSpace;
232 AC.lUnitTrace = AM.gUnitTrace;
233 AC.lDefDim = AM.gDefDim;
234 AC.lDefDim4 = AM.gDefDim4;
236 if ( AC.ncmod == AM.gncmod && AC.modmode == AM.gmodmode ) {
239 if ( AC.cmod[j] != AM.gcmod[j] )
break;
242 M_free(AC.halfmod,
"halfmod");
243 AC.halfmod = 0; AC.nhalfmod = 0;
247 M_free(AC.halfmod,
"halfmod");
248 AC.halfmod = 0; AC.nhalfmod = 0;
251 if ( AC.modinverses ) {
252 if ( AC.ncmod == AM.gncmod && AC.modmode == AM.gmodmode ) {
255 if ( AC.cmod[j] != AM.gcmod[j] )
break;
258 M_free(AC.modinverses,
"modinverses");
263 M_free(AC.modinverses,
"modinverses");
267 AN.ncmod = AC.ncmod = AM.gncmod;
268 AC.npowmod = AM.gnpowmod;
269 AC.modmode = AM.gmodmode;
270 if ( ( ( AC.modmode & INVERSETABLE ) != 0 ) && ( AC.modinverses == 0 ) )
272 AC.funpowers = AM.gfunpowers;
273 AC.lPolyFun = AM.gPolyFun;
274 AC.lPolyFunInv = AM.gPolyFunInv;
275 AC.lPolyFunType = AM.gPolyFunType;
276 AC.lPolyFunExp = AM.gPolyFunExp;
277 AR.PolyFunVar = AC.lPolyFunVar = AM.gPolyFunVar;
278 AC.lPolyFunPow = AM.gPolyFunPow;
279 AC.parallelflag = AM.gparallelflag;
280 AC.ProcessBucketSize = AC.mProcessBucketSize = AM.gProcessBucketSize;
281 AC.properorderflag = AM.gproperorderflag;
282 AC.ThreadBucketSize = AM.gThreadBucketSize;
283 AC.ThreadStats = AM.gThreadStats;
284 AC.FinalStats = AM.gFinalStats;
285 AC.OldGCDflag = AM.gOldGCDflag;
286 AC.WTimeStatsFlag = AM.gWTimeStatsFlag;
287 AC.ThreadsFlag = AM.gThreadsFlag;
288 AC.ThreadBalancing = AM.gThreadBalancing;
289 AC.ThreadSortFileSynch = AM.gThreadSortFileSynch;
290 AC.ProcessStats = AM.gProcessStats;
291 AC.OldParallelStats = AM.gOldParallelStats;
292 AC.IsFortran90 = AM.gIsFortran90;
293 AC.SizeCommuteInSet = AM.gSizeCommuteInSet;
294 PruneExtraSymbols(AM.gnumextrasym);
296 if ( AC.Fortran90Kind ) {
297 M_free(AC.Fortran90Kind,
"Fortran90 Kind");
298 AC.Fortran90Kind = 0;
300 if ( AM.gFortran90Kind ) {
301 AC.Fortran90Kind = strDup1(AM.gFortran90Kind,
"Fortran90 Kind");
303 if ( AC.ThreadsFlag && AM.totalnumberofthreads > 1 ) AS.MultiThreaded = 1;
315 if ( MakeModTable() ) {
316 MesPrint(
"===No printing in powers of generator");
328 AC.Cnumpows = AM.gCnumpows;
329 AC.OutputMode = AM.gOutputMode;
330 AC.OutputSpaces = AM.gOutputSpaces;
331 AC.OutNumberType = AM.gOutNumberType;
332 AR.SortType = AC.SortType = AM.gSortType;
333 AC.ShortStatsMax = AM.gShortStatsMax;
337 for ( i = 0; i < NumFunctions; i++ ) functions[i].flags &= ~COULDCOMMUTE;
338 if ( AC.CommuteInSet ) {
344 if ( *gg <= GAMMASEVEN && *gg >= GAMMA ) {
345 functions[GAMMA-FUNCTION].flags |= COULDCOMMUTE;
346 functions[GAMMAI-FUNCTION].flags |= COULDCOMMUTE;
347 functions[GAMMAFIVE-FUNCTION].flags |= COULDCOMMUTE;
348 functions[GAMMASIX-FUNCTION].flags |= COULDCOMMUTE;
349 functions[GAMMASEVEN-FUNCTION].flags |= COULDCOMMUTE;
352 functions[*gg-FUNCTION].flags |= COULDCOMMUTE;
360 for ( i = AO.NumDictionaries-1; i >= AO.gNumDictionaries; i-- ) {
361 RemoveDictionary(AO.Dictionaries[i]);
362 M_free(AO.Dictionaries[i],
"Dictionary");
364 for( ; i >= 0; i-- ) {
365 ShrinkDictionary(AO.Dictionaries[i]);
367 AO.NumDictionaries = AO.gNumDictionaries;
383 AM.gCodesFlag = AC.CodesFlag;
384 AM.gNamesFlag = AC.NamesFlag;
385 AM.gStatsFlag = AC.StatsFlag;
386 AM.gOldFactArgFlag = AC.OldFactArgFlag;
387 AM.gextrasymbols = AC.extrasymbols;
388 if ( AM.gextrasym ) { M_free(AM.gextrasym,
"extrasym"); AM.gextrasym = 0; }
389 i = 1; s = AC.extrasym;
while ( *s ) { s++; i++; }
390 AM.gextrasym = (UBYTE *)Malloc1(i*
sizeof(UBYTE),
"extrasym");
391 for ( j = 0; j < i; j++ ) AM.gextrasym[j] = AC.extrasym[j];
392 AM.gTokensWriteFlag= AC.TokensWriteFlag;
393 AM.gNoSpacesInNumbers = AO.NoSpacesInNumbers;
394 AM.gIndentSpace = AO.IndentSpace;
395 AM.gUnitTrace = AC.lUnitTrace;
396 AM.gDefDim = AC.lDefDim;
397 AM.gDefDim4 = AC.lDefDim4;
398 AM.gncmod = AC.ncmod;
399 AM.gnpowmod = AC.npowmod;
400 AM.gmodmode = AC.modmode;
401 AM.gCnumpows = AC.Cnumpows;
402 AM.gOutputMode = AC.OutputMode;
403 AM.gOutputSpaces = AC.OutputSpaces;
404 AM.gOutNumberType = AC.OutNumberType;
405 AM.gfunpowers = AC.funpowers;
406 AM.gPolyFun = AC.lPolyFun;
407 AM.gPolyFunInv = AC.lPolyFunInv;
408 AM.gPolyFunType = AC.lPolyFunType;
409 AM.gPolyFunExp = AC.lPolyFunExp;
410 AM.gPolyFunVar = AC.lPolyFunVar;
411 AM.gPolyFunPow = AC.lPolyFunPow;
412 AM.gparallelflag = AC.parallelflag;
413 AM.gProcessBucketSize = AC.ProcessBucketSize;
414 AM.gproperorderflag = AC.properorderflag;
415 AM.gThreadBucketSize = AC.ThreadBucketSize;
416 AM.gThreadStats = AC.ThreadStats;
417 AM.gFinalStats = AC.FinalStats;
418 AM.gOldGCDflag = AC.OldGCDflag;
419 AM.gWTimeStatsFlag = AC.WTimeStatsFlag;
420 AM.gThreadsFlag = AC.ThreadsFlag;
421 AM.gThreadBalancing = AC.ThreadBalancing;
422 AM.gThreadSortFileSynch = AC.ThreadSortFileSynch;
423 AM.gProcessStats = AC.ProcessStats;
424 AM.gOldParallelStats = AC.OldParallelStats;
425 AM.gIsFortran90 = AC.IsFortran90;
426 AM.gSizeCommuteInSet = AC.SizeCommuteInSet;
427 AM.gnumextrasym = (cbuf+AM.sbufnum)->numrhs;
428 if ( AM.gFortran90Kind ) {
429 M_free(AM.gFortran90Kind,
"Fortran 90 Kind");
430 AM.gFortran90Kind = 0;
432 if ( AC.Fortran90Kind ) {
433 AM.gFortran90Kind = strDup1(AC.Fortran90Kind,
"Fortran 90 Kind");
447 AM.gSortType = AC.SortType;
448 AM.gShortStatsMax = AC.ShortStatsMax;
450 if ( AO.CurrentDictionary > 0 || AP.OpenDictionary > 0 ) {
451 Warning(
"You cannot have an open or selected dictionary at a .global. Dictionary closed.");
452 AP.OpenDictionary = 0;
453 AO.CurrentDictionary = 0;
456 AO.gNumDictionaries = AO.NumDictionaries;
457 for ( i = 0; i < AO.NumDictionaries; i++ ) {
458 AO.Dictionaries[i]->gnumelements = AO.Dictionaries[i]->numelements;
460 if ( AM.NumSpectatorFiles > 0 ) {
461 for ( i = 0; i < AM.SizeForSpectatorFiles; i++ ) {
462 if ( AM.SpectatorFiles[i].name != 0 )
463 AM.SpectatorFiles[i].flags |= GLOBALSPECTATORFLAG;
477 for ( j = 0, e = Expressions; j < NumExpressions; j++, e++ ) {
478 switch ( e->status ) {
479 case SKIPLEXPRESSION:
480 e->status = LOCALEXPRESSION;
482 case UNHIDELEXPRESSION:
483 e->status = LOCALEXPRESSION;
484 ClearBracketIndex(j);
485 e->bracketinfo = e->newbracketinfo; e->newbracketinfo = 0;
487 case HIDELEXPRESSION:
488 e->status = HIDDENLEXPRESSION;
490 case SKIPGEXPRESSION:
491 e->status = GLOBALEXPRESSION;
493 case UNHIDEGEXPRESSION:
494 e->status = GLOBALEXPRESSION;
495 ClearBracketIndex(j);
496 e->bracketinfo = e->newbracketinfo; e->newbracketinfo = 0;
498 case HIDEGEXPRESSION:
499 e->status = HIDDENGEXPRESSION;
501 case DROPLEXPRESSION:
502 case DROPGEXPRESSION:
503 case DROPHLEXPRESSION:
504 case DROPHGEXPRESSION:
505 case DROPSPECTATOREXPRESSION:
506 e->status = DROPPEDEXPRESSION;
507 ClearBracketIndex(j);
508 e->bracketinfo = e->newbracketinfo; e->newbracketinfo = 0;
509 if ( e->replace >= 0 ) {
510 Expressions[e->replace].replace = REGULAREXPRESSION;
511 AC.exprnames->namenode[e->node].number = e->replace;
512 e->replace = REGULAREXPRESSION;
515 AC.exprnames->namenode[e->node].type = CDELETE;
519 case LOCALEXPRESSION:
520 case GLOBALEXPRESSION:
521 ClearBracketIndex(j);
522 e->bracketinfo = e->newbracketinfo; e->newbracketinfo = 0;
524 case HIDDENLEXPRESSION:
525 case HIDDENGEXPRESSION:
527 case INTOHIDELEXPRESSION:
528 ClearBracketIndex(j);
529 e->bracketinfo = e->newbracketinfo; e->newbracketinfo = 0;
530 e->status = HIDDENLEXPRESSION;
532 case INTOHIDEGEXPRESSION:
533 ClearBracketIndex(j);
534 e->bracketinfo = e->newbracketinfo; e->newbracketinfo = 0;
535 e->status = HIDDENGEXPRESSION;
538 ClearBracketIndex(j);
542 if ( e->replace == NEWLYDEFINEDEXPRESSION ) e->replace = REGULAREXPRESSION;
551 void PutInVflags(WORD nexpr)
558 if ( AS.OldOnFile == 0 ) {
559 AS.NumOldOnFile = 20;
560 AS.OldOnFile = (
POSITION *)Malloc1(AS.NumOldOnFile*
sizeof(
POSITION),
"file pointers");
562 else if ( nexpr >= AS.NumOldOnFile ) {
564 AS.OldOnFile = (
POSITION *)Malloc1(2*AS.NumOldOnFile*
sizeof(
POSITION),
"file pointers");
565 for ( i = 0; i < AS.NumOldOnFile; i++ ) AS.OldOnFile[i] = old[i];
566 AS.NumOldOnFile = 2*AS.NumOldOnFile;
567 M_free(old,
"process file pointers");
569 if ( AS.OldNumFactors == 0 ) {
570 AS.NumOldNumFactors = 20;
571 AS.OldNumFactors = (WORD *)Malloc1(AS.NumOldNumFactors*
sizeof(WORD),
"numfactors pointers");
572 AS.Oldvflags = (WORD *)Malloc1(AS.NumOldNumFactors*
sizeof(WORD),
"vflags pointers");
574 else if ( nexpr >= AS.NumOldNumFactors ) {
575 oldw = AS.OldNumFactors;
576 AS.OldNumFactors = (WORD *)Malloc1(2*AS.NumOldNumFactors*
sizeof(WORD),
"numfactors pointers");
577 for ( i = 0; i < AS.NumOldNumFactors; i++ ) AS.OldNumFactors[i] = oldw[i];
578 M_free(oldw,
"numfactors pointers");
580 AS.Oldvflags = (WORD *)Malloc1(2*AS.NumOldNumFactors*
sizeof(WORD),
"vflags pointers");
581 for ( i = 0; i < AS.NumOldNumFactors; i++ ) AS.Oldvflags[i] = oldw[i];
582 AS.NumOldNumFactors = 2*AS.NumOldNumFactors;
583 M_free(oldw,
"vflags pointers");
588 if ( nexpr >= AS.NumOldOnFile || nexpr >= AS.NumOldNumFactors )
goto restart;
589 AS.OldOnFile[nexpr] = e->onfile;
590 AS.OldNumFactors[nexpr] = e->numfactors;
591 AS.Oldvflags[nexpr] = e->vflags;
599 WORD DoExecute(WORD par, WORD skip)
603 int i, oldmultithreaded = AS.MultiThreaded;
608 SpecialCleanup(BHEAD0);
609 if ( skip )
goto skipexec;
610 if ( AC.IfLevel > 0 ) {
611 MesPrint(
" %d endif statement(s) missing",AC.IfLevel);
614 if ( AC.WhileLevel > 0 ) {
615 MesPrint(
" %d endwhile statement(s) missing",AC.WhileLevel);
618 if ( AC.arglevel > 0 ) {
619 MesPrint(
" %d endargument statement(s) missing",AC.arglevel);
622 if ( AC.termlevel > 0 ) {
623 MesPrint(
" %d endterm statement(s) missing",AC.termlevel);
626 if ( AC.insidelevel > 0 ) {
627 MesPrint(
" %d endinside statement(s) missing",AC.insidelevel);
630 if ( AC.inexprlevel > 0 ) {
631 MesPrint(
" %d endinexpression statement(s) missing",AC.inexprlevel);
634 if ( AC.NumLabels > 0 ) {
635 for ( i = 0; i < AC.NumLabels; i++ ) {
636 if ( AC.Labels[i] < 0 ) {
637 MesPrint(
" -->Label %s missing",AC.LabelNames[i]);
642 if ( AC.dolooplevel > 0 ) {
643 MesPrint(
" %d enddo statement(s) missing",AC.dolooplevel);
646 if ( AP.OpenDictionary > 0 ) {
647 MesPrint(
" Dictionary %s has not been closed.",
648 AO.Dictionaries[AP.OpenDictionary-1]->name);
649 AP.OpenDictionary = 0;
652 if ( RetCode )
return(RetCode);
653 AR.Cnumlhs = cbuf[AM.rbufnum].numlhs;
655 if ( ( AS.ExecMode = par ) == GLOBALMODULE ) AS.ExecMode = 0;
664 if ( NumPotModdollars >= 0 ) {
665 for ( i = 0; i < NumExpressions; i++ ) {
666 if ( Expressions[i].partodo ) { AC.partodoflag = 1;
break; }
670 if ( AC.partodoflag > 0 && PF.numtasks < 3 ) {
674 if ( AC.partodoflag > 0 || ( NumPotModdollars > 0 && AC.mparallelflag == PARALLELFLAG ) ) {
675 if ( NumPotModdollars > NumModOptdollars ) {
676 AC.mparallelflag |= NOPARALLEL_DOLLAR;
678 AS.MultiThreaded = 0;
683 for ( i = 0; i < NumPotModdollars; i++ ) {
684 for ( j = 0; j < NumModOptdollars; j++ )
685 if ( PotModdollars[i] == ModOptdollars[j].number )
break;
686 if ( j >= NumModOptdollars ) {
687 AC.mparallelflag |= NOPARALLEL_DOLLAR;
689 AS.MultiThreaded = 0;
694 switch ( ModOptdollars[j].type ) {
701 AC.mparallelflag |= NOPARALLEL_DOLLAR;
702 AS.MultiThreaded = 0;
709 else if ( ( AC.mparallelflag & NOPARALLEL_USER ) != 0 ) {
711 AS.MultiThreaded = 0;
715 if ( AC.partodoflag == 0 ) {
716 for ( i = 0; i < NumExpressions; i++ ) {
717 Expressions[i].partodo = 0;
720 else if ( AC.partodoflag == -1 ) {
728 if ( AC.RhsExprInModuleFlag && (AC.mparallelflag == PARALLELFLAG || AC.partodoflag) ) {
729 if (PF.rhsInParallel) {
732 PF.slavebuf.PObuffer=(WORD *)Malloc1(AM.ScratSize*
sizeof(WORD),
"PF inbuf");
733 PF.slavebuf.POsize=AM.ScratSize*
sizeof(WORD);
734 PF.slavebuf.POfull = PF.slavebuf.POfill = PF.slavebuf.PObuffer;
735 PF.slavebuf.POstop= PF.slavebuf.PObuffer+AM.ScratSize;
736 PUTZERO(PF.slavebuf.POposition);
740 AC.mparallelflag |= NOPARALLEL_RHS;
742 for ( i = 0; i < NumExpressions; i++ ) {
743 Expressions[i].partodo = 0;
750 if ( (AC.mparallelflag == PARALLELFLAG || AC.partodoflag) && PF.me != MASTER ) {
751 for ( i = 0; i < NumModOptdollars; i++ ) {
752 if ( ModOptdollars[i].type == MODSUM ) {
753 DOLLARS d = Dollars + ModOptdollars[i].number;
755 if ( d->where && d->where != &AM.dollarzero ) M_free(d->where,
"old content of dollar");
756 d->where = &AM.dollarzero;
758 CleanDollarFactors(d);
763 AR.SortType = AC.SortType;
765 if ( PF.me == MASTER )
768 if ( AC.SetupFlag ) WriteSetup();
769 if ( AC.NamesFlag || AC.CodesFlag ) WriteLists();
771 if ( par == GLOBALMODULE ) MakeGlobal();
772 if ( RevertScratch() )
return(-1);
773 if ( AC.ncmod ) SetMods();
778 if ( PF.me == MASTER )
781 if ( !AC.ThreadsFlag || AC.mparallelflag & NOPARALLEL_USER ) {
784 else if ( AC.mparallelflag & NOPARALLEL_DOLLAR ) {
785 if ( AC.WarnFlag >= 2 ) {
788 s = strDup1((UBYTE *)
"",
"NOPARALLEL_DOLLAR s");
790 j = NumPotModdollars;
791 for ( i = 0; i < j; i++ ) {
792 for ( k = 0; k < NumModOptdollars; k++ )
793 if ( ModOptdollars[k].number == PotModdollars[i] )
break;
794 if ( k >= NumModOptdollars ) {
797 s = AddToString(s,(UBYTE *)
", ",0);
798 s = AddToString(s,(UBYTE *)
"$",0);
799 s = AddToString(s,DOLLARNAME(Dollars,PotModdollars[i]),0);
803 s1 = strDup1((UBYTE *)
"This module is forced to run in sequential mode due to $-variable",
"NOPARALLEL_DOLLAR s1");
805 s1 = AddToString(s1,(UBYTE *)
"s",0);
806 s1 = AddToString(s1,(UBYTE *)
": ",0);
807 s1 = AddToString(s1,s,0);
808 HighWarning((
char *)s1);
809 M_free(s,
"NOPARALLEL_DOLLAR s");
810 M_free(s1,
"NOPARALLEL_DOLLAR s1");
813 else if ( AC.mparallelflag & NOPARALLEL_RHS ) {
814 HighWarning(
"This module is forced to run in sequential mode due to RHS expression names");
816 else if ( AC.mparallelflag & NOPARALLEL_CONVPOLY ) {
817 HighWarning(
"This module is forced to run in sequential mode due to conversion to extra symbols");
819 else if ( AC.mparallelflag & NOPARALLEL_SPECTATOR ) {
820 HighWarning(
"This module is forced to run in sequential mode due to tospectator/copyspectator");
822 else if ( AC.mparallelflag & NOPARALLEL_TBLDOLLAR ) {
823 HighWarning(
"This module is forced to run in sequential mode due to $-variable assignments in tables");
825 else if ( AC.mparallelflag & NOPARALLEL_NPROC ) {
826 HighWarning(
"This module is forced to run in sequential mode because there is only one processor");
838 if ( AP.preError == 0 && (
Processor() || WriteAll() ) ) RetCode = -1;
845 if ( AC.ncmod ) UnSetMods();
846 AS.MultiThreaded = oldmultithreaded;
852 if ( NumPotModdollars > 0 ) {
854 if ( RetCode )
return RetCode;
856 if ( RetCode )
return RetCode;
859 if ( AC.numpfirstnum > 0 ) {
861 if ( RetCode )
return RetCode;
864 if ( AC.topolynomialflag & TOPOLYNOMIALFLAG ) {
866 if ( RetCode )
return RetCode;
873 if ( RetCode )
return RetCode;
878 if ( PF.me != MASTER && AR.hidefile->PObuffer ) {
879 if ( AR.hidefile->handle >= 0 ) {
880 CloseFile(AR.hidefile->handle);
881 AR.hidefile->handle = -1;
882 remove(AR.hidefile->name);
884 AR.hidefile->POfull = AR.hidefile->POfill = AR.hidefile->PObuffer;
885 PUTZERO(AR.hidefile->POposition);
889 for ( j = 0; j < NumModOptdollars; j++ ) {
890 if ( ModOptdollars[j].dstruct ) {
894 for ( i = 0; i < AM.totalnumberofthreads; i++ ) {
895 if ( ModOptdollars[j].dstruct[i].size > 0 ) {
896 CleanDollarFactors(&(ModOptdollars[j].dstruct[i]));
897 M_free(ModOptdollars[j].dstruct[i].where,
"Local dollar value");
903 M_free(ModOptdollars[j].dstruct,
"Local DOLLARS");
904 ModOptdollars[j].dstruct = 0;
925 if ( ModOptdollars ) M_free(ModOptdollars,
"ModOptdollars pointer");
926 if ( PotModdollars ) M_free(PotModdollars,
"PotModdollars pointer");
929 AC.ModOptDolList.lijst = NULL;
931 AC.PotModDolList.lijst = NULL;
933 NumPotModdollars = 0;
934 NumModOptdollars = 0;
941 AC.PolyRatFunChanged = 0;
943 if ( par == STOREMODULE || par == CLEARMODULE ) {
945 if ( par == STOREMODULE && PopVariables() ) RetCode = -1;
946 if ( AR.infile->handle >= 0 ) {
947 CloseFile(AR.infile->handle);
948 remove(AR.infile->name);
949 AR.infile->handle = -1;
951 AR.infile->POfill = AR.infile->PObuffer;
952 PUTZERO(AR.infile->POposition);
953 AR.infile->POfull = AR.infile->PObuffer;
954 if ( AR.outfile->handle >= 0 ) {
955 CloseFile(AR.outfile->handle);
956 remove(AR.outfile->name);
957 AR.outfile->handle = -1;
960 AR.outfile->POfill = AR.outfile->PObuffer;
961 PUTZERO(AR.outfile->POposition);
962 if ( AR.hidefile->handle >= 0 ) {
963 CloseFile(AR.hidefile->handle);
964 remove(AR.hidefile->name);
965 AR.hidefile->handle = -1;
967 AR.hidefile->POfull =
968 AR.hidefile->POfill = AR.hidefile->PObuffer;
969 PUTZERO(AR.hidefile->POposition);
971 if ( par == CLEARMODULE ) {
972 if ( DeleteStore(0) < 0 ) {
973 MesPrint(
"Cannot restart the storage file");
979 AM.gProcessBucketSize = AM.hProcessBucketSize;
980 AM.gparallelflag = PARALLELFLAG;
981 AM.gnumextrasym = AM.ggnumextrasym;
982 PruneExtraSymbols(AM.ggnumextrasym);
985 ClearSpectators(par);
988 if ( CleanExpr(0) ) RetCode = -1;
989 if ( AC.DidClean ) CompactifyTree(AC.exprnames,EXPRNAMES);
994 if ( AC.MultiBracketBuf != 0 ) {
995 for ( i = 0; i < MAXMULTIBRACKETLEVELS; i++ ) {
996 if ( AC.MultiBracketBuf[i] ) {
997 M_free(AC.MultiBracketBuf[i],
"bracket buffer i");
998 AC.MultiBracketBuf[i] = 0;
1001 AC.MultiBracketLevels = 0;
1002 M_free(AC.MultiBracketBuf,
"multi bracket buffer");
1003 AC.MultiBracketBuf = 0;
1030 WORD PutBracket(
PHEAD WORD *termin)
1033 WORD *t, *t1, *b, i, j, *lastfun;
1035 WORD *bStop, *bb, *bf, *tStop;
1036 WORD *term1,*term2, *m1, *m2, *tStopa;
1037 WORD *bbb = 0, *bind, *binst = 0, bwild = 0, *bss = 0, *bns = 0, bset = 0;
1038 term1 = AT.WorkPointer+1;
1039 term2 = (WORD *)(((UBYTE *)(term1)) + AM.MaxTer);
1040 if ( ( (WORD *)(((UBYTE *)(term2)) + AM.MaxTer) ) > AT.WorkTop )
return(MesWork());
1041 if ( AR.BracketOn < 0 ) {
1042 t2 = term1; t1 = term2;
1045 t1 = term1; t2 = term2;
1047 b = AT.BrackBuf; bStop = b+*b; b++;
1048 while ( b < bStop ) {
1049 if ( *b == INDEX ) { bwild = 1; bbb = b+2; binst = b + b[1]; }
1050 if ( *b == SETSET ) { bset = 1; bss = b+2; bns = b + b[1]; }
1054 t = termin; tStopa = t + *t; i = *(t + *t -1); i = ABS(i);
1055 if ( AR.PolyFun && AT.PolyAct ) tStop = termin + AT.PolyAct;
1056 else tStop = tStopa - i;
1058 if ( AR.BracketOn < 0 ) {
1060 while ( t < tStop && *t >= FUNCTION
1061 && functions[*t-FUNCTION].commute ) {
1063 while ( b < bStop ) {
1066 while ( t < tStop && *t >= FUNCTION
1067 && functions[*t-FUNCTION].commute ) t += t[1];
1075 if ( b[1] == CFUNCTION ) {
1076 SETS set = Sets+b[0]; WORD i;
1077 for ( i = set->first; i < set->last; i++ ) {
1078 if ( SetElements[i] == *t ) {
1080 while ( t < tStop && *t >= FUNCTION
1081 && functions[*t-FUNCTION].commute ) t += t[1];
1089 if ( bwild && *t >= FUNCTION && functions[*t-FUNCTION].spec ) {
1094 while ( bind < binst ) {
1095 if ( *bind == *s2 ) {
1097 while ( t < tStop && *t >= FUNCTION
1098 && functions[*t-FUNCTION].commute ) t += t[1];
1111 while ( s1 < lastfun ) *t2++ = *s1++;
1112 while ( s1 < t ) *t1++ = *s1++;
1115 while ( s1 < t ) *t2++ = *s1++;
1121 while ( t < tStop && *t >= FUNCTION
1122 && functions[*t-FUNCTION].commute ) {
1124 while ( b < bStop ) {
1125 if ( *b == *t ) { lastfun = t + t[1];
goto NextNcom; }
1131 if ( b[1] == CFUNCTION ) {
1132 SETS set = Sets+b[0]; WORD i;
1133 for ( i = set->first; i < set->last; i++ ) {
1134 if ( SetElements[i] == *t ) {
1143 if ( bwild && *t >= FUNCTION && functions[*t-FUNCTION].spec ) {
1148 while ( bind < binst ) {
1149 if ( *bind == *s2 ) { lastfun = t + t[1];
goto NextNcom; }
1159 while ( s1 < lastfun ) *t1++ = *s1++;
1160 while ( s1 < t ) *t2++ = *s1++;
1165 b = AT.BrackBuf + 1;
1166 while ( b < bStop && *b >= FUNCTION
1167 && ( *b < FUNCTION || functions[*b-FUNCTION].commute ) ) {
1172 while ( t < tStop && ( bf < bStop || bwild || bset ) ) {
1174 while ( b < bStop && *b != *t ) { b += b[1]; }
1176 if ( *t >= FUNCTION ) {
1177 if ( b < bStop && *b == *t )
goto FunBrac;
1181 if ( b[1] == CFUNCTION ) {
1182 SETS set = Sets+b[0]; WORD i;
1183 for ( i = set->first; i < set->last; i++ ) {
1184 if ( SetElements[i] == *t )
goto FunBrac;
1190 if ( bwild && *t >= FUNCTION && functions[*t-FUNCTION].spec ) {
1195 while ( bind < binst ) {
1196 if ( *bind == *s2 )
goto FunBrac;
1204 FunBrac: NCOPY(t1,t,i);
1210 if ( *t == DELTA ) {
1211 if ( b < bStop && *b == DELTA ) {
1215 else { NCOPY(t2,t,i); }
1217 else if ( *t == INDEX ) {
1220 *t1++ = *t; t1++; *t2++ = *t; t2++;
1224 while ( --j >= 0 ) {
1225 while ( *bind < *t && bind < binst ) bind++;
1226 if ( *bind == *t && bind < binst ) {
1231 while ( b3 < bns ) {
1232 if ( b3[1] == CVECTOR ) {
1233 SETS set = Sets+b3[0]; WORD i;
1234 for ( i = set->first; i < set->last; i++ ) {
1235 if ( SetElements[i] == *t ) {
1248 m1[1] = WORDDIF(t1,m1);
1249 if ( m1[1] == 2 ) t1 = m1;
1250 m2[1] = WORDDIF(t2,m2);
1251 if ( m2[1] == 2 ) t2 = m2;
1255 *t1++ = *t; t1++; *t2++ = *t; t2++;
1258 while ( --j >= 0 ) {
1260 while ( b3 < bns ) {
1261 if ( b3[1] == CVECTOR ) {
1262 SETS set = Sets+b3[0]; WORD i;
1263 for ( i = set->first; i < set->last; i++ ) {
1264 if ( SetElements[i] == *t ) {
1275 m1[1] = WORDDIF(t1,m1);
1276 if ( m1[1] == 2 ) t1 = m1;
1277 m2[1] = WORDDIF(t2,m2);
1278 if ( m2[1] == 2 ) t2 = m2;
1284 else if ( *t == VECTOR ) {
1285 if ( ( b < bStop && *b == VECTOR ) || bwild ) {
1286 if ( b < bStop && *b == VECTOR ) {
1287 bb = b + b[1]; b += 2;
1291 m1 = t1; m2 = t2; *t1++ = *t; *t2++ = *t; t1++; t2++; t += 2;
1294 while ( b < bb && ( *b < *t ||
1295 ( *b == *t && b[1] < t[1] ) ) ) b += 2;
1296 if ( b < bb && ( *t == *b && t[1] == b[1] ) ) {
1297 *t1++ = *t++; *t1++ = *t++;
goto nextvec;
1301 while ( bind < binst ) {
1302 if ( *t == *bind || t[1] == *bind ) {
1303 *t1++ = *t++; *t1++ = *t++;
1311 while ( b3 < bns ) {
1312 if ( b3[1] == CVECTOR ) {
1313 SETS set = Sets+b3[0]; WORD i;
1314 for ( i = set->first; i < set->last; i++ ) {
1315 if ( SetElements[i] == *t ) {
1316 *t1++ = *t++; *t1++ = *t++;
1324 *t2++ = *t++; *t2++ = *t++;
1327 m1[1] = WORDDIF(t1,m1);
1328 if ( m1[1] == 2 ) t1 = m1;
1329 m2[1] = WORDDIF(t2,m2);
1330 if ( m2[1] == 2 ) t2 = m2;
1333 m1 = t1; *t1++ = *t; t1++;
1334 m2 = t2; *t2++ = *t; t2++;
1338 while ( b3 < bns ) {
1339 if ( b3[1] == CVECTOR ) {
1340 SETS set = Sets+b3[0]; WORD i;
1341 for ( i = set->first; i < set->last; i++ ) {
1342 if ( SetElements[i] == *t ) {
1343 *t1++ = *t++; *t1++ = *t++;
1350 *t2++ = *t++; *t2++ = *t++;
1353 m1[1] = WORDDIF(t1,m1);
1354 if ( m1[1] == 2 ) t1 = m1;
1355 m2[1] = WORDDIF(t2,m2);
1356 if ( m2[1] == 2 ) t2 = m2;
1362 else if ( *t == DOTPRODUCT ) {
1363 if ( ( b < bStop && *b == *t ) || bwild ) {
1364 m1 = t1; *t1++ = *t; t1++;
1365 m2 = t2; *t2++ = *t; t2++;
1366 if ( b >= bStop || *b != *t ) { bb = b; s1 = b; }
1368 s1 = b + b[1]; bb = b + 2;
1371 while ( t < s2 && ( bb < s1 || bwild || bset ) ) {
1372 while ( bb < s1 && ( *bb < *t ||
1373 ( *bb == *t && bb[1] < t[1] ) ) ) bb += 3;
1374 if ( bb < s1 && *bb == *t && bb[1] == t[1] ) {
1375 *t1++ = *t++; *t1++ = *t++; *t1++ = *t++; bb += 3;
1380 while ( bind < binst ) {
1381 if ( *bind == *t || *bind == t[1] ) {
1382 *t1++ = *t++; *t1++ = *t++; *t1++ = *t++;
1390 while ( b3 < bns ) {
1391 if ( b3[1] == CVECTOR ) {
1392 SETS set = Sets+b3[0]; WORD i;
1393 for ( i = set->first; i < set->last; i++ ) {
1394 if ( SetElements[i] == *t || SetElements[i] == t[1] ) {
1395 *t1++ = *t++; *t1++ = *t++; *t1++ = *t++;
1403 *t2++ = *t++; *t2++ = *t++; *t2++ = *t++;
1406 while ( t < s2 ) *t2++ = *t++;
1407 m1[1] = WORDDIF(t1,m1);
1408 if ( m1[1] == 2 ) t1 = m1;
1409 m2[1] = WORDDIF(t2,m2);
1410 if ( m2[1] == 2 ) t2 = m2;
1413 m1 = t1; *t1++ = *t; t1++;
1414 m2 = t2; *t2++ = *t; t2++;
1418 while ( b3 < bns ) {
1419 if ( b3[1] == CVECTOR ) {
1420 SETS set = Sets+b3[0]; WORD i;
1421 for ( i = set->first; i < set->last; i++ ) {
1422 if ( SetElements[i] == *t || SetElements[i] == t[1] ) {
1423 *t1++ = *t++; *t1++ = *t++; *t1++ = *t++;
1430 *t2++ = *t++; *t2++ = *t++; *t2++ = *t++;
1433 m1[1] = WORDDIF(t1,m1);
1434 if ( m1[1] == 2 ) t1 = m1;
1435 m2[1] = WORDDIF(t2,m2);
1436 if ( m2[1] == 2 ) t2 = m2;
1438 else { NCOPY(t2,t,i); }
1440 else if ( *t == SYMBOL ) {
1441 if ( b < bStop && *b == *t ) {
1442 m1 = t1; *t1++ = *t; t1++;
1443 m2 = t2; *t2++ = *t; t2++;
1444 s1 = b + b[1]; bb = b+2;
1446 while ( bb < s1 && t < s2 ) {
1447 while ( bb < s1 && *bb < *t ) bb += 2;
1449 if ( bset )
goto TrySymbolSet;
1452 if ( *bb == *t ) { *t1++ = *t++; *t1++ = *t++; }
1457 while ( bbb < bns ) {
1458 if ( bbb[1] == CSYMBOL ) {
1459 SETS set = Sets+bbb[0]; WORD i;
1460 for ( i = set->first; i < set->last; i++ ) {
1461 if ( SetElements[i] == *t ) {
1462 *t1++ = *t++; *t1++ = *t++;
1469 *t2++ = *t++; *t2++ = *t++;
1471 else { *t2++ = *t++; *t2++ = *t++; }
1474 while ( t < s2 ) *t2++ = *t++;
1475 m1[1] = WORDDIF(t1,m1);
1476 if ( m1[1] == 2 ) t1 = m1;
1477 m2[1] = WORDDIF(t2,m2);
1478 if ( m2[1] == 2 ) t2 = m2;
1482 m1 = t1; *t1++ = *t; t1++;
1483 m2 = t2; *t2++ = *t; t2++;
1487 while ( bbb < bns ) {
1488 if ( bbb[1] == CSYMBOL ) {
1489 SETS set = Sets+bbb[0]; WORD i;
1490 for ( i = set->first; i < set->last; i++ ) {
1491 if ( SetElements[i] == *t ) {
1492 *t1++ = *t++; *t1++ = *t++;
1499 *t2++ = *t++; *t2++ = *t++;
1502 m1[1] = WORDDIF(t1,m1);
1503 if ( m1[1] == 2 ) t1 = m1;
1504 m2[1] = WORDDIF(t2,m2);
1505 if ( m2[1] == 2 ) t2 = m2;
1507 else { NCOPY(t2,t,i); }
1513 if ( ( i = WORDDIF(tStop,t) ) > 0 ) NCOPY(t2,t,i);
1514 if ( AR.BracketOn < 0 ) {
1515 s1 = t1; t1 = t2; t2 = s1;
1517 do { *t2++ = *t++; }
while ( t < (WORD *)tStopa );
1519 i = WORDDIF(t1,term1);
1520 *t++ = 4 + i + WORDDIF(t2,term2);
1525 i = WORDDIF(t2,term2);
1527 if ( i > 0 ) NCOPY(t,t1,i);
1539 VOID SpecialCleanup(PHEAD0)
1542 if ( AT.previousEfactor ) M_free(AT.previousEfactor,
"Efactor cache");
1543 AT.previousEfactor = 0;
1551 #ifndef WITHPTHREADS 1556 if ( AN.cmod != 0 ) M_free(AN.cmod,
"AN.cmod");
1558 AN.cmod = (UWORD *)Malloc1(
sizeof(WORD)*n,
"AN.cmod");
1559 for ( i = 0; i < n; i++ ) AN.cmod[i] = AC.cmod[i];
1569 #ifndef WITHPTHREADS 1573 if ( AN.cmod != 0 ) M_free(AN.cmod,
"AN.cmod");
1586 void ExchangeExpressions(
int num1,
int num2)
1589 WORD node1, node2, namesize, TMproto[SUBEXPSIZE];
1595 e1 = Expressions + num1;
1596 e2 = Expressions + num2;
1599 AC.exprnames->namenode[node1].number = num2;
1600 AC.exprnames->namenode[node2].number = num1;
1601 a = e1->name; e1->name = e2->name; e2->name = a;
1602 namesize = e1->namesize; e1->namesize = e2->namesize; e2->namesize = namesize;
1605 if ( e1->status == STOREDEXPRESSION ) {
1609 TMproto[0] = EXPRESSION;
1610 TMproto[1] = SUBEXPSIZE;
1613 {
int ie;
for ( ie = 4; ie < SUBEXPSIZE; ie++ ) TMproto[ie] = 0; }
1614 AT.TMaddr = TMproto;
1615 ind = FindInIndex(num1,&AR.StoreData,0,0);
1616 s1 = (SBYTE *)(AC.exprnames->namebuffer+e1->name);
1621 SeekFile(AR.StoreData.Handle,&(e1->onfile),SEEK_SET);
1622 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)ind,
1624 MesPrint(
"File error while exchanging expressions");
1627 FlushFile(AR.StoreData.Handle);
1629 if ( e2->status == STOREDEXPRESSION ) {
1633 TMproto[0] = EXPRESSION;
1634 TMproto[1] = SUBEXPSIZE;
1637 {
int ie;
for ( ie = 4; ie < SUBEXPSIZE; ie++ ) TMproto[ie] = 0; }
1638 AT.TMaddr = TMproto;
1639 ind = FindInIndex(num1,&AR.StoreData,0,0);
1640 s1 = (SBYTE *)(AC.exprnames->namebuffer+e2->name);
1645 SeekFile(AR.StoreData.Handle,&(e2->onfile),SEEK_SET);
1646 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)ind,
1648 MesPrint(
"File error while exchanging expressions");
1651 FlushFile(AR.StoreData.Handle);
1660 int GetFirstBracket(WORD *term,
int num)
1671 WORD type, *oldcomppointer, oldonefile, numword;
1674 oldcomppointer = AR.CompressPointer;
1675 type = Expressions[num].status;
1676 if ( type == STOREDEXPRESSION ) {
1677 WORD TMproto[SUBEXPSIZE];
1678 TMproto[0] = EXPRESSION;
1679 TMproto[1] = SUBEXPSIZE;
1682 {
int ie;
for ( ie = 4; ie < SUBEXPSIZE; ie++ ) TMproto[ie] = 0; }
1683 AT.TMaddr = TMproto;
1685 if ( ( renumber = GetTable(num,&position,0) ) == 0 ) {
1686 MesCall(
"GetFirstBracket");
1689 if ( GetFromStore(term,&position,renumber,&numword,num) < 0 ) {
1690 MesCall(
"GetFirstBracket");
1696 if ( renumber->
symb.
lo != AN.dummyrenumlist )
1697 M_free(renumber->
symb.
lo,
"VarSpace");
1698 M_free(renumber,
"Renumber");
1704 oldonefile = AR.GetOneFile;
1705 if ( type == HIDDENLEXPRESSION || type == HIDDENGEXPRESSION ) {
1706 AR.GetOneFile = 2; fi = AR.hidefile;
1709 AR.GetOneFile = 0; fi = AR.infile;
1712 PUTZERO(oldposition);
1718 SETBASEPOSITION(oldposition,fi->POfill-fi->PObuffer);
1720 position = AS.OldOnFile[num];
1721 if ( GetOneTerm(BHEAD term,fi,&position,1) < 0
1722 || ( GetOneTerm(BHEAD term,fi,&position,1) < 0 ) ) {
1723 MLOCK(ErrorMessageLock);
1724 MesCall(
"GetFirstBracket");
1725 MUNLOCK(ErrorMessageLock);
1740 fi->POfill = fi->PObuffer+BASEPOSITION(oldposition);
1742 AR.GetOneFile = oldonefile;
1744 AR.CompressPointer = oldcomppointer;
1746 tstop = term + *term; tstop -= ABS(tstop[-1]);
1748 while ( t < tstop ) {
1749 if ( *t == HAAKJE )
break;
1753 term[0] = 4; term[1] = 1; term[2] = 1; term[3] = 3;
1756 *t++ = 1; *t++ = 1; *t++ = 3; *term = t - term;
1760 term[0] = 4; term[1] = 1; term[2] = 1; term[3] = 3;
1770 int GetFirstTerm(WORD *term,
int num)
1781 WORD type, *oldcomppointer, oldonefile, numword;
1783 oldcomppointer = AR.CompressPointer;
1784 type = Expressions[num].status;
1785 if ( type == STOREDEXPRESSION ) {
1786 WORD TMproto[SUBEXPSIZE];
1787 TMproto[0] = EXPRESSION;
1788 TMproto[1] = SUBEXPSIZE;
1791 {
int ie;
for ( ie = 4; ie < SUBEXPSIZE; ie++ ) TMproto[ie] = 0; }
1792 AT.TMaddr = TMproto;
1794 if ( ( renumber = GetTable(num,&position,0) ) == 0 ) {
1795 MesCall(
"GetFirstTerm");
1798 if ( GetFromStore(term,&position,renumber,&numword,num) < 0 ) {
1799 MesCall(
"GetFirstTerm");
1805 if ( renumber->
symb.
lo != AN.dummyrenumlist )
1806 M_free(renumber->
symb.
lo,
"VarSpace");
1807 M_free(renumber,
"Renumber");
1813 oldonefile = AR.GetOneFile;
1814 if ( type == HIDDENLEXPRESSION || type == HIDDENGEXPRESSION ) {
1815 AR.GetOneFile = 2; fi = AR.hidefile;
1819 if ( Expressions[num].replace == NEWLYDEFINEDEXPRESSION )
1821 else fi = AR.infile;
1824 PUTZERO(oldposition);
1830 SETBASEPOSITION(oldposition,fi->POfill-fi->PObuffer);
1832 position = AS.OldOnFile[num];
1833 if ( GetOneTerm(BHEAD term,fi,&position,1) < 0
1834 || ( GetOneTerm(BHEAD term,fi,&position,1) < 0 ) ) {
1835 MLOCK(ErrorMessageLock);
1836 MesCall(
"GetFirstTerm");
1837 MUNLOCK(ErrorMessageLock);
1852 fi->POfill = fi->PObuffer+BASEPOSITION(oldposition);
1854 AR.GetOneFile = oldonefile;
1856 AR.CompressPointer = oldcomppointer;
1865 int GetContent(WORD *content,
int num)
1880 WORD type, *oldcomppointer, oldonefile, numword, *term, i;
1881 WORD *cbuffer = TermMalloc(
"GetContent");
1882 WORD *oldworkpointer = AT.WorkPointer;
1884 oldcomppointer = AR.CompressPointer;
1885 type = Expressions[num].status;
1886 if ( type == STOREDEXPRESSION ) {
1887 WORD TMproto[SUBEXPSIZE];
1888 TMproto[0] = EXPRESSION;
1889 TMproto[1] = SUBEXPSIZE;
1892 {
int ie;
for ( ie = 4; ie < SUBEXPSIZE; ie++ ) TMproto[ie] = 0; }
1893 AT.TMaddr = TMproto;
1895 if ( ( renumber = GetTable(num,&position,0) ) == 0 )
goto CalledFrom;
1896 if ( GetFromStore(cbuffer,&position,renumber,&numword,num) < 0 )
goto CalledFrom;
1898 term = oldworkpointer;
1899 AR.CompressPointer = oldcomppointer;
1900 if ( GetFromStore(term,&position,renumber,&numword,num) < 0 )
goto CalledFrom;
1901 if ( *term == 0 )
break;
1905 if ( ContentMerge(BHEAD cbuffer,term) < 0 )
goto CalledFrom;
1910 if ( renumber->
symb.
lo != AN.dummyrenumlist )
1911 M_free(renumber->
symb.
lo,
"VarSpace");
1912 M_free(renumber,
"Renumber");
1918 oldonefile = AR.GetOneFile;
1919 if ( type == HIDDENLEXPRESSION || type == HIDDENGEXPRESSION ) {
1920 AR.GetOneFile = 2; fi = AR.hidefile;
1924 if ( Expressions[num].replace == NEWLYDEFINEDEXPRESSION )
1926 else fi = AR.infile;
1929 PUTZERO(oldposition);
1935 SETBASEPOSITION(oldposition,fi->POfill-fi->PObuffer);
1937 position = AS.OldOnFile[num];
1938 if ( GetOneTerm(BHEAD cbuffer,fi,&position,1) < 0 )
goto CalledFrom;
1939 AR.CompressPointer = oldcomppointer;
1940 if ( GetOneTerm(BHEAD cbuffer,fi,&position,1) < 0 )
goto CalledFrom;
1949 term = oldworkpointer;
1950 AR.CompressPointer = oldcomppointer;
1951 if ( GetOneTerm(BHEAD term,fi,&position,1) < 0 )
goto CalledFrom;
1952 if ( *term == 0 )
break;
1956 if ( ContentMerge(BHEAD cbuffer,term) < 0 )
goto CalledFrom;
1959 fi->POfill = fi->PObuffer+BASEPOSITION(oldposition);
1961 AR.GetOneFile = oldonefile;
1963 AR.CompressPointer = oldcomppointer;
1964 for ( i = 0; i < *cbuffer; i++ ) content[i] = cbuffer[i];
1965 TermFree(cbuffer,
"GetContent");
1966 AT.WorkPointer = oldworkpointer;
1969 MLOCK(ErrorMessageLock);
1970 MesCall(
"GetContent");
1971 MUNLOCK(ErrorMessageLock);
1982 int CleanupTerm(WORD *term)
1984 WORD *tstop, *t, *tfill, *tt;
1985 GETSTOP(term,tstop);
1987 while ( t < tstop ) {
1988 if ( *t >= FUNCTION && ( functions[*t-FUNCTION].commute || *t == DENOMINATOR ) ) {
1989 tfill = t; tt = t + t[1]; tstop = term + *term;
1990 while ( tt < tstop ) *tfill++ = *tt++;
1991 *term = tfill - term;
1992 tstop -= ABS(tfill[-1]);
2006 WORD ContentMerge(
PHEAD WORD *content, WORD *term)
2009 WORD *cstop, csize, crsize, sign = 1, numsize, densize, i, tnsize, tdsize;
2010 UWORD *num, *den, *tnum, *tden;
2011 WORD *outfill, *outb = TermMalloc(
"ContentMerge"), *ct;
2012 WORD *t, *tstop, tsize, trsize, *told;
2013 WORD *t1, *t2, *c1, *c2, i1, i2, *out1;
2014 cstop = content + *content;
2016 if ( csize < 0 ) { sign = -sign; csize = -csize; }
2018 numsize = densize = crsize = (csize-1)/2;
2019 num = NumberMalloc(
"ContentMerge");
2020 den = NumberMalloc(
"ContentMerge");
2021 for ( i = 0; i < numsize; i++ ) num[i] = (UWORD)(cstop[i]);
2022 for ( i = 0; i < densize; i++ ) den[i] = (UWORD)(cstop[i+crsize]);
2023 while ( num[numsize-1] == 0 ) numsize--;
2024 while ( den[densize-1] == 0 ) densize--;
2028 tstop = term + *term;
2030 if ( tsize < 0 ) tsize = -tsize;
2032 tstop = tstop - tsize;
2033 tnsize = tdsize = trsize = (tsize-1)/2;
2034 tnum = (UWORD *)tstop; tden = (UWORD *)(tstop + trsize);
2035 while ( tnum[tnsize-1] == 0 ) tnsize--;
2036 while ( tden[tdsize-1] == 0 ) tdsize--;
2037 GcdLong(BHEAD num, numsize, tnum, tnsize, num, &numsize);
2038 if ( LcmLong(BHEAD den, densize, tden, tdsize, den, &densize) )
goto CalledFrom;
2042 while ( ct < cstop ) {
2046 while ( t < tstop && *t != *ct ) t += t[1];
2047 if ( t >= tstop )
break;
2048 t1 = t+2; t2 = t+t[1];
2049 c1 = ct+2; c2 = ct+ct[1];
2050 out1 = outfill; *outfill++ = *ct; outfill++;
2051 while ( c1 < c2 && t1 < t2 ) {
2053 if ( t1[1] <= c1[1] ) {
2054 *outfill++ = *t1++; *outfill++ = *t1++;
2058 *outfill++ = *c1++; *outfill++ = *c1++;
2062 else if ( *c1 < *t1 ) {
2064 *outfill++ = *c1++; *outfill++ = *c1++;
2070 *outfill++ = *t1++; *outfill++ = *t1++;
2076 if ( c1[1] < 0 ) { *outfill++ = c1[0]; *outfill++ = c1[1]; }
2080 if ( t1[1] < 0 ) { *outfill++ = t1[0]; *outfill++ = t1[1]; }
2083 out1[1] = outfill - out1;
2084 if ( out1[1] == 2 ) outfill = out1;
2088 while ( t < tstop && *t != *ct ) t += t[1];
2089 if ( t >= tstop )
break;
2090 t1 = t+2; t2 = t+t[1];
2091 c1 = ct+2; c2 = ct+ct[1];
2092 out1 = outfill; *outfill++ = *ct; outfill++;
2093 while ( c1 < c2 && t1 < t2 ) {
2094 if ( *c1 == *t1 && c1[1] == t1[1] ) {
2095 if ( t1[2] <= c1[2] ) {
2096 *outfill++ = *t1++; *outfill++ = *t1++; *outfill++ = *t1++;
2100 *outfill++ = *c1++; *outfill++ = *c1++; *outfill++ = *c1++;
2104 else if ( *c1 < *t1 || ( *c1 == *t1 && c1[1] < t1[1] ) ) {
2106 *outfill++ = *c1++; *outfill++ = *c1++; *outfill++ = *c1++;
2112 *outfill++ = *t1++; *outfill++ = *t1++; *outfill++ = *t1++;
2118 if ( c1[2] < 0 ) { *outfill++ = c1[0]; *outfill++ = c1[1]; *outfill++ = c1[1]; }
2122 if ( t1[2] < 0 ) { *outfill++ = t1[0]; *outfill++ = t1[1]; *outfill++ = t1[1]; }
2125 out1[1] = outfill - out1;
2126 if ( out1[1] == 2 ) outfill = out1;
2130 while ( t < tstop && *t != *ct ) t += t[1];
2131 if ( t >= tstop )
break;
2132 t1 = t+2; t2 = t+t[1];
2133 c1 = ct+2; c2 = ct+ct[1];
2134 out1 = outfill; *outfill++ = *ct; outfill++;
2135 while ( c1 < c2 && t1 < t2 ) {
2140 else if ( *c1 < *t1 ) { c1 += 1; }
2143 out1[1] = outfill - out1;
2144 if ( out1[1] == 2 ) outfill = out1;
2149 while ( t < tstop && *t != *ct ) t += t[1];
2150 if ( t >= tstop )
break;
2151 t1 = t+2; t2 = t+t[1];
2152 c1 = ct+2; c2 = ct+ct[1];
2153 out1 = outfill; *outfill++ = *ct; outfill++;
2154 while ( c1 < c2 && t1 < t2 ) {
2155 if ( *c1 == *t1 && c1[1] && t1[1] ) {
2156 *outfill++ = *c1++; *outfill++ = *c1++;
2159 else if ( *c1 < *t1 || ( *c1 == *t1 && c1[1] < t1[1] ) ) {
2166 out1[1] = outfill - out1;
2167 if ( out1[1] == 2 ) outfill = out1;
2172 while ( *t < *ct && t < tstop ) t += t[1];
2173 if ( t >= tstop ) { t = told; }
2175 t1 = t; t2 = ct; i1 = t1[1]; i2 = t2[1];
2176 if ( i1 != i2 ) { t = told; }
2179 if ( *t1 != *t2 )
break;
2183 for ( i = 0; i < i2; i++ ) { *outfill++ = *t++; }
2195 if ( numsize < densize ) {
2196 for ( i = numsize; i < densize; i++ ) num[i] = 0;
2199 else if ( densize < numsize ) {
2200 for ( i = densize; i < numsize; i++ ) den[i] = 0;
2203 for ( i = 0; i < numsize; i++ ) *outfill++ = num[i];
2204 for ( i = 0; i < densize; i++ ) *outfill++ = den[i];
2205 csize = numsize+densize+1;
2206 if ( sign < 0 ) csize = -csize;
2208 *outb = outfill-outb;
2209 NumberFree(den,
"ContentMerge");
2210 NumberFree(num,
"ContentMerge");
2211 for ( i = 0; i < *outb; i++ ) content[i] = outb[i];
2212 TermFree(outb,
"ContentMerge");
2215 MLOCK(ErrorMessageLock);
2216 MesCall(
"GetContent");
2217 MUNLOCK(ErrorMessageLock);
2226 LONG TermsInExpression(WORD num)
2228 LONG x = Expressions[num].counter;
2229 if ( x >= 0 )
return(x);
2238 void UpdatePositions()
2244 if ( NumExpressions > 0 &&
2245 ( AS.OldOnFile == 0 || AS.NumOldOnFile < NumExpressions ) ) {
2246 if ( AS.OldOnFile ) {
2248 AS.OldOnFile = (
POSITION *)Malloc1(NumExpressions*
sizeof(
POSITION),
"file pointers");
2249 for ( i = 0; i < AS.NumOldOnFile; i++ ) AS.OldOnFile[i] = old[i];
2250 AS.NumOldOnFile = NumExpressions;
2251 M_free(old,
"process file pointers");
2254 AS.OldOnFile = (
POSITION *)Malloc1(NumExpressions*
sizeof(
POSITION),
"file pointers");
2255 AS.NumOldOnFile = NumExpressions;
2258 if ( NumExpressions > 0 &&
2259 ( AS.OldNumFactors == 0 || AS.NumOldNumFactors < NumExpressions ) ) {
2260 if ( AS.OldNumFactors ) {
2261 oldw = AS.OldNumFactors;
2262 AS.OldNumFactors = (WORD *)Malloc1(NumExpressions*
sizeof(WORD),
"numfactors pointers");
2263 for ( i = 0; i < AS.NumOldNumFactors; i++ ) AS.OldNumFactors[i] = oldw[i];
2264 M_free(oldw,
"numfactors pointers");
2265 oldw = AS.Oldvflags;
2266 AS.Oldvflags = (WORD *)Malloc1(NumExpressions*
sizeof(WORD),
"vflags pointers");
2267 for ( i = 0; i < AS.NumOldNumFactors; i++ ) AS.Oldvflags[i] = oldw[i];
2268 AS.NumOldNumFactors = NumExpressions;
2269 M_free(oldw,
"vflags pointers");
2272 AS.OldNumFactors = (WORD *)Malloc1(NumExpressions*
sizeof(WORD),
"numfactors pointers");
2273 AS.Oldvflags = (WORD *)Malloc1(NumExpressions*
sizeof(WORD),
"vflags pointers");
2274 AS.NumOldNumFactors = NumExpressions;
2277 for ( i = 0; i < NumExpressions; i++ ) {
2278 AS.OldOnFile[i] = e[i].onfile;
2279 AS.OldNumFactors[i] = e[i].numfactors;
2280 AS.Oldvflags[i] = e[i].vflags;
2292 LONG CountTerms1(PHEAD0)
2295 POSITION oldposition, startposition;
2296 WORD *t, *m, *mstop, decr, i, *oldwork, retval;
2297 WORD *oldipointer = AR.CompressPointer;
2298 WORD oldGetOneFile = AR.GetOneFile, olddeferflag = AR.DeferFlag;
2301 oldwork = AT.WorkPointer;
2302 AT.WorkPointer = (WORD *)(((UBYTE *)(AT.WorkPointer)) + AM.MaxTer);
2304 startposition = AR.DefPosition;
2308 if ( AR.infile->handle >= 0 ) {
2309 PUTZERO(oldposition);
2315 SETBASEPOSITION(oldposition,AR.infile->POfill-AR.infile->PObuffer);
2316 AR.infile->POfill = (WORD *)((UBYTE *)(AR.infile->PObuffer)
2317 +BASEPOSITION(startposition));
2322 t = m = AR.CompressBuffer;
2324 mstop = t - ABS(t[-1]);
2326 while ( *m != HAAKJE && m < mstop ) m += m[1];
2329 AR.DeferFlag = olddeferflag;
2330 AT.WorkPointer = oldwork;
2331 AR.GetOneFile = oldGetOneFile;
2335 decr = WORDDIF(mstop,AR.CompressBuffer)-1;
2337 m = AR.CompressBuffer;
2338 t = AR.CompressPointer;
2350 AR.CompressPointer = oldipointer;
2353 retval = GetOneTerm(BHEAD AT.WorkPointer,AR.infile,&startposition,0);
2354 if ( retval >= 0 ) AR.CompressPointer = oldipointer;
2355 if ( retval <= 0 )
break;
2356 t = AR.CompressPointer;
2357 if ( *t < (1 + decr + ABS(*(t+*t-1))) )
break;
2359 m = AR.CompressBuffer+1;
2360 while ( m < mstop ) {
2361 if ( *m != *t )
goto Thatsit;
2369 AT.WorkPointer = oldwork;
2370 if ( AR.infile->handle >= 0 ) {
2376 AR.infile->POfill = AR.infile->PObuffer + BASEPOSITION(oldposition);
2378 AR.DeferFlag = olddeferflag;
2379 AR.GetOneFile = oldGetOneFile;
2395 #define CURRENTBRACKET 1 2396 #define BRACKETCURRENTEXPR 2 2397 #define BRACKETOTHEREXPR 3 2398 #define NOBRACKETACTIVE 4 2400 LONG TermsInBracket(
PHEAD WORD *term, WORD level)
2402 WORD *t, *tstop, *b, *tt, *n1, *n2;
2403 int type = 0, i, num;
2405 WORD *bracketbuffer = AT.WorkPointer;
2406 t = term; GETSTOP(t,tstop);
2407 t++; b = bracketbuffer;
2408 while ( t < tstop ) {
2409 if ( *t != TERMSINBRACKET ) { t += t[1];
continue; }
2410 if ( t[1] == FUNHEAD || (
2412 && t[FUNHEAD] == -SNUMBER
2413 && t[FUNHEAD+1] == 0
2415 if ( AC.ComDefer == 0 ) {
2416 type = NOBRACKETACTIVE;
2419 type = CURRENTBRACKET;
2424 if ( t[FUNHEAD] == -EXPRESSION ) {
2425 if ( t[FUNHEAD+2] < 0 ) {
2426 if ( ( t[FUNHEAD+2] <= -FUNCTION ) && ( t[1] == FUNHEAD+3 ) ) {
2427 type = BRACKETOTHEREXPR;
2428 *b++ = FUNHEAD+4; *b++ = -t[FUNHEAD+2]; *b++ = FUNHEAD;
2429 for ( i = 2; i < FUNHEAD; i++ ) *b++ = 0;
2430 *b++ = 1; *b++ = 1; *b++ = 3;
2433 else if ( ( t[FUNHEAD+2] > -FUNCTION ) && ( t[1] == FUNHEAD+4 ) ) {
2434 type = BRACKETOTHEREXPR;
2438 *b++ = 8; *b++ = SYMBOL; *b++ = 4; *b++ = tt[1];
2439 *b++ = 1; *b++ = 1; *b++ = 1; *b++ = 3;
2443 *b++ = 4; *b++ = 1; *b++ = 1; *b++ = 3;
2445 else goto IllBraReq;
2453 else if ( ( t[FUNHEAD+2] == (t[1]-FUNHEAD-2) ) &&
2454 ( t[FUNHEAD+2+ARGHEAD] == (t[FUNHEAD+2]-ARGHEAD) ) ) {
2455 type = BRACKETOTHEREXPR;
2456 tt = t + FUNHEAD + ARGHEAD; num = *tt;
2457 for ( i = 0; i < num; i++ ) *b++ = *tt++;
2462 if ( t[FUNHEAD] < 0 ) {
2463 if ( ( t[FUNHEAD] <= -FUNCTION ) && ( t[1] == FUNHEAD+1 ) ) {
2464 type = BRACKETCURRENTEXPR;
2465 *b++ = FUNHEAD+4; *b++ = -t[FUNHEAD+2]; *b++ = FUNHEAD;
2466 for ( i = 2; i < FUNHEAD; i++ ) *b++ = 0;
2467 *b++ = 1; *b++ = 1; *b++ = 3; *b = 0;
2470 else if ( ( t[FUNHEAD] > -FUNCTION ) && ( t[1] == FUNHEAD+2 ) ) {
2471 type = BRACKETCURRENTEXPR;
2475 *b++ = 8; *b++ = SYMBOL; *b++ = 4; *b++ = tt[1];
2476 *b++ = 1; *b++ = 1; *b++ = 1; *b++ = 3;
2480 *b++ = 4; *b++ = 1; *b++ = 1; *b++ = 3;
2482 else goto IllBraReq;
2490 else if ( ( t[FUNHEAD] == (t[1]-FUNHEAD) ) &&
2491 ( t[FUNHEAD+ARGHEAD] == (t[FUNHEAD]-ARGHEAD) ) ) {
2492 type = BRACKETCURRENTEXPR;
2493 tt = t + FUNHEAD + ARGHEAD; num = *tt;
2494 for ( i = 0; i < num; i++ ) *b++ = *tt++;
2499 MLOCK(ErrorMessageLock);
2500 MesPrint(
"Illegal bracket request in termsinbracket_ function.");
2501 MUNLOCK(ErrorMessageLock);
2508 if ( AT.WorkPointer + *term +4 > AT.WorkTop ) {
2509 MLOCK(ErrorMessageLock);
2511 MesPrint(
"Called from termsinbracket_ function.");
2512 MUNLOCK(ErrorMessageLock);
2519 case CURRENTBRACKET:
2525 numterms = CountTerms1(BHEAD0);
2527 case BRACKETCURRENTEXPR:
2531 MLOCK(ErrorMessageLock);
2532 MesPrint(
"termsinbracket_ function currently only handles Keep Brackets.");
2533 MUNLOCK(ErrorMessageLock);
2535 case BRACKETOTHEREXPR:
2536 MLOCK(ErrorMessageLock);
2537 MesPrint(
"termsinbracket_ function currently only handles Keep Brackets.");
2538 MUNLOCK(ErrorMessageLock);
2540 case NOBRACKETACTIVE:
2547 n1 = term; n2 = AT.WorkPointer; tstop = n1 + *n1;
2548 while ( n1 < t ) *n2++ = *n1++;
2549 i = numterms >> BITSINWORD;
2551 *n2++ = LNUMBER; *n2++ = 4; *n2++ = 1; *n2++ = (WORD)(numterms & WORDMASK);
2554 *n2++ = LNUMBER; *n2++ = 5; *n2++ = 2;
2555 *n2++ = (WORD)(numterms & WORDMASK); *n2++ = i;
2558 while ( n1 < tstop ) *n2++ = *n1++;
2559 AT.WorkPointer[0] = n2 - AT.WorkPointer;
2560 AT.WorkPointer = n2;
2562 AT.WorkPointer = bracketbuffer;
2563 MLOCK(ErrorMessageLock);
2564 MesPrint(
"Called from termsinbracket_ function.");
2565 MUNLOCK(ErrorMessageLock);
2571 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)