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 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 *)
"jumpratio");
677 AM.jumpratio = sp->value;
678 sp = GetSetupPar((UBYTE *)
"nwritestatistics");
679 AC.StatsFlag = AM.gStatsFlag = AM.ggStatsFlag = 1-sp->value;
680 sp = GetSetupPar((UBYTE *)
"nwritefinalstatistics");
681 AC.FinalStats = AM.gFinalStats = AM.ggFinalStats = 1-sp->value;
682 sp = GetSetupPar((UBYTE *)
"nwritethreadstatistics");
683 AC.ThreadStats = AM.gThreadStats = AM.ggThreadStats = 1-sp->value;
684 sp = GetSetupPar((UBYTE *)
"nwriteprocessstatistics");
685 AC.ProcessStats = AM.gProcessStats = AM.ggProcessStats = 1-sp->value;
686 sp = GetSetupPar((UBYTE *)
"oldparallelstatistics");
687 AC.OldParallelStats = AM.gOldParallelStats = AM.ggOldParallelStats = sp->value;
688 sp = GetSetupPar((UBYTE *)
"oldfactarg");
689 AC.OldFactArgFlag = AM.gOldFactArgFlag = AM.ggOldFactArgFlag = sp->value;
690 sp = GetSetupPar((UBYTE *)
"oldgcd");
691 AC.OldGCDflag = AM.gOldGCDflag = AM.ggOldGCDflag = sp->value;
692 sp = GetSetupPar((UBYTE *)
"wtimestats");
693 if ( sp->value == 2 ) sp->value = AM.ggWTimeStatsFlag;
694 AC.WTimeStatsFlag = AM.gWTimeStatsFlag = AM.ggWTimeStatsFlag = sp->value;
695 sp = GetSetupPar((UBYTE *)
"sorttype");
696 if ( StrICmp((UBYTE *)
"lowfirst",(UBYTE *)sp->value) == 0 ) {
697 AC.lSortType = SORTLOWFIRST;
699 else if ( StrICmp((UBYTE *)
"highfirst",(UBYTE *)sp->value) == 0 ) {
700 AC.lSortType = SORTHIGHFIRST;
703 MesPrint(
" Illegal SortType specification: %s",(UBYTE *)sp->value);
707 sp = GetSetupPar((UBYTE *)
"processbucketsize");
708 AM.hProcessBucketSize = AM.gProcessBucketSize =
709 AC.ProcessBucketSize = AC.mProcessBucketSize = sp->value;
713 sp = GetSetupPar((UBYTE *)
"numstorecaches");
714 AM.NumStoreCaches = sp->value;
715 sp = GetSetupPar((UBYTE *)
"sizestorecache");
716 AM.SizeStoreCache = sp->value;
722 AT.StoreCache = AT.StoreCacheAlloc = 0;
723 if ( AM.NumStoreCaches > 0 ) {
725 size =
sizeof(
struct StOrEcAcHe)+AM.SizeStoreCache;
726 size = ((size-1)/
sizeof(
size_t)+1)*
sizeof(
size_t);
727 AT.StoreCacheAlloc = (
STORECACHE)Malloc1(size*AM.NumStoreCaches,
"StoreCaches");
728 AT.StoreCache = AT.StoreCacheAlloc;
730 for ( j = 0; j < AM.NumStoreCaches; j++ ) {
732 if ( j == AM.NumStoreCaches-1 ) {
738 SETBASEPOSITION(sa->position,-1);
739 SETBASEPOSITION(sa->toppos,-1);
748 if ( AM.Path == 0 ) {
749 sp = GetSetupPar((UBYTE *)
"path");
750 AM.Path = strDup1((UBYTE *)(sp->value),
"path");
752 if ( AM.IncDir == 0 ) {
753 sp = GetSetupPar((UBYTE *)
"incdir");
754 AM.IncDir = strDup1((UBYTE *)(sp->value),
"incdir");
786 MesPrint(
" The setup parameters are:");
787 for ( sp = setupparameters; n > 0; n--, sp++ ) {
790 MesPrint(
" %s: %l",sp->parameter,sp->value);
793 if ( StrICmp(sp->parameter,(UBYTE *)
"path") == 0 && AM.Path ) {
794 MesPrint(
" %s: '%s'",sp->parameter,(UBYTE *)(AM.Path));
797 if ( StrICmp(sp->parameter,(UBYTE *)
"incdir") == 0 && AM.IncDir ) {
798 MesPrint(
" %s: '%s'",sp->parameter,(UBYTE *)(AM.IncDir));
803 if ( StrICmp(sp->parameter,(UBYTE *)
"tempdir") == 0 && AM.TempDir ) {
804 MesPrint(
" %s: '%s'",sp->parameter,(UBYTE *)(AM.TempDir));
806 else if ( StrICmp(sp->parameter,(UBYTE *)
"tempsortdir") == 0 && AM.TempSortDir ) {
807 MesPrint(
" %s: '%s'",sp->parameter,(UBYTE *)(AM.TempSortDir));
810 MesPrint(
" %s: '%s'",sp->parameter,(UBYTE *)(sp->value));
814 if ( sp->value == 0 )
815 MesPrint(
" %s: OFF",sp->parameter);
816 else if ( sp->value == 1 )
817 MesPrint(
" %s: ON",sp->parameter);
838 SORTING *AllocSort(LONG LargeSize, LONG SmallSize, LONG SmallEsize, LONG TermsInSmall,
839 int MaxPatches,
int MaxFpatches, LONG IOsize)
841 LONG allocation,longer,terms2insmall,sortsize,longerp;
842 LONG IObuffersize = IOsize;
848 s = FG.fname2; i = 0;
849 while ( *s ) { s++; i++; }
852 if ( MaxFpatches < 4 ) MaxFpatches = 4;
853 longer = MaxPatches > MaxFpatches ? MaxPatches : MaxFpatches;
855 while ( (1 << j) < longerp ) j++;
856 longerp = (1 << j) + 1;
857 longerp +=
sizeof(WORD*) - (longerp%
sizeof(WORD *));
859 longer +=
sizeof(WORD*) - (longer%
sizeof(WORD *));
860 if ( SmallSize < 16*AM.MaxTer ) SmallSize = 16*AM.MaxTer+16;
861 TermsInSmall = (TermsInSmall+15) & (-16L);
862 terms2insmall = 2*TermsInSmall;
863 if ( SmallEsize < (SmallSize*3)/2 ) SmallEsize = (SmallSize*3)/2;
864 if ( LargeSize > 0 && LargeSize < 2*SmallSize ) LargeSize = 2*SmallSize;
866 SmallEsize = (SmallEsize+15) & (-16L);
867 if ( LargeSize < 0 ) LargeSize = 0;
869 sortsize = (sortsize+15)&(-16L);
870 IObuffersize = (IObuffersize+
sizeof(WORD)-1)/
sizeof(WORD);
876 if ( (ULONG)( LargeSize+SmallEsize ) < MaxFpatches*((IObuffersize
877 +COMPINC)*
sizeof(WORD)+2*AM.MaxTer) ) {
878 if ( LargeSize == 0 )
879 SmallEsize = MaxFpatches*((IObuffersize+COMPINC)*
sizeof(WORD)+2*AM.MaxTer);
881 LargeSize = MaxFpatches*((IObuffersize+COMPINC)*
sizeof(WORD)+2*AM.MaxTer)
885 IOtry = ((LargeSize+SmallEsize)/MaxFpatches-2*AM.MaxTer)/
sizeof(WORD)-COMPINC;
887 if ( (LONG)(IObuffersize*
sizeof(WORD)) < IOtry )
888 IObuffersize = (IOtry+
sizeof(WORD)-1)/
sizeof(WORD);
892 +2*
sizeof(WORD *)*longer
893 +2*(longerp*(
sizeof(WORD *)+
sizeof(WORD)))
894 +(3*longerp+2)*
sizeof(WORD)
896 +(2*longerp+4)*
sizeof(WORD)
898 +terms2insmall*
sizeof(WORD *)
899 +terms2insmall*
sizeof(WORD *)/2
903 +IObuffersize*
sizeof(WORD) + i + 16;
904 sort = (
SORTING *)Malloc1(allocation,
"sort buffers");
906 sort->LargeSize = LargeSize/
sizeof(WORD);
907 sort->SmallSize = SmallSize/
sizeof(WORD);
908 sort->SmallEsize = SmallEsize/
sizeof(WORD);
909 sort->MaxPatches = MaxPatches;
910 sort->MaxFpatches = MaxFpatches;
911 sort->TermsInSmall = TermsInSmall;
912 sort->Terms2InSmall = terms2insmall;
914 sort->sPointer = (WORD **)(sort+1);
915 sort->SplitScratch = sort->sPointer + terms2insmall;
916 sort->Patches = (WORD **)(sort->SplitScratch + terms2insmall/2);
917 sort->pStop = sort->Patches+longer;
918 sort->poina = sort->pStop+longer;
919 sort->poin2a = sort->poina + longerp;
920 sort->fPatches = (
POSITION *)(sort->poin2a+longerp);
921 sort->fPatchesStop = sort->fPatches + longer;
922 sort->inPatches = sort->fPatchesStop + longer;
923 sort->tree = (WORD *)(sort->inPatches + longer);
924 sort->used = sort->tree+longerp;
926 sort->fpcompressed = sort->used+longerp;
927 sort->fpincompressed = sort->fpcompressed+longerp+2;
928 sort->ktoi = sort->fpincompressed+longerp+2;
931 sort->ktoi = sort->used + longerp;
933 sort->lBuffer = (WORD *)(sort->ktoi + longerp + 2);
934 sort->lTop = sort->lBuffer+sort->LargeSize;
935 sort->sBuffer = sort->lTop;
936 if ( sort->LargeSize == 0 ) { sort->lBuffer = 0; sort->lTop = 0; }
937 sort->sTop = sort->sBuffer + sort->SmallSize;
938 sort->sTop2 = sort->sBuffer + sort->SmallEsize;
939 sort->sHalf = sort->sBuffer + (LONG)((sort->SmallSize+sort->SmallEsize)>>1);
940 sort->file.PObuffer = (WORD *)(sort->sTop2);
941 sort->file.POstop = sort->file.PObuffer+IObuffersize;
942 sort->file.POsize = IObuffersize *
sizeof(WORD);
943 sort->file.POfill = sort->file.POfull = sort->file.PObuffer;
944 sort->file.active = 0;
946 PUTZERO(sort->file.POposition);
948 sort->file.pthreadslock = dummylock;
952 sort->file.ziosize = IObuffersize*
sizeof(WORD);
953 sort->file.ziobuffer = 0;
956 sort->file.name = (
char *)(sort->file.PObuffer + IObuffersize);
957 AllocSortFileName(sort);
959 else sort->file.name = 0;
961 sort->cBufferSize = 0;
973 VOID AllocSortFileName(
SORTING *sort)
981 s = FG.fname2; t = sort->file.name;
982 while ( *s ) *t++ = *s++;
985 sprintf(t-1,
"%d.%d",identity,AN.filenum);
988 sprintf(t-1,
"%d",AN.filenum);
998 FILEHANDLE *AllocFileHandle(WORD par,
char *name)
1001 LONG allocation, Ssize;
1006 s = FG.fname2; i = 0;
1007 while ( *s ) { s++; i++; }
1008 if ( par == 0 ) { i += 16; Ssize = AM.SIOsize; }
1009 else { s = name;
while ( *s ) { i++; s++; } i+= 2; Ssize = AM.SpectatorSize; }
1011 allocation =
sizeof(
FILEHANDLE) + (Ssize+1)*
sizeof(WORD) + i*
sizeof(
char);
1012 fh = (
FILEHANDLE *)Malloc1(allocation,
"FileHandle");
1014 fh->PObuffer = (WORD *)(fh+1);
1015 fh->POstop = fh->PObuffer+Ssize;
1016 fh->POsize = Ssize *
sizeof(WORD);
1019 PUTZERO(fh->POposition);
1021 fh->pthreadslock = dummylock;
1025 fh->name = (
char *)(fh->POstop + 1);
1026 s = FG.fname2; t = fh->name;
1027 while ( *s ) *t++ = *s++;
1030 sprintf(t-1,
"%d-%d",identity,AN.filenum);
1033 sprintf(t-1,
"%d",AN.filenum);
1040 fh->name = (
char *)(fh->POstop + 1);
1041 s = FG.fname; t = fh->name;
1042 for ( i = 0; i < FG.fnamebase; i++ ) *t++ = *s++;
1044 while ( *s ) *t++ = *s++;
1047 fh->POfill = fh->POfull = fh->PObuffer;
1067 M_free(fh,
"Temporary FileHandle");
1075 int MakeSetupAllocs()
1077 if ( RecalcSetups() || AllocSetups() )
return(1);
1093 #define SETBUFSIZE 257 1097 LONG oldstreamposition;
1099 int error = 0, eqnum;
1100 int oldNoShowInput = AC.NoShowInput;
1101 UBYTE buff[SETBUFSIZE+1], *s, *t, *u, *settop, c;
1102 LONG linenum, prevline;
1104 if ( AC.CurrentStream == 0 )
return(error);
1105 oldstream = AC.CurrentStream - AC.Streams;
1106 oldstreamposition = GetStreamPosition(AC.CurrentStream);
1107 linenum = AC.CurrentStream->linenumber;
1108 prevline = AC.CurrentStream->prevline;
1109 eqnum = AC.CurrentStream->eqnum;
1111 settop = buff + SETBUFSIZE;
1112 if ( AC.CurrentStream->type == INPUTSTREAM && oldstreamposition == 0 ) AC.CurrentStream->fileposition = 0;
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;
1169 if ( AC.CurrentStream->type == INPUTSTREAM ) AC.CurrentStream->fileposition = -1;
1172 MesPrint(
"Input file without a program.");
1181 int TryEnvironment()
1183 char *s, *t, *u, varname[100];
1186 varname[0] =
'F'; varname[1] =
'O'; varname[2] =
'R'; varname[3] =
'M';
1187 varname[4] =
'_'; varname[5] = 0;
1188 for ( i = 0; i < imax; i++ ) {
1189 t = s = (
char *)(setupparameters[i].parameter);
1191 while ( *s ) { *u++ = (char)(toupper((
unsigned char)*s)); s++; }
1193 s = (
char *)(getenv(varname));
1195 error += ProcessOption((UBYTE *)t,(UBYTE *)s,2);
struct StOrEcAcHe * STORECACHE
int TheDefine(UBYTE *, int)