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++ =
')';
790 WORD timepart = (WORD)(millitime%1000);
793 MesPrint(
"Time = %7l.%2i sec",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 <= -FUNCTION ) {
1482 StrCopy(FindFunction(-*t),Out);
1486 MesPrint(
"Illegal function argument while writing");
1489 TokenToLine(buffer);
1491 lowestlevel = oldlowestlevel;
1510 WORD WriteSubTerm(WORD *sterm, WORD first)
1513 UBYTE *Out, closepar[2] = { (UBYTE)
')', 0};
1514 WORD *stopper, *t, *tt, i, j, po = 0;
1516 stopper = sterm + sterm[1];
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 ) MultiplyToLine();
1528 if ( AC.OutputMode == CMODE && t[1] != 1 ) {
1529 if ( AC.Cnumpows >= t[1] && t[1] > 0 ) {
1531 Out = StrCopy((UBYTE *)
"POW",buffer);
1532 Out = NumCopy(po,Out);
1533 Out = StrCopy((UBYTE *)
"(",Out);
1534 TokenToLine(buffer);
1537 TokenToLine((UBYTE *)
"pow(");
1540 if ( *t < NumSymbols ) {
1541 Out = StrCopy(FindSymbol(*t),buffer); t++;
1548 Out = StrCopy(FindExtraSymbol(MAXVARIABLES-*t),buffer);
1566 if ( AC.OutputMode == CMODE && po > 1
1567 && AC.Cnumpows >= po ) {
1568 Out = StrCopy((UBYTE *)
")",Out);
1571 else if ( *t != 1 ) WrtPower(Out,*t);
1572 TokenToLine(buffer);
1578 while ( t < stopper ) {
1579 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1581 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1583 if ( first ) TokenToLine((UBYTE *)
" ");
1585 if ( !first ) MultiplyToLine();
1587 Out = StrCopy(FindVector(*t),buffer);
1590 if ( AC.OutputMode == MATHEMATICAMODE ) *Out++ =
'[';
1592 if ( *t >= AM.OffsetIndex ) {
1594 if ( i >= AM.IndDum ) {
1597 Out = NumCopy(i,Out);
1603 Out = StrCopy(FindIndex(i),Out);
1606 else if ( *t == FUNNYVEC ) { *Out++ =
'?'; *Out = 0; }
1608 Out = NumCopy(*t++,Out);
1610 if ( AC.OutputMode == MATHEMATICAMODE ) *Out++ =
']';
1613 TokenToLine(buffer);
1618 while ( t < stopper ) {
1619 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1621 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1623 if ( first ) TokenToLine((UBYTE *)
" ");
1625 if ( !first ) MultiplyToLine();
1627 if ( *t < AM.OffsetIndex ) {
1628 TalToLine((UWORD)(*t++));
1632 if ( i >= AM.IndDum ) {
1636 Out = NumCopy(i,Out);
1642 i -= AM.OffsetIndex;
1643 Out = StrCopy(FindIndex(i%WILDOFFSET+AM.OffsetIndex),buffer);
1645 if ( i >= WILDOFFSET ) { *Out++ =
'?'; *Out = 0; }
1647 TokenToLine(buffer);
1651 TokenToLine(FindVector(*t)); t++;
1657 case DOLLAREXPRESSION:
1659 DOLLARS d = Dollars + sterm[2];
1660 Out = StrCopy((UBYTE *)
"$",buffer);
1661 Out = StrCopy(AC.dollarnames->namebuffer+d->name,Out);
1662 if ( sterm[3] != 1 ) WrtPower(Out,sterm[3]);
1663 TokenToLine(buffer);
1668 while ( t < stopper ) {
1669 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1671 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1673 if ( first ) TokenToLine((UBYTE *)
" ");
1675 if ( !first ) MultiplyToLine();
1676 Out = StrCopy((UBYTE *)
"d_(",buffer);
1677 if ( *t >= AM.OffsetIndex ) {
1678 if ( *t < AM.IndDum ) {
1679 Out = StrCopy(FindIndex(*t),Out);
1685 Out = NumCopy( *t++ - AM.IndDum, Out);
1691 else if ( *t == FUNNYVEC ) { *Out++ =
'?'; *Out = 0; }
1693 Out = NumCopy(*t++,Out);
1696 if ( *t >= AM.OffsetIndex ) {
1697 if ( *t < AM.IndDum ) {
1698 Out = StrCopy(FindIndex(*t),Out);
1704 Out = NumCopy(*t++ - AM.IndDum,Out);
1710 Out = NumCopy(*t++,Out);
1714 TokenToLine(buffer);
1719 while ( t < stopper ) {
1720 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1722 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1724 if ( first ) TokenToLine((UBYTE *)
" ");
1726 if ( !first ) MultiplyToLine();
1727 if ( AC.OutputMode == CMODE && t[2] != 1 )
1728 TokenToLine((UBYTE *)
"pow(");
1729 Out = StrCopy(FindVector(*t),buffer);
1732 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE
1733 || AC.OutputMode == CMODE )
1734 *Out++ = AO.FortDotChar;
1736 Out = StrCopy(FindVector(*t),Out);
1739 if ( *t != 1 ) WrtPower(Out,*t);
1741 TokenToLine(buffer);
1749 if ( !first ) MultiplyToLine();
1750 if ( AC.OutputMode == CMODE ) TokenToLine((UBYTE *)
"pow(");
1751 else TokenToLine((UBYTE *)
"(");
1753 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE
1754 || AC.OutputMode == REDUCEMODE )
1755 TokenToLine((UBYTE *)
")**(");
1756 else if ( AC.OutputMode == CMODE ) TokenToLine((UBYTE *)
",");
1757 else TokenToLine((UBYTE *)
")^(");
1760 TokenToLine((UBYTE *)
")");
1766 if ( first ) TokenToLine((UBYTE *)
"1/(");
1767 else TokenToLine((UBYTE *)
"/(");
1769 TokenToLine((UBYTE *)
")");
1772 if ( !first ) MultiplyToLine();
1773 TokenToLine((UBYTE *)
"(");
1774 t = cbuf[sterm[4]].rhs[sterm[2]];
1776 while ( *tt ) tt += *tt;
1777 oldoutsidefun = AC.outsidefun; AC.outsidefun = 0;
1779 WriteExpression(t,(LONG)(tt-t));
1782 TokenToLine((UBYTE *)
"0");
1784 AC.outsidefun = oldoutsidefun;
1785 TokenToLine((UBYTE *)
")");
1786 if ( sterm[3] != 1 ) {
1787 TokenToLine((UBYTE *)
"^");
1789 NumCopy(sterm[3],Out);
1790 TokenToLine(buffer);
1794 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1796 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1798 if ( first ) TokenToLine((UBYTE *)
" ");
1800 if ( *sterm < FUNCTION ) {
1801 return(MesPrint(
"Illegal subterm while writing"));
1803 if ( !first ) MultiplyToLine();
1806 if ( ( tmp = FindFunWithArgs(sterm) ) != 0 ) {
1813 if ( *sterm == GAMMA && t[-FUNHEAD+1] == FUNHEAD+1 ) {
1814 TokenToLine((UBYTE *)
"gi_(");
1817 if ( *sterm != DUMFUN ) {
1818 Out = StrCopy(FindFunction(*sterm),buffer);
1821 else { Out = buffer; *Out = 0; }
1822 if ( t >= stopper ) {
1823 TokenToLine(buffer);
1826 if ( AC.OutputMode == MATHEMATICAMODE ) { *Out++ =
'['; closepar[0] = (UBYTE)
']'; }
1827 else { *Out++ =
'('; }
1829 TokenToLine(buffer);
1831 i = functions[*sterm - FUNCTION].spec;
1832 if ( i >= TENSORFUNCTION ) {
1833 int curdict = AO.CurrentDictionary;
1834 if ( AO.CurrentDictionary && AO.CurDictNotInFunctions > 0 )
1835 AO.CurrentDictionary = 0;
1836 t = sterm + FUNHEAD;
1837 while ( t < stopper ) {
1838 if ( !first ) TokenToLine((UBYTE *)
",");
1842 if ( j < AM.OffsetIndex ) TalToLine((UWORD)(j));
1843 else if ( j < AM.IndDum ) {
1844 i = j - AM.OffsetIndex;
1845 Out = StrCopy(FindIndex(i%WILDOFFSET+AM.OffsetIndex),buffer);
1847 if ( i >= WILDOFFSET ) { *Out++ =
'?'; *Out = 0; }
1848 TokenToLine(buffer);
1853 Out = NumCopy(j - AM.IndDum,Out);
1857 TokenToLine(buffer);
1860 else if ( j == FUNNYVEC ) { TokenToLine((UBYTE *)
"?"); }
1861 else if ( j > -WILDOFFSET ) {
1863 Out = NumCopy((UWORD)(-j + 4),Out);
1866 TokenToLine(buffer);
1869 TokenToLine(FindVector(j));
1873 AO.CurrentDictionary = curdict;
1876 int curdict = AO.CurrentDictionary;
1877 if ( AO.CurrentDictionary && AO.CurDictNotInFunctions > 0 )
1878 AO.CurrentDictionary = 0;
1879 while ( t < stopper ) {
1880 if ( !first ) TokenToLine((UBYTE *)
",");
1885 AO.CurrentDictionary = curdict;
1887 TokenToLine(closepar);
1888 closepar[0] = (UBYTE)
')';
1903 WORD WriteInnerTerm(WORD *term, WORD first)
1905 WORD *t, *s, *s1, *s2, n, i, pow;
1910 if ( *s == HAAKJE )
break;
1913 if ( s < t ) { s += s[1]; }
1914 else { s = term+1; }
1916 if ( n < 0 || !first ) {
1917 if ( n > 0 ) { TOKENTOLINE(
" + ",
"+") }
1918 else if ( n < 0 ) { n = -n; TOKENTOLINE(
" - ",
"-") }
1920 if ( AC.modpowers ) {
1921 if ( n == 1 && *t == 1 && t > s ) first = 1;
1922 else if ( ABS(AC.ncmod) == 1 ) {
1923 LongToLine((UWORD *)AC.powmod,AC.npowmod);
1924 TokenToLine((UBYTE *)
"^");
1925 TalToLine(AC.modpowers[(LONG)((UWORD)*t)]);
1930 LongToLine((UWORD *)AC.powmod,AC.npowmod);
1931 TokenToLine((UBYTE *)
"^");
1933 if ( n == 2 ) jj += ((LONG)t[1])<<BITSINWORD;
1934 if ( AC.modpowers[jj+1] == 0 ) {
1935 TalToLine(AC.modpowers[jj]);
1938 LongToLine(AC.modpowers+jj,2);
1943 else if ( n != 1 || *t != 1 || t[1] != 1 || t <= s ) {
1944 if ( lowestlevel && ( ( AO.PrintType & PRINTONEFUNCTION ) != 0 ) ) {
1946 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1949 if ( AO.CurrentDictionary > 0 ) TransformRational((UWORD *)t,n);
1950 else RatToLine((UWORD *)t,n);
1955 if ( lowestlevel && ( (AO.PrintType & (PRINTONEFUNCTION | PRINTALL)) == PRINTONEFUNCTION ) ) {
1957 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1965 if ( *s == GAMMA ) {
1967 ss = AT.WorkPointer;
1972 tt = s + FUNHEAD + 1;
1973 n = s[1] - FUNHEAD-1;
1975 while ( --n >= 0 ) *ss++ = *tt++;
1977 while ( *tt == GAMMA && tt[FUNHEAD] == s[FUNHEAD] && tt < t ) {
1980 n = s[1] - FUNHEAD-1;
1984 tt = AT.WorkPointer;
1985 AT.WorkPointer = ss;
1986 tt[1] = WORDDIF(ss,tt);
1987 if ( WriteSubTerm(tt,first) ) {
1988 MesCall(
"WriteInnerTerm");
1991 AT.WorkPointer = tt;
1999 if ( *s >= FUNCTION && AC.funpowers > 0
2000 && functions[*s-FUNCTION].spec == 0 && ( AC.funpowers == ALLFUNPOWERS ||
2001 ( AC.funpowers == COMFUNPOWERS && functions[*s-FUNCTION].commute == 0 ) ) ) {
2004 s1 = s; s2 = s + s[1]; i = s[1];
2006 while ( --i >= 0 && *s1 == *s2 ) { s1++; s2++; }
2015 if ( AC.OutputMode == CMODE ) {
2016 if ( !first ) MultiplyToLine();
2017 TokenToLine((UBYTE *)
"pow(");
2020 if ( WriteSubTerm(s,first) ) {
2021 MesCall(
"WriteInnerTerm");
2024 if ( AC.OutputMode == FORTRANMODE
2025 || AC.OutputMode == PFORTRANMODE ) { TokenToLine((UBYTE *)
"**"); }
2026 else if ( AC.OutputMode == CMODE ) { TokenToLine((UBYTE *)
","); }
2027 else { TokenToLine((UBYTE *)
"^"); }
2029 if ( AC.OutputMode == CMODE ) TokenToLine((UBYTE *)
")");
2031 else if ( WriteSubTerm(s,first) ) {
2032 MesCall(
"WriteInnerTerm");
2036 else if ( WriteSubTerm(s,first) ) {
2037 MesCall(
"WriteInnerTerm");
2061 WORD WriteTerm(WORD *term, WORD *lbrac, WORD first, WORD prtf, WORD br)
2063 WORD *t, *stopper, *b, n;
2064 int oldIsFortran90 = AC.IsFortran90, i;
2065 if ( *lbrac >= 0 ) {
2067 stopper = (term + *term - 1);
2068 stopper -= ABS(*stopper) - 1;
2069 while ( t < stopper ) {
2070 if ( *t == HAAKJE ) {
2073 if ( *lbrac == ( n = WORDDIF(stopper,t) ) ) {
2076 while ( n > 0 && ( *b++ == *t++ ) ) { n--; }
2077 if ( n <= 0 && ( ( AO.InFbrack < AM.FortranCont )
2078 || ( lowestlevel == 0 ) ) ) {
2083 if ( ( prtf & PRINTCONTENTS ) != 0 ) {
2087 if ( WriteInnerTerm(term,0) )
goto WrtTmes;
2088 if ( ( AO.PrintType & PRINTONETERM ) != 0 ) {
2090 TokenToLine((UBYTE *)
" ");
2096 n = WORDDIF(stopper,t);
2102 if ( ( prtf & PRINTCONTENTS ) ) PrtTerms();
2103 TOKENTOLINE(
" )",
")")
2104 if ( AC.OutputMode == CMODE && AO.FactorMode == 0 )
2105 TokenToLine((UBYTE *)";");
2106 else if ( AO.FactorMode && ( n == 0 ) ) {
2112 AC.IsFortran90 = ISNOTFORTRAN90;
2114 AC.IsFortran90 = oldIsFortran90;
2115 if ( AC.OutputMode != FORTRANMODE && AC.OutputMode != PFORTRANMODE
2116 && AC.OutputSpaces == NORMALFORMAT
2117 && AO.FactorMode == 0 ) FiniLine();
2120 if ( AC.OutputMode == CMODE && AO.FactorMode == 0 )
2121 TokenToLine((UBYTE *)
";");
2122 if ( AO.FortFirst == 0 ) {
2124 AC.IsFortran90 = ISNOTFORTRAN90;
2126 AC.IsFortran90 = oldIsFortran90;
2130 if ( AO.FactorMode == 0 ) {
2131 if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2133 WORD oldmode = AC.OutputMode;
2136 AC.OutputMode = oldmode;
2139 if ( AO.FortFirst == 0 ) {
2140 TokenToLine(AO.CurBufWrt);
2141 TOKENTOLINE(
" = ",
"=")
2142 TokenToLine(AO.CurBufWrt);
2146 TokenToLine(AO.CurBufWrt);
2147 TOKENTOLINE(
" = ",
"=")
2150 else if ( AC.OutputMode == CMODE && !first ) {
2152 if ( AO.FortFirst == 0 ) {
2153 TokenToLine(AO.CurBufWrt);
2154 TOKENTOLINE(
" += ",
"+=")
2158 TokenToLine(AO.CurBufWrt);
2159 TOKENTOLINE(
" = ",
"=")
2162 else if ( startinline == 0 ) {
2166 if ( ( *lbrac = n ) > 0 ) {
2169 while ( --n >= 0 ) *b++ = *t++;
2170 *b++ = 1; *b++ = 1; *b = 3;
2172 if ( WriteInnerTerm(AO.bracket,0) ) {
2179 while ( --i >= 0 ) { TalToLine((UWORD)(*t++));
2180 if ( AC.OutputSpaces == NORMALFORMAT )
2181 TokenToLine((UBYTE *)
" "); }
2184 MesCall(
"WriteTerm");
2187 TOKENTOLINE(
" * ( ",
"*(")
2190 if ( ( prtf & PRINTONETERM ) != 0 ) {
2193 TokenToLine((UBYTE *)
" ");
2207 if ( ( *lbrac = n ) > 0 ) {
2210 while ( --n >= 0 ) *b++ = *t++;
2211 *b++ = 1; *b++ = 1; *b = 3;
2212 for ( i = AO.FactorNum+1; i < AO.bracket[4]; i++ ) {
2214 TOKENTOLINE(
" ( 0 )",
" (0)")
2218 TOKENTOLINE(
" * ( 0 )",
"*(0)")
2223 AO.FactorNum = AO.bracket[4];
2229 if ( first == 0 ) { TOKENTOLINE(
" * ( ",
"*(") }
2230 else { TOKENTOLINE(
" ( ",
" (") }
2234 if ( ( prtf & PRINTCONTENTS ) != 0 ) AO.NumInBrack++;
2235 else if ( WriteInnerTerm(term,first) )
goto WrtTmes;
2236 if ( ( AO.PrintType & PRINTONETERM ) != 0 ) {
2238 TokenToLine((UBYTE *)
" ");
2245 if ( ( prtf & PRINTCONTENTS ) != 0 ) PrtTerms();
2246 TokenToLine((UBYTE *)
" )");
2247 if ( AC.OutputMode == CMODE ) TokenToLine((UBYTE *)
";");
2248 if ( AO.FortFirst == 0 ) {
2249 AC.IsFortran90 = ISNOTFORTRAN90;
2251 AC.IsFortran90 = oldIsFortran90;
2253 if ( AC.OutputMode != FORTRANMODE && AC.OutputMode != PFORTRANMODE
2254 && AC.OutputSpaces == NORMALFORMAT ) FiniLine();
2255 if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2257 WORD oldmode = AC.OutputMode;
2260 AC.OutputMode = oldmode;
2262 if ( AO.FortFirst == 0 ) {
2263 TokenToLine(AO.CurBufWrt);
2264 TOKENTOLINE(
" = ",
"=")
2265 TokenToLine(AO.CurBufWrt);
2269 TokenToLine(AO.CurBufWrt);
2270 TOKENTOLINE(
" = ",
"=")
2280 else if ( AC.OutputMode == CMODE && !first ) {
2282 if ( AO.FortFirst == 0 ) {
2283 TokenToLine(AO.CurBufWrt);
2284 TOKENTOLINE(
" += ",
"+=")
2288 TokenToLine(AO.CurBufWrt);
2289 TOKENTOLINE(
" = ",
"=")
2305 if ( !br ) AO.IsBracket = 0;
2306 if ( ( AO.InFbrack >= AM.FortranCont ) && lowestlevel ) {
2307 if ( AC.OutputMode == CMODE ) TokenToLine((UBYTE *)
";");
2308 if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2310 WORD oldmode = AC.OutputMode;
2311 if ( AO.FortFirst == 0 ) {
2312 AC.IsFortran90 = ISNOTFORTRAN90;
2314 AC.IsFortran90 = oldIsFortran90;
2317 AC.OutputMode = oldmode;
2319 TokenToLine(AO.CurBufWrt);
2320 TOKENTOLINE(
" = ",
"=")
2321 TokenToLine(AO.CurBufWrt);
2338 else if ( AC.OutputMode == CMODE && !first ) {
2341 if ( AO.FortFirst == 0 ) {
2342 TokenToLine(AO.CurBufWrt);
2343 TOKENTOLINE(
" += ",
"+=")
2347 TokenToLine(AO.CurBufWrt);
2348 TOKENTOLINE(
" = ",
"=")
2365 if ( WriteInnerTerm(term,first) )
goto WrtTmes;
2366 if ( ( AO.PrintType & PRINTONETERM ) != 0 ) {
2383 WORD WriteExpression(WORD *terms, LONG ltot)
2387 WORD OldIsBracket = AO.IsBracket, OldPrintType = AO.PrintType;
2388 if ( !AC.outsidefun ) { AO.PrintType &= ~PRINTONETERM; first = 1; }
2390 stopper = terms + ltot;
2392 while ( terms < stopper ) {
2393 AO.IsBracket = OldIsBracket;
2394 if ( WriteTerm(terms,&btot,first,0,1) ) {
2395 MesCall(
"WriteExpression");
2402 AO.IsBracket = OldIsBracket;
2403 AO.PrintType = OldPrintType;
2418 WORD *t, *stopper, n, prtf;
2419 int oldIsFortran90 = AC.IsFortran90, i;
2423 if ( AM.exitflag )
return(0);
2425 if ( PF.me != MASTER ) {
2430 for ( n = 0; n < NumExpressions; n++ ) {
2431 e = &Expressions[n];
2432 if ( !e->printflag & PRINTON )
continue;
2433 switch ( e->status ) {
2434 case LOCALEXPRESSION:
2435 case GLOBALEXPRESSION:
2436 case UNHIDELEXPRESSION:
2437 case UNHIDEGEXPRESSION:
2443 PutPreVar(AM.oldnumextrasymbols, GetPreVar((UBYTE *)
"EXTRASYMBOLS_", 0), 0, 1);
2444 if ( AO.OptimizationLevel > 0 ) {
2445 if ( Optimize(0, 1) )
return(-1);
2451 SeekScratch(AR.outfile,&pos);
2452 if ( ResetScratch() ) {
2453 MesCall(
"WriteAll");
2456 AO.termbuf = AT.WorkPointer;
2457 AO.bracket = (WORD *)(((UBYTE *)(AT.WorkPointer)) + AM.MaxTer);
2458 AT.WorkPointer = (WORD *)(((UBYTE *)(AT.WorkPointer)) + AM.MaxTer*2);
2459 AO.OutFill = AO.OutputLine = (UBYTE *)AT.WorkPointer;
2460 AT.WorkPointer += 2*AC.LineLength;
2461 *(AR.CompressBuffer) = 0;
2463 for ( n = 0; n < NumExpressions; n++ ) {
2464 if ( ( Expressions[n].printflag & PRINTON ) != 0 ) { first = 1;
break; }
2466 if ( !first )
goto EndWrite;
2470 while ( GetTerm(BHEAD AO.termbuf) ) {
2472 e = Expressions + AO.termbuf[3];
2474 if ( ( n == LOCALEXPRESSION || n == GLOBALEXPRESSION
2475 || n == UNHIDELEXPRESSION || n == UNHIDEGEXPRESSION ) &&
2476 ( ( prtf = e->printflag ) & PRINTON ) != 0 ) {
2480 GetPreVar((UBYTE *)
"EXTRASYMBOLS_",0),0,1);
2481 if ( ( prtf & PRINTLFILE ) != 0 ) {
2482 if ( AC.LogHandle < 0 ) prtf &= ~PRINTLFILE;
2484 AO.PrintType = prtf;
2497 if ( AO.OptimizationLevel > 0 ) {
2498 UBYTE *oldOutFill = AO.OutFill, *oldOutputLine = AO.OutputLine;
2500 if ( Optimize(AO.termbuf[3], 1) )
goto AboWrite;
2502 AO.OutFill = oldOutFill; AO.OutputLine = oldOutputLine;
2506 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2509 AO.CurBufWrt = EXPRNAME(AO.termbuf[3]);
2510 TokenToLine(AO.CurBufWrt);
2513 if ( t < stopper ) {
2514 TokenToLine((UBYTE *)
"(");
2516 while ( t < stopper ) {
2518 if ( !first ) TokenToLine((UBYTE *)
",");
2521 TokenToLine(FindSymbol(t[2]));
2525 TokenToLine(FindVector(t[2]));
2529 TokenToLine(FindIndex(t[2]));
2533 TokenToLine(FindFunction(t[2]));
2540 TokenToLine((UBYTE *)
")");
2542 TOKENTOLINE(
" =",
"=");
2545 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2550 if ( ( e->vflags & ISFACTORIZED ) != 0 ) {
2551 AO.FactorMode = 1+e->numfactors;
2557 while ( GetTerm(BHEAD AO.termbuf) ) {
2559 GETSTOP(AO.termbuf,m);
2560 if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2561 && ( ( prtf & PRINTONETERM ) != 0 ) ) {}
2568 if ( ( prtf & PRINTONETERM ) != 0 ) first = 0;
2569 if ( WriteTerm(AO.termbuf,&lbrac,first,prtf,0) )
2573 if ( AO.FactorMode ) {
2574 if ( first ) { AO.FactorNum = 1; TOKENTOLINE(
" ( 0 )",
" (0)") }
2575 else TOKENTOLINE(
" )",
")");
2576 for ( i = AO.FactorNum+1; i <= e->numfactors; i++ ) {
2579 TOKENTOLINE(
" * ( 0 )",
"*(0)");
2581 AO.FactorNum = e->numfactors;
2582 if ( AC.OutputMode != FORTRANMODE && AC.OutputMode != PFORTRANMODE )
2583 TokenToLine((UBYTE *)
";");
2585 else if ( AO.FactorMode == 0 || first ) {
2586 if ( first ) { TOKENTOLINE(
" 0",
"0") }
2588 if ( ( prtf & PRINTCONTENTS ) != 0 ) PrtTerms();
2589 TOKENTOLINE(
" )",
")")
2591 else if ( ( prtf & PRINTCONTENTS ) != 0 ) {
2592 TOKENTOLINE(
" + 1 * ( ",
"+1*(")
2594 TOKENTOLINE(" )",")")
2596 if ( AC.OutputMode != FORTRANMODE && AC.OutputMode != PFORTRANMODE )
2597 TokenToLine((UBYTE *)";");
2600 AC.IsFortran90 = ISNOTFORTRAN90;
2602 AC.IsFortran90 = oldIsFortran90;
2606 do { }
while ( GetTerm(BHEAD AO.termbuf) );
2609 if ( AC.OutputSpaces == NORMALFORMAT ) FiniLine();
2611 if ( AR.infile->handle >= 0 ) {
2612 SeekFile(AR.infile->handle,&(AR.infile->filesize),SEEK_SET);
2615 AT.WorkPointer = AO.termbuf;
2616 SetScratch(AR.infile,&pos);
2617 f = AR.outfile; AR.outfile = AR.infile; AR.infile = f;
2620 SetScratch(AR.infile,&pos);
2621 f = AR.outfile; AR.outfile = AR.infile; AR.infile = f;
2622 MesCall(
"WriteAll");
2634 WORD WriteOne(UBYTE *name,
int alreadyinline,
int nosemi)
2642 if ( GetName(AC.exprnames,name,&number,NOAUTO) != CEXPRESSION ) {
2643 MesPrint(
"@%s is not an expression",name);
2646 switch ( Expressions[number].status ) {
2647 case HIDDENLEXPRESSION:
2648 case HIDDENGEXPRESSION:
2649 case HIDELEXPRESSION:
2650 case HIDEGEXPRESSION:
2651 case UNHIDELEXPRESSION:
2652 case UNHIDEGEXPRESSION:
2659 case LOCALEXPRESSION:
2660 case GLOBALEXPRESSION:
2661 case SKIPLEXPRESSION:
2662 case SKIPGEXPRESSION:
2670 MesPrint(
"@expressions %s is not active. It cannot be written",name);
2673 SeekScratch(AR.outfile,&pos);
2675 f = AR.outfile; AR.outfile = AR.infile; AR.infile = f;
2682 if ( AR.GetFile == 2 ) f = AR.hidefile;
2688 SetScratch(f,&(Expressions[number].onfile));
2691 f->POfill = (WORD *)((UBYTE *)(f->PObuffer)
2692 + BASEPOSITION(Expressions[number].onfile));
2694 AO.termbuf = AT.WorkPointer;
2695 AO.bracket = (WORD *)(((UBYTE *)(AT.WorkPointer)) + AM.MaxTer);
2696 AT.WorkPointer = (WORD *)(((UBYTE *)(AT.WorkPointer)) + AM.MaxTer*2);
2698 AO.OutFill = AO.OutputLine = (UBYTE *)AT.WorkPointer;
2699 AT.WorkPointer += 2*AC.LineLength;
2700 *(AR.CompressBuffer) = 0;
2706 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2708 if ( GetTerm(BHEAD AO.termbuf) <= 0 ) {
2709 MesPrint(
"@ReadError in expression %s",name);
2722 if ( AO.OptimizationLevel > 0 ) {
2724 if ( Optimize(AO.termbuf[3], 1) )
goto AboWrite;
2733 while ( GetTerm(BHEAD AO.termbuf) ) {
2735 GETSTOP(AO.termbuf,m);
2738 startinline = alreadyinline;
2739 AO.OutFill = AO.OutputLine + startinline;
2741 if ( WriteTerm(AO.termbuf,&lbrac,first,0,0) )
2747 startinline = alreadyinline;
2748 AO.OutFill = AO.OutputLine + startinline;
2749 TOKENTOLINE(
" 0",
"0");
2752 TOKENTOLINE(
" )",
")");
2754 if ( AC.OutputMode != FORTRANMODE && AC.OutputMode != PFORTRANMODE
2755 && nosemi == 0 ) TokenToLine((UBYTE *)
";");
2757 if ( AC.OutputSpaces == NORMALFORMAT && nosemi == 0 ) {
2761 noextralinefeed = 1;
2763 noextralinefeed = 0;
2767 AT.WorkPointer = AO.termbuf;
2769 f = AR.outfile; AR.outfile = AR.infile; AR.infile = f;
2773 SetScratch(AR.infile,&pos);
2774 f->POposition = pos;
2775 f = AR.outfile; AR.outfile = AR.infile; AR.infile = f;
2776 MesCall(
"WriteOne");
int PutPreVar(UBYTE *, UBYTE *, UBYTE *, int)