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 *)
"jumpratio", NUMERICALVALUE, 0, (LONG)JUMPRATIO}
70 ,{(UBYTE *)
"largepatches", NUMERICALVALUE, 0, (LONG)MAXPATCHES}
71 ,{(UBYTE *)
"largesize", NUMERICALVALUE, 0, (LONG)LARGEBUFFER}
72 ,{(UBYTE *)
"maxnumbersize", NUMERICALVALUE, 0, (LONG)0}
74 ,{(UBYTE *)
"maxtermsize", NUMERICALVALUE, 0, (LONG)MAXTER}
75 ,{(UBYTE *)
"maxwildcards", NUMERICALVALUE, 0, (LONG)MAXWILDC}
76 ,{(UBYTE *)
"nospacesinnumbers", ONOFFVALUE, 0, (LONG)0}
77 ,{(UBYTE *)
"numstorecaches", NUMERICALVALUE, 0, (LONG)NUMSTORECACHES}
78 ,{(UBYTE *)
"nwritefinalstatistics", ONOFFVALUE, 0, (LONG)0}
79 ,{(UBYTE *)
"nwriteprocessstatistics", ONOFFVALUE, 0, (LONG)0}
80 ,{(UBYTE *)
"nwritestatistics", ONOFFVALUE, 0, (LONG)0}
81 ,{(UBYTE *)
"nwritethreadstatistics", ONOFFVALUE, 0, (LONG)0}
82 ,{(UBYTE *)
"oldfactarg", ONOFFVALUE, 0, (LONG)NEWFACTARG}
83 ,{(UBYTE *)
"oldgcd", ONOFFVALUE, 0, (LONG)1}
84 ,{(UBYTE *)
"oldorder", ONOFFVALUE, 0, (LONG)0}
85 ,{(UBYTE *)
"oldparallelstatistics", ONOFFVALUE, 0, (LONG)0}
86 ,{(UBYTE *)
"parentheses", NUMERICALVALUE, 0, (LONG)MAXPARLEVEL}
87 ,{(UBYTE *)
"path", PATHVALUE, 0, (LONG)curdirp}
88 ,{(UBYTE *)
"procedureextension", STRINGVALUE, 0, (LONG)procedureextension}
89 ,{(UBYTE *)
"processbucketsize", NUMERICALVALUE, 0, (LONG)DEFAULTPROCESSBUCKETSIZE}
90 ,{(UBYTE *)
"resettimeonclear", ONOFFVALUE, 0, (LONG)1}
91 ,{(UBYTE *)
"scratchsize", NUMERICALVALUE, 0, (LONG)SCRATCHSIZE}
92 ,{(UBYTE *)
"shmwinsize", NUMERICALVALUE, 0, (LONG)SHMWINSIZE}
93 ,{(UBYTE *)
"sizestorecache", NUMERICALVALUE, 0, (LONG)SIZESTORECACHE}
94 ,{(UBYTE *)
"smallextension", NUMERICALVALUE, 0, (LONG)SMALLOVERFLOW}
95 ,{(UBYTE *)
"smallsize", NUMERICALVALUE, 0, (LONG)SMALLBUFFER}
96 ,{(UBYTE *)
"sortiosize", NUMERICALVALUE, 0, (LONG)SORTIOSIZE}
97 ,{(UBYTE *)
"sorttype", STRINGVALUE, 0, (LONG)lowfirst}
98 ,{(UBYTE *)
"spectatorsize", NUMERICALVALUE, 0, (LONG)SPECTATORSIZE}
99 ,{(UBYTE *)
"subfilepatches", NUMERICALVALUE, 0, (LONG)SMAXFPATCHES}
100 ,{(UBYTE *)
"sublargepatches", NUMERICALVALUE, 0, (LONG)SMAXPATCHES}
101 ,{(UBYTE *)
"sublargesize", NUMERICALVALUE, 0, (LONG)SLARGEBUFFER}
102 ,{(UBYTE *)
"subsmallextension", NUMERICALVALUE, 0, (LONG)SSMALLOVERFLOW}
103 ,{(UBYTE *)
"subsmallsize", NUMERICALVALUE, 0, (LONG)SSMALLBUFFER}
104 ,{(UBYTE *)
"subsortiosize", NUMERICALVALUE, 0, (LONG)SSORTIOSIZE}
105 ,{(UBYTE *)
"subtermsinsmall", NUMERICALVALUE, 0, (LONG)STERMSSMALL}
106 ,{(UBYTE *)
"tempdir", STRINGVALUE, 0, (LONG)curdirp}
107 ,{(UBYTE *)
"tempsortdir", STRINGVALUE, 0, (LONG)cursortdirp}
108 ,{(UBYTE *)
"termsinsmall", NUMERICALVALUE, 0, (LONG)TERMSSMALL}
109 ,{(UBYTE *)
"threadbucketsize", NUMERICALVALUE, 0, (LONG)DEFAULTTHREADBUCKETSIZE}
110 ,{(UBYTE *)
"threadloadbalancing", ONOFFVALUE, 0, (LONG)DEFAULTTHREADLOADBALANCING}
111 ,{(UBYTE *)
"threads", NUMERICALVALUE, 0, (LONG)DEFAULTTHREADS}
112 ,{(UBYTE *)
"threadscratchoutsize", NUMERICALVALUE, 0, (LONG)THREADSCRATCHOUTSIZE}
113 ,{(UBYTE *)
"threadscratchsize", NUMERICALVALUE, 0, (LONG)THREADSCRATCHSIZE}
114 ,{(UBYTE *)
"threadsortfilesynch", ONOFFVALUE, 0, (LONG)0}
115 ,{(UBYTE *)
"totalsize", ONOFFVALUE, 0, (LONG)2}
116 ,{(UBYTE *)
"workspace", NUMERICALVALUE, 0, (LONG)WORKBUFFER}
117 ,{(UBYTE *)
"wtimestats", ONOFFVALUE, 0, (LONG)2}
128 UBYTE *setbuffer, *s, *t, *u ;
130 setbuffer = LoadInputFile((UBYTE *)setupfilename,SETUPFILE);
139 if ( *s ==
' ' || *s ==
'\t' || *s ==
'*' || *s ==
'#' || *s ==
'\n' ) {
140 while ( *s && *s !=
'\n' ) s++;
142 else if ( tolower(*s) <
'a' || tolower(*s) >
'z' ) {
144 while ( *s && *s !=
'\n' ) s++;
153 while ( tolower(*s) >=
'a' && tolower(*s) <=
'z' ) s++;
155 while ( *s ==
' ' || *s ==
'\t' ) s++;
157 while ( *s && *s !=
'\n' && *s !=
'\r' ) s++;
159 errors += ProcessOption(t,u,0);
161 while ( *s ==
'\n' || *s ==
'\r' ) s++;
163 M_free(setbuffer,
"setup file buffer");
165 if ( errors )
return(1);
174 static char *proop1[3] = {
"Setup file",
"Setups in .frm file",
"Setup in environment" };
176 int ProcessOption(UBYTE *s1, UBYTE *s2,
int filetype)
179 int n, giveback = 0, error = 0;
180 UBYTE *s, *t, *s2ret;
182 sp = GetSetupPar(s1);
190 UBYTE *s3,*s4,*s5,*s6, c, *start;
194 if ( *s ==
'\\' ) s += 2;
195 else if ( *s ==
'`' ) {
197 while ( *s && *s !=
'\'' ) {
198 if ( *s ==
'\\' ) s++;
202 MesPrint(
"%s: Illegal use of ` character for parameter %s"
203 ,proop1[filetype],s1);
207 s3 = (UBYTE *)getenv((
char *)(start+1));
209 MesPrint(
"%s: Cannot find environment variable %s for parameter %s"
210 ,proop1[filetype],start+1,s1);
215 n1 = start - s2; s4 = s3; n2 = 0;
217 if ( *s4 ==
'\\' ) { s4++; n2++; }
222 if ( *s4 ==
'\\' ) { s4++; n3++; }
225 s4 = (UBYTE *)Malloc1((n1+n2+n3+1)*
sizeof(UBYTE),
"environment in setup");
227 while ( n1-- > 0 ) *s6++ = *s5++;
229 while ( n2-- > 0 ) *s6++ = *s5++;
231 while ( n3-- > 0 ) *s6++ = *s5++;
233 if ( giveback ) M_free(s2,
"environment in setup");
246 if ( *s2 ==
'K' ) { x = x * 1000; s2++; }
247 else if ( *s2 ==
'M' ) { x = x * 1000000; s2++; }
248 else if ( *s2 ==
'G' ) { x = x * 1000000000; s2++; }
249 else if ( *s2 ==
'T' ) { x = x * 1000000000000; s2++; }
250 if ( *s2 && *s2 !=
' ' && *s2 !=
'\t' ) {
251 MesPrint(
"%s: Numerical value expected for parameter %s"
252 ,proop1[filetype],s1);
256 sp->flags = USEDFLAG;
259 if ( StrICmp(s1,(UBYTE *)
"tempsortdir") == 0 ) AM.havesortdir = 1;
262 if ( *s ==
' ' || *s ==
'\t' )
break;
263 if ( *s ==
'\\' ) s++;
267 if ( sp->flags == USEDFLAG && sp->value != 0 )
268 M_free((VOID *)(sp->value),
"Process option");
269 sp->value = (LONG)strDup1(s2,
"Process option");
270 sp->flags = USEDFLAG;
273 if ( StrICmp(s1,(UBYTE *)
"incdir") == 0 ) {
276 else if ( StrICmp(s1,(UBYTE *)
"path") == 0 ) {
277 if ( AM.Path ) M_free(AM.Path,
"path");
281 MesPrint(
"Setups: %s not yet implemented",s1);
285 if ( sp->flags == USEDFLAG && sp->value != 0 )
286 M_free((VOID *)(sp->value),
"Process option");
287 sp->value = (LONG)strDup1(s2,
"Process option");
288 sp->flags = USEDFLAG;
291 if ( tolower(*s2) ==
'o' && tolower(s2[1]) ==
'n'
292 && ( s2[2] == 0 || s2[2] ==
' ' || s2[2] ==
'\t' ) )
294 else if ( tolower(*s2) ==
'o' && tolower(s2[1]) ==
'f'
295 && tolower(s2[2]) ==
'f'
296 && ( s2[3] == 0 || s2[3] ==
' ' || s2[3] ==
'\t' ) )
299 MesPrint(
"%s: Unrecognized option for parameter %s: %s"
300 ,proop1[filetype],s1,s2);
303 sp->flags = USEDFLAG;
313 Error1(
"Error in setupparameter table for:",s1);
319 MesPrint(
"%s: Keyword not recognized: %s",proop1[filetype],s1);
322 if ( giveback ) M_free(s2ret,
"environment in setup");
337 med = ( hi + lo ) / 2;
338 i = StrICmp(s,(UBYTE *)setupparameters[med].parameter);
339 if ( i == 0 )
return(setupparameters+med);
340 if ( i < 0 ) hi = med-1;
342 }
while ( hi >= lo );
355 sp1 = GetSetupPar((UBYTE *)
"threads");
356 if ( AM.totalnumberofthreads > 1 ) sp1->value = AM.totalnumberofthreads - 1;
362 sp = GetSetupPar((UBYTE *)
"filepatches");
363 if ( sp->value < AM.totalnumberofthreads-1 )
364 sp->value = AM.totalnumberofthreads - 1;
366 sp = GetSetupPar((UBYTE *)
"smallsize");
367 sp1 = GetSetupPar((UBYTE *)
"smallextension");
368 if ( 6*sp1->value < 7*sp->value ) sp1->value = (7*sp->value)/6;
369 sp = GetSetupPar((UBYTE *)
"termsinsmall");
370 sp->value = ( sp->value + 15 ) & (-16L);
374 LONG totalsize, minimumsize;
375 sp = GetSetupPar((UBYTE *)
"largesize");
376 totalsize = sp1->value+sp->value;
377 sp2 = GetSetupPar((UBYTE *)
"maxtermsize");
378 AM.MaxTer = sp2->value*
sizeof(WORD);
379 if ( AM.MaxTer < 200*(LONG)(
sizeof(WORD)) ) AM.MaxTer = 200*(LONG)(
sizeof(WORD));
380 if ( AM.MaxTer > MAXPOSITIVE - 200*(LONG)(
sizeof(WORD)) ) AM.MaxTer = MAXPOSITIVE - 200*(LONG)(
sizeof(WORD));
381 AM.MaxTer /=
sizeof(WORD);
382 AM.MaxTer *=
sizeof(WORD);
383 minimumsize = (AM.totalnumberofthreads-1)*(AM.MaxTer+
384 NUMBEROFBLOCKSINSORT*MINIMUMNUMBEROFTERMS*AM.MaxTer);
385 if ( totalsize < minimumsize ) {
386 sp->value = minimumsize - sp1->value;
401 LONG LargeSize, SmallSize, SmallEsize, TermsInSmall, IOsize;
402 int MaxPatches, MaxFpatches, error = 0, i, size;
407 sp = GetSetupPar((UBYTE *)
"threads");
408 if ( sp->value > 0 ) AM.totalnumberofthreads = sp->value+1;
410 AM.OutBuffer = (UBYTE *)Malloc1(AM.OutBufSize+1,
"OutputBuffer");
411 AP.PreAssignStack =(LONG *)Malloc1(AP.MaxPreAssignLevel*
sizeof(LONG *),
"PreAssignStack");
412 for ( i = 0; i < AP.MaxPreAssignLevel; i++ ) AP.PreAssignStack[i] = 0;
413 AC.iBuffer = (UBYTE *)Malloc1(AC.iBufferSize+1,
"statement buffer");
414 AC.iStop = AC.iBuffer + AC.iBufferSize-2;
415 AP.preStart = (UBYTE *)Malloc1(AP.pSize,
"instruction buffer");
416 AP.preStop = AP.preStart + AP.pSize - 3;
419 if ( AP.PreIfStack ) M_free(AP.PreIfStack,
"PreIfStack");
420 AP.PreIfStack = (
int *)Malloc1(AP.MaxPreIfLevel*
sizeof(
int),
421 "Preprocessor if stack");
422 AP.PreIfStack[0] = EXECUTINGIF;
423 sp = GetSetupPar((UBYTE *)
"insidefirst");
424 AM.ginsidefirst = AC.minsidefirst = AC.insidefirst = sp->value;
428 sp = GetSetupPar((UBYTE *)
"maxtermsize");
429 AM.MaxTer = sp->value*
sizeof(WORD);
430 if ( AM.MaxTer < 200*(LONG)(
sizeof(WORD)) ) AM.MaxTer = 200*(LONG)(
sizeof(WORD));
431 if ( AM.MaxTer > MAXPOSITIVE - 200*(LONG)(
sizeof(WORD)) ) AM.MaxTer = MAXPOSITIVE - 200*(LONG)(
sizeof(WORD));
432 AM.MaxTer /= (LONG)
sizeof(WORD);
433 AM.MaxTer *= (LONG)
sizeof(WORD);
437 sp = GetSetupPar((UBYTE *)
"workspace");
438 AM.WorkSize = sp->value;
441 AT.WorkSpace = (WORD *)Malloc1(AM.WorkSize*
sizeof(WORD),(
char *)(sp->parameter));
442 AT.WorkTop = AT.WorkSpace + AM.WorkSize;
443 AT.WorkPointer = AT.WorkSpace;
448 sp = GetSetupPar((UBYTE *)
"constindex");
449 if ( ( sp->value+100+5*WILDOFFSET ) > MAXPOSITIVE ) {
450 MesPrint(
"Setting of %s in setupfile too large",
"constindex");
451 AM.OffsetIndex = MAXPOSITIVE - 5*WILDOFFSET - 100;
452 MesPrint(
"value corrected to maximum allowed: %d",AM.OffsetIndex);
454 else AM.OffsetIndex = sp->value + 1;
455 AC.FixIndices = (WORD *)Malloc1((AM.OffsetIndex)*
sizeof(WORD),(
char *)(sp->parameter));
456 AM.WilInd = AM.OffsetIndex + WILDOFFSET;
457 AM.DumInd = AM.OffsetIndex + 2*WILDOFFSET;
458 AM.IndDum = AM.DumInd + WILDOFFSET;
460 AR.CurDum = AN.IndDum = AM.IndDum;
462 AM.mTraceDum = AM.IndDum + 2*WILDOFFSET;
464 sp = GetSetupPar((UBYTE *)
"parentheses");
465 AM.MaxParLevel = sp->value+1;
466 AC.tokenarglevel = (WORD *)Malloc1((sp->value+1)*
sizeof(WORD),(
char *)(sp->parameter));
470 sp = GetSetupPar((UBYTE *)
"maxnumbersize");
484 if ( sp->value == 0 ) {
485 AM.MaxTal = (AM.MaxTer/
sizeof(WORD)-2)/2;
488 size = ( sp->value + 11 ) & (-4);
489 AM.MaxTal = size - 2;
490 if ( (
size_t)AM.MaxTal > (size_t)((AM.MaxTer/
sizeof(WORD)-2)/2) )
491 AM.MaxTal = (AM.MaxTer/
sizeof(WORD)-2)/2;
493 AM.MaxTal &= -
sizeof(WORD)*2;
495 sp->value = AM.MaxTal;
496 AC.cmod = (UWORD *)Malloc1(AM.MaxTal*4*
sizeof(UWORD),(
char *)(sp->parameter));
497 AM.gcmod = AC.cmod + AM.MaxTal;
498 AC.powmod = AM.gcmod + AM.MaxTal;
499 AM.gpowmod = AC.powmod + AM.MaxTal;
505 sp = GetSetupPar((UBYTE *)
"scratchsize");
506 AM.ScratSize = sp->value/
sizeof(WORD);
507 if ( AM.ScratSize < 4*AM.MaxTer ) AM.ScratSize = 4*AM.MaxTer;
508 AM.HideSize = AM.ScratSize;
509 sp = GetSetupPar((UBYTE *)
"hidesize");
510 if ( sp->value > 0 ) {
511 AM.HideSize = sp->value/
sizeof(WORD);
512 if ( AM.HideSize < 4*AM.MaxTer ) AM.HideSize = 4*AM.MaxTer;
514 sp = GetSetupPar((UBYTE *)
"factorizationcache");
515 AM.fbuffersize = sp->value;
517 sp = GetSetupPar((UBYTE *)
"threadscratchsize");
518 AM.ThreadScratSize = sp->value/
sizeof(WORD);
519 sp = GetSetupPar((UBYTE *)
"threadscratchoutsize");
520 AM.ThreadScratOutSize = sp->value/
sizeof(WORD);
523 for ( j = 0; j < 2; j++ ) {
525 ScratchBuf = (WORD *)Malloc1(AM.ScratSize*
sizeof(WORD),
"scratchsize");
526 AR.Fscr[j].POsize = AM.ScratSize *
sizeof(WORD);
527 AR.Fscr[j].POfull = AR.Fscr[j].POfill = AR.Fscr[j].PObuffer = ScratchBuf;
528 AR.Fscr[j].POstop = AR.Fscr[j].PObuffer + AM.ScratSize;
529 PUTZERO(AR.Fscr[j].POposition);
531 AR.Fscr[2].PObuffer = 0;
533 sp = GetSetupPar((UBYTE *)
"threadbucketsize");
534 AC.ThreadBucketSize = AM.gThreadBucketSize = AM.ggThreadBucketSize = sp->value;
535 sp = GetSetupPar((UBYTE *)
"threadloadbalancing");
536 AC.ThreadBalancing = AM.gThreadBalancing = AM.ggThreadBalancing = sp->value;
537 sp = GetSetupPar((UBYTE *)
"threadsortfilesynch");
538 AC.ThreadSortFileSynch = AM.gThreadSortFileSynch = AM.ggThreadSortFileSynch = sp->value;
542 sp = GetSetupPar((UBYTE *)
"shmwinsize");
543 AM.shmWinSize = sp->value/
sizeof(WORD);
544 if ( AM.shmWinSize < 4*AM.MaxTer ) AM.shmWinSize = 4*AM.MaxTer;
548 sp = GetSetupPar((UBYTE *)
"smallsize");
549 SmallSize = sp->value;
550 sp = GetSetupPar((UBYTE *)
"smallextension");
551 SmallEsize = sp->value;
552 sp = GetSetupPar((UBYTE *)
"largesize");
553 LargeSize = sp->value;
554 sp = GetSetupPar((UBYTE *)
"termsinsmall");
555 TermsInSmall = sp->value;
556 sp = GetSetupPar((UBYTE *)
"largepatches");
557 MaxPatches = sp->value;
558 sp = GetSetupPar((UBYTE *)
"filepatches");
559 MaxFpatches = sp->value;
560 sp = GetSetupPar((UBYTE *)
"sortiosize");
562 if ( IOsize < AM.MaxTer ) { IOsize = AM.MaxTer; sp->value = IOsize; }
565 for ( j = 0; j < 2; j++ ) { AR.Fscr[j].ziosize = IOsize; }
569 AM.S0 = AllocSort(LargeSize,SmallSize,SmallEsize,TermsInSmall
570 ,MaxPatches,MaxFpatches,IOsize);
572 AM.S0->file.ziosize = IOsize;
574 AR.FoStage4[0].ziosize = IOsize;
575 AR.FoStage4[1].ziosize = IOsize;
584 AR.FoStage4[0].POsize = ((IOsize+
sizeof(WORD)-1)/
sizeof(WORD))*
sizeof(WORD);
585 AR.FoStage4[1].POsize = ((IOsize+
sizeof(WORD)-1)/
sizeof(WORD))*
sizeof(WORD);
587 sp = GetSetupPar((UBYTE *)
"subsmallsize");
588 AM.SSmallSize = sp->value;
589 sp = GetSetupPar((UBYTE *)
"subsmallextension");
590 AM.SSmallEsize = sp->value;
591 sp = GetSetupPar((UBYTE *)
"sublargesize");
592 AM.SLargeSize = sp->value;
593 sp = GetSetupPar((UBYTE *)
"subtermsinsmall");
594 AM.STermsInSmall = sp->value;
595 sp = GetSetupPar((UBYTE *)
"sublargepatches");
596 AM.SMaxPatches = sp->value;
597 sp = GetSetupPar((UBYTE *)
"subfilepatches");
598 AM.SMaxFpatches = sp->value;
599 sp = GetSetupPar((UBYTE *)
"subsortiosize");
600 AM.SIOsize = sp->value;
601 sp = GetSetupPar((UBYTE *)
"spectatorsize");
602 AM.SpectatorSize = sp->value;
608 sp = GetSetupPar((UBYTE *)
"functionlevels");
609 AM.maxFlevels = sp->value + 1;
612 AT.Nest = (
NESTING)Malloc1((LONG)
sizeof(
struct NeStInG)*AM.maxFlevels,
"functionlevels");
613 AT.NestStop = AT.Nest + AM.maxFlevels;
614 AT.NestPoin = AT.Nest;
617 sp = GetSetupPar((UBYTE *)
"maxwildcards");
618 AM.MaxWildcards = sp->value;
621 AT.WildMask = (WORD *)Malloc1((LONG)AM.MaxWildcards*
sizeof(WORD),
"maxwildcards");
624 sp = GetSetupPar((UBYTE *)
"compresssize");
625 if ( sp->value < 2*AM.MaxTer ) sp->value = 2*AM.MaxTer;
626 AM.CompressSize = sp->value;
628 AR.CompressBuffer = (WORD *)Malloc1((AM.CompressSize+10)*
sizeof(WORD),
"compresssize");
629 AR.CompressPointer = AR.CompressBuffer;
630 AR.ComprTop = AR.CompressBuffer + AM.CompressSize;
632 sp = GetSetupPar((UBYTE *)
"bracketindexsize");
633 if ( sp->value < 20*AM.MaxTer ) sp->value = 20*AM.MaxTer;
634 AM.MaxBracketBufferSize = sp->value/
sizeof(WORD);
636 sp = GetSetupPar((UBYTE *)
"dotchar");
637 AO.FortDotChar = ((UBYTE *)(sp->value))[0];
638 sp = GetSetupPar((UBYTE *)
"commentchar");
639 AP.cComChar = AP.ComChar = ((UBYTE *)(sp->value))[0];
640 sp = GetSetupPar((UBYTE *)
"procedureextension");
644 s = (UBYTE *)(sp->value);
645 if ( FG.cTable[*s] != 0 ) {
646 MesPrint(
" Illegal string for procedure extension %s",(UBYTE *)sp->value);
652 if ( *s ==
' ' || *s ==
'\t' || *s ==
'\n' ) {
653 MesPrint(
" Illegal string for procedure extension %s",(UBYTE *)sp->value);
660 AP.cprocedureExtension = strDup1((UBYTE *)(sp->value),
"procedureExtension");
661 AP.procedureExtension = strDup1(AP.cprocedureExtension,
"procedureExtension");
663 sp = GetSetupPar((UBYTE *)
"totalsize");
664 if ( sp->value != 2 ) AM.PrintTotalSize = sp->value;
666 sp = GetSetupPar((UBYTE *)
"continuationlines");
667 AM.FortranCont = sp->value;
668 if ( AM.FortranCont <= 0 ) AM.FortranCont = 1;
669 sp = GetSetupPar((UBYTE *)
"oldorder");
670 AM.OldOrderFlag = sp->value;
671 sp = GetSetupPar((UBYTE *)
"resettimeonclear");
672 AM.resetTimeOnClear = sp->value;
673 sp = GetSetupPar((UBYTE *)
"nospacesinnumbers");
674 AO.NoSpacesInNumbers = AM.gNoSpacesInNumbers = AM.ggNoSpacesInNumbers = sp->value;
675 sp = GetSetupPar((UBYTE *)
"indentspace");
676 AO.IndentSpace = AM.gIndentSpace = AM.ggIndentSpace = sp->value;
677 sp = GetSetupPar((UBYTE *)
"jumpratio");
678 AM.jumpratio = sp->value;
679 sp = GetSetupPar((UBYTE *)
"nwritestatistics");
680 AC.StatsFlag = AM.gStatsFlag = AM.ggStatsFlag = 1-sp->value;
681 sp = GetSetupPar((UBYTE *)
"nwritefinalstatistics");
682 AC.FinalStats = AM.gFinalStats = AM.ggFinalStats = 1-sp->value;
683 sp = GetSetupPar((UBYTE *)
"nwritethreadstatistics");
684 AC.ThreadStats = AM.gThreadStats = AM.ggThreadStats = 1-sp->value;
685 sp = GetSetupPar((UBYTE *)
"nwriteprocessstatistics");
686 AC.ProcessStats = AM.gProcessStats = AM.ggProcessStats = 1-sp->value;
687 sp = GetSetupPar((UBYTE *)
"oldparallelstatistics");
688 AC.OldParallelStats = AM.gOldParallelStats = AM.ggOldParallelStats = sp->value;
689 sp = GetSetupPar((UBYTE *)
"oldfactarg");
690 AC.OldFactArgFlag = AM.gOldFactArgFlag = AM.ggOldFactArgFlag = sp->value;
691 sp = GetSetupPar((UBYTE *)
"oldgcd");
692 AC.OldGCDflag = AM.gOldGCDflag = AM.ggOldGCDflag = sp->value;
693 sp = GetSetupPar((UBYTE *)
"wtimestats");
694 if ( sp->value == 2 ) sp->value = AM.ggWTimeStatsFlag;
695 AC.WTimeStatsFlag = AM.gWTimeStatsFlag = AM.ggWTimeStatsFlag = sp->value;
696 sp = GetSetupPar((UBYTE *)
"sorttype");
697 if ( StrICmp((UBYTE *)
"lowfirst",(UBYTE *)sp->value) == 0 ) {
698 AC.lSortType = SORTLOWFIRST;
700 else if ( StrICmp((UBYTE *)
"highfirst",(UBYTE *)sp->value) == 0 ) {
701 AC.lSortType = SORTHIGHFIRST;
704 MesPrint(
" Illegal SortType specification: %s",(UBYTE *)sp->value);
708 sp = GetSetupPar((UBYTE *)
"processbucketsize");
709 AM.hProcessBucketSize = AM.gProcessBucketSize =
710 AC.ProcessBucketSize = AC.mProcessBucketSize = sp->value;
714 sp = GetSetupPar((UBYTE *)
"numstorecaches");
715 AM.NumStoreCaches = sp->value;
716 sp = GetSetupPar((UBYTE *)
"sizestorecache");
717 AM.SizeStoreCache = sp->value;
723 AT.StoreCache = AT.StoreCacheAlloc = 0;
724 if ( AM.NumStoreCaches > 0 ) {
726 size =
sizeof(
struct StOrEcAcHe)+AM.SizeStoreCache;
727 size = ((size-1)/
sizeof(
size_t)+1)*
sizeof(
size_t);
728 AT.StoreCacheAlloc = (
STORECACHE)Malloc1(size*AM.NumStoreCaches,
"StoreCaches");
729 AT.StoreCache = AT.StoreCacheAlloc;
731 for ( j = 0; j < AM.NumStoreCaches; j++ ) {
733 if ( j == AM.NumStoreCaches-1 ) {
739 SETBASEPOSITION(sa->position,-1);
740 SETBASEPOSITION(sa->toppos,-1);
749 if ( AM.Path == 0 ) {
750 sp = GetSetupPar((UBYTE *)
"path");
751 AM.Path = strDup1((UBYTE *)(sp->value),
"path");
753 if ( AM.IncDir == 0 ) {
754 sp = GetSetupPar((UBYTE *)
"incdir");
755 AM.IncDir = strDup1((UBYTE *)(sp->value),
"incdir");
787 MesPrint(
" The setup parameters are:");
788 for ( sp = setupparameters; n > 0; n--, sp++ ) {
791 MesPrint(
" %s: %l",sp->parameter,sp->value);
794 if ( StrICmp(sp->parameter,(UBYTE *)
"path") == 0 && AM.Path ) {
795 MesPrint(
" %s: '%s'",sp->parameter,(UBYTE *)(AM.Path));
798 if ( StrICmp(sp->parameter,(UBYTE *)
"incdir") == 0 && AM.IncDir ) {
799 MesPrint(
" %s: '%s'",sp->parameter,(UBYTE *)(AM.IncDir));
804 if ( StrICmp(sp->parameter,(UBYTE *)
"tempdir") == 0 && AM.TempDir ) {
805 MesPrint(
" %s: '%s'",sp->parameter,(UBYTE *)(AM.TempDir));
807 else if ( StrICmp(sp->parameter,(UBYTE *)
"tempsortdir") == 0 && AM.TempSortDir ) {
808 MesPrint(
" %s: '%s'",sp->parameter,(UBYTE *)(AM.TempSortDir));
811 MesPrint(
" %s: '%s'",sp->parameter,(UBYTE *)(sp->value));
815 if ( sp->value == 0 )
816 MesPrint(
" %s: OFF",sp->parameter);
817 else if ( sp->value == 1 )
818 MesPrint(
" %s: ON",sp->parameter);
839 SORTING *AllocSort(LONG LargeSize, LONG SmallSize, LONG SmallEsize, LONG TermsInSmall,
840 int MaxPatches,
int MaxFpatches, LONG IOsize)
842 LONG allocation,longer,terms2insmall,sortsize,longerp;
843 LONG IObuffersize = IOsize;
849 s = FG.fname2; i = 0;
850 while ( *s ) { s++; i++; }
853 if ( MaxFpatches < 4 ) MaxFpatches = 4;
854 longer = MaxPatches > MaxFpatches ? MaxPatches : MaxFpatches;
856 while ( (1 << j) < longerp ) j++;
857 longerp = (1 << j) + 1;
858 longerp +=
sizeof(WORD*) - (longerp%
sizeof(WORD *));
860 longer +=
sizeof(WORD*) - (longer%
sizeof(WORD *));
861 if ( SmallSize < 16*AM.MaxTer ) SmallSize = 16*AM.MaxTer+16;
862 TermsInSmall = (TermsInSmall+15) & (-16L);
863 terms2insmall = 2*TermsInSmall;
864 if ( SmallEsize < (SmallSize*3)/2 ) SmallEsize = (SmallSize*3)/2;
865 if ( LargeSize > 0 && LargeSize < 2*SmallSize ) LargeSize = 2*SmallSize;
867 SmallEsize = (SmallEsize+15) & (-16L);
868 if ( LargeSize < 0 ) LargeSize = 0;
870 sortsize = (sortsize+15)&(-16L);
871 IObuffersize = (IObuffersize+
sizeof(WORD)-1)/
sizeof(WORD);
877 if ( (ULONG)( LargeSize+SmallEsize ) < MaxFpatches*((IObuffersize
878 +COMPINC)*
sizeof(WORD)+2*AM.MaxTer) ) {
879 if ( LargeSize == 0 )
880 SmallEsize = MaxFpatches*((IObuffersize+COMPINC)*
sizeof(WORD)+2*AM.MaxTer);
882 LargeSize = MaxFpatches*((IObuffersize+COMPINC)*
sizeof(WORD)+2*AM.MaxTer)
886 IOtry = ((LargeSize+SmallEsize)/MaxFpatches-2*AM.MaxTer)/
sizeof(WORD)-COMPINC;
888 if ( (LONG)(IObuffersize*
sizeof(WORD)) < IOtry )
889 IObuffersize = (IOtry+
sizeof(WORD)-1)/
sizeof(WORD);
893 +2*
sizeof(WORD *)*longer
894 +2*(longerp*(
sizeof(WORD *)+
sizeof(WORD)))
895 +(3*longerp+2)*
sizeof(WORD)
897 +(2*longerp+4)*
sizeof(WORD)
899 +terms2insmall*
sizeof(WORD *)
900 +terms2insmall*
sizeof(WORD *)/2
904 +IObuffersize*
sizeof(WORD) + i + 16;
905 sort = (
SORTING *)Malloc1(allocation,
"sort buffers");
907 sort->LargeSize = LargeSize/
sizeof(WORD);
908 sort->SmallSize = SmallSize/
sizeof(WORD);
909 sort->SmallEsize = SmallEsize/
sizeof(WORD);
910 sort->MaxPatches = MaxPatches;
911 sort->MaxFpatches = MaxFpatches;
912 sort->TermsInSmall = TermsInSmall;
913 sort->Terms2InSmall = terms2insmall;
915 sort->sPointer = (WORD **)(sort+1);
916 sort->SplitScratch = sort->sPointer + terms2insmall;
917 sort->Patches = (WORD **)(sort->SplitScratch + terms2insmall/2);
918 sort->pStop = sort->Patches+longer;
919 sort->poina = sort->pStop+longer;
920 sort->poin2a = sort->poina + longerp;
921 sort->fPatches = (
POSITION *)(sort->poin2a+longerp);
922 sort->fPatchesStop = sort->fPatches + longer;
923 sort->inPatches = sort->fPatchesStop + longer;
924 sort->tree = (WORD *)(sort->inPatches + longer);
925 sort->used = sort->tree+longerp;
927 sort->fpcompressed = sort->used+longerp;
928 sort->fpincompressed = sort->fpcompressed+longerp+2;
929 sort->ktoi = sort->fpincompressed+longerp+2;
932 sort->ktoi = sort->used + longerp;
934 sort->lBuffer = (WORD *)(sort->ktoi + longerp + 2);
935 sort->lTop = sort->lBuffer+sort->LargeSize;
936 sort->sBuffer = sort->lTop;
937 if ( sort->LargeSize == 0 ) { sort->lBuffer = 0; sort->lTop = 0; }
938 sort->sTop = sort->sBuffer + sort->SmallSize;
939 sort->sTop2 = sort->sBuffer + sort->SmallEsize;
940 sort->sHalf = sort->sBuffer + (LONG)((sort->SmallSize+sort->SmallEsize)>>1);
941 sort->file.PObuffer = (WORD *)(sort->sTop2);
942 sort->file.POstop = sort->file.PObuffer+IObuffersize;
943 sort->file.POsize = IObuffersize *
sizeof(WORD);
944 sort->file.POfill = sort->file.POfull = sort->file.PObuffer;
945 sort->file.active = 0;
947 PUTZERO(sort->file.POposition);
949 sort->file.pthreadslock = dummylock;
953 sort->file.ziosize = IObuffersize*
sizeof(WORD);
954 sort->file.ziobuffer = 0;
957 sort->file.name = (
char *)(sort->file.PObuffer + IObuffersize);
958 AllocSortFileName(sort);
960 else sort->file.name = 0;
962 sort->cBufferSize = 0;
974 VOID AllocSortFileName(
SORTING *sort)
982 s = FG.fname2; t = sort->file.name;
983 while ( *s ) *t++ = *s++;
986 sprintf(t-1,
"%d.%d",identity,AN.filenum);
989 sprintf(t-1,
"%d",AN.filenum);
999 FILEHANDLE *AllocFileHandle(WORD par,
char *name)
1002 LONG allocation, Ssize;
1007 s = FG.fname2; i = 0;
1008 while ( *s ) { s++; i++; }
1009 if ( par == 0 ) { i += 16; Ssize = AM.SIOsize; }
1010 else { s = name;
while ( *s ) { i++; s++; } i+= 2; Ssize = AM.SpectatorSize; }
1012 allocation =
sizeof(
FILEHANDLE) + (Ssize+1)*
sizeof(WORD) + i*
sizeof(
char);
1013 fh = (
FILEHANDLE *)Malloc1(allocation,
"FileHandle");
1015 fh->PObuffer = (WORD *)(fh+1);
1016 fh->POstop = fh->PObuffer+Ssize;
1017 fh->POsize = Ssize *
sizeof(WORD);
1020 PUTZERO(fh->POposition);
1022 fh->pthreadslock = dummylock;
1026 fh->name = (
char *)(fh->POstop + 1);
1027 s = FG.fname2; t = fh->name;
1028 while ( *s ) *t++ = *s++;
1031 sprintf(t-1,
"%d-%d",identity,AN.filenum);
1034 sprintf(t-1,
"%d",AN.filenum);
1041 fh->name = (
char *)(fh->POstop + 1);
1042 s = FG.fname; t = fh->name;
1043 for ( i = 0; i < FG.fnamebase; i++ ) *t++ = *s++;
1045 while ( *s ) *t++ = *s++;
1048 fh->POfill = fh->POfull = fh->PObuffer;
1068 M_free(fh,
"Temporary FileHandle");
1076 int MakeSetupAllocs()
1078 if ( RecalcSetups() || AllocSetups() )
return(1);
1094 #define SETBUFSIZE 257
1098 LONG oldstreamposition;
1100 int error = 0, eqnum;
1101 int oldNoShowInput = AC.NoShowInput;
1102 UBYTE buff[SETBUFSIZE+1], *s, *t, *u, *settop, c;
1103 LONG linenum, prevline;
1105 if ( AC.CurrentStream == 0 )
return(error);
1106 oldstream = AC.CurrentStream - AC.Streams;
1107 oldstreamposition = GetStreamPosition(AC.CurrentStream);
1108 linenum = AC.CurrentStream->linenumber;
1109 prevline = AC.CurrentStream->prevline;
1110 eqnum = AC.CurrentStream->eqnum;
1112 settop = buff + SETBUFSIZE;
1115 if ( c ==
'*' || c ==
'\n' ) {
1116 while ( c !=
'\n' && c != ENDOFINPUT ) c = GetInput();
1117 if ( c == ENDOFINPUT )
goto eoi;
1120 if ( c == ENDOFINPUT )
goto eoi;
1121 if ( c !=
'#' )
break;
1123 if ( c == ENDOFINPUT )
goto eoi;
1124 if ( c !=
'-' && c !=
'+' && c !=
':' )
break;
1126 while ( c !=
'\n' && c != ENDOFINPUT ) c = GetInput();
1130 while ( ( c = GetInput() ) ==
' ' || c ==
'\t' || c ==
'\r' ) {}
1131 if ( c == ENDOFINPUT )
break;
1132 if ( c == LINEFEED )
continue;
1133 if ( c == 0 || c == ENDOFINPUT )
break;
1134 while ( c != LINEFEED ) {
1137 if ( c != LINEFEED && c !=
'\r' )
continue;
1138 if ( s >= settop ) {
1139 while ( c !=
'\n' && c != ENDOFINPUT ) c = GetInput();
1140 MesPrint(
"Setups in .frm file: Line too long. setup ignored");
1141 error++;
goto nextline;
1146 while ( tolower(*s) >=
'a' && tolower(*s) <=
'z' ) s++;
1149 while ( *s ==
' ' || *s ==
'\t' ) s++;
1151 while ( *s && *s !=
'\n' && *s !=
'\r' ) s++;
1159 error += ProcessOption(t,u,1);
1162 AC.NoShowInput = oldNoShowInput;
1163 AC.CurrentStream = AC.Streams + oldstream;
1164 PositionStream(AC.CurrentStream,oldstreamposition);
1165 AC.CurrentStream->linenumber = linenum;
1166 AC.CurrentStream->prevline = prevline;
1167 AC.CurrentStream->eqnum = eqnum;
1171 MesPrint(
"Input file without a program.");
1180 int TryEnvironment()
1182 char *s, *t, *u, varname[100];
1185 varname[0] =
'F'; varname[1] =
'O'; varname[2] =
'R'; varname[3] =
'M';
1186 varname[4] =
'_'; varname[5] = 0;
1187 for ( i = 0; i < imax; i++ ) {
1188 t = s = (
char *)(setupparameters[i].parameter);
1190 while ( *s ) { *u++ = (char)(toupper((
unsigned char)*s)); s++; }
1192 s = (
char *)(getenv(varname));
1194 error += ProcessOption((UBYTE *)t,(UBYTE *)s,2);
struct StOrEcAcHe * STORECACHE
int TheDefine(UBYTE *, int)