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)MAXNUMBERSIZE}
72 ,{(UBYTE *)
"maxtermsize", NUMERICALVALUE, 0, (LONG)MAXTER}
73 ,{(UBYTE *)
"maxwildcards", NUMERICALVALUE, 0, (LONG)MAXWILDC}
74 ,{(UBYTE *)
"nospacesinnumbers", ONOFFVALUE, 0, (LONG)0}
75 ,{(UBYTE *)
"numstorecaches", NUMERICALVALUE, 0, (LONG)NUMSTORECACHES}
76 ,{(UBYTE *)
"nwritefinalstatistics", ONOFFVALUE, 0, (LONG)0}
77 ,{(UBYTE *)
"nwriteprocessstatistics", ONOFFVALUE, 0, (LONG)0}
78 ,{(UBYTE *)
"nwritestatistics", ONOFFVALUE, 0, (LONG)0}
79 ,{(UBYTE *)
"nwritethreadstatistics", ONOFFVALUE, 0, (LONG)0}
80 ,{(UBYTE *)
"oldfactarg", ONOFFVALUE, 0, (LONG)NEWFACTARG}
81 ,{(UBYTE *)
"oldorder", ONOFFVALUE, 0, (LONG)0}
82 ,{(UBYTE *)
"oldparallelstatistics", ONOFFVALUE, 0, (LONG)0}
83 ,{(UBYTE *)
"parentheses", NUMERICALVALUE, 0, (LONG)MAXPARLEVEL}
84 ,{(UBYTE *)
"path", PATHVALUE, 0, (LONG)curdirp}
85 ,{(UBYTE *)
"procedureextension", STRINGVALUE, 0, (LONG)procedureextension}
86 ,{(UBYTE *)
"processbucketsize", NUMERICALVALUE, 0, (LONG)DEFAULTPROCESSBUCKETSIZE}
87 ,{(UBYTE *)
"resettimeonclear", ONOFFVALUE, 0, (LONG)1}
88 ,{(UBYTE *)
"scratchsize", NUMERICALVALUE, 0, (LONG)SCRATCHSIZE}
89 ,{(UBYTE *)
"shmwinsize", NUMERICALVALUE, 0, (LONG)SHMWINSIZE}
90 ,{(UBYTE *)
"sizestorecache", NUMERICALVALUE, 0, (LONG)SIZESTORECACHE}
91 ,{(UBYTE *)
"smallextension", NUMERICALVALUE, 0, (LONG)SMALLOVERFLOW}
92 ,{(UBYTE *)
"smallsize", NUMERICALVALUE, 0, (LONG)SMALLBUFFER}
93 ,{(UBYTE *)
"sortiosize", NUMERICALVALUE, 0, (LONG)SORTIOSIZE}
94 ,{(UBYTE *)
"sorttype", STRINGVALUE, 0, (LONG)lowfirst}
95 ,{(UBYTE *)
"subfilepatches", NUMERICALVALUE, 0, (LONG)SMAXFPATCHES}
96 ,{(UBYTE *)
"sublargepatches", NUMERICALVALUE, 0, (LONG)SMAXPATCHES}
97 ,{(UBYTE *)
"sublargesize", NUMERICALVALUE, 0, (LONG)SLARGEBUFFER}
98 ,{(UBYTE *)
"subsmallextension", NUMERICALVALUE, 0, (LONG)SSMALLOVERFLOW}
99 ,{(UBYTE *)
"subsmallsize", NUMERICALVALUE, 0, (LONG)SSMALLBUFFER}
100 ,{(UBYTE *)
"subsortiosize", NUMERICALVALUE, 0, (LONG)SSORTIOSIZE}
101 ,{(UBYTE *)
"subtermsinsmall", NUMERICALVALUE, 0, (LONG)STERMSSMALL}
102 ,{(UBYTE *)
"tempdir", STRINGVALUE, 0, (LONG)curdirp}
103 ,{(UBYTE *)
"tempsortdir", STRINGVALUE, 0, (LONG)cursortdirp}
104 ,{(UBYTE *)
"termsinsmall", NUMERICALVALUE, 0, (LONG)TERMSSMALL}
105 ,{(UBYTE *)
"threadbucketsize", NUMERICALVALUE, 0, (LONG)DEFAULTTHREADBUCKETSIZE}
106 ,{(UBYTE *)
"threadloadbalancing", ONOFFVALUE, 0, (LONG)DEFAULTTHREADLOADBALANCING}
107 ,{(UBYTE *)
"threads", NUMERICALVALUE, 0, (LONG)DEFAULTTHREADS}
108 ,{(UBYTE *)
"threadscratchoutsize", NUMERICALVALUE, 0, (LONG)THREADSCRATCHOUTSIZE}
109 ,{(UBYTE *)
"threadscratchsize", NUMERICALVALUE, 0, (LONG)THREADSCRATCHSIZE}
110 ,{(UBYTE *)
"threadsortfilesynch", ONOFFVALUE, 0, (LONG)0}
111 ,{(UBYTE *)
"totalsize", ONOFFVALUE, 0, (LONG)2}
112 ,{(UBYTE *)
"workspace", NUMERICALVALUE, 0, (LONG)WORKBUFFER}
123 UBYTE *setbuffer, *s, *t, *u ;
125 setbuffer = LoadInputFile((UBYTE *)setupfilename,SETUPFILE);
134 if ( *s ==
' ' || *s ==
'\t' || *s ==
'*' || *s ==
'#' || *s ==
'\n' ) {
135 while ( *s && *s !=
'\n' ) s++;
137 else if ( tolower(*s) <
'a' || tolower(*s) >
'z' ) {
139 while ( *s && *s !=
'\n' ) s++;
148 while ( tolower(*s) >=
'a' && tolower(*s) <=
'z' ) s++;
150 while ( *s ==
' ' || *s ==
'\t' ) s++;
152 while ( *s && *s !=
'\n' && *s !=
'\r' ) s++;
154 errors += ProcessOption(t,u,0);
156 while ( *s ==
'\n' || *s ==
'\r' ) s++;
158 M_free(setbuffer,
"setup file buffer");
160 if ( errors )
return(1);
169 static char *proop1[3] = {
"Setup file",
"Setups in .frm file",
"Setup in environment" };
171 int ProcessOption(UBYTE *s1, UBYTE *s2,
int filetype)
174 int n, giveback = 0, error = 0;
175 UBYTE *s, *t, *s2ret;
177 sp = GetSetupPar(s1);
185 UBYTE *s3,*s4,*s5,*s6, c, *start;
189 if ( *s ==
'\\' ) s += 2;
190 else if ( *s ==
'`' ) {
192 while ( *s && *s !=
'\'' ) {
193 if ( *s ==
'\\' ) s++;
197 MesPrint(
"%s: Illegal use of ` character for parameter %s" 198 ,proop1[filetype],s1);
202 s3 = (UBYTE *)getenv((
char *)(start+1));
204 MesPrint(
"%s: Cannot find environment variable %s for parameter %s" 205 ,proop1[filetype],start+1,s1);
210 n1 = start - s2; s4 = s3; n2 = 0;
212 if ( *s4 ==
'\\' ) { s4++; n2++; }
217 if ( *s4 ==
'\\' ) { s4++; n3++; }
220 s4 = (UBYTE *)Malloc1((n1+n2+n3+1)*
sizeof(UBYTE),
"environment in setup");
222 while ( n1-- > 0 ) *s6++ = *s5++;
224 while ( n2-- > 0 ) *s6++ = *s5++;
226 while ( n3-- > 0 ) *s6++ = *s5++;
228 if ( giveback ) M_free(s2,
"environment in setup");
241 if ( *s2 ==
'K' ) { x = x * 1000; s2++; }
242 else if ( *s2 ==
'M' ) { x = x * 1000000; s2++; }
243 else if ( *s2 ==
'G' ) { x = x * 1000000000; s2++; }
244 if ( *s2 && *s2 !=
' ' && *s2 !=
'\t' ) {
245 MesPrint(
"%s: Numerical value expected for parameter %s" 246 ,proop1[filetype],s1);
250 sp->flags = USEDFLAG;
255 if ( *s ==
' ' || *s ==
'\t' )
break;
256 if ( *s ==
'\\' ) s++;
260 sp->value = (LONG)strDup1(s2,
"Process option");
261 sp->flags = USEDFLAG;
264 MesPrint(
"Setups: PATHVALUE not yet implemented");
267 if ( tolower(*s2) ==
'o' && tolower(s2[1]) ==
'n' 268 && ( s2[2] == 0 || s2[2] ==
' ' || s2[2] ==
'\t' ) )
270 else if ( tolower(*s2) ==
'o' && tolower(s2[1]) ==
'f' 271 && tolower(s2[2]) ==
'f' 272 && ( s2[3] == 0 || s2[3] ==
' ' || s2[3] ==
'\t' ) )
275 MesPrint(
"%s: Unrecognized option for parameter %s: %s" 276 ,proop1[filetype],s1,s2);
279 sp->flags = USEDFLAG;
289 Error1(
"Error in setupparameter table for:",s1);
295 MesPrint(
"%s: Keyword not recognized: %s",proop1[filetype],s1);
298 if ( giveback ) M_free(s2ret,
"environment in setup");
313 med = ( hi + lo ) / 2;
314 i = StrICmp(s,(UBYTE *)setupparameters[med].parameter);
315 if ( i == 0 )
return(setupparameters+med);
316 if ( i < 0 ) hi = med-1;
318 }
while ( hi >= lo );
331 sp1 = GetSetupPar((UBYTE *)
"threads");
332 if ( AM.totalnumberofthreads > 1 ) sp1->value = AM.totalnumberofthreads - 1;
338 sp = GetSetupPar((UBYTE *)
"filepatches");
339 if ( sp->value < AM.totalnumberofthreads-1 )
340 sp->value = AM.totalnumberofthreads - 1;
342 sp = GetSetupPar((UBYTE *)
"smallsize");
343 sp1 = GetSetupPar((UBYTE *)
"smallextension");
344 if ( 6*sp1->value < 7*sp->value ) sp1->value = (7*sp->value)/6;
345 sp = GetSetupPar((UBYTE *)
"termsinsmall");
346 sp->value = ( sp->value + 15 ) & (-16L);
350 LONG totalsize, minimumsize;
351 sp = GetSetupPar((UBYTE *)
"largesize");
352 totalsize = sp1->value+sp->value;
353 sp2 = GetSetupPar((UBYTE *)
"maxtermsize");
354 AM.MaxTer = sp2->value*
sizeof(WORD);
355 if ( AM.MaxTer < 200*(LONG)(
sizeof(WORD)) ) AM.MaxTer = 200*(LONG)(
sizeof(WORD));
356 if ( AM.MaxTer > MAXPOSITIVE - 200*(LONG)(
sizeof(WORD)) ) AM.MaxTer = MAXPOSITIVE - 200*(LONG)(
sizeof(WORD));
357 AM.MaxTer /=
sizeof(WORD);
358 AM.MaxTer *=
sizeof(WORD);
359 minimumsize = (AM.totalnumberofthreads-1)*(AM.MaxTer+
360 NUMBEROFBLOCKSINSORT*MINIMUMNUMBEROFTERMS*AM.MaxTer);
361 if ( totalsize < minimumsize ) {
362 sp->value = minimumsize - sp1->value;
377 LONG LargeSize, SmallSize, SmallEsize, TermsInSmall, IOsize;
378 int MaxPatches, MaxFpatches, error = 0;
383 sp = GetSetupPar((UBYTE *)
"threads");
384 if ( sp->value > 0 ) AM.totalnumberofthreads = sp->value+1;
386 AM.OutBuffer = (UBYTE *)Malloc1(AM.OutBufSize+1,
"OutputBuffer");
387 AC.iBuffer = (UBYTE *)Malloc1(AC.iBufferSize+1,
"statement buffer");
388 AC.iStop = AC.iBuffer + AC.iBufferSize-2;
389 AP.preStart = (UBYTE *)Malloc1(AP.pSize,
"instruction buffer");
390 AP.preStop = AP.preStart + AP.pSize - 3;
393 if ( AP.PreIfStack ) M_free(AP.PreIfStack,
"PreIfStack");
394 AP.PreIfStack = (
int *)Malloc1(AP.MaxPreIfLevel*
sizeof(
int),
395 "Preprocessor if stack");
396 AP.PreIfStack[0] = EXECUTINGIF;
397 sp = GetSetupPar((UBYTE *)
"insidefirst");
398 AM.ginsidefirst = AC.minsidefirst = AC.insidefirst = sp->value;
402 sp = GetSetupPar((UBYTE *)
"maxtermsize");
403 AM.MaxTer = sp->value*
sizeof(WORD);
404 if ( AM.MaxTer < 200*(LONG)(
sizeof(WORD)) ) AM.MaxTer = 200*(LONG)(
sizeof(WORD));
405 if ( AM.MaxTer > MAXPOSITIVE - 200*(LONG)(
sizeof(WORD)) ) AM.MaxTer = MAXPOSITIVE - 200*(LONG)(
sizeof(WORD));
406 AM.MaxTer /= (LONG)
sizeof(WORD);
407 AM.MaxTer *= (LONG)
sizeof(WORD);
411 sp = GetSetupPar((UBYTE *)
"workspace");
412 AM.WorkSize = sp->value;
415 AT.WorkSpace = (WORD *)Malloc1(AM.WorkSize*
sizeof(WORD),(
char *)(sp->parameter));
416 AT.WorkTop = AT.WorkSpace + AM.WorkSize;
417 AT.WorkPointer = AT.WorkSpace;
422 sp = GetSetupPar((UBYTE *)
"constindex");
423 if ( ( sp->value+100+5*WILDOFFSET ) > MAXPOSITIVE ) {
424 MesPrint(
"Setting of %s in setupfile too large",
"constindex");
425 AM.OffsetIndex = MAXPOSITIVE - 5*WILDOFFSET - 100;
426 MesPrint(
"value corrected to maximum allowed: %d",AM.OffsetIndex);
428 else AM.OffsetIndex = sp->value + 1;
429 AC.FixIndices = (WORD *)Malloc1((AM.OffsetIndex)*
sizeof(WORD),(
char *)(sp->parameter));
430 AM.WilInd = AM.OffsetIndex + WILDOFFSET;
431 AM.DumInd = AM.OffsetIndex + 2*WILDOFFSET;
432 AM.IndDum = AM.DumInd + WILDOFFSET;
434 AR.CurDum = AN.IndDum = AM.IndDum;
436 AM.mTraceDum = AM.IndDum + 2*WILDOFFSET;
438 sp = GetSetupPar((UBYTE *)
"parentheses");
439 AM.MaxParLevel = sp->value+1;
440 AC.tokenarglevel = (WORD *)Malloc1((sp->value+1)*
sizeof(WORD),(
char *)(sp->parameter));
444 sp = GetSetupPar((UBYTE *)
"maxnumbersize");
458 AM.MaxTal = (AM.MaxTer/
sizeof(WORD)-2)/2;
460 AM.MaxTal &= -
sizeof(WORD)*2;
461 sp->value = AM.MaxTal;
468 AT.n_coef = (WORD *)Malloc1(
sizeof(WORD)*4*AM.MaxTal+2,(
char *)(sp->parameter));
469 AT.n_llnum = AT.n_coef + 2*AM.MaxTal;
471 AC.cmod = (UWORD *)Malloc1(AM.MaxTal*4*
sizeof(UWORD),(
char *)(sp->parameter));
472 AM.gcmod = AC.cmod + AM.MaxTal;
473 AC.powmod = AM.gcmod + AM.MaxTal;
474 AM.gpowmod = AC.powmod + AM.MaxTal;
480 sp = GetSetupPar((UBYTE *)
"scratchsize");
481 AM.ScratSize = sp->value/
sizeof(WORD);
482 if ( AM.ScratSize < 4*AM.MaxTer ) AM.ScratSize = 4*AM.MaxTer;
483 AM.HideSize = AM.ScratSize;
484 sp = GetSetupPar((UBYTE *)
"hidesize");
485 if ( sp->value > 0 ) {
486 AM.HideSize = sp->value/
sizeof(WORD);
487 if ( AM.HideSize < 4*AM.MaxTer ) AM.HideSize = 4*AM.MaxTer;
489 sp = GetSetupPar((UBYTE *)
"factorizationcache");
490 AM.fbuffersize = sp->value;
492 sp = GetSetupPar((UBYTE *)
"threadscratchsize");
493 AM.ThreadScratSize = sp->value/
sizeof(WORD);
494 sp = GetSetupPar((UBYTE *)
"threadscratchoutsize");
495 AM.ThreadScratOutSize = sp->value/
sizeof(WORD);
498 for ( j = 0; j < 2; j++ ) {
500 ScratchBuf = (WORD *)Malloc1(AM.ScratSize*
sizeof(WORD),
"scratchsize");
501 AR.Fscr[j].POsize = AM.ScratSize *
sizeof(WORD);
502 AR.Fscr[j].POfull = AR.Fscr[j].POfill = AR.Fscr[j].PObuffer = ScratchBuf;
503 AR.Fscr[j].POstop = AR.Fscr[j].PObuffer + AM.ScratSize;
504 PUTZERO(AR.Fscr[j].POposition);
506 AR.Fscr[2].PObuffer = 0;
508 sp = GetSetupPar((UBYTE *)
"threadbucketsize");
509 AC.ThreadBucketSize = AM.gThreadBucketSize = AM.ggThreadBucketSize = sp->value;
510 sp = GetSetupPar((UBYTE *)
"threadloadbalancing");
511 AC.ThreadBalancing = AM.gThreadBalancing = AM.ggThreadBalancing = sp->value;
512 sp = GetSetupPar((UBYTE *)
"threadsortfilesynch");
513 AC.ThreadSortFileSynch = AM.gThreadSortFileSynch = AM.ggThreadSortFileSynch = sp->value;
517 sp = GetSetupPar((UBYTE *)
"shmwinsize");
518 AM.shmWinSize = sp->value/
sizeof(WORD);
519 if ( AM.shmWinSize < 4*AM.MaxTer ) AM.shmWinSize = 4*AM.MaxTer;
523 sp = GetSetupPar((UBYTE *)
"smallsize");
524 SmallSize = sp->value;
525 sp = GetSetupPar((UBYTE *)
"smallextension");
526 SmallEsize = sp->value;
527 sp = GetSetupPar((UBYTE *)
"largesize");
528 LargeSize = sp->value;
529 sp = GetSetupPar((UBYTE *)
"termsinsmall");
530 TermsInSmall = sp->value;
531 sp = GetSetupPar((UBYTE *)
"largepatches");
532 MaxPatches = sp->value;
533 sp = GetSetupPar((UBYTE *)
"filepatches");
534 MaxFpatches = sp->value;
535 sp = GetSetupPar((UBYTE *)
"sortiosize");
537 if ( IOsize < AM.MaxTer ) { IOsize = AM.MaxTer; sp->value = IOsize; }
540 for ( j = 0; j < 2; j++ ) { AR.Fscr[j].ziosize = IOsize; }
544 AM.S0 = AllocSort(LargeSize,SmallSize,SmallEsize,TermsInSmall
545 ,MaxPatches,MaxFpatches,IOsize);
547 AM.S0->file.ziosize = IOsize;
549 AR.FoStage4[0].ziosize = IOsize;
550 AR.FoStage4[1].ziosize = IOsize;
559 AR.FoStage4[0].POsize = ((IOsize+
sizeof(WORD)-1)/
sizeof(WORD))*
sizeof(WORD);
560 AR.FoStage4[1].POsize = ((IOsize+
sizeof(WORD)-1)/
sizeof(WORD))*
sizeof(WORD);
562 sp = GetSetupPar((UBYTE *)
"subsmallsize");
563 AM.SSmallSize = sp->value;
564 sp = GetSetupPar((UBYTE *)
"subsmallextension");
565 AM.SSmallEsize = sp->value;
566 sp = GetSetupPar((UBYTE *)
"sublargesize");
567 AM.SLargeSize = sp->value;
568 sp = GetSetupPar((UBYTE *)
"subtermsinsmall");
569 AM.STermsInSmall = sp->value;
570 sp = GetSetupPar((UBYTE *)
"sublargepatches");
571 AM.SMaxPatches = sp->value;
572 sp = GetSetupPar((UBYTE *)
"subfilepatches");
573 AM.SMaxFpatches = sp->value;
574 sp = GetSetupPar((UBYTE *)
"subsortiosize");
575 AM.SIOsize = sp->value;
581 sp = GetSetupPar((UBYTE *)
"functionlevels");
582 AM.maxFlevels = sp->value + 1;
585 AT.Nest = (
NESTING)Malloc1((LONG)
sizeof(
struct NeStInG)*AM.maxFlevels,
"functionlevels");
586 AT.NestStop = AT.Nest + AM.maxFlevels;
587 AT.NestPoin = AT.Nest;
590 sp = GetSetupPar((UBYTE *)
"maxwildcards");
591 AM.MaxWildcards = sp->value;
594 AT.WildMask = (WORD *)Malloc1((LONG)AM.MaxWildcards*
sizeof(WORD),
"maxwildcards");
597 sp = GetSetupPar((UBYTE *)
"compresssize");
598 if ( sp->value < 2*AM.MaxTer ) sp->value = 2*AM.MaxTer;
599 AM.CompressSize = sp->value;
601 AR.CompressBuffer = (WORD *)Malloc1((AM.CompressSize+10)*
sizeof(WORD),
"compresssize");
602 AR.ComprTop = AR.CompressBuffer + AM.CompressSize;
604 sp = GetSetupPar((UBYTE *)
"bracketindexsize");
605 if ( sp->value < 20*AM.MaxTer ) sp->value = 20*AM.MaxTer;
606 AM.MaxBracketBufferSize = sp->value/
sizeof(WORD);
608 sp = GetSetupPar((UBYTE *)
"dotchar");
609 AO.FortDotChar = ((UBYTE *)(sp->value))[0];
610 sp = GetSetupPar((UBYTE *)
"commentchar");
611 AP.cComChar = AP.ComChar = ((UBYTE *)(sp->value))[0];
612 sp = GetSetupPar((UBYTE *)
"procedureextension");
616 s = (UBYTE *)(sp->value);
617 if ( FG.cTable[*s] != 0 ) {
618 MesPrint(
" Illegal string for procedure extension %s",(UBYTE *)sp->value);
624 if ( *s ==
' ' || *s ==
'\t' || *s ==
'\n' ) {
625 MesPrint(
" Illegal string for procedure extension %s",(UBYTE *)sp->value);
632 AP.cprocedureExtension = strDup1((UBYTE *)(sp->value),
"procedureExtension");
633 AP.procedureExtension = strDup1(AP.cprocedureExtension,
"procedureExtension");
635 sp = GetSetupPar((UBYTE *)
"totalsize");
636 if ( sp->value != 2 ) AM.PrintTotalSize = sp->value;
638 sp = GetSetupPar((UBYTE *)
"continuationlines");
639 AM.FortranCont = sp->value;
640 if ( AM.FortranCont <= 0 ) AM.FortranCont = 1;
641 sp = GetSetupPar((UBYTE *)
"oldorder");
642 AM.OldOrderFlag = sp->value;
643 sp = GetSetupPar((UBYTE *)
"resettimeonclear");
644 AM.resetTimeOnClear = sp->value;
645 sp = GetSetupPar((UBYTE *)
"nospacesinnumbers");
646 AO.NoSpacesInNumbers = AM.gNoSpacesInNumbers = AM.ggNoSpacesInNumbers = sp->value;
647 sp = GetSetupPar((UBYTE *)
"indentspace");
648 AO.IndentSpace = AM.gIndentSpace = AM.ggIndentSpace = sp->value;
649 sp = GetSetupPar((UBYTE *)
"nwritestatistics");
650 AC.StatsFlag = AM.gStatsFlag = AM.ggStatsFlag = 1-sp->value;
651 sp = GetSetupPar((UBYTE *)
"nwritefinalstatistics");
652 AC.FinalStats = AM.gFinalStats = AM.ggFinalStats = 1-sp->value;
653 sp = GetSetupPar((UBYTE *)
"nwritethreadstatistics");
654 AC.ThreadStats = AM.gThreadStats = AM.ggThreadStats = 1-sp->value;
655 sp = GetSetupPar((UBYTE *)
"nwriteprocessstatistics");
656 AC.ProcessStats = AM.gProcessStats = AM.ggProcessStats = 1-sp->value;
657 sp = GetSetupPar((UBYTE *)
"oldparallelstatistics");
658 AC.OldParallelStats = AM.gOldParallelStats = AM.ggOldParallelStats = sp->value;
659 sp = GetSetupPar((UBYTE *)
"oldfactarg");
660 AC.OldFactArgFlag = AM.gOldFactArgFlag = AM.ggOldFactArgFlag = sp->value;
661 sp = GetSetupPar((UBYTE *)
"sorttype");
662 if ( StrICmp((UBYTE *)
"lowfirst",(UBYTE *)sp->value) == 0 ) {
663 AC.lSortType = SORTLOWFIRST;
665 else if ( StrICmp((UBYTE *)
"highfirst",(UBYTE *)sp->value) == 0 ) {
666 AC.lSortType = SORTHIGHFIRST;
669 MesPrint(
" Illegal SortType specification: %s",(UBYTE *)sp->value);
673 sp = GetSetupPar((UBYTE *)
"processbucketsize");
674 AM.hProcessBucketSize = AM.gProcessBucketSize =
675 AC.ProcessBucketSize = AC.mProcessBucketSize = sp->value;
679 sp = GetSetupPar((UBYTE *)
"numstorecaches");
680 AM.NumStoreCaches = sp->value;
681 sp = GetSetupPar((UBYTE *)
"sizestorecache");
682 AM.SizeStoreCache = sp->value;
688 AT.StoreCache = AT.StoreCacheAlloc = 0;
689 if ( AM.NumStoreCaches > 0 ) {
691 size =
sizeof(
struct StOrEcAcHe)+AM.SizeStoreCache;
692 size = ((size-1)/
sizeof(
size_t)+1)*
sizeof(
size_t);
693 AT.StoreCacheAlloc = (
STORECACHE)Malloc1(size*AM.NumStoreCaches,
"StoreCaches");
694 AT.StoreCache = AT.StoreCacheAlloc;
696 for ( j = 0; j < AM.NumStoreCaches; j++ ) {
698 if ( j == AM.NumStoreCaches-1 ) {
704 SETBASEPOSITION(sa->position,-1);
705 SETBASEPOSITION(sa->toppos,-1);
714 if ( AM.Path == 0 ) {
715 sp = GetSetupPar((UBYTE *)
"path");
716 AM.Path = strDup1((UBYTE *)(sp->value),
"path");
718 if ( AM.IncDir == 0 ) {
719 sp = GetSetupPar((UBYTE *)
"incdir");
720 AM.IncDir = strDup1((UBYTE *)(sp->value),
"incdir");
752 MesPrint(
" The setup parameters are:");
753 for ( sp = setupparameters; n > 0; n--, sp++ ) {
756 MesPrint(
" %s: %l",sp->parameter,sp->value);
759 if ( StrICmp(sp->parameter,(UBYTE *)
"path") == 0 && AM.Path ) {
760 MesPrint(
" %s: '%s'",sp->parameter,(UBYTE *)(AM.Path));
763 if ( StrICmp(sp->parameter,(UBYTE *)
"incdir") == 0 && AM.IncDir ) {
764 MesPrint(
" %s: '%s'",sp->parameter,(UBYTE *)(AM.IncDir));
768 if ( StrICmp(sp->parameter,(UBYTE *)
"tempdir") == 0 && AM.TempDir ) {
769 MesPrint(
" %s: '%s'",sp->parameter,(UBYTE *)(AM.TempDir));
772 MesPrint(
" %s: '%s'",sp->parameter,(UBYTE *)(sp->value));
776 if ( sp->value == 0 )
777 MesPrint(
" %s: OFF",sp->parameter);
778 else if ( sp->value == 1 )
779 MesPrint(
" %s: ON",sp->parameter);
800 SORTING *AllocSort(LONG LargeSize, LONG SmallSize, LONG SmallEsize, LONG TermsInSmall,
801 int MaxPatches,
int MaxFpatches, LONG IOsize)
803 LONG allocation,longer,terms2insmall,sortsize,longerp;
804 LONG IObuffersize = IOsize;
811 while ( *s ) { s++; i++; }
815 if ( MaxFpatches < 4 ) MaxFpatches = 4;
816 longer = MaxPatches > MaxFpatches ? MaxPatches : MaxFpatches;
818 while ( (1 << j) < longerp ) j++;
819 longerp = (1 << j) + 1;
820 longerp +=
sizeof(WORD*) - (longerp%
sizeof(WORD *));
822 longer +=
sizeof(WORD*) - (longer%
sizeof(WORD *));
823 TermsInSmall = (TermsInSmall+15) & (-16L);
824 terms2insmall = 2*TermsInSmall;
825 if ( SmallEsize < (SmallSize*3)/2 ) SmallEsize = (SmallSize*3)/2;
826 if ( SmallEsize < 3*AM.MaxTer ) SmallEsize = 3*AM.MaxTer;
827 SmallEsize = (SmallEsize+15) & (-16L);
828 if ( LargeSize < 0 ) LargeSize = 0;
830 sortsize = (sortsize+15)&(-16L);
831 IObuffersize = (IObuffersize+
sizeof(WORD)-1)/
sizeof(WORD);
837 if ( (ULONG)( LargeSize+SmallEsize ) < MaxFpatches*((IObuffersize
838 +COMPINC)*
sizeof(WORD)+2*AM.MaxTer) ) {
839 if ( LargeSize == 0 )
840 SmallEsize = MaxFpatches*((IObuffersize+COMPINC)*
sizeof(WORD)+2*AM.MaxTer);
842 LargeSize = MaxFpatches*((IObuffersize+COMPINC)*
sizeof(WORD)+2*AM.MaxTer)
846 IOtry = ((LargeSize+SmallEsize)/MaxFpatches-2*AM.MaxTer)/
sizeof(WORD)-COMPINC;
848 if ( (LONG)(IObuffersize*
sizeof(WORD)) < IOtry )
849 IObuffersize = (IOtry+
sizeof(WORD)-1)/
sizeof(WORD);
853 +2*
sizeof(WORD *)*longer
854 +2*(longerp*(
sizeof(WORD *)+
sizeof(WORD)))
855 +(3*longerp+2)*
sizeof(WORD)
856 +terms2insmall*
sizeof(WORD *)
857 +terms2insmall*
sizeof(WORD *)/2
861 +IObuffersize*
sizeof(WORD) + i + 16;
862 sort = (
SORTING *)Malloc1(allocation,
"sort buffers");
864 sort->LargeSize = LargeSize/
sizeof(WORD);
865 sort->SmallSize = SmallSize/
sizeof(WORD);
866 sort->SmallEsize = SmallEsize/
sizeof(WORD);
867 sort->MaxPatches = MaxPatches;
868 sort->MaxFpatches = MaxFpatches;
869 sort->TermsInSmall = TermsInSmall;
870 sort->Terms2InSmall = terms2insmall;
872 sort->sPointer = (WORD **)(sort+1);
873 sort->SplitScratch = sort->sPointer + terms2insmall;
874 sort->Patches = (WORD **)(sort->SplitScratch + terms2insmall/2);
875 sort->pStop = sort->Patches+longer;
876 sort->poina = sort->pStop+longer;
877 sort->poin2a = sort->poina + longerp;
878 sort->fPatches = (
POSITION *)(sort->poin2a+longerp);
879 sort->fPatchesStop = sort->fPatches + longer;
880 sort->inPatches = sort->fPatchesStop + longer;
881 sort->tree = (WORD *)(sort->inPatches + longer);
882 sort->used = sort->tree+longerp;
884 sort->fpcompressed = sort->used+longerp;
885 sort->fpincompressed = sort->fpcompressed+longerp;
886 sort->ktoi = sort->fpincompressed+longerp;
889 sort->ktoi = sort->used + longerp;
891 sort->lBuffer = (WORD *)(sort->ktoi + longerp + 2);
892 sort->lTop = sort->lBuffer+sort->LargeSize;
893 sort->sBuffer = sort->lTop;
894 if ( sort->LargeSize == 0 ) { sort->lBuffer = 0; sort->lTop = 0; }
895 sort->sTop = sort->sBuffer + sort->SmallSize;
896 sort->sTop2 = sort->sBuffer + sort->SmallEsize;
897 sort->sHalf = sort->sBuffer + (LONG)((sort->SmallSize+sort->SmallEsize)>>1);
898 sort->file.PObuffer = (WORD *)(sort->sTop2);
899 sort->file.POstop = sort->file.PObuffer+IObuffersize;
900 sort->file.POsize = IObuffersize *
sizeof(WORD);
901 sort->file.POfill = sort->file.POfull = sort->file.PObuffer;
902 sort->file.active = 0;
904 PUTZERO(sort->file.POposition);
906 sort->file.pthreadslock = dummylock;
910 sort->file.ziosize = IObuffersize*
sizeof(WORD);
913 sort->file.name = (
char *)(sort->file.PObuffer + IObuffersize);
914 AllocSortFileName(sort);
916 else sort->file.name = 0;
918 sort->cBufferSize = 0;
929 VOID AllocSortFileName(
SORTING *sort)
937 s = FG.fname; t = sort->file.name;
938 while ( *s ) *t++ = *s++;
941 sprintf(t-1,
"%d.%d",identity,AN.filenum);
944 sprintf(t-1,
"%d",AN.filenum);
963 while ( *s ) { s++; i++; }
967 allocation =
sizeof(
FILEHANDLE) + (AM.SIOsize+1)*
sizeof(WORD) + i*
sizeof(
char);
968 fh = (
FILEHANDLE *)Malloc1(allocation,
"FileHandle");
970 fh->PObuffer = (WORD *)(fh+1);
971 fh->POstop = fh->PObuffer+AM.SIOsize;
972 fh->POsize = AM.SIOsize *
sizeof(WORD);
975 PUTZERO(fh->POposition);
977 fh->pthreadslock = dummylock;
980 fh->name = (
char *)(fh->POstop + 1);
981 s = FG.fname; t = fh->name;
982 while ( *s ) *t++ = *s++;
985 sprintf(t-1,
"%d-%d",identity,AN.filenum);
988 sprintf(t-1,
"%d",AN.filenum);
993 fh->POfill = fh->POfull = fh->PObuffer;
1013 M_free(fh,
"Temporary FileHandle");
1021 int MakeSetupAllocs()
1023 if ( RecalcSetups() || AllocSetups() )
return(1);
1039 #define SETBUFSIZE 257 1043 LONG oldstreamposition;
1045 int error = 0, eqnum;
1046 int oldNoShowInput = AC.NoShowInput;
1047 UBYTE buff[SETBUFSIZE+1], *s, *t, *u, *settop, c;
1048 LONG linenum, prevline;
1050 if ( AC.CurrentStream == 0 )
return(error);
1051 oldstream = AC.CurrentStream - AC.Streams;
1052 oldstreamposition = GetStreamPosition(AC.CurrentStream);
1053 linenum = AC.CurrentStream->linenumber;
1054 prevline = AC.CurrentStream->prevline;
1055 eqnum = AC.CurrentStream->eqnum;
1057 settop = buff + SETBUFSIZE;
1060 if ( c ==
'*' || c ==
'\n' ) {
1061 while ( c !=
'\n' && c != ENDOFINPUT ) c = GetInput();
1062 if ( c == ENDOFINPUT )
goto eoi;
1065 if ( c == ENDOFINPUT )
goto eoi;
1066 if ( c !=
'#' )
break;
1068 if ( c == ENDOFINPUT )
goto eoi;
1069 if ( c !=
'-' && c !=
'+' && c !=
':' )
break;
1071 while ( c !=
'\n' && c != ENDOFINPUT ) c = GetInput();
1075 while ( ( c = GetInput() ) ==
' ' || c ==
'\t' || c ==
'\r' ) {}
1076 if ( c == ENDOFINPUT )
break;
1077 if ( c == LINEFEED )
continue;
1078 if ( c == 0 || c == ENDOFINPUT )
break;
1079 while ( c != LINEFEED ) {
1082 if ( c != LINEFEED && c !=
'\r' )
continue;
1083 if ( s >= settop ) {
1084 while ( c !=
'\n' && c != ENDOFINPUT ) c = GetInput();
1085 MesPrint(
"Setups in .frm file: Line too long. setup ignored");
1086 error++;
goto nextline;
1091 while ( tolower(*s) >=
'a' && tolower(*s) <=
'z' ) s++;
1093 while ( *s ==
' ' || *s ==
'\t' ) s++;
1095 while ( *s && *s !=
'\n' && *s !=
'\r' ) s++;
1097 error += ProcessOption(t,u,1);
1100 AC.NoShowInput = oldNoShowInput;
1101 AC.CurrentStream = AC.Streams + oldstream;
1102 PositionStream(AC.CurrentStream,oldstreamposition);
1103 AC.CurrentStream->linenumber = linenum;
1104 AC.CurrentStream->prevline = prevline;
1105 AC.CurrentStream->eqnum = eqnum;
1109 MesPrint(
"Input file without a program.");
1118 int TryEnvironment()
1120 char *s, *t, *u, varname[100];
1123 varname[0] =
'F'; varname[1] =
'O'; varname[2] =
'R'; varname[3] =
'M';
1124 varname[4] =
'_'; varname[5] = 0;
1125 for ( i = 0; i < imax; i++ ) {
1126 t = s = (
char *)(setupparameters[i].parameter);
1128 while ( *s ) { *u++ = (char)(toupper((
unsigned char)*s)); s++; }
1130 s = (
char *)(getenv(varname));
1132 error += ProcessOption((UBYTE *)t,(UBYTE *)s,2);
struct StOrEcAcHe * STORECACHE
int TheDefine(UBYTE *, int)