51 if ( AR.outfile->handle >= 0 ) {
52 SeekFile(AR.outfile->handle,&(AR.outfile->filesize),SEEK_SET);
53 AR.outfile->POposition = AR.outfile->filesize;
54 AR.outfile->POfill = AR.outfile->PObuffer;
66 *pos = fi->POposition;
67 ADDPOS(*pos,(TOLONG(fi->POfill)-TOLONG(fi->PObuffer)));
78 SETBASEPOSITION(*position,(f->POfull-f->PObuffer)*
sizeof(WORD));
80 else *position = f->filesize;
81 SetScratch(f,position);
92 SETBASEPOSITION(*position,(f->POfull-f->PObuffer)*
sizeof(WORD));
93 f->POfill = f->POfull;
99 SeekFile(f->
handle,&possize,SEEK_END);
100 MesPrint(
"SetEndHScratch: filesize(th) = %12p, filesize(ex) = %12p",&(f->filesize),
103 *position = f->filesize;
104 f->POposition = f->filesize;
105 f->POfill = f->POfull = f->PObuffer;
119 LONG size, *whichInInBuf;
120 if ( f == AR.hidefile ) whichInInBuf = &(AR.InHiBuf);
121 else whichInInBuf = &(AR.InInBuf);
123 if ( f == AR.hidefile ) MesPrint(
"In the hide file");
124 else MesPrint(
"In the input file");
125 MesPrint(
"SetScratch to position %15p",position);
126 MesPrint(
"POposition = %15p, full = %l, fill = %l" 127 ,&(f->POposition),(f->POfull-f->PObuffer)*
sizeof(WORD)
128 ,(f->POfill-f->PObuffer)*
sizeof(WORD));
130 if ( ISLESSPOS(*position,f->POposition) ||
131 ISGEPOSINC(*position,f->POposition,(f->POfull-f->PObuffer)*
sizeof(WORD)) ) {
133 if ( ISEQUALPOSINC(*position,f->POposition,
134 (f->POfull-f->PObuffer)*
sizeof(WORD)) )
goto endpos;
135 MesPrint(
"Illegal position in SetScratch");
140 SeekFile(f->
handle,&possize,SEEK_SET);
141 if ( ISNOTEQUALPOS(possize,*position) ) {
142 UNLOCK(AS.inputslock);
143 MesPrint(
"Cannot position file in SetScratch");
147 MesPrint(
"SetScratch1(%w): position = %12p, size = %l, address = %x",position,f->POsize,f->PObuffer);
149 if ( ( size = ReadFile(f->
handle,(UBYTE *)(f->PObuffer),f->POsize) ) < 0
150 || ( size & 1 ) != 0 ) {
151 UNLOCK(AS.inputslock);
152 MesPrint(
"Read error in SetScratch");
155 UNLOCK(AS.inputslock);
159 f->POfill = f->PObuffer;
160 f->POposition = *position;
162 *whichInInBuf = size >> 1;
164 *whichInInBuf = size / TABLESIZE(WORD,UBYTE);
166 f->POfull = f->PObuffer + *whichInInBuf;
168 MesPrint(
"SetScratch2: size = %l, InInBuf = %l, fill = %l, full = %l" 169 ,size,*whichInInBuf,(f->POfill-f->PObuffer)*
sizeof(WORD)
170 ,(f->POfull-f->PObuffer)*
sizeof(WORD));
175 DIFPOS(possize,*position,f->POposition);
176 f->POfill = (WORD *)(BASEPOSITION(possize)+(UBYTE *)(f->PObuffer));
177 *whichInInBuf = f->POfull-f->POfill;
194 if ( AR.infile->handle >= 0 && AR.infile->handle != AR.outfile->handle ) {
195 CloseFile(AR.infile->handle);
196 AR.infile->handle = -1;
197 remove(AR.infile->name);
199 f = AR.infile; AR.infile = AR.outfile; AR.outfile = f;
200 AR.infile->POfull = AR.infile->POfill;
201 AR.infile->POfill = AR.infile->PObuffer;
202 if ( AR.infile->handle >= 0 ) {
205 SeekFile(AR.infile->handle,&scrpos,SEEK_SET);
206 if ( ISNOTZEROPOS(scrpos) ) {
207 return(MesPrint(
"Error with scratch output."));
209 if ( ( AR.InInBuf = ReadFile(AR.infile->handle,(UBYTE *)(AR.infile->PObuffer)
210 ,AR.infile->POsize) ) < 0 || AR.InInBuf & 1 ) {
211 return(MesPrint(
"Error while reading from scratch file"));
214 AR.InInBuf /= TABLESIZE(WORD,UBYTE);
216 AR.infile->POfull = AR.infile->PObuffer + AR.InInBuf;
218 PUTZERO(AR.infile->POposition);
219 AR.outfile->POfill = AR.outfile->POfull = AR.outfile->PObuffer;
220 PUTZERO(AR.outfile->POposition);
221 PUTZERO(AR.outfile->filesize);
239 if ( AR.infile->handle >= 0 ) {
240 CloseFile(AR.infile->handle); AR.infile->handle = -1;
241 remove(AR.infile->name);
242 PUTZERO(AR.infile->POposition);
243 AR.infile->POfill = AR.infile->POfull = AR.infile->PObuffer;
245 if ( AR.outfile->handle >= 0 ) {
248 SeekFile(AR.outfile->handle,&scrpos,SEEK_SET);
249 if ( ISNOTZEROPOS(scrpos) ) {
250 return(MesPrint(
"Error with scratch output."));
252 if ( ( AR.InInBuf = ReadFile(AR.outfile->handle,(UBYTE *)(AR.outfile->PObuffer)
253 ,AR.outfile->POsize) ) < 0 || AR.InInBuf & 1 ) {
254 return(MesPrint(
"Error while reading from scratch file"));
256 else AR.InInBuf /= TABLESIZE(WORD,UBYTE);
257 AR.outfile->POfull = AR.outfile->PObuffer + AR.InInBuf;
259 else AR.outfile->POfull = AR.outfile->POfill;
260 AR.outfile->POfill = AR.outfile->PObuffer;
261 PUTZERO(AR.outfile->POposition);
262 f = AR.outfile; AR.outfile = AR.infile; AR.infile = f;
277 int CoSave(UBYTE *inp)
282 WORD error = 0, type,
number;
283 LONG RetCode = 0, wSize;
287 WORD TMproto[SUBEXPSIZE];
289 int ii, j =
sizeof(
FILEINDEX)/(
sizeof(LONG));
291 while ( *inp ==
',' ) inp++;
295 if( PF.me != MASTER)
return(0);
298 if ( !*p )
return(MesPrint(
"No filename in save statement"));
299 if ( FG.cTable[*p] && ( *p != SEPARATOR ) && ( *p != ALTSEPARATOR ) )
300 return(MesPrint(
"Illegal filename"));
301 while ( *++p && *p !=
',' ) {}
304 if ( !AP.preError ) {
305 if ( ( RetCode = CreateFile((
char *)inp) ) < 0 ) {
306 return(MesPrint(
"Cannot open file %s",inp));
309 AO.SaveData.Handle = (WORD)RetCode;
318 if (
WriteStoreHeader(AO.SaveData.Handle) )
return(MesPrint(
"Error writing storage file header"));
321 lo = (LONG *)(&AO.SaveData.Index);
322 for ( ii = 0; ii < j; ii++ ) *lo++ = 0;
323 SETBASEPOSITION(AO.SaveData.Position,(LONG)
sizeof(
STOREHEADER));
324 ind = AO.SaveData.Index.expression;
325 if ( !AP.preError && WriteFile(AO.SaveData.Handle,(UBYTE *)(&(AO.SaveData.Index))
327 SeekFile(AO.SaveData.Handle,&(filesize),SEEK_END);
331 if ( !FG.cTable[*p] || *p ==
'[' ) {
333 if ( p == 0 )
return(-1);
336 if ( GetVar(inp,&type,&number,CEXPRESSION,NOAUTO) != NAMENOTFOUND ) {
337 if ( e[number].status == STOREDEXPRESSION ) {
343 if ( AP.preError )
goto NextExpr;
344 TMproto[0] = EXPRESSION;
345 TMproto[1] = SUBEXPSIZE;
348 {
int ie;
for ( ie = 4; ie < SUBEXPSIZE; ie++ ) TMproto[ie] = 0; }
350 if ( ( indold = FindInIndex(number,&AR.StoreData,0,0) ) != 0 ) {
355 SeekFile(AO.SaveData.Handle,&(AO.SaveData.Index.next),SEEK_END);
356 scrpos = AO.SaveData.Position;
357 SeekFile(AO.SaveData.Handle,&scrpos,SEEK_SET);
358 if ( ISNOTEQUALPOS(scrpos,AO.SaveData.Position) )
goto SavWrt;
359 if ( WriteFile(AO.SaveData.Handle,(UBYTE *)(&(AO.SaveData.Index))
363 AO.SaveData.Position = AO.SaveData.Index.next;
364 lo = (LONG *)(&AO.SaveData.Index);
365 for ( ii = 0; ii < j; ii++ ) *lo++ = 0;
366 ind = AO.SaveData.Index.expression;
367 scrpos = AO.SaveData.Position;
368 SeekFile(AO.SaveData.Handle,&scrpos,SEEK_SET);
369 if ( ISNOTEQUALPOS(scrpos,AO.SaveData.Position) )
goto SavWrt;
370 if ( WriteFile(AO.SaveData.Handle,(UBYTE *)(&(AO.SaveData.Index))
373 ADDPOS(filesize,
sizeof(
struct FiLeInDeX));
382 SeekFile(AR.StoreData.Handle,&(indold->
variables),SEEK_SET);
383 wSize = TOLONG(AT.WorkTop) - TOLONG(AT.WorkPointer);
386 ADD2POS(filesize,scrpos);
387 SETBASEPOSITION(scrpos1,wSize);
389 if ( ISLESSPOS(scrpos,scrpos1) ) wSize = BASEPOSITION(scrpos);
390 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)AT.WorkPointer,wSize)
392 MesPrint(
"ReadError");
396 if ( WriteFile(AO.SaveData.Handle,(UBYTE *)AT.WorkPointer,wSize)
397 != wSize )
goto SavWrt;
398 ADDPOS(scrpos,-wSize);
399 }
while ( ISPOSPOS(scrpos) );
400 ADDPOS(AO.SaveData.Index.number,1);
407 MesPrint(
"%s is not a stored expression",inp);
413 MesPrint(
"%s is not an expression",inp);
417 if ( c !=
',' && c ) {
418 MesComp(
"Illegal character",inp,p);
425 if ( !AP.preError ) {
426 scrpos = AO.SaveData.Position;
427 SeekFile(AO.SaveData.Handle,&scrpos,SEEK_SET);
428 if ( ISNOTEQUALPOS(scrpos,AO.SaveData.Position) )
goto SavWrt;
431 WriteFile(AO.SaveData.Handle,(UBYTE *)(&(AO.SaveData.Index))
434 else if ( !AP.preError ) {
436 if ( e->status == STOREDEXPRESSION )
break;
438 }
while ( --n > 0 ); }
440 wSize = TOLONG(AT.WorkTop) - TOLONG(AT.WorkPointer);
442 SeekFile(AR.StoreData.Handle,&scrpos,SEEK_SET);
443 scrpos = AR.StoreData.Fill;
444 SETBASEPOSITION(scrpos1,wSize);
446 if ( ISLESSPOS(scrpos,scrpos1) ) wSize = BASEPOSITION(scrpos);
447 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)AT.WorkPointer,wSize) != wSize ) {
448 MesPrint(
"ReadError");
452 if ( WriteFile(AO.SaveData.Handle,(UBYTE *)AT.WorkPointer,wSize) != wSize )
454 ADDPOS(scrpos,-wSize);
455 }
while ( ISPOSPOS(scrpos) );
459 if ( !AP.preError ) {
460 CloseFile(AO.SaveData.Handle);
461 AO.SaveData.Handle = -1;
465 MesPrint(
"WriteError");
475 int CoLoad(UBYTE *inp)
481 WORD num, i, error = 0;
482 WORD type,
number, silentload = 0;
483 WORD TMproto[SUBEXPSIZE];
485 while ( *inp ==
',' ) inp++;
487 if ( ( *p ==
',' && p[1] ==
'-' ) || *p ==
'-' ) {
488 if ( *p ==
',' ) p++;
490 if ( *p ==
's' || *p ==
'S' ) {
492 while ( *p && ( *p !=
',' && *p !=
'-' && *p !=
'+' 493 && *p != SEPARATOR && *p != ALTSEPARATOR ) ) p++;
495 else if ( *p !=
',' ) {
496 return(MesPrint(
"Illegal option in Load statement"));
498 while ( *p ==
',' ) p++;
501 if ( !*p )
return(MesPrint(
"No filename in load statement"));
502 if ( FG.cTable[*p] && ( *p != SEPARATOR ) && ( *p != ALTSEPARATOR ) )
503 return(MesPrint(
"Illegal filename"));
504 while ( *++p && *p !=
',' ) {}
507 if ( ( RetCode = OpenFile((
char *)inp) ) < 0 ) {
508 return(MesPrint(
"Cannot open file %s",inp));
516 AO.SaveData.Handle = (WORD)(RetCode);
518 #ifdef SYSDEPENDENTSAVE 519 if ( ReadFile(AO.SaveData.Handle,(UBYTE *)(&(AO.SaveData.Index)),
523 TELLFILE(AO.SaveData.Handle,&firstposition);
531 if ( !FG.cTable[*p] || *p ==
'[' ) {
533 if ( p == 0 )
return(-1);
536 if ( GetVar(inp,&type,&number,ALLVARIABLES,NOAUTO) != NAMENOTFOUND ) {
537 MesPrint(
"Conflicting name: %s",inp);
541 if ( ( num = EntVar(CEXPRESSION,inp,STOREDEXPRESSION,0,0,0) ) >= 0 ) {
542 TMproto[0] = EXPRESSION;
543 TMproto[1] = SUBEXPSIZE;
546 {
int ie;
for ( ie = 4; ie < SUBEXPSIZE; ie++ ) TMproto[ie] = 0; }
548 SeekFile(AO.SaveData.Handle,&firstposition,SEEK_SET);
549 AO.SaveData.Position = firstposition;
551 if ( ( ind = FindInIndex(num,&AO.SaveData,1,0) ) != 0 ) {
553 if ( PutInStore(ind,num) ) error = -1;
554 else if ( !AM.silent && silentload == 0 )
555 MesPrint(
" %s loaded",ind->name);
560 Expressions[num].counter = -1;
563 MesPrint(
" %s not found",inp);
570 if ( c !=
',' && c ) {
571 MesComp(
"Illegal character",inp,p);
578 scrpos = AR.StoreData.Position;
579 SeekFile(AR.StoreData.Handle,&scrpos,SEEK_SET);
580 if ( ISNOTEQUALPOS(scrpos,AR.StoreData.Position) )
goto LoadWrt;
581 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)(&(AR.StoreData.Index))
585 i = (WORD)BASEPOSITION(AO.SaveData.Index.number);
586 ind = AO.SaveData.Index.expression;
587 #ifdef SYSDEPENDENTSAVE 589 if ( GetVar((UBYTE *)(ind->name),&type,&number,ALLVARIABLES,NOAUTO) != NAMENOTFOUND ) {
590 MesPrint(
"Conflicting name: %s",ind->name);
594 if ( ( num = EntVar(CEXPRESSION,(UBYTE *)(ind->name),STOREDEXPRESSION,0,0,0) ) >= 0 ) {
596 if ( PutInStore(ind,num) ) error = -1;
597 else if ( !AM.silent && silentload == 0 )
598 MesPrint(
" %s loaded",ind->name);
604 if ( i == 0 && ISNOTZEROPOS(AO.SaveData.Index.next) ) {
605 SeekFile(AO.SaveData.Handle,&(AO.SaveData.Index.next),SEEK_SET);
606 if ( ReadFile(AO.SaveData.Handle,(UBYTE *)(&(AO.SaveData.Index)),
608 i = (WORD)BASEPOSITION(AO.SaveData.Index.number);
609 ind = AO.SaveData.Index.expression;
616 if ( GetVar((UBYTE *)(ind->name),&type,&number,ALLVARIABLES,NOAUTO) != NAMENOTFOUND ) {
617 MesPrint(
"Conflicting name: %s",ind->name);
621 if ( ( num = EntVar(CEXPRESSION,(UBYTE *)(ind->name),STOREDEXPRESSION,0,0,0) ) >= 0 ) {
623 if ( PutInStore(ind,num) ) error = -1;
624 else if ( !AM.silent && silentload == 0 )
625 MesPrint(
" %s loaded",ind->name);
631 if ( i == 0 && (ISNOTZEROPOS(AO.SaveData.Index.next) || AO.bufferedInd) ) {
632 SeekFile(AO.SaveData.Handle,&(AO.SaveData.Index.next),SEEK_SET);
634 i = (WORD)BASEPOSITION(AO.SaveData.Index.number);
635 ind = AO.SaveData.Index.expression;
643 #ifndef SYSDEPENDENTSAVE 644 if ( AO.powerFlag ) {
645 MesPrint(
"WARNING: min-/maxpower had to be adjusted!");
647 if ( AO.resizeFlag ) {
648 MesPrint(
"ERROR: could not downsize data!");
652 CloseFile(AO.SaveData.Handle);
653 AO.SaveData.Handle = -1;
654 SeekFile(AR.StoreData.Handle,&(AC.StoreFileSize),SEEK_END);
657 MesPrint(
"WriteError");
661 MesPrint(
"ReadError");
675 WORD DeleteStore(WORD par)
682 if ( AR.StoreData.Handle >= 0 ) {
686 e_in = e_out = Expressions;
688 if ( e_in->status == STOREDEXPRESSION ) {
690 AC.exprnames->namebuffer+e_in->name);
691 node->
type = CDELETE;
695 if ( e_out != e_in ) {
697 node = GetNode(AC.exprnames,
698 AC.exprnames->namebuffer+e_in->name);
699 node->
number = (WORD)(e_out - Expressions);
700 e_out->onfile = e_in->onfile;
701 e_out->printflag = 0;
702 e_out->status = e_in->status;
703 e_out->name = e_in->name;
704 e_out->inmem = e_in->inmem;
710 }
while ( --n > 0 ); }
712 if ( DidClean ) CompactifyTree(AC.exprnames,EXPRNAMES);
714 AR.StoreData.Handle = -1;
715 CloseFile(AC.StoreHandle);
724 SETBASEPOSITION(st->position,-1);
725 SETBASEPOSITION(st->toppos,-1);
729 for ( j = 1; j < AM.totalnumberofthreads; j++ ) {
732 SETBASEPOSITION(st->position,-1);
733 SETBASEPOSITION(st->toppos,-1);
739 PUTZERO(AC.StoreFileSize);
740 s = FG.fname;
while ( *s ) s++;
742 *s =
';'; s[1] =
'*'; s[2] = 0;
746 return(AC.StoreHandle = CreateFile(FG.fname));
766 #ifndef SYSDEPENDENTSAVE 771 newind = NextFileIndex(&(Expressions[num].onfile));
773 #ifndef SYSDEPENDENTSAVE 774 SETBASEPOSITION(newind->length, 0);
776 newind->variables = AR.StoreData.Fill;
777 SeekFile(AR.StoreData.Handle,&(newind->variables),SEEK_SET);
778 if ( ISNOTEQUALPOS(newind->variables,AR.StoreData.Fill) )
goto PutErrS;
779 newind->position = newind->variables;
780 #ifdef SYSDEPENDENTSAVE 785 SeekFile(AO.SaveData.Handle,&scrpos,SEEK_SET);
786 if ( ISNOTEQUALPOS(scrpos,ind->
variables) )
goto PutErrS;
788 wSize = TOLONG(AT.WorkTop) - TOLONG(AT.WorkPointer);
789 #ifdef SYSDEPENDENTSAVE 792 ADD2POS(AR.StoreData.Fill,scrpos);
794 SETBASEPOSITION(scrpos1,wSize);
795 #ifndef SYSDEPENDENTSAVE 798 AO.tensorList = (UBYTE *)Malloc1(MAXSAVEFUNCTION,
"PutInStore");
804 wSize = TOLONG(AT.WorkTop) - TOLONG(AT.WorkPointer);
805 if ( ISLESSPOS(scrpos,scrpos1) ) wSize = BASEPOSITION(scrpos);
808 (UBYTE *)AT.WorkPointer, (UBYTE *)AT.WorkTop, &wSize, &wSizeOut, ind, &stage) ) {
811 if ( WriteFile(AR.StoreData.Handle, (UBYTE *)AT.WorkPointer, wSizeOut)
812 != wSizeOut )
goto PutErrS;
813 ADDPOS(scrpos,-wSize);
814 ADDPOS(newind->position, wSizeOut);
815 ADDPOS(AR.StoreData.Fill, wSizeOut);
816 }
while ( ISPOSPOS(scrpos) );
818 wSize = TOLONG(AT.WorkTop) - TOLONG(AT.WorkPointer);
822 wSize = TOLONG(AT.WorkTop) - TOLONG(AT.WorkPointer);
823 if ( ISLESSPOS(scrpos,scrpos1) ) wSize = BASEPOSITION(scrpos);
824 #ifdef SYSDEPENDENTSAVE 825 if ( ReadFile(AO.SaveData.Handle,(UBYTE *)AT.WorkPointer,wSize)
826 != wSize )
goto PutErrS;
827 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)AT.WorkPointer,wSize)
828 != wSize )
goto PutErrS;
829 ADDPOS(scrpos,-wSize);
833 if (
ReadSaveExpression((UBYTE *)AT.WorkPointer, (UBYTE *)AT.WorkTop, &wSize, &wSizeOut) ) {
837 if ( WriteFile(AR.StoreData.Handle, (UBYTE *)AT.WorkPointer, wSizeOut)
838 != wSizeOut )
goto PutErrS;
839 ADDPOS(scrpos,-wSize);
840 ADDPOS(AR.StoreData.Fill, wSizeOut);
841 ADDPOS(newind->length, wSizeOut);
843 }
while ( ISPOSPOS(scrpos) );
846 M_free(AO.tensorList,
"PutInStore");
848 scrpos = AR.StoreData.Position;
849 SeekFile(AR.StoreData.Handle,&scrpos,SEEK_SET);
850 if ( ISNOTEQUALPOS(scrpos,AR.StoreData.Position) )
goto PutErrS;
851 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)(&AR.StoreData.Index),(LONG)
sizeof(
FILEINDEX))
854 return(MesPrint(
"File error"));
880 WORD GetTerm(
PHEAD WORD *term)
883 WORD *inp, i, j = 0, len;
884 LONG InIn, *whichInInBuf;
885 WORD *r, *m, *mstop = 0, minsiz = 0, *bra = 0, *from;
886 WORD first, *start = 0, testing = 0;
889 if ( AR.GetFile == 2 ) {
891 whichInInBuf = &(AR.InHiBuf);
895 whichInInBuf = &(AR.InInBuf);
897 InIn = *whichInInBuf;
899 if ( AR.KeptInHold ) {
900 r = AR.CompressBuffer;
902 if ( i <= 0 ) { *term = 0;
goto RegRet; }
908 if ( AR.DeferFlag ) {
909 m = AR.CompressBuffer;
912 mstop -= ABS(mstop[-1]);
914 while ( m < mstop ) {
915 if ( *m == HAAKJE ) {
918 bra = (WORD *)(((UBYTE *)(term)) + 2*AM.MaxTer);
919 m = AR.CompressBuffer+1;
921 while ( m < mstop ) *r++ = *m++;
923 minsiz = WORDDIF(mstop,bra);
932 bra = (WORD *)(((UBYTE *)(term)) + 2*AM.MaxTer);
940 r = AR.CompressBuffer;
943 ADDPOS(fi->POposition,(fi->POfull-fi->PObuffer)*
sizeof(WORD));
945 SeekFile(fi->
handle,&(fi->POposition),SEEK_SET);
946 InIn = ReadFile(fi->
handle,(UBYTE *)(fi->PObuffer),fi->POsize);
947 UNLOCK(AS.inputslock);
948 if ( ( InIn < 0 ) || ( InIn & 1 ) ) {
954 InIn /= TABLESIZE(WORD,UBYTE);
956 *whichInInBuf = InIn;
957 if ( !InIn ) { *r = 0; *from = 0;
goto RegRet; }
958 fi->POfill = fi->PObuffer;
959 fi->POfull = fi->PObuffer + InIn;
962 if ( ( len = i = *inp ) == 0 ) {
975 while ( ++i <= 0 ) *term++ = *r++;
980 *(AR.CompressBuffer) = len = *start;
994 *r++ = *term++ = *inp++;
998 ADDPOS(fi->POposition,(fi->POfull-fi->PObuffer)*
sizeof(WORD));
1000 SeekFile(fi->
handle,&(fi->POposition),SEEK_SET);
1001 InIn = ReadFile(fi->
handle,(UBYTE *)(fi->PObuffer),fi->POsize);
1002 UNLOCK(AS.inputslock);
1003 if ( ( InIn <= 0 ) || ( InIn & 1 ) ) {
1009 InIn /= TABLESIZE(WORD,UBYTE);
1012 fi->POfull = inp + InIn;
1018 *(AR.CompressBuffer) = len = *start;
1021 while ( --j >= 0 ) { *r++ = *term++ = *inp++; }
1024 *whichInInBuf = InIn;
1025 AR.DefPosition = fi->POposition;
1026 ADDPOS(AR.DefPosition,((UBYTE *)(fi->POfill)-(UBYTE *)(fi->PObuffer)));
1030 if ( inp >= fi->POfull ) { *from = 0;
goto RegRet; }
1034 *term++ = *r++ = len = - j + 1 + *inp;
1035 while ( ++j <= 0 ) *term++ = *r++;
1038 else if ( !j ) j = 1;
1039 while ( --j >= 0 ) { *r++ = *term++ = *inp++; }
1042 SETBASEPOSITION(AR.DefPosition,((UBYTE *)(fi->POfill)-(UBYTE *)(fi->PObuffer)));
1043 if ( inp > fi->POfull ) {
1047 if ( r >= AR.ComprTop ) {
1048 MesPrint(
"CompressSize of %10l is insufficient",AM.CompressSize);
1051 AR.CompressPointer = r; *r = 0;
1056 if ( testing && *from != 0 ) {
1059 jj = *r - 1 - ABS(*(r+*r-1));
1060 if ( jj < minsiz )
goto strip;
1063 while ( m < mstop ) {
1067 mstop = m - ABS(m[-1]);
1069 while ( r < mstop ) {
1070 if ( *r == HAAKJE ) {
1074 len = WORDDIF(r,from);
1096 if ( ( AP.PreDebug & DUMPINTERMS ) == DUMPINTERMS ) {
1097 MLOCK(ErrorMessageLock);
1098 AO.OutFill = AO.OutputLine = OutBuf;
1103 TokenToLine((UBYTE *)(
"Input: "));
1105 TokenToLine((UBYTE *)
"zero");
1108 TokenToLine((UBYTE *)
"negative!!");
1111 while ( --i >= 0 ) {
1112 TalToLine((UWORD)(*r++)); TokenToLine((UBYTE *)
" ");
1116 MUNLOCK(ErrorMessageLock);
1124 MesPrint(
"Error while reading scratch file in GetTerm");
1160 WORD *r, *rr = AR.CompressPointer;
1175 if ( AT.identity > 0 ) par = 1;
1185 siz = ReadPosFile(BHEAD fi,(UBYTE *)term,1L,pos);
1188 LOCK(AS.inputslock);
1189 SeekFile(fi->
handle,pos,SEEK_SET);
1190 siz = ReadFile(fi->
handle,(UBYTE *)term,
sizeof(WORD));
1191 UNLOCK(AS.inputslock);
1194 if ( siz ==
sizeof(WORD) ) {
1197 if ( ( i > AM.MaxTer/((WORD)
sizeof(WORD)) ) || ( -i >= AM.MaxTer/((WORD)
sizeof(WORD)) ) )
1205 while ( ++i <= 0 ) *term++ = *r++;
1207 siz = ReadPosFile(BHEAD fi,(UBYTE *)term,1L,pos);
1210 LOCK(AS.inputslock);
1211 SeekFile(fi->
handle,pos,SEEK_SET);
1212 siz = ReadFile(fi->
handle,(UBYTE *)term,
sizeof(WORD));
1213 UNLOCK(AS.inputslock);
1214 ADDPOS(*pos,
sizeof(WORD));
1216 if ( siz !=
sizeof(WORD) ) {
1222 if ( ( j > AM.MaxTer/((WORD)
sizeof(WORD)) ) || ( j <= 0 ) )
1230 if ( !j )
return(0);
1235 siz = ReadPosFile(BHEAD fi,(UBYTE *)term,j,pos);
1236 j *= TABLESIZE(WORD,UBYTE);
1239 j *= TABLESIZE(WORD,UBYTE);
1240 LOCK(AS.inputslock);
1241 SeekFile(fi->
handle,pos,SEEK_SET);
1242 siz = ReadFile(fi->
handle,(UBYTE *)term,j);
1243 UNLOCK(AS.inputslock);
1250 while ( --i >= 0 ) *r++ = *term++;
1251 if ( r >= AR.ComprTop ) {
1252 MLOCK(ErrorMessageLock);
1253 MesPrint(
"CompressSize of %10l is insufficient",AM.CompressSize);
1254 MUNLOCK(ErrorMessageLock);
1257 AR.CompressPointer = r; *r = 0;
1266 fi->POfill = (WORD *)((UBYTE *)(fi->PObuffer) + BASEPOSITION(*pos));
1268 if ( p >= fi->POfull ) { *term = 0;
return(0); }
1272 j = *r++ = *term++ = -i + 1 + *p;
1273 while ( ++i <= 0 ) *term++ = *r++;
1276 if ( i == 0 ) { i = 1; *r++ = 0; *term++ = 0; }
1277 else {
while ( --i >= 0 ) { *r++ = *term++ = *p++; } }
1279 SETBASEPOSITION(*pos,(UBYTE *)(fi->POfill)-(UBYTE *)(fi->PObuffer));
1280 if ( p <= fi->POfull ) {
1281 if ( r >= AR.ComprTop ) {
1282 MLOCK(ErrorMessageLock);
1283 MesPrint(
"CompressSize of %10l is insufficient",AM.CompressSize);
1284 MUNLOCK(ErrorMessageLock);
1287 AR.CompressPointer = r; *r = 0;
1293 MLOCK(ErrorMessageLock);
1294 MesPrint(
"Error while reading scratch file in GetOneTerm (%d)",error);
1295 MUNLOCK(ErrorMessageLock);
1312 WORD GetMoreTerms(WORD *term)
1315 WORD *t, *r, *m, *h, *tstop, i, inc, same;
1321 extra = ((AM.MaxTer/
sizeof(WORD))*((LONG)100-AC.CollectPercentage))/100;
1322 if ( extra < 23 ) extra = 23;
1327 tstop = t - ABS(t[-1]);
1329 while ( *h != HAAKJE && h < tstop ) h += h[1];
1330 if ( h >= tstop )
return(retval);
1331 inc = FUNHEAD+ARGHEAD+1-h[1];
1332 same = WORDDIF(h,term) + h[1] - 1;
1335 while ( t > tstop ) *--r = *--t;
1338 while ( GetTerm(BHEAD m) > 0 ) {
1341 if ( same > ( i = ( *m - ABS(*t) -1 ) ) ) {
1342 if ( AC.AltCollectFun && AS.CollectOverFlag == 2 ) AS.CollectOverFlag = 3;
1347 while ( --i >= 0 ) {
1349 if ( AC.AltCollectFun && AS.CollectOverFlag == 2 ) AS.CollectOverFlag = 3;
1354 if ( ( WORDDIF(m,term) + i + extra ) > (WORD)(AM.MaxTer/
sizeof(WORD)) ) {
1356 if ( AS.CollectOverFlag == 0 && AC.AltCollectFun == 0 ) {
1357 Warning(
"Bracket contents too long in Collect statement");
1358 Warning(
"Contents spread over more than one term");
1359 Warning(
"If possible: increase MaxTermSize in setfile");
1360 AS.CollectOverFlag = 1;
1362 else if ( AC.AltCollectFun ) {
1363 AS.CollectOverFlag = 2;
1370 while ( r < tstop ) *m++ = *r++;
1372 if ( extra == 23 ) extra = ((AM.MaxTer/
sizeof(WORD))/6);
1375 h[1] = WORDDIF(m,h);
1376 if ( AS.CollectOverFlag > 1 ) {
1377 *h = AC.AltCollectFun;
1378 if ( AS.CollectOverFlag == 3 ) AS.CollectOverFlag = 1;
1380 else *h = AC.CollectFun;
1382 h[FUNHEAD] = h[1] - FUNHEAD;
1384 if ( ToFast(h+FUNHEAD,h+FUNHEAD) ) {
1385 if ( h[FUNHEAD] <= -FUNCTION ) {
1397 *term = WORDDIF(m,term);
1408 WORD GetMoreFromMem(WORD *term, WORD **tpoin)
1411 WORD *t, *r, *m, *h, *tstop, i, j, inc, same;
1417 tstop = t - ABS(t[-1]);
1419 while ( *h != HAAKJE && h < tstop ) h += h[1];
1420 if ( h >= tstop )
return(0);
1421 inc = FUNHEAD+ARGHEAD+1-h[1];
1422 same = WORDDIF(h,term) + h[1] - 1;
1425 while ( t > tstop ) *--r = *--t;
1430 for ( i = 0; i < j; i++ ) m[i] = *r++;
1434 if ( same > ( i = ( *m - ABS(*t) -1 ) ) ) {
1435 if ( AC.AltCollectFun && AS.CollectOverFlag == 2 ) AS.CollectOverFlag = 3;
1440 while ( --i >= 0 ) {
1442 if ( AC.AltCollectFun && AS.CollectOverFlag == 2 ) AS.CollectOverFlag = 3;
1447 if ( ( WORDDIF(m,term) + i + extra ) > (LONG)(AM.MaxTer/(2*
sizeof(WORD))) ) {
1449 if ( AS.CollectOverFlag == 0 && AC.AltCollectFun == 0 ) {
1450 Warning(
"Bracket contents too long in Collect statement");
1451 Warning(
"Contents spread over more than one term");
1452 Warning(
"If possible: increase MaxTermSize in setfile");
1453 AS.CollectOverFlag = 1;
1455 else if ( AC.AltCollectFun ) {
1456 AS.CollectOverFlag = 2;
1463 while ( r < tstop ) *m++ = *r++;
1464 if ( extra == 23 ) extra = ((AM.MaxTer/
sizeof(WORD))/6);
1467 h[1] = WORDDIF(m,h);
1468 if ( AS.CollectOverFlag > 1 ) {
1469 *h = AC.AltCollectFun;
1470 if ( AS.CollectOverFlag == 3 ) AS.CollectOverFlag = 1;
1472 else *h = AC.CollectFun;
1474 h[FUNHEAD] = h[1] - FUNHEAD;
1476 if ( ToFast(h+FUNHEAD,h+FUNHEAD) ) {
1477 if ( h[FUNHEAD] <= -FUNCTION ) {
1489 *term = WORDDIF(m,term);
1515 WORD GetFromStore(WORD *to,
POSITION *position,
RENUMBER renumber, WORD *InCompState, WORD nexpr)
1518 LONG RetCode, num, first = 0;
1523 WORD *r, *rr = AR.CompressPointer;
1526 sc.next = AT.StoreCache;
1533 if ( BASEPOSITION(s->position) == -1 )
break;
1534 if ( ISLESSPOS(*position,s->toppos) &&
1535 ISGEPOS(*position,s->position) ) {
1536 if ( AT.StoreCache != s ) {
1537 sold->next = s->next;
1538 s->next = AT.StoreCache->next;
1541 from = (WORD *)(((UBYTE *)(s->buffer)) + DIFBASE(*position,s->position));
1543 if ( !num ) {
return(*to = 0); }
1544 *InCompState = (WORD)num;
1548 ADDPOS(*position,
sizeof(WORD));
1549 *m++ = (WORD)(-num+1);
1551 while ( ++num <= 0 ) *m++ = *r++;
1552 if ( ISLESSPOS(*position,s->toppos) ) {
1555 ADDPOS(*position,
sizeof(WORD));
1556 *InCompState = (WORD)(num + 2);
1564 while ( num > 0 && ISLESSPOS(*position,s->toppos) ) {
1565 *r++ = *m++ = *from++; ADDPOS(*position,
sizeof(WORD)); num--;
1569 SETBASEPOSITION(s->position,-1);
1570 SETBASEPOSITION(s->toppos,-1);
1571 LOCK(AM.storefilelock);
1572 SeekFile(AR.StoreData.Handle,position,SEEK_SET);
1573 RetCode = ReadFile(AR.StoreData.Handle,(UBYTE *)(s->buffer),AM.SizeStoreCache);
1574 UNLOCK(AM.storefilelock);
1575 if ( RetCode < 0 )
goto PastErr;
1576 if ( !RetCode )
return( *to = 0 );
1577 s->position = *position;
1578 s->toppos = *position;
1579 ADDPOS(s->toppos,RetCode);
1583 ADDPOS(*position,
sizeof(WORD));
1586 *InCompState = (WORD)(num + 2);
1593 if ( AT.StoreCache ) {
1594 s->position = *position;
1595 LOCK(AM.storefilelock);
1596 SeekFile(AR.StoreData.Handle,position,SEEK_SET);
1597 RetCode = ReadFile(AR.StoreData.Handle,(UBYTE *)(s->buffer),AM.SizeStoreCache);
1598 UNLOCK(AM.storefilelock);
1599 if ( RetCode < 0 )
goto PastErr;
1600 if ( !RetCode )
return( *to = 0 );
1601 s->toppos = *position;
1602 ADDPOS(s->toppos,RetCode);
1603 if ( AT.StoreCache != s ) {
1604 sold->next = s->next;
1605 s->next = AT.StoreCache->next;
1611 if ( !num ) {
return( *to = 0 ); }
1612 *InCompState = (WORD)num;
1614 *m++ = (WORD)(-num+1);
1617 ADDPOS(*position,
sizeof(WORD));
1618 while ( ++num <= 0 ) *m++ = *r++;
1621 ADDPOS(*position,
sizeof(WORD));
1622 *InCompState = (WORD)(num+2);
1627 LOCK(AM.storefilelock);
1628 SeekFile(AR.StoreData.Handle,position,SEEK_SET);
1629 RetCode = ReadFile(AR.StoreData.Handle,(UBYTE *)to,(LONG)
sizeof(WORD));
1630 SeekFile(AR.StoreData.Handle,position,SEEK_CUR);
1631 UNLOCK(AM.storefilelock);
1632 if ( RetCode !=
sizeof(WORD) ) {
1634 return((WORD)RetCode);
1636 if ( !*to )
return(0);
1640 *to = *r++ = (WORD)(-num + 1);
1641 while ( ++num <= 0 ) *m++ = *r++;
1642 LOCK(AM.storefilelock);
1643 SeekFile(AR.StoreData.Handle,position,SEEK_SET);
1644 RetCode = ReadFile(AR.StoreData.Handle,(UBYTE *)m,(LONG)
sizeof(WORD));
1645 SeekFile(AR.StoreData.Handle,position,SEEK_CUR);
1646 UNLOCK(AM.storefilelock);
1647 if ( RetCode !=
sizeof(WORD) ) {
1648 MLOCK(ErrorMessageLock);
1649 MesPrint(
"@Error in compression of store file");
1650 MUNLOCK(ErrorMessageLock);
1655 *InCompState = (WORD)(num + 2);
1659 num = *to - 1; m = to + 1; r = rr + 1;
1662 num *= wsizeof(WORD);
1664 MLOCK(ErrorMessageLock);
1665 MesPrint(
"@Error in stored expressions file at position %9p",position);
1666 MUNLOCK(ErrorMessageLock);
1669 LOCK(AM.storefilelock);
1670 SeekFile(AR.StoreData.Handle,position,SEEK_SET);
1671 RetCode = ReadFile(AR.StoreData.Handle,(UBYTE *)m,num);
1672 SeekFile(AR.StoreData.Handle,position,SEEK_CUR);
1673 UNLOCK(AM.storefilelock);
1674 if ( RetCode != num ) {
1675 MLOCK(ErrorMessageLock);
1676 MesPrint(
"@Error in stored expressions file at position %9p",position);
1677 MUNLOCK(ErrorMessageLock);
1683 if ( r >= AR.ComprTop ) {
1684 MLOCK(ErrorMessageLock);
1685 MesPrint(
"CompressSize of %10l is insufficient",AM.CompressSize);
1686 MUNLOCK(ErrorMessageLock);
1689 AR.CompressPointer = r; *r = 0;
1691 MarkDirty(to,DIRTYSYMFLAG);
1692 if ( AR.CurDum > AM.IndDum && Expressions[nexpr].numdummies > 0 )
1693 MoveDummies(BHEAD to,AR.CurDum - AM.IndDum);
1697 MLOCK(ErrorMessageLock);
1698 MesCall(
"GetFromStore");
1699 MUNLOCK(ErrorMessageLock);
1714 VOID DetVars(WORD *term, WORD par)
1720 stopper = term + *term - 1;
1721 stopper = stopper - ABS(*stopper) + 1;
1725 if ( ( n = NumSymbols ) > 0 ) {
1730 }
while ( --n > 0 );
1732 if ( ( n = NumIndices ) > 0 ) {
1737 }
while ( --n > 0 );
1739 if ( ( n = NumVectors ) > 0 ) {
1744 }
while ( --n > 0 );
1746 if ( ( n = NumFunctions ) > 0 ) {
1751 }
while ( --n > 0 );
1754 while ( term < stopper ) {
1755 if ( *term == SYMTOSYM || *term == SYMTONUM ) {
1757 AN.UsedSymbol[*term] = 1;
1758 symbols[*term].flags = 1;
1760 else if ( *term == VECTOVEC ) {
1762 AN.UsedVector[*term-AM.OffsetVector] = 1;
1763 vectors[*term-AM.OffsetVector].flags = 1;
1765 else if ( *term == INDTOIND ) {
1767 sym = indices[*term - AM.OffsetIndex].dimension;
1768 if ( sym < 0 ) AN.UsedSymbol[-sym] = 1;
1769 AN.UsedIndex[(*term) - AM.OffsetIndex] = 1;
1770 sym = indices[*term-AM.OffsetIndex].nmin4;
1771 if ( sym < -NMIN4SHIFT ) AN.UsedSymbol[-sym-NMIN4SHIFT] = 1;
1772 indices[*term-AM.OffsetIndex].flags = 1;
1774 else if ( *term == FUNTOFUN ) {
1776 AN.UsedFunction[*term-FUNCTION] = 1;
1777 functions[*term-FUNCTION].flags = 1;
1783 while ( term < stopper ) {
1785 if ( *term == SYMBOL ) {
1788 AN.UsedSymbol[*term] = 1;
1790 }
while ( term < t );
1792 else if ( *term == DOTPRODUCT ) {
1795 AN.UsedVector[(*term++) - AM.OffsetVector] = 1;
1796 AN.UsedVector[(*term) - AM.OffsetVector] = 1;
1798 }
while ( term < t );
1800 else if ( *term == VECTOR ) {
1803 AN.UsedVector[(*term++) - AM.OffsetVector] = 1;
1804 if ( *term >= AM.OffsetIndex && *term < AM.DumInd ) {
1805 sym = indices[*term - AM.OffsetIndex].dimension;
1806 if ( sym < 0 ) AN.UsedSymbol[-sym] = 1;
1807 AN.UsedIndex[*term - AM.OffsetIndex] = 1;
1808 sym = indices[(*term++)-AM.OffsetIndex].nmin4;
1809 if ( sym < -NMIN4SHIFT ) AN.UsedSymbol[-sym-NMIN4SHIFT] = 1;
1812 }
while ( term < t );
1814 else if ( *term == INDEX || *term == LEVICIVITA || *term == GAMMA
1815 || *term == DELTA ) {
1820 if ( *term == INDEX || *term == DELTA ) term += 2;
1825 while ( term < t ) {
1826 if ( *term >= AM.OffsetIndex && *term < AM.DumInd ) {
1827 sym = indices[*term - AM.OffsetIndex].dimension;
1828 if ( sym < 0 ) AN.UsedSymbol[-sym] = 1;
1829 AN.UsedIndex[(*term) - AM.OffsetIndex] = 1;
1830 sym = indices[*term-AM.OffsetIndex].nmin4;
1831 if ( sym < -NMIN4SHIFT ) AN.UsedSymbol[-sym-NMIN4SHIFT] = 1;
1833 else if ( *term < (WILDOFFSET+AM.OffsetVector) )
1834 AN.UsedVector[(*term) - AM.OffsetVector] = 1;
1838 else if ( *term == HAAKJE ) term = t;
1840 if ( *term > MAXBUILTINFUNCTION )
1841 AN.UsedFunction[(*term)-FUNCTION] = 1;
1842 if ( *term >= FUNCTION && functions[*term-FUNCTION].spec
1843 >= TENSORFUNCTION && term[1] > FUNHEAD )
goto Tensors;
1845 while ( term < t ) {
1849 sarg = term + *term;
1851 if ( term < sarg ) {
do {
1854 }
while ( term < sarg ); }
1857 if ( *term < -MAXBUILTINFUNCTION ) {
1858 AN.UsedFunction[-*term-FUNCTION] = 1;
1860 else if ( *term == -SYMBOL ) {
1861 AN.UsedSymbol[term[1]] = 1;
1863 else if ( *term == -INDEX ) {
1864 if ( term[1] < (WILDOFFSET+AM.OffsetVector) ) {
1865 AN.UsedVector[term[1]-AM.OffsetVector] = 1;
1867 else if ( term[1] >= AM.OffsetIndex && term[1] < AM.DumInd ) {
1868 sym = indices[term[1] - AM.OffsetIndex].dimension;
1869 if ( sym < 0 ) AN.UsedSymbol[-sym] = 1;
1870 AN.UsedIndex[term[1] - AM.OffsetIndex] = 1;
1871 sym = indices[term[1]-AM.OffsetIndex].nmin4;
1872 if ( sym < -NMIN4SHIFT ) AN.UsedSymbol[-sym-NMIN4SHIFT] = 1;
1875 else if ( *term == -VECTOR || *term == -MINVECTOR ) {
1876 AN.UsedVector[term[1]-AM.OffsetVector] = 1;
1910 if ( ( indexent = NextFileIndex(&indexpos) ) == 0 ) {
1911 MesCall(
"ToStorage");
1915 f = AR.infile; AR.infile = AR.outfile; AR.outfile = f;
1916 if ( e->status == HIDDENGEXPRESSION ) {
1917 AR.InHiBuf = 0; f = AR.hidefile; AR.GetFile = 2;
1920 AR.InInBuf = 0; f = AR.infile; AR.GetFile = 0;
1924 SeekFile(f->
handle,&scrpos,SEEK_SET);
1925 if ( ISNOTEQUALPOS(scrpos,e->onfile) ) {
1926 MesPrint(
":::Error in Scratch file");
1929 f->POposition = e->onfile;
1930 f->POfull = f->PObuffer;
1931 if ( e->status == HIDDENGEXPRESSION ) AR.InHiBuf = 0;
1932 else AR.InInBuf = 0;
1935 f->POfill = (WORD *)((UBYTE *)(f->PObuffer)+BASEPOSITION(e->onfile));
1938 AN.UsedSymbol = w; w += NumSymbols;
1939 AN.UsedVector = w; w += NumVectors;
1940 AN.UsedIndex = w; w += NumIndices;
1941 AN.UsedFunction = w; w += NumFunctions;
1943 w = (WORD *)(((UBYTE *)(w)) + AM.MaxTer);
1944 if ( w > AT.WorkTop ) {
1949 i = NumSymbols + NumVectors + NumIndices + NumFunctions;
1950 do { *w++ = 0; }
while ( --i > 0 );
1951 if ( GetTerm(BHEAD term) > 0 ) {
1953 if ( GetTerm(BHEAD term) ) {
1954 do { DetVars(term,0); }
while ( GetTerm(BHEAD term) > 0 );
1960 while ( --i >= 0 ) {
if ( *w++ ) j++; }
1966 while ( --i >= 0 ) {
if ( *w++ ) j++; }
1972 while ( --i >= 0 ) {
if ( *w++ ) j++; }
1976 w = AN.UsedFunction;
1978 while ( --i >= 0 ) {
if ( *w++ ) j++; }
1981 indexent->
length = *length;
1982 indexent->
variables = AR.StoreData.Fill;
1984 StrCopy(AC.exprnames->namebuffer+e->name,(UBYTE *)(indexent->
name));
1985 SeekFile(AR.StoreData.Handle,&(AR.StoreData.Fill),SEEK_SET);
1987 AO.wpos = (UBYTE *)Malloc1(AO.wlen,
"AO.wpos buffer");
1995 while ( --i >= 0 ) {
1996 while ( !*w ) { w++; a++; j++; }
1998 if ( VarStore((UBYTE *)a,(WORD)(
sizeof(
struct SyMbOl)),a->name,
1999 a->namesize) )
goto ErrToSto;
2009 while ( --i >= 0 ) {
2010 while ( !*w ) { w++; a++; j++; }
2012 if ( VarStore((UBYTE *)a,(WORD)(
sizeof(
struct InDeX)),a->name,
2013 a->namesize) )
goto ErrToSto;
2023 while ( --i >= 0 ) {
2024 while ( !*w ) { w++; a++; j++; }
2026 if ( VarStore((UBYTE *)a,(WORD)(
sizeof(
struct VeCtOr)),a->name,
2027 a->namesize) )
goto ErrToSto;
2033 w = AN.UsedFunction;
2037 while ( --i >= 0 ) {
2038 while ( !*w ) { w++; a++; j++; }
2040 if ( VarStore((UBYTE *)a,(WORD)(
sizeof(
struct FuNcTiOn)),a->
name,
2045 if ( VarStore((UBYTE *)0L,(WORD)0,(WORD)0,(WORD)0) )
goto ErrToSto;
2046 TELLFILE(AR.StoreData.Handle,&(indexent->
position));
2055 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)(&(e->numdummies)),(LONG)
sizeof(WORD)) !=
2057 MesPrint(
"Error while writing storage file");
2060 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)(&(e->numfactors)),(LONG)
sizeof(WORD)) !=
2062 MesPrint(
"Error while writing storage file");
2065 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)(&(e->vflags)),(LONG)
sizeof(WORD)) !=
2067 MesPrint(
"Error while writing storage file");
2070 TELLFILE(AR.StoreData.Handle,&(indexent->
position));
2074 SeekFile(f->
handle,&(e->onfile),SEEK_SET);
2075 while ( ISPOSPOS(llength) ) {
2076 SETBASEPOSITION(scrpos,AO.wlen);
2077 if ( ISLESSPOS(llength,scrpos) ) size = BASEPOSITION(llength);
2078 else size = AO.wlen;
2079 if ( ReadFile(f->
handle,AO.wpos,size) != size ) {
2080 MesPrint(
"Error while reading scratch file");
2083 if ( WriteFile(AR.StoreData.Handle,AO.wpos,size) != size ) {
2084 MesPrint(
"Error while writing storage file");
2087 ADDPOS(llength,-size);
2092 ppp = (WORD *)((UBYTE *)(f->PObuffer) + BASEPOSITION(e->onfile));
2093 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)ppp,BASEPOSITION(*length)) !=
2094 BASEPOSITION(*length) ) {
2095 MesPrint(
"Error while writing storage file");
2099 ADD2POS(*length,indexent->
position);
2100 e->onfile = indexpos;
2104 AR.StoreData.Fill = *length;
2105 SeekFile(AR.StoreData.Handle,&(AR.StoreData.Fill),SEEK_SET);
2106 scrpos = AR.StoreData.Position;
2108 SeekFile(AR.StoreData.Handle,&scrpos,SEEK_SET);
2109 if ( WriteFile(AR.StoreData.Handle,((UBYTE *)&(AR.StoreData.Index.number))
2111 SeekFile(AR.StoreData.Handle,&indexpos,SEEK_SET);
2112 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)indexent,(LONG)(
sizeof(
INDEXENTRY))) !=
2114 FlushFile(AR.StoreData.Handle);
2115 SeekFile(AR.StoreData.Handle,&(AC.StoreFileSize),SEEK_END);
2116 f = AR.infile; AR.infile = AR.outfile; AR.outfile = f;
2117 if ( AO.wpos ) M_free(AO.wpos,
"AO.wpos buffer");
2118 AO.wpos = AO.wpoin = 0;
2121 MesPrint(
"---Error while storing namelists");
2124 MesPrint(
"Error in storage");
2126 if ( AO.wpos ) M_free(AO.wpos,
"AO.wpos buffer");
2127 AO.wpos = AO.wpoin = 0;
2128 f = AR.infile; AR.infile = AR.outfile; AR.outfile = f;
2141 int i, j =
sizeof(
FILEINDEX)/(
sizeof(LONG));
2143 if ( AR.StoreData.Handle <= 0 ) {
2145 MesCall(
"NextFileIndex");
2148 SETBASEPOSITION(AR.StoreData.Index.number,1);
2149 #ifdef SYSDEPENDENTSAVE 2150 SETBASEPOSITION(*indexpos,(2*
sizeof(
POSITION)));
2154 return(AR.StoreData.Index.expression);
2156 while ( BASEPOSITION(AR.StoreData.Index.number) >= (LONG)(
INFILEINDEX) ) {
2157 if ( ISNOTZEROPOS(AR.StoreData.Index.next) ) {
2158 SeekFile(AR.StoreData.Handle,&(AR.StoreData.Index.next),SEEK_SET);
2159 AR.StoreData.Position = AR.StoreData.Index.next;
2160 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)(&AR.StoreData.Index),(LONG)(
sizeof(
FILEINDEX))) !=
2161 (LONG)(
sizeof(
FILEINDEX)) )
goto ErrNextS;
2164 PUTZERO(AR.StoreData.Index.number);
2165 SeekFile(AR.StoreData.Handle,&(AR.StoreData.Position),SEEK_SET);
2166 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)(&(AR.StoreData.Fill)),(LONG)(
sizeof(
POSITION)))
2167 != (LONG)(
sizeof(
POSITION)) )
goto ErrNextS;
2168 PUTZERO(AR.StoreData.Index.next);
2169 SeekFile(AR.StoreData.Handle,&(AR.StoreData.Fill),SEEK_SET);
2170 AR.StoreData.Position = AR.StoreData.Fill;
2171 lo = (LONG *)(&AR.StoreData.Index);
2172 for ( i = 0; i < j; i++ ) *lo++ = 0;
2173 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)(&AR.StoreData.Index),(LONG)(
sizeof(
FILEINDEX))) !=
2174 (LONG)(
sizeof(
FILEINDEX)) )
goto ErrNextS;
2175 ADDPOS(AR.StoreData.Fill,
sizeof(
FILEINDEX));
2178 *indexpos = AR.StoreData.Position;
2179 ADDPOS(*indexpos,(2*
sizeof(
POSITION)) +
2180 BASEPOSITION(AR.StoreData.Index.number) *
sizeof(
INDEXENTRY));
2181 ind = &AR.StoreData.Index.expression[BASEPOSITION(AR.StoreData.Index.number)];
2182 ADDPOS(AR.StoreData.Index.number,1);
2185 MesPrint(
"Error in storage file");
2203 int i, j =
sizeof(
FILEINDEX)/(
sizeof(LONG));
2205 if ( AR.StoreData.Handle < 0 ) {
2206 AR.StoreData.Handle = AC.StoreHandle;
2207 PUTZERO(AR.StoreData.Index.next);
2208 PUTZERO(AR.StoreData.Index.number);
2209 #ifdef SYSDEPENDENTSAVE 2210 SETBASEPOSITION(AR.StoreData.Fill,
sizeof(
FILEINDEX));
2212 if (
WriteStoreHeader(AR.StoreData.Handle) )
return(MesPrint(
"Error writing storage file header"));
2215 lo = (LONG *)(&AR.StoreData.Index);
2216 for ( i = 0; i < j; i++ ) *lo++ = 0;
2217 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)(&AR.StoreData.Index),(LONG)(
sizeof(
FILEINDEX))) !=
2218 (LONG)(
sizeof(
FILEINDEX)) )
return(MesPrint(
"Error writing storage file"));
2222 #ifdef SYSDEPENDENTSAVE 2225 SETBASEPOSITION(scrpos, (LONG)(
sizeof(
STOREHEADER)));
2227 SeekFile(AR.StoreData.Handle,&scrpos,SEEK_SET);
2228 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)(&AR.StoreData.Index),(LONG)(
sizeof(
FILEINDEX))) !=
2229 (LONG)(
sizeof(
FILEINDEX)) )
return(MesPrint(
"Error reading storage file"));
2231 #ifdef SYSDEPENDENTSAVE 2232 PUTZERO(AR.StoreData.Position);
2234 SETBASEPOSITION(AR.StoreData.Position, (LONG)(
sizeof(
STOREHEADER)));
2249 WORD VarStore(UBYTE *s, WORD n, WORD name, WORD namesize)
2255 t = (UBYTE *)AO.wpoin;
2259 u = AO.wpos+AO.wlen;
2260 while ( n > 0 && t < u ) { *t++ = *s++; n--; }
2262 if ( WriteFile(AR.StoreData.Handle,AO.wpos,AO.wlen) != AO.wlen )
return(-1);
2264 while ( n > 0 && t < u ) { *t++ = *s++; n--; }
2266 s = AC.varnames->namebuffer + name;
2268 n +=
sizeof(
void *)-1; n &= -(
sizeof(
void *));
2271 while ( n > 0 && t < u ) {
2272 if ( namesize > 0 ) { *t++ = *s++; namesize--; }
2277 if ( WriteFile(AR.StoreData.Handle,AO.wpos,AO.wlen) != AO.wlen )
return(-1);
2279 while ( n > 0 && t < u ) {
2280 if ( namesize > 0 ) { *t++ = *s++; namesize--; }
2289 size = AO.wpoin - AO.wpos;
2290 if ( WriteFile(AR.StoreData.Handle,AO.wpos,size) != size )
return(-1);
2315 stopper = term + *term - 1;
2316 stopper = stopper - ABS(*stopper) + 1;
2318 while ( term < stopper ) {
2322 if ( *term == SYMBOL ) {
2326 if ( ( n = FindrNumber(*term,&(renumber->
symb)) ) < 0 )
goto ErrR;
2327 *term = renumber->
symnum[n];
2329 }
while ( term < t );
2331 else if ( *term == DOTPRODUCT ) {
2335 if ( ( n = FindrNumber(*term,&(renumber->
vect)) )
2337 *term++ = renumber->
vecnum[n];
2338 if ( ( n = FindrNumber(*term,&(renumber->
vect)) )
2340 *term = renumber->
vecnum[n];
2342 }
while ( term < t );
2344 else if ( *term == VECTOR ) {
2348 if ( ( n = FindrNumber(*term,&(renumber->
vect)) )
2350 *term++ = renumber->
vecnum[n];
2351 if ( ( *term >= AM.OffsetIndex ) && ( *term < AM.IndDum ) ) {
2352 if ( ( n = FindrNumber(*term,&(renumber->
indi)) )
2354 *term++ = renumber->
indnum[n];
2357 }
while ( term < t );
2359 else if ( *term == INDEX || *term == LEVICIVITA || *term == GAMMA
2360 || *term == DELTA ) {
2363 if ( *term == INDEX || * term == DELTA ) term += 2;
2364 else term += FUNHEAD;
2368 while ( term < t ) {
2369 if ( *term >= AM.OffsetIndex + WILDOFFSET ) {
2374 else if ( ( *term >= AM.OffsetIndex ) && ( *term < AM.IndDum ) ) {
2375 if ( ( n = FindrNumber(*term,&(renumber->
indi)) )
2377 *term = renumber->
indnum[n];
2379 else if ( *term < (WILDOFFSET+AM.OffsetVector) ) {
2380 if ( ( n = FindrNumber(*term,&(renumber->
vect)) )
2382 *term = renumber->
vecnum[n];
2387 else if ( *term == HAAKJE ) term += term[1];
2389 if ( *term > MAXBUILTINFUNCTION ) {
2390 if ( ( n = FindrNumber(*term,&(renumber->
func)) )
2392 *term = renumber->
funnum[n];
2394 if ( *term >= FUNCTION && functions[*term-FUNCTION].spec
2395 >= TENSORFUNCTION && term[1] > FUNHEAD )
goto Tensors;
2398 while ( term < t ) {
2409 while ( term < sarg ) {
2415 if ( *term <= -MAXBUILTINFUNCTION ) {
2416 if ( ( n = FindrNumber(-*term,&(renumber->
func)) )
2418 *term = -renumber->
funnum[n];
2420 else if ( *term == -SYMBOL ) {
2422 if ( ( n = FindrNumber(*term,
2423 &(renumber->
symb)) ) < 0 )
goto ErrR;
2424 *term = renumber->
symnum[n];
2426 else if ( *term == -INDEX ) {
2428 if ( *term >= AM.OffsetIndex + WILDOFFSET ) {
2433 else if ( ( *term >= AM.OffsetIndex ) && ( *term < AM.IndDum ) ) {
2434 if ( ( n = FindrNumber(*term,&(renumber->
indi)) )
2436 *term = renumber->
indnum[n];
2438 else if ( *term < (WILDOFFSET+AM.OffsetVector) ) {
2439 if ( ( n = FindrNumber(*term,&(renumber->
vect)) )
2441 *term = renumber->
vecnum[n];
2444 else if ( *term == -VECTOR || *term == -MINVECTOR ) {
2446 if ( ( n = FindrNumber(*term,&(renumber->
vect)) )
2448 *term = renumber->
vecnum[n];
2458 MesCall(
"TermRenumber");
2467 WORD FindrNumber(WORD n,
VARRENUM *v)
2475 MesPrint(
"Serious problems coming up in FindrNumber");
2480 while ( *med != n ) {
2482 if ( med == hi )
goto ErrFindr;
2484 med = hi - ((WORDDIF(hi,med))/2);
2487 if ( med == lo )
goto ErrFindr;
2489 med = lo + ((WORDDIF(med,lo))/2);
2492 return(WORDDIF(med,v->
lo));
2499 i = WORDDIF(v->
hi,v->
lo);
2500 MesPrint(
"FindrNumber: n = %d, list has %d members",n,i);
2502 MesPrint(
"v->lo[%d] = %d",i,v->
lo[i]); i--;
2507 MesPrint(
"Start with %d,%d,%d",0,WORDDIF(med,v->
lo),WORDDIF(hi,v->
lo));
2508 while ( *med != n ) {
2510 if ( med == hi )
goto ErrFindr2;
2512 med = hi - ((WORDDIF(hi,med))/2);
2515 if ( med == lo )
goto ErrFindr2;
2517 med = ((WORDDIF(med,lo))/2) + lo;
2519 MesPrint(
"New: %d,%d,%d, *med = %d",WORDDIF(lo,v->
lo),WORDDIF(med,v->
lo),WORDDIF(hi,v->
lo),*med);
2522 return(WORDDIF(med,v->
lo));
2524 return(MesPrint(
"Renumbering problems"));
2549 WORD *start, *stop, *stop2, *m2, nomatch = 0;
2550 POSITION stindex, indexpos, scrpos;
2552 stindex = f->Position;
2557 while ( m < stop ) {
2558 if ( *m == FROMBRAC || *m == WILDCARDS )
break;
2562 if ( !par ) hand = AR.StoreData.Handle;
2563 else hand = AO.SaveData.Handle;
2565 if ( ( i = (WORD)BASEPOSITION(f->Index.
number) ) != 0 ) {
2566 indexpos = f->Position;
2567 ADDPOS(indexpos,(2*
sizeof(
POSITION)));
2570 if ( ( !par && ISEQUALPOS(indexpos,Expressions[expr].onfile) )
2571 || ( par && !StrCmp(EXPRNAME(expr),(UBYTE *)(ind->name)) ) ) {
2583 if ( par )
return(ind);
2584 scrpos = ind->position;
2585 SeekFile(hand,&scrpos,SEEK_SET);
2586 if ( ISNOTEQUALPOS(scrpos,ind->position) )
goto ErrGt2;
2587 if ( ReadFile(hand,(UBYTE *)AT.WorkPointer,(LONG)
sizeof(WORD)) !=
2588 sizeof(WORD) || !*AT.WorkPointer )
goto ErrGt2;
2589 num = *AT.WorkPointer - 1;
2590 num *= wsizeof(WORD);
2591 if ( *AT.WorkPointer < 0 ||
2592 ReadFile(hand,(UBYTE *)(AT.WorkPointer+1),num) != num )
goto ErrGt2;
2594 m2 = AT.WorkPointer + 1;
2597 while ( m < stop && m2 < stop2 ) {
2598 if ( *m == SYMBOL ) {
2599 if ( *m2 != SYMTOSYM )
break;
2602 else if ( *m == INDEX ) {
2604 if ( *m2 != INDTOIND )
break;
2607 if ( *m2 != VECTOVEC )
break;
2611 else if ( *m >= FUNCTION ) {
2612 if ( *m2 != FUNTOFUN )
break;
2619 if ( ( m >= stop && m2 >= stop2 ) || mode == 0 ) {
2620 AT.WorkPointer = stop2;
2627 }
while ( --i > 0 );
2629 f->Position = f->Index.
next;
2630 #ifndef SYSDEPENDENTSAVE 2631 if ( !ISNOTZEROPOS(f->Position) ) ADDPOS(f->Position,
sizeof(
STOREHEADER));
2634 if ( ISEQUALPOS(f->Position,stindex) && !AO.bufferedInd )
goto ErrGetTab;
2636 SeekFile(AR.StoreData.Handle,&(f->Position),SEEK_SET);
2637 if ( ISNOTEQUALPOS(f->Position,AR.StoreData.Position) )
goto ErrGt2;
2638 #ifndef SYSDEPENDENTSAVE 2639 if ( ReadFile(f->Handle, (UBYTE *)(&(f->Index)), number) != number )
goto ErrGt2;
2643 SeekFile(AO.SaveData.Handle,&(f->Position),SEEK_SET);
2644 if ( ISNOTEQUALPOS(f->Position,AO.SaveData.Position) )
goto ErrGt2;
2645 #ifndef SYSDEPENDENTSAVE 2649 #ifdef SYSDEPENDENTSAVE 2651 if ( ReadFile(f->Handle,(UBYTE *)(&(f->Index)),number) !=
2652 number )
goto ErrGt2;
2657 MesPrint(
"Parameters of expression %s don't match." 2661 MesPrint(
"Cannot find expression %s",EXPRNAME(expr));
2665 MesPrint(
"Readerror in IndexSearch");
2711 LONG num, nsize, xx;
2712 WORD jsym, jind, jvec, jfun;
2713 WORD k, type, error = 0, *oldw, *neww, *oldwork = AT.WorkPointer;
2738 oldw = AT.WorkPointer + 1 + SUBEXPSIZE;
2744 LOCK(AM.storefilelock);
2745 if ( ( ind = FindInIndex(expr,&AR.StoreData,0,mode) ) == 0 ) {
2746 UNLOCK(AM.storefilelock);
2750 xx = ind->nsymbols+ind->nindices+ind->nvectors+ind->nfunctions;
2752 Expressions[expr].renumlists =
2753 w = AN.dummyrenumlist;
2761 w = (WORD *)Malloc1(
sizeof(WORD)*(xx*2),
"VarSpace");
2786 w += ind->nfunctions;
2791 SeekFile(AR.StoreData.Handle,&(ind->variables),SEEK_SET);
2792 *position = ind->position;
2793 jsym = ind->nsymbols;
2794 jvec = ind->nvectors;
2795 jind = ind->nindices;
2796 jfun = ind->nfunctions;
2802 w = r->
symb.
lo; j = jsym;
2803 for ( i = 0; i < j; i++ ) {
2804 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)s,(LONG)(
sizeof(
struct SyMbOl)))
2805 !=
sizeof(
struct SyMbOl) )
goto ErrGt2;
2806 nsize = s->namesize; nsize +=
sizeof(
void *)-1;
2807 nsize &= -
sizeof(
void *);
2808 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)(AT.WorkPointer),nsize)
2809 != nsize )
goto ErrGt2;
2814 while ( *neww != SYMTOSYM || neww[2] != *w ) neww += neww[1];
2817 else if ( GetVar((UBYTE *)AT.WorkPointer,&type,&k,ALLVARIABLES,NOAUTO) != NAMENOTFOUND ) {
2818 if ( type != CSYMBOL ) {
2819 MesPrint(
"Error: Conflicting types for %s",(AT.WorkPointer));
2823 if ( ( s->complex & (VARTYPEIMAGINARY|VARTYPECOMPLEX) ) !=
2824 ( symbols[k].complex & (VARTYPEIMAGINARY|VARTYPECOMPLEX) ) ) {
2825 MesPrint(
"Warning: Conflicting complexity for %s",AT.WorkPointer);
2828 if ( ( s->complex & (VARTYPEROOTOFUNITY) ) !=
2829 ( symbols[k].complex & (VARTYPEROOTOFUNITY) ) ) {
2830 MesPrint(
"Warning: Conflicting root of unity properties for %s",AT.WorkPointer);
2833 if ( ( s->complex & VARTYPEROOTOFUNITY ) == VARTYPEROOTOFUNITY ) {
2834 if ( s->maxpower != symbols[k].maxpower ) {
2835 MesPrint(
"Warning: Conflicting n in n-th root of unity properties for %s",AT.WorkPointer);
2839 else if ( ( s->minpower !=
2840 symbols[k].minpower || s->maxpower !=
2841 symbols[k].maxpower ) && AC.WarnFlag ) {
2842 MesPrint(
"Warning: Conflicting power restrictions for %s",AT.WorkPointer);
2847 if ( ( k = EntVar(CSYMBOL,(UBYTE *)(AT.WorkPointer),s->complex,s->minpower,
2848 s->maxpower,s->dimension) ) < 0 )
goto GetTcall;
2860 w = r->
indi.
lo; j = jind;
2861 for ( i = 0; i < j; i++ ) {
2862 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)s,(LONG)(
sizeof(
struct InDeX)))
2863 !=
sizeof(
struct InDeX) ) goto ErrGt2;
2864 nsize = s->namesize; nsize +=
sizeof(
void *)-1;
2865 nsize &= -
sizeof(
void *);
2866 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)(AT.WorkPointer),nsize)
2867 != nsize )
goto ErrGt2;
2868 *w = s->number + AM.OffsetIndex;
2869 if ( s->dimension < 0 ) {
2870 s->dimension = -r->
symnum[FindrNumber(-s->dimension,&(r->
symb))];
2871 if ( s->nmin4 < -NMIN4SHIFT ) {
2872 s->nmin4 = -r->
symnum[FindrNumber(-s->nmin4-NMIN4SHIFT
2873 ,&(r->
symb))]-NMIN4SHIFT;
2879 while ( *neww != INDTOIND || neww[2] != *w ) neww += neww[1];
2880 k = neww[3] - AM.OffsetIndex;
2882 else if ( s->type == DUMMY ) {
2887 else if ( GetVar((UBYTE *)(AT.WorkPointer),&type,&k,ALLVARIABLES,NOAUTO) != NAMENOTFOUND ) {
2888 if ( type != CINDEX ) {
2889 MesPrint(
"Error: Conflicting types for %s",(AT.WorkPointer));
2895 MesPrint(
"Warning: %s is also a dummy index",(AT.WorkPointer));
2899 if ( s->dimension != indices[k].dimension ) {
2900 MesPrint(
"Warning: Conflicting dimensions for %s",(AT.WorkPointer));
2907 if ( ( k = EntVar(CINDEX,(UBYTE *)(AT.WorkPointer),
2908 s->dimension,0,s->nmin4,0) ) < 0 )
goto GetTcall;
2911 *(w+j) = k + AM.OffsetIndex;
2921 w = r->
vect.
lo; j = jvec;
2922 for ( i = 0; i < j; i++ ) {
2923 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)s,(LONG)(
sizeof(
struct VeCtOr)))
2924 !=
sizeof(
struct VeCtOr) ) goto ErrGt2;
2925 nsize = s->namesize; nsize +=
sizeof(
void *)-1;
2926 nsize &= -
sizeof(
void *);
2927 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)(AT.WorkPointer),nsize)
2928 != nsize )
goto ErrGt2;
2929 *w = s->number + AM.OffsetVector;
2933 while ( *neww != VECTOVEC || neww[2] != *w ) neww += neww[1];
2934 k = neww[3] - AM.OffsetVector;
2936 else if ( GetVar((UBYTE *)(AT.WorkPointer),&type,&k,ALLVARIABLES,NOAUTO) != NAMENOTFOUND ) {
2937 if ( type != CVECTOR ) {
2938 MesPrint(
"Error: Conflicting types for %s",(AT.WorkPointer));
2942 if ( ( s->complex & (VARTYPEIMAGINARY|VARTYPECOMPLEX) ) !=
2943 ( vectors[k].complex & (VARTYPEIMAGINARY|VARTYPECOMPLEX) ) ) {
2944 MesPrint(
"Warning: Conflicting complexity for %s",(AT.WorkPointer));
2950 if ( ( k = EntVar(CVECTOR,(UBYTE *)(AT.WorkPointer),
2951 s->complex,0,0,s->dimension) ) < 0 )
goto GetTcall;
2953 *(w+j) = k + AM.OffsetVector;
2963 w = r->
func.
lo; j = jfun;
2964 for ( i = 0; i < j; i++ ) {
2965 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)s,(LONG)(
sizeof(
struct FuNcTiOn)))
2966 !=
sizeof(
struct FuNcTiOn) ) goto ErrGt2;
2967 nsize = s->
namesize; nsize +=
sizeof(
void *)-1;
2968 nsize &= -
sizeof(
void *);
2969 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)(AT.WorkPointer),nsize)
2970 != nsize )
goto ErrGt2;
2971 *w = s->
number + FUNCTION;
2975 while ( *neww != FUNTOFUN || neww[2] != *w ) neww += neww[1];
2976 k = neww[3] - FUNCTION;
2978 else if ( GetVar((UBYTE *)(AT.WorkPointer),&type,&k,ALLVARIABLES,NOAUTO) != NAMENOTFOUND ) {
2979 if ( type != CFUNCTION ) {
2980 MesPrint(
"Error: Conflicting types for %s",(AT.WorkPointer));
2984 if ( s->
complex != functions[k].complex ) {
2985 MesPrint(
"Warning: Conflicting complexity for %s",(AT.WorkPointer));
2988 else if ( s->
symmetric != functions[k].symmetric ) {
2989 MesPrint(
"Warning: Conflicting symmetry properties for %s",(AT.WorkPointer));
2992 else if ( ( s->maxnumargs != functions[k].maxnumargs )
2993 || ( s->minnumargs != functions[k].minnumargs ) ) {
2994 MesPrint(
"Warning: Conflicting argument restriction properties for %s",(AT.WorkPointer));
3000 if ( ( k = EntVar(CFUNCTION,(UBYTE *)(AT.WorkPointer),
3003 functions[k].maxnumargs = s->maxnumargs;
3004 functions[k].minnumargs = s->minnumargs;
3006 *(w+j) = k + FUNCTION;
3016 UNLOCK(AM.storefilelock);
3017 AT.WorkPointer = oldwork;
3035 TELLFILE(AR.StoreData.Handle,&pos);
3036 nummystery = DIFBASE(ind->position,pos);
3042 if ( nummystery > 0 ) {
3043 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)AT.WorkPointer,(LONG)
sizeof(WORD)) !=
3045 UNLOCK(AM.storefilelock);
3046 AT.WorkPointer = oldwork;
3049 Expressions[expr].numdummies = *AT.WorkPointer;
3053 nummystery -=
sizeof(WORD);
3056 Expressions[expr].numdummies = 0;
3058 if ( nummystery > 0 ) {
3059 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)AT.WorkPointer,(LONG)
sizeof(WORD)) !=
3061 UNLOCK(AM.storefilelock);
3062 AT.WorkPointer = oldwork;
3065 if ( ( AS.OldNumFactors == 0 ) || ( AS.NumOldNumFactors < NumExpressions ) ) {
3066 AS.NumOldNumFactors = 20;
3067 if ( AS.NumOldNumFactors < NumExpressions ) AS.NumOldNumFactors = NumExpressions*2;
3068 if ( AS.OldNumFactors ) M_free(AS.OldNumFactors,
"numfactors pointers");
3069 AS.OldNumFactors = (WORD *)Malloc1(AS.NumOldNumFactors*
sizeof(WORD),
"numfactors pointers");
3070 if ( AS.Oldvflags ) M_free(AS.Oldvflags,
"vflags pointers");
3071 AS.Oldvflags = (WORD *)Malloc1(AS.NumOldNumFactors*
sizeof(WORD),
"vflags pointers");
3074 AS.OldNumFactors[expr] =
3075 Expressions[expr].numfactors = *AT.WorkPointer;
3079 nummystery -=
sizeof(WORD);
3082 Expressions[expr].numfactors = 0;
3084 if ( nummystery > 0 ) {
3085 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)AT.WorkPointer,(LONG)
sizeof(WORD)) !=
3087 UNLOCK(AM.storefilelock);
3088 AT.WorkPointer = oldwork;
3091 AS.Oldvflags[expr] =
3092 Expressions[expr].vflags = *AT.WorkPointer;
3096 nummystery -=
sizeof(WORD);
3099 Expressions[expr].vflags = 0;
3103 SeekFile(AR.StoreData.Handle,&(ind->position),SEEK_SET);
3104 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)AT.WorkPointer,(LONG)
sizeof(WORD)) !=
3105 sizeof(WORD) || !*AT.WorkPointer ) {
3106 UNLOCK(AM.storefilelock);
3107 AT.WorkPointer = oldwork;
3110 num = *AT.WorkPointer - 1;
3111 num *=
sizeof(WORD);
3112 if ( *AT.WorkPointer < 0 ||
3113 ReadFile(AR.StoreData.Handle,(UBYTE *)(AT.WorkPointer+1),num) != num ) {
3114 MesPrint(
"@Error in stored expressions file at position %10p",*position);
3115 UNLOCK(AM.storefilelock);
3116 AT.WorkPointer = oldwork;
3119 UNLOCK(AM.storefilelock);
3120 ADDPOS(*position,num+
sizeof(WORD));
3121 r->startposition = *position;
3122 AT.WorkPointer = oldwork;
3125 UNLOCK(AM.storefilelock);
3126 AT.WorkPointer = oldwork;
3127 MesCall(
"GetTable");
3130 UNLOCK(AM.storefilelock);
3131 AT.WorkPointer = oldwork;
3132 MesPrint(
"Readerror in GetTable");
3155 SeekScratch(from,&posfrom);
3156 if ( from->
handle < 0 ) {
3157 fullsize = (BASEPOSITION(posfrom))/
sizeof(WORD);
3158 if ( ( to->POstop - to->POfull ) >= fullsize ) {
3162 t1 = from->PObuffer;
3164 NCOPY(t2,t1,fullsize)
3165 to->POfull = to->POfill = t2;
3169 if ( ( RetCode = CreateFile(to->name) ) >= 0 ) {
3170 to->
handle = (WORD)RetCode;
3171 PUTZERO(to->filesize);
3172 PUTZERO(to->POposition);
3175 MLOCK(ErrorMessageLock);
3176 MesPrint(
"Cannot create scratch file %s",to->name);
3177 MUNLOCK(ErrorMessageLock);
3181 t1 = from->PObuffer;
3182 while ( fullsize > 0 ) {
3183 i = to->POstop - to->POfull;
3184 if ( i > fullsize ) i = fullsize;
3188 if ( fullsize > 0 ) {
3189 SeekFile(to->
handle,&(to->POposition),SEEK_SET);
3190 if ( WriteFile(to->
handle,((UBYTE *)(to->PObuffer)),to->POsize) != to->POsize ) {
3191 MLOCK(ErrorMessageLock);
3192 MesPrint(
"Error while writing to disk. Disk full?");
3193 MUNLOCK(ErrorMessageLock);
3196 ADDPOS(to->POposition,to->POsize);
3198 to->filesize = to->POposition;
3199 to->POfill = to->POfull = to->PObuffer;
3202 to->POfill = to->POfull = t2;
3211 if ( ((UBYTE *)(from->POfill)-(UBYTE *)(from->PObuffer)) > 0 ) {
3212 if ( WriteFile(from->
handle,((UBYTE *)(from->PObuffer)),((UBYTE *)(from->POfill)-(UBYTE *)(from->PObuffer)))
3213 != ((UBYTE *)(from->POfill)-(UBYTE *)(from->PObuffer)) ) {
3214 MLOCK(ErrorMessageLock);
3215 MesPrint(
"Error while writing to disk. Disk full?");
3216 MUNLOCK(ErrorMessageLock);
3219 SeekFile(from->
handle,&(from->POposition),SEEK_CUR);
3220 posfrom = from->filesize = from->POposition;
3221 from->POfill = from->POfull = from->PObuffer;
3227 SeekFile(from->
handle,&poscopy,SEEK_SET);
3228 while ( ISLESSPOS(poscopy,posfrom) ) {
3229 fullsize = ReadFile(from->
handle,((UBYTE *)(from->PObuffer)),from->POsize);
3230 if ( fullsize < 0 || ( fullsize %
sizeof(WORD) ) != 0 ) {
3231 MLOCK(ErrorMessageLock);
3232 MesPrint(
"Error while reading from disk while copying expression.");
3233 MUNLOCK(ErrorMessageLock);
3236 fullsize /=
sizeof(WORD);
3237 from->POfull = from->PObuffer + fullsize;
3238 t1 = from->PObuffer;
3240 if ( ( to->POstop - to->POfull ) >= fullsize ) {
3245 NCOPY(t2,t1,fullsize)
3246 to->POfill = to->POfull = t2;
3250 if ( ( RetCode = CreateFile(to->name) ) >= 0 ) {
3251 to->
handle = (WORD)RetCode;
3252 PUTZERO(to->POposition);
3253 PUTZERO(to->filesize);
3256 MLOCK(ErrorMessageLock);
3257 MesPrint(
"Cannot create scratch file %s",to->name);
3258 MUNLOCK(ErrorMessageLock);
3262 while ( fullsize > 0 ) {
3263 i = to->POstop - to->POfull;
3264 if ( i > fullsize ) i = fullsize;
3268 if ( fullsize > 0 ) {
3269 SeekFile(to->
handle,&(to->POposition),SEEK_SET);
3270 if ( WriteFile(to->
handle,((UBYTE *)(to->PObuffer)),to->POsize) != to->POsize ) {
3271 MLOCK(ErrorMessageLock);
3272 MesPrint(
"Error while writing to disk. Disk full?");
3273 MUNLOCK(ErrorMessageLock);
3276 ADDPOS(to->POposition,to->POsize);
3278 to->filesize = to->POposition;
3279 to->POfill = to->POfull = to->PObuffer;
3282 to->POfill = to->POfull = t2;
3286 SeekFile(from->
handle,&poscopy,SEEK_CUR);
3289 if ( ( to->
handle >= 0 ) && ( to->POfill > to->PObuffer ) ) {
3290 fullsize = (UBYTE *)(to->POfill) - (UBYTE *)(to->PObuffer);
3295 SeekFile(to->
handle,&(to->filesize),SEEK_SET);
3296 if ( WriteFile(to->
handle,((UBYTE *)(to->PObuffer)),fullsize) != fullsize ) {
3297 MLOCK(ErrorMessageLock);
3298 MesPrint(
"Error while writing to disk. Disk full?");
3299 MUNLOCK(ErrorMessageLock);
3302 ADDPOS(to->filesize,fullsize);
3303 to->POposition = to->filesize;
3304 to->POfill = to->POfull = to->PObuffer;
3317 static UBYTE *statusexpr[] = {
3318 (UBYTE *)
"LOCALEXPRESSION" 3319 ,(UBYTE *)
"SKIPLEXPRESSION" 3320 ,(UBYTE *)
"DROPLEXPRESSION" 3321 ,(UBYTE *)
"DROPPEDEXPRESSION" 3322 ,(UBYTE *)
"GLOBALEXPRESSION" 3323 ,(UBYTE *)
"SKIPGEXPRESSION" 3324 ,(UBYTE *)
"DROPGEXPRESSION" 3326 ,(UBYTE *)
"STOREDEXPRESSION" 3327 ,(UBYTE *)
"HIDDENLEXPRESSION" 3328 ,(UBYTE *)
"HIDELEXPRESSION" 3329 ,(UBYTE *)
"DROPHLEXPRESSION" 3330 ,(UBYTE *)
"UNHIDELEXPRESSION" 3331 ,(UBYTE *)
"HIDDENGEXPRESSION" 3332 ,(UBYTE *)
"HIDEGEXPRESSION" 3333 ,(UBYTE *)
"DROPHGEXPRESSION" 3334 ,(UBYTE *)
"UNHIDEGEXPRESSION" 3335 ,(UBYTE *)
"INTOHIDELEXPRESSION" 3336 ,(UBYTE *)
"INTOHIDEGEXPRESSION" 3341 MesPrint(
"Expression %s(%d) has status %s(%d,%d). Buffer: %d, Position: %15p",
3342 AC.exprnames->namebuffer+e->name,(WORD)(e-Expressions),
3343 statusexpr[e->status],e->status,e->hidelevel,
3344 e->whichbuffer,&(e->onfile));
3366 #error "INT16 not defined!" 3369 #error "INT32 not defined!" 3381 static void FlipN(UBYTE *p,
int length)
3387 buf = *p; *p = *q; *q = buf;
3388 }
while ( ++p != q );
3400 static void Flip16(UBYTE *p)
3402 INT16 in = *((INT16 *)p);
3403 INT16 out = (INT16)( (((in) >> 8) & 0x00FF) | (((in) << 8) & 0xFF00) );
3404 *((INT16 *)p) = out;
3408 static void Flip32(UBYTE *p)
3410 INT32 in = *((INT32 *)p);
3412 ( (((in) >> 24) & 0x000000FF) | (((in) >> 8) & 0x0000FF00) | \
3413 (((in) << 8) & 0x00FF0000) | (((in) << 24) & 0xFF000000) );
3414 *((INT32 *)p) = out;
3419 static void Flip64(UBYTE *p)
3421 INT64 in = *((INT64 *)p);
3423 ( (((in) >> 56) & (INT64)0x00000000000000FFLL) | (((in) >> 40) & (INT64)0x000000000000FF00LL) | \
3424 (((in) >> 24) & (INT64)0x0000000000FF0000LL) | (((in) >> 8) & (INT64)0x00000000FF000000LL) | \
3425 (((in) << 8) & (INT64)0x000000FF00000000LL) | (((in) << 24) & (INT64)0x0000FF0000000000LL) | \
3426 (((in) << 40) & (INT64)0x00FF000000000000LL) | (((in) << 56) & (INT64)0xFF00000000000000LL) );
3427 *((INT64 *)p) = out;
3430 static void Flip64(UBYTE *p) { FlipN(p, 8); }
3434 static void Flip128(UBYTE *p) { FlipN(p, 16); }
3452 static void ResizeDataBE(UBYTE *src,
int slen, UBYTE *dst,
int dlen)
3454 if ( slen > dlen ) {
3456 while ( dlen-- ) { *dst++ = *src++; }
3459 int i = dlen - slen;
3460 while ( i-- ) { *dst++ = 0; }
3461 while ( slen-- ) { *dst++ = *src++; }
3468 static void ResizeDataLE(UBYTE *src,
int slen, UBYTE *dst,
int dlen)
3470 if ( slen > dlen ) {
3471 while ( dlen-- ) { *dst++ = *src++; }
3474 int i = dlen - slen;
3475 while ( slen-- ) { *dst++ = *src++; }
3476 while ( i-- ) { *dst++ = 0; }
3492 static void Resize16t16(UBYTE *src, UBYTE *dst)
3494 *((INT16 *)dst) = *((INT16 *)src);
3498 static void Resize16t32(UBYTE *src, UBYTE *dst)
3500 INT16 in = *((INT16 *)src);
3501 INT32 out = (INT32)in;
3502 *((INT32 *)dst) = out;
3507 static void Resize16t64(UBYTE *src, UBYTE *dst)
3509 INT16 in = *((INT16 *)src);
3510 INT64 out = (INT64)in;
3511 *((INT64 *)dst) = out;
3514 static void Resize16t64(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 2, dst, 8); }
3518 static void Resize16t128(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 2, dst, 16); }
3521 static void Resize32t32(UBYTE *src, UBYTE *dst)
3523 *((INT32 *)dst) = *((INT32 *)src);
3528 static void Resize32t64(UBYTE *src, UBYTE *dst)
3530 INT32 in = *((INT32 *)src);
3531 INT64 out = (INT64)in;
3532 *((INT64 *)dst) = out;
3535 static void Resize32t64(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 4, dst, 8); }
3539 static void Resize32t128(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 4, dst, 16); }
3543 static void Resize64t64(UBYTE *src, UBYTE *dst)
3545 *((INT64 *)dst) = *((INT64 *)src);
3548 static void Resize64t64(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 8, dst, 8); }
3552 static void Resize64t128(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 8, dst, 16); }
3555 static void Resize128t128(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 16, dst, 16); }
3558 static void Resize32t16(UBYTE *src, UBYTE *dst)
3560 INT32 in = *((INT32 *)src);
3561 INT16 out = (INT16)in;
3562 if ( in > (1<<15)-1 || in < -(1<<15)+1 ) AO.resizeFlag |= 1;
3563 *((INT16 *)dst) = out;
3572 static void Resize32t16NC(UBYTE *src, UBYTE *dst)
3574 INT32 in = *((INT32 *)src);
3575 INT16 out = (INT16)in;
3576 *((INT16 *)dst) = out;
3581 static void Resize64t16(UBYTE *src, UBYTE *dst)
3583 INT64 in = *((INT64 *)src);
3584 INT16 out = (INT16)in;
3585 if ( in > (1<<15)-1 || in < -(1<<15)+1 ) AO.resizeFlag |= 1;
3586 *((INT16 *)dst) = out;
3589 static void Resize64t16NC(UBYTE *src, UBYTE *dst)
3591 INT64 in = *((INT64 *)src);
3592 INT16 out = (INT16)in;
3593 *((INT16 *)dst) = out;
3597 static void Resize64t16(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 8, dst, 2); }
3599 static void Resize64t16NC(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 8, dst, 2); }
3604 static void Resize64t32(UBYTE *src, UBYTE *dst)
3606 INT64 in = *((INT64 *)src);
3607 INT32 out = (INT32)in;
3608 if ( in > ((INT64)1<<31)-1 || in < -((INT64)1<<31)+1 ) AO.resizeFlag |= 1;
3609 *((INT32 *)dst) = out;
3612 static void Resize64t32NC(UBYTE *src, UBYTE *dst)
3614 INT64 in = *((INT64 *)src);
3615 INT32 out = (INT32)in;
3616 *((INT32 *)dst) = out;
3620 static void Resize64t32(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 8, dst, 4); }
3622 static void Resize64t32NC(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 8, dst, 4); }
3626 static void Resize128t16(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 16, dst, 2); }
3629 static void Resize128t16NC(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 16, dst, 2); }
3632 static void Resize128t32(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 16, dst, 4); }
3635 static void Resize128t32NC(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 16, dst, 4); }
3638 static void Resize128t64(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 16, dst, 8); }
3641 static void Resize128t64NC(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 16, dst, 8); }
3654 static void CheckPower32(UBYTE *p)
3656 if ( *((INT32 *)p) < -MAXPOWER ) {
3657 AO.powerFlag |= 0x01;
3658 *((INT32 *)p) = -MAXPOWER;
3661 if ( *((INT32 *)p) > MAXPOWER ) {
3662 AO.powerFlag |= 0x02;
3663 *((INT32 *)p) = MAXPOWER;
3674 static void RenumberVec32(UBYTE *p)
3677 void *dummy = (
void *)AO.SaveHeader.wildoffset;
3678 INT32 wildoffset = *(INT32 *)dummy;
3679 INT32 in = *((INT32 *)p);
3680 in = in + 2*wildoffset;
3681 in = in - 2*WILDOFFSET;
3703 static void ResizeCoeff32(UBYTE **bout, UBYTE *bend, UBYTE *top)
3708 INT32 *out = (INT32 *)*bout;
3709 INT32 *end = (INT32 *)bend;
3711 if (
sizeof(WORD) == 2 ) {
3713 INT32 len = (end - 1 - out) / 2;
3717 if ( *p & 0xFFFF0000 ) --zeros;
3719 if ( *p & 0xFFFF0000 ) --zeros;
3722 sign = ( *in-- > 0 ) ? 1 : -1;
3724 if ( zeros == 2 ) p -= 2;
3727 if ( zeros < 2 ) *p-- = *in >> 16;
3728 *p-- = *in-- & 0x0000FFFF;
3729 for ( i = 1; i < len; ++i ) {
3731 *p-- = *in-- & 0x0000FFFF;
3733 if ( zeros < 2 ) *p-- = *in >> 16;
3734 *p-- = *in-- & 0x0000FFFF;
3735 for ( i = 1; i < len; ++i ) {
3737 *p-- = *in-- & 0x0000FFFF;
3740 *out = (out - p) * sign;
3741 *bout = (UBYTE *)(out+1);
3746 INT32 len = (end - 1 - out) / 2;
3748 *out = *(
unsigned INT16 *)out;
3750 *out = *(
unsigned INT16 *)out;
3756 *out = *(
unsigned INT16 *)out;
3758 for ( i = 1; i < len; ++i ) {
3760 *out = (
unsigned INT32)(*(
unsigned INT16 *)out)
3761 + ((
unsigned INT32)(*(
unsigned INT16 *)in) << 16);
3763 if ( ++i == len )
break;
3766 *out = *(
unsigned INT16 *)in;
3770 *out = *(
unsigned INT16 *)in;
3772 for ( i = 1; i < len; ++i ) {
3774 *out = (
unsigned INT32)(*(
unsigned INT16 *)out)
3775 + ((
unsigned INT32)(*(
unsigned INT16 *)in) << 16);
3777 if ( ++i == len )
break;
3780 *out = *(
unsigned INT16 *)in;
3784 if ( *in < 0 ) *out = -(out - p + 1);
3785 else *out = out - p + 1;
3789 if ( out > (INT32 *)top ) {
3790 MesPrint(
"Error in resizing coefficient!");
3793 *bout = (UBYTE *)out;
3802 #define SAVEREVISION 0x02 3817 { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF },
3835 for ( i = 1; i < (int)
sizeof(
int); ++i ) {
3839 for ( i = 0; i < (int)
sizeof(
int); ++i ) sh.
endianness[i] = ((
char *)&endian)[i];
3851 for ( i = 0; i < 8; i++ ) dumw[i] = 0;
3852 dummy = (UBYTE *)dumw;
3853 dumw[0] = (WORD)MAXPOWER;
3854 for ( i = 0; i < 16; i++ ) sh.
maxpower[i] = dummy[i];
3855 dumw[0] = (WORD)WILDOFFSET;
3856 for ( i = 0; i < 16; i++ ) sh.
wildoffset[i] = dummy[i];
3860 return ( WriteFile(handle,(UBYTE *)(&sh),(LONG)(
sizeof(
STOREHEADER)))
3876 static unsigned int CompactifySizeof(
unsigned int size)
3883 default: MesPrint(
"Error compactifying size.");
3909 static VOID (*flipJumpTable[4])(UBYTE *) =
3910 { Flip16, Flip32, Flip64, Flip128 };
3911 static VOID (*resizeJumpTable[4][4])(UBYTE *, UBYTE *) =
3912 { { Resize16t16, Resize32t16, Resize64t16, Resize128t16 },
3913 { Resize16t32, Resize32t32, Resize64t32, Resize128t32 },
3914 { Resize16t64, Resize32t64, Resize64t64, Resize128t64 },
3915 { Resize16t128, Resize32t128, Resize64t128, Resize128t128 } };
3916 static VOID (*resizeNCJumpTable[4][4])(UBYTE *, UBYTE *) =
3917 { { Resize16t16, Resize32t16NC, Resize64t16NC, Resize128t16NC },
3918 { Resize16t32, Resize32t32, Resize64t32NC, Resize128t32NC },
3919 { Resize16t64, Resize32t64, Resize64t64, Resize128t64NC },
3920 { Resize16t128, Resize32t128, Resize64t128, Resize128t128 } };
3923 WORD idxW = CompactifySizeof(
sizeof(WORD));
3924 WORD idxL = CompactifySizeof(
sizeof(LONG));
3925 WORD idxP = CompactifySizeof(
sizeof(
POSITION));
3926 WORD idxVP = CompactifySizeof(
sizeof(
void *));
3933 if ( ReadFile(AO.SaveData.Handle,(UBYTE *)(&AO.SaveHeader),
3935 return(MesPrint(
"Error reading save file header"));
3940 for ( i = 0; i < 8; ++i ) {
3941 if ( AO.SaveHeader.headermark[i] != 0xFF ) {
3944 SeekFile(AO.SaveData.Handle, &p, SEEK_SET);
3949 if ( AO.SaveHeader.revision != SAVEREVISION ) {
3950 return(MesPrint(
"Save file header from an old version. Cannot read this file."));
3954 for ( i = 1; i < (int)
sizeof(
int); ++i ) {
3958 if ( ((
char *)&endian)[0] < ((
char *)&endian)[1] ) {
3960 AO.ResizeData = ResizeDataBE;
3964 AO.ResizeData = ResizeDataLE;
3968 if ( AO.SaveHeader.endianness[0] > AO.SaveHeader.endianness[1] ) {
3969 AO.transFlag = ( ((
char *)&endian)[0] < ((
char *)&endian)[1] );
3972 AO.transFlag = ( ((
char *)&endian)[0] > ((
char *)&endian)[1] );
3974 if ( (WORD)AO.SaveHeader.lenWORD !=
sizeof(WORD) ) AO.transFlag |= 0x02;
3975 if ( (WORD)AO.SaveHeader.lenLONG !=
sizeof(LONG) ) AO.transFlag |= 0x04;
3976 if ( (WORD)AO.SaveHeader.lenPOS !=
sizeof(
POSITION) ) AO.transFlag |= 0x08;
3977 if ( (WORD)AO.SaveHeader.lenPOINTER !=
sizeof(
void *) ) AO.transFlag |= 0x10;
3979 AO.FlipWORD = flipJumpTable[idxW];
3980 AO.FlipLONG = flipJumpTable[idxL];
3981 AO.FlipPOS = flipJumpTable[idxP];
3982 AO.FlipPOINTER = flipJumpTable[idxVP];
3985 AO.CheckPower = CheckPower32;
3986 AO.RenumberVec = RenumberVec32;
3988 AO.ResizeWORD = resizeJumpTable[idxW][CompactifySizeof(AO.SaveHeader.lenWORD)];
3989 AO.ResizeNCWORD = resizeNCJumpTable[idxW][CompactifySizeof(AO.SaveHeader.lenWORD)];
3990 AO.ResizeLONG = resizeJumpTable[idxL][CompactifySizeof(AO.SaveHeader.lenLONG)];
3991 AO.ResizePOS = resizeJumpTable[idxP][CompactifySizeof(AO.SaveHeader.lenPOS)];
3992 AO.ResizePOINTER = resizeJumpTable[idxVP][CompactifySizeof(AO.SaveHeader.lenPOINTER)];
3997 for ( i = 0; i < 8; i++ ) dumw[i] = 0;
3998 dummy = (UBYTE *)dumw;
3999 for ( i = 0; i < 16; i++ ) dummy[i] = AO.SaveHeader.maxpower[i];
4000 AO.mpower = dumw[0];
4027 if ( AO.transFlag ) {
4038 int lenW = AO.SaveHeader.lenWORD;
4039 int lenL = AO.SaveHeader.lenLONG;
4040 int lenP = AO.SaveHeader.lenPOS;
4043 if ( AO.bufferedInd ) {
4049 if ( ReadFile(AO.SaveData.Handle, (UBYTE *)fileind,
sizeof(
FILEINDEX))
4051 return ( MesPrint(
"Error(1) reading stored expression.") );
4055 if ( AO.transFlag & 1 ) {
4058 int padp = lenL - ((lenW*5+(MAXENAME + 1)) & (lenL-1));
4059 p = (UBYTE *)fileind;
4060 AO.FlipPOS(p); p += lenP;
4062 AO.ResizePOS(p, (UBYTE *)&number);
4064 for ( i = 0; i <
number; ++i ) {
4065 AO.FlipPOS(p); p += lenP;
4066 AO.FlipPOS(p); p += lenP;
4067 AO.FlipPOS(p); p += lenP;
4068 AO.FlipLONG(p); p += lenL;
4069 AO.FlipWORD(p); p += lenW;
4070 AO.FlipWORD(p); p += lenW;
4071 AO.FlipWORD(p); p += lenW;
4072 AO.FlipWORD(p); p += lenW;
4073 AO.FlipWORD(p); p += lenW;
4079 if ( AO.transFlag > 1 ) {
4083 int padp = lenL - ((lenW*5+(MAXENAME + 1)) & (lenL-1));
4084 int padq =
sizeof(LONG) - ((
sizeof(WORD)*5+(MAXENAME + 1)) & (
sizeof(LONG)-1));
4086 p = (UBYTE *)fileind; q = (UBYTE *)&buffer;
4091 number = BASEPOSITION(*((
POSITION *)q));
4097 if ( AO.bufferedInd > (WORD)INFILEINDEX ) {
4100 return ( MesPrint(
"Too many index entries.") );
4103 SETBASEPOSITION(*((
POSITION *)q),INFILEINDEX);
4110 for ( i = 0; i < maxnumber; ++i ) {
4117 AO.ResizeLONG(p, q);
4118 p += lenL; q +=
sizeof(LONG);
4119 AO.ResizeWORD(p, q);
4120 p += lenW; q +=
sizeof(WORD);
4121 AO.ResizeWORD(p, q);
4122 p += lenW; q +=
sizeof(WORD);
4123 AO.ResizeWORD(p, q);
4124 p += lenW; q +=
sizeof(WORD);
4125 AO.ResizeWORD(p, q);
4126 p += lenW; q +=
sizeof(WORD);
4127 AO.ResizeWORD(p, q);
4128 p += lenW; q +=
sizeof(WORD);
4135 if ( AO.bufferedInd ) {
4137 SETBASEPOSITION(sbuffer.
number,AO.bufferedInd);
4138 q = (UBYTE *)&sbuffer +
sizeof(
POSITION) +
sizeof(LONG);
4139 for ( i = maxnumber; i <
number; ++i ) {
4146 AO.ResizeLONG(p, q);
4147 p += lenL; q +=
sizeof(LONG);
4148 AO.ResizeWORD(p, q);
4149 p += lenW; q +=
sizeof(WORD);
4150 AO.ResizeWORD(p, q);
4151 p += lenW; q +=
sizeof(WORD);
4152 AO.ResizeWORD(p, q);
4153 p += lenW; q +=
sizeof(WORD);
4154 AO.ResizeWORD(p, q);
4155 p += lenW; q +=
sizeof(WORD);
4156 AO.ResizeWORD(p, q);
4157 p += lenW; q +=
sizeof(WORD);
4165 p = (UBYTE *)fileind; q = (UBYTE *)&buffer; n =
sizeof(
FILEINDEX);
4170 return ( ReadFile(AO.SaveData.Handle, (UBYTE *)fileind,
sizeof(
FILEINDEX))
4214 if ( AO.transFlag ) {
4218 static WORD numReadSym;
4219 static WORD numReadInd;
4220 static WORD numReadVec;
4221 static WORD numReadFun;
4224 UBYTE *in, *out, *pp = 0, *end, *outbuf;
4226 WORD namelen, realnamelen;
4228 WORD lenW = AO.SaveHeader.lenWORD;
4229 WORD lenL = AO.SaveHeader.lenLONG;
4230 WORD lenP = AO.SaveHeader.lenPOINTER;
4231 WORD flip = AO.transFlag & 1;
4234 TELLFILE(AO.SaveData.Handle,&pos);
4242 if ( (lenW > (WORD)
sizeof(WORD))
4243 || ( (lenW == (WORD)
sizeof(WORD))
4244 && ( (lenL > (WORD)
sizeof(LONG))
4245 || ( (lenL == (WORD)
sizeof(LONG)) && lenP > (WORD)
sizeof(
void *))
4249 end = buffer + *size;
4256 LONG newsize = (top - buffer) / (1 +
sizeof(WORD)/lenW);
4260 if ( *size > newsize ) *size = newsize;
4263 if ( ( numread = ReadFile(AO.SaveData.Handle, in, *size) ) != *size ) {
4264 return ( MesPrint(
"Error(2) reading stored expression.") );
4271 if ( *stage == -1 ) {
4279 while ( in < end ) {
4281 if ( *stage == 0 ) {
4282 if ( ind->
nsymbols <= numReadSym ) {
4286 if ( end - in < AO.SaveHeader.sSym ) {
4291 AO.FlipLONG(pp); pp += lenL;
4292 while ( pp < in + AO.SaveHeader.sSym ) {
4293 AO.FlipWORD(pp); pp += lenW;
4296 pp = in + AO.SaveHeader.sSym;
4297 AO.ResizeLONG(in, out); in += lenL; out +=
sizeof(LONG);
4299 AO.ResizeWORD(in, out); in += lenW;
4300 if ( *((WORD *)out) == -AO.mpower ) *((WORD *)out) = -MAXPOWER;
4301 out +=
sizeof(WORD);
4302 AO.ResizeWORD(in, out); in += lenW;
4303 if ( *((WORD *)out) == AO.mpower ) *((WORD *)out) = MAXPOWER;
4304 out +=
sizeof(WORD);
4305 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4306 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4307 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4308 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4309 AO.ResizeWORD(in, out); in += lenW;
4310 realnamelen = *((WORD *)out);
4311 realnamelen +=
sizeof(
void *)-1; realnamelen &= -(
sizeof(
void *));
4312 out +=
sizeof(WORD);
4313 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4315 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4317 namelen = *((WORD *)out-1);
4318 if ( end - in < namelen ) {
4321 *((WORD *)out-1) = realnamelen;
4322 *size += AO.SaveHeader.sSym + namelen;
4323 *outsize +=
sizeof(
struct SyMbOl) + realnamelen;
4324 if ( realnamelen > namelen ) {
4327 out += realnamelen - namelen;
4330 int j = realnamelen;
4332 in += namelen - realnamelen;
4338 if ( *stage == 1 ) {
4339 if ( ind->
nindices <= numReadInd ) {
4343 if ( end - in < AO.SaveHeader.sInd ) {
4348 AO.FlipLONG(pp); pp += lenL;
4349 while ( pp < in + AO.SaveHeader.sInd ) {
4350 AO.FlipWORD(pp); pp += lenW;
4353 pp = in + AO.SaveHeader.sInd;
4354 AO.ResizeLONG(in, out); in += lenL; out +=
sizeof(LONG);
4355 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4356 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4357 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4358 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4359 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4360 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4361 AO.ResizeWORD(in, out); in += lenW;
4362 realnamelen = *((WORD *)out);
4363 realnamelen +=
sizeof(
void *)-1; realnamelen &= -(
sizeof(
void *));
4364 out +=
sizeof(WORD);
4366 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4368 namelen = *((WORD *)out-1);
4369 if ( end - in < namelen ) {
4372 *((WORD *)out-1) = realnamelen;
4373 *size += AO.SaveHeader.sInd + namelen;
4374 *outsize +=
sizeof(
struct InDeX) + realnamelen;
4375 if ( realnamelen > namelen ) {
4378 out += realnamelen - namelen;
4381 int j = realnamelen;
4383 in += namelen - realnamelen;
4389 if ( *stage == 2 ) {
4390 if ( ind->
nvectors <= numReadVec ) {
4394 if ( end - in < AO.SaveHeader.sVec ) {
4399 AO.FlipLONG(pp); pp += lenL;
4400 while ( pp < in + AO.SaveHeader.sVec ) {
4401 AO.FlipWORD(pp); pp += lenW;
4404 pp = in + AO.SaveHeader.sVec;
4405 AO.ResizeLONG(in, out); in += lenL; out +=
sizeof(LONG);
4406 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4407 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4408 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4409 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4410 AO.ResizeWORD(in, out); in += lenW;
4411 realnamelen = *((WORD *)out);
4412 realnamelen +=
sizeof(
void *)-1; realnamelen &= -(
sizeof(
void *));
4413 out +=
sizeof(WORD);
4414 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4416 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4418 namelen = *((WORD *)out-1);
4419 if ( end - in < namelen ) {
4422 *((WORD *)out-1) = realnamelen;
4423 *size += AO.SaveHeader.sVec + namelen;
4424 *outsize +=
sizeof(
struct VeCtOr) + realnamelen;
4425 if ( realnamelen > namelen ) {
4428 out += realnamelen - namelen;
4431 int j = realnamelen;
4433 in += namelen - realnamelen;
4439 if ( *stage == 3 ) {
4444 if ( end - in < AO.SaveHeader.sFun ) {
4449 AO.FlipPOINTER(pp); pp += lenP;
4450 AO.FlipLONG(pp); pp += lenL;
4451 AO.FlipLONG(pp); pp += lenL;
4452 while ( pp < in + AO.SaveHeader.sFun ) {
4453 AO.FlipWORD(pp); pp += lenW;
4456 pp = in + AO.SaveHeader.sFun;
4458 AO.ResizePOINTER(in, out); in += lenP; out +=
sizeof(
void *);
4459 AO.ResizeLONG(in, out); in += lenL; out +=
sizeof(LONG);
4460 AO.ResizeLONG(in, out); in += lenL; out +=
sizeof(LONG);
4461 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4462 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4463 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4464 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4465 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4466 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4467 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4468 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4469 AO.ResizeWORD(in, out); in += lenW;
4470 realnamelen = *((WORD *)out);
4471 realnamelen +=
sizeof(
void *)-1; realnamelen &= -(
sizeof(
void *));
4472 out +=
sizeof(WORD);
4473 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4475 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4477 namelen = *((WORD *)out-1);
4478 if ( end - in < namelen ) {
4481 *((WORD *)out-1) = realnamelen;
4482 *size += AO.SaveHeader.sFun + namelen;
4483 *outsize +=
sizeof(
struct FuNcTiOn) + realnamelen;
4484 if ( realnamelen > namelen ) {
4487 out += realnamelen - namelen;
4490 int j = realnamelen;
4492 in += namelen - realnamelen;
4496 AO.tensorList[((
FUNCTIONS)outbuf)->number+FUNCTION] =
4501 if ( end - in >= lenW ) {
4502 if ( flip ) AO.FlipWORD(in);
4503 AO.ResizeWORD(in, out);
4505 *outsize +=
sizeof(WORD);
4508 if ( end - in >= lenW ) {
4509 if ( flip ) AO.FlipWORD(in);
4510 AO.ResizeWORD(in, out);
4512 *outsize +=
sizeof(WORD);
4515 if ( end - in >= lenW ) {
4516 if ( flip ) AO.FlipWORD(in);
4517 AO.ResizeWORD(in, out);
4519 *outsize +=
sizeof(WORD);
4529 SeekFile(AO.SaveData.Handle, &pos, SEEK_SET);
4532 return ( ReadFile(AO.SaveData.Handle, buffer, *size) != *size );
4570 ReadSaveTerm32(UBYTE *bin, UBYTE *binend, UBYTE **bout, UBYTE *boutend, UBYTE *top,
int terminbuf)
4576 INT32 *r, *t, *coeff, *end, *newtermsize, *rend;
4578 INT32 *in = (INT32 *)bin;
4579 INT32 *out = (INT32 *)*bout;
4588 rend = (INT32 *)boutend;
4589 coeff = end - ABS(*(end-1));
4590 newtermsize = (INT32 *)*bout;
4591 out = newtermsize + 1;
4597 r = (INT32 *)AR.CompressBuffer;
4603 if ( (UBYTE *)in >= binend ) {
4606 *out = len = -j + 1 + *in;
4608 if ( (UBYTE *)end >= top ) {
4613 while ( ++j <= 0 ) {
4619 else if ( j == 0 ) {
4621 while ( (UBYTE *)in < binend ) {
4623 if ( (UBYTE *)out > top ) {
4624 return ( (UBYTE *)bin );
4630 *bout = (UBYTE *)out;
4631 return ( (UBYTE *)in );
4635 if ( (UBYTE *)end >= top ) {
4639 if ( (UBYTE *)(in + j) >= binend ) {
4640 *(AR.CompressBuffer) = rbuf;
4643 if ( (UBYTE *)out + j >= top ) {
4647 while ( --j >= 0 ) {
4653 r = (INT32 *)AR.CompressBuffer + 1;
4654 coeff = end - ABS(*(end-1));
4655 newtermsize = (INT32 *)*bout;
4656 out = newtermsize + 1;
4660 while ( out < coeff ) {
4668 if (
id == SYMBOL ) {
4672 if ( ABS(*out) >= MAXPOWER ) {
4675 INT32 num = *(out-1);
4680 if ( (UBYTE *)end > top )
return ( bin );
4690 *out++ = ABS(exp) & 0x0000FFFF;
4691 *out++ = ABS(exp) >> 16;
4694 *out++ = ( exp < 0 ) ? -5 : 5;
4705 else if (
id == DOTPRODUCT ) {
4707 AO.RenumberVec((UBYTE *)out);
4709 AO.RenumberVec((UBYTE *)out);
4712 if ( ABS(*out) >= MAXPOWER ) {
4715 INT32 num1 = *(out-2);
4716 INT32 num2 = *(out-1);
4721 if ( (UBYTE *)end > top )
return ( bin );
4729 *out++ = DOTPRODUCT;
4740 *out++ = ABS(exp) & 0x0000FFFF;
4741 *out++ = ABS(exp) >> 16;
4744 *out++ = ( exp < 0 ) ? -5 : 5;
4755 else if (
id == VECTOR ) {
4757 AO.RenumberVec((UBYTE *)out);
4762 else if (
id == INDEX ) {
4764 void *dummy = (
void *)AO.SaveHeader.wildoffset;
4765 INT32 vectoroffset = -2 * *((INT32 *)dummy);
4768 if ( *out < vectoroffset ) {
4769 AO.RenumberVec((UBYTE *)out);
4774 else if (
id == SUBEXPRESSION ) {
4780 else if (
id == DELTA ) {
4785 else if (
id == HAAKJE ) {
4790 else if (
id == GAMMA ||
id == LEVICIVITA || (
id >= FUNCTION && AO.tensorList[
id]) ) {
4792 void *dummy = (
void *)AO.SaveHeader.wildoffset;
4793 INT32 vectoroffset = -2 * *((INT32 *)dummy);
4796 if ( *out < vectoroffset ) {
4797 AO.RenumberVec((UBYTE *)out);
4802 else if (
id >= FUNCTION ) {
4819 if (
sizeof(WORD) == 2 ) {
4821 if ( *out > (1<<15)-1 || *out < -(1<<15)+1 ) {
4829 if ( (UBYTE *)end > top )
return ( bin );
4834 *out++ = ABS(num) & 0x0000FFFF;
4835 *out++ = ABS(num) >> 16;
4838 *out++ = ( num < 0 ) ? -5 : 5;
4854 AO.RenumberVec((UBYTE *)out);
4863 AO.RenumberVec((UBYTE *)out);
4867 if ( -*out >= FUNCTION ) {
4871 MesPrint(
"short function code %d not implemented.", *out);
4872 return ( (UBYTE *)in );
4878 INT32 *newargsize = out;
4879 argEnd = out + *out;
4882 while ( out < argEnd ) {
4883 INT32 *keepsizep = out + *out;
4884 INT32 lenbuf = *out;
4887 newbin =
ReadSaveTerm32((UBYTE *)r, binend, (UBYTE **)ppp, (UBYTE *)rend, top, 1);
4889 if ( newbin == (UBYTE *)r ) {
4890 return ( (UBYTE *)in );
4894 if ( out > keepsizep ) {
4897 INT32 extention = out - keepsizep;
4904 argEnd += extention;
4907 else if ( out < keepsizep ) {
4910 INT32 extention = keepsizep - out;
4917 argEnd -= extention;
4921 *newargsize = out - newargsize;
4926 MesPrint(
"ID %d not recognized.",
id);
4927 return ( (UBYTE *)in );
4930 *newsubtermp = out - newsubtermp + 1;
4933 if ( (UBYTE *)end >= top ) {
4939 *bout = (UBYTE *)out;
4941 ResizeCoeff32(bout, (UBYTE *)end, top);
4943 if ( *bout >= top ) {
4948 *newtermsize = (INT32 *)*bout - newtermsize;
4950 return ( (UBYTE *)in );
4981 if ( AO.transFlag ) {
4982 UBYTE *in, *end, *out, *outend, *p;
4985 WORD lenW = AO.SaveHeader.lenWORD;
4989 TELLFILE(AO.SaveData.Handle,&pos);
4993 half = (top-buffer)/2;
4994 if ( *size > half ) *size = half;
4995 if ( lenW < (WORD)
sizeof(WORD) ) {
4996 if ( *size * (LONG)
sizeof(WORD)/lenW > half ) *size = half*lenW/(LONG)
sizeof(WORD);
4999 if ( *size > half ) *size = half;
5010 if ( lenW ==
sizeof(WORD) ) in += half;
5013 outend = out + *size;
5015 if ( ReadFile(AO.SaveData.Handle, in, *size) != *size ) {
5016 return ( MesPrint(
"Error(3) reading stored expression.") );
5019 if ( AO.transFlag & 1 ) {
5022 while ( p <= end ) {
5023 AO.FlipWORD(p); p += lenW;
5028 if ( lenW > (WORD)
sizeof(WORD) ) {
5032 if ( outend > top ) outend = top;
5034 if ( p == in )
break;
5036 }
while ( in <= end - lenW );
5038 *size = in - buffer;
5043 while ( in < end ) {
5045 AO.ResizeNCWORD(in, out);
5046 in += lenW; out +=
sizeof(WORD);
5050 if ( lenW < (WORD)
sizeof(WORD) ) {
5052 while ( in < end ) {
5053 AO.ResizeWORD(in, out);
5054 in += lenW; out +=
sizeof(WORD);
5063 if ( p == in )
break;
5065 }
while ( in <= end -
sizeof(WORD) );
5066 *size = (in - buffer - half) * lenW / (ULONG)
sizeof(WORD);
5068 *outsize = out - buffer;
5070 SeekFile(AO.SaveData.Handle, &pos, SEEK_SET);
5075 return ( ReadFile(AO.SaveData.Handle, buffer, *size) != *size );
UBYTE * ReadSaveTerm32(UBYTE *bin, UBYTE *binend, UBYTE **bout, UBYTE *boutend, UBYTE *top, int terminbuf)
WORD ReadSaveIndex(FILEINDEX *fileind)
struct ReNuMbEr * RENUMBER
INDEXENTRY expression[INFILEINDEX]
WORD ReadSaveExpression(UBYTE *buffer, UBYTE *top, LONG *size, LONG *outsize)
struct StOrEcAcHe * STORECACHE
WORD ReadSaveVariables(UBYTE *buffer, UBYTE *top, LONG *size, LONG *outsize, INDEXENTRY *ind, LONG *stage)
WORD WriteStoreHeader(WORD handle)
struct FuNcTiOn * FUNCTIONS
WORD TermRenumber(WORD *term, RENUMBER renumber, WORD nexpr)
struct FiLeInDeX FILEINDEX