47typedef 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])
56static int startinline = 0;
57static char fcontchar =
'&';
58static int noextralinefeed = 0;
59static int lowestlevel = 1;
67UBYTE *StrCopy(UBYTE *from, UBYTE *to)
69 while( ( *to++ = *from++ ) != 0 );
82VOID 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 ) {
267VOID IniLine(WORD extrablank)
271 AO.OutStop = Out + AC.LineLength;
277 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE ) {
284 while ( extrablank > 0 ) {
301static UBYTE *LLscratch = 0;
303VOID 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");
334static UBYTE *RLscratch = 0;
335static UWORD *RLscratE = 0;
337VOID 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 ) == 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 ) == 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 ) == 2 ) { AddToLine((UBYTE *)
".Q0"); }
379 else { AddToLine((UBYTE *)
".D0"); }
382 AddToLine((UBYTE *)
"/");
383 LongToLine(a,adenom);
385 if ( ( AO.DoubleFlag & 2 ) == 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 ) == 2 ) { AddToLine((UBYTE *)
".Q0/"); }
415 else if ( ( AO.DoubleFlag & 1 ) == 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 ) == 2 ) { AddToLine((UBYTE *)
".Q0"); }
430 else if ( ( AO.DoubleFlag & 1 ) == 1 ) { AddToLine((UBYTE *)
".D0"); }
431 else { AddToLine((UBYTE *)
"."); }
434 else if ( ( anumer > 1 || ( AO.DoubleFlag & 4 ) == 4 ) && ( 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 ) == 2 ) { AddToLine((UBYTE *)
".Q0"); }
445 else if ( ( AO.DoubleFlag & 1 ) == 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 ( AO.DoubleFlag & 4 ) == 0 ) {}
460 else if ( ( AO.DoubleFlag & 2 ) == 2 ) { AddToLine((UBYTE *)
".Q0"); }
461 else if ( ( AO.DoubleFlag & 1 ) == 1 ) { AddToLine((UBYTE *)
".D0"); }
470 WORD exponent = 0, i, ndig, newl;
471 UWORD *c, *den, b = 10, dig[10];
476 if ( RLscratch == 0 ) {
477 RLscratch = (UBYTE *)Malloc1(4*(AM.MaxTal+2)*
sizeof(UBYTE),
"RatToLine");
478 RLscratE = (UWORD *)Malloc1(2*(AM.MaxTal+2)*
sizeof(UWORD),
"RatToLine");
480 out = OutScratch = RLscratch;
481 c = RLscratE;
for ( i = 0; i < 2*na; i++ ) c[i] = a[i];
482 UnPack(c,na,&adenom,&anumer);
483 while ( BigLong(c,anumer,c+na,adenom) >= 0 ) {
484 Divvy(BHEAD c,&na,&b,1);
485 UnPack(c,na,&adenom,&anumer);
488 while ( BigLong(c,anumer,c+na,adenom) < 0 ) {
489 Mully(BHEAD c,&na,&b,1);
490 UnPack(c,na,&adenom,&anumer);
497 DivLong(c,anumer,den,adenom,dig,&ndig,c,&newl);
498 *out++ = (UBYTE)(dig[0]+
'0'); *out++ =
'.';
499 while ( newl && i < AC.OutNumberType ) {
500 Pack(c,&newl,den,adenom);
501 Mully(BHEAD c,&newl,&b,1);
503 UnPack(c,na,&adenom,&anumer);
505 DivLong(c,anumer,den,adenom,dig,&ndig,c,&newl);
506 if ( ndig == 0 ) *out++ =
'0';
507 else *out++ = (UBYTE)(dig[0]+
'0');
511 if ( exponent < 0 ) { exponent = -exponent; *out++ =
'-'; }
512 else { *out++ =
'+'; }
515 *out++ = (UBYTE)((exponent % 10)+
'0');
517 }
while ( exponent );
519 while ( o < out ) { cc = *o; *o = *out; *out = cc; o++; out--; }
520 TokenToLine(OutScratch);
534VOID TalToLine(UWORD x)
536 UBYTE t[BITSINWORD/3+1];
540 do { *s++ = (UBYTE)((x % 10)+
'0'); i++; }
while ( ( x /= 10 ) != 0 );
544 i = t[j]; t[j] = s[-j]; s[-j] = (UBYTE)i; j--;
563VOID TokenToLine(UBYTE *s)
567 if ( AO.OutInBuffer ) { AddToDollarBuffer(s);
return; }
568 t = s; Out = AO.OutFill;
571 if ( ( Out + i ) >= AO.OutStop && ( ( i < ((AC.LineLength-AO.OutSkip)>>1) )
572 || ( (AO.OutStop-Out) < (i>>2) ) ) ) {
573 if ( AC.OutputMode == FORTRANMODE && AC.IsFortran90 == ISFORTRAN90 ) {
577 *Out++ = CARRIAGERETURN;
581 num = Out - AO.OutputLine;
582 if ( AC.LogHandle >= 0 ) {
583 if ( WriteFile(AC.LogHandle,AO.OutputLine+startinline,
584 num-startinline) != (num-startinline) ) {
586 if ( BUG.logfileflag == 0 ) {
587 fprintf(stderr,
"Panic: Cannot write to log file! Disk full?\n");
590 BUG.eflag = 1; BUG.printflag = 1;
596 if ( ( AO.PrintType & PRINTLFILE ) == 0 ) {
598 if ( num > 1 && AO.OutputLine[num-2] == CARRIAGERETURN ) {
599 AO.OutputLine[num-2] = LINEFEED;
603 if ( WriteFile(AM.StdOut,AO.OutputLine+startinline,
604 num-startinline) != (num-startinline) ) {
606 if ( BUG.stdoutflag == 0 ) {
607 fprintf(stderr,
"Panic: Cannot write to standard output!\n");
610 BUG.eflag = 1; BUG.printflag = 1;
618 if ( AO.BlockSpaces == 0 ) {
619 for ( j = 0; j < AO.OutSkip; j++ ) { *Out++ =
' '; }
620 if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE ) ) {
621 if ( AO.OutSkip == 7 ) {
638 if ( AO.IsBracket ) { *Out++ =
' '; *Out++ =
' '; *Out++ =
' '; }
640 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE
641 || ( AC.OutputMode == CMODE && AO.FactorMode == 0 ) ) AO.InFbrack++;
643 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE ) {
645 if ( i > (WORD)(AO.OutStop-Out) ) j = (WORD)(AO.OutStop - Out);
651 if ( i > (WORD)(AO.OutStop-Out) ) j = (WORD)(AO.OutStop - Out - 1);
655 if ( i > 0 ) *Out++ =
'\\';
670UBYTE *CodeToLine(WORD number, UBYTE *Out)
672 Out = StrCopy((UBYTE *)
"(",Out);
673 Out = NumCopy(number,Out);
674 Out = StrCopy((UBYTE *)
")",Out);
686 if ( AO.CurrentDictionary > 0 && AO.CurDictSpecials > 0
687 && AO.CurDictSpecials == DICT_DOSPECIALS ) {
688 DICTIONARY *dict = AO.Dictionaries[AO.CurrentDictionary-1];
692 for ( i = 0; i < dict->numelements; i++ ) {
693 if ( dict->elements[i]->type != DICT_SPECIALCHARACTER )
continue;
694 if ( (UBYTE)dict->elements[i]->lhs[0] == (UBYTE)(
'*') ) {
695 TokenToLine((UBYTE *)(dict->elements[i]->rhs));
700 TokenToLine((UBYTE *)
"*");
708UBYTE *AddArrayIndex(WORD num,UBYTE *out)
710 if ( AC.OutputMode == CMODE ) {
711 out = StrCopy((UBYTE *)
"[",out);
712 out = NumCopy(num,out);
713 out = StrCopy((UBYTE *)
"]",out);
716 out = StrCopy((UBYTE *)
"(",out);
717 out = NumCopy(num,out);
718 out = StrCopy((UBYTE *)
")",out);
732 a[0] = (UWORD)AO.NumInBrack;
733 a[1] = (UWORD)(AO.NumInBrack >> BITSINWORD);
736 TokenToLine((UBYTE *)
" ");
738 if ( a[0] == 1 && na == 1 ) {
739 TokenToLine((UBYTE *)
" term");
741 else TokenToLine((UBYTE *)
" terms");
750UBYTE *WrtPower(UBYTE *Out, WORD Power)
752 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE
753 || AC.OutputMode == REDUCEMODE ) {
754 *Out++ =
'*'; *Out++ =
'*';
756 else if ( AC.OutputMode == CMODE ) *Out++ =
',';
758 UBYTE *Out1 = IsExponentSign();
759 if ( Out1 == 0 ) *Out++ =
'^';
761 while ( *Out1 ) *Out++ = *Out1++;
766 if ( Power < 2*MAXPOWER )
767 Out = NumCopy(Power,Out);
769 Out = StrCopy(FindSymbol((WORD)((LONG)Power-2*MAXPOWER)),Out);
771 if ( AC.OutputMode == CMODE ) *Out++ =
')';
775 if ( ( AC.OutputMode >= FORTRANMODE || AC.OutputMode >= PFORTRANMODE
776 || AC.OutputMode >= REDUCEMODE ) && AC.OutputMode != CMODE )
779 if ( Power > -2*MAXPOWER )
780 Out = NumCopy(-Power,Out);
782 Out = StrCopy(FindSymbol((WORD)((LONG)Power-2*MAXPOWER)),Out);
784 if ( AC.OutputMode >= FORTRANMODE || AC.OutputMode >= PFORTRANMODE
785 || AC.OutputMode >= REDUCEMODE) *Out++ =
')';
796void PrintTime(UBYTE *mess)
799 WORD timepart = (WORD)(millitime%1000);
802 MesPrint(
"At %s: Time = %7l.%2i sec",mess,millitime,timepart);
815static UBYTE *symname[] = {
816 (UBYTE *)
"(cyclic)",(UBYTE *)
"(reversecyclic)"
817 ,(UBYTE *)
"(symmetric)",(UBYTE *)
"(antisymmetric)" };
818static UBYTE *rsymname[] = {
819 (UBYTE *)
"(-cyclic)",(UBYTE *)
"(-reversecyclic)"
820 ,(UBYTE *)
"(-symmetric)",(UBYTE *)
"(-antisymmetric)" };
826 int first, startvalue;
829 CBUF *C = cbuf+AC.cbufnum;
830 int olddict = AO.CurrentDictionary;
833 AO.OutputLine = AO.OutFill = (UBYTE *)AT.WorkPointer;
834 AO.CurrentDictionary = 0;
836 OutScr = (UBYTE *)AT.WorkPointer + ( TOLONG(AT.WorkTop) - TOLONG(AT.WorkPointer) ) /2;
837 if ( AC.CodesFlag || AC.NamesFlag > 1 ) startvalue = 0;
838 else startvalue = FIRSTUSERSYMBOL;
842 if ( ( j = NumSymbols ) > startvalue ) {
843 TokenToLine((UBYTE *)
" Symbols");
846 for ( i = startvalue; i < j; i++ ) {
847 if ( i >= BUILTINSYMBOLS && i < FIRSTUSERSYMBOL )
continue;
848 Out = StrCopy(VARNAME(symbols,i),OutScr);
849 if ( symbols[i].minpower > -MAXPOWER || symbols[i].maxpower < MAXPOWER ) {
850 Out = StrCopy((UBYTE *)
"(",Out);
851 if ( symbols[i].minpower > -MAXPOWER )
852 Out = NumCopy(symbols[i].minpower,Out);
853 Out = StrCopy((UBYTE *)
":",Out);
854 if ( symbols[i].maxpower < MAXPOWER )
855 Out = NumCopy(symbols[i].maxpower,Out);
856 Out = StrCopy((UBYTE *)
")",Out);
858 if ( ( symbols[i].complex & VARTYPEIMAGINARY ) == VARTYPEIMAGINARY ) {
859 Out = StrCopy((UBYTE *)
"#i",Out);
861 else if ( ( symbols[i].complex & VARTYPECOMPLEX ) == VARTYPECOMPLEX ) {
862 Out = StrCopy((UBYTE *)
"#c",Out);
864 else if ( ( symbols[i].complex & VARTYPEROOTOFUNITY ) == VARTYPEROOTOFUNITY ) {
865 Out = StrCopy((UBYTE *)
"#",Out);
866 if ( ( symbols[i].complex & VARTYPEMINUS ) == VARTYPEMINUS ) {
867 Out = StrCopy((UBYTE *)
"-",Out);
870 Out = StrCopy((UBYTE *)
"+",Out);
872 Out = NumCopy(symbols[i].maxpower,Out);
874 if ( AC.CodesFlag ) Out = CodeToLine(i,Out);
875 if ( ( symbols[i].complex & VARTYPECOMPLEX ) == VARTYPECOMPLEX ) i++;
876 StrCopy((UBYTE *)
" ",Out);
886 if ( AC.CodesFlag || AC.NamesFlag > 1 ) startvalue = 0;
887 else startvalue = BUILTININDICES;
888 if ( ( j = NumIndices ) > startvalue ) {
889 TokenToLine((UBYTE *)
" Indices");
892 for ( i = startvalue; i < j; i++ ) {
893 Out = StrCopy(FindIndex(i+AM.OffsetIndex),OutScr);
894 Out = StrCopy(VARNAME(indices,i),OutScr);
895 if ( indices[i].dimension >= 0 ) {
896 if ( indices[i].dimension != AC.lDefDim ) {
897 Out = StrCopy((UBYTE *)
"=",Out);
898 Out = NumCopy(indices[i].dimension,Out);
901 else if ( indices[i].dimension < 0 ) {
902 Out = StrCopy((UBYTE *)
"=",Out);
903 Out = StrCopy(VARNAME(symbols,-indices[i].dimension),Out);
904 if ( indices[i].nmin4 < -NMIN4SHIFT ) {
905 Out = StrCopy((UBYTE *)
":",Out);
906 Out = StrCopy(VARNAME(symbols,-indices[i].nmin4-NMIN4SHIFT),Out);
909 if ( AC.CodesFlag ) Out = CodeToLine(i+AM.OffsetIndex,Out);
910 StrCopy((UBYTE *)
" ",Out);
920 if ( AC.CodesFlag || AC.NamesFlag > 1 ) startvalue = 0;
921 else startvalue = BUILTINVECTORS;
922 if ( ( j = NumVectors ) > startvalue ) {
923 TokenToLine((UBYTE *)
" Vectors");
926 for ( i = startvalue; i < j; i++ ) {
927 Out = StrCopy(VARNAME(vectors,i),OutScr);
928 if ( AC.CodesFlag ) Out = CodeToLine(i+AM.OffsetVector,Out);
929 StrCopy((UBYTE *)
" ",Out);
939 if ( AC.CodesFlag || AC.NamesFlag > 1 ) startvalue = 0;
940 else startvalue = AM.NumFixedFunctions;
941 for ( k = 0; k < 2; k++ ) {
944 for ( i = startvalue; i < j; i++ ) {
945 if ( i > MAXBUILTINFUNCTION-FUNCTION
946 && i < FIRSTUSERFUNCTION-FUNCTION )
continue;
947 if ( ( k == 0 && functions[i].commute )
948 || ( k != 0 && !functions[i].commute ) ) {
950 TokenToLine((UBYTE *)(FG.FunNam[k]));
955 Out = StrCopy(VARNAME(functions,i),OutScr);
956 if ( ( functions[i].complex & VARTYPEIMAGINARY ) == VARTYPEIMAGINARY ) {
957 Out = StrCopy((UBYTE *)
"#i",Out);
959 else if ( ( functions[i].complex & VARTYPECOMPLEX ) == VARTYPECOMPLEX ) {
960 Out = StrCopy((UBYTE *)
"#c",Out);
962 if ( functions[i].spec >= TENSORFUNCTION ) {
963 Out = StrCopy((UBYTE *)
"(Tensor)",Out);
965 if ( functions[i].symmetric > 0 ) {
966 if ( ( functions[i].symmetric & REVERSEORDER ) != 0 ) {
967 Out = StrCopy((UBYTE *)(rsymname[(functions[i].symmetric & ~REVERSEORDER)-1]),Out);
970 Out = StrCopy((UBYTE *)(symname[functions[i].symmetric-1]),Out);
973 if ( AC.CodesFlag ) Out = CodeToLine(i+FUNCTION,Out);
974 if ( ( functions[i].complex & VARTYPECOMPLEX ) == VARTYPECOMPLEX ) i++;
975 StrCopy((UBYTE *)
" ",Out);
980 if ( first == 0 ) FiniLine();
986 if ( AC.CodesFlag || AC.NamesFlag > 1 ) startvalue = 0;
987 else startvalue = AM.NumFixedSets;
988 if ( ( j = AC.SetList.num ) > startvalue ) {
989 WORD element, LastElement, type, number;
990 TokenToLine((UBYTE *)
" Sets");
991 for ( i = startvalue; i < j; i++ ) {
994 if ( Sets[i].name < 0 ) {
995 Out = StrCopy((UBYTE *)
"{}",OutScr);
998 Out = StrCopy(VARNAME(Sets,i),OutScr);
1000 if ( AC.CodesFlag ) Out = CodeToLine(i,Out);
1001 StrCopy((UBYTE *)
":",Out);
1002 TokenToLine(OutScr);
1003 if ( i < AM.NumFixedSets ) {
1004 TokenToLine((UBYTE *)
" ");
1005 TokenToLine((UBYTE *)fixedsets[i].description);
1007 else if ( Sets[i].type == CRANGE ) {
1009 if ( Sets[i].first == 3*MAXPOWER ) {
1011 else if ( Sets[i].first >= MAXPOWER ) {
1012 TokenToLine((UBYTE *)
"<=");
1013 NumCopy(Sets[i].first-2*MAXPOWER,OutScr);
1014 TokenToLine(OutScr);
1018 TokenToLine((UBYTE *)
"<");
1019 NumCopy(Sets[i].first,OutScr);
1020 TokenToLine(OutScr);
1023 if ( Sets[i].last == -3*MAXPOWER ) {
1025 else if ( Sets[i].last <= -MAXPOWER ) {
1026 if ( iflag ) TokenToLine((UBYTE *)
",");
1027 TokenToLine((UBYTE *)
">=");
1028 NumCopy(Sets[i].last+2*MAXPOWER,OutScr);
1029 TokenToLine(OutScr);
1032 if ( iflag ) TokenToLine((UBYTE *)
",");
1033 TokenToLine((UBYTE *)
">");
1034 NumCopy(Sets[i].last,OutScr);
1035 TokenToLine(OutScr);
1039 element = Sets[i].first;
1040 LastElement = Sets[i].last;
1041 type = Sets[i].type;
1043 TokenToLine((UBYTE *)
" ");
1044 number = SetElements[element++];
1048 StrCopy(VARNAME(symbols,-number),OutScr);
1049 StrCopy((UBYTE *)
"?",Out);
1050 TokenToLine(OutScr);
1052 else if ( number < MAXPOWER )
1053 TokenToLine(VARNAME(symbols,number));
1055 NumCopy(number-2*MAXPOWER,OutScr);
1056 TokenToLine(OutScr);
1060 if ( number >= AM.IndDum ) {
1061 Out = StrCopy((UBYTE *)
"N",OutScr);
1062 Out = NumCopy(number-(AM.IndDum),Out);
1063 StrCopy((UBYTE *)
"_?",Out);
1064 TokenToLine(OutScr);
1066 else if ( number >= AM.OffsetIndex + (WORD)WILDMASK ) {
1067 Out = StrCopy(VARNAME(indices,number
1068 -AM.OffsetIndex-WILDMASK),OutScr);
1069 StrCopy((UBYTE *)
"?",Out);
1070 TokenToLine(OutScr);
1072 else if ( number >= AM.OffsetIndex ) {
1073 TokenToLine(VARNAME(indices,number-AM.OffsetIndex));
1076 NumCopy(number,OutScr);
1077 TokenToLine(OutScr);
1082 if ( number < AM.OffsetVector ) {
1084 Out = StrCopy((UBYTE *)
"-",Out);
1086 if ( number >= AM.OffsetVector + WILDOFFSET ) {
1087 Out = StrCopy(VARNAME(vectors,number
1088 -AM.OffsetVector-WILDOFFSET),Out);
1089 StrCopy((UBYTE *)
"?",Out);
1092 Out = StrCopy(VARNAME(vectors,number-AM.OffsetVector),Out);
1094 TokenToLine(OutScr);
1097 if ( number >= FUNCTION + (WORD)WILDMASK ) {
1098 Out = StrCopy(VARNAME(functions,number
1099 -FUNCTION-WILDMASK),OutScr);
1100 StrCopy((UBYTE *)
"?",Out);
1101 TokenToLine(OutScr);
1103 TokenToLine(VARNAME(functions,number-FUNCTION));
1106 NumCopy(number,OutScr);
1107 TokenToLine(OutScr);
1110 }
while ( element < LastElement );
1120 if ( AS.ExecMode ) {
1124 for ( i = 0; i < j; i++, e++ ) {
1125 if ( e->status >= 0 ) {
1127 TokenToLine((UBYTE *)
" Expressions");
1132 Out = StrCopy(AC.exprnames->namebuffer+e->name,OutScr);
1133 Out = StrCopy((UBYTE *)(FG.ExprStat[e->status]),Out);
1134 if ( AC.CodesFlag ) Out = CodeToLine(i,Out);
1135 StrCopy((UBYTE *)
" ",Out);
1136 TokenToLine(OutScr);
1147 for ( i = 0; i < j; i++ ) {
1148 if ( e->printflag && ( e->status == LOCALEXPRESSION ||
1149 e->status == GLOBALEXPRESSION || e->status == UNHIDELEXPRESSION
1150 || e->status == UNHIDEGEXPRESSION ) ) {
1152 TokenToLine((UBYTE *)
" Expressions to be printed");
1157 Out = StrCopy(AC.exprnames->namebuffer+e->name,OutScr);
1158 StrCopy((UBYTE *)
" ",Out);
1159 TokenToLine(OutScr);
1172 if ( AC.CodesFlag || AC.NamesFlag > 1 ) startvalue = 0;
1173 else startvalue = BUILTINDOLLARS;
1174 if ( ( j = NumDollars ) > startvalue ) {
1175 TokenToLine((UBYTE *)
" Dollar variables");
1178 for ( i = startvalue; i < j; i++ ) {
1179 Out = StrCopy((UBYTE *)
"$", OutScr);
1180 Out = StrCopy(DOLLARNAME(Dollars, i), Out);
1181 if ( AC.CodesFlag ) Out = CodeToLine(i, Out);
1182 StrCopy((UBYTE *)
" ", Out);
1183 TokenToLine(OutScr);
1189 if ( ( j = NumPotModdollars ) > 0 ) {
1190 TokenToLine((UBYTE *)
" Dollar variables to be modified");
1193 for ( i = 0; i < j; i++ ) {
1194 Out = StrCopy((UBYTE *)
"$", OutScr);
1195 Out = StrCopy(DOLLARNAME(Dollars, PotModdollars[i]), Out);
1196 for ( k = 0; k < NumModOptdollars; k++ )
1197 if ( ModOptdollars[k].number == PotModdollars[i] )
break;
1198 if ( k < NumModOptdollars ) {
1199 switch ( ModOptdollars[k].type ) {
1201 Out = StrCopy((UBYTE *)
"(sum)", Out);
1204 Out = StrCopy((UBYTE *)
"(maximum)", Out);
1207 Out = StrCopy((UBYTE *)
"(minimum)", Out);
1210 Out = StrCopy((UBYTE *)
"(local)", Out);
1213 Out = StrCopy((UBYTE *)
"(?)", Out);
1217 StrCopy((UBYTE *)
" ", Out);
1218 TokenToLine(OutScr);
1227 if ( AC.ncmod != 0 ) {
1228 TokenToLine((UBYTE *)
"All arithmetic is modulus ");
1229 LongToLine((UWORD *)AC.cmod,ABS(AC.ncmod));
1230 if ( AC.ncmod > 0 ) TokenToLine((UBYTE *)
" with powerreduction");
1231 else TokenToLine((UBYTE *)
" without powerreduction");
1232 if ( ( AC.modmode & POSNEG ) != 0 ) TokenToLine((UBYTE *)
" centered around 0");
1233 else TokenToLine((UBYTE *)
" positive numbers only");
1236 if ( AC.lDefDim != 4 ) {
1237 TokenToLine((UBYTE *)
"The default dimension is ");
1238 if ( AC.lDefDim >= 0 ) {
1239 NumCopy(AC.lDefDim,OutScr);
1240 TokenToLine(OutScr);
1243 TokenToLine(VARNAME(symbols,-AC.lDefDim));
1244 if ( AC.lDefDim4 != -NMIN4SHIFT ) {
1245 TokenToLine((UBYTE *)
":");
1246 if ( AC.lDefDim4 >= -NMIN4SHIFT ) {
1247 NumCopy(AC.lDefDim4,OutScr);
1248 TokenToLine(OutScr);
1251 TokenToLine(VARNAME(symbols,-AC.lDefDim4-NMIN4SHIFT));
1257 if ( AC.lUnitTrace != 4 ) {
1258 TokenToLine((UBYTE *)
"The trace of the unit matrix is ");
1259 if ( AC.lUnitTrace >= 0 ) {
1260 NumCopy(AC.lUnitTrace,OutScr);
1261 TokenToLine(OutScr);
1264 TokenToLine(VARNAME(symbols,-AC.lUnitTrace));
1268 if ( AO.NumDictionaries > 0 ) {
1269 for ( i = 0; i < AO.NumDictionaries; i++ ) {
1270 WriteDictionary(AO.Dictionaries[i]);
1273 MesPrint(
"\nCurrently dictionary %s is active\n",
1274 AO.Dictionaries[olddict-1]->name);
1276 MesPrint(
"\nCurrently there is no actice dictionary\n");
1278 if ( AC.CodesFlag ) {
1279 if ( C->numlhs > 0 ) {
1280 TokenToLine((UBYTE *)
" Left Hand Sides:");
1282 for ( i = 1; i <= C->numlhs; i++ ) {
1286 while ( --j >= 0 ) { TalToLine((UWORD)(*skip++)); TokenToLine((UBYTE *)
" "); }
1291 if ( C->numrhs > 0 ) {
1292 TokenToLine((UBYTE *)
" Right Hand Sides:");
1294 for ( i = 1; i <= C->numrhs; i++ ) {
1297 while ( ( j = skip[0] ) != 0 ) {
1298 while ( --j >= 0 ) { TalToLine((UWORD)(*skip++)); TokenToLine((UBYTE *)
" "); }
1306 AO.CurrentDictionary = olddict;
1320 WORD *skip, na, *a, spec, *t, *tstop, j;
1321 UBYTE str[2], *OutScr, *Out;
1322 WORD oldoutputmode = AC.OutputMode, oldoutputspaces = AC.OutputSpaces;
1323 WORD oldoutskip = AO.OutSkip;
1324 AC.OutputMode = NORMALFORMAT;
1325 AC.OutputSpaces = NOSPACEFORMAT;
1326 MesPrint(
"===Contents of dictionary %s===",dict->name);
1329 AO.OutputLine = AO.OutFill = (UBYTE *)AT.WorkPointer;
1330 for ( j = 0; j < *skip; j++ ) *(AO.OutFill)++ =
' ';
1332 OutScr = (UBYTE *)AT.WorkPointer + ( TOLONG(AT.WorkTop) - TOLONG(AT.WorkPointer) ) /2;
1333 for ( i = 0; i < dict->numelements; i++ ) {
1334 switch ( dict->elements[i]->type ) {
1335 case DICT_INTEGERNUMBER:
1336 LongToLine((UWORD *)(dict->elements[i]->lhs),dict->elements[i]->size);
1337 Out = OutScr; *Out = 0;
1339 case DICT_RATIONALNUMBER:
1340 a = dict->elements[i]->lhs;
1341 na = a[a[0]-1]; na = (ABS(na)-1)/2;
1342 RatToLine((UWORD *)(a+1),na);
1343 Out = OutScr; *Out = 0;
1346 na = dict->elements[i]->lhs[0];
1347 Out = StrCopy(VARNAME(symbols,na),OutScr);
1350 na = dict->elements[i]->lhs[0]-AM.OffsetVector;
1351 Out = StrCopy(VARNAME(vectors,na),OutScr);
1354 na = dict->elements[i]->lhs[0]-AM.OffsetIndex;
1355 Out = StrCopy(VARNAME(indices,na),OutScr);
1358 na = dict->elements[i]->lhs[0]-FUNCTION;
1359 Out = StrCopy(VARNAME(functions,na),OutScr);
1361 case DICT_FUNCTION_WITH_ARGUMENTS:
1362 t = dict->elements[i]->lhs;
1364 Out = StrCopy(VARNAME(functions,na),OutScr);
1365 spec = functions[*t - FUNCTION].spec;
1368 if ( t[1] <= FUNHEAD ) {}
1369 else if ( spec >= TENSORFUNCTION ) {
1370 t += FUNHEAD; *Out++ = (UBYTE)
'(';
1371 while ( t < tstop ) {
1372 if ( first == 0 ) *Out++ = (UBYTE)(
',');
1376 if ( j < AM.OffsetIndex ) { Out = NumCopy(j,Out); }
1377 else if ( j < AM.IndDum ) {
1378 Out = StrCopy(VARNAME(indices,j-AM.OffsetIndex),Out);
1381 MesPrint(
"Currently wildcards are not allowed in dictionary elements");
1386 Out = StrCopy(VARNAME(vectors,j-AM.OffsetVector),Out);
1389 *Out++ = (UBYTE)
')'; *Out = 0;
1392 t += FUNHEAD; *Out++ = (UBYTE)
'('; *Out = 0;
1393 TokenToLine(OutScr);
1394 while ( t < tstop ) {
1395 if ( !first ) TokenToLine((UBYTE *)
",");
1401 *Out++ = (UBYTE)
')'; *Out = 0;
1404 case DICT_SPECIALCHARACTER:
1405 str[0] = (UBYTE)(dict->elements[i]->lhs[0]);
1407 Out = StrCopy(str,OutScr);
1410 Out = OutScr; *Out = 0;
1413 Out = StrCopy((UBYTE *)
": \"",Out);
1414 Out = StrCopy((UBYTE *)(dict->elements[i]->rhs),Out);
1415 Out = StrCopy((UBYTE *)
"\"",Out);
1416 TokenToLine(OutScr);
1419 MesPrint(
"========End of dictionary %s===",dict->name);
1420 AC.OutputMode = oldoutputmode;
1421 AC.OutputSpaces = oldoutputspaces;
1422 AO.OutSkip = oldoutskip;
1433VOID WriteArgument(WORD *t)
1438 int oldoutsidefun, oldlowestlevel = lowestlevel;
1441 oldoutsidefun = AC.outsidefun; AC.outsidefun = 0;
1442 WriteExpression(t+ARGHEAD,(LONG)(*t-ARGHEAD));
1443 AC.outsidefun = oldoutsidefun;
1447 if ( *t == -SNUMBER) {
1450 else if ( *t == -SYMBOL ) {
1451 if ( t[1] >= MAXVARIABLES-cbuf[AM.sbufnum].numrhs ) {
1452 Out = StrCopy(FindExtraSymbol(MAXVARIABLES-t[1]),Out);
1470 StrCopy(FindSymbol(t[1]),Out);
1474 else if ( *t == -VECTOR ) {
1475 if ( t[1] == FUNNYVEC ) { *Out++ =
'?'; *Out = 0; }
1477 StrCopy(FindVector(t[1]),Out);
1480 else if ( *t == -MINVECTOR ) {
1482 StrCopy(FindVector(t[1]),Out);
1485 else if ( *t == -INDEX ) {
1487 if ( t[1] < AM.OffsetIndex ) { NumCopy(t[1],Out); }
1490 if ( i >= AM.IndDum ) {
1493 Out = NumCopy(i,Out);
1499 i -= AM.OffsetIndex;
1500 Out = StrCopy(FindIndex(i%WILDOFFSET+AM.OffsetIndex),Out);
1502 if ( i >= WILDOFFSET ) { *Out++ =
'?'; *Out = 0; }
1506 else if ( t[1] == FUNNYVEC ) { *Out++ =
'?'; *Out = 0; }
1508 StrCopy(FindVector(t[1]),Out);
1511 else if ( *t == -DOLLAREXPRESSION ) {
1514 StrCopy(AC.dollarnames->namebuffer+d->name,Out);
1516 else if ( *t == -EXPRESSION ) {
1517 StrCopy(EXPRNAME(t[1]),Out);
1519 else if ( *t == -SETSET ) {
1520 StrCopy(VARNAME(Sets,t[1]),Out);
1522 else if ( *t <= -FUNCTION ) {
1523 StrCopy(FindFunction(-*t),Out);
1527 MesPrint(
"Illegal function argument while writing");
1530 TokenToLine(buffer);
1532 lowestlevel = oldlowestlevel;
1551WORD WriteSubTerm(WORD *sterm, WORD first)
1554 UBYTE *Out, closepar[2] = { (UBYTE)
')', 0};
1555 WORD *stopper, *t, *tt, i, j, po = 0;
1557 stopper = sterm + sterm[1];
1561 while ( t < stopper ) {
1562 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1564 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1566 if ( first ) TokenToLine((UBYTE *)
" ");
1568 if ( !first ) MultiplyToLine();
1569 if ( AC.OutputMode == CMODE && t[1] != 1 ) {
1570 if ( AC.Cnumpows >= t[1] && t[1] > 0 ) {
1572 Out = StrCopy((UBYTE *)
"POW",buffer);
1573 Out = NumCopy(po,Out);
1574 Out = StrCopy((UBYTE *)
"(",Out);
1575 TokenToLine(buffer);
1578 TokenToLine((UBYTE *)
"pow(");
1581 if ( *t < NumSymbols ) {
1582 Out = StrCopy(FindSymbol(*t),buffer); t++;
1589 Out = StrCopy(FindExtraSymbol(MAXVARIABLES-*t),buffer);
1607 if ( AC.OutputMode == CMODE && po > 1
1608 && AC.Cnumpows >= po ) {
1609 Out = StrCopy((UBYTE *)
")",Out);
1612 else if ( *t != 1 ) WrtPower(Out,*t);
1613 TokenToLine(buffer);
1619 while ( t < stopper ) {
1620 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1622 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1624 if ( first ) TokenToLine((UBYTE *)
" ");
1626 if ( !first ) MultiplyToLine();
1628 Out = StrCopy(FindVector(*t),buffer);
1631 if ( AC.OutputMode == MATHEMATICAMODE ) *Out++ =
'[';
1633 if ( *t >= AM.OffsetIndex ) {
1635 if ( i >= AM.IndDum ) {
1638 Out = NumCopy(i,Out);
1644 Out = StrCopy(FindIndex(i),Out);
1647 else if ( *t == FUNNYVEC ) { *Out++ =
'?'; *Out = 0; }
1649 Out = NumCopy(*t++,Out);
1651 if ( AC.OutputMode == MATHEMATICAMODE ) *Out++ =
']';
1654 TokenToLine(buffer);
1659 while ( t < stopper ) {
1660 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1662 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1664 if ( first ) TokenToLine((UBYTE *)
" ");
1666 if ( !first ) MultiplyToLine();
1668 if ( *t < AM.OffsetIndex ) {
1669 TalToLine((UWORD)(*t++));
1673 if ( i >= AM.IndDum ) {
1677 Out = NumCopy(i,Out);
1683 i -= AM.OffsetIndex;
1684 Out = StrCopy(FindIndex(i%WILDOFFSET+AM.OffsetIndex),buffer);
1686 if ( i >= WILDOFFSET ) { *Out++ =
'?'; *Out = 0; }
1688 TokenToLine(buffer);
1692 TokenToLine(FindVector(*t)); t++;
1698 case DOLLAREXPRESSION:
1700 DOLLARS d = Dollars + sterm[2];
1701 Out = StrCopy((UBYTE *)
"$",buffer);
1702 Out = StrCopy(AC.dollarnames->namebuffer+d->name,Out);
1703 if ( sterm[3] != 1 ) WrtPower(Out,sterm[3]);
1704 TokenToLine(buffer);
1709 while ( t < stopper ) {
1710 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1712 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1714 if ( first ) TokenToLine((UBYTE *)
" ");
1716 if ( !first ) MultiplyToLine();
1717 Out = StrCopy((UBYTE *)
"d_(",buffer);
1718 if ( *t >= AM.OffsetIndex ) {
1719 if ( *t < AM.IndDum ) {
1720 Out = StrCopy(FindIndex(*t),Out);
1726 Out = NumCopy( *t++ - AM.IndDum, Out);
1732 else if ( *t == FUNNYVEC ) { *Out++ =
'?'; *Out = 0; }
1734 Out = NumCopy(*t++,Out);
1737 if ( *t >= AM.OffsetIndex ) {
1738 if ( *t < AM.IndDum ) {
1739 Out = StrCopy(FindIndex(*t),Out);
1745 Out = NumCopy(*t++ - AM.IndDum,Out);
1751 Out = NumCopy(*t++,Out);
1755 TokenToLine(buffer);
1760 while ( t < stopper ) {
1761 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1763 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1765 if ( first ) TokenToLine((UBYTE *)
" ");
1767 if ( !first ) MultiplyToLine();
1768 if ( AC.OutputMode == CMODE && t[2] != 1 )
1769 TokenToLine((UBYTE *)
"pow(");
1770 Out = StrCopy(FindVector(*t),buffer);
1773 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE
1774 || AC.OutputMode == CMODE )
1775 *Out++ = AO.FortDotChar;
1777 Out = StrCopy(FindVector(*t),Out);
1780 if ( *t != 1 ) WrtPower(Out,*t);
1782 TokenToLine(buffer);
1790 if ( !first ) MultiplyToLine();
1791 if ( AC.OutputMode == CMODE ) TokenToLine((UBYTE *)
"pow(");
1792 else TokenToLine((UBYTE *)
"(");
1794 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE
1795 || AC.OutputMode == REDUCEMODE )
1796 TokenToLine((UBYTE *)
")**(");
1797 else if ( AC.OutputMode == CMODE ) TokenToLine((UBYTE *)
",");
1799 UBYTE *Out1 = IsExponentSign();
1801 TokenToLine((UBYTE *)
")");
1803 TokenToLine((UBYTE *)
"(");
1805 else TokenToLine((UBYTE *)
")^(");
1809 TokenToLine((UBYTE *)
")");
1815 if ( first ) TokenToLine((UBYTE *)
"1/(");
1816 else TokenToLine((UBYTE *)
"/(");
1818 TokenToLine((UBYTE *)
")");
1821 if ( !first ) MultiplyToLine();
1822 TokenToLine((UBYTE *)
"(");
1823 t = cbuf[sterm[4]].rhs[sterm[2]];
1825 while ( *tt ) tt += *tt;
1826 oldoutsidefun = AC.outsidefun; AC.outsidefun = 0;
1828 WriteExpression(t,(LONG)(tt-t));
1831 TokenToLine((UBYTE *)
"0");
1833 AC.outsidefun = oldoutsidefun;
1834 TokenToLine((UBYTE *)
")");
1835 if ( sterm[3] != 1 ) {
1836 UBYTE *Out1 = IsExponentSign();
1837 if ( Out1 ) TokenToLine(Out1);
1838 else TokenToLine((UBYTE *)
"^");
1840 NumCopy(sterm[3],Out);
1841 TokenToLine(buffer);
1845 if ( lowestlevel && ( ( AO.PrintType & PRINTALL ) != 0 ) ) {
1847 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
1849 if ( first ) TokenToLine((UBYTE *)
" ");
1851 if ( *sterm < FUNCTION ) {
1852 return(MesPrint(
"Illegal subterm while writing"));
1854 if ( !first ) MultiplyToLine();
1857 if ( ( tmp = FindFunWithArgs(sterm) ) != 0 ) {
1864 if ( *sterm == GAMMA && t[-FUNHEAD+1] == FUNHEAD+1 ) {
1865 TokenToLine((UBYTE *)
"gi_(");
1868 if ( *sterm != DUMFUN ) {
1869 Out = StrCopy(FindFunction(*sterm),buffer);
1872 else { Out = buffer; *Out = 0; }
1873 if ( t >= stopper ) {
1874 TokenToLine(buffer);
1877 if ( AC.OutputMode == MATHEMATICAMODE ) { *Out++ =
'['; closepar[0] = (UBYTE)
']'; }
1878 else { *Out++ =
'('; }
1880 TokenToLine(buffer);
1882 i = functions[*sterm - FUNCTION].spec;
1883 if ( i >= TENSORFUNCTION ) {
1884 int curdict = AO.CurrentDictionary;
1885 if ( AO.CurrentDictionary && AO.CurDictNotInFunctions > 0 )
1886 AO.CurrentDictionary = 0;
1887 t = sterm + FUNHEAD;
1888 while ( t < stopper ) {
1889 if ( !first ) TokenToLine((UBYTE *)
",");
1893 if ( j < AM.OffsetIndex ) TalToLine((UWORD)(j));
1894 else if ( j < AM.IndDum ) {
1895 i = j - AM.OffsetIndex;
1896 Out = StrCopy(FindIndex(i%WILDOFFSET+AM.OffsetIndex),buffer);
1898 if ( i >= WILDOFFSET ) { *Out++ =
'?'; *Out = 0; }
1899 TokenToLine(buffer);
1904 Out = NumCopy(j - AM.IndDum,Out);
1908 TokenToLine(buffer);
1911 else if ( j == FUNNYVEC ) { TokenToLine((UBYTE *)
"?"); }
1912 else if ( j > -WILDOFFSET ) {
1914 Out = NumCopy((UWORD)(-j + 4),Out);
1917 TokenToLine(buffer);
1920 TokenToLine(FindVector(j));
1924 AO.CurrentDictionary = curdict;
1927 int curdict = AO.CurrentDictionary;
1928 if ( AO.CurrentDictionary && AO.CurDictNotInFunctions > 0 )
1929 AO.CurrentDictionary = 0;
1930 while ( t < stopper ) {
1931 if ( !first ) TokenToLine((UBYTE *)
",");
1936 AO.CurrentDictionary = curdict;
1938 TokenToLine(closepar);
1939 closepar[0] = (UBYTE)
')';
1954WORD WriteInnerTerm(WORD *term, WORD first)
1956 WORD *t, *s, *s1, *s2, n, i, pow;
1961 if ( *s == HAAKJE )
break;
1964 if ( s < t ) { s += s[1]; }
1965 else { s = term+1; }
1967 if ( n < 0 || !first ) {
1968 if ( n > 0 ) { TOKENTOLINE(
" + ",
"+") }
1969 else if ( n < 0 ) { n = -n; TOKENTOLINE(
" - ",
"-") }
1971 if ( AC.modpowers ) {
1972 if ( n == 1 && *t == 1 && t > s ) first = 1;
1973 else if ( ABS(AC.ncmod) == 1 ) {
1974 UBYTE *Out1 = IsExponentSign();
1975 LongToLine((UWORD *)AC.powmod,AC.npowmod);
1976 if ( Out1 ) TokenToLine(Out1);
1977 else TokenToLine((UBYTE *)
"^");
1978 TalToLine(AC.modpowers[(LONG)((UWORD)*t)]);
1983 UBYTE *Out1 = IsExponentSign();
1984 LongToLine((UWORD *)AC.powmod,AC.npowmod);
1985 if ( Out1 ) TokenToLine(Out1);
1986 else TokenToLine((UBYTE *)
"^");
1988 if ( n == 2 ) jj += ((LONG)t[1])<<BITSINWORD;
1989 if ( AC.modpowers[jj+1] == 0 ) {
1990 TalToLine(AC.modpowers[jj]);
1993 LongToLine(AC.modpowers+jj,2);
1998 else if ( n != 1 || *t != 1 || t[1] != 1 || t <= s ) {
1999 if ( lowestlevel && ( ( AO.PrintType & PRINTONEFUNCTION ) != 0 ) ) {
2001 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
2004 if ( AO.CurrentDictionary > 0 ) TransformRational((UWORD *)t,n);
2005 else RatToLine((UWORD *)t,n);
2010 if ( lowestlevel && ( (AO.PrintType & (PRINTONEFUNCTION | PRINTALL)) == PRINTONEFUNCTION ) ) {
2012 if ( AC.OutputSpaces == NOSPACEFORMAT ) IniLine(1);
2020 if ( *s == GAMMA ) {
2022 ss = AT.WorkPointer;
2027 tt = s + FUNHEAD + 1;
2028 n = s[1] - FUNHEAD-1;
2030 while ( --n >= 0 ) *ss++ = *tt++;
2032 while ( *tt == GAMMA && tt[FUNHEAD] == s[FUNHEAD] && tt < t ) {
2035 n = s[1] - FUNHEAD-1;
2039 tt = AT.WorkPointer;
2040 AT.WorkPointer = ss;
2041 tt[1] = WORDDIF(ss,tt);
2042 if ( WriteSubTerm(tt,first) ) {
2043 MesCall(
"WriteInnerTerm");
2046 AT.WorkPointer = tt;
2054 if ( *s >= FUNCTION && AC.funpowers > 0
2055 && functions[*s-FUNCTION].spec == 0 && ( AC.funpowers == ALLFUNPOWERS ||
2056 ( AC.funpowers == COMFUNPOWERS && functions[*s-FUNCTION].commute == 0 ) ) ) {
2059 s1 = s; s2 = s + s[1]; i = s[1];
2061 while ( --i >= 0 && *s1 == *s2 ) { s1++; s2++; }
2070 if ( AC.OutputMode == CMODE ) {
2071 if ( !first ) MultiplyToLine();
2072 TokenToLine((UBYTE *)
"pow(");
2075 if ( WriteSubTerm(s,first) ) {
2076 MesCall(
"WriteInnerTerm");
2079 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE
2080 || AC.OutputMode == REDUCEMODE ) { TokenToLine((UBYTE *)
"**"); }
2081 else if ( AC.OutputMode == CMODE ) { TokenToLine((UBYTE *)
","); }
2083 UBYTE *Out1 = IsExponentSign();
2084 if ( Out1 ) TokenToLine(Out1);
2085 else TokenToLine((UBYTE *)
"^");
2088 if ( AC.OutputMode == CMODE ) TokenToLine((UBYTE *)
")");
2090 else if ( WriteSubTerm(s,first) ) {
2091 MesCall(
"WriteInnerTerm");
2095 else if ( WriteSubTerm(s,first) ) {
2096 MesCall(
"WriteInnerTerm");
2120WORD WriteTerm(WORD *term, WORD *lbrac, WORD first, WORD prtf, WORD br)
2122 WORD *t, *stopper, *b, n;
2123 int oldIsFortran90 = AC.IsFortran90, i;
2124 if ( *lbrac >= 0 ) {
2126 stopper = (term + *term - 1);
2127 stopper -= ABS(*stopper) - 1;
2128 while ( t < stopper ) {
2129 if ( *t == HAAKJE ) {
2132 if ( *lbrac == ( n = WORDDIF(stopper,t) ) ) {
2135 while ( n > 0 && ( *b++ == *t++ ) ) { n--; }
2136 if ( n <= 0 && ( ( AM.FortranCont <= 0 || AO.InFbrack < AM.FortranCont )
2137 || ( lowestlevel == 0 ) ) ) {
2142 if ( ( prtf & PRINTCONTENTS ) != 0 ) {
2146 if ( WriteInnerTerm(term,0) )
goto WrtTmes;
2147 if ( ( AO.PrintType & PRINTONETERM ) != 0 ) {
2149 TokenToLine((UBYTE *)
" ");
2155 n = WORDDIF(stopper,t);
2161 if ( ( prtf & PRINTCONTENTS ) ) PrtTerms();
2162 TOKENTOLINE(
" )",
")")
2163 if ( AC.OutputMode == CMODE && AO.FactorMode == 0 )
2164 TokenToLine((UBYTE *)";");
2165 else if ( AO.FactorMode && ( n == 0 ) ) {
2171 AC.IsFortran90 = ISNOTFORTRAN90;
2173 AC.IsFortran90 = oldIsFortran90;
2174 if ( AC.OutputMode != FORTRANMODE && AC.OutputMode != PFORTRANMODE
2175 && AC.OutputSpaces == NORMALFORMAT
2176 && AO.FactorMode == 0 ) FiniLine();
2179 if ( AC.OutputMode == CMODE && AO.FactorMode == 0 )
2180 TokenToLine((UBYTE *)
";");
2181 if ( AO.FortFirst == 0 ) {
2183 AC.IsFortran90 = ISNOTFORTRAN90;
2185 AC.IsFortran90 = oldIsFortran90;
2189 if ( AO.FactorMode == 0 ) {
2190 if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2192 WORD oldmode = AC.OutputMode;
2195 AC.OutputMode = oldmode;
2198 if ( AO.FortFirst == 0 ) {
2199 TokenToLine(AO.CurBufWrt);
2200 TOKENTOLINE(
" = ",
"=")
2201 TokenToLine(AO.CurBufWrt);
2205 TokenToLine(AO.CurBufWrt);
2206 TOKENTOLINE(
" = ",
"=")
2209 else if ( AC.OutputMode == CMODE && !first ) {
2211 if ( AO.FortFirst == 0 ) {
2212 TokenToLine(AO.CurBufWrt);
2213 TOKENTOLINE(
" += ",
"+=")
2217 TokenToLine(AO.CurBufWrt);
2218 TOKENTOLINE(
" = ",
"=")
2221 else if ( startinline == 0 ) {
2225 if ( ( *lbrac = n ) > 0 ) {
2228 while ( --n >= 0 ) *b++ = *t++;
2229 *b++ = 1; *b++ = 1; *b = 3;
2231 if ( WriteInnerTerm(AO.bracket,0) ) {
2238 while ( --i >= 0 ) { TalToLine((UWORD)(*t++));
2239 if ( AC.OutputSpaces == NORMALFORMAT )
2240 TokenToLine((UBYTE *)
" "); }
2243 MesCall(
"WriteTerm");
2246 TOKENTOLINE(
" * ( ",
"*(")
2249 if ( ( prtf & PRINTONETERM ) != 0 ) {
2252 TokenToLine((UBYTE *)
" ");
2266 if ( ( *lbrac = n ) > 0 ) {
2269 while ( --n >= 0 ) *b++ = *t++;
2270 *b++ = 1; *b++ = 1; *b = 3;
2271 for ( i = AO.FactorNum+1; i < AO.bracket[4]; i++ ) {
2273 TOKENTOLINE(
" ( 0 )",
" (0)")
2277 TOKENTOLINE(
" * ( 0 )",
"*(0)")
2282 AO.FactorNum = AO.bracket[4];
2288 if ( first == 0 ) { TOKENTOLINE(
" * ( ",
"*(") }
2289 else { TOKENTOLINE(
" ( ",
" (") }
2293 if ( ( prtf & PRINTCONTENTS ) != 0 ) AO.NumInBrack++;
2294 else if ( WriteInnerTerm(term,first) )
goto WrtTmes;
2295 if ( ( AO.PrintType & PRINTONETERM ) != 0 ) {
2297 TokenToLine((UBYTE *)
" ");
2304 if ( ( prtf & PRINTCONTENTS ) != 0 ) PrtTerms();
2305 TokenToLine((UBYTE *)
" )");
2306 if ( AC.OutputMode == CMODE ) TokenToLine((UBYTE *)
";");
2307 if ( AO.FortFirst == 0 ) {
2308 AC.IsFortran90 = ISNOTFORTRAN90;
2310 AC.IsFortran90 = oldIsFortran90;
2312 if ( AC.OutputMode != FORTRANMODE && AC.OutputMode != PFORTRANMODE
2313 && AC.OutputSpaces == NORMALFORMAT ) FiniLine();
2314 if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2316 WORD oldmode = AC.OutputMode;
2319 AC.OutputMode = oldmode;
2321 if ( AO.FortFirst == 0 ) {
2322 TokenToLine(AO.CurBufWrt);
2323 TOKENTOLINE(
" = ",
"=")
2324 TokenToLine(AO.CurBufWrt);
2328 TokenToLine(AO.CurBufWrt);
2329 TOKENTOLINE(
" = ",
"=")
2339 else if ( AC.OutputMode == CMODE && !first ) {
2341 if ( AO.FortFirst == 0 ) {
2342 TokenToLine(AO.CurBufWrt);
2343 TOKENTOLINE(
" += ",
"+=")
2347 TokenToLine(AO.CurBufWrt);
2348 TOKENTOLINE(
" = ",
"=")
2364 if ( !br ) AO.IsBracket = 0;
2365 if ( ( AM.FortranCont > 0 && AO.InFbrack >= AM.FortranCont ) && lowestlevel ) {
2366 if ( AC.OutputMode == CMODE ) TokenToLine((UBYTE *)
";");
2367 if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2369 WORD oldmode = AC.OutputMode;
2370 if ( AO.FortFirst == 0 ) {
2371 AC.IsFortran90 = ISNOTFORTRAN90;
2373 AC.IsFortran90 = oldIsFortran90;
2376 AC.OutputMode = oldmode;
2378 TokenToLine(AO.CurBufWrt);
2379 TOKENTOLINE(
" = ",
"=")
2380 TokenToLine(AO.CurBufWrt);
2397 else if ( AC.OutputMode == CMODE && !first ) {
2400 if ( AO.FortFirst == 0 ) {
2401 TokenToLine(AO.CurBufWrt);
2402 TOKENTOLINE(
" += ",
"+=")
2406 TokenToLine(AO.CurBufWrt);
2407 TOKENTOLINE(
" = ",
"=")
2424 if ( WriteInnerTerm(term,first) )
goto WrtTmes;
2425 if ( ( AO.PrintType & PRINTONETERM ) != 0 ) {
2442WORD WriteExpression(WORD *terms, LONG ltot)
2446 WORD OldIsBracket = AO.IsBracket, OldPrintType = AO.PrintType;
2447 if ( !AC.outsidefun ) { AO.PrintType &= ~PRINTONETERM; first = 1; }
2449 stopper = terms + ltot;
2451 while ( terms < stopper ) {
2452 AO.IsBracket = OldIsBracket;
2453 if ( WriteTerm(terms,&btot,first,0,1) ) {
2454 MesCall(
"WriteExpression");
2461 AO.IsBracket = OldIsBracket;
2462 AO.PrintType = OldPrintType;
2477 WORD *t, *stopper, n, prtf;
2478 int oldIsFortran90 = AC.IsFortran90, i;
2482 if ( AM.exitflag )
return(0);
2484 if ( PF.me != MASTER ) {
2489 for ( n = 0; n < NumExpressions; n++ ) {
2490 e = &Expressions[n];
2491 if ( !e->printflag & PRINTON )
continue;
2492 switch ( e->status ) {
2493 case LOCALEXPRESSION:
2494 case GLOBALEXPRESSION:
2495 case UNHIDELEXPRESSION:
2496 case UNHIDEGEXPRESSION:
2502 PutPreVar(AM.oldnumextrasymbols, GetPreVar((UBYTE *)
"EXTRASYMBOLS_", 0), 0, 1);
2503 if ( AO.OptimizationLevel > 0 ) {
2510 SeekScratch(AR.outfile,&pos);
2511 if ( ResetScratch() ) {
2512 MesCall(
"WriteAll");
2515 AO.termbuf = AT.WorkPointer;
2516 AO.bracket = (WORD *)(((UBYTE *)(AT.WorkPointer)) + AM.MaxTer);
2517 AT.WorkPointer = (WORD *)(((UBYTE *)(AT.WorkPointer)) + AM.MaxTer*2);
2518 AO.OutFill = AO.OutputLine = (UBYTE *)AT.WorkPointer;
2519 AT.WorkPointer += 2*AC.LineLength;
2520 *(AR.CompressBuffer) = 0;
2522 for ( n = 0; n < NumExpressions; n++ ) {
2523 if ( ( Expressions[n].printflag & PRINTON ) != 0 ) { first = 1;
break; }
2525 if ( !first )
goto EndWrite;
2529 while ( GetTerm(BHEAD AO.termbuf) ) {
2531 e = Expressions + AO.termbuf[3];
2533 if ( ( n == LOCALEXPRESSION || n == GLOBALEXPRESSION
2534 || n == UNHIDELEXPRESSION || n == UNHIDEGEXPRESSION ) &&
2535 ( ( prtf = e->printflag ) & PRINTON ) != 0 ) {
2539 GetPreVar((UBYTE *)
"EXTRASYMBOLS_",0),0,1);
2540 if ( ( prtf & PRINTLFILE ) != 0 ) {
2541 if ( AC.LogHandle < 0 ) prtf &= ~PRINTLFILE;
2543 AO.PrintType = prtf;
2556 if ( AO.OptimizationLevel > 0 ) {
2557 UBYTE *oldOutFill = AO.OutFill, *oldOutputLine = AO.OutputLine;
2559 if (
Optimize(AO.termbuf[3], 1) )
goto AboWrite;
2561 AO.OutFill = oldOutFill; AO.OutputLine = oldOutputLine;
2565 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2568 AO.CurBufWrt = EXPRNAME(AO.termbuf[3]);
2569 TokenToLine(AO.CurBufWrt);
2572 if ( t < stopper ) {
2573 TokenToLine((UBYTE *)
"(");
2575 while ( t < stopper ) {
2577 if ( !first ) TokenToLine((UBYTE *)
",");
2580 TokenToLine(FindSymbol(t[2]));
2584 TokenToLine(FindVector(t[2]));
2588 TokenToLine(FindIndex(t[2]));
2592 TokenToLine(FindFunction(t[2]));
2599 TokenToLine((UBYTE *)
")");
2601 TOKENTOLINE(
" =",
"=");
2604 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2609 if ( ( e->vflags & ISFACTORIZED ) != 0 ) {
2610 AO.FactorMode = 1+e->numfactors;
2616 while ( GetTerm(BHEAD AO.termbuf) ) {
2618 GETSTOP(AO.termbuf,m);
2619 if ( ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2620 && ( ( prtf & PRINTONETERM ) != 0 ) ) {}
2627 if ( ( prtf & PRINTONETERM ) != 0 ) first = 0;
2628 if ( WriteTerm(AO.termbuf,&lbrac,first,prtf,0) )
2632 if ( AO.FactorMode ) {
2633 if ( first ) { AO.FactorNum = 1; TOKENTOLINE(
" ( 0 )",
" (0)") }
2634 else TOKENTOLINE(
" )",
")");
2635 for ( i = AO.FactorNum+1; i <= e->numfactors; i++ ) {
2638 TOKENTOLINE(
" * ( 0 )",
"*(0)");
2640 AO.FactorNum = e->numfactors;
2641 if ( AC.OutputMode != FORTRANMODE && AC.OutputMode != PFORTRANMODE )
2642 TokenToLine((UBYTE *)
";");
2644 else if ( AO.FactorMode == 0 || first ) {
2645 if ( first ) { TOKENTOLINE(
" 0",
"0") }
2647 if ( ( prtf & PRINTCONTENTS ) != 0 ) PrtTerms();
2648 TOKENTOLINE(
" )",
")")
2650 else if ( ( prtf & PRINTCONTENTS ) != 0 ) {
2651 TOKENTOLINE(
" + 1 * ( ",
"+1*(")
2653 TOKENTOLINE(" )",")")
2655 if ( AC.OutputMode != FORTRANMODE && AC.OutputMode != PFORTRANMODE )
2656 TokenToLine((UBYTE *)";");
2659 AC.IsFortran90 = ISNOTFORTRAN90;
2661 AC.IsFortran90 = oldIsFortran90;
2665 do { }
while ( GetTerm(BHEAD AO.termbuf) );
2668 if ( AC.OutputSpaces == NORMALFORMAT ) FiniLine();
2670 if ( AR.infile->handle >= 0 ) {
2671 SeekFile(AR.infile->handle,&(AR.infile->filesize),SEEK_SET);
2674 AT.WorkPointer = AO.termbuf;
2675 SetScratch(AR.infile,&pos);
2676 f = AR.outfile; AR.outfile = AR.infile; AR.infile = f;
2679 SetScratch(AR.infile,&pos);
2680 f = AR.outfile; AR.outfile = AR.infile; AR.infile = f;
2681 MesCall(
"WriteAll");
2693WORD WriteOne(UBYTE *name,
int alreadyinline,
int nosemi, WORD plus)
2702 if ( GetName(AC.exprnames,name,&number,NOAUTO) != CEXPRESSION ) {
2703 MesPrint(
"@%s is not an expression",name);
2706 switch ( Expressions[number].status ) {
2707 case HIDDENLEXPRESSION:
2708 case HIDDENGEXPRESSION:
2709 case HIDELEXPRESSION:
2710 case HIDEGEXPRESSION:
2711 case UNHIDELEXPRESSION:
2712 case UNHIDEGEXPRESSION:
2719 case LOCALEXPRESSION:
2720 case GLOBALEXPRESSION:
2721 case SKIPLEXPRESSION:
2722 case SKIPGEXPRESSION:
2730 MesPrint(
"@expressions %s is not active. It cannot be written",name);
2733 SeekScratch(AR.outfile,&pos);
2735 f = AR.outfile; AR.outfile = AR.infile; AR.infile = f;
2742 if ( AR.GetFile == 2 ) f = AR.hidefile;
2744 prf = Expressions[number].printflag;
2745 if ( plus ) prf |= PRINTONETERM;
2750 SetScratch(f,&(Expressions[number].onfile));
2753 f->POfill = (WORD *)((UBYTE *)(f->PObuffer)
2754 + BASEPOSITION(Expressions[number].onfile));
2756 AO.termbuf = AT.WorkPointer;
2757 AO.bracket = (WORD *)(((UBYTE *)(AT.WorkPointer)) + AM.MaxTer);
2758 AT.WorkPointer = (WORD *)(((UBYTE *)(AT.WorkPointer)) + AM.MaxTer*2);
2760 AO.OutFill = AO.OutputLine = (UBYTE *)AT.WorkPointer;
2761 AT.WorkPointer += 2*AC.LineLength;
2762 *(AR.CompressBuffer) = 0;
2768 if ( AC.OutputMode == FORTRANMODE || AC.OutputMode == PFORTRANMODE )
2770 if ( GetTerm(BHEAD AO.termbuf) <= 0 ) {
2771 MesPrint(
"@ReadError in expression %s",name);
2784 if ( AO.OptimizationLevel > 0 ) {
2786 if (
Optimize(AO.termbuf[3], 1) )
goto AboWrite;
2795 while ( GetTerm(BHEAD AO.termbuf) ) {
2797 GETSTOP(AO.termbuf,m);
2800 startinline = alreadyinline;
2801 AO.OutFill = AO.OutputLine + startinline;
2802 if ( WriteTerm(AO.termbuf,&lbrac,first,0,0) )
2807 if ( ( prf & PRINTONETERM ) != 0 ) first = 1;
2813 if ( WriteTerm(AO.termbuf,&lbrac,first,0,0) )
2819 startinline = alreadyinline;
2820 AO.OutFill = AO.OutputLine + startinline;
2821 TOKENTOLINE(
" 0",
"0");
2824 TOKENTOLINE(
" )",
")");
2826 if ( AC.OutputMode != FORTRANMODE && AC.OutputMode != PFORTRANMODE
2827 && nosemi == 0 ) TokenToLine((UBYTE *)
";");
2829 if ( AC.OutputSpaces == NORMALFORMAT && nosemi == 0 ) {
2833 noextralinefeed = 1;
2835 noextralinefeed = 0;
2839 AT.WorkPointer = AO.termbuf;
2841 f = AR.outfile; AR.outfile = AR.infile; AR.infile = f;
2845 SetScratch(AR.infile,&pos);
2846 f->POposition = pos;
2847 f = AR.outfile; AR.outfile = AR.infile; AR.infile = f;
2848 MesCall(
"WriteOne");
int PutPreVar(UBYTE *, UBYTE *, UBYTE *, int)