40 char cursortdirp[] =
".";
41 char commentchar[] =
"*";
43 char highfirst[] =
"highfirst";
44 char lowfirst[] =
"lowfirst";
45 char procedureextension[] =
"prc";
47 #define NUMERICALVALUE 0 55 {(UBYTE *)
"bracketindexsize", NUMERICALVALUE, 0, (LONG)MAXBRACKETBUFFERSIZE}
56 ,{(UBYTE *)
"commentchar", STRINGVALUE, 0, (LONG)commentchar}
57 ,{(UBYTE *)
"compresssize", NUMERICALVALUE, 0, (LONG)COMPRESSBUFFER}
58 ,{(UBYTE *)
"constindex", NUMERICALVALUE, 0, (LONG)NUMFIXED}
59 ,{(UBYTE *)
"continuationlines", NUMERICALVALUE, 0, (LONG)FORTRANCONTINUATIONLINES}
60 ,{(UBYTE *)
"define", DEFINEVALUE, 0, (LONG)0}
61 ,{(UBYTE *)
"dotchar", STRINGVALUE, 0, (LONG)dotchar}
62 ,{(UBYTE *)
"factorizationcache", NUMERICALVALUE, 0, (LONG)FBUFFERSIZE}
63 ,{(UBYTE *)
"filepatches", NUMERICALVALUE, 0, (LONG)MAXFPATCHES}
64 ,{(UBYTE *)
"functionlevels", NUMERICALVALUE, 0, (LONG)MAXFLEVELS}
65 ,{(UBYTE *)
"hidesize", NUMERICALVALUE, 0, (LONG)0}
66 ,{(UBYTE *)
"incdir", PATHVALUE, 0, (LONG)curdirp}
67 ,{(UBYTE *)
"indentspace", NUMERICALVALUE, 0, (LONG)INDENTSPACE}
68 ,{(UBYTE *)
"insidefirst", ONOFFVALUE, 0, (LONG)1}
69 ,{(UBYTE *)
"largepatches", NUMERICALVALUE, 0, (LONG)MAXPATCHES}
70 ,{(UBYTE *)
"largesize", NUMERICALVALUE, 0, (LONG)LARGEBUFFER}
71 ,{(UBYTE *)
"maxnumbersize", NUMERICALVALUE, 0, (LONG)0}
73 ,{(UBYTE *)
"maxtermsize", NUMERICALVALUE, 0, (LONG)MAXTER}
74 ,{(UBYTE *)
"maxwildcards", NUMERICALVALUE, 0, (LONG)MAXWILDC}
75 ,{(UBYTE *)
"nospacesinnumbers", ONOFFVALUE, 0, (LONG)0}
76 ,{(UBYTE *)
"numstorecaches", NUMERICALVALUE, 0, (LONG)NUMSTORECACHES}
77 ,{(UBYTE *)
"nwritefinalstatistics", ONOFFVALUE, 0, (LONG)0}
78 ,{(UBYTE *)
"nwriteprocessstatistics", ONOFFVALUE, 0, (LONG)0}
79 ,{(UBYTE *)
"nwritestatistics", ONOFFVALUE, 0, (LONG)0}
80 ,{(UBYTE *)
"nwritethreadstatistics", ONOFFVALUE, 0, (LONG)0}
81 ,{(UBYTE *)
"oldfactarg", ONOFFVALUE, 0, (LONG)NEWFACTARG}
82 ,{(UBYTE *)
"oldgcd", ONOFFVALUE, 0, (LONG)1}
83 ,{(UBYTE *)
"oldorder", ONOFFVALUE, 0, (LONG)0}
84 ,{(UBYTE *)
"oldparallelstatistics", ONOFFVALUE, 0, (LONG)0}
85 ,{(UBYTE *)
"parentheses", NUMERICALVALUE, 0, (LONG)MAXPARLEVEL}
86 ,{(UBYTE *)
"path", PATHVALUE, 0, (LONG)curdirp}
87 ,{(UBYTE *)
"procedureextension", STRINGVALUE, 0, (LONG)procedureextension}
88 ,{(UBYTE *)
"processbucketsize", NUMERICALVALUE, 0, (LONG)DEFAULTPROCESSBUCKETSIZE}
89 ,{(UBYTE *)
"resettimeonclear", ONOFFVALUE, 0, (LONG)1}
90 ,{(UBYTE *)
"scratchsize", NUMERICALVALUE, 0, (LONG)SCRATCHSIZE}
91 ,{(UBYTE *)
"shmwinsize", NUMERICALVALUE, 0, (LONG)SHMWINSIZE}
92 ,{(UBYTE *)
"sizestorecache", NUMERICALVALUE, 0, (LONG)SIZESTORECACHE}
93 ,{(UBYTE *)
"smallextension", NUMERICALVALUE, 0, (LONG)SMALLOVERFLOW}
94 ,{(UBYTE *)
"smallsize", NUMERICALVALUE, 0, (LONG)SMALLBUFFER}
95 ,{(UBYTE *)
"sortiosize", NUMERICALVALUE, 0, (LONG)SORTIOSIZE}
96 ,{(UBYTE *)
"sorttype", STRINGVALUE, 0, (LONG)lowfirst}
97 ,{(UBYTE *)
"spectatorsize", NUMERICALVALUE, 0, (LONG)SPECTATORSIZE}
98 ,{(UBYTE *)
"subfilepatches", NUMERICALVALUE, 0, (LONG)SMAXFPATCHES}
99 ,{(UBYTE *)
"sublargepatches", NUMERICALVALUE, 0, (LONG)SMAXPATCHES}
100 ,{(UBYTE *)
"sublargesize", NUMERICALVALUE, 0, (LONG)SLARGEBUFFER}
101 ,{(UBYTE *)
"subsmallextension", NUMERICALVALUE, 0, (LONG)SSMALLOVERFLOW}
102 ,{(UBYTE *)
"subsmallsize", NUMERICALVALUE, 0, (LONG)SSMALLBUFFER}
103 ,{(UBYTE *)
"subsortiosize", NUMERICALVALUE, 0, (LONG)SSORTIOSIZE}
104 ,{(UBYTE *)
"subtermsinsmall", NUMERICALVALUE, 0, (LONG)STERMSSMALL}
105 ,{(UBYTE *)
"tempdir", STRINGVALUE, 0, (LONG)curdirp}
106 ,{(UBYTE *)
"tempsortdir", STRINGVALUE, 0, (LONG)cursortdirp}
107 ,{(UBYTE *)
"termsinsmall", NUMERICALVALUE, 0, (LONG)TERMSSMALL}
108 ,{(UBYTE *)
"threadbucketsize", NUMERICALVALUE, 0, (LONG)DEFAULTTHREADBUCKETSIZE}
109 ,{(UBYTE *)
"threadloadbalancing", ONOFFVALUE, 0, (LONG)DEFAULTTHREADLOADBALANCING}
110 ,{(UBYTE *)
"threads", NUMERICALVALUE, 0, (LONG)DEFAULTTHREADS}
111 ,{(UBYTE *)
"threadscratchoutsize", NUMERICALVALUE, 0, (LONG)THREADSCRATCHOUTSIZE}
112 ,{(UBYTE *)
"threadscratchsize", NUMERICALVALUE, 0, (LONG)THREADSCRATCHSIZE}
113 ,{(UBYTE *)
"threadsortfilesynch", ONOFFVALUE, 0, (LONG)0}
114 ,{(UBYTE *)
"totalsize", ONOFFVALUE, 0, (LONG)2}
115 ,{(UBYTE *)
"workspace", NUMERICALVALUE, 0, (LONG)WORKBUFFER}
116 ,{(UBYTE *)
"wtimestats", ONOFFVALUE, 0, (LONG)2}
127 UBYTE *setbuffer, *s, *t, *u ;
129 setbuffer = LoadInputFile((UBYTE *)setupfilename,SETUPFILE);
138 if ( *s ==
' ' || *s ==
'\t' || *s ==
'*' || *s ==
'#' || *s ==
'\n' ) {
139 while ( *s && *s !=
'\n' ) s++;
141 else if ( tolower(*s) <
'a' || tolower(*s) >
'z' ) {
143 while ( *s && *s !=
'\n' ) s++;
152 while ( tolower(*s) >=
'a' && tolower(*s) <=
'z' ) s++;
154 while ( *s ==
' ' || *s ==
'\t' ) s++;
156 while ( *s && *s !=
'\n' && *s !=
'\r' ) s++;
158 errors += ProcessOption(t,u,0);
160 while ( *s ==
'\n' || *s ==
'\r' ) s++;
162 M_free(setbuffer,
"setup file buffer");
164 if ( errors )
return(1);
173 static char *proop1[3] = {
"Setup file",
"Setups in .frm file",
"Setup in environment" };
175 int ProcessOption(UBYTE *s1, UBYTE *s2,
int filetype)
178 int n, giveback = 0, error = 0;
179 UBYTE *s, *t, *s2ret;
181 sp = GetSetupPar(s1);
189 UBYTE *s3,*s4,*s5,*s6, c, *start;
193 if ( *s ==
'\\' ) s += 2;
194 else if ( *s ==
'`' ) {
196 while ( *s && *s !=
'\'' ) {
197 if ( *s ==
'\\' ) s++;
201 MesPrint(
"%s: Illegal use of ` character for parameter %s" 202 ,proop1[filetype],s1);
206 s3 = (UBYTE *)getenv((
char *)(start+1));
208 MesPrint(
"%s: Cannot find environment variable %s for parameter %s" 209 ,proop1[filetype],start+1,s1);
214 n1 = start - s2; s4 = s3; n2 = 0;
216 if ( *s4 ==
'\\' ) { s4++; n2++; }
221 if ( *s4 ==
'\\' ) { s4++; n3++; }
224 s4 = (UBYTE *)Malloc1((n1+n2+n3+1)*
sizeof(UBYTE),
"environment in setup");
226 while ( n1-- > 0 ) *s6++ = *s5++;
228 while ( n2-- > 0 ) *s6++ = *s5++;
230 while ( n3-- > 0 ) *s6++ = *s5++;
232 if ( giveback ) M_free(s2,
"environment in setup");
245 if ( *s2 ==
'K' ) { x = x * 1000; s2++; }
246 else if ( *s2 ==
'M' ) { x = x * 1000000; s2++; }
247 else if ( *s2 ==
'G' ) { x = x * 1000000000; s2++; }
248 else if ( *s2 ==
'T' ) { x = x * 1000000000000; s2++; }
249 if ( *s2 && *s2 !=
' ' && *s2 !=
'\t' ) {
250 MesPrint(
"%s: Numerical value expected for parameter %s" 251 ,proop1[filetype],s1);
255 sp->flags = USEDFLAG;
258 if ( StrICmp(s1,(UBYTE *)
"tempsortdir") == 0 ) AM.havesortdir = 1;
261 if ( *s ==
' ' || *s ==
'\t' )
break;
262 if ( *s ==
'\\' ) s++;
266 if ( sp->flags == USEDFLAG && sp->value != 0 )
267 M_free((VOID *)(sp->value),
"Process option");
268 sp->value = (LONG)strDup1(s2,
"Process option");
269 sp->flags = USEDFLAG;
272 if ( StrICmp(s1,(UBYTE *)
"incdir") == 0 ) {
275 else if ( StrICmp(s1,(UBYTE *)
"path") == 0 ) {
276 if ( AM.Path ) M_free(AM.Path,
"path");
280 MesPrint(
"Setups: %s not yet implemented",s1);
284 if ( sp->flags == USEDFLAG && sp->value != 0 )
285 M_free((VOID *)(sp->value),
"Process option");
286 sp->value = (LONG)strDup1(s2,
"Process option");
287 sp->flags = USEDFLAG;
290 if ( tolower(*s2) ==
'o' && tolower(s2[1]) ==
'n' 291 && ( s2[2] == 0 || s2[2] ==
' ' || s2[2] ==
'\t' ) )
293 else if ( tolower(*s2) ==
'o' && tolower(s2[1]) ==
'f' 294 && tolower(s2[2]) ==
'f' 295 && ( s2[3] == 0 || s2[3] ==
' ' || s2[3] ==
'\t' ) )
298 MesPrint(
"%s: Unrecognized option for parameter %s: %s" 299 ,proop1[filetype],s1,s2);
302 sp->flags = USEDFLAG;
312 Error1(
"Error in setupparameter table for:",s1);
318 MesPrint(
"%s: Keyword not recognized: %s",proop1[filetype],s1);
321 if ( giveback ) M_free(s2ret,
"environment in setup");
336 med = ( hi + lo ) / 2;
337 i = StrICmp(s,(UBYTE *)setupparameters[med].parameter);
338 if ( i == 0 )
return(setupparameters+med);
339 if ( i < 0 ) hi = med-1;
341 }
while ( hi >= lo );
354 sp1 = GetSetupPar((UBYTE *)
"threads");
355 if ( AM.totalnumberofthreads > 1 ) sp1->value = AM.totalnumberofthreads - 1;
361 sp = GetSetupPar((UBYTE *)
"filepatches");
362 if ( sp->value < AM.totalnumberofthreads-1 )
363 sp->value = AM.totalnumberofthreads - 1;
365 sp = GetSetupPar((UBYTE *)
"smallsize");
366 sp1 = GetSetupPar((UBYTE *)
"smallextension");
367 if ( 6*sp1->value < 7*sp->value ) sp1->value = (7*sp->value)/6;
368 sp = GetSetupPar((UBYTE *)
"termsinsmall");
369 sp->value = ( sp->value + 15 ) & (-16L);
373 LONG totalsize, minimumsize;
374 sp = GetSetupPar((UBYTE *)
"largesize");
375 totalsize = sp1->value+sp->value;
376 sp2 = GetSetupPar((UBYTE *)
"maxtermsize");
377 AM.MaxTer = sp2->value*
sizeof(WORD);
378 if ( AM.MaxTer < 200*(LONG)(
sizeof(WORD)) ) AM.MaxTer = 200*(LONG)(
sizeof(WORD));
379 if ( AM.MaxTer > MAXPOSITIVE - 200*(LONG)(
sizeof(WORD)) ) AM.MaxTer = MAXPOSITIVE - 200*(LONG)(
sizeof(WORD));
380 AM.MaxTer /=
sizeof(WORD);
381 AM.MaxTer *=
sizeof(WORD);
382 minimumsize = (AM.totalnumberofthreads-1)*(AM.MaxTer+
383 NUMBEROFBLOCKSINSORT*MINIMUMNUMBEROFTERMS*AM.MaxTer);
384 if ( totalsize < minimumsize ) {
385 sp->value = minimumsize - sp1->value;
400 LONG LargeSize, SmallSize, SmallEsize, TermsInSmall, IOsize;
401 int MaxPatches, MaxFpatches, error = 0, i, size;
406 sp = GetSetupPar((UBYTE *)
"threads");
407 if ( sp->value > 0 ) AM.totalnumberofthreads = sp->value+1;
409 AM.OutBuffer = (UBYTE *)Malloc1(AM.OutBufSize+1,
"OutputBuffer");
410 AP.PreAssignStack =(LONG *)Malloc1(AP.MaxPreAssignLevel*
sizeof(LONG *),
"PreAssignStack");
411 for ( i = 0; i < AP.MaxPreAssignLevel; i++ ) AP.PreAssignStack[i] = 0;
412 AC.iBuffer = (UBYTE *)Malloc1(AC.iBufferSize+1,
"statement buffer");
413 AC.iStop = AC.iBuffer + AC.iBufferSize-2;
414 AP.preStart = (UBYTE *)Malloc1(AP.pSize,
"instruction buffer");
415 AP.preStop = AP.preStart + AP.pSize - 3;
418 if ( AP.PreIfStack ) M_free(AP.PreIfStack,
"PreIfStack");
419 AP.PreIfStack = (
int *)Malloc1(AP.MaxPreIfLevel*
sizeof(
int),
420 "Preprocessor if stack");
421 AP.PreIfStack[0] = EXECUTINGIF;
422 sp = GetSetupPar((UBYTE *)
"insidefirst");
423 AM.ginsidefirst = AC.minsidefirst = AC.insidefirst = sp->value;
427 sp = GetSetupPar((UBYTE *)
"maxtermsize");
428 AM.MaxTer = sp->value*
sizeof(WORD);
429 if ( AM.MaxTer < 200*(LONG)(
sizeof(WORD)) ) AM.MaxTer = 200*(LONG)(
sizeof(WORD));
430 if ( AM.MaxTer > MAXPOSITIVE - 200*(LONG)(
sizeof(WORD)) ) AM.MaxTer = MAXPOSITIVE - 200*(LONG)(
sizeof(WORD));
431 AM.MaxTer /= (LONG)
sizeof(WORD);
432 AM.MaxTer *= (LONG)
sizeof(WORD);
436 sp = GetSetupPar((UBYTE *)
"workspace");
437 AM.WorkSize = sp->value;
440 AT.WorkSpace = (WORD *)Malloc1(AM.WorkSize*
sizeof(WORD),(
char *)(sp->parameter));
441 AT.WorkTop = AT.WorkSpace + AM.WorkSize;
442 AT.WorkPointer = AT.WorkSpace;
447 sp = GetSetupPar((UBYTE *)
"constindex");
448 if ( ( sp->value+100+5*WILDOFFSET ) > MAXPOSITIVE ) {
449 MesPrint(
"Setting of %s in setupfile too large",
"constindex");
450 AM.OffsetIndex = MAXPOSITIVE - 5*WILDOFFSET - 100;
451 MesPrint(
"value corrected to maximum allowed: %d",AM.OffsetIndex);
453 else AM.OffsetIndex = sp->value + 1;
454 AC.FixIndices = (WORD *)Malloc1((AM.OffsetIndex)*
sizeof(WORD),(
char *)(sp->parameter));
455 AM.WilInd = AM.OffsetIndex + WILDOFFSET;
456 AM.DumInd = AM.OffsetIndex + 2*WILDOFFSET;
457 AM.IndDum = AM.DumInd + WILDOFFSET;
459 AR.CurDum = AN.IndDum = AM.IndDum;
461 AM.mTraceDum = AM.IndDum + 2*WILDOFFSET;
463 sp = GetSetupPar((UBYTE *)
"parentheses");
464 AM.MaxParLevel = sp->value+1;
465 AC.tokenarglevel = (WORD *)Malloc1((sp->value+1)*
sizeof(WORD),(
char *)(sp->parameter));
469 sp = GetSetupPar((UBYTE *)
"maxnumbersize");
483 if ( sp->value == 0 ) {
484 AM.MaxTal = (AM.MaxTer/
sizeof(WORD)-2)/2;
487 size = ( sp->value + 11 ) & (-4);
488 AM.MaxTal = size - 2;
489 if ( (
size_t)AM.MaxTal > (size_t)((AM.MaxTer/
sizeof(WORD)-2)/2) )
490 AM.MaxTal = (AM.MaxTer/
sizeof(WORD)-2)/2;
492 AM.MaxTal &= -
sizeof(WORD)*2;
494 sp->value = AM.MaxTal;
495 AC.cmod = (UWORD *)Malloc1(AM.MaxTal*4*
sizeof(UWORD),(
char *)(sp->parameter));
496 AM.gcmod = AC.cmod + AM.MaxTal;
497 AC.powmod = AM.gcmod + AM.MaxTal;
498 AM.gpowmod = AC.powmod + AM.MaxTal;
504 sp = GetSetupPar((UBYTE *)
"scratchsize");
505 AM.ScratSize = sp->value/
sizeof(WORD);
506 if ( AM.ScratSize < 4*AM.MaxTer ) AM.ScratSize = 4*AM.MaxTer;
507 AM.HideSize = AM.ScratSize;
508 sp = GetSetupPar((UBYTE *)
"hidesize");
509 if ( sp->value > 0 ) {
510 AM.HideSize = sp->value/
sizeof(WORD);
511 if ( AM.HideSize < 4*AM.MaxTer ) AM.HideSize = 4*AM.MaxTer;
513 sp = GetSetupPar((UBYTE *)
"factorizationcache");
514 AM.fbuffersize = sp->value;
516 sp = GetSetupPar((UBYTE *)
"threadscratchsize");
517 AM.ThreadScratSize = sp->value/
sizeof(WORD);
518 sp = GetSetupPar((UBYTE *)
"threadscratchoutsize");
519 AM.ThreadScratOutSize = sp->value/
sizeof(WORD);
522 for ( j = 0; j < 2; j++ ) {
524 ScratchBuf = (WORD *)Malloc1(AM.ScratSize*
sizeof(WORD),
"scratchsize");
525 AR.Fscr[j].POsize = AM.ScratSize *
sizeof(WORD);
526 AR.Fscr[j].POfull = AR.Fscr[j].POfill = AR.Fscr[j].PObuffer = ScratchBuf;
527 AR.Fscr[j].POstop = AR.Fscr[j].PObuffer + AM.ScratSize;
528 PUTZERO(AR.Fscr[j].POposition);
530 AR.Fscr[2].PObuffer = 0;
532 sp = GetSetupPar((UBYTE *)
"threadbucketsize");
533 AC.ThreadBucketSize = AM.gThreadBucketSize = AM.ggThreadBucketSize = sp->value;
534 sp = GetSetupPar((UBYTE *)
"threadloadbalancing");
535 AC.ThreadBalancing = AM.gThreadBalancing = AM.ggThreadBalancing = sp->value;
536 sp = GetSetupPar((UBYTE *)
"threadsortfilesynch");
537 AC.ThreadSortFileSynch = AM.gThreadSortFileSynch = AM.ggThreadSortFileSynch = sp->value;
541 sp = GetSetupPar((UBYTE *)
"shmwinsize");
542 AM.shmWinSize = sp->value/
sizeof(WORD);
543 if ( AM.shmWinSize < 4*AM.MaxTer ) AM.shmWinSize = 4*AM.MaxTer;
547 sp = GetSetupPar((UBYTE *)
"smallsize");
548 SmallSize = sp->value;
549 sp = GetSetupPar((UBYTE *)
"smallextension");
550 SmallEsize = sp->value;
551 sp = GetSetupPar((UBYTE *)
"largesize");
552 LargeSize = sp->value;
553 sp = GetSetupPar((UBYTE *)
"termsinsmall");
554 TermsInSmall = sp->value;
555 sp = GetSetupPar((UBYTE *)
"largepatches");
556 MaxPatches = sp->value;
557 sp = GetSetupPar((UBYTE *)
"filepatches");
558 MaxFpatches = sp->value;
559 sp = GetSetupPar((UBYTE *)
"sortiosize");
561 if ( IOsize < AM.MaxTer ) { IOsize = AM.MaxTer; sp->value = IOsize; }
564 for ( j = 0; j < 2; j++ ) { AR.Fscr[j].ziosize = IOsize; }
568 AM.S0 = AllocSort(LargeSize,SmallSize,SmallEsize,TermsInSmall
569 ,MaxPatches,MaxFpatches,IOsize);
571 AM.S0->file.ziosize = IOsize;
573 AR.FoStage4[0].ziosize = IOsize;
574 AR.FoStage4[1].ziosize = IOsize;
583 AR.FoStage4[0].POsize = ((IOsize+
sizeof(WORD)-1)/
sizeof(WORD))*
sizeof(WORD);
584 AR.FoStage4[1].POsize = ((IOsize+
sizeof(WORD)-1)/
sizeof(WORD))*
sizeof(WORD);
586 sp = GetSetupPar((UBYTE *)
"subsmallsize");
587 AM.SSmallSize = sp->value;
588 sp = GetSetupPar((UBYTE *)
"subsmallextension");
589 AM.SSmallEsize = sp->value;
590 sp = GetSetupPar((UBYTE *)
"sublargesize");
591 AM.SLargeSize = sp->value;
592 sp = GetSetupPar((UBYTE *)
"subtermsinsmall");
593 AM.STermsInSmall = sp->value;
594 sp = GetSetupPar((UBYTE *)
"sublargepatches");
595 AM.SMaxPatches = sp->value;
596 sp = GetSetupPar((UBYTE *)
"subfilepatches");
597 AM.SMaxFpatches = sp->value;
598 sp = GetSetupPar((UBYTE *)
"subsortiosize");
599 AM.SIOsize = sp->value;
600 sp = GetSetupPar((UBYTE *)
"spectatorsize");
601 AM.SpectatorSize = sp->value;
607 sp = GetSetupPar((UBYTE *)
"functionlevels");
608 AM.maxFlevels = sp->value + 1;
611 AT.Nest = (
NESTING)Malloc1((LONG)
sizeof(
struct NeStInG)*AM.maxFlevels,
"functionlevels");
612 AT.NestStop = AT.Nest + AM.maxFlevels;
613 AT.NestPoin = AT.Nest;
616 sp = GetSetupPar((UBYTE *)
"maxwildcards");
617 AM.MaxWildcards = sp->value;
620 AT.WildMask = (WORD *)Malloc1((LONG)AM.MaxWildcards*
sizeof(WORD),
"maxwildcards");
623 sp = GetSetupPar((UBYTE *)
"compresssize");
624 if ( sp->value < 2*AM.MaxTer ) sp->value = 2*AM.MaxTer;
625 AM.CompressSize = sp->value;
627 AR.CompressBuffer = (WORD *)Malloc1((AM.CompressSize+10)*
sizeof(WORD),
"compresssize");
628 AR.CompressPointer = AR.CompressBuffer;
629 AR.ComprTop = AR.CompressBuffer + AM.CompressSize;
631 sp = GetSetupPar((UBYTE *)
"bracketindexsize");
632 if ( sp->value < 20*AM.MaxTer ) sp->value = 20*AM.MaxTer;
633 AM.MaxBracketBufferSize = sp->value/
sizeof(WORD);
635 sp = GetSetupPar((UBYTE *)
"dotchar");
636 AO.FortDotChar = ((UBYTE *)(sp->value))[0];
637 sp = GetSetupPar((UBYTE *)
"commentchar");
638 AP.cComChar = AP.ComChar = ((UBYTE *)(sp->value))[0];
639 sp = GetSetupPar((UBYTE *)
"procedureextension");
643 s = (UBYTE *)(sp->value);
644 if ( FG.cTable[*s] != 0 ) {
645 MesPrint(
" Illegal string for procedure extension %s",(UBYTE *)sp->value);
651 if ( *s ==
' ' || *s ==
'\t' || *s ==
'\n' ) {
652 MesPrint(
" Illegal string for procedure extension %s",(UBYTE *)sp->value);
659 AP.cprocedureExtension = strDup1((UBYTE *)(sp->value),
"procedureExtension");
660 AP.procedureExtension = strDup1(AP.cprocedureExtension,
"procedureExtension");
662 sp = GetSetupPar((UBYTE *)
"totalsize");
663 if ( sp->value != 2 ) AM.PrintTotalSize = sp->value;
665 sp = GetSetupPar((UBYTE *)
"continuationlines");
666 AM.FortranCont = sp->value;
667 if ( AM.FortranCont <= 0 ) AM.FortranCont = 1;
668 sp = GetSetupPar((UBYTE *)
"oldorder");
669 AM.OldOrderFlag = sp->value;
670 sp = GetSetupPar((UBYTE *)
"resettimeonclear");
671 AM.resetTimeOnClear = sp->value;
672 sp = GetSetupPar((UBYTE *)
"nospacesinnumbers");
673 AO.NoSpacesInNumbers = AM.gNoSpacesInNumbers = AM.ggNoSpacesInNumbers = sp->value;
674 sp = GetSetupPar((UBYTE *)
"indentspace");
675 AO.IndentSpace = AM.gIndentSpace = AM.ggIndentSpace = sp->value;
676 sp = GetSetupPar((UBYTE *)
"nwritestatistics");
677 AC.StatsFlag = AM.gStatsFlag = AM.ggStatsFlag = 1-sp->value;
678 sp = GetSetupPar((UBYTE *)
"nwritefinalstatistics");
679 AC.FinalStats = AM.gFinalStats = AM.ggFinalStats = 1-sp->value;
680 sp = GetSetupPar((UBYTE *)
"nwritethreadstatistics");
681 AC.ThreadStats = AM.gThreadStats = AM.ggThreadStats = 1-sp->value;
682 sp = GetSetupPar((UBYTE *)
"nwriteprocessstatistics");
683 AC.ProcessStats = AM.gProcessStats = AM.ggProcessStats = 1-sp->value;
684 sp = GetSetupPar((UBYTE *)
"oldparallelstatistics");
685 AC.OldParallelStats = AM.gOldParallelStats = AM.ggOldParallelStats = sp->value;
686 sp = GetSetupPar((UBYTE *)
"oldfactarg");
687 AC.OldFactArgFlag = AM.gOldFactArgFlag = AM.ggOldFactArgFlag = sp->value;
688 sp = GetSetupPar((UBYTE *)
"oldgcd");
689 AC.OldGCDflag = AM.gOldGCDflag = AM.ggOldGCDflag = sp->value;
690 sp = GetSetupPar((UBYTE *)
"wtimestats");
691 if ( sp->value == 2 ) sp->value = AM.ggWTimeStatsFlag;
692 AC.WTimeStatsFlag = AM.gWTimeStatsFlag = AM.ggWTimeStatsFlag = sp->value;
693 sp = GetSetupPar((UBYTE *)
"sorttype");
694 if ( StrICmp((UBYTE *)
"lowfirst",(UBYTE *)sp->value) == 0 ) {
695 AC.lSortType = SORTLOWFIRST;
697 else if ( StrICmp((UBYTE *)
"highfirst",(UBYTE *)sp->value) == 0 ) {
698 AC.lSortType = SORTHIGHFIRST;
701 MesPrint(
" Illegal SortType specification: %s",(UBYTE *)sp->value);
705 sp = GetSetupPar((UBYTE *)
"processbucketsize");
706 AM.hProcessBucketSize = AM.gProcessBucketSize =
707 AC.ProcessBucketSize = AC.mProcessBucketSize = sp->value;
711 sp = GetSetupPar((UBYTE *)
"numstorecaches");
712 AM.NumStoreCaches = sp->value;
713 sp = GetSetupPar((UBYTE *)
"sizestorecache");
714 AM.SizeStoreCache = sp->value;
720 AT.StoreCache = AT.StoreCacheAlloc = 0;
721 if ( AM.NumStoreCaches > 0 ) {
723 size =
sizeof(
struct StOrEcAcHe)+AM.SizeStoreCache;
724 size = ((size-1)/
sizeof(
size_t)+1)*
sizeof(
size_t);
725 AT.StoreCacheAlloc = (
STORECACHE)Malloc1(size*AM.NumStoreCaches,
"StoreCaches");
726 AT.StoreCache = AT.StoreCacheAlloc;
728 for ( j = 0; j < AM.NumStoreCaches; j++ ) {
730 if ( j == AM.NumStoreCaches-1 ) {
736 SETBASEPOSITION(sa->position,-1);
737 SETBASEPOSITION(sa->toppos,-1);
746 if ( AM.Path == 0 ) {
747 sp = GetSetupPar((UBYTE *)
"path");
748 AM.Path = strDup1((UBYTE *)(sp->value),
"path");
750 if ( AM.IncDir == 0 ) {
751 sp = GetSetupPar((UBYTE *)
"incdir");
752 AM.IncDir = strDup1((UBYTE *)(sp->value),
"incdir");
784 MesPrint(
" The setup parameters are:");
785 for ( sp = setupparameters; n > 0; n--, sp++ ) {
788 MesPrint(
" %s: %l",sp->parameter,sp->value);
791 if ( StrICmp(sp->parameter,(UBYTE *)
"path") == 0 && AM.Path ) {
792 MesPrint(
" %s: '%s'",sp->parameter,(UBYTE *)(AM.Path));
795 if ( StrICmp(sp->parameter,(UBYTE *)
"incdir") == 0 && AM.IncDir ) {
796 MesPrint(
" %s: '%s'",sp->parameter,(UBYTE *)(AM.IncDir));
800 if ( StrICmp(sp->parameter,(UBYTE *)
"tempdir") == 0 && AM.TempDir ) {
801 MesPrint(
" %s: '%s'",sp->parameter,(UBYTE *)(AM.TempDir));
803 else if ( StrICmp(sp->parameter,(UBYTE *)
"tempsortdir") == 0 && AM.TempSortDir ) {
804 MesPrint(
" %s: '%s'",sp->parameter,(UBYTE *)(AM.TempSortDir));
807 MesPrint(
" %s: '%s'",sp->parameter,(UBYTE *)(sp->value));
811 if ( sp->value == 0 )
812 MesPrint(
" %s: OFF",sp->parameter);
813 else if ( sp->value == 1 )
814 MesPrint(
" %s: ON",sp->parameter);
835 SORTING *AllocSort(LONG LargeSize, LONG SmallSize, LONG SmallEsize, LONG TermsInSmall,
836 int MaxPatches,
int MaxFpatches, LONG IOsize)
838 LONG allocation,longer,terms2insmall,sortsize,longerp;
839 LONG IObuffersize = IOsize;
845 s = FG.fname2; i = 0;
846 while ( *s ) { s++; i++; }
849 if ( MaxFpatches < 4 ) MaxFpatches = 4;
850 longer = MaxPatches > MaxFpatches ? MaxPatches : MaxFpatches;
852 while ( (1 << j) < longerp ) j++;
853 longerp = (1 << j) + 1;
854 longerp +=
sizeof(WORD*) - (longerp%
sizeof(WORD *));
856 longer +=
sizeof(WORD*) - (longer%
sizeof(WORD *));
857 if ( SmallSize < 16*AM.MaxTer ) SmallSize = 16*AM.MaxTer+16;
858 TermsInSmall = (TermsInSmall+15) & (-16L);
859 terms2insmall = 2*TermsInSmall;
860 if ( SmallEsize < (SmallSize*3)/2 ) SmallEsize = (SmallSize*3)/2;
861 if ( LargeSize > 0 && LargeSize < 2*SmallSize ) LargeSize = 2*SmallSize;
863 SmallEsize = (SmallEsize+15) & (-16L);
864 if ( LargeSize < 0 ) LargeSize = 0;
866 sortsize = (sortsize+15)&(-16L);
867 IObuffersize = (IObuffersize+
sizeof(WORD)-1)/
sizeof(WORD);
873 if ( (ULONG)( LargeSize+SmallEsize ) < MaxFpatches*((IObuffersize
874 +COMPINC)*
sizeof(WORD)+2*AM.MaxTer) ) {
875 if ( LargeSize == 0 )
876 SmallEsize = MaxFpatches*((IObuffersize+COMPINC)*
sizeof(WORD)+2*AM.MaxTer);
878 LargeSize = MaxFpatches*((IObuffersize+COMPINC)*
sizeof(WORD)+2*AM.MaxTer)
882 IOtry = ((LargeSize+SmallEsize)/MaxFpatches-2*AM.MaxTer)/
sizeof(WORD)-COMPINC;
884 if ( (LONG)(IObuffersize*
sizeof(WORD)) < IOtry )
885 IObuffersize = (IOtry+
sizeof(WORD)-1)/
sizeof(WORD);
889 +2*
sizeof(WORD *)*longer
890 +2*(longerp*(
sizeof(WORD *)+
sizeof(WORD)))
891 +(3*longerp+2)*
sizeof(WORD)
893 +(2*longerp+4)*
sizeof(WORD)
895 +terms2insmall*
sizeof(WORD *)
896 +terms2insmall*
sizeof(WORD *)/2
900 +IObuffersize*
sizeof(WORD) + i + 16;
901 sort = (
SORTING *)Malloc1(allocation,
"sort buffers");
903 sort->LargeSize = LargeSize/
sizeof(WORD);
904 sort->SmallSize = SmallSize/
sizeof(WORD);
905 sort->SmallEsize = SmallEsize/
sizeof(WORD);
906 sort->MaxPatches = MaxPatches;
907 sort->MaxFpatches = MaxFpatches;
908 sort->TermsInSmall = TermsInSmall;
909 sort->Terms2InSmall = terms2insmall;
911 sort->sPointer = (WORD **)(sort+1);
912 sort->SplitScratch = sort->sPointer + terms2insmall;
913 sort->Patches = (WORD **)(sort->SplitScratch + terms2insmall/2);
914 sort->pStop = sort->Patches+longer;
915 sort->poina = sort->pStop+longer;
916 sort->poin2a = sort->poina + longerp;
917 sort->fPatches = (
POSITION *)(sort->poin2a+longerp);
918 sort->fPatchesStop = sort->fPatches + longer;
919 sort->inPatches = sort->fPatchesStop + longer;
920 sort->tree = (WORD *)(sort->inPatches + longer);
921 sort->used = sort->tree+longerp;
923 sort->fpcompressed = sort->used+longerp;
924 sort->fpincompressed = sort->fpcompressed+longerp+2;
925 sort->ktoi = sort->fpincompressed+longerp+2;
928 sort->ktoi = sort->used + longerp;
930 sort->lBuffer = (WORD *)(sort->ktoi + longerp + 2);
931 sort->lTop = sort->lBuffer+sort->LargeSize;
932 sort->sBuffer = sort->lTop;
933 if ( sort->LargeSize == 0 ) { sort->lBuffer = 0; sort->lTop = 0; }
934 sort->sTop = sort->sBuffer + sort->SmallSize;
935 sort->sTop2 = sort->sBuffer + sort->SmallEsize;
936 sort->sHalf = sort->sBuffer + (LONG)((sort->SmallSize+sort->SmallEsize)>>1);
937 sort->file.PObuffer = (WORD *)(sort->sTop2);
938 sort->file.POstop = sort->file.PObuffer+IObuffersize;
939 sort->file.POsize = IObuffersize *
sizeof(WORD);
940 sort->file.POfill = sort->file.POfull = sort->file.PObuffer;
941 sort->file.active = 0;
943 PUTZERO(sort->file.POposition);
945 sort->file.pthreadslock = dummylock;
949 sort->file.ziosize = IObuffersize*
sizeof(WORD);
952 sort->file.name = (
char *)(sort->file.PObuffer + IObuffersize);
953 AllocSortFileName(sort);
955 else sort->file.name = 0;
957 sort->cBufferSize = 0;
968 VOID AllocSortFileName(
SORTING *sort)
976 s = FG.fname2; t = sort->file.name;
977 while ( *s ) *t++ = *s++;
980 sprintf(t-1,
"%d.%d",identity,AN.filenum);
983 sprintf(t-1,
"%d",AN.filenum);
993 FILEHANDLE *AllocFileHandle(WORD par,
char *name)
996 LONG allocation, Ssize;
1001 s = FG.fname2; i = 0;
1002 while ( *s ) { s++; i++; }
1003 if ( par == 0 ) { i += 16; Ssize = AM.SIOsize; }
1004 else { s = name;
while ( *s ) { i++; s++; } i+= 2; Ssize = AM.SpectatorSize; }
1006 allocation =
sizeof(
FILEHANDLE) + (Ssize+1)*
sizeof(WORD) + i*
sizeof(
char);
1007 fh = (
FILEHANDLE *)Malloc1(allocation,
"FileHandle");
1009 fh->PObuffer = (WORD *)(fh+1);
1010 fh->POstop = fh->PObuffer+Ssize;
1011 fh->POsize = Ssize *
sizeof(WORD);
1014 PUTZERO(fh->POposition);
1016 fh->pthreadslock = dummylock;
1020 fh->name = (
char *)(fh->POstop + 1);
1021 s = FG.fname2; t = fh->name;
1022 while ( *s ) *t++ = *s++;
1025 sprintf(t-1,
"%d-%d",identity,AN.filenum);
1028 sprintf(t-1,
"%d",AN.filenum);
1035 fh->name = (
char *)(fh->POstop + 1);
1036 s = FG.fname; t = fh->name;
1037 for ( i = 0; i < FG.fnamebase; i++ ) *t++ = *s++;
1039 while ( *s ) *t++ = *s++;
1042 fh->POfill = fh->POfull = fh->PObuffer;
1062 M_free(fh,
"Temporary FileHandle");
1070 int MakeSetupAllocs()
1072 if ( RecalcSetups() || AllocSetups() )
return(1);
1088 #define SETBUFSIZE 257 1092 LONG oldstreamposition;
1094 int error = 0, eqnum;
1095 int oldNoShowInput = AC.NoShowInput;
1096 UBYTE buff[SETBUFSIZE+1], *s, *t, *u, *settop, c;
1097 LONG linenum, prevline;
1099 if ( AC.CurrentStream == 0 )
return(error);
1100 oldstream = AC.CurrentStream - AC.Streams;
1101 oldstreamposition = GetStreamPosition(AC.CurrentStream);
1102 linenum = AC.CurrentStream->linenumber;
1103 prevline = AC.CurrentStream->prevline;
1104 eqnum = AC.CurrentStream->eqnum;
1106 settop = buff + SETBUFSIZE;
1109 if ( c ==
'*' || c ==
'\n' ) {
1110 while ( c !=
'\n' && c != ENDOFINPUT ) c = GetInput();
1111 if ( c == ENDOFINPUT )
goto eoi;
1114 if ( c == ENDOFINPUT )
goto eoi;
1115 if ( c !=
'#' )
break;
1117 if ( c == ENDOFINPUT )
goto eoi;
1118 if ( c !=
'-' && c !=
'+' && c !=
':' )
break;
1120 while ( c !=
'\n' && c != ENDOFINPUT ) c = GetInput();
1124 while ( ( c = GetInput() ) ==
' ' || c ==
'\t' || c ==
'\r' ) {}
1125 if ( c == ENDOFINPUT )
break;
1126 if ( c == LINEFEED )
continue;
1127 if ( c == 0 || c == ENDOFINPUT )
break;
1128 while ( c != LINEFEED ) {
1131 if ( c != LINEFEED && c !=
'\r' )
continue;
1132 if ( s >= settop ) {
1133 while ( c !=
'\n' && c != ENDOFINPUT ) c = GetInput();
1134 MesPrint(
"Setups in .frm file: Line too long. setup ignored");
1135 error++;
goto nextline;
1140 while ( tolower(*s) >=
'a' && tolower(*s) <=
'z' ) s++;
1143 while ( *s ==
' ' || *s ==
'\t' ) s++;
1145 while ( *s && *s !=
'\n' && *s !=
'\r' ) s++;
1153 error += ProcessOption(t,u,1);
1156 AC.NoShowInput = oldNoShowInput;
1157 AC.CurrentStream = AC.Streams + oldstream;
1158 PositionStream(AC.CurrentStream,oldstreamposition);
1159 AC.CurrentStream->linenumber = linenum;
1160 AC.CurrentStream->prevline = prevline;
1161 AC.CurrentStream->eqnum = eqnum;
1165 MesPrint(
"Input file without a program.");
1174 int TryEnvironment()
1176 char *s, *t, *u, varname[100];
1179 varname[0] =
'F'; varname[1] =
'O'; varname[2] =
'R'; varname[3] =
'M';
1180 varname[4] =
'_'; varname[5] = 0;
1181 for ( i = 0; i < imax; i++ ) {
1182 t = s = (
char *)(setupparameters[i].parameter);
1184 while ( *s ) { *u++ = (char)(toupper((
unsigned char)*s)); s++; }
1186 s = (
char *)(getenv(varname));
1188 error += ProcessOption((UBYTE *)t,(UBYTE *)s,2);
struct StOrEcAcHe * STORECACHE
int TheDefine(UBYTE *, int)