47 typedef UBYTE *va_list;
48 #define va_dcl int va_alist; 49 #define va_start(list) list = (UBYTE *) &va_alist 51 #define va_arg(list,mode) (((mode *)(list += sizeof(mode)))[-1]) 56 static int startinline = 0;
57 static char fcontchar =
'&';
58 static int noextralinefeed = 0;
59 static int lowestlevel = 1;
67 UBYTE *StrCopy(UBYTE *from, UBYTE *to)
69 while( ( *to++ = *from++ ) != 0 );
82 VOID AddToLine(UBYTE *s)
87 if ( AO.OutInBuffer ) { AddToDollarBuffer(s);
return; }
90 if ( Out >= AO.OutStop ) {
91 if ( AC.OutputMode == FORTRANMODE && AC.IsFortran90 == ISFORTRAN90 ) {
95 *Out++ = CARRIAGERETURN;
99 num = Out - AO.OutputLine;
101 if ( AC.LogHandle >= 0 ) {
102 if ( WriteFile(AC.LogHandle,AO.OutputLine+startinline
103 ,num-startinline) != (num-startinline) ) {
109 if ( BUG.logfileflag == 0 ) {
110 fprintf(stderr,
"Panic: Cannot write to log file! Disk full?\n");
113 BUG.eflag = 1; BUG.printflag = 1;
120 if ( ( AO.PrintType & PRINTLFILE ) == 0 ) {
122 if ( num > 1 && AO.OutputLine[num-2] == CARRIAGERETURN ) {
123 AO.OutputLine[num-2] = LINEFEED;
127 if ( WriteFile(AM.StdOut,AO.OutputLine+startinline
128 ,num-startinline) != (num-startinline) ) {
130 if ( BUG.stdoutflag == 0 ) {
131 fprintf(stderr,
"Panic: Cannot write to standard output!\n");
134 BUG.eflag = 1; BUG.printflag = 1;
148 for ( i = 0; i < AO.OutSkip; i++ ) AO.OutputLine[i] =
' ';
149 Out = AO.OutputLine + AO.OutSkip;
150 if ( ( AC.OutputMode == FORTRANMODE
151 || AC.OutputMode == PFORTRANMODE ) && AO.OutSkip == 7 ) {
153 if(AC.IsFortran90 == ISFORTRAN90) {
161 if ( AO.IsBracket ) { *Out++ =
' ';
162 if ( AC.OutputSpaces == NORMALFORMAT ) {
163 *Out++ =
' '; *Out++ =
' '; }
166 if ( AC.OutputMode == FORTRANMODE
167 || ( AC.OutputMode == CMODE && AO.FactorMode == 0 )
168 || AC.OutputMode == PFORTRANMODE )
187 if ( AO.OutInBuffer )
return;
189 while ( Out > AO.OutputLine ) {
190 if ( Out[-1] ==
' ' ) Out--;
193 i = (WORD)(Out-AO.OutputLine);
194 if ( noextralinefeed == 0 ) {
195 if ( AC.OutputMode == FORTRANMODE && AC.IsFortran90 == ISFORTRAN90
196 && Out > AO.OutputLine ) {
202 *Out++ = CARRIAGERETURN;
207 num = Out - AO.OutputLine;
209 if ( AC.LogHandle >= 0 ) {
210 if ( WriteFile(AC.LogHandle,AO.OutputLine+startinline
211 ,num-startinline) != (num-startinline) ) {
213 if ( BUG.logfileflag == 0 ) {
214 fprintf(stderr,
"Panic: Cannot write to log file! Disk full?\n");
217 BUG.eflag = 1; BUG.printflag = 1;
224 if ( ( AO.PrintType & PRINTLFILE ) == 0 ) {
226 if ( num > 1 && AO.OutputLine[num-2] == CARRIAGERETURN ) {
227 AO.OutputLine[num-2] = LINEFEED;
231 if ( WriteFile(AM.StdOut,AO.OutputLine+startinline,
232 num-startinline) != (num-startinline) ) {
234 if ( BUG.stdoutflag == 0 ) {
235 fprintf(stderr,
"Panic: Cannot write to standard output!\n");
238 BUG.eflag = 1; BUG.printflag = 1;
245 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE
246 || ( AC.OutputMode == CMODE && AO.FactorMode == 0 ) ) AO.InFbrack++;
248 AO.OutStop = Out + AC.LineLength;
250 while ( --i >= 0 ) *Out++ =
' ';
251 if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
252 && AO.OutSkip == 7 ) {
267 VOID IniLine(WORD extrablank)
271 AO.OutStop = Out + AC.LineLength;
277 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE ) {
284 while ( extrablank > 0 ) {
301 static UBYTE *LLscratch = 0;
303 VOID LongToLine(UWORD *a, WORD na)
306 if ( LLscratch == 0 ) {
307 LLscratch = (UBYTE *)Malloc1(4*(AM.MaxTal*
sizeof(WORD)+2)*
sizeof(UBYTE),
"LongToLine");
309 OutScratch = LLscratch;
310 if ( na < 0 ) na = -na;
312 PrtLong(a,na,OutScratch);
313 if ( AO.NoSpacesInNumbers || AC.OutputMode == REDUCEMODE ) {
315 TokenToLine(OutScratch);
319 TokenToLine(OutScratch);
322 else if ( !na ) TokenToLine((UBYTE *)
"0");
334 static UBYTE *RLscratch = 0;
335 static UWORD *RLscratE = 0;
337 VOID RatToLine(UWORD *a, WORD na)
341 if ( na < 0 ) na = -na;
342 if ( AC.OutNumberType == RATIONALMODE ) {
351 if ( AC.OutputMode == PFORTRANMODE ) {
352 UnPack(a,na,&adenom,&anumer);
353 if ( na == 1 && a[0] == 1 && a[1] == 1 ) {
354 AddToLine((UBYTE *)
"one");
357 if ( adenom == 1 && a[na] == 1 ) {
358 LongToLine(a,anumer);
359 if ( anumer > 1 ) { AddToLine((UBYTE *)
".D0"); }
361 else if ( anumer == 1 && a[0] == 1 ) {
363 AddToLine((UBYTE *)
"(one/");
364 LongToLine(a,adenom);
365 if ( adenom > 1 ) { AddToLine((UBYTE *)
".D0"); }
366 AddToLine((UBYTE *)
")");
369 if ( anumer > 1 || adenom > 1 ) {
370 LongToLine(a,anumer);
371 if ( anumer > 1 ) { AddToLine((UBYTE *)
".D0"); }
373 AddToLine((UBYTE *)
"/");
374 LongToLine(a,adenom);
375 if ( adenom > 1 ) { AddToLine((UBYTE *)
".D0"); }
378 AddToLine((UBYTE *)
"((one*");
379 LongToLine(a,anumer);
381 AddToLine((UBYTE *)
")/");
382 LongToLine(a,adenom);
383 AddToLine((UBYTE *)
")");
388 UnPack(a,na,&adenom,&anumer);
389 LongToLine(a,anumer);
391 if ( anumer && !( adenom == 1 && *a == 1 ) ) {
392 if ( AC.OutputMode == FORTRANMODE && AC.IsFortran90 == ISFORTRAN90 ) {
393 if ( AC.Fortran90Kind ) {
394 AddToLine(AC.Fortran90Kind);
395 AddToLine((UBYTE *)
"/");
398 AddToLine((UBYTE *)
"./");
401 else if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == CMODE ) {
402 if ( AO.DoubleFlag ) { AddToLine((UBYTE *)
".D0/"); }
403 else { AddToLine((UBYTE *)
"./"); }
405 else AddToLine((UBYTE *)
"/");
406 LongToLine(a,adenom);
407 if ( AC.OutputMode == FORTRANMODE && AC.IsFortran90 == ISFORTRAN90 ) {
408 if ( AC.Fortran90Kind ) {
409 AddToLine(AC.Fortran90Kind);
412 AddToLine((UBYTE *)
".");
415 else if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == CMODE ) {
416 if ( AO.DoubleFlag ) { AddToLine((UBYTE *)
".D0"); }
417 else { AddToLine((UBYTE *)
"."); }
420 else if ( anumer > 1 && ( AC.OutputMode == FORTRANMODE
421 || AC.OutputMode == CMODE ) ) {
422 if ( AC.OutputMode == FORTRANMODE && AC.IsFortran90 == ISFORTRAN90 ) {
423 if ( AC.Fortran90Kind ) {
424 AddToLine(AC.Fortran90Kind);
427 AddToLine((UBYTE *)
".");
430 else if ( AO.DoubleFlag ) { AddToLine((UBYTE *)
".D0"); }
431 else { AddToLine((UBYTE *)
"."); }
433 else if ( AC.OutputMode == FORTRANMODE && AC.IsFortran90 == ISFORTRAN90 ) {
434 if ( AC.Fortran90Kind ) {
435 AddToLine(AC.Fortran90Kind);
438 AddToLine((UBYTE *)
".");
441 else if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == CMODE )
443 AddToLine((UBYTE *)
".D0");
452 WORD exponent = 0, i, ndig, newl;
453 UWORD *c, *den, b = 10, dig[10];
458 if ( RLscratch == 0 ) {
459 RLscratch = (UBYTE *)Malloc1(4*(AM.MaxTal+2)*
sizeof(UBYTE),
"RatToLine");
460 RLscratE = (UWORD *)Malloc1(2*(AM.MaxTal+2)*
sizeof(UWORD),
"RatToLine");
462 out = OutScratch = RLscratch;
463 c = RLscratE;
for ( i = 0; i < 2*na; i++ ) c[i] = a[i];
464 UnPack(c,na,&adenom,&anumer);
465 while ( BigLong(c,anumer,c+na,adenom) >= 0 ) {
466 Divvy(BHEAD c,&na,&b,1);
467 UnPack(c,na,&adenom,&anumer);
470 while ( BigLong(c,anumer,c+na,adenom) < 0 ) {
471 Mully(BHEAD c,&na,&b,1);
472 UnPack(c,na,&adenom,&anumer);
479 DivLong(c,anumer,den,adenom,dig,&ndig,c,&newl);
480 *out++ = (UBYTE)(dig[0]+
'0'); *out++ =
'.';
481 while ( newl && i < AC.OutNumberType ) {
482 Pack(c,&newl,den,adenom);
483 Mully(BHEAD c,&newl,&b,1);
485 UnPack(c,na,&adenom,&anumer);
487 DivLong(c,anumer,den,adenom,dig,&ndig,c,&newl);
488 if ( ndig == 0 ) *out++ =
'0';
489 else *out++ = (UBYTE)(dig[0]+
'0');
493 if ( exponent < 0 ) { exponent = -exponent; *out++ =
'-'; }
494 else { *out++ =
'+'; }
497 *out++ = (UBYTE)((exponent % 10)+
'0');
499 }
while ( exponent );
501 while ( o < out ) { cc = *o; *o = *out; *out = cc; o++; out--; }
502 TokenToLine(OutScratch);
516 VOID TalToLine(UWORD x)
518 UBYTE t[BITSINWORD/3+1];
522 do { *s++ = (UBYTE)((x % 10)+
'0'); i++; }
while ( ( x /= 10 ) != 0 );
526 i = t[j]; t[j] = s[-j]; s[-j] = (UBYTE)i; j--;
545 VOID TokenToLine(UBYTE *s)
549 if ( AO.OutInBuffer ) { AddToDollarBuffer(s);
return; }
550 t = s; Out = AO.OutFill;
553 if ( ( Out + i ) >= AO.OutStop && ( ( i < ((AC.LineLength-AO.OutSkip)>>1) )
554 || ( (AO.OutStop-Out) < (i>>2) ) ) ) {
555 if ( AC.OutputMode == FORTRANMODE && AC.IsFortran90 == ISFORTRAN90 ) {
559 *Out++ = CARRIAGERETURN;
563 num = Out - AO.OutputLine;
564 if ( AC.LogHandle >= 0 ) {
565 if ( WriteFile(AC.LogHandle,AO.OutputLine+startinline,
566 num-startinline) != (num-startinline) ) {
568 if ( BUG.logfileflag == 0 ) {
569 fprintf(stderr,
"Panic: Cannot write to log file! Disk full?\n");
572 BUG.eflag = 1; BUG.printflag = 1;
578 if ( ( AO.PrintType & PRINTLFILE ) == 0 ) {
580 if ( num > 1 && AO.OutputLine[num-2] == CARRIAGERETURN ) {
581 AO.OutputLine[num-2] = LINEFEED;
585 if ( WriteFile(AM.StdOut,AO.OutputLine+startinline,
586 num-startinline) != (num-startinline) ) {
588 if ( BUG.stdoutflag == 0 ) {
589 fprintf(stderr,
"Panic: Cannot write to standard output!\n");
592 BUG.eflag = 1; BUG.printflag = 1;
600 if ( AO.BlockSpaces == 0 ) {
601 for ( j = 0; j < AO.OutSkip; j++ ) { *Out++ =
' '; }
602 if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE ) ) {
603 if ( AO.OutSkip == 7 ) {
620 if ( AO.IsBracket ) { *Out++ =
' '; *Out++ =
' '; *Out++ =
' '; }
622 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE
623 || ( AC.OutputMode == CMODE && AO.FactorMode == 0 ) ) AO.InFbrack++;
625 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE ) {
627 if ( i > (WORD)(AO.OutStop-Out) ) j = (WORD)(AO.OutStop - Out);
633 if ( i > (WORD)(AO.OutStop-Out) ) j = (WORD)(AO.OutStop - Out - 1);
637 if ( i > 0 ) *Out++ =
'\\';
652 UBYTE *CodeToLine(WORD number, UBYTE *Out)
654 Out = StrCopy((UBYTE *)
"(",Out);
655 Out = NumCopy(number,Out);
656 Out = StrCopy((UBYTE *)
")",Out);
665 UBYTE *AddArrayIndex(WORD num,UBYTE *out)
667 if ( AC.OutputMode == CMODE ) {
668 out = StrCopy((UBYTE *)
"[",out);
669 out = NumCopy(num,out);
670 out = StrCopy((UBYTE *)
"]",out);
673 out = StrCopy((UBYTE *)
"(",out);
674 out = NumCopy(num,out);
675 out = StrCopy((UBYTE *)
")",out);
689 a[0] = (UWORD)AO.NumInBrack;
690 a[1] = (UWORD)(AO.NumInBrack >> BITSINWORD);
693 TokenToLine((UBYTE *)
" ");
695 if ( a[0] == 1 && na == 1 ) {
696 TokenToLine((UBYTE *)
" term");
698 else TokenToLine((UBYTE *)
" terms");
707 UBYTE *WrtPower(UBYTE *Out, WORD Power)
709 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE
710 || AC.OutputMode == REDUCEMODE ) {
711 *Out++ =
'*'; *Out++ =
'*';
713 else if ( AC.OutputMode == CMODE ) *Out++ =
',';
716 if ( Power < 2*MAXPOWER )
717 Out = NumCopy(Power,Out);
719 Out = StrCopy(VARNAME(symbols,(LONG)Power-2*MAXPOWER),Out);
720 if ( AC.OutputMode == CMODE ) *Out++ =
')';
724 if ( ( AC.OutputMode >= FORTRANMODE || AC.OutputMode >= PFORTRANMODE )
725 && AC.OutputMode != CMODE )
728 if ( Power > -2*MAXPOWER )
729 Out = NumCopy(-Power,Out);
731 Out = StrCopy(VARNAME(symbols,(LONG)(-Power)-2*MAXPOWER),Out);
732 if ( AC.OutputMode >= FORTRANMODE || AC.OutputMode >= PFORTRANMODE ) *Out++ =
')';
745 LONG millitime = TimeCPU(1);
746 WORD timepart = (WORD)(millitime%1000);
749 MesPrint(
"Time = %7l.%2i sec",millitime,timepart);
762 static UBYTE *symname[] = {
763 (UBYTE *)
"(cyclic)",(UBYTE *)
"(reversecyclic)" 764 ,(UBYTE *)
"(symmetric)",(UBYTE *)
"(antisymmetric)" };
765 static UBYTE *rsymname[] = {
766 (UBYTE *)
"(-cyclic)",(UBYTE *)
"(-reversecyclic)" 767 ,(UBYTE *)
"(-symmetric)",(UBYTE *)
"(-antisymmetric)" };
773 int first, startvalue;
776 CBUF *C = cbuf+AC.cbufnum;
779 AO.OutputLine = AO.OutFill = (UBYTE *)AT.WorkPointer;
781 OutScr = (UBYTE *)AT.WorkPointer + ( TOLONG(AT.WorkTop) - TOLONG(AT.WorkPointer) ) /2;
782 if ( AC.CodesFlag || AC.NamesFlag > 1 ) startvalue = 0;
783 else startvalue = FIRSTUSERSYMBOL;
784 if ( ( j = NumSymbols ) > startvalue ) {
785 TokenToLine((UBYTE *)
" Symbols");
788 for ( i = startvalue; i < j; i++ ) {
789 if ( i >= BUILTINSYMBOLS && i < FIRSTUSERSYMBOL )
continue;
790 Out = StrCopy(VARNAME(symbols,i),OutScr);
791 if ( symbols[i].minpower > -MAXPOWER || symbols[i].maxpower < MAXPOWER ) {
792 Out = StrCopy((UBYTE *)
"(",Out);
793 if ( symbols[i].minpower > -MAXPOWER )
794 Out = NumCopy(symbols[i].minpower,Out);
795 Out = StrCopy((UBYTE *)
":",Out);
796 if ( symbols[i].maxpower < MAXPOWER )
797 Out = NumCopy(symbols[i].maxpower,Out);
798 Out = StrCopy((UBYTE *)
")",Out);
800 if ( ( symbols[i].complex & VARTYPEIMAGINARY ) == VARTYPEIMAGINARY ) {
801 Out = StrCopy((UBYTE *)
"#i",Out);
803 else if ( ( symbols[i].complex & VARTYPECOMPLEX ) == VARTYPECOMPLEX ) {
804 Out = StrCopy((UBYTE *)
"#c",Out);
806 else if ( ( symbols[i].complex & VARTYPEROOTOFUNITY ) == VARTYPEROOTOFUNITY ) {
807 Out = StrCopy((UBYTE *)
"#",Out);
808 if ( ( symbols[i].complex & VARTYPEMINUS ) == VARTYPEMINUS ) {
809 Out = StrCopy((UBYTE *)
"-",Out);
812 Out = StrCopy((UBYTE *)
"+",Out);
814 Out = NumCopy(symbols[i].maxpower,Out);
816 if ( AC.CodesFlag ) Out = CodeToLine(i,Out);
817 if ( ( symbols[i].complex & VARTYPECOMPLEX ) == VARTYPECOMPLEX ) i++;
818 StrCopy((UBYTE *)
" ",Out);
824 if ( AC.CodesFlag || AC.NamesFlag > 1 ) startvalue = 0;
825 else startvalue = BUILTININDICES;
826 if ( ( j = NumIndices ) > startvalue ) {
827 TokenToLine((UBYTE *)
" Indices");
830 for ( i = startvalue; i < j; i++ ) {
831 Out = StrCopy(VARNAME(indices,i),OutScr);
832 if ( indices[i].dimension >= 0 ) {
833 if ( indices[i].dimension != AC.lDefDim ) {
834 Out = StrCopy((UBYTE *)
"=",Out);
835 Out = NumCopy(indices[i].dimension,Out);
838 else if ( indices[i].dimension < 0 ) {
839 Out = StrCopy((UBYTE *)
"=",Out);
840 Out = StrCopy(VARNAME(symbols,-indices[i].dimension),Out);
841 if ( indices[i].nmin4 < -NMIN4SHIFT ) {
842 Out = StrCopy((UBYTE *)
":",Out);
843 Out = StrCopy(VARNAME(symbols,-indices[i].nmin4-NMIN4SHIFT),Out);
846 if ( AC.CodesFlag ) Out = CodeToLine(i+AM.OffsetIndex,Out);
847 StrCopy((UBYTE *)
" ",Out);
853 if ( AC.CodesFlag || AC.NamesFlag > 1 ) startvalue = 0;
854 else startvalue = BUILTINVECTORS;
855 if ( ( j = NumVectors ) > startvalue ) {
856 TokenToLine((UBYTE *)
" Vectors");
859 for ( i = startvalue; i < j; i++ ) {
860 Out = StrCopy(VARNAME(vectors,i),OutScr);
861 if ( AC.CodesFlag ) Out = CodeToLine(i+AM.OffsetVector,Out);
862 StrCopy((UBYTE *)
" ",Out);
869 if ( AC.CodesFlag || AC.NamesFlag > 1 ) startvalue = 0;
870 else startvalue = AM.NumFixedFunctions;
871 for ( k = 0; k < 2; k++ ) {
874 for ( i = startvalue; i < j; i++ ) {
875 if ( i > MAXBUILTINFUNCTION-FUNCTION
876 && i < FIRSTUSERFUNCTION-FUNCTION )
continue;
877 if ( ( k == 0 && functions[i].commute )
878 || ( k != 0 && !functions[i].commute ) ) {
880 TokenToLine((UBYTE *)(FG.FunNam[k]));
885 Out = StrCopy(VARNAME(functions,i),OutScr);
886 if ( ( functions[i].complex & VARTYPEIMAGINARY ) == VARTYPEIMAGINARY ) {
887 Out = StrCopy((UBYTE *)
"#i",Out);
889 else if ( ( functions[i].complex & VARTYPECOMPLEX ) == VARTYPECOMPLEX ) {
890 Out = StrCopy((UBYTE *)
"#c",Out);
892 if ( functions[i].spec >= TENSORFUNCTION ) {
893 Out = StrCopy((UBYTE *)
"(Tensor)",Out);
895 if ( functions[i].symmetric > 0 ) {
896 if ( ( functions[i].symmetric & REVERSEORDER ) != 0 ) {
897 Out = StrCopy((UBYTE *)(rsymname[(functions[i].symmetric & ~REVERSEORDER)-1]),Out);
900 Out = StrCopy((UBYTE *)(symname[functions[i].symmetric-1]),Out);
903 if ( AC.CodesFlag ) Out = CodeToLine(i+FUNCTION,Out);
904 if ( ( functions[i].complex & VARTYPECOMPLEX ) == VARTYPECOMPLEX ) i++;
905 StrCopy((UBYTE *)
" ",Out);
910 if ( first == 0 ) FiniLine();
912 if ( AC.CodesFlag || AC.NamesFlag > 1 ) startvalue = 0;
913 else startvalue = AM.NumFixedSets;
914 if ( ( j = AC.SetList.num ) > startvalue ) {
915 WORD element, LastElement, type, number;
916 TokenToLine((UBYTE *)
" Sets");
917 for ( i = startvalue; i < j; i++ ) {
920 if ( Sets[i].name < 0 ) {
921 Out = StrCopy((UBYTE *)
"{}",OutScr);
924 Out = StrCopy(VARNAME(Sets,i),OutScr);
926 if ( AC.CodesFlag ) Out = CodeToLine(i,Out);
927 StrCopy((UBYTE *)
":",Out);
929 if ( i < AM.NumFixedSets ) {
930 TokenToLine((UBYTE *)
" ");
931 TokenToLine((UBYTE *)fixedsets[i].description);
933 else if ( Sets[i].type == CRANGE ) {
935 if ( Sets[i].first == 3*MAXPOWER ) {
937 else if ( Sets[i].first >= MAXPOWER ) {
938 TokenToLine((UBYTE *)
"<=");
939 NumCopy(Sets[i].first-2*MAXPOWER,OutScr);
944 TokenToLine((UBYTE *)
"<");
945 NumCopy(Sets[i].first,OutScr);
949 if ( Sets[i].last == -3*MAXPOWER ) {
951 else if ( Sets[i].last <= -MAXPOWER ) {
952 if ( iflag ) TokenToLine((UBYTE *)
",");
953 TokenToLine((UBYTE *)
">=");
954 NumCopy(Sets[i].last+2*MAXPOWER,OutScr);
958 if ( iflag ) TokenToLine((UBYTE *)
",");
959 TokenToLine((UBYTE *)
">");
960 NumCopy(Sets[i].last,OutScr);
965 element = Sets[i].first;
966 LastElement = Sets[i].last;
969 TokenToLine((UBYTE *)
" ");
970 number = SetElements[element++];
974 StrCopy(VARNAME(symbols,-number),OutScr);
975 StrCopy((UBYTE *)
"?",Out);
978 else if ( number < MAXPOWER )
979 TokenToLine(VARNAME(symbols,number));
981 NumCopy(number-2*MAXPOWER,OutScr);
986 if ( number >= AM.IndDum ) {
987 Out = StrCopy((UBYTE *)
"N",OutScr);
988 Out = NumCopy(number-(AM.IndDum),Out);
989 StrCopy((UBYTE *)
"_?",Out);
992 else if ( number >= AM.OffsetIndex + (WORD)WILDMASK ) {
993 Out = StrCopy(VARNAME(indices,number
994 -AM.OffsetIndex-WILDMASK),OutScr);
995 StrCopy((UBYTE *)
"?",Out);
998 else if ( number >= AM.OffsetIndex ) {
999 TokenToLine(VARNAME(indices,number-AM.OffsetIndex));
1002 NumCopy(number,OutScr);
1003 TokenToLine(OutScr);
1007 if ( number >= AM.OffsetVector + WILDOFFSET ) {
1008 Out = StrCopy(VARNAME(vectors,number
1009 -AM.OffsetVector-WILDOFFSET),OutScr);
1010 StrCopy((UBYTE *)
"?",Out);
1011 TokenToLine(OutScr);
1014 TokenToLine(VARNAME(vectors,number-AM.OffsetVector));
1017 if ( number >= FUNCTION + (WORD)WILDMASK ) {
1018 Out = StrCopy(VARNAME(functions,number
1019 -FUNCTION-WILDMASK),OutScr);
1020 StrCopy((UBYTE *)
"?",Out);
1021 TokenToLine(OutScr);
1023 TokenToLine(VARNAME(functions,number-FUNCTION));
1026 NumCopy(number,OutScr);
1027 TokenToLine(OutScr);
1030 }
while ( element < LastElement );
1036 if ( AS.ExecMode ) {
1040 for ( i = 0; i < j; i++, e++ ) {
1041 if ( e->status >= 0 ) {
1043 TokenToLine((UBYTE *)
" Expressions");
1048 Out = StrCopy(AC.exprnames->namebuffer+e->name,OutScr);
1049 Out = StrCopy((UBYTE *)(FG.ExprStat[e->status]),Out);
1050 if ( AC.CodesFlag ) Out = CodeToLine(i,Out);
1051 StrCopy((UBYTE *)
" ",Out);
1052 TokenToLine(OutScr);
1063 for ( i = 0; i < j; i++ ) {
1064 if ( e->printflag && ( e->status == LOCALEXPRESSION ||
1065 e->status == GLOBALEXPRESSION || e->status == UNHIDELEXPRESSION
1066 || e->status == UNHIDEGEXPRESSION ) ) {
1068 TokenToLine((UBYTE *)
" Expressions to be printed");
1073 Out = StrCopy(AC.exprnames->namebuffer+e->name,OutScr);
1074 StrCopy((UBYTE *)
" ",Out);
1075 TokenToLine(OutScr);
1084 if ( AC.CodesFlag || AC.NamesFlag > 1 ) startvalue = 0;
1085 else startvalue = BUILTINDOLLARS;
1086 if ( ( j = NumDollars ) > startvalue ) {
1087 TokenToLine((UBYTE *)
" Dollar variables");
1090 for ( i = startvalue; i < j; i++ ) {
1091 Out = StrCopy((UBYTE *)
"$", OutScr);
1092 Out = StrCopy(DOLLARNAME(Dollars, i), Out);
1093 if ( AC.CodesFlag ) Out = CodeToLine(i, Out);
1094 StrCopy((UBYTE *)
" ", Out);
1095 TokenToLine(OutScr);
1101 if ( ( j = NumPotModdollars ) > 0 ) {
1102 TokenToLine((UBYTE *)
" Dollar variables to be modified");
1105 for ( i = 0; i < j; i++ ) {
1106 Out = StrCopy((UBYTE *)
"$", OutScr);
1107 Out = StrCopy(DOLLARNAME(Dollars, PotModdollars[i]), Out);
1108 for ( k = 0; k < NumModOptdollars; k++ )
1109 if ( ModOptdollars[k].number == PotModdollars[i] )
break;
1110 if ( k < NumModOptdollars ) {
1111 switch ( ModOptdollars[k].type ) {
1113 Out = StrCopy((UBYTE *)
"(sum)", Out);
1116 Out = StrCopy((UBYTE *)
"(maximum)", Out);
1119 Out = StrCopy((UBYTE *)
"(minimum)", Out);
1122 Out = StrCopy((UBYTE *)
"(local)", Out);
1125 Out = StrCopy((UBYTE *)
"(?)", Out);
1129 StrCopy((UBYTE *)
" ", Out);
1130 TokenToLine(OutScr);
1136 if ( AC.ncmod != 0 ) {
1137 TokenToLine((UBYTE *)
"All arithmetic is modulus ");
1138 LongToLine((UWORD *)AC.cmod,ABS(AC.ncmod));
1139 if ( AC.ncmod > 0 ) TokenToLine((UBYTE *)
" with powerreduction");
1140 else TokenToLine((UBYTE *)
" without powerreduction");
1141 if ( ( AC.modmode & POSNEG ) != 0 ) TokenToLine((UBYTE *)
" centered around 0");
1142 else TokenToLine((UBYTE *)
" positive numbers only");
1145 if ( AC.lDefDim != 4 ) {
1146 TokenToLine((UBYTE *)
"The default dimension is ");
1147 if ( AC.lDefDim >= 0 ) {
1148 NumCopy(AC.lDefDim,OutScr);
1149 TokenToLine(OutScr);
1152 TokenToLine(VARNAME(symbols,-AC.lDefDim));
1153 if ( AC.lDefDim4 != -NMIN4SHIFT ) {
1154 TokenToLine((UBYTE *)
":");
1155 if ( AC.lDefDim4 >= -NMIN4SHIFT ) {
1156 NumCopy(AC.lDefDim4,OutScr);
1157 TokenToLine(OutScr);
1160 TokenToLine(VARNAME(symbols,-AC.lDefDim4-NMIN4SHIFT));
1166 if ( AC.lUnitTrace != 4 ) {
1167 TokenToLine((UBYTE *)
"The trace of the unit matrix is ");
1168 if ( AC.lUnitTrace >= 0 ) {
1169 NumCopy(AC.lUnitTrace,OutScr);
1170 TokenToLine(OutScr);
1173 TokenToLine(VARNAME(symbols,-AC.lUnitTrace));
1177 if ( AC.CodesFlag ) {
1178 if ( C->numlhs > 0 ) {
1179 TokenToLine((UBYTE *)
" Left Hand Sides:");
1181 for ( i = 1; i <= C->numlhs; i++ ) {
1185 while ( --j >= 0 ) { TalToLine((UWORD)(*skip++)); TokenToLine((UBYTE *)
" "); }
1190 if ( C->numrhs > 0 ) {
1191 TokenToLine((UBYTE *)
" Right Hand Sides:");
1193 for ( i = 1; i <= C->numrhs; i++ ) {
1196 while ( ( j = skip[0] ) != 0 ) {
1197 while ( --j >= 0 ) { TalToLine((UWORD)(*skip++)); TokenToLine((UBYTE *)
" "); }
1215 VOID WriteArgument(WORD *t)
1220 int oldoutsidefun, oldlowestlevel = lowestlevel;
1223 oldoutsidefun = AC.outsidefun; AC.outsidefun = 0;
1224 WriteExpression(t+ARGHEAD,(LONG)(*t-ARGHEAD));
1225 AC.outsidefun = oldoutsidefun;
1229 if ( *t == -SNUMBER) {
1232 else if ( *t == -SYMBOL ) {
1233 if ( t[1] >= MAXVARIABLES-cbuf[AM.sbufnum].numrhs ) {
1234 Out = StrCopy((UBYTE *)AC.extrasym,Out);
1235 if ( AC.extrasymbols == 0 ) {
1236 Out = NumCopy((MAXVARIABLES-t[1]),Out);
1237 Out = StrCopy((UBYTE *)
"_",Out);
1239 else if ( AC.extrasymbols == 1 ) {
1240 Out = AddArrayIndex((MAXVARIABLES-t[1]),Out);
1249 StrCopy(VARNAME(symbols,t[1]),Out);
1252 else if ( *t == -VECTOR ) {
1253 if ( t[1] == FUNNYVEC ) { *Out++ =
'?'; *Out = 0; }
1255 StrCopy(VARNAME(vectors,t[1] - AM.OffsetVector),Out);
1257 else if ( *t == -MINVECTOR ) {
1259 StrCopy(VARNAME(vectors,t[1] - AM.OffsetVector),Out);
1261 else if ( *t == -INDEX ) {
1263 if ( t[1] < AM.OffsetIndex ) { NumCopy(t[1],Out); }
1266 if ( i >= AM.IndDum ) {
1269 Out = NumCopy(i,Out);
1275 i -= AM.OffsetIndex;
1276 Out = StrCopy(VARNAME(indices,i%WILDOFFSET),Out);
1277 if ( i >= WILDOFFSET ) { *Out++ =
'?'; *Out = 0; }
1281 else if ( t[1] == FUNNYVEC ) { *Out++ =
'?'; *Out = 0; }
1283 StrCopy(VARNAME(vectors,t[1] - AM.OffsetVector),Out);
1285 else if ( *t == -DOLLAREXPRESSION ) {
1288 StrCopy(AC.dollarnames->namebuffer+d->name,Out);
1290 else if ( *t == -EXPRESSION ) {
1291 StrCopy(EXPRNAME(t[1]),Out);
1293 else if ( *t <= -FUNCTION ) {
1294 StrCopy(VARNAME(functions,-*t-FUNCTION),Out);
1297 MesPrint(
"Illegal function argument while writing");
1300 TokenToLine(buffer);
1302 lowestlevel = oldlowestlevel;
1321 WORD WriteSubTerm(WORD *sterm, WORD first)
1324 UBYTE *Out, closepar[2] = { (UBYTE)
')', 0};
1325 WORD *stopper, *t, *tt, i, j, po = 0;
1327 stopper = sterm + sterm[1];
1331 while ( t < stopper ) {
1332 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1334 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1336 if ( first ) TokenToLine((UBYTE *)
" ");
1338 if ( !first ) TokenToLine((UBYTE *)
"*");
1339 if ( AC.OutputMode == CMODE && t[1] != 1 ) {
1340 if ( AC.Cnumpows >= t[1] && t[1] > 0 ) {
1342 Out = StrCopy((UBYTE *)
"POW",buffer);
1343 Out = NumCopy(po,Out);
1344 Out = StrCopy((UBYTE *)
"(",Out);
1345 TokenToLine(buffer);
1348 TokenToLine((UBYTE *)
"pow(");
1351 if ( *t < NumSymbols ) {
1352 Out = StrCopy(VARNAME(symbols,*t),buffer); t++;
1358 Out = StrCopy((UBYTE *)AC.extrasym,buffer);
1359 if ( AC.extrasymbols == 0 ) {
1360 Out = NumCopy((MAXVARIABLES-*t),Out);
1361 Out = StrCopy((UBYTE *)
"_",Out);
1363 else if ( AC.extrasymbols == 1 ) {
1364 Out = AddArrayIndex((MAXVARIABLES-*t),Out);
1373 if ( AC.OutputMode == CMODE && po > 1
1374 && AC.Cnumpows >= po ) {
1375 Out = StrCopy((UBYTE *)
")",Out);
1378 else if ( *t != 1 ) WrtPower(Out,*t);
1379 TokenToLine(buffer);
1385 while ( t < stopper ) {
1386 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1388 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1390 if ( first ) TokenToLine((UBYTE *)
" ");
1392 if ( !first ) TokenToLine((UBYTE *)
"*");
1394 Out = StrCopy(VARNAME(vectors,*t - AM.OffsetVector),buffer);
1396 if ( AC.OutputMode == MATHEMATICAMODE ) *Out++ =
'[';
1398 if ( *t >= AM.OffsetIndex ) {
1400 if ( i >= AM.IndDum ) {
1403 Out = NumCopy(i,Out);
1409 Out = StrCopy(VARNAME(indices,i - AM.OffsetIndex),Out);
1411 else if ( *t == FUNNYVEC ) { *Out++ =
'?'; *Out = 0; }
1413 Out = NumCopy(*t++,Out);
1415 if ( AC.OutputMode == MATHEMATICAMODE ) *Out++ =
']';
1418 TokenToLine(buffer);
1423 while ( t < stopper ) {
1424 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1426 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1428 if ( first ) TokenToLine((UBYTE *)
" ");
1430 if ( !first ) TokenToLine((UBYTE *)
"*");
1432 if ( *t < AM.OffsetIndex ) {
1433 TalToLine((UWORD)(*t++));
1437 if ( i >= AM.IndDum ) {
1441 Out = NumCopy(i,Out);
1447 i -= AM.OffsetIndex;
1448 Out = StrCopy(VARNAME(indices,i%WILDOFFSET),buffer);
1449 if ( i >= WILDOFFSET ) { *Out++ =
'?'; *Out = 0; }
1451 TokenToLine(buffer);
1455 TokenToLine(VARNAME(vectors,*t - AM.OffsetVector)); t++;
1460 case DOLLAREXPRESSION:
1462 DOLLARS d = Dollars + sterm[2];
1463 Out = StrCopy((UBYTE *)
"$",buffer);
1464 Out = StrCopy(AC.dollarnames->namebuffer+d->name,Out);
1465 if ( sterm[3] != 1 ) WrtPower(Out,sterm[3]);
1466 TokenToLine(buffer);
1471 while ( t < stopper ) {
1472 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1474 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1476 if ( first ) TokenToLine((UBYTE *)
" ");
1478 if ( !first ) TokenToLine((UBYTE *)
"*");
1479 Out = StrCopy((UBYTE *)
"d_(",buffer);
1480 if ( *t >= AM.OffsetIndex ) {
1481 if ( *t < AM.IndDum ) {
1482 Out = StrCopy(VARNAME(indices,*t - AM.OffsetIndex),Out);
1487 Out = NumCopy( *t++ - AM.IndDum, Out);
1493 else if ( *t == FUNNYVEC ) { *Out++ =
'?'; *Out = 0; }
1495 Out = NumCopy(*t++,Out);
1498 if ( *t >= AM.OffsetIndex ) {
1499 if ( *t < AM.IndDum ) {
1500 Out = StrCopy(VARNAME(indices,*t - AM.OffsetIndex),Out);
1505 Out = NumCopy(*t++ - AM.IndDum,Out);
1511 Out = NumCopy(*t++,Out);
1515 TokenToLine(buffer);
1520 while ( t < stopper ) {
1521 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1523 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1525 if ( first ) TokenToLine((UBYTE *)
" ");
1527 if ( !first ) TokenToLine((UBYTE *)
"*");
1528 if ( AC.OutputMode == CMODE && t[2] != 1 )
1529 TokenToLine((UBYTE *)
"pow(");
1530 Out = StrCopy(VARNAME(vectors,*t - AM.OffsetVector),buffer);
1532 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE
1533 || AC.OutputMode == CMODE )
1534 *Out++ = AO.FortDotChar;
1536 Out = StrCopy(VARNAME(vectors,*t - AM.OffsetVector),Out);
1538 if ( *t != 1 ) WrtPower(Out,*t);
1540 TokenToLine(buffer);
1548 if ( !first ) TokenToLine((UBYTE *)
"*");
1549 if ( AC.OutputMode == CMODE ) TokenToLine((UBYTE *)
"pow(");
1550 else TokenToLine((UBYTE *)
"(");
1552 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE
1553 || AC.OutputMode == REDUCEMODE )
1554 TokenToLine((UBYTE *)
")**(");
1555 else if ( AC.OutputMode == CMODE ) TokenToLine((UBYTE *)
",");
1556 else TokenToLine((UBYTE *)
")^(");
1559 TokenToLine((UBYTE *)")");
1565 if ( first ) TokenToLine((UBYTE *)
"1/(");
1566 else TokenToLine((UBYTE *)
"/(");
1568 TokenToLine((UBYTE *)
")");
1571 if ( !first ) TokenToLine((UBYTE *)
"*");
1572 TokenToLine((UBYTE *)
"(");
1573 t = cbuf[sterm[4]].rhs[sterm[2]];
1575 while ( *tt ) tt += *tt;
1576 oldoutsidefun = AC.outsidefun; AC.outsidefun = 0;
1578 WriteExpression(t,(LONG)(tt-t));
1581 TokenToLine((UBYTE *)
"0");
1583 AC.outsidefun = oldoutsidefun;
1584 TokenToLine((UBYTE *)
")");
1585 if ( sterm[3] != 1 ) {
1586 TokenToLine((UBYTE *)
"^");
1588 NumCopy(sterm[3],Out);
1589 TokenToLine(buffer);
1593 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1595 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1597 if ( first ) TokenToLine((UBYTE *)
" ");
1599 if ( *sterm < FUNCTION ) {
1600 return(MesPrint(
"Illegal subterm while writing"));
1602 if ( !first ) TokenToLine((UBYTE *)
"*");
1605 if ( *sterm == GAMMA && t[-FUNHEAD+1] == FUNHEAD+1 ) {
1606 TokenToLine((UBYTE *)
"gi_(");
1609 if ( *sterm != DUMFUN ) {
1610 Out = StrCopy(VARNAME(functions,*sterm - FUNCTION),buffer);
1612 else { Out = buffer; *Out = 0; }
1613 if ( t >= stopper ) {
1614 TokenToLine(buffer);
1617 if ( AC.OutputMode == MATHEMATICAMODE ) { *Out++ =
'['; closepar[0] = (UBYTE)
']'; }
1618 else { *Out++ =
'('; }
1620 TokenToLine(buffer);
1623 i = functions[*sterm - FUNCTION].spec;
1624 if ( i >= TENSORFUNCTION ) {
1625 t = sterm + FUNHEAD;
1626 while ( t < stopper ) {
1627 if ( !first ) TokenToLine((UBYTE *)
",");
1631 if ( j < AM.OffsetIndex ) TalToLine((UWORD)(j));
1632 else if ( j < AM.IndDum ) {
1633 i = j - AM.OffsetIndex;
1634 Out = StrCopy(VARNAME(indices,i%WILDOFFSET),buffer);
1635 if ( i >= WILDOFFSET ) { *Out++ =
'?'; *Out = 0; }
1636 TokenToLine(buffer);
1641 Out = NumCopy(j - AM.IndDum,Out);
1645 TokenToLine(buffer);
1648 else if ( j == FUNNYVEC ) { TokenToLine((UBYTE *)
"?"); }
1649 else if ( j > -WILDOFFSET ) {
1651 Out = NumCopy((UWORD)(-j + 4),Out);
1654 TokenToLine(buffer);
1657 TokenToLine(VARNAME(vectors,j - AM.OffsetVector));
1662 while ( t < stopper ) {
1663 if ( !first ) TokenToLine((UBYTE *)
",");
1669 TokenToLine(closepar);
1670 closepar[0] = (UBYTE)')';
1685 WORD WriteInnerTerm(WORD *term, WORD first)
1687 WORD *t, *s, *s1, *s2, n, i, pow;
1692 if ( *s == HAAKJE )
break;
1695 if ( s < t ) { s += s[1]; }
1696 else { s = term+1; }
1698 if ( n < 0 || !first ) {
1699 if ( n > 0 ) { TOKENTOLINE(
" + ",
"+") }
1700 else if ( n < 0 ) { n = -n; TOKENTOLINE(
" - ",
"-") }
1702 if ( AC.modpowers ) {
1703 if ( n == 1 && *t == 1 && t > s ) first = 1;
1704 else if ( ABS(AC.ncmod) == 1 ) {
1705 LongToLine((UWORD *)AC.powmod,AC.npowmod);
1706 TokenToLine((UBYTE *)
"^");
1707 TalToLine(AC.modpowers[(LONG)((UWORD)*t)]);
1712 LongToLine((UWORD *)AC.powmod,AC.npowmod);
1713 TokenToLine((UBYTE *)
"^");
1715 if ( n == 2 ) jj += ((LONG)t[1])<<BITSINWORD;
1716 if ( AC.modpowers[jj+1] == 0 ) {
1717 TalToLine(AC.modpowers[jj]);
1720 LongToLine(AC.modpowers+jj,2);
1725 else if ( n != 1 || *t != 1 || t[1] != 1 || t <= s ) {
1726 if ( lowestlevel && ( ( AO.PrintType & PRINTONEFUNCTION ) != 0 ) ) {
1728 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1731 RatToLine((UWORD *)t,n); first = 0;
1735 if ( lowestlevel && ( (AO.PrintType & (PRINTONEFUNCTION | PRINTALL)) == PRINTONEFUNCTION ) ) {
1737 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1745 if ( *s == GAMMA ) {
1747 ss = AT.WorkPointer;
1752 tt = s + FUNHEAD + 1;
1753 n = s[1] - FUNHEAD-1;
1755 while ( --n >= 0 ) *ss++ = *tt++;
1757 while ( *tt == GAMMA && tt[FUNHEAD] == s[FUNHEAD] && tt < t ) {
1760 n = s[1] - FUNHEAD-1;
1764 tt = AT.WorkPointer;
1765 AT.WorkPointer = ss;
1766 tt[1] = WORDDIF(ss,tt);
1767 if ( WriteSubTerm(tt,first) ) {
1768 MesCall(
"WriteInnerTerm");
1771 AT.WorkPointer = tt;
1779 if ( *s >= FUNCTION && AC.funpowers > 0
1780 && functions[*s-FUNCTION].spec == 0 && ( AC.funpowers == ALLFUNPOWERS ||
1781 ( AC.funpowers == COMFUNPOWERS && functions[*s-FUNCTION].commute == 0 ) ) ) {
1784 s1 = s; s2 = s + s[1]; i = s[1];
1786 while ( --i >= 0 && *s1 == *s2 ) { s1++; s2++; }
1795 if ( AC.OutputMode == CMODE ) {
1796 if ( !first ) TokenToLine((UBYTE *)
"*");
1797 TokenToLine((UBYTE *)
"pow(");
1800 if ( WriteSubTerm(s,first) ) {
1801 MesCall(
"WriteInnerTerm");
1804 if ( AC.OutputMode == FORTRANMODE
1805 || AC.OutputMode == PFORTRANMODE ) { TokenToLine((UBYTE *)
"**"); }
1806 else if ( AC.OutputMode == CMODE ) { TokenToLine((UBYTE *)
","); }
1807 else { TokenToLine((UBYTE *)
"^"); }
1809 if ( AC.OutputMode == CMODE ) TokenToLine((UBYTE *)
")");
1811 else if ( WriteSubTerm(s,first) ) {
1812 MesCall(
"WriteInnerTerm");
1816 else if ( WriteSubTerm(s,first) ) {
1817 MesCall(
"WriteInnerTerm");
1841 WORD WriteTerm(WORD *term, WORD *lbrac, WORD first, WORD prtf, WORD br)
1843 WORD *t, *stopper, *b, n;
1844 int oldIsFortran90 = AC.IsFortran90, i;
1845 if ( *lbrac >= 0 ) {
1847 stopper = (term + *term - 1);
1848 stopper -= ABS(*stopper) - 1;
1849 while ( t < stopper ) {
1850 if ( *t == HAAKJE ) {
1853 if ( *lbrac == ( n = WORDDIF(stopper,t) ) ) {
1856 while ( n > 0 && ( *b++ == *t++ ) ) { n--; }
1857 if ( n <= 0 && ( ( AO.InFbrack < AM.FortranCont )
1858 || ( lowestlevel == 0 ) ) ) {
1863 if ( ( prtf & PRINTCONTENTS ) != 0 ) {
1867 if ( WriteInnerTerm(term,0) )
goto WrtTmes;
1868 if ( ( AO.PrintType & PRINTONETERM ) != 0 ) {
1870 TokenToLine((UBYTE *)
" ");
1876 n = WORDDIF(stopper,t);
1882 if ( ( prtf & PRINTCONTENTS ) ) PrtTerms();
1883 TOKENTOLINE(
" )",
")")
1884 if ( AC.OutputMode == CMODE && AO.FactorMode == 0 )
1885 TokenToLine((UBYTE *)";");
1886 else if ( AO.FactorMode && ( n == 0 ) ) {
1892 AC.IsFortran90 = ISNOTFORTRAN90;
1894 AC.IsFortran90 = oldIsFortran90;
1895 if ( AC.OutputMode != FORTRANMODE && AC.OutputMode != PFORTRANMODE
1896 && AC.OutputSpaces == NORMALFORMAT
1897 && AO.FactorMode == 0 ) FiniLine();
1900 if ( AC.OutputMode == CMODE && AO.FactorMode == 0 )
1901 TokenToLine((UBYTE *)
";");
1902 if ( AO.FortFirst == 0 ) {
1904 AC.IsFortran90 = ISNOTFORTRAN90;
1906 AC.IsFortran90 = oldIsFortran90;
1910 if ( AO.FactorMode == 0 ) {
1911 if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
1913 WORD oldmode = AC.OutputMode;
1916 AC.OutputMode = oldmode;
1919 if ( AO.FortFirst == 0 ) {
1920 TokenToLine(AO.CurBufWrt);
1921 TOKENTOLINE(
" = ",
"=")
1922 TokenToLine(AO.CurBufWrt);
1926 TokenToLine(AO.CurBufWrt);
1927 TOKENTOLINE(
" = ",
"=")
1930 else if ( AC.OutputMode == CMODE && !first ) {
1932 if ( AO.FortFirst == 0 ) {
1933 TokenToLine(AO.CurBufWrt);
1934 TOKENTOLINE(
" += ",
"+=")
1938 TokenToLine(AO.CurBufWrt);
1939 TOKENTOLINE(
" = ",
"=")
1942 else if ( startinline == 0 ) {
1946 if ( ( *lbrac = n ) > 0 ) {
1949 while ( --n >= 0 ) *b++ = *t++;
1950 *b++ = 1; *b++ = 1; *b = 3;
1952 if ( WriteInnerTerm(AO.bracket,0) ) {
1959 while ( --i >= 0 ) { TalToLine((UWORD)(*t++));
1960 if ( AC.OutputSpaces == NORMALFORMAT )
1961 TokenToLine((UBYTE *)
" "); }
1964 MesCall(
"WriteTerm");
1967 TOKENTOLINE(
" * ( ",
"*(")
1970 if ( ( prtf & PRINTONETERM ) != 0 ) {
1973 TokenToLine((UBYTE *)
" ");
1987 if ( ( *lbrac = n ) > 0 ) {
1990 while ( --n >= 0 ) *b++ = *t++;
1991 *b++ = 1; *b++ = 1; *b = 3;
1992 for ( i = AO.FactorNum+1; i < AO.bracket[4]; i++ ) {
1994 TOKENTOLINE(
" ( 0 )",
" (0)")
1998 TOKENTOLINE(
" * ( 0 )",
"*(0)")
2003 AO.FactorNum = AO.bracket[4];
2009 if ( first == 0 ) { TOKENTOLINE(
" * ( ",
"*(") }
2010 else { TOKENTOLINE(
" ( ",
" (") }
2014 if ( ( prtf & PRINTCONTENTS ) != 0 ) AO.NumInBrack++;
2015 else if ( WriteInnerTerm(term,first) )
goto WrtTmes;
2016 if ( ( AO.PrintType & PRINTONETERM ) != 0 ) {
2018 TokenToLine((UBYTE *)
" ");
2025 if ( ( prtf & PRINTCONTENTS ) != 0 ) PrtTerms();
2026 TokenToLine((UBYTE *)
" )");
2027 if ( AC.OutputMode == CMODE ) TokenToLine((UBYTE *)
";");
2028 if ( AO.FortFirst == 0 ) {
2029 AC.IsFortran90 = ISNOTFORTRAN90;
2031 AC.IsFortran90 = oldIsFortran90;
2033 if ( AC.OutputMode != FORTRANMODE && AC.OutputMode != PFORTRANMODE
2034 && AC.OutputSpaces == NORMALFORMAT ) FiniLine();
2035 if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2037 WORD oldmode = AC.OutputMode;
2040 AC.OutputMode = oldmode;
2042 if ( AO.FortFirst == 0 ) {
2043 TokenToLine(AO.CurBufWrt);
2044 TOKENTOLINE(
" = ",
"=")
2045 TokenToLine(AO.CurBufWrt);
2049 TokenToLine(AO.CurBufWrt);
2050 TOKENTOLINE(
" = ",
"=")
2060 else if ( AC.OutputMode == CMODE && !first ) {
2062 if ( AO.FortFirst == 0 ) {
2063 TokenToLine(AO.CurBufWrt);
2064 TOKENTOLINE(
" += ",
"+=")
2068 TokenToLine(AO.CurBufWrt);
2069 TOKENTOLINE(
" = ",
"=")
2085 if ( !br ) AO.IsBracket = 0;
2086 if ( ( AO.InFbrack >= AM.FortranCont ) && lowestlevel ) {
2087 if ( AC.OutputMode == CMODE ) TokenToLine((UBYTE *)
";");
2088 if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2090 WORD oldmode = AC.OutputMode;
2091 if ( AO.FortFirst == 0 ) {
2092 AC.IsFortran90 = ISNOTFORTRAN90;
2094 AC.IsFortran90 = oldIsFortran90;
2097 AC.OutputMode = oldmode;
2099 TokenToLine(AO.CurBufWrt);
2100 TOKENTOLINE(
" = ",
"=")
2101 TokenToLine(AO.CurBufWrt);
2118 else if ( AC.OutputMode == CMODE && !first ) {
2121 if ( AO.FortFirst == 0 ) {
2122 TokenToLine(AO.CurBufWrt);
2123 TOKENTOLINE(
" += ",
"+=")
2127 TokenToLine(AO.CurBufWrt);
2128 TOKENTOLINE(
" = ",
"=")
2145 if ( WriteInnerTerm(term,first) )
goto WrtTmes;
2146 if ( ( AO.PrintType & PRINTONETERM ) != 0 ) {
2163 WORD WriteExpression(WORD *terms, LONG ltot)
2167 WORD OldIsBracket = AO.IsBracket, OldPrintType = AO.PrintType;
2168 if ( !AC.outsidefun ) { AO.PrintType &= ~PRINTONETERM; first = 1; }
2170 stopper = terms + ltot;
2172 while ( terms < stopper ) {
2173 AO.IsBracket = OldIsBracket;
2174 if ( WriteTerm(terms,&btot,first,0,1) ) {
2175 MesCall(
"WriteExpression");
2182 AO.IsBracket = OldIsBracket;
2183 AO.PrintType = OldPrintType;
2198 WORD *t, *stopper, n, prtf;
2199 int oldIsFortran90 = AC.IsFortran90, i;
2203 if ( AM.exitflag )
return(0);
2205 if ( PF.me != MASTER ) {
2210 for ( n = 0; n < NumExpressions; n++ ) {
2211 e = &Expressions[n];
2212 if ( !e->printflag & PRINTON )
continue;
2213 switch ( e->status ) {
2214 case LOCALEXPRESSION:
2215 case GLOBALEXPRESSION:
2216 case UNHIDELEXPRESSION:
2217 case UNHIDEGEXPRESSION:
2223 PutPreVar(AM.oldnumextrasymbols, GetPreVar((UBYTE *)
"EXTRASYMBOLS_", 0), 0, 1);
2224 if ( AO.OptimizationLevel > 0 ) {
2225 if ( Optimize(0, 1) )
return(-1);
2231 SeekScratch(AR.outfile,&pos);
2232 if ( ResetScratch() ) {
2233 MesCall(
"WriteAll");
2236 AO.termbuf = AT.WorkPointer;
2237 AO.bracket = (WORD *)(((UBYTE *)(AT.WorkPointer)) + AM.MaxTer);
2238 AT.WorkPointer = (WORD *)(((UBYTE *)(AT.WorkPointer)) + AM.MaxTer*2);
2239 AO.OutFill = AO.OutputLine = (UBYTE *)AT.WorkPointer;
2240 AT.WorkPointer += 2*AC.LineLength;
2241 *(AR.CompressBuffer) = 0;
2243 for ( n = 0; n < NumExpressions; n++ ) {
2244 if ( ( Expressions[n].printflag & PRINTON ) != 0 ) { first = 1;
break; }
2246 if ( !first )
goto EndWrite;
2250 while ( GetTerm(BHEAD AO.termbuf) ) {
2252 e = Expressions + AO.termbuf[3];
2254 if ( ( n == LOCALEXPRESSION || n == GLOBALEXPRESSION
2255 || n == UNHIDELEXPRESSION || n == UNHIDEGEXPRESSION ) &&
2256 ( ( prtf = e->printflag ) & PRINTON ) != 0 ) {
2260 GetPreVar((UBYTE *)
"EXTRASYMBOLS_",0),0,1);
2261 if ( ( prtf & PRINTLFILE ) != 0 ) {
2262 if ( AC.LogHandle < 0 ) prtf &= ~PRINTLFILE;
2264 AO.PrintType = prtf;
2277 if ( AO.OptimizationLevel > 0 ) {
2278 UBYTE *oldOutFill = AO.OutFill, *oldOutputLine = AO.OutputLine;
2280 if ( Optimize(AO.termbuf[3], 1) )
goto AboWrite;
2282 AO.OutFill = oldOutFill; AO.OutputLine = oldOutputLine;
2286 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2289 AO.CurBufWrt = EXPRNAME(AO.termbuf[3]);
2290 TokenToLine(AO.CurBufWrt);
2293 if ( t < stopper ) {
2294 TokenToLine((UBYTE *)
"(");
2296 while ( t < stopper ) {
2298 if ( !first ) TokenToLine((UBYTE *)
",");
2301 TokenToLine(VARNAME(symbols,t[2]));
2304 TokenToLine(VARNAME(vectors,t[2] - AM.OffsetVector));
2307 TokenToLine(VARNAME(indices,t[2] - AM.OffsetIndex));
2310 TokenToLine(VARNAME(functions,t[2] - FUNCTION));
2316 TokenToLine((UBYTE *)
")");
2318 TOKENTOLINE(
" =",
"=");
2321 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2326 if ( ( e->vflags & ISFACTORIZED ) != 0 ) {
2327 AO.FactorMode = 1+e->numfactors;
2333 while ( GetTerm(BHEAD AO.termbuf) ) {
2335 GETSTOP(AO.termbuf,m);
2336 if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2337 && ( ( prtf & PRINTONETERM ) != 0 ) ) {}
2344 if ( ( prtf & PRINTONETERM ) != 0 ) first = 0;
2345 if ( WriteTerm(AO.termbuf,&lbrac,first,prtf,0) )
2349 if ( AO.FactorMode ) {
2350 if ( first ) { AO.FactorNum = 1; TOKENTOLINE(
" ( 0 )",
" (0)") }
2351 else TOKENTOLINE(
" )",
")");
2352 for ( i = AO.FactorNum+1; i <= e->numfactors; i++ ) {
2355 TOKENTOLINE(
" * ( 0 )",
"*(0)");
2357 AO.FactorNum = e->numfactors;
2358 if ( AC.OutputMode != FORTRANMODE && AC.OutputMode != PFORTRANMODE )
2359 TokenToLine((UBYTE *)
";");
2361 else if ( AO.FactorMode == 0 || first ) {
2362 if ( first ) { TOKENTOLINE(
" 0",
"0") }
2364 if ( ( prtf & PRINTCONTENTS ) != 0 ) PrtTerms();
2365 TOKENTOLINE(
" )",
")")
2367 else if ( ( prtf & PRINTCONTENTS ) != 0 ) {
2368 TOKENTOLINE(
" + 1 * ( ",
"+1*(")
2370 TOKENTOLINE(" )",")")
2372 if ( AC.OutputMode != FORTRANMODE && AC.OutputMode != PFORTRANMODE )
2373 TokenToLine((UBYTE *)";");
2376 AC.IsFortran90 = ISNOTFORTRAN90;
2378 AC.IsFortran90 = oldIsFortran90;
2382 do { }
while ( GetTerm(BHEAD AO.termbuf) );
2385 if ( AC.OutputSpaces == NORMALFORMAT ) FiniLine();
2387 if ( AR.infile->handle >= 0 ) {
2388 SeekFile(AR.infile->handle,&(AR.infile->filesize),SEEK_SET);
2391 AT.WorkPointer = AO.termbuf;
2392 SetScratch(AR.infile,&pos);
2393 f = AR.outfile; AR.outfile = AR.infile; AR.infile = f;
2396 SetScratch(AR.infile,&pos);
2397 f = AR.outfile; AR.outfile = AR.infile; AR.infile = f;
2398 MesCall(
"WriteAll");
2410 WORD WriteOne(UBYTE *name,
int alreadyinline,
int nosemi)
2418 if ( GetName(AC.exprnames,name,&number,NOAUTO) != CEXPRESSION ) {
2419 MesPrint(
"@%s is not an expression",name);
2422 switch ( Expressions[number].status ) {
2423 case HIDDENLEXPRESSION:
2424 case HIDDENGEXPRESSION:
2425 case HIDELEXPRESSION:
2426 case HIDEGEXPRESSION:
2427 case UNHIDELEXPRESSION:
2428 case UNHIDEGEXPRESSION:
2435 case LOCALEXPRESSION:
2436 case GLOBALEXPRESSION:
2437 case SKIPLEXPRESSION:
2438 case SKIPGEXPRESSION:
2446 MesPrint(
"@expressions %s is not active. It cannot be written",name);
2449 SeekScratch(AR.outfile,&pos);
2451 f = AR.outfile; AR.outfile = AR.infile; AR.infile = f;
2458 if ( AR.GetFile == 2 ) f = AR.hidefile;
2464 SetScratch(f,&(Expressions[number].onfile));
2467 f->POfill = (WORD *)((UBYTE *)(f->PObuffer)
2468 + BASEPOSITION(Expressions[number].onfile));
2470 AO.termbuf = AT.WorkPointer;
2471 AO.bracket = (WORD *)(((UBYTE *)(AT.WorkPointer)) + AM.MaxTer);
2472 AT.WorkPointer = (WORD *)(((UBYTE *)(AT.WorkPointer)) + AM.MaxTer*2);
2474 AO.OutFill = AO.OutputLine = (UBYTE *)AT.WorkPointer;
2475 AT.WorkPointer += 2*AC.LineLength;
2476 *(AR.CompressBuffer) = 0;
2482 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2484 if ( GetTerm(BHEAD AO.termbuf) <= 0 ) {
2485 MesPrint(
"@ReadError in expression %s",name);
2498 if ( AO.OptimizationLevel > 0 ) {
2500 if ( Optimize(AO.termbuf[3], 1) )
goto AboWrite;
2509 while ( GetTerm(BHEAD AO.termbuf) ) {
2511 GETSTOP(AO.termbuf,m);
2514 startinline = alreadyinline;
2515 AO.OutFill = AO.OutputLine + startinline;
2517 if ( WriteTerm(AO.termbuf,&lbrac,first,0,0) )
2523 startinline = alreadyinline;
2524 AO.OutFill = AO.OutputLine + startinline;
2525 TOKENTOLINE(
" 0",
"0");
2528 TOKENTOLINE(
" )",
")");
2530 if ( AC.OutputMode != FORTRANMODE && AC.OutputMode != PFORTRANMODE
2531 && nosemi == 0 ) TokenToLine((UBYTE *)
";");
2533 if ( AC.OutputSpaces == NORMALFORMAT && nosemi == 0 ) {
2537 noextralinefeed = 1;
2539 noextralinefeed = 0;
2543 AT.WorkPointer = AO.termbuf;
2545 f = AR.outfile; AR.outfile = AR.infile; AR.infile = f;
2549 SetScratch(AR.infile,&pos);
2550 f->POposition = pos;
2551 f = AR.outfile; AR.outfile = AR.infile; AR.infile = f;
2552 MesCall(
"WriteOne");
int PutPreVar(UBYTE *, UBYTE *, UBYTE *, int)