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);
360 if ( AO.DoubleFlag == 2 ) { AddToLine((UBYTE *)
".Q0"); }
361 else { AddToLine((UBYTE *)
".D0"); }
364 else if ( anumer == 1 && a[0] == 1 ) {
366 AddToLine((UBYTE *)
"(one/");
367 LongToLine(a,adenom);
369 if ( AO.DoubleFlag == 2 ) { AddToLine((UBYTE *)
".Q0"); }
370 else { AddToLine((UBYTE *)
".D0"); }
372 AddToLine((UBYTE *)
")");
375 if ( anumer > 1 || adenom > 1 ) {
376 LongToLine(a,anumer);
378 if ( AO.DoubleFlag == 2 ) { AddToLine((UBYTE *)
".Q0"); }
379 else { AddToLine((UBYTE *)
".D0"); }
382 AddToLine((UBYTE *)
"/");
383 LongToLine(a,adenom);
385 if ( AO.DoubleFlag == 2 ) { AddToLine((UBYTE *)
".Q0"); }
386 else { AddToLine((UBYTE *)
".D0"); }
390 AddToLine((UBYTE *)
"((one*");
391 LongToLine(a,anumer);
393 AddToLine((UBYTE *)
")/");
394 LongToLine(a,adenom);
395 AddToLine((UBYTE *)
")");
400 UnPack(a,na,&adenom,&anumer);
401 LongToLine(a,anumer);
403 if ( anumer && !( adenom == 1 && *a == 1 ) ) {
404 if ( AC.OutputMode == FORTRANMODE && AC.IsFortran90 == ISFORTRAN90 ) {
405 if ( AC.Fortran90Kind ) {
406 AddToLine(AC.Fortran90Kind);
407 AddToLine((UBYTE *)
"/");
410 AddToLine((UBYTE *)
"./");
413 else if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == CMODE ) {
414 if ( AO.DoubleFlag == 2 ) { AddToLine((UBYTE *)
".Q0/"); }
415 else if ( AO.DoubleFlag == 1 ) { AddToLine((UBYTE *)
".D0/"); }
416 else { AddToLine((UBYTE *)
"./"); }
418 else AddToLine((UBYTE *)
"/");
419 LongToLine(a,adenom);
420 if ( AC.OutputMode == FORTRANMODE && AC.IsFortran90 == ISFORTRAN90 ) {
421 if ( AC.Fortran90Kind ) {
422 AddToLine(AC.Fortran90Kind);
425 AddToLine((UBYTE *)
".");
428 else if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == CMODE ) {
429 if ( AO.DoubleFlag == 2 ) { AddToLine((UBYTE *)
".Q0"); }
430 else if ( AO.DoubleFlag == 1 ) { AddToLine((UBYTE *)
".D0"); }
431 else { AddToLine((UBYTE *)
"."); }
434 else if ( anumer > 1 && ( AC.OutputMode == FORTRANMODE
435 || AC.OutputMode == CMODE ) ) {
436 if ( AC.OutputMode == FORTRANMODE && AC.IsFortran90 == ISFORTRAN90 ) {
437 if ( AC.Fortran90Kind ) {
438 AddToLine(AC.Fortran90Kind);
441 AddToLine((UBYTE *)
".");
444 else if ( AO.DoubleFlag == 2 ) { AddToLine((UBYTE *)
".Q0"); }
445 else if ( AO.DoubleFlag == 1 ) { AddToLine((UBYTE *)
".D0"); }
446 else { AddToLine((UBYTE *)
"."); }
448 else if ( AC.OutputMode == FORTRANMODE && AC.IsFortran90 == ISFORTRAN90 ) {
449 if ( AC.Fortran90Kind ) {
450 AddToLine(AC.Fortran90Kind);
453 AddToLine((UBYTE *)
".");
456 else if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == CMODE )
458 if ( anumer == 1 && adenom == 1 && a[0] == 1 ) {}
459 else if ( AO.DoubleFlag == 2 ) { AddToLine((UBYTE *)
".Q0"); }
460 else if ( AO.DoubleFlag == 1 ) { AddToLine((UBYTE *)
".D0"); }
469 WORD exponent = 0, i, ndig, newl;
470 UWORD *c, *den, b = 10, dig[10];
475 if ( RLscratch == 0 ) {
476 RLscratch = (UBYTE *)Malloc1(4*(AM.MaxTal+2)*
sizeof(UBYTE),
"RatToLine");
477 RLscratE = (UWORD *)Malloc1(2*(AM.MaxTal+2)*
sizeof(UWORD),
"RatToLine");
479 out = OutScratch = RLscratch;
480 c = RLscratE;
for ( i = 0; i < 2*na; i++ ) c[i] = a[i];
481 UnPack(c,na,&adenom,&anumer);
482 while ( BigLong(c,anumer,c+na,adenom) >= 0 ) {
483 Divvy(BHEAD c,&na,&b,1);
484 UnPack(c,na,&adenom,&anumer);
487 while ( BigLong(c,anumer,c+na,adenom) < 0 ) {
488 Mully(BHEAD c,&na,&b,1);
489 UnPack(c,na,&adenom,&anumer);
496 DivLong(c,anumer,den,adenom,dig,&ndig,c,&newl);
497 *out++ = (UBYTE)(dig[0]+
'0'); *out++ =
'.';
498 while ( newl && i < AC.OutNumberType ) {
499 Pack(c,&newl,den,adenom);
500 Mully(BHEAD c,&newl,&b,1);
502 UnPack(c,na,&adenom,&anumer);
504 DivLong(c,anumer,den,adenom,dig,&ndig,c,&newl);
505 if ( ndig == 0 ) *out++ =
'0';
506 else *out++ = (UBYTE)(dig[0]+
'0');
510 if ( exponent < 0 ) { exponent = -exponent; *out++ =
'-'; }
511 else { *out++ =
'+'; }
514 *out++ = (UBYTE)((exponent % 10)+
'0');
516 }
while ( exponent );
518 while ( o < out ) { cc = *o; *o = *out; *out = cc; o++; out--; }
519 TokenToLine(OutScratch);
533 VOID TalToLine(UWORD x)
535 UBYTE t[BITSINWORD/3+1];
539 do { *s++ = (UBYTE)((x % 10)+
'0'); i++; }
while ( ( x /= 10 ) != 0 );
543 i = t[j]; t[j] = s[-j]; s[-j] = (UBYTE)i; j--;
562 VOID TokenToLine(UBYTE *s)
566 if ( AO.OutInBuffer ) { AddToDollarBuffer(s);
return; }
567 t = s; Out = AO.OutFill;
570 if ( ( Out + i ) >= AO.OutStop && ( ( i < ((AC.LineLength-AO.OutSkip)>>1) )
571 || ( (AO.OutStop-Out) < (i>>2) ) ) ) {
572 if ( AC.OutputMode == FORTRANMODE && AC.IsFortran90 == ISFORTRAN90 ) {
576 *Out++ = CARRIAGERETURN;
580 num = Out - AO.OutputLine;
581 if ( AC.LogHandle >= 0 ) {
582 if ( WriteFile(AC.LogHandle,AO.OutputLine+startinline,
583 num-startinline) != (num-startinline) ) {
585 if ( BUG.logfileflag == 0 ) {
586 fprintf(stderr,
"Panic: Cannot write to log file! Disk full?\n");
589 BUG.eflag = 1; BUG.printflag = 1;
595 if ( ( AO.PrintType & PRINTLFILE ) == 0 ) {
597 if ( num > 1 && AO.OutputLine[num-2] == CARRIAGERETURN ) {
598 AO.OutputLine[num-2] = LINEFEED;
602 if ( WriteFile(AM.StdOut,AO.OutputLine+startinline,
603 num-startinline) != (num-startinline) ) {
605 if ( BUG.stdoutflag == 0 ) {
606 fprintf(stderr,
"Panic: Cannot write to standard output!\n");
609 BUG.eflag = 1; BUG.printflag = 1;
617 if ( AO.BlockSpaces == 0 ) {
618 for ( j = 0; j < AO.OutSkip; j++ ) { *Out++ =
' '; }
619 if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE ) ) {
620 if ( AO.OutSkip == 7 ) {
637 if ( AO.IsBracket ) { *Out++ =
' '; *Out++ =
' '; *Out++ =
' '; }
639 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE
640 || ( AC.OutputMode == CMODE && AO.FactorMode == 0 ) ) AO.InFbrack++;
642 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE ) {
644 if ( i > (WORD)(AO.OutStop-Out) ) j = (WORD)(AO.OutStop - Out);
650 if ( i > (WORD)(AO.OutStop-Out) ) j = (WORD)(AO.OutStop - Out - 1);
654 if ( i > 0 ) *Out++ =
'\\';
669 UBYTE *CodeToLine(WORD number, UBYTE *Out)
671 Out = StrCopy((UBYTE *)
"(",Out);
672 Out = NumCopy(number,Out);
673 Out = StrCopy((UBYTE *)
")",Out);
682 void MultiplyToLine()
685 if ( AO.CurrentDictionary > 0 && AO.CurDictSpecials > 0
686 && AO.CurDictSpecials == DICT_DOSPECIALS ) {
687 DICTIONARY *dict = AO.Dictionaries[AO.CurrentDictionary-1];
691 for ( i = 0; i < dict->numelements; i++ ) {
692 if ( dict->elements[i]->type != DICT_SPECIALCHARACTER )
continue;
693 if ( (UBYTE)dict->elements[i]->lhs[0] == (UBYTE)(
'*') ) {
694 TokenToLine((UBYTE *)(dict->elements[i]->rhs));
699 TokenToLine((UBYTE *)
"*");
707 UBYTE *AddArrayIndex(WORD num,UBYTE *out)
709 if ( AC.OutputMode == CMODE ) {
710 out = StrCopy((UBYTE *)
"[",out);
711 out = NumCopy(num,out);
712 out = StrCopy((UBYTE *)
"]",out);
715 out = StrCopy((UBYTE *)
"(",out);
716 out = NumCopy(num,out);
717 out = StrCopy((UBYTE *)
")",out);
731 a[0] = (UWORD)AO.NumInBrack;
732 a[1] = (UWORD)(AO.NumInBrack >> BITSINWORD);
735 TokenToLine((UBYTE *)
" ");
737 if ( a[0] == 1 && na == 1 ) {
738 TokenToLine((UBYTE *)
" term");
740 else TokenToLine((UBYTE *)
" terms");
749 UBYTE *WrtPower(UBYTE *Out, WORD Power)
751 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE
752 || AC.OutputMode == REDUCEMODE ) {
753 *Out++ =
'*'; *Out++ =
'*';
755 else if ( AC.OutputMode == CMODE ) *Out++ =
',';
758 if ( Power < 2*MAXPOWER )
759 Out = NumCopy(Power,Out);
761 Out = StrCopy(FindSymbol((WORD)((LONG)Power-2*MAXPOWER)),Out);
763 if ( AC.OutputMode == CMODE ) *Out++ =
')';
767 if ( ( AC.OutputMode >= FORTRANMODE || AC.OutputMode >= PFORTRANMODE )
768 && AC.OutputMode != CMODE )
771 if ( Power > -2*MAXPOWER )
772 Out = NumCopy(-Power,Out);
774 Out = StrCopy(FindSymbol((WORD)((LONG)Power-2*MAXPOWER)),Out);
776 if ( AC.OutputMode >= FORTRANMODE || AC.OutputMode >= PFORTRANMODE ) *Out++ =
')';
787 void PrintTime(UBYTE *mess)
790 WORD timepart = (WORD)(millitime%1000);
793 MesPrint(
"At %s: Time = %7l.%2i sec",mess,millitime,timepart);
806 static UBYTE *symname[] = {
807 (UBYTE *)
"(cyclic)",(UBYTE *)
"(reversecyclic)"
808 ,(UBYTE *)
"(symmetric)",(UBYTE *)
"(antisymmetric)" };
809 static UBYTE *rsymname[] = {
810 (UBYTE *)
"(-cyclic)",(UBYTE *)
"(-reversecyclic)"
811 ,(UBYTE *)
"(-symmetric)",(UBYTE *)
"(-antisymmetric)" };
817 int first, startvalue;
820 CBUF *C = cbuf+AC.cbufnum;
821 int olddict = AO.CurrentDictionary;
824 AO.OutputLine = AO.OutFill = (UBYTE *)AT.WorkPointer;
825 AO.CurrentDictionary = 0;
827 OutScr = (UBYTE *)AT.WorkPointer + ( TOLONG(AT.WorkTop) - TOLONG(AT.WorkPointer) ) /2;
828 if ( AC.CodesFlag || AC.NamesFlag > 1 ) startvalue = 0;
829 else startvalue = FIRSTUSERSYMBOL;
830 if ( ( j = NumSymbols ) > startvalue ) {
831 TokenToLine((UBYTE *)
" Symbols");
834 for ( i = startvalue; i < j; i++ ) {
835 if ( i >= BUILTINSYMBOLS && i < FIRSTUSERSYMBOL )
continue;
836 Out = StrCopy(VARNAME(symbols,i),OutScr);
837 if ( symbols[i].minpower > -MAXPOWER || symbols[i].maxpower < MAXPOWER ) {
838 Out = StrCopy((UBYTE *)
"(",Out);
839 if ( symbols[i].minpower > -MAXPOWER )
840 Out = NumCopy(symbols[i].minpower,Out);
841 Out = StrCopy((UBYTE *)
":",Out);
842 if ( symbols[i].maxpower < MAXPOWER )
843 Out = NumCopy(symbols[i].maxpower,Out);
844 Out = StrCopy((UBYTE *)
")",Out);
846 if ( ( symbols[i].complex & VARTYPEIMAGINARY ) == VARTYPEIMAGINARY ) {
847 Out = StrCopy((UBYTE *)
"#i",Out);
849 else if ( ( symbols[i].complex & VARTYPECOMPLEX ) == VARTYPECOMPLEX ) {
850 Out = StrCopy((UBYTE *)
"#c",Out);
852 else if ( ( symbols[i].complex & VARTYPEROOTOFUNITY ) == VARTYPEROOTOFUNITY ) {
853 Out = StrCopy((UBYTE *)
"#",Out);
854 if ( ( symbols[i].complex & VARTYPEMINUS ) == VARTYPEMINUS ) {
855 Out = StrCopy((UBYTE *)
"-",Out);
858 Out = StrCopy((UBYTE *)
"+",Out);
860 Out = NumCopy(symbols[i].maxpower,Out);
862 if ( AC.CodesFlag ) Out = CodeToLine(i,Out);
863 if ( ( symbols[i].complex & VARTYPECOMPLEX ) == VARTYPECOMPLEX ) i++;
864 StrCopy((UBYTE *)
" ",Out);
870 if ( AC.CodesFlag || AC.NamesFlag > 1 ) startvalue = 0;
871 else startvalue = BUILTININDICES;
872 if ( ( j = NumIndices ) > startvalue ) {
873 TokenToLine((UBYTE *)
" Indices");
876 for ( i = startvalue; i < j; i++ ) {
877 Out = StrCopy(FindIndex(i+AM.OffsetIndex),OutScr);
878 Out = StrCopy(VARNAME(indices,i),OutScr);
879 if ( indices[i].dimension >= 0 ) {
880 if ( indices[i].dimension != AC.lDefDim ) {
881 Out = StrCopy((UBYTE *)
"=",Out);
882 Out = NumCopy(indices[i].dimension,Out);
885 else if ( indices[i].dimension < 0 ) {
886 Out = StrCopy((UBYTE *)
"=",Out);
887 Out = StrCopy(VARNAME(symbols,-indices[i].dimension),Out);
888 if ( indices[i].nmin4 < -NMIN4SHIFT ) {
889 Out = StrCopy((UBYTE *)
":",Out);
890 Out = StrCopy(VARNAME(symbols,-indices[i].nmin4-NMIN4SHIFT),Out);
893 if ( AC.CodesFlag ) Out = CodeToLine(i+AM.OffsetIndex,Out);
894 StrCopy((UBYTE *)
" ",Out);
900 if ( AC.CodesFlag || AC.NamesFlag > 1 ) startvalue = 0;
901 else startvalue = BUILTINVECTORS;
902 if ( ( j = NumVectors ) > startvalue ) {
903 TokenToLine((UBYTE *)
" Vectors");
906 for ( i = startvalue; i < j; i++ ) {
907 Out = StrCopy(VARNAME(vectors,i),OutScr);
908 if ( AC.CodesFlag ) Out = CodeToLine(i+AM.OffsetVector,Out);
909 StrCopy((UBYTE *)
" ",Out);
916 if ( AC.CodesFlag || AC.NamesFlag > 1 ) startvalue = 0;
917 else startvalue = AM.NumFixedFunctions;
918 for ( k = 0; k < 2; k++ ) {
921 for ( i = startvalue; i < j; i++ ) {
922 if ( i > MAXBUILTINFUNCTION-FUNCTION
923 && i < FIRSTUSERFUNCTION-FUNCTION )
continue;
924 if ( ( k == 0 && functions[i].commute )
925 || ( k != 0 && !functions[i].commute ) ) {
927 TokenToLine((UBYTE *)(FG.FunNam[k]));
932 Out = StrCopy(VARNAME(functions,i),OutScr);
933 if ( ( functions[i].complex & VARTYPEIMAGINARY ) == VARTYPEIMAGINARY ) {
934 Out = StrCopy((UBYTE *)
"#i",Out);
936 else if ( ( functions[i].complex & VARTYPECOMPLEX ) == VARTYPECOMPLEX ) {
937 Out = StrCopy((UBYTE *)
"#c",Out);
939 if ( functions[i].spec >= TENSORFUNCTION ) {
940 Out = StrCopy((UBYTE *)
"(Tensor)",Out);
942 if ( functions[i].symmetric > 0 ) {
943 if ( ( functions[i].symmetric & REVERSEORDER ) != 0 ) {
944 Out = StrCopy((UBYTE *)(rsymname[(functions[i].symmetric & ~REVERSEORDER)-1]),Out);
947 Out = StrCopy((UBYTE *)(symname[functions[i].symmetric-1]),Out);
950 if ( AC.CodesFlag ) Out = CodeToLine(i+FUNCTION,Out);
951 if ( ( functions[i].complex & VARTYPECOMPLEX ) == VARTYPECOMPLEX ) i++;
952 StrCopy((UBYTE *)
" ",Out);
957 if ( first == 0 ) FiniLine();
959 if ( AC.CodesFlag || AC.NamesFlag > 1 ) startvalue = 0;
960 else startvalue = AM.NumFixedSets;
961 if ( ( j = AC.SetList.num ) > startvalue ) {
962 WORD element, LastElement, type, number;
963 TokenToLine((UBYTE *)
" Sets");
964 for ( i = startvalue; i < j; i++ ) {
967 if ( Sets[i].name < 0 ) {
968 Out = StrCopy((UBYTE *)
"{}",OutScr);
971 Out = StrCopy(VARNAME(Sets,i),OutScr);
973 if ( AC.CodesFlag ) Out = CodeToLine(i,Out);
974 StrCopy((UBYTE *)
":",Out);
976 if ( i < AM.NumFixedSets ) {
977 TokenToLine((UBYTE *)
" ");
978 TokenToLine((UBYTE *)fixedsets[i].description);
980 else if ( Sets[i].type == CRANGE ) {
982 if ( Sets[i].first == 3*MAXPOWER ) {
984 else if ( Sets[i].first >= MAXPOWER ) {
985 TokenToLine((UBYTE *)
"<=");
986 NumCopy(Sets[i].first-2*MAXPOWER,OutScr);
991 TokenToLine((UBYTE *)
"<");
992 NumCopy(Sets[i].first,OutScr);
996 if ( Sets[i].last == -3*MAXPOWER ) {
998 else if ( Sets[i].last <= -MAXPOWER ) {
999 if ( iflag ) TokenToLine((UBYTE *)
",");
1000 TokenToLine((UBYTE *)
">=");
1001 NumCopy(Sets[i].last+2*MAXPOWER,OutScr);
1002 TokenToLine(OutScr);
1005 if ( iflag ) TokenToLine((UBYTE *)
",");
1006 TokenToLine((UBYTE *)
">");
1007 NumCopy(Sets[i].last,OutScr);
1008 TokenToLine(OutScr);
1012 element = Sets[i].first;
1013 LastElement = Sets[i].last;
1014 type = Sets[i].type;
1016 TokenToLine((UBYTE *)
" ");
1017 number = SetElements[element++];
1021 StrCopy(VARNAME(symbols,-number),OutScr);
1022 StrCopy((UBYTE *)
"?",Out);
1023 TokenToLine(OutScr);
1025 else if ( number < MAXPOWER )
1026 TokenToLine(VARNAME(symbols,number));
1028 NumCopy(number-2*MAXPOWER,OutScr);
1029 TokenToLine(OutScr);
1033 if ( number >= AM.IndDum ) {
1034 Out = StrCopy((UBYTE *)
"N",OutScr);
1035 Out = NumCopy(number-(AM.IndDum),Out);
1036 StrCopy((UBYTE *)
"_?",Out);
1037 TokenToLine(OutScr);
1039 else if ( number >= AM.OffsetIndex + (WORD)WILDMASK ) {
1040 Out = StrCopy(VARNAME(indices,number
1041 -AM.OffsetIndex-WILDMASK),OutScr);
1042 StrCopy((UBYTE *)
"?",Out);
1043 TokenToLine(OutScr);
1045 else if ( number >= AM.OffsetIndex ) {
1046 TokenToLine(VARNAME(indices,number-AM.OffsetIndex));
1049 NumCopy(number,OutScr);
1050 TokenToLine(OutScr);
1055 if ( number < AM.OffsetVector ) {
1057 Out = StrCopy((UBYTE *)
"-",Out);
1059 if ( number >= AM.OffsetVector + WILDOFFSET ) {
1060 Out = StrCopy(VARNAME(vectors,number
1061 -AM.OffsetVector-WILDOFFSET),Out);
1062 StrCopy((UBYTE *)
"?",Out);
1065 Out = StrCopy(VARNAME(vectors,number-AM.OffsetVector),Out);
1067 TokenToLine(OutScr);
1070 if ( number >= FUNCTION + (WORD)WILDMASK ) {
1071 Out = StrCopy(VARNAME(functions,number
1072 -FUNCTION-WILDMASK),OutScr);
1073 StrCopy((UBYTE *)
"?",Out);
1074 TokenToLine(OutScr);
1076 TokenToLine(VARNAME(functions,number-FUNCTION));
1079 NumCopy(number,OutScr);
1080 TokenToLine(OutScr);
1083 }
while ( element < LastElement );
1089 if ( AS.ExecMode ) {
1093 for ( i = 0; i < j; i++, e++ ) {
1094 if ( e->status >= 0 ) {
1096 TokenToLine((UBYTE *)
" Expressions");
1101 Out = StrCopy(AC.exprnames->namebuffer+e->name,OutScr);
1102 Out = StrCopy((UBYTE *)(FG.ExprStat[e->status]),Out);
1103 if ( AC.CodesFlag ) Out = CodeToLine(i,Out);
1104 StrCopy((UBYTE *)
" ",Out);
1105 TokenToLine(OutScr);
1116 for ( i = 0; i < j; i++ ) {
1117 if ( e->printflag && ( e->status == LOCALEXPRESSION ||
1118 e->status == GLOBALEXPRESSION || e->status == UNHIDELEXPRESSION
1119 || e->status == UNHIDEGEXPRESSION ) ) {
1121 TokenToLine((UBYTE *)
" Expressions to be printed");
1126 Out = StrCopy(AC.exprnames->namebuffer+e->name,OutScr);
1127 StrCopy((UBYTE *)
" ",Out);
1128 TokenToLine(OutScr);
1137 if ( AC.CodesFlag || AC.NamesFlag > 1 ) startvalue = 0;
1138 else startvalue = BUILTINDOLLARS;
1139 if ( ( j = NumDollars ) > startvalue ) {
1140 TokenToLine((UBYTE *)
" Dollar variables");
1143 for ( i = startvalue; i < j; i++ ) {
1144 Out = StrCopy((UBYTE *)
"$", OutScr);
1145 Out = StrCopy(DOLLARNAME(Dollars, i), Out);
1146 if ( AC.CodesFlag ) Out = CodeToLine(i, Out);
1147 StrCopy((UBYTE *)
" ", Out);
1148 TokenToLine(OutScr);
1154 if ( ( j = NumPotModdollars ) > 0 ) {
1155 TokenToLine((UBYTE *)
" Dollar variables to be modified");
1158 for ( i = 0; i < j; i++ ) {
1159 Out = StrCopy((UBYTE *)
"$", OutScr);
1160 Out = StrCopy(DOLLARNAME(Dollars, PotModdollars[i]), Out);
1161 for ( k = 0; k < NumModOptdollars; k++ )
1162 if ( ModOptdollars[k].number == PotModdollars[i] )
break;
1163 if ( k < NumModOptdollars ) {
1164 switch ( ModOptdollars[k].type ) {
1166 Out = StrCopy((UBYTE *)
"(sum)", Out);
1169 Out = StrCopy((UBYTE *)
"(maximum)", Out);
1172 Out = StrCopy((UBYTE *)
"(minimum)", Out);
1175 Out = StrCopy((UBYTE *)
"(local)", Out);
1178 Out = StrCopy((UBYTE *)
"(?)", Out);
1182 StrCopy((UBYTE *)
" ", Out);
1183 TokenToLine(OutScr);
1189 if ( AC.ncmod != 0 ) {
1190 TokenToLine((UBYTE *)
"All arithmetic is modulus ");
1191 LongToLine((UWORD *)AC.cmod,ABS(AC.ncmod));
1192 if ( AC.ncmod > 0 ) TokenToLine((UBYTE *)
" with powerreduction");
1193 else TokenToLine((UBYTE *)
" without powerreduction");
1194 if ( ( AC.modmode & POSNEG ) != 0 ) TokenToLine((UBYTE *)
" centered around 0");
1195 else TokenToLine((UBYTE *)
" positive numbers only");
1198 if ( AC.lDefDim != 4 ) {
1199 TokenToLine((UBYTE *)
"The default dimension is ");
1200 if ( AC.lDefDim >= 0 ) {
1201 NumCopy(AC.lDefDim,OutScr);
1202 TokenToLine(OutScr);
1205 TokenToLine(VARNAME(symbols,-AC.lDefDim));
1206 if ( AC.lDefDim4 != -NMIN4SHIFT ) {
1207 TokenToLine((UBYTE *)
":");
1208 if ( AC.lDefDim4 >= -NMIN4SHIFT ) {
1209 NumCopy(AC.lDefDim4,OutScr);
1210 TokenToLine(OutScr);
1213 TokenToLine(VARNAME(symbols,-AC.lDefDim4-NMIN4SHIFT));
1219 if ( AC.lUnitTrace != 4 ) {
1220 TokenToLine((UBYTE *)
"The trace of the unit matrix is ");
1221 if ( AC.lUnitTrace >= 0 ) {
1222 NumCopy(AC.lUnitTrace,OutScr);
1223 TokenToLine(OutScr);
1226 TokenToLine(VARNAME(symbols,-AC.lUnitTrace));
1230 if ( AO.NumDictionaries > 0 ) {
1231 for ( i = 0; i < AO.NumDictionaries; i++ ) {
1232 WriteDictionary(AO.Dictionaries[i]);
1235 MesPrint(
"\nCurrently dictionary %s is active\n",
1236 AO.Dictionaries[olddict-1]->name);
1238 MesPrint(
"\nCurrently there is no actice dictionary\n");
1240 if ( AC.CodesFlag ) {
1241 if ( C->numlhs > 0 ) {
1242 TokenToLine((UBYTE *)
" Left Hand Sides:");
1244 for ( i = 1; i <= C->numlhs; i++ ) {
1248 while ( --j >= 0 ) { TalToLine((UWORD)(*skip++)); TokenToLine((UBYTE *)
" "); }
1253 if ( C->numrhs > 0 ) {
1254 TokenToLine((UBYTE *)
" Right Hand Sides:");
1256 for ( i = 1; i <= C->numrhs; i++ ) {
1259 while ( ( j = skip[0] ) != 0 ) {
1260 while ( --j >= 0 ) { TalToLine((UWORD)(*skip++)); TokenToLine((UBYTE *)
" "); }
1268 AO.CurrentDictionary = olddict;
1282 WORD *skip, na, *a, spec, *t, *tstop, j;
1283 UBYTE str[2], *OutScr, *Out;
1284 WORD oldoutputmode = AC.OutputMode, oldoutputspaces = AC.OutputSpaces;
1285 WORD oldoutskip = AO.OutSkip;
1286 AC.OutputMode = NORMALFORMAT;
1287 AC.OutputSpaces = NOSPACEFORMAT;
1288 MesPrint(
"===Contents of dictionary %s===",dict->name);
1291 AO.OutputLine = AO.OutFill = (UBYTE *)AT.WorkPointer;
1292 for ( j = 0; j < *skip; j++ ) *(AO.OutFill)++ =
' ';
1294 OutScr = (UBYTE *)AT.WorkPointer + ( TOLONG(AT.WorkTop) - TOLONG(AT.WorkPointer) ) /2;
1295 for ( i = 0; i < dict->numelements; i++ ) {
1296 switch ( dict->elements[i]->type ) {
1297 case DICT_INTEGERNUMBER:
1298 LongToLine((UWORD *)(dict->elements[i]->lhs),dict->elements[i]->size);
1299 Out = OutScr; *Out = 0;
1301 case DICT_RATIONALNUMBER:
1302 a = dict->elements[i]->lhs;
1303 na = a[a[0]-1]; na = (ABS(na)-1)/2;
1304 RatToLine((UWORD *)(a+1),na);
1305 Out = OutScr; *Out = 0;
1308 na = dict->elements[i]->lhs[0];
1309 Out = StrCopy(VARNAME(symbols,na),OutScr);
1312 na = dict->elements[i]->lhs[0]-AM.OffsetVector;
1313 Out = StrCopy(VARNAME(vectors,na),OutScr);
1316 na = dict->elements[i]->lhs[0]-AM.OffsetIndex;
1317 Out = StrCopy(VARNAME(indices,na),OutScr);
1320 na = dict->elements[i]->lhs[0]-FUNCTION;
1321 Out = StrCopy(VARNAME(functions,na),OutScr);
1323 case DICT_FUNCTION_WITH_ARGUMENTS:
1324 t = dict->elements[i]->lhs;
1326 Out = StrCopy(VARNAME(functions,na),OutScr);
1327 spec = functions[*t - FUNCTION].spec;
1330 if ( t[1] <= FUNHEAD ) {}
1331 else if ( spec >= TENSORFUNCTION ) {
1332 t += FUNHEAD; *Out++ = (UBYTE)
'(';
1333 while ( t < tstop ) {
1334 if ( first == 0 ) *Out++ = (UBYTE)(
',');
1338 if ( j < AM.OffsetIndex ) { Out = NumCopy(j,Out); }
1339 else if ( j < AM.IndDum ) {
1340 Out = StrCopy(VARNAME(indices,j-AM.OffsetIndex),Out);
1343 MesPrint(
"Currently wildcards are not allowed in dictionary elements");
1348 Out = StrCopy(VARNAME(vectors,j-AM.OffsetVector),Out);
1351 *Out++ = (UBYTE)
')'; *Out = 0;
1354 t += FUNHEAD; *Out++ = (UBYTE)
'('; *Out = 0;
1355 TokenToLine(OutScr);
1356 while ( t < tstop ) {
1357 if ( !first ) TokenToLine((UBYTE *)
",");
1363 *Out++ = (UBYTE)')'; *Out = 0;
1366 case DICT_SPECIALCHARACTER:
1367 str[0] = (UBYTE)(dict->elements[i]->lhs[0]);
1369 Out = StrCopy(str,OutScr);
1372 Out = OutScr; *Out = 0;
1375 Out = StrCopy((UBYTE *)": \"",Out);
1376 Out = StrCopy((UBYTE *)(dict->elements[i]->rhs),Out);
1377 Out = StrCopy((UBYTE *)"\"",Out);
1378 TokenToLine(OutScr);
1381 MesPrint("========End of dictionary %s===",dict->name);
1382 AC.OutputMode = oldoutputmode;
1383 AC.OutputSpaces = oldoutputspaces;
1384 AO.OutSkip = oldoutskip;
1395 VOID WriteArgument(WORD *t)
1400 int oldoutsidefun, oldlowestlevel = lowestlevel;
1403 oldoutsidefun = AC.outsidefun; AC.outsidefun = 0;
1404 WriteExpression(t+ARGHEAD,(LONG)(*t-ARGHEAD));
1405 AC.outsidefun = oldoutsidefun;
1409 if ( *t == -SNUMBER) {
1412 else if ( *t == -SYMBOL ) {
1413 if ( t[1] >= MAXVARIABLES-cbuf[AM.sbufnum].numrhs ) {
1414 Out = StrCopy(FindExtraSymbol(MAXVARIABLES-t[1]),Out);
1432 StrCopy(FindSymbol(t[1]),Out);
1436 else if ( *t == -VECTOR ) {
1437 if ( t[1] == FUNNYVEC ) { *Out++ =
'?'; *Out = 0; }
1439 StrCopy(FindVector(t[1]),Out);
1442 else if ( *t == -MINVECTOR ) {
1444 StrCopy(FindVector(t[1]),Out);
1447 else if ( *t == -INDEX ) {
1449 if ( t[1] < AM.OffsetIndex ) { NumCopy(t[1],Out); }
1452 if ( i >= AM.IndDum ) {
1455 Out = NumCopy(i,Out);
1461 i -= AM.OffsetIndex;
1462 Out = StrCopy(FindIndex(i%WILDOFFSET+AM.OffsetIndex),Out);
1464 if ( i >= WILDOFFSET ) { *Out++ =
'?'; *Out = 0; }
1468 else if ( t[1] == FUNNYVEC ) { *Out++ =
'?'; *Out = 0; }
1470 StrCopy(FindVector(t[1]),Out);
1473 else if ( *t == -DOLLAREXPRESSION ) {
1476 StrCopy(AC.dollarnames->namebuffer+d->name,Out);
1478 else if ( *t == -EXPRESSION ) {
1479 StrCopy(EXPRNAME(t[1]),Out);
1481 else if ( *t == -SETSET ) {
1482 StrCopy(VARNAME(Sets,t[1]),Out);
1484 else if ( *t <= -FUNCTION ) {
1485 StrCopy(FindFunction(-*t),Out);
1489 MesPrint(
"Illegal function argument while writing");
1492 TokenToLine(buffer);
1494 lowestlevel = oldlowestlevel;
1513 WORD WriteSubTerm(WORD *sterm, WORD first)
1516 UBYTE *Out, closepar[2] = { (UBYTE)
')', 0};
1517 WORD *stopper, *t, *tt, i, j, po = 0;
1519 stopper = sterm + sterm[1];
1523 while ( t < stopper ) {
1524 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1526 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1528 if ( first ) TokenToLine((UBYTE *)
" ");
1530 if ( !first ) MultiplyToLine();
1531 if ( AC.OutputMode == CMODE && t[1] != 1 ) {
1532 if ( AC.Cnumpows >= t[1] && t[1] > 0 ) {
1534 Out = StrCopy((UBYTE *)
"POW",buffer);
1535 Out = NumCopy(po,Out);
1536 Out = StrCopy((UBYTE *)
"(",Out);
1537 TokenToLine(buffer);
1540 TokenToLine((UBYTE *)
"pow(");
1543 if ( *t < NumSymbols ) {
1544 Out = StrCopy(FindSymbol(*t),buffer); t++;
1551 Out = StrCopy(FindExtraSymbol(MAXVARIABLES-*t),buffer);
1569 if ( AC.OutputMode == CMODE && po > 1
1570 && AC.Cnumpows >= po ) {
1571 Out = StrCopy((UBYTE *)
")",Out);
1574 else if ( *t != 1 ) WrtPower(Out,*t);
1575 TokenToLine(buffer);
1581 while ( t < stopper ) {
1582 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1584 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1586 if ( first ) TokenToLine((UBYTE *)
" ");
1588 if ( !first ) MultiplyToLine();
1590 Out = StrCopy(FindVector(*t),buffer);
1593 if ( AC.OutputMode == MATHEMATICAMODE ) *Out++ =
'[';
1595 if ( *t >= AM.OffsetIndex ) {
1597 if ( i >= AM.IndDum ) {
1600 Out = NumCopy(i,Out);
1606 Out = StrCopy(FindIndex(i),Out);
1609 else if ( *t == FUNNYVEC ) { *Out++ =
'?'; *Out = 0; }
1611 Out = NumCopy(*t++,Out);
1613 if ( AC.OutputMode == MATHEMATICAMODE ) *Out++ =
']';
1616 TokenToLine(buffer);
1621 while ( t < stopper ) {
1622 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1624 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1626 if ( first ) TokenToLine((UBYTE *)
" ");
1628 if ( !first ) MultiplyToLine();
1630 if ( *t < AM.OffsetIndex ) {
1631 TalToLine((UWORD)(*t++));
1635 if ( i >= AM.IndDum ) {
1639 Out = NumCopy(i,Out);
1645 i -= AM.OffsetIndex;
1646 Out = StrCopy(FindIndex(i%WILDOFFSET+AM.OffsetIndex),buffer);
1648 if ( i >= WILDOFFSET ) { *Out++ =
'?'; *Out = 0; }
1650 TokenToLine(buffer);
1654 TokenToLine(FindVector(*t)); t++;
1660 case DOLLAREXPRESSION:
1662 DOLLARS d = Dollars + sterm[2];
1663 Out = StrCopy((UBYTE *)
"$",buffer);
1664 Out = StrCopy(AC.dollarnames->namebuffer+d->name,Out);
1665 if ( sterm[3] != 1 ) WrtPower(Out,sterm[3]);
1666 TokenToLine(buffer);
1671 while ( t < stopper ) {
1672 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1674 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1676 if ( first ) TokenToLine((UBYTE *)
" ");
1678 if ( !first ) MultiplyToLine();
1679 Out = StrCopy((UBYTE *)
"d_(",buffer);
1680 if ( *t >= AM.OffsetIndex ) {
1681 if ( *t < AM.IndDum ) {
1682 Out = StrCopy(FindIndex(*t),Out);
1688 Out = NumCopy( *t++ - AM.IndDum, Out);
1694 else if ( *t == FUNNYVEC ) { *Out++ =
'?'; *Out = 0; }
1696 Out = NumCopy(*t++,Out);
1699 if ( *t >= AM.OffsetIndex ) {
1700 if ( *t < AM.IndDum ) {
1701 Out = StrCopy(FindIndex(*t),Out);
1707 Out = NumCopy(*t++ - AM.IndDum,Out);
1713 Out = NumCopy(*t++,Out);
1717 TokenToLine(buffer);
1722 while ( t < stopper ) {
1723 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1725 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1727 if ( first ) TokenToLine((UBYTE *)
" ");
1729 if ( !first ) MultiplyToLine();
1730 if ( AC.OutputMode == CMODE && t[2] != 1 )
1731 TokenToLine((UBYTE *)
"pow(");
1732 Out = StrCopy(FindVector(*t),buffer);
1735 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE
1736 || AC.OutputMode == CMODE )
1737 *Out++ = AO.FortDotChar;
1739 Out = StrCopy(FindVector(*t),Out);
1742 if ( *t != 1 ) WrtPower(Out,*t);
1744 TokenToLine(buffer);
1752 if ( !first ) MultiplyToLine();
1753 if ( AC.OutputMode == CMODE ) TokenToLine((UBYTE *)
"pow(");
1754 else TokenToLine((UBYTE *)
"(");
1756 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE
1757 || AC.OutputMode == REDUCEMODE )
1758 TokenToLine((UBYTE *)
")**(");
1759 else if ( AC.OutputMode == CMODE ) TokenToLine((UBYTE *)
",");
1760 else TokenToLine((UBYTE *)
")^(");
1763 TokenToLine((UBYTE *)")");
1769 if ( first ) TokenToLine((UBYTE *)
"1/(");
1770 else TokenToLine((UBYTE *)
"/(");
1772 TokenToLine((UBYTE *)
")");
1775 if ( !first ) MultiplyToLine();
1776 TokenToLine((UBYTE *)
"(");
1777 t = cbuf[sterm[4]].rhs[sterm[2]];
1779 while ( *tt ) tt += *tt;
1780 oldoutsidefun = AC.outsidefun; AC.outsidefun = 0;
1782 WriteExpression(t,(LONG)(tt-t));
1785 TokenToLine((UBYTE *)
"0");
1787 AC.outsidefun = oldoutsidefun;
1788 TokenToLine((UBYTE *)
")");
1789 if ( sterm[3] != 1 ) {
1790 TokenToLine((UBYTE *)
"^");
1792 NumCopy(sterm[3],Out);
1793 TokenToLine(buffer);
1797 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1799 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1801 if ( first ) TokenToLine((UBYTE *)
" ");
1803 if ( *sterm < FUNCTION ) {
1804 return(MesPrint(
"Illegal subterm while writing"));
1806 if ( !first ) MultiplyToLine();
1809 if ( ( tmp = FindFunWithArgs(sterm) ) != 0 ) {
1816 if ( *sterm == GAMMA && t[-FUNHEAD+1] == FUNHEAD+1 ) {
1817 TokenToLine((UBYTE *)
"gi_(");
1820 if ( *sterm != DUMFUN ) {
1821 Out = StrCopy(FindFunction(*sterm),buffer);
1824 else { Out = buffer; *Out = 0; }
1825 if ( t >= stopper ) {
1826 TokenToLine(buffer);
1829 if ( AC.OutputMode == MATHEMATICAMODE ) { *Out++ =
'['; closepar[0] = (UBYTE)
']'; }
1830 else { *Out++ =
'('; }
1832 TokenToLine(buffer);
1834 i = functions[*sterm - FUNCTION].spec;
1835 if ( i >= TENSORFUNCTION ) {
1836 int curdict = AO.CurrentDictionary;
1837 if ( AO.CurrentDictionary && AO.CurDictNotInFunctions > 0 )
1838 AO.CurrentDictionary = 0;
1839 t = sterm + FUNHEAD;
1840 while ( t < stopper ) {
1841 if ( !first ) TokenToLine((UBYTE *)
",");
1845 if ( j < AM.OffsetIndex ) TalToLine((UWORD)(j));
1846 else if ( j < AM.IndDum ) {
1847 i = j - AM.OffsetIndex;
1848 Out = StrCopy(FindIndex(i%WILDOFFSET+AM.OffsetIndex),buffer);
1850 if ( i >= WILDOFFSET ) { *Out++ =
'?'; *Out = 0; }
1851 TokenToLine(buffer);
1856 Out = NumCopy(j - AM.IndDum,Out);
1860 TokenToLine(buffer);
1863 else if ( j == FUNNYVEC ) { TokenToLine((UBYTE *)
"?"); }
1864 else if ( j > -WILDOFFSET ) {
1866 Out = NumCopy((UWORD)(-j + 4),Out);
1869 TokenToLine(buffer);
1872 TokenToLine(FindVector(j));
1876 AO.CurrentDictionary = curdict;
1879 int curdict = AO.CurrentDictionary;
1880 if ( AO.CurrentDictionary && AO.CurDictNotInFunctions > 0 )
1881 AO.CurrentDictionary = 0;
1882 while ( t < stopper ) {
1883 if ( !first ) TokenToLine((UBYTE *)
",");
1888 AO.CurrentDictionary = curdict;
1890 TokenToLine(closepar);
1891 closepar[0] = (UBYTE)')';
1906 WORD WriteInnerTerm(WORD *term, WORD first)
1908 WORD *t, *s, *s1, *s2, n, i, pow;
1913 if ( *s == HAAKJE )
break;
1916 if ( s < t ) { s += s[1]; }
1917 else { s = term+1; }
1919 if ( n < 0 || !first ) {
1920 if ( n > 0 ) { TOKENTOLINE(
" + ",
"+") }
1921 else if ( n < 0 ) { n = -n; TOKENTOLINE(
" - ",
"-") }
1923 if ( AC.modpowers ) {
1924 if ( n == 1 && *t == 1 && t > s ) first = 1;
1925 else if ( ABS(AC.ncmod) == 1 ) {
1926 LongToLine((UWORD *)AC.powmod,AC.npowmod);
1927 TokenToLine((UBYTE *)
"^");
1928 TalToLine(AC.modpowers[(LONG)((UWORD)*t)]);
1933 LongToLine((UWORD *)AC.powmod,AC.npowmod);
1934 TokenToLine((UBYTE *)
"^");
1936 if ( n == 2 ) jj += ((LONG)t[1])<<BITSINWORD;
1937 if ( AC.modpowers[jj+1] == 0 ) {
1938 TalToLine(AC.modpowers[jj]);
1941 LongToLine(AC.modpowers+jj,2);
1946 else if ( n != 1 || *t != 1 || t[1] != 1 || t <= s ) {
1947 if ( lowestlevel && ( ( AO.PrintType & PRINTONEFUNCTION ) != 0 ) ) {
1949 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1952 if ( AO.CurrentDictionary > 0 ) TransformRational((UWORD *)t,n);
1953 else RatToLine((UWORD *)t,n);
1958 if ( lowestlevel && ( (AO.PrintType & (PRINTONEFUNCTION | PRINTALL)) == PRINTONEFUNCTION ) ) {
1960 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1968 if ( *s == GAMMA ) {
1970 ss = AT.WorkPointer;
1975 tt = s + FUNHEAD + 1;
1976 n = s[1] - FUNHEAD-1;
1978 while ( --n >= 0 ) *ss++ = *tt++;
1980 while ( *tt == GAMMA && tt[FUNHEAD] == s[FUNHEAD] && tt < t ) {
1983 n = s[1] - FUNHEAD-1;
1987 tt = AT.WorkPointer;
1988 AT.WorkPointer = ss;
1989 tt[1] = WORDDIF(ss,tt);
1990 if ( WriteSubTerm(tt,first) ) {
1991 MesCall(
"WriteInnerTerm");
1994 AT.WorkPointer = tt;
2002 if ( *s >= FUNCTION && AC.funpowers > 0
2003 && functions[*s-FUNCTION].spec == 0 && ( AC.funpowers == ALLFUNPOWERS ||
2004 ( AC.funpowers == COMFUNPOWERS && functions[*s-FUNCTION].commute == 0 ) ) ) {
2007 s1 = s; s2 = s + s[1]; i = s[1];
2009 while ( --i >= 0 && *s1 == *s2 ) { s1++; s2++; }
2018 if ( AC.OutputMode == CMODE ) {
2019 if ( !first ) MultiplyToLine();
2020 TokenToLine((UBYTE *)
"pow(");
2023 if ( WriteSubTerm(s,first) ) {
2024 MesCall(
"WriteInnerTerm");
2027 if ( AC.OutputMode == FORTRANMODE
2028 || AC.OutputMode == PFORTRANMODE ) { TokenToLine((UBYTE *)
"**"); }
2029 else if ( AC.OutputMode == CMODE ) { TokenToLine((UBYTE *)
","); }
2030 else { TokenToLine((UBYTE *)
"^"); }
2032 if ( AC.OutputMode == CMODE ) TokenToLine((UBYTE *)
")");
2034 else if ( WriteSubTerm(s,first) ) {
2035 MesCall(
"WriteInnerTerm");
2039 else if ( WriteSubTerm(s,first) ) {
2040 MesCall(
"WriteInnerTerm");
2064 WORD WriteTerm(WORD *term, WORD *lbrac, WORD first, WORD prtf, WORD br)
2066 WORD *t, *stopper, *b, n;
2067 int oldIsFortran90 = AC.IsFortran90, i;
2068 if ( *lbrac >= 0 ) {
2070 stopper = (term + *term - 1);
2071 stopper -= ABS(*stopper) - 1;
2072 while ( t < stopper ) {
2073 if ( *t == HAAKJE ) {
2076 if ( *lbrac == ( n = WORDDIF(stopper,t) ) ) {
2079 while ( n > 0 && ( *b++ == *t++ ) ) { n--; }
2080 if ( n <= 0 && ( ( AO.InFbrack < AM.FortranCont )
2081 || ( lowestlevel == 0 ) ) ) {
2086 if ( ( prtf & PRINTCONTENTS ) != 0 ) {
2090 if ( WriteInnerTerm(term,0) )
goto WrtTmes;
2091 if ( ( AO.PrintType & PRINTONETERM ) != 0 ) {
2093 TokenToLine((UBYTE *)
" ");
2099 n = WORDDIF(stopper,t);
2105 if ( ( prtf & PRINTCONTENTS ) ) PrtTerms();
2106 TOKENTOLINE(
" )",
")")
2107 if ( AC.OutputMode == CMODE && AO.FactorMode == 0 )
2108 TokenToLine((UBYTE *)";");
2109 else if ( AO.FactorMode && ( n == 0 ) ) {
2115 AC.IsFortran90 = ISNOTFORTRAN90;
2117 AC.IsFortran90 = oldIsFortran90;
2118 if ( AC.OutputMode != FORTRANMODE && AC.OutputMode != PFORTRANMODE
2119 && AC.OutputSpaces == NORMALFORMAT
2120 && AO.FactorMode == 0 ) FiniLine();
2123 if ( AC.OutputMode == CMODE && AO.FactorMode == 0 )
2124 TokenToLine((UBYTE *)
";");
2125 if ( AO.FortFirst == 0 ) {
2127 AC.IsFortran90 = ISNOTFORTRAN90;
2129 AC.IsFortran90 = oldIsFortran90;
2133 if ( AO.FactorMode == 0 ) {
2134 if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2136 WORD oldmode = AC.OutputMode;
2139 AC.OutputMode = oldmode;
2142 if ( AO.FortFirst == 0 ) {
2143 TokenToLine(AO.CurBufWrt);
2144 TOKENTOLINE(
" = ",
"=")
2145 TokenToLine(AO.CurBufWrt);
2149 TokenToLine(AO.CurBufWrt);
2150 TOKENTOLINE(
" = ",
"=")
2153 else if ( AC.OutputMode == CMODE && !first ) {
2155 if ( AO.FortFirst == 0 ) {
2156 TokenToLine(AO.CurBufWrt);
2157 TOKENTOLINE(
" += ",
"+=")
2161 TokenToLine(AO.CurBufWrt);
2162 TOKENTOLINE(
" = ",
"=")
2165 else if ( startinline == 0 ) {
2169 if ( ( *lbrac = n ) > 0 ) {
2172 while ( --n >= 0 ) *b++ = *t++;
2173 *b++ = 1; *b++ = 1; *b = 3;
2175 if ( WriteInnerTerm(AO.bracket,0) ) {
2182 while ( --i >= 0 ) { TalToLine((UWORD)(*t++));
2183 if ( AC.OutputSpaces == NORMALFORMAT )
2184 TokenToLine((UBYTE *)
" "); }
2187 MesCall(
"WriteTerm");
2190 TOKENTOLINE(
" * ( ",
"*(")
2193 if ( ( prtf & PRINTONETERM ) != 0 ) {
2196 TokenToLine((UBYTE *)
" ");
2210 if ( ( *lbrac = n ) > 0 ) {
2213 while ( --n >= 0 ) *b++ = *t++;
2214 *b++ = 1; *b++ = 1; *b = 3;
2215 for ( i = AO.FactorNum+1; i < AO.bracket[4]; i++ ) {
2217 TOKENTOLINE(
" ( 0 )",
" (0)")
2221 TOKENTOLINE(
" * ( 0 )",
"*(0)")
2226 AO.FactorNum = AO.bracket[4];
2232 if ( first == 0 ) { TOKENTOLINE(
" * ( ",
"*(") }
2233 else { TOKENTOLINE(
" ( ",
" (") }
2237 if ( ( prtf & PRINTCONTENTS ) != 0 ) AO.NumInBrack++;
2238 else if ( WriteInnerTerm(term,first) )
goto WrtTmes;
2239 if ( ( AO.PrintType & PRINTONETERM ) != 0 ) {
2241 TokenToLine((UBYTE *)
" ");
2248 if ( ( prtf & PRINTCONTENTS ) != 0 ) PrtTerms();
2249 TokenToLine((UBYTE *)
" )");
2250 if ( AC.OutputMode == CMODE ) TokenToLine((UBYTE *)
";");
2251 if ( AO.FortFirst == 0 ) {
2252 AC.IsFortran90 = ISNOTFORTRAN90;
2254 AC.IsFortran90 = oldIsFortran90;
2256 if ( AC.OutputMode != FORTRANMODE && AC.OutputMode != PFORTRANMODE
2257 && AC.OutputSpaces == NORMALFORMAT ) FiniLine();
2258 if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2260 WORD oldmode = AC.OutputMode;
2263 AC.OutputMode = oldmode;
2265 if ( AO.FortFirst == 0 ) {
2266 TokenToLine(AO.CurBufWrt);
2267 TOKENTOLINE(
" = ",
"=")
2268 TokenToLine(AO.CurBufWrt);
2272 TokenToLine(AO.CurBufWrt);
2273 TOKENTOLINE(
" = ",
"=")
2283 else if ( AC.OutputMode == CMODE && !first ) {
2285 if ( AO.FortFirst == 0 ) {
2286 TokenToLine(AO.CurBufWrt);
2287 TOKENTOLINE(
" += ",
"+=")
2291 TokenToLine(AO.CurBufWrt);
2292 TOKENTOLINE(
" = ",
"=")
2308 if ( !br ) AO.IsBracket = 0;
2309 if ( ( AO.InFbrack >= AM.FortranCont ) && lowestlevel ) {
2310 if ( AC.OutputMode == CMODE ) TokenToLine((UBYTE *)
";");
2311 if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2313 WORD oldmode = AC.OutputMode;
2314 if ( AO.FortFirst == 0 ) {
2315 AC.IsFortran90 = ISNOTFORTRAN90;
2317 AC.IsFortran90 = oldIsFortran90;
2320 AC.OutputMode = oldmode;
2322 TokenToLine(AO.CurBufWrt);
2323 TOKENTOLINE(
" = ",
"=")
2324 TokenToLine(AO.CurBufWrt);
2341 else if ( AC.OutputMode == CMODE && !first ) {
2344 if ( AO.FortFirst == 0 ) {
2345 TokenToLine(AO.CurBufWrt);
2346 TOKENTOLINE(
" += ",
"+=")
2350 TokenToLine(AO.CurBufWrt);
2351 TOKENTOLINE(
" = ",
"=")
2368 if ( WriteInnerTerm(term,first) )
goto WrtTmes;
2369 if ( ( AO.PrintType & PRINTONETERM ) != 0 ) {
2386 WORD WriteExpression(WORD *terms, LONG ltot)
2390 WORD OldIsBracket = AO.IsBracket, OldPrintType = AO.PrintType;
2391 if ( !AC.outsidefun ) { AO.PrintType &= ~PRINTONETERM; first = 1; }
2393 stopper = terms + ltot;
2395 while ( terms < stopper ) {
2396 AO.IsBracket = OldIsBracket;
2397 if ( WriteTerm(terms,&btot,first,0,1) ) {
2398 MesCall(
"WriteExpression");
2405 AO.IsBracket = OldIsBracket;
2406 AO.PrintType = OldPrintType;
2421 WORD *t, *stopper, n, prtf;
2422 int oldIsFortran90 = AC.IsFortran90, i;
2426 if ( AM.exitflag )
return(0);
2428 if ( PF.me != MASTER ) {
2433 for ( n = 0; n < NumExpressions; n++ ) {
2434 e = &Expressions[n];
2435 if ( !e->printflag & PRINTON )
continue;
2436 switch ( e->status ) {
2437 case LOCALEXPRESSION:
2438 case GLOBALEXPRESSION:
2439 case UNHIDELEXPRESSION:
2440 case UNHIDEGEXPRESSION:
2446 PutPreVar(AM.oldnumextrasymbols, GetPreVar((UBYTE *)
"EXTRASYMBOLS_", 0), 0, 1);
2447 if ( AO.OptimizationLevel > 0 ) {
2448 if ( Optimize(0, 1) )
return(-1);
2454 SeekScratch(AR.outfile,&pos);
2455 if ( ResetScratch() ) {
2456 MesCall(
"WriteAll");
2459 AO.termbuf = AT.WorkPointer;
2460 AO.bracket = (WORD *)(((UBYTE *)(AT.WorkPointer)) + AM.MaxTer);
2461 AT.WorkPointer = (WORD *)(((UBYTE *)(AT.WorkPointer)) + AM.MaxTer*2);
2462 AO.OutFill = AO.OutputLine = (UBYTE *)AT.WorkPointer;
2463 AT.WorkPointer += 2*AC.LineLength;
2464 *(AR.CompressBuffer) = 0;
2466 for ( n = 0; n < NumExpressions; n++ ) {
2467 if ( ( Expressions[n].printflag & PRINTON ) != 0 ) { first = 1;
break; }
2469 if ( !first )
goto EndWrite;
2473 while ( GetTerm(BHEAD AO.termbuf) ) {
2475 e = Expressions + AO.termbuf[3];
2477 if ( ( n == LOCALEXPRESSION || n == GLOBALEXPRESSION
2478 || n == UNHIDELEXPRESSION || n == UNHIDEGEXPRESSION ) &&
2479 ( ( prtf = e->printflag ) & PRINTON ) != 0 ) {
2483 GetPreVar((UBYTE *)
"EXTRASYMBOLS_",0),0,1);
2484 if ( ( prtf & PRINTLFILE ) != 0 ) {
2485 if ( AC.LogHandle < 0 ) prtf &= ~PRINTLFILE;
2487 AO.PrintType = prtf;
2500 if ( AO.OptimizationLevel > 0 ) {
2501 UBYTE *oldOutFill = AO.OutFill, *oldOutputLine = AO.OutputLine;
2503 if ( Optimize(AO.termbuf[3], 1) )
goto AboWrite;
2505 AO.OutFill = oldOutFill; AO.OutputLine = oldOutputLine;
2509 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2512 AO.CurBufWrt = EXPRNAME(AO.termbuf[3]);
2513 TokenToLine(AO.CurBufWrt);
2516 if ( t < stopper ) {
2517 TokenToLine((UBYTE *)
"(");
2519 while ( t < stopper ) {
2521 if ( !first ) TokenToLine((UBYTE *)
",");
2524 TokenToLine(FindSymbol(t[2]));
2528 TokenToLine(FindVector(t[2]));
2532 TokenToLine(FindIndex(t[2]));
2536 TokenToLine(FindFunction(t[2]));
2543 TokenToLine((UBYTE *)
")");
2545 TOKENTOLINE(
" =",
"=");
2548 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2553 if ( ( e->vflags & ISFACTORIZED ) != 0 ) {
2554 AO.FactorMode = 1+e->numfactors;
2560 while ( GetTerm(BHEAD AO.termbuf) ) {
2562 GETSTOP(AO.termbuf,m);
2563 if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2564 && ( ( prtf & PRINTONETERM ) != 0 ) ) {}
2571 if ( ( prtf & PRINTONETERM ) != 0 ) first = 0;
2572 if ( WriteTerm(AO.termbuf,&lbrac,first,prtf,0) )
2576 if ( AO.FactorMode ) {
2577 if ( first ) { AO.FactorNum = 1; TOKENTOLINE(
" ( 0 )",
" (0)") }
2578 else TOKENTOLINE(
" )",
")");
2579 for ( i = AO.FactorNum+1; i <= e->numfactors; i++ ) {
2582 TOKENTOLINE(
" * ( 0 )",
"*(0)");
2584 AO.FactorNum = e->numfactors;
2585 if ( AC.OutputMode != FORTRANMODE && AC.OutputMode != PFORTRANMODE )
2586 TokenToLine((UBYTE *)
";");
2588 else if ( AO.FactorMode == 0 || first ) {
2589 if ( first ) { TOKENTOLINE(
" 0",
"0") }
2591 if ( ( prtf & PRINTCONTENTS ) != 0 ) PrtTerms();
2592 TOKENTOLINE(
" )",
")")
2594 else if ( ( prtf & PRINTCONTENTS ) != 0 ) {
2595 TOKENTOLINE(
" + 1 * ( ",
"+1*(")
2597 TOKENTOLINE(" )",")")
2599 if ( AC.OutputMode != FORTRANMODE && AC.OutputMode != PFORTRANMODE )
2600 TokenToLine((UBYTE *)";");
2603 AC.IsFortran90 = ISNOTFORTRAN90;
2605 AC.IsFortran90 = oldIsFortran90;
2609 do { }
while ( GetTerm(BHEAD AO.termbuf) );
2612 if ( AC.OutputSpaces == NORMALFORMAT ) FiniLine();
2614 if ( AR.infile->handle >= 0 ) {
2615 SeekFile(AR.infile->handle,&(AR.infile->filesize),SEEK_SET);
2618 AT.WorkPointer = AO.termbuf;
2619 SetScratch(AR.infile,&pos);
2620 f = AR.outfile; AR.outfile = AR.infile; AR.infile = f;
2623 SetScratch(AR.infile,&pos);
2624 f = AR.outfile; AR.outfile = AR.infile; AR.infile = f;
2625 MesCall(
"WriteAll");
2637 WORD WriteOne(UBYTE *name,
int alreadyinline,
int nosemi, WORD plus)
2646 if ( GetName(AC.exprnames,name,&number,NOAUTO) != CEXPRESSION ) {
2647 MesPrint(
"@%s is not an expression",name);
2650 switch ( Expressions[number].status ) {
2651 case HIDDENLEXPRESSION:
2652 case HIDDENGEXPRESSION:
2653 case HIDELEXPRESSION:
2654 case HIDEGEXPRESSION:
2655 case UNHIDELEXPRESSION:
2656 case UNHIDEGEXPRESSION:
2663 case LOCALEXPRESSION:
2664 case GLOBALEXPRESSION:
2665 case SKIPLEXPRESSION:
2666 case SKIPGEXPRESSION:
2674 MesPrint(
"@expressions %s is not active. It cannot be written",name);
2677 SeekScratch(AR.outfile,&pos);
2679 f = AR.outfile; AR.outfile = AR.infile; AR.infile = f;
2686 if ( AR.GetFile == 2 ) f = AR.hidefile;
2688 prf = Expressions[number].printflag;
2689 if ( plus ) prf |= PRINTONETERM;
2694 SetScratch(f,&(Expressions[number].onfile));
2697 f->POfill = (WORD *)((UBYTE *)(f->PObuffer)
2698 + BASEPOSITION(Expressions[number].onfile));
2700 AO.termbuf = AT.WorkPointer;
2701 AO.bracket = (WORD *)(((UBYTE *)(AT.WorkPointer)) + AM.MaxTer);
2702 AT.WorkPointer = (WORD *)(((UBYTE *)(AT.WorkPointer)) + AM.MaxTer*2);
2704 AO.OutFill = AO.OutputLine = (UBYTE *)AT.WorkPointer;
2705 AT.WorkPointer += 2*AC.LineLength;
2706 *(AR.CompressBuffer) = 0;
2712 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2714 if ( GetTerm(BHEAD AO.termbuf) <= 0 ) {
2715 MesPrint(
"@ReadError in expression %s",name);
2728 if ( AO.OptimizationLevel > 0 ) {
2730 if ( Optimize(AO.termbuf[3], 1) )
goto AboWrite;
2739 while ( GetTerm(BHEAD AO.termbuf) ) {
2741 GETSTOP(AO.termbuf,m);
2744 startinline = alreadyinline;
2745 AO.OutFill = AO.OutputLine + startinline;
2746 if ( WriteTerm(AO.termbuf,&lbrac,first,0,0) )
2751 if ( ( prf & PRINTONETERM ) != 0 ) first = 1;
2757 if ( WriteTerm(AO.termbuf,&lbrac,first,0,0) )
2763 startinline = alreadyinline;
2764 AO.OutFill = AO.OutputLine + startinline;
2765 TOKENTOLINE(
" 0",
"0");
2768 TOKENTOLINE(
" )",
")");
2770 if ( AC.OutputMode != FORTRANMODE && AC.OutputMode != PFORTRANMODE
2771 && nosemi == 0 ) TokenToLine((UBYTE *)
";");
2773 if ( AC.OutputSpaces == NORMALFORMAT && nosemi == 0 ) {
2777 noextralinefeed = 1;
2779 noextralinefeed = 0;
2783 AT.WorkPointer = AO.termbuf;
2785 f = AR.outfile; AR.outfile = AR.infile; AR.infile = f;
2789 SetScratch(AR.infile,&pos);
2790 f->POposition = pos;
2791 f = AR.outfile; AR.outfile = AR.infile; AR.infile = f;
2792 MesCall(
"WriteOne");
int PutPreVar(UBYTE *, UBYTE *, UBYTE *, int)