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;
276 LONG l = BASEPOSITION(*length);
278 memcpy(buffer,fi->POfill,l);
281 SeekFile(fi->
handle,pos,SEEK_SET);
282 if ( ReadFile(fi->
handle,buffer,l) != l ) {
283 if ( fi == AR.hidefile )
284 MesPrint(
"Error reading from hide file.");
286 MesPrint(
"Error reading from scratch file.");
304 LONG l = BASEPOSITION(*length), avail;
306 fi->POfill = fi->POfull;
307 while ( fi->POfill+l/
sizeof(WORD) > fi->POstop ) {
308 avail = (fi->POstop-fi->POfill)*
sizeof(WORD);
310 memcpy(fi->POfill,buffer,avail);
311 l -= avail; buffer += avail;
314 if ( ( fi->
handle = (WORD)CreateFile(fi->name) ) < 0 ) {
315 if ( fi == AR.hidefile )
316 MesPrint(
"Cannot create hide file %s",fi->name);
318 MesPrint(
"Cannot create scratch file %s",fi->name);
321 PUTZERO(fi->POposition);
323 SeekFile(fi->
handle,&(fi->POposition),SEEK_SET);
324 if ( WriteFile(fi->
handle,(UBYTE *)fi->PObuffer,fi->POsize) != fi->POsize )
326 ADDPOS(fi->POposition,fi->POsize);
327 fi->POfill = fi->POfull = fi->PObuffer;
330 memcpy(fi->POfill,buffer,l);
331 fi->POfill += l/
sizeof(WORD);
332 fi->POfull = fi->POfill;
334 if ( withflush && fi->
handle >= 0 && fi->POfill > fi->PObuffer ) {
335 l = (LONG)fi->POfill - (LONG)fi->PObuffer;
336 SeekFile(fi->
handle,&(fi->POposition),SEEK_SET);
337 if ( WriteFile(fi->
handle,(UBYTE *)fi->PObuffer,l) != l )
goto writeerror;
338 ADDPOS(fi->POposition,fi->POsize);
339 fi->POfill = fi->POfull = fi->PObuffer;
341 if ( withflush && fi->
handle >= 0 )
342 SETBASEPOSITION(fi->filesize,TellFile(fi->
handle));
345 if ( fi == AR.hidefile )
346 MesPrint(
"Error writing to hide file. Disk full?");
348 MesPrint(
"Error writing to scratch file. Disk full?");
363int CoSave(UBYTE *inp)
368 WORD error = 0, type, number;
369 LONG RetCode = 0, wSize;
373 WORD TMproto[SUBEXPSIZE];
375 int ii, j =
sizeof(
FILEINDEX)/(
sizeof(LONG));
377 while ( *inp ==
',' ) inp++;
381 if( PF.me != MASTER)
return(0);
384 if ( !*p )
return(MesPrint(
"No filename in save statement"));
385 if ( FG.cTable[*p] > 1 && ( *p !=
'.' ) && ( *p != SEPARATOR ) && ( *p != ALTSEPARATOR ) )
386 return(MesPrint(
"Illegal filename"));
387 while ( *++p && *p !=
',' ) {}
390 if ( !AP.preError ) {
391 if ( ( RetCode = CreateFile((
char *)inp) ) < 0 ) {
392 return(MesPrint(
"Cannot open file %s",inp));
395 AO.SaveData.Handle = (WORD)RetCode;
404 if (
WriteStoreHeader(AO.SaveData.Handle) )
return(MesPrint(
"Error writing storage file header"));
407 lo = (LONG *)(&AO.SaveData.Index);
408 for ( ii = 0; ii < j; ii++ ) *lo++ = 0;
409 SETBASEPOSITION(AO.SaveData.Position,(LONG)
sizeof(
STOREHEADER));
410 ind = AO.SaveData.Index.expression;
411 if ( !AP.preError && WriteFile(AO.SaveData.Handle,(UBYTE *)(&(AO.SaveData.Index))
413 SeekFile(AO.SaveData.Handle,&(filesize),SEEK_END);
417 if ( !FG.cTable[*p] || *p ==
'[' ) {
419 if ( p == 0 )
return(-1);
422 if ( GetVar(inp,&type,&number,CEXPRESSION,NOAUTO) != NAMENOTFOUND ) {
423 if ( e[number].status == STOREDEXPRESSION ) {
429 if ( AP.preError )
goto NextExpr;
430 TMproto[0] = EXPRESSION;
431 TMproto[1] = SUBEXPSIZE;
434 {
int ie;
for ( ie = 4; ie < SUBEXPSIZE; ie++ ) TMproto[ie] = 0; }
436 if ( ( indold = FindInIndex(number,&AR.StoreData,0,0) ) != 0 ) {
441 SeekFile(AO.SaveData.Handle,&(AO.SaveData.Index.next),SEEK_END);
442 scrpos = AO.SaveData.Position;
443 SeekFile(AO.SaveData.Handle,&scrpos,SEEK_SET);
444 if ( ISNOTEQUALPOS(scrpos,AO.SaveData.Position) )
goto SavWrt;
445 if ( WriteFile(AO.SaveData.Handle,(UBYTE *)(&(AO.SaveData.Index))
449 AO.SaveData.Position = AO.SaveData.Index.next;
450 lo = (LONG *)(&AO.SaveData.Index);
451 for ( ii = 0; ii < j; ii++ ) *lo++ = 0;
452 ind = AO.SaveData.Index.expression;
453 scrpos = AO.SaveData.Position;
454 SeekFile(AO.SaveData.Handle,&scrpos,SEEK_SET);
455 if ( ISNOTEQUALPOS(scrpos,AO.SaveData.Position) )
goto SavWrt;
456 if ( WriteFile(AO.SaveData.Handle,(UBYTE *)(&(AO.SaveData.Index))
459 ADDPOS(filesize,
sizeof(
struct FiLeInDeX));
468 SeekFile(AR.StoreData.Handle,&(indold->
variables),SEEK_SET);
469 wSize = TOLONG(AT.WorkTop) - TOLONG(AT.WorkPointer);
472 ADD2POS(filesize,scrpos);
473 SETBASEPOSITION(scrpos1,wSize);
475 if ( ISLESSPOS(scrpos,scrpos1) ) wSize = BASEPOSITION(scrpos);
476 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)AT.WorkPointer,wSize)
478 MesPrint(
"ReadError");
482 if ( WriteFile(AO.SaveData.Handle,(UBYTE *)AT.WorkPointer,wSize)
483 != wSize )
goto SavWrt;
484 ADDPOS(scrpos,-wSize);
485 }
while ( ISPOSPOS(scrpos) );
486 ADDPOS(AO.SaveData.Index.number,1);
493 MesPrint(
"%s is not a stored expression",inp);
499 MesPrint(
"%s is not an expression",inp);
503 if ( c !=
',' && c ) {
504 MesComp(
"Illegal character",inp,p);
511 if ( !AP.preError ) {
512 scrpos = AO.SaveData.Position;
513 SeekFile(AO.SaveData.Handle,&scrpos,SEEK_SET);
514 if ( ISNOTEQUALPOS(scrpos,AO.SaveData.Position) )
goto SavWrt;
517 WriteFile(AO.SaveData.Handle,(UBYTE *)(&(AO.SaveData.Index))
520 else if ( !AP.preError ) {
522 if ( e->status == STOREDEXPRESSION )
break;
524 }
while ( --n > 0 ); }
526 wSize = TOLONG(AT.WorkTop) - TOLONG(AT.WorkPointer);
528 SeekFile(AR.StoreData.Handle,&scrpos,SEEK_SET);
529 scrpos = AR.StoreData.Fill;
530 SETBASEPOSITION(scrpos1,wSize);
532 if ( ISLESSPOS(scrpos,scrpos1) ) wSize = BASEPOSITION(scrpos);
533 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)AT.WorkPointer,wSize) != wSize ) {
534 MesPrint(
"ReadError");
538 if ( WriteFile(AO.SaveData.Handle,(UBYTE *)AT.WorkPointer,wSize) != wSize )
540 ADDPOS(scrpos,-wSize);
541 }
while ( ISPOSPOS(scrpos) );
545 if ( !AP.preError ) {
546 CloseFile(AO.SaveData.Handle);
547 AO.SaveData.Handle = -1;
551 MesPrint(
"WriteError");
561int CoLoad(UBYTE *inp)
567 WORD num, i, error = 0;
568 WORD type, number, silentload = 0;
569 WORD TMproto[SUBEXPSIZE];
571 while ( *inp ==
',' ) inp++;
573 if ( ( *p ==
',' && p[1] ==
'-' ) || *p ==
'-' ) {
574 if ( *p ==
',' ) p++;
576 if ( *p ==
's' || *p ==
'S' ) {
578 while ( *p && ( *p !=
',' && *p !=
'-' && *p !=
'+'
579 && *p != SEPARATOR && *p != ALTSEPARATOR && *p !=
'.' ) ) p++;
581 else if ( *p !=
',' ) {
582 return(MesPrint(
"Illegal option in Load statement"));
584 while ( *p ==
',' ) p++;
587 if ( !*p )
return(MesPrint(
"No filename in load statement"));
588 if ( FG.cTable[*p] > 1 && ( *p !=
'.' ) && ( *p != SEPARATOR ) && ( *p != ALTSEPARATOR ) )
589 return(MesPrint(
"Illegal filename"));
590 while ( *++p && *p !=
',' ) {}
593 if ( ( RetCode = OpenFile((
char *)inp) ) < 0 ) {
594 return(MesPrint(
"Cannot open file %s",inp));
602 AO.SaveData.Handle = (WORD)(RetCode);
604#ifdef SYSDEPENDENTSAVE
605 if ( ReadFile(AO.SaveData.Handle,(UBYTE *)(&(AO.SaveData.Index)),
609 TELLFILE(AO.SaveData.Handle,&firstposition);
617 if ( !FG.cTable[*p] || *p ==
'[' ) {
619 if ( p == 0 )
return(-1);
622 if ( GetVar(inp,&type,&number,ALLVARIABLES,NOAUTO) != NAMENOTFOUND ) {
623 MesPrint(
"Conflicting name: %s",inp);
627 if ( ( num = EntVar(CEXPRESSION,inp,STOREDEXPRESSION,0,0,0) ) >= 0 ) {
628 TMproto[0] = EXPRESSION;
629 TMproto[1] = SUBEXPSIZE;
632 {
int ie;
for ( ie = 4; ie < SUBEXPSIZE; ie++ ) TMproto[ie] = 0; }
634 SeekFile(AO.SaveData.Handle,&firstposition,SEEK_SET);
635 AO.SaveData.Position = firstposition;
637 if ( ( ind = FindInIndex(num,&AO.SaveData,1,0) ) != 0 ) {
639 if ( PutInStore(ind,num) ) error = -1;
640 else if ( !AM.silent && silentload == 0 )
641 MesPrint(
" %s loaded",ind->name);
646 Expressions[num].counter = -1;
649 MesPrint(
" %s not found",inp);
656 if ( c !=
',' && c ) {
657 MesComp(
"Illegal character",inp,p);
664 scrpos = AR.StoreData.Position;
665 SeekFile(AR.StoreData.Handle,&scrpos,SEEK_SET);
666 if ( ISNOTEQUALPOS(scrpos,AR.StoreData.Position) )
goto LoadWrt;
667 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)(&(AR.StoreData.Index))
671 i = (WORD)BASEPOSITION(AO.SaveData.Index.number);
672 ind = AO.SaveData.Index.expression;
673#ifdef SYSDEPENDENTSAVE
675 if ( GetVar((UBYTE *)(ind->name),&type,&number,ALLVARIABLES,NOAUTO) != NAMENOTFOUND ) {
676 MesPrint(
"Conflicting name: %s",ind->name);
680 if ( ( num = EntVar(CEXPRESSION,(UBYTE *)(ind->name),STOREDEXPRESSION,0,0,0) ) >= 0 ) {
682 if ( PutInStore(ind,num) ) error = -1;
683 else if ( !AM.silent && silentload == 0 )
684 MesPrint(
" %s loaded",ind->name);
690 if ( i == 0 && ISNOTZEROPOS(AO.SaveData.Index.next) ) {
691 SeekFile(AO.SaveData.Handle,&(AO.SaveData.Index.next),SEEK_SET);
692 if ( ReadFile(AO.SaveData.Handle,(UBYTE *)(&(AO.SaveData.Index)),
694 i = (WORD)BASEPOSITION(AO.SaveData.Index.number);
695 ind = AO.SaveData.Index.expression;
702 if ( GetVar((UBYTE *)(ind->name),&type,&number,ALLVARIABLES,NOAUTO) != NAMENOTFOUND ) {
703 MesPrint(
"Conflicting name: %s",ind->name);
707 if ( ( num = EntVar(CEXPRESSION,(UBYTE *)(ind->name),STOREDEXPRESSION,0,0,0) ) >= 0 ) {
709 if ( PutInStore(ind,num) ) error = -1;
710 else if ( !AM.silent && silentload == 0 )
711 MesPrint(
" %s loaded",ind->name);
717 if ( i == 0 && (ISNOTZEROPOS(AO.SaveData.Index.next) || AO.bufferedInd) ) {
718 SeekFile(AO.SaveData.Handle,&(AO.SaveData.Index.next),SEEK_SET);
720 i = (WORD)BASEPOSITION(AO.SaveData.Index.number);
721 ind = AO.SaveData.Index.expression;
729#ifndef SYSDEPENDENTSAVE
730 if ( AO.powerFlag ) {
731 MesPrint(
"WARNING: min-/maxpower had to be adjusted!");
733 if ( AO.resizeFlag ) {
734 MesPrint(
"ERROR: could not downsize data!");
738 CloseFile(AO.SaveData.Handle);
739 AO.SaveData.Handle = -1;
740 SeekFile(AR.StoreData.Handle,&(AC.StoreFileSize),SEEK_END);
743 MesPrint(
"WriteError");
747 MesPrint(
"ReadError");
761WORD DeleteStore(WORD par)
768 if ( AR.StoreData.Handle >= 0 ) {
772 e_in = e_out = Expressions;
774 if ( e_in->status == STOREDEXPRESSION ) {
776 AC.exprnames->namebuffer+e_in->name);
777 node->type = CDELETE;
781 if ( e_out != e_in ) {
783 node = GetNode(AC.exprnames,
784 AC.exprnames->namebuffer+e_in->name);
785 node->number = (WORD)(e_out - Expressions);
786 e_out->onfile = e_in->onfile;
787 e_out->prototype = e_in->prototype;
788 e_out->printflag = 0;
789 e_out->status = e_in->status;
790 e_out->name = e_in->name;
791 e_out->inmem = e_in->inmem;
792 e_out->counter = e_in->counter;
793 e_out->numfactors = e_in->numfactors;
794 e_out->numdummies = e_in->numdummies;
795 e_out->compression = e_in->compression;
796 e_out->namesize = e_in->namesize;
797 e_out->whichbuffer = e_in->whichbuffer;
798 e_out->hidelevel = e_in->hidelevel;
799 e_out->node = e_in->node;
800 e_out->replace = e_in->replace;
801 e_out->vflags = e_in->vflags;
803 e_out->partodo = e_in->partodo;
810 }
while ( --n > 0 ); }
812 if ( DidClean ) CompactifyTree(AC.exprnames,EXPRNAMES);
814 AR.StoreData.Handle = -1;
815 CloseFile(AC.StoreHandle);
824 SETBASEPOSITION(st->position,-1);
825 SETBASEPOSITION(st->toppos,-1);
829 for ( j = 1; j < AM.totalnumberofthreads; j++ ) {
832 SETBASEPOSITION(st->position,-1);
833 SETBASEPOSITION(st->toppos,-1);
839 PUTZERO(AC.StoreFileSize);
840 s = FG.fname;
while ( *s ) s++;
842 *s =
';'; s[1] =
'*'; s[2] = 0;
846 return(AC.StoreHandle = CreateFile(FG.fname));
866#ifndef SYSDEPENDENTSAVE
871 newind = NextFileIndex(&(Expressions[num].onfile));
873#ifndef SYSDEPENDENTSAVE
874 SETBASEPOSITION(newind->length, 0);
876 newind->variables = AR.StoreData.Fill;
877 SeekFile(AR.StoreData.Handle,&(newind->variables),SEEK_SET);
878 if ( ISNOTEQUALPOS(newind->variables,AR.StoreData.Fill) )
goto PutErrS;
879 newind->position = newind->variables;
880#ifdef SYSDEPENDENTSAVE
885 SeekFile(AO.SaveData.Handle,&scrpos,SEEK_SET);
886 if ( ISNOTEQUALPOS(scrpos,ind->
variables) )
goto PutErrS;
888 wSize = TOLONG(AT.WorkTop) - TOLONG(AT.WorkPointer);
889#ifdef SYSDEPENDENTSAVE
892 ADD2POS(AR.StoreData.Fill,scrpos);
894 SETBASEPOSITION(scrpos1,wSize);
895#ifndef SYSDEPENDENTSAVE
898 AO.tensorList = (UBYTE *)Malloc1(MAXSAVEFUNCTION,
"PutInStore");
904 wSize = TOLONG(AT.WorkTop) - TOLONG(AT.WorkPointer);
905 if ( ISLESSPOS(scrpos,scrpos1) ) wSize = BASEPOSITION(scrpos);
908 (UBYTE *)AT.WorkPointer, (UBYTE *)AT.WorkTop, &wSize, &wSizeOut, ind, &stage) ) {
911 if ( WriteFile(AR.StoreData.Handle, (UBYTE *)AT.WorkPointer, wSizeOut)
912 != wSizeOut )
goto PutErrS;
913 ADDPOS(scrpos,-wSize);
914 ADDPOS(newind->position, wSizeOut);
915 ADDPOS(AR.StoreData.Fill, wSizeOut);
916 }
while ( ISPOSPOS(scrpos) );
918 wSize = TOLONG(AT.WorkTop) - TOLONG(AT.WorkPointer);
922 wSize = TOLONG(AT.WorkTop) - TOLONG(AT.WorkPointer);
923 if ( ISLESSPOS(scrpos,scrpos1) ) wSize = BASEPOSITION(scrpos);
924#ifdef SYSDEPENDENTSAVE
925 if ( ReadFile(AO.SaveData.Handle,(UBYTE *)AT.WorkPointer,wSize)
926 != wSize )
goto PutErrS;
927 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)AT.WorkPointer,wSize)
928 != wSize )
goto PutErrS;
929 ADDPOS(scrpos,-wSize);
933 if (
ReadSaveExpression((UBYTE *)AT.WorkPointer, (UBYTE *)AT.WorkTop, &wSize, &wSizeOut) ) {
937 if ( WriteFile(AR.StoreData.Handle, (UBYTE *)AT.WorkPointer, wSizeOut)
938 != wSizeOut )
goto PutErrS;
939 ADDPOS(scrpos,-wSize);
940 ADDPOS(AR.StoreData.Fill, wSizeOut);
941 ADDPOS(newind->length, wSizeOut);
943 }
while ( ISPOSPOS(scrpos) );
946 M_free(AO.tensorList,
"PutInStore");
948 scrpos = AR.StoreData.Position;
949 SeekFile(AR.StoreData.Handle,&scrpos,SEEK_SET);
950 if ( ISNOTEQUALPOS(scrpos,AR.StoreData.Position) )
goto PutErrS;
951 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)(&AR.StoreData.Index),(LONG)
sizeof(
FILEINDEX))
954 return(MesPrint(
"File error"));
980WORD GetTerm(PHEAD WORD *term)
983 WORD *inp, i, j = 0, len;
984 LONG InIn, *whichInInBuf;
985 WORD *r, *m, *mstop = 0, minsiz = 0, *bra = 0, *from;
986 WORD first, *start = 0, testing = 0;
989 if ( AR.GetFile == 2 ) {
991 whichInInBuf = &(AR.InHiBuf);
995 whichInInBuf = &(AR.InInBuf);
997 InIn = *whichInInBuf;
999 if ( AR.KeptInHold ) {
1000 r = AR.CompressBuffer;
1003 if ( i <= 0 ) { *term = 0;
goto RegRet; }
1008 if ( AR.DeferFlag ) {
1009 m = AR.CompressBuffer;
1012 mstop -= ABS(mstop[-1]);
1014 while ( m < mstop ) {
1015 if ( *m == HAAKJE ) {
1018 bra = (WORD *)(((UBYTE *)(term)) + 2*AM.MaxTer);
1019 m = AR.CompressBuffer+1;
1021 while ( m < mstop ) *r++ = *m++;
1023 minsiz = WORDDIF(mstop,bra);
1032 bra = (WORD *)(((UBYTE *)(term)) + 2*AM.MaxTer);
1040 r = AR.CompressBuffer;
1043 ADDPOS(fi->POposition,(fi->POfull-fi->PObuffer)*
sizeof(WORD));
1044 LOCK(AS.inputslock);
1045 SeekFile(fi->
handle,&(fi->POposition),SEEK_SET);
1046 InIn = ReadFile(fi->
handle,(UBYTE *)(fi->PObuffer),fi->POsize);
1047 UNLOCK(AS.inputslock);
1048 if ( ( InIn < 0 ) || ( InIn & 1 ) ) {
1054 InIn /= TABLESIZE(WORD,UBYTE);
1056 *whichInInBuf = InIn;
1057 if ( !InIn ) { *r = 0; *from = 0;
goto RegRet; }
1058 fi->POfill = fi->PObuffer;
1059 fi->POfull = fi->PObuffer + InIn;
1062 if ( ( len = i = *inp ) == 0 ) {
1075 while ( ++i <= 0 ) *term++ = *r++;
1080 *(AR.CompressBuffer) = len = *start;
1093 while ( --i >= 0 ) {
1094 *r++ = *term++ = *inp++;
1098 ADDPOS(fi->POposition,(fi->POfull-fi->PObuffer)*
sizeof(WORD));
1099 LOCK(AS.inputslock);
1100 SeekFile(fi->
handle,&(fi->POposition),SEEK_SET);
1101 InIn = ReadFile(fi->
handle,(UBYTE *)(fi->PObuffer),fi->POsize);
1102 UNLOCK(AS.inputslock);
1103 if ( ( InIn <= 0 ) || ( InIn & 1 ) ) {
1109 InIn /= TABLESIZE(WORD,UBYTE);
1112 fi->POfull = inp + InIn;
1118 *(AR.CompressBuffer) = len = *start;
1121 while ( --j >= 0 ) { *r++ = *term++ = *inp++; }
1124 *whichInInBuf = InIn;
1125 AR.DefPosition = fi->POposition;
1126 ADDPOS(AR.DefPosition,((UBYTE *)(fi->POfill)-(UBYTE *)(fi->PObuffer)));
1130 if ( inp >= fi->POfull ) { *from = 0;
goto RegRet; }
1134 *term++ = *r++ = len = - j + 1 + *inp;
1135 while ( ++j <= 0 ) *term++ = *r++;
1138 else if ( !j ) j = 1;
1139 while ( --j >= 0 ) { *r++ = *term++ = *inp++; }
1142 SETBASEPOSITION(AR.DefPosition,((UBYTE *)(fi->POfill)-(UBYTE *)(fi->PObuffer)));
1143 if ( inp > fi->POfull ) {
1147 if ( r >= AR.ComprTop ) {
1148 MesPrint(
"CompressSize of %10l is insufficient",AM.CompressSize);
1151 AR.CompressPointer = r; *r = 0;
1156 if ( testing && *from != 0 ) {
1159 jj = *r - 1 - ABS(*(r+*r-1));
1160 if ( jj < minsiz )
goto strip;
1163 while ( m < mstop ) {
1167 mstop = m - ABS(m[-1]);
1169 while ( r < mstop ) {
1170 if ( *r == HAAKJE ) {
1174 len = WORDDIF(r,from);
1196 if ( ( AP.PreDebug & DUMPINTERMS ) == DUMPINTERMS ) {
1197 MLOCK(ErrorMessageLock);
1198 AO.OutFill = AO.OutputLine = OutBuf;
1203 TokenToLine((UBYTE *)(
"Input: "));
1205 TokenToLine((UBYTE *)
"zero");
1208 TokenToLine((UBYTE *)
"negative!!");
1211 while ( --i >= 0 ) {
1212 TalToLine((UWORD)(*r++)); TokenToLine((UBYTE *)
" ");
1216 MUNLOCK(ErrorMessageLock);
1224 MesPrint(
"Error while reading scratch file in GetTerm");
1260 WORD *r, *rr = AR.CompressPointer;
1275 if ( AT.identity > 0 ) par = 1;
1285 siz = ReadPosFile(BHEAD fi,(UBYTE *)term,1L,pos);
1288 LOCK(AS.inputslock);
1289 SeekFile(fi->
handle,pos,SEEK_SET);
1290 siz = ReadFile(fi->
handle,(UBYTE *)term,
sizeof(WORD));
1291 UNLOCK(AS.inputslock);
1294 if ( siz ==
sizeof(WORD) ) {
1297 if ( ( i > AM.MaxTer/((WORD)
sizeof(WORD)) ) || ( -i >= AM.MaxTer/((WORD)
sizeof(WORD)) ) )
1305 while ( ++i <= 0 ) *term++ = *r++;
1307 siz = ReadPosFile(BHEAD fi,(UBYTE *)term,1L,pos);
1310 LOCK(AS.inputslock);
1311 SeekFile(fi->
handle,pos,SEEK_SET);
1312 siz = ReadFile(fi->
handle,(UBYTE *)term,
sizeof(WORD));
1313 UNLOCK(AS.inputslock);
1314 ADDPOS(*pos,
sizeof(WORD));
1316 if ( siz !=
sizeof(WORD) ) {
1322 if ( ( j > AM.MaxTer/((WORD)
sizeof(WORD)) ) || ( j <= 0 ) )
1330 if ( !j )
return(0);
1335 siz = ReadPosFile(BHEAD fi,(UBYTE *)term,j,pos);
1336 j *= TABLESIZE(WORD,UBYTE);
1339 j *= TABLESIZE(WORD,UBYTE);
1340 LOCK(AS.inputslock);
1341 SeekFile(fi->
handle,pos,SEEK_SET);
1342 siz = ReadFile(fi->
handle,(UBYTE *)term,j);
1343 UNLOCK(AS.inputslock);
1350 while ( --i >= 0 ) *r++ = *term++;
1351 if ( r >= AR.ComprTop ) {
1352 MLOCK(ErrorMessageLock);
1353 MesPrint(
"CompressSize of %10l is insufficient",AM.CompressSize);
1354 MUNLOCK(ErrorMessageLock);
1357 AR.CompressPointer = r; *r = 0;
1366 fi->POfill = (WORD *)((UBYTE *)(fi->PObuffer) + BASEPOSITION(*pos));
1368 if ( p >= fi->POfull ) { *term = 0;
return(0); }
1372 j = *r++ = *term++ = -i + 1 + *p;
1373 while ( ++i <= 0 ) *term++ = *r++;
1376 if ( i == 0 ) { i = 1; *r++ = 0; *term++ = 0; }
1377 else {
while ( --i >= 0 ) { *r++ = *term++ = *p++; } }
1379 SETBASEPOSITION(*pos,(UBYTE *)(fi->POfill)-(UBYTE *)(fi->PObuffer));
1380 if ( p <= fi->POfull ) {
1381 if ( r >= AR.ComprTop ) {
1382 MLOCK(ErrorMessageLock);
1383 MesPrint(
"CompressSize of %10l is insufficient",AM.CompressSize);
1384 MUNLOCK(ErrorMessageLock);
1387 AR.CompressPointer = r; *r = 0;
1393 MLOCK(ErrorMessageLock);
1394 MesPrint(
"Error while reading scratch file in GetOneTerm (%d)",error);
1395 MUNLOCK(ErrorMessageLock);
1412WORD GetMoreTerms(WORD *term)
1415 WORD *t, *r, *m, *h, *tstop, i, inc, same;
1421 extra = ((AM.MaxTer/
sizeof(WORD))*((LONG)100-AC.CollectPercentage))/100;
1422 if ( extra < 23 ) extra = 23;
1427 tstop = t - ABS(t[-1]);
1429 while ( *h != HAAKJE && h < tstop ) h += h[1];
1430 if ( h >= tstop )
return(retval);
1431 inc = FUNHEAD+ARGHEAD+1-h[1];
1432 same = WORDDIF(h,term) + h[1] - 1;
1435 while ( t > tstop ) *--r = *--t;
1438 while ( GetTerm(BHEAD m) > 0 ) {
1441 if ( same > ( i = ( *m - ABS(*t) -1 ) ) ) {
1442 if ( AC.AltCollectFun && AS.CollectOverFlag == 2 ) AS.CollectOverFlag = 3;
1447 while ( --i >= 0 ) {
1449 if ( AC.AltCollectFun && AS.CollectOverFlag == 2 ) AS.CollectOverFlag = 3;
1454 if ( ( WORDDIF(m,term) + i + extra ) > (WORD)(AM.MaxTer/
sizeof(WORD)) ) {
1456 if ( AS.CollectOverFlag == 0 && AC.AltCollectFun == 0 ) {
1457 Warning(
"Bracket contents too long in Collect statement");
1458 Warning(
"Contents spread over more than one term");
1459 Warning(
"If possible: increase MaxTermSize in setfile");
1460 AS.CollectOverFlag = 1;
1462 else if ( AC.AltCollectFun ) {
1463 AS.CollectOverFlag = 2;
1470 while ( r < tstop ) *m++ = *r++;
1472 if ( extra == 23 ) extra = ((AM.MaxTer/
sizeof(WORD))/6);
1475 h[1] = WORDDIF(m,h);
1476 if ( AS.CollectOverFlag > 1 ) {
1477 *h = AC.AltCollectFun;
1478 if ( AS.CollectOverFlag == 3 ) AS.CollectOverFlag = 1;
1480 else *h = AC.CollectFun;
1482 h[FUNHEAD] = h[1] - FUNHEAD;
1484 if ( ToFast(h+FUNHEAD,h+FUNHEAD) ) {
1485 if ( h[FUNHEAD] <= -FUNCTION ) {
1497 *term = WORDDIF(m,term);
1508WORD GetMoreFromMem(WORD *term, WORD **tpoin)
1511 WORD *t, *r, *m, *h, *tstop, i, j, inc, same;
1517 tstop = t - ABS(t[-1]);
1519 while ( *h != HAAKJE && h < tstop ) h += h[1];
1520 if ( h >= tstop )
return(0);
1521 inc = FUNHEAD+ARGHEAD+1-h[1];
1522 same = WORDDIF(h,term) + h[1] - 1;
1525 while ( t > tstop ) *--r = *--t;
1530 for ( i = 0; i < j; i++ ) m[i] = *r++;
1534 if ( same > ( i = ( *m - ABS(*t) -1 ) ) ) {
1535 if ( AC.AltCollectFun && AS.CollectOverFlag == 2 ) AS.CollectOverFlag = 3;
1540 while ( --i >= 0 ) {
1542 if ( AC.AltCollectFun && AS.CollectOverFlag == 2 ) AS.CollectOverFlag = 3;
1547 if ( ( WORDDIF(m,term) + i + extra ) > (LONG)(AM.MaxTer/(2*
sizeof(WORD))) ) {
1549 if ( AS.CollectOverFlag == 0 && AC.AltCollectFun == 0 ) {
1550 Warning(
"Bracket contents too long in Collect statement");
1551 Warning(
"Contents spread over more than one term");
1552 Warning(
"If possible: increase MaxTermSize in setfile");
1553 AS.CollectOverFlag = 1;
1555 else if ( AC.AltCollectFun ) {
1556 AS.CollectOverFlag = 2;
1563 while ( r < tstop ) *m++ = *r++;
1564 if ( extra == 23 ) extra = ((AM.MaxTer/
sizeof(WORD))/6);
1567 h[1] = WORDDIF(m,h);
1568 if ( AS.CollectOverFlag > 1 ) {
1569 *h = AC.AltCollectFun;
1570 if ( AS.CollectOverFlag == 3 ) AS.CollectOverFlag = 1;
1572 else *h = AC.CollectFun;
1574 h[FUNHEAD] = h[1] - FUNHEAD;
1576 if ( ToFast(h+FUNHEAD,h+FUNHEAD) ) {
1577 if ( h[FUNHEAD] <= -FUNCTION ) {
1589 *term = WORDDIF(m,term);
1615WORD GetFromStore(WORD *to,
POSITION *position,
RENUMBER renumber, WORD *InCompState, WORD nexpr)
1618 LONG RetCode, num, first = 0;
1623 WORD *r, *rr = AR.CompressPointer;
1626 sc.next = AT.StoreCache;
1633 if ( BASEPOSITION(s->position) == -1 )
break;
1634 if ( ISLESSPOS(*position,s->toppos) &&
1635 ISGEPOS(*position,s->position) ) {
1636 if ( AT.StoreCache != s ) {
1637 sold->next = s->next;
1638 s->next = AT.StoreCache->next;
1641 from = (WORD *)(((UBYTE *)(s->buffer)) + DIFBASE(*position,s->position));
1643 if ( !num ) {
return(*to = 0); }
1644 *InCompState = (WORD)num;
1648 ADDPOS(*position,
sizeof(WORD));
1649 *m++ = (WORD)(-num+1);
1651 while ( ++num <= 0 ) *m++ = *r++;
1652 if ( ISLESSPOS(*position,s->toppos) ) {
1655 ADDPOS(*position,
sizeof(WORD));
1656 *InCompState = (WORD)(num + 2);
1664 while ( num > 0 && ISLESSPOS(*position,s->toppos) ) {
1665 *r++ = *m++ = *from++; ADDPOS(*position,
sizeof(WORD)); num--;
1669 SETBASEPOSITION(s->position,-1);
1670 SETBASEPOSITION(s->toppos,-1);
1671 LOCK(AM.storefilelock);
1672 SeekFile(AR.StoreData.Handle,position,SEEK_SET);
1673 RetCode = ReadFile(AR.StoreData.Handle,(UBYTE *)(s->buffer),AM.SizeStoreCache);
1674 UNLOCK(AM.storefilelock);
1675 if ( RetCode < 0 )
goto PastErr;
1676 if ( !RetCode )
return( *to = 0 );
1677 s->position = *position;
1678 s->toppos = *position;
1679 ADDPOS(s->toppos,RetCode);
1683 ADDPOS(*position,
sizeof(WORD));
1686 *InCompState = (WORD)(num + 2);
1693 if ( AT.StoreCache ) {
1694 s->position = *position;
1695 LOCK(AM.storefilelock);
1696 SeekFile(AR.StoreData.Handle,position,SEEK_SET);
1697 RetCode = ReadFile(AR.StoreData.Handle,(UBYTE *)(s->buffer),AM.SizeStoreCache);
1698 UNLOCK(AM.storefilelock);
1699 if ( RetCode < 0 )
goto PastErr;
1700 if ( !RetCode )
return( *to = 0 );
1701 s->toppos = *position;
1702 ADDPOS(s->toppos,RetCode);
1703 if ( AT.StoreCache != s ) {
1704 sold->next = s->next;
1705 s->next = AT.StoreCache->next;
1711 if ( !num ) {
return( *to = 0 ); }
1712 *InCompState = (WORD)num;
1714 *m++ = (WORD)(-num+1);
1717 ADDPOS(*position,
sizeof(WORD));
1718 while ( ++num <= 0 ) *m++ = *r++;
1721 ADDPOS(*position,
sizeof(WORD));
1722 *InCompState = (WORD)(num+2);
1727 LOCK(AM.storefilelock);
1728 SeekFile(AR.StoreData.Handle,position,SEEK_SET);
1729 RetCode = ReadFile(AR.StoreData.Handle,(UBYTE *)to,(LONG)
sizeof(WORD));
1730 SeekFile(AR.StoreData.Handle,position,SEEK_CUR);
1731 UNLOCK(AM.storefilelock);
1732 if ( RetCode !=
sizeof(WORD) ) {
1734 return((WORD)RetCode);
1736 if ( !*to )
return(0);
1740 *to = *r++ = (WORD)(-num + 1);
1741 while ( ++num <= 0 ) *m++ = *r++;
1742 LOCK(AM.storefilelock);
1743 SeekFile(AR.StoreData.Handle,position,SEEK_SET);
1744 RetCode = ReadFile(AR.StoreData.Handle,(UBYTE *)m,(LONG)
sizeof(WORD));
1745 SeekFile(AR.StoreData.Handle,position,SEEK_CUR);
1746 UNLOCK(AM.storefilelock);
1747 if ( RetCode !=
sizeof(WORD) ) {
1748 MLOCK(ErrorMessageLock);
1749 MesPrint(
"@Error in compression of store file");
1750 MUNLOCK(ErrorMessageLock);
1755 *InCompState = (WORD)(num + 2);
1759 num = *to - 1; m = to + 1; r = rr + 1;
1762 num *= wsizeof(WORD);
1764 MLOCK(ErrorMessageLock);
1765 MesPrint(
"@Error in stored expressions file at position %9p",position);
1766 MUNLOCK(ErrorMessageLock);
1769 LOCK(AM.storefilelock);
1770 SeekFile(AR.StoreData.Handle,position,SEEK_SET);
1771 RetCode = ReadFile(AR.StoreData.Handle,(UBYTE *)m,num);
1772 SeekFile(AR.StoreData.Handle,position,SEEK_CUR);
1773 UNLOCK(AM.storefilelock);
1774 if ( RetCode != num ) {
1775 MLOCK(ErrorMessageLock);
1776 MesPrint(
"@Error in stored expressions file at position %9p",position);
1777 MUNLOCK(ErrorMessageLock);
1783 if ( r >= AR.ComprTop ) {
1784 MLOCK(ErrorMessageLock);
1785 MesPrint(
"CompressSize of %10l is insufficient",AM.CompressSize);
1786 MUNLOCK(ErrorMessageLock);
1789 AR.CompressPointer = r; *r = 0;
1791 MarkDirty(to,DIRTYSYMFLAG);
1792 if ( AR.CurDum > AM.IndDum && Expressions[nexpr].numdummies > 0 )
1793 MoveDummies(BHEAD to,AR.CurDum - AM.IndDum);
1797 MLOCK(ErrorMessageLock);
1798 MesCall(
"GetFromStore");
1799 MUNLOCK(ErrorMessageLock);
1814VOID DetVars(WORD *term, WORD par)
1820 stopper = term + *term - 1;
1821 stopper = stopper - ABS(*stopper) + 1;
1825 if ( ( n = NumSymbols ) > 0 ) {
1829 (tt++)->flags &= ~INUSE;
1830 }
while ( --n > 0 );
1832 if ( ( n = NumIndices ) > 0 ) {
1836 (tt++)->flags &= ~INUSE;
1837 }
while ( --n > 0 );
1839 if ( ( n = NumVectors ) > 0 ) {
1843 (tt++)->flags &= ~INUSE;
1844 }
while ( --n > 0 );
1846 if ( ( n = NumFunctions ) > 0 ) {
1850 (tt++)->flags &= ~INUSE;
1851 }
while ( --n > 0 );
1854 while ( term < stopper ) {
1855 if ( *term == SYMTOSYM || *term == SYMTONUM ) {
1857 AN.UsedSymbol[*term] = 1;
1858 symbols[*term].flags |= INUSE;
1860 else if ( *term == VECTOVEC ) {
1862 AN.UsedVector[*term-AM.OffsetVector] = 1;
1863 vectors[*term-AM.OffsetVector].flags |= INUSE;
1865 else if ( *term == INDTOIND ) {
1867 sym = indices[*term - AM.OffsetIndex].dimension;
1868 if ( sym < 0 ) AN.UsedSymbol[-sym] = 1;
1869 AN.UsedIndex[(*term) - AM.OffsetIndex] = 1;
1870 sym = indices[*term-AM.OffsetIndex].nmin4;
1871 if ( sym < -NMIN4SHIFT ) AN.UsedSymbol[-sym-NMIN4SHIFT] = 1;
1872 indices[*term-AM.OffsetIndex].flags |= INUSE;
1874 else if ( *term == FUNTOFUN ) {
1876 AN.UsedFunction[*term-FUNCTION] = 1;
1877 functions[*term-FUNCTION].flags |= INUSE;
1883 while ( term < stopper ) {
1885 if ( *term == SYMBOL ) {
1888 AN.UsedSymbol[*term] = 1;
1890 }
while ( term < t );
1892 else if ( *term == DOTPRODUCT ) {
1895 AN.UsedVector[(*term++) - AM.OffsetVector] = 1;
1896 AN.UsedVector[(*term) - AM.OffsetVector] = 1;
1898 }
while ( term < t );
1900 else if ( *term == VECTOR ) {
1903 AN.UsedVector[(*term++) - AM.OffsetVector] = 1;
1904 if ( *term >= AM.OffsetIndex && *term < AM.DumInd ) {
1905 sym = indices[*term - AM.OffsetIndex].dimension;
1906 if ( sym < 0 ) AN.UsedSymbol[-sym] = 1;
1907 AN.UsedIndex[*term - AM.OffsetIndex] = 1;
1908 sym = indices[(*term++)-AM.OffsetIndex].nmin4;
1909 if ( sym < -NMIN4SHIFT ) AN.UsedSymbol[-sym-NMIN4SHIFT] = 1;
1912 }
while ( term < t );
1914 else if ( *term == INDEX || *term == LEVICIVITA || *term == GAMMA
1915 || *term == DELTA ) {
1920 if ( *term == INDEX || *term == DELTA ) term += 2;
1925 while ( term < t ) {
1926 if ( *term >= AM.OffsetIndex && *term < AM.DumInd ) {
1927 sym = indices[*term - AM.OffsetIndex].dimension;
1928 if ( sym < 0 ) AN.UsedSymbol[-sym] = 1;
1929 AN.UsedIndex[(*term) - AM.OffsetIndex] = 1;
1930 sym = indices[*term-AM.OffsetIndex].nmin4;
1931 if ( sym < -NMIN4SHIFT ) AN.UsedSymbol[-sym-NMIN4SHIFT] = 1;
1933 else if ( *term < (WILDOFFSET+AM.OffsetVector) )
1934 AN.UsedVector[(*term) - AM.OffsetVector] = 1;
1938 else if ( *term == HAAKJE ) term = t;
1940 if ( *term > MAXBUILTINFUNCTION )
1941 AN.UsedFunction[(*term)-FUNCTION] = 1;
1942 if ( *term >= FUNCTION && functions[*term-FUNCTION].spec
1943 >= TENSORFUNCTION && term[1] > FUNHEAD )
goto Tensors;
1945 while ( term < t ) {
1949 sarg = term + *term;
1951 if ( term < sarg ) {
do {
1954 }
while ( term < sarg ); }
1957 if ( *term < -MAXBUILTINFUNCTION ) {
1958 AN.UsedFunction[-*term-FUNCTION] = 1;
1960 else if ( *term == -SYMBOL ) {
1961 AN.UsedSymbol[term[1]] = 1;
1963 else if ( *term == -INDEX ) {
1964 if ( term[1] < (WILDOFFSET+AM.OffsetVector) ) {
1965 AN.UsedVector[term[1]-AM.OffsetVector] = 1;
1967 else if ( term[1] >= AM.OffsetIndex && term[1] < AM.DumInd ) {
1968 sym = indices[term[1] - AM.OffsetIndex].dimension;
1969 if ( sym < 0 ) AN.UsedSymbol[-sym] = 1;
1970 AN.UsedIndex[term[1] - AM.OffsetIndex] = 1;
1971 sym = indices[term[1]-AM.OffsetIndex].nmin4;
1972 if ( sym < -NMIN4SHIFT ) AN.UsedSymbol[-sym-NMIN4SHIFT] = 1;
1975 else if ( *term == -VECTOR || *term == -MINVECTOR ) {
1976 AN.UsedVector[term[1]-AM.OffsetVector] = 1;
2010 if ( ( indexent = NextFileIndex(&indexpos) ) == 0 ) {
2011 MesCall(
"ToStorage");
2015 f = AR.infile; AR.infile = AR.outfile; AR.outfile = f;
2016 if ( e->status == HIDDENGEXPRESSION ) {
2017 AR.InHiBuf = 0; f = AR.hidefile; AR.GetFile = 2;
2020 AR.InInBuf = 0; f = AR.infile; AR.GetFile = 0;
2024 SeekFile(f->
handle,&scrpos,SEEK_SET);
2025 if ( ISNOTEQUALPOS(scrpos,e->onfile) ) {
2026 MesPrint(
":::Error in Scratch file");
2029 f->POposition = e->onfile;
2030 f->POfull = f->PObuffer;
2031 if ( e->status == HIDDENGEXPRESSION ) AR.InHiBuf = 0;
2032 else AR.InInBuf = 0;
2035 f->POfill = (WORD *)((UBYTE *)(f->PObuffer)+BASEPOSITION(e->onfile));
2038 AN.UsedSymbol = w; w += NumSymbols;
2039 AN.UsedVector = w; w += NumVectors;
2040 AN.UsedIndex = w; w += NumIndices;
2041 AN.UsedFunction = w; w += NumFunctions;
2043 w = (WORD *)(((UBYTE *)(w)) + AM.MaxTer);
2044 if ( w > AT.WorkTop ) {
2049 i = NumSymbols + NumVectors + NumIndices + NumFunctions;
2050 do { *w++ = 0; }
while ( --i > 0 );
2051 if ( GetTerm(BHEAD term) > 0 ) {
2053 if ( GetTerm(BHEAD term) ) {
2054 do { DetVars(term,0); }
while ( GetTerm(BHEAD term) > 0 );
2060 while ( --i >= 0 ) {
if ( *w++ ) j++; }
2066 while ( --i >= 0 ) {
if ( *w++ ) j++; }
2072 while ( --i >= 0 ) {
if ( *w++ ) j++; }
2076 w = AN.UsedFunction;
2078 while ( --i >= 0 ) {
if ( *w++ ) j++; }
2081 indexent->
length = *length;
2082 indexent->
variables = AR.StoreData.Fill;
2084 StrCopy(AC.exprnames->namebuffer+e->name,(UBYTE *)(indexent->
name));
2085 SeekFile(AR.StoreData.Handle,&(AR.StoreData.Fill),SEEK_SET);
2087 AO.wpos = (UBYTE *)Malloc1(AO.wlen,
"AO.wpos buffer");
2095 while ( --i >= 0 ) {
2096 while ( !*w ) { w++; a++; j++; }
2098 if ( VarStore((UBYTE *)a,(WORD)(
sizeof(
struct SyMbOl)),a->name,
2099 a->namesize) )
goto ErrToSto;
2109 while ( --i >= 0 ) {
2110 while ( !*w ) { w++; a++; j++; }
2112 if ( VarStore((UBYTE *)a,(WORD)(
sizeof(
struct InDeX)),a->name,
2113 a->namesize) )
goto ErrToSto;
2123 while ( --i >= 0 ) {
2124 while ( !*w ) { w++; a++; j++; }
2126 if ( VarStore((UBYTE *)a,(WORD)(
sizeof(
struct VeCtOr)),a->name,
2127 a->namesize) )
goto ErrToSto;
2133 w = AN.UsedFunction;
2137 while ( --i >= 0 ) {
2138 while ( !*w ) { w++; a++; j++; }
2140 if ( VarStore((UBYTE *)a,(WORD)(
sizeof(
struct FuNcTiOn)),a->name,
2141 a->namesize) )
goto ErrToSto;
2145 if ( VarStore((UBYTE *)0L,(WORD)0,(WORD)0,(WORD)0) )
goto ErrToSto;
2146 TELLFILE(AR.StoreData.Handle,&(indexent->
position));
2155 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)(&(e->numdummies)),(LONG)
sizeof(WORD)) !=
2157 MesPrint(
"Error while writing storage file");
2160 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)(&(e->numfactors)),(LONG)
sizeof(WORD)) !=
2162 MesPrint(
"Error while writing storage file");
2165 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)(&(e->vflags)),(LONG)
sizeof(WORD)) !=
2167 MesPrint(
"Error while writing storage file");
2170 TELLFILE(AR.StoreData.Handle,&(indexent->
position));
2174 SeekFile(f->
handle,&(e->onfile),SEEK_SET);
2175 while ( ISPOSPOS(llength) ) {
2176 SETBASEPOSITION(scrpos,AO.wlen);
2177 if ( ISLESSPOS(llength,scrpos) ) size = BASEPOSITION(llength);
2178 else size = AO.wlen;
2179 if ( ReadFile(f->
handle,AO.wpos,size) != size ) {
2180 MesPrint(
"Error while reading scratch file");
2183 if ( WriteFile(AR.StoreData.Handle,AO.wpos,size) != size ) {
2184 MesPrint(
"Error while writing storage file");
2187 ADDPOS(llength,-size);
2192 ppp = (WORD *)((UBYTE *)(f->PObuffer) + BASEPOSITION(e->onfile));
2193 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)ppp,BASEPOSITION(*length)) !=
2194 BASEPOSITION(*length) ) {
2195 MesPrint(
"Error while writing storage file");
2199 ADD2POS(*length,indexent->
position);
2200 e->onfile = indexpos;
2204 AR.StoreData.Fill = *length;
2205 SeekFile(AR.StoreData.Handle,&(AR.StoreData.Fill),SEEK_SET);
2206 scrpos = AR.StoreData.Position;
2208 SeekFile(AR.StoreData.Handle,&scrpos,SEEK_SET);
2209 if ( WriteFile(AR.StoreData.Handle,((UBYTE *)&(AR.StoreData.Index.number))
2211 SeekFile(AR.StoreData.Handle,&indexpos,SEEK_SET);
2212 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)indexent,(LONG)(
sizeof(
INDEXENTRY))) !=
2214 FlushFile(AR.StoreData.Handle);
2215 SeekFile(AR.StoreData.Handle,&(AC.StoreFileSize),SEEK_END);
2216 f = AR.infile; AR.infile = AR.outfile; AR.outfile = f;
2217 if ( AO.wpos ) M_free(AO.wpos,
"AO.wpos buffer");
2218 AO.wpos = AO.wpoin = 0;
2221 MesPrint(
"---Error while storing namelists");
2224 MesPrint(
"Error in storage");
2226 if ( AO.wpos ) M_free(AO.wpos,
"AO.wpos buffer");
2227 AO.wpos = AO.wpoin = 0;
2228 f = AR.infile; AR.infile = AR.outfile; AR.outfile = f;
2241 int i, j =
sizeof(
FILEINDEX)/(
sizeof(LONG));
2243 if ( AR.StoreData.Handle <= 0 ) {
2245 MesCall(
"NextFileIndex");
2248 SETBASEPOSITION(AR.StoreData.Index.number,1);
2249#ifdef SYSDEPENDENTSAVE
2250 SETBASEPOSITION(*indexpos,(2*
sizeof(
POSITION)));
2254 return(AR.StoreData.Index.expression);
2256 while ( BASEPOSITION(AR.StoreData.Index.number) >= (LONG)(
INFILEINDEX) ) {
2257 if ( ISNOTZEROPOS(AR.StoreData.Index.next) ) {
2258 SeekFile(AR.StoreData.Handle,&(AR.StoreData.Index.next),SEEK_SET);
2259 AR.StoreData.Position = AR.StoreData.Index.next;
2260 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)(&AR.StoreData.Index),(LONG)(
sizeof(
FILEINDEX))) !=
2261 (LONG)(
sizeof(
FILEINDEX)) )
goto ErrNextS;
2264 PUTZERO(AR.StoreData.Index.number);
2265 SeekFile(AR.StoreData.Handle,&(AR.StoreData.Position),SEEK_SET);
2266 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)(&(AR.StoreData.Fill)),(LONG)(
sizeof(
POSITION)))
2267 != (LONG)(
sizeof(
POSITION)) )
goto ErrNextS;
2268 PUTZERO(AR.StoreData.Index.next);
2269 SeekFile(AR.StoreData.Handle,&(AR.StoreData.Fill),SEEK_SET);
2270 AR.StoreData.Position = AR.StoreData.Fill;
2271 lo = (LONG *)(&AR.StoreData.Index);
2272 for ( i = 0; i < j; i++ ) *lo++ = 0;
2273 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)(&AR.StoreData.Index),(LONG)(
sizeof(
FILEINDEX))) !=
2274 (LONG)(
sizeof(
FILEINDEX)) )
goto ErrNextS;
2275 ADDPOS(AR.StoreData.Fill,
sizeof(
FILEINDEX));
2278 *indexpos = AR.StoreData.Position;
2279 ADDPOS(*indexpos,(2*
sizeof(
POSITION)) +
2280 BASEPOSITION(AR.StoreData.Index.number) *
sizeof(
INDEXENTRY));
2281 ind = &AR.StoreData.Index.expression[BASEPOSITION(AR.StoreData.Index.number)];
2282 ADDPOS(AR.StoreData.Index.number,1);
2285 MesPrint(
"Error in storage file");
2303 int i, j =
sizeof(
FILEINDEX)/(
sizeof(LONG));
2305 if ( AR.StoreData.Handle < 0 ) {
2306 AR.StoreData.Handle = AC.StoreHandle;
2307 PUTZERO(AR.StoreData.Index.next);
2308 PUTZERO(AR.StoreData.Index.number);
2309#ifdef SYSDEPENDENTSAVE
2310 SETBASEPOSITION(AR.StoreData.Fill,
sizeof(
FILEINDEX));
2312 if (
WriteStoreHeader(AR.StoreData.Handle) )
return(MesPrint(
"Error writing storage file header"));
2315 lo = (LONG *)(&AR.StoreData.Index);
2316 for ( i = 0; i < j; i++ ) *lo++ = 0;
2317 if ( WriteFile(AR.StoreData.Handle,(UBYTE *)(&AR.StoreData.Index),(LONG)(
sizeof(
FILEINDEX))) !=
2318 (LONG)(
sizeof(
FILEINDEX)) )
return(MesPrint(
"Error writing storage file"));
2322#ifdef SYSDEPENDENTSAVE
2325 SETBASEPOSITION(scrpos, (LONG)(
sizeof(
STOREHEADER)));
2327 SeekFile(AR.StoreData.Handle,&scrpos,SEEK_SET);
2328 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)(&AR.StoreData.Index),(LONG)(
sizeof(
FILEINDEX))) !=
2329 (LONG)(
sizeof(
FILEINDEX)) )
return(MesPrint(
"Error reading storage file"));
2331#ifdef SYSDEPENDENTSAVE
2332 PUTZERO(AR.StoreData.Position);
2334 SETBASEPOSITION(AR.StoreData.Position, (LONG)(
sizeof(
STOREHEADER)));
2349WORD VarStore(UBYTE *s, WORD n, WORD name, WORD namesize)
2355 t = (UBYTE *)AO.wpoin;
2359 u = AO.wpos+AO.wlen;
2360 while ( n > 0 && t < u ) { *t++ = *s++; n--; }
2362 if ( WriteFile(AR.StoreData.Handle,AO.wpos,AO.wlen) != AO.wlen )
return(-1);
2364 while ( n > 0 && t < u ) { *t++ = *s++; n--; }
2366 s = AC.varnames->namebuffer + name;
2368 n +=
sizeof(
void *)-1; n &= -(
sizeof(
void *));
2371 while ( n > 0 && t < u ) {
2372 if ( namesize > 0 ) { *t++ = *s++; namesize--; }
2377 if ( WriteFile(AR.StoreData.Handle,AO.wpos,AO.wlen) != AO.wlen )
return(-1);
2379 while ( n > 0 && t < u ) {
2380 if ( namesize > 0 ) { *t++ = *s++; namesize--; }
2389 size = AO.wpoin - AO.wpos;
2390 if ( WriteFile(AR.StoreData.Handle,AO.wpos,size) != size )
return(-1);
2415 stopper = term + *term - 1;
2416 stopper = stopper - ABS(*stopper) + 1;
2418 while ( term < stopper ) {
2422 if ( *term == SYMBOL ) {
2426 if ( ( n = FindrNumber(*term,&(renumber->
symb)) ) < 0 )
goto ErrR;
2427 *term = renumber->
symnum[n];
2429 }
while ( term < t );
2431 else if ( *term == DOTPRODUCT ) {
2435 if ( ( n = FindrNumber(*term,&(renumber->
vect)) )
2437 *term++ = renumber->
vecnum[n];
2438 if ( ( n = FindrNumber(*term,&(renumber->
vect)) )
2440 *term = renumber->
vecnum[n];
2442 }
while ( term < t );
2444 else if ( *term == VECTOR ) {
2448 if ( ( n = FindrNumber(*term,&(renumber->
vect)) )
2450 *term++ = renumber->
vecnum[n];
2451 if ( ( *term >= AM.OffsetIndex ) && ( *term < AM.IndDum ) ) {
2452 if ( ( n = FindrNumber(*term,&(renumber->
indi)) )
2454 *term++ = renumber->
indnum[n];
2457 }
while ( term < t );
2459 else if ( *term == INDEX || *term == LEVICIVITA || *term == GAMMA
2460 || *term == DELTA ) {
2463 if ( *term == INDEX || * term == DELTA ) term += 2;
2464 else term += FUNHEAD;
2468 while ( term < t ) {
2469 if ( *term >= AM.OffsetIndex + WILDOFFSET ) {
2474 else if ( ( *term >= AM.OffsetIndex ) && ( *term < AM.IndDum ) ) {
2475 if ( ( n = FindrNumber(*term,&(renumber->
indi)) )
2477 *term = renumber->
indnum[n];
2479 else if ( *term < (WILDOFFSET+AM.OffsetVector) ) {
2480 if ( ( n = FindrNumber(*term,&(renumber->
vect)) )
2482 *term = renumber->
vecnum[n];
2487 else if ( *term == HAAKJE ) term += term[1];
2489 if ( *term > MAXBUILTINFUNCTION ) {
2490 if ( ( n = FindrNumber(*term,&(renumber->
func)) )
2492 *term = renumber->
funnum[n];
2494 if ( *term >= FUNCTION && functions[*term-FUNCTION].spec
2495 >= TENSORFUNCTION && term[1] > FUNHEAD )
goto Tensors;
2498 while ( term < t ) {
2509 while ( term < sarg ) {
2515 if ( *term <= -MAXBUILTINFUNCTION ) {
2516 if ( ( n = FindrNumber(-*term,&(renumber->
func)) )
2518 *term = -renumber->
funnum[n];
2520 else if ( *term == -SYMBOL ) {
2522 if ( ( n = FindrNumber(*term,
2523 &(renumber->
symb)) ) < 0 )
goto ErrR;
2524 *term = renumber->
symnum[n];
2526 else if ( *term == -INDEX ) {
2528 if ( *term >= AM.OffsetIndex + WILDOFFSET ) {
2533 else if ( ( *term >= AM.OffsetIndex ) && ( *term < AM.IndDum ) ) {
2534 if ( ( n = FindrNumber(*term,&(renumber->
indi)) )
2536 *term = renumber->
indnum[n];
2538 else if ( *term < (WILDOFFSET+AM.OffsetVector) ) {
2539 if ( ( n = FindrNumber(*term,&(renumber->
vect)) )
2541 *term = renumber->
vecnum[n];
2544 else if ( *term == -VECTOR || *term == -MINVECTOR ) {
2546 if ( ( n = FindrNumber(*term,&(renumber->
vect)) )
2548 *term = renumber->
vecnum[n];
2558 MesCall(
"TermRenumber");
2567WORD FindrNumber(WORD n,
VARRENUM *v)
2575 MesPrint(
"Serious problems coming up in FindrNumber");
2580 while ( *med != n ) {
2582 if ( med == hi )
goto ErrFindr;
2584 med = hi - ((WORDDIF(hi,med))/2);
2587 if ( med == lo )
goto ErrFindr;
2589 med = lo + ((WORDDIF(med,lo))/2);
2592 return(WORDDIF(med,v->
lo));
2599 i = WORDDIF(v->
hi,v->
lo);
2600 MesPrint(
"FindrNumber: n = %d, list has %d members",n,i);
2602 MesPrint(
"v->lo[%d] = %d",i,v->
lo[i]); i--;
2607 MesPrint(
"Start with %d,%d,%d",0,WORDDIF(med,v->
lo),WORDDIF(hi,v->
lo));
2608 while ( *med != n ) {
2610 if ( med == hi )
goto ErrFindr2;
2612 med = hi - ((WORDDIF(hi,med))/2);
2615 if ( med == lo )
goto ErrFindr2;
2617 med = ((WORDDIF(med,lo))/2) + lo;
2619 MesPrint(
"New: %d,%d,%d, *med = %d",WORDDIF(lo,v->
lo),WORDDIF(med,v->
lo),WORDDIF(hi,v->
lo),*med);
2622 return(WORDDIF(med,v->
lo));
2624 return(MesPrint(
"Renumbering problems"));
2649 WORD *start, *stop, *stop2, *m2, nomatch = 0;
2650 POSITION stindex, indexpos, scrpos;
2652 stindex = f->Position;
2657 while ( m < stop ) {
2658 if ( *m == FROMBRAC || *m == WILDCARDS )
break;
2662 if ( !par ) hand = AR.StoreData.Handle;
2663 else hand = AO.SaveData.Handle;
2665 if ( ( i = (WORD)BASEPOSITION(f->Index.
number) ) != 0 ) {
2666 indexpos = f->Position;
2667 ADDPOS(indexpos,(2*
sizeof(
POSITION)));
2670 if ( ( !par && ISEQUALPOS(indexpos,Expressions[expr].onfile) )
2671 || ( par && !StrCmp(EXPRNAME(expr),(UBYTE *)(ind->name)) ) ) {
2683 if ( par )
return(ind);
2684 scrpos = ind->position;
2685 SeekFile(hand,&scrpos,SEEK_SET);
2686 if ( ISNOTEQUALPOS(scrpos,ind->position) )
goto ErrGt2;
2687 if ( ReadFile(hand,(UBYTE *)AT.WorkPointer,(LONG)
sizeof(WORD)) !=
2688 sizeof(WORD) || !*AT.WorkPointer )
goto ErrGt2;
2689 num = *AT.WorkPointer - 1;
2690 num *= wsizeof(WORD);
2691 if ( *AT.WorkPointer < 0 ||
2692 ReadFile(hand,(UBYTE *)(AT.WorkPointer+1),num) != num )
goto ErrGt2;
2694 m2 = AT.WorkPointer + 1;
2697 while ( m < stop && m2 < stop2 ) {
2698 if ( *m == SYMBOL ) {
2699 if ( *m2 != SYMTOSYM )
break;
2702 else if ( *m == INDEX ) {
2704 if ( *m2 != INDTOIND )
break;
2707 if ( *m2 != VECTOVEC )
break;
2711 else if ( *m >= FUNCTION ) {
2712 if ( *m2 != FUNTOFUN )
break;
2719 if ( ( m >= stop && m2 >= stop2 ) || mode == 0 ) {
2720 AT.WorkPointer = stop2;
2727 }
while ( --i > 0 );
2729 f->Position = f->Index.
next;
2730#ifndef SYSDEPENDENTSAVE
2731 if ( !ISNOTZEROPOS(f->Position) ) ADDPOS(f->Position,
sizeof(
STOREHEADER));
2734 if ( ISEQUALPOS(f->Position,stindex) && !AO.bufferedInd )
goto ErrGetTab;
2736 SeekFile(AR.StoreData.Handle,&(f->Position),SEEK_SET);
2737 if ( ISNOTEQUALPOS(f->Position,AR.StoreData.Position) )
goto ErrGt2;
2738#ifndef SYSDEPENDENTSAVE
2739 if ( ReadFile(f->Handle, (UBYTE *)(&(f->Index)),
number) !=
number )
goto ErrGt2;
2743 SeekFile(AO.SaveData.Handle,&(f->Position),SEEK_SET);
2744 if ( ISNOTEQUALPOS(f->Position,AO.SaveData.Position) )
goto ErrGt2;
2745#ifndef SYSDEPENDENTSAVE
2749#ifdef SYSDEPENDENTSAVE
2751 if ( ReadFile(f->Handle,(UBYTE *)(&(f->Index)),
number) !=
2757 MesPrint(
"Parameters of expression %s don't match."
2761 MesPrint(
"Cannot find expression %s",EXPRNAME(expr));
2765 MesPrint(
"Readerror in IndexSearch");
2811 LONG num, nsize, xx;
2812 WORD jsym, jind, jvec, jfun;
2813 WORD k, type, error = 0, *oldw, *neww, *oldwork = AT.WorkPointer;
2838 oldw = AT.WorkPointer + 1 + SUBEXPSIZE;
2844 LOCK(AM.storefilelock);
2845 if ( ( ind = FindInIndex(expr,&AR.StoreData,0,mode) ) == 0 ) {
2846 UNLOCK(AM.storefilelock);
2850 xx = ind->nsymbols+ind->nindices+ind->nvectors+ind->nfunctions;
2852 Expressions[expr].renumlists =
2853 w = AN.dummyrenumlist;
2861 w = (WORD *)Malloc1(
sizeof(WORD)*(xx*2),
"VarSpace");
2886 w += ind->nfunctions;
2891 SeekFile(AR.StoreData.Handle,&(ind->variables),SEEK_SET);
2892 *position = ind->position;
2893 jsym = ind->nsymbols;
2894 jvec = ind->nvectors;
2895 jind = ind->nindices;
2896 jfun = ind->nfunctions;
2902 w = r->
symb.
lo; j = jsym;
2903 for ( i = 0; i < j; i++ ) {
2904 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)s,(LONG)(
sizeof(
struct SyMbOl)))
2905 !=
sizeof(
struct SyMbOl) )
goto ErrGt2;
2906 nsize = s->namesize; nsize +=
sizeof(
void *)-1;
2907 nsize &= -
sizeof(
void *);
2908 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)(AT.WorkPointer),nsize)
2909 != nsize )
goto ErrGt2;
2911 if ( ( s->flags & INUSE ) != 0 ) {
2914 while ( *neww != SYMTOSYM || neww[2] != *w ) neww += neww[1];
2917 else if ( GetVar((UBYTE *)AT.WorkPointer,&type,&k,ALLVARIABLES,NOAUTO) != NAMENOTFOUND ) {
2918 if ( type != CSYMBOL ) {
2919 MesPrint(
"Error: Conflicting types for %s",(AT.WorkPointer));
2923 if ( ( s->complex & (VARTYPEIMAGINARY|VARTYPECOMPLEX) ) !=
2924 ( symbols[k].complex & (VARTYPEIMAGINARY|VARTYPECOMPLEX) ) ) {
2925 MesPrint(
"Warning: Conflicting complexity for %s",AT.WorkPointer);
2928 if ( ( s->complex & (VARTYPEROOTOFUNITY) ) !=
2929 ( symbols[k].complex & (VARTYPEROOTOFUNITY) ) ) {
2930 MesPrint(
"Warning: Conflicting root of unity properties for %s",AT.WorkPointer);
2933 if ( ( s->complex & VARTYPEROOTOFUNITY ) == VARTYPEROOTOFUNITY ) {
2934 if ( s->maxpower != symbols[k].maxpower ) {
2935 MesPrint(
"Warning: Conflicting n in n-th root of unity properties for %s",AT.WorkPointer);
2939 else if ( ( s->minpower !=
2940 symbols[k].minpower || s->maxpower !=
2941 symbols[k].maxpower ) && AC.WarnFlag ) {
2942 MesPrint(
"Warning: Conflicting power restrictions for %s",AT.WorkPointer);
2947 if ( ( k = EntVar(CSYMBOL,(UBYTE *)(AT.WorkPointer),s->complex,s->minpower,
2948 s->maxpower,s->dimension) ) < 0 )
goto GetTcall;
2960 w = r->
indi.
lo; j = jind;
2961 for ( i = 0; i < j; i++ ) {
2962 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)s,(LONG)(
sizeof(
struct InDeX)))
2963 !=
sizeof(
struct InDeX) )
goto ErrGt2;
2964 nsize = s->namesize; nsize +=
sizeof(
void *)-1;
2965 nsize &= -
sizeof(
void *);
2966 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)(AT.WorkPointer),nsize)
2967 != nsize )
goto ErrGt2;
2968 *w = s->number + AM.OffsetIndex;
2969 if ( s->dimension < 0 ) {
2970 s->dimension = -r->
symnum[FindrNumber(-s->dimension,&(r->
symb))];
2971 if ( s->nmin4 < -NMIN4SHIFT ) {
2972 s->nmin4 = -r->
symnum[FindrNumber(-s->nmin4-NMIN4SHIFT
2973 ,&(r->
symb))]-NMIN4SHIFT;
2976 if ( ( s->flags & INUSE ) != 0 ) {
2979 while ( *neww != INDTOIND || neww[2] != *w ) neww += neww[1];
2980 k = neww[3] - AM.OffsetIndex;
2982 else if ( s->type == DUMMY ) {
2987 else if ( GetVar((UBYTE *)(AT.WorkPointer),&type,&k,ALLVARIABLES,NOAUTO) != NAMENOTFOUND ) {
2988 if ( type != CINDEX ) {
2989 MesPrint(
"Error: Conflicting types for %s",(AT.WorkPointer));
2995 MesPrint(
"Warning: %s is also a dummy index",(AT.WorkPointer));
2999 if ( s->dimension != indices[k].dimension ) {
3000 MesPrint(
"Warning: Conflicting dimensions for %s",(AT.WorkPointer));
3007 if ( ( k = EntVar(CINDEX,(UBYTE *)(AT.WorkPointer),
3008 s->dimension,0,s->nmin4,0) ) < 0 )
goto GetTcall;
3011 *(w+j) = k + AM.OffsetIndex;
3021 w = r->
vect.
lo; j = jvec;
3022 for ( i = 0; i < j; i++ ) {
3023 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)s,(LONG)(
sizeof(
struct VeCtOr)))
3024 !=
sizeof(
struct VeCtOr) )
goto ErrGt2;
3025 nsize = s->namesize; nsize +=
sizeof(
void *)-1;
3026 nsize &= -
sizeof(
void *);
3027 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)(AT.WorkPointer),nsize)
3028 != nsize )
goto ErrGt2;
3029 *w = s->number + AM.OffsetVector;
3030 if ( ( s->flags & INUSE ) != 0 ) {
3033 while ( *neww != VECTOVEC || neww[2] != *w ) neww += neww[1];
3034 k = neww[3] - AM.OffsetVector;
3036 else if ( GetVar((UBYTE *)(AT.WorkPointer),&type,&k,ALLVARIABLES,NOAUTO) != NAMENOTFOUND ) {
3037 if ( type != CVECTOR ) {
3038 MesPrint(
"Error: Conflicting types for %s",(AT.WorkPointer));
3042 if ( ( s->complex & (VARTYPEIMAGINARY|VARTYPECOMPLEX) ) !=
3043 ( vectors[k].complex & (VARTYPEIMAGINARY|VARTYPECOMPLEX) ) ) {
3044 MesPrint(
"Warning: Conflicting complexity for %s",(AT.WorkPointer));
3050 if ( ( k = EntVar(CVECTOR,(UBYTE *)(AT.WorkPointer),
3051 s->complex,0,0,s->dimension) ) < 0 )
goto GetTcall;
3053 *(w+j) = k + AM.OffsetVector;
3063 w = r->
func.
lo; j = jfun;
3064 for ( i = 0; i < j; i++ ) {
3065 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)s,(LONG)(
sizeof(
struct FuNcTiOn)))
3066 !=
sizeof(
struct FuNcTiOn) )
goto ErrGt2;
3067 nsize = s->namesize; nsize +=
sizeof(
void *)-1;
3068 nsize &= -
sizeof(
void *);
3069 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)(AT.WorkPointer),nsize)
3070 != nsize )
goto ErrGt2;
3071 *w = s->number + FUNCTION;
3072 if ( ( s->flags & INUSE ) != 0 ) {
3075 while ( *neww != FUNTOFUN || neww[2] != *w ) neww += neww[1];
3076 k = neww[3] - FUNCTION;
3078 else if ( GetVar((UBYTE *)(AT.WorkPointer),&type,&k,ALLVARIABLES,NOAUTO) != NAMENOTFOUND ) {
3079 if ( type != CFUNCTION ) {
3080 MesPrint(
"Error: Conflicting types for %s",(AT.WorkPointer));
3084 if ( s->complex != functions[k].complex ) {
3085 MesPrint(
"Warning: Conflicting complexity for %s",(AT.WorkPointer));
3088 else if ( s->symmetric != functions[k].symmetric ) {
3089 MesPrint(
"Warning: Conflicting symmetry properties for %s",(AT.WorkPointer));
3092 else if ( ( s->maxnumargs != functions[k].maxnumargs )
3093 || ( s->minnumargs != functions[k].minnumargs ) ) {
3094 MesPrint(
"Warning: Conflicting argument restriction properties for %s",(AT.WorkPointer));
3100 if ( ( k = EntVar(CFUNCTION,(UBYTE *)(AT.WorkPointer),
3101 s->complex,s->commute,s->spec,s->dimension) ) < 0 )
goto GetTcall;
3102 functions[k].symmetric = s->symmetric;
3103 functions[k].maxnumargs = s->maxnumargs;
3104 functions[k].minnumargs = s->minnumargs;
3106 *(w+j) = k + FUNCTION;
3116 UNLOCK(AM.storefilelock);
3117 AT.WorkPointer = oldwork;
3135 TELLFILE(AR.StoreData.Handle,&pos);
3136 nummystery = DIFBASE(ind->position,pos);
3142 if ( nummystery > 0 ) {
3143 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)AT.WorkPointer,(LONG)
sizeof(WORD)) !=
3145 UNLOCK(AM.storefilelock);
3146 AT.WorkPointer = oldwork;
3149 Expressions[expr].numdummies = *AT.WorkPointer;
3153 nummystery -=
sizeof(WORD);
3156 Expressions[expr].numdummies = 0;
3158 if ( nummystery > 0 ) {
3159 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)AT.WorkPointer,(LONG)
sizeof(WORD)) !=
3161 UNLOCK(AM.storefilelock);
3162 AT.WorkPointer = oldwork;
3165 if ( ( AS.OldNumFactors == 0 ) || ( AS.NumOldNumFactors < NumExpressions ) ) {
3168 if (capacity < NumExpressions) capacity = NumExpressions * 2;
3170 buffer = (WORD *)Malloc1(capacity *
sizeof(WORD),
"numfactors pointers");
3171 if (AS.OldNumFactors) {
3172 WCOPY(buffer, AS.OldNumFactors, AS.NumOldNumFactors);
3173 M_free(AS.OldNumFactors,
"numfactors pointers");
3175 AS.OldNumFactors = buffer;
3177 buffer = (WORD *)Malloc1(capacity *
sizeof(WORD),
"vflags pointers");
3179 WCOPY(buffer, AS.Oldvflags, AS.NumOldNumFactors);
3180 M_free(AS.Oldvflags,
"vflags pointers");
3182 AS.Oldvflags = buffer;
3184 AS.NumOldNumFactors = capacity;
3187 AS.OldNumFactors[expr] =
3188 Expressions[expr].numfactors = *AT.WorkPointer;
3192 nummystery -=
sizeof(WORD);
3195 Expressions[expr].numfactors = 0;
3197 if ( nummystery > 0 ) {
3198 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)AT.WorkPointer,(LONG)
sizeof(WORD)) !=
3200 UNLOCK(AM.storefilelock);
3201 AT.WorkPointer = oldwork;
3204 AS.Oldvflags[expr] =
3205 Expressions[expr].vflags = *AT.WorkPointer;
3209 nummystery -=
sizeof(WORD);
3212 Expressions[expr].vflags = 0;
3216 SeekFile(AR.StoreData.Handle,&(ind->position),SEEK_SET);
3217 if ( ReadFile(AR.StoreData.Handle,(UBYTE *)AT.WorkPointer,(LONG)
sizeof(WORD)) !=
3218 sizeof(WORD) || !*AT.WorkPointer ) {
3219 UNLOCK(AM.storefilelock);
3220 AT.WorkPointer = oldwork;
3223 num = *AT.WorkPointer - 1;
3224 num *=
sizeof(WORD);
3225 if ( *AT.WorkPointer < 0 ||
3226 ReadFile(AR.StoreData.Handle,(UBYTE *)(AT.WorkPointer+1),num) != num ) {
3227 MesPrint(
"@Error in stored expressions file at position %10p",*position);
3228 UNLOCK(AM.storefilelock);
3229 AT.WorkPointer = oldwork;
3232 UNLOCK(AM.storefilelock);
3233 ADDPOS(*position,num+
sizeof(WORD));
3234 r->startposition = *position;
3235 AT.WorkPointer = oldwork;
3238 UNLOCK(AM.storefilelock);
3239 AT.WorkPointer = oldwork;
3240 MesCall(
"GetTable");
3243 UNLOCK(AM.storefilelock);
3244 AT.WorkPointer = oldwork;
3245 MesPrint(
"Readerror in GetTable");
3268 SeekScratch(from,&posfrom);
3269 if ( from->
handle < 0 ) {
3270 fullsize = (BASEPOSITION(posfrom))/
sizeof(WORD);
3271 if ( ( to->POstop - to->POfull ) >= fullsize ) {
3275 t1 = from->PObuffer;
3277 NCOPY(t2,t1,fullsize)
3278 to->POfull = to->POfill = t2;
3282 if ( ( RetCode = CreateFile(to->name) ) >= 0 ) {
3283 to->
handle = (WORD)RetCode;
3284 PUTZERO(to->filesize);
3285 PUTZERO(to->POposition);
3288 MLOCK(ErrorMessageLock);
3289 MesPrint(
"Cannot create scratch file %s",to->name);
3290 MUNLOCK(ErrorMessageLock);
3294 t1 = from->PObuffer;
3295 while ( fullsize > 0 ) {
3296 i = to->POstop - to->POfull;
3297 if ( i > fullsize ) i = fullsize;
3301 if ( fullsize > 0 ) {
3302 SeekFile(to->
handle,&(to->POposition),SEEK_SET);
3303 if ( WriteFile(to->
handle,((UBYTE *)(to->PObuffer)),to->POsize) != to->POsize ) {
3304 MLOCK(ErrorMessageLock);
3305 MesPrint(
"Error while writing to disk. Disk full?");
3306 MUNLOCK(ErrorMessageLock);
3309 ADDPOS(to->POposition,to->POsize);
3311 to->filesize = to->POposition;
3312 to->POfill = to->POfull = to->PObuffer;
3315 to->POfill = to->POfull = t2;
3324 if ( ((UBYTE *)(from->POfill)-(UBYTE *)(from->PObuffer)) > 0 ) {
3325 if ( WriteFile(from->
handle,((UBYTE *)(from->PObuffer)),((UBYTE *)(from->POfill)-(UBYTE *)(from->PObuffer)))
3326 != ((UBYTE *)(from->POfill)-(UBYTE *)(from->PObuffer)) ) {
3327 MLOCK(ErrorMessageLock);
3328 MesPrint(
"Error while writing to disk. Disk full?");
3329 MUNLOCK(ErrorMessageLock);
3332 SeekFile(from->
handle,&(from->POposition),SEEK_CUR);
3333 posfrom = from->filesize = from->POposition;
3334 from->POfill = from->POfull = from->PObuffer;
3340 SeekFile(from->
handle,&poscopy,SEEK_SET);
3341 while ( ISLESSPOS(poscopy,posfrom) ) {
3342 fullsize = ReadFile(from->
handle,((UBYTE *)(from->PObuffer)),from->POsize);
3343 if ( fullsize < 0 || ( fullsize %
sizeof(WORD) ) != 0 ) {
3344 MLOCK(ErrorMessageLock);
3345 MesPrint(
"Error while reading from disk while copying expression.");
3346 MUNLOCK(ErrorMessageLock);
3349 fullsize /=
sizeof(WORD);
3350 from->POfull = from->PObuffer + fullsize;
3351 t1 = from->PObuffer;
3353 if ( ( to->POstop - to->POfull ) >= fullsize ) {
3358 NCOPY(t2,t1,fullsize)
3359 to->POfill = to->POfull = t2;
3363 if ( ( RetCode = CreateFile(to->name) ) >= 0 ) {
3364 to->
handle = (WORD)RetCode;
3365 PUTZERO(to->POposition);
3366 PUTZERO(to->filesize);
3369 MLOCK(ErrorMessageLock);
3370 MesPrint(
"Cannot create scratch file %s",to->name);
3371 MUNLOCK(ErrorMessageLock);
3375 while ( fullsize > 0 ) {
3376 i = to->POstop - to->POfull;
3377 if ( i > fullsize ) i = fullsize;
3381 if ( fullsize > 0 ) {
3382 SeekFile(to->
handle,&(to->POposition),SEEK_SET);
3383 if ( WriteFile(to->
handle,((UBYTE *)(to->PObuffer)),to->POsize) != to->POsize ) {
3384 MLOCK(ErrorMessageLock);
3385 MesPrint(
"Error while writing to disk. Disk full?");
3386 MUNLOCK(ErrorMessageLock);
3389 ADDPOS(to->POposition,to->POsize);
3391 to->filesize = to->POposition;
3392 to->POfill = to->POfull = to->PObuffer;
3395 to->POfill = to->POfull = t2;
3399 SeekFile(from->
handle,&poscopy,SEEK_CUR);
3402 if ( ( to->
handle >= 0 ) && ( to->POfill > to->PObuffer ) ) {
3403 fullsize = (UBYTE *)(to->POfill) - (UBYTE *)(to->PObuffer);
3408 SeekFile(to->
handle,&(to->filesize),SEEK_SET);
3409 if ( WriteFile(to->
handle,((UBYTE *)(to->PObuffer)),fullsize) != fullsize ) {
3410 MLOCK(ErrorMessageLock);
3411 MesPrint(
"Error while writing to disk. Disk full?");
3412 MUNLOCK(ErrorMessageLock);
3415 ADDPOS(to->filesize,fullsize);
3416 to->POposition = to->filesize;
3417 to->POfill = to->POfull = to->PObuffer;
3430static UBYTE *statusexpr[] = {
3431 (UBYTE *)
"LOCALEXPRESSION"
3432 ,(UBYTE *)
"SKIPLEXPRESSION"
3433 ,(UBYTE *)
"DROPLEXPRESSION"
3434 ,(UBYTE *)
"DROPPEDEXPRESSION"
3435 ,(UBYTE *)
"GLOBALEXPRESSION"
3436 ,(UBYTE *)
"SKIPGEXPRESSION"
3437 ,(UBYTE *)
"DROPGEXPRESSION"
3439 ,(UBYTE *)
"STOREDEXPRESSION"
3440 ,(UBYTE *)
"HIDDENLEXPRESSION"
3441 ,(UBYTE *)
"HIDELEXPRESSION"
3442 ,(UBYTE *)
"DROPHLEXPRESSION"
3443 ,(UBYTE *)
"UNHIDELEXPRESSION"
3444 ,(UBYTE *)
"HIDDENGEXPRESSION"
3445 ,(UBYTE *)
"HIDEGEXPRESSION"
3446 ,(UBYTE *)
"DROPHGEXPRESSION"
3447 ,(UBYTE *)
"UNHIDEGEXPRESSION"
3448 ,(UBYTE *)
"INTOHIDELEXPRESSION"
3449 ,(UBYTE *)
"INTOHIDEGEXPRESSION"
3454 MesPrint(
"Expression %s(%d) has status %s(%d,%d). Buffer: %d, Position: %15p",
3455 AC.exprnames->namebuffer+e->name,(WORD)(e-Expressions),
3456 statusexpr[e->status],e->status,e->hidelevel,
3457 e->whichbuffer,&(e->onfile));
3479#error "INT16 not defined!"
3482#error "INT32 not defined!"
3494static void FlipN(UBYTE *p,
int length)
3500 buf = *p; *p = *q; *q = buf;
3501 }
while ( ++p != q );
3513static void Flip16(UBYTE *p)
3515 INT16 in = *((INT16 *)p);
3516 INT16 out = (INT16)( (((in) >> 8) & 0x00FF) | (((in) << 8) & 0xFF00) );
3517 *((INT16 *)p) = out;
3521static void Flip32(UBYTE *p)
3523 INT32 in = *((INT32 *)p);
3525 ( (((in) >> 24) & 0x000000FF) | (((in) >> 8) & 0x0000FF00) | \
3526 (((in) << 8) & 0x00FF0000) | (((in) << 24) & 0xFF000000) );
3527 *((INT32 *)p) = out;
3532static void Flip64(UBYTE *p)
3534 INT64 in = *((INT64 *)p);
3536 ( (((in) >> 56) & (INT64)0x00000000000000FFLL) | (((in) >> 40) & (INT64)0x000000000000FF00LL) | \
3537 (((in) >> 24) & (INT64)0x0000000000FF0000LL) | (((in) >> 8) & (INT64)0x00000000FF000000LL) | \
3538 (((in) << 8) & (INT64)0x000000FF00000000LL) | (((in) << 24) & (INT64)0x0000FF0000000000LL) | \
3539 (((in) << 40) & (INT64)0x00FF000000000000LL) | (((in) << 56) & (INT64)0xFF00000000000000LL) );
3540 *((INT64 *)p) = out;
3543static void Flip64(UBYTE *p) { FlipN(p, 8); }
3547static void Flip128(UBYTE *p) { FlipN(p, 16); }
3565static void ResizeDataBE(UBYTE *src,
int slen, UBYTE *dst,
int dlen)
3567 if ( slen > dlen ) {
3569 while ( dlen-- ) { *dst++ = *src++; }
3572 int i = dlen - slen;
3573 while ( i-- ) { *dst++ = 0; }
3574 while ( slen-- ) { *dst++ = *src++; }
3581static void ResizeDataLE(UBYTE *src,
int slen, UBYTE *dst,
int dlen)
3583 if ( slen > dlen ) {
3584 while ( dlen-- ) { *dst++ = *src++; }
3587 int i = dlen - slen;
3588 while ( slen-- ) { *dst++ = *src++; }
3589 while ( i-- ) { *dst++ = 0; }
3605static void Resize16t16(UBYTE *src, UBYTE *dst)
3607 *((INT16 *)dst) = *((INT16 *)src);
3611static void Resize16t32(UBYTE *src, UBYTE *dst)
3613 INT16 in = *((INT16 *)src);
3614 INT32 out = (INT32)in;
3615 *((INT32 *)dst) = out;
3620static void Resize16t64(UBYTE *src, UBYTE *dst)
3622 INT16 in = *((INT16 *)src);
3623 INT64 out = (INT64)in;
3624 *((INT64 *)dst) = out;
3627static void Resize16t64(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 2, dst, 8); }
3631static void Resize16t128(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 2, dst, 16); }
3634static void Resize32t32(UBYTE *src, UBYTE *dst)
3636 *((INT32 *)dst) = *((INT32 *)src);
3641static void Resize32t64(UBYTE *src, UBYTE *dst)
3643 INT32 in = *((INT32 *)src);
3644 INT64 out = (INT64)in;
3645 *((INT64 *)dst) = out;
3648static void Resize32t64(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 4, dst, 8); }
3652static void Resize32t128(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 4, dst, 16); }
3656static void Resize64t64(UBYTE *src, UBYTE *dst)
3658 *((INT64 *)dst) = *((INT64 *)src);
3661static void Resize64t64(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 8, dst, 8); }
3665static void Resize64t128(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 8, dst, 16); }
3668static void Resize128t128(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 16, dst, 16); }
3671static void Resize32t16(UBYTE *src, UBYTE *dst)
3673 INT32 in = *((INT32 *)src);
3674 INT16 out = (INT16)in;
3675 if ( in > (1<<15)-1 || in < -(1<<15)+1 ) AO.resizeFlag |= 1;
3676 *((INT16 *)dst) = out;
3685static void Resize32t16NC(UBYTE *src, UBYTE *dst)
3687 INT32 in = *((INT32 *)src);
3688 INT16 out = (INT16)in;
3689 *((INT16 *)dst) = out;
3694static void Resize64t16(UBYTE *src, UBYTE *dst)
3696 INT64 in = *((INT64 *)src);
3697 INT16 out = (INT16)in;
3698 if ( in > (1<<15)-1 || in < -(1<<15)+1 ) AO.resizeFlag |= 1;
3699 *((INT16 *)dst) = out;
3702static void Resize64t16NC(UBYTE *src, UBYTE *dst)
3704 INT64 in = *((INT64 *)src);
3705 INT16 out = (INT16)in;
3706 *((INT16 *)dst) = out;
3710static void Resize64t16(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 8, dst, 2); }
3712static void Resize64t16NC(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 8, dst, 2); }
3717static void Resize64t32(UBYTE *src, UBYTE *dst)
3719 INT64 in = *((INT64 *)src);
3720 INT32 out = (INT32)in;
3721 if ( in > ((INT64)1<<31)-1 || in < -((INT64)1<<31)+1 ) AO.resizeFlag |= 1;
3722 *((INT32 *)dst) = out;
3725static void Resize64t32NC(UBYTE *src, UBYTE *dst)
3727 INT64 in = *((INT64 *)src);
3728 INT32 out = (INT32)in;
3729 *((INT32 *)dst) = out;
3733static void Resize64t32(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 8, dst, 4); }
3735static void Resize64t32NC(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 8, dst, 4); }
3739static void Resize128t16(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 16, dst, 2); }
3742static void Resize128t16NC(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 16, dst, 2); }
3745static void Resize128t32(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 16, dst, 4); }
3748static void Resize128t32NC(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 16, dst, 4); }
3751static void Resize128t64(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 16, dst, 8); }
3754static void Resize128t64NC(UBYTE *src, UBYTE *dst) { AO.ResizeData(src, 16, dst, 8); }
3767static void CheckPower32(UBYTE *p)
3769 if ( *((INT32 *)p) < -MAXPOWER ) {
3770 AO.powerFlag |= 0x01;
3771 *((INT32 *)p) = -MAXPOWER;
3774 if ( *((INT32 *)p) > MAXPOWER ) {
3775 AO.powerFlag |= 0x02;
3776 *((INT32 *)p) = MAXPOWER;
3787static void RenumberVec32(UBYTE *p)
3790 void *dummy = (
void *)AO.SaveHeader.wildoffset;
3791 INT32 wildoffset = *(INT32 *)dummy;
3792 INT32 in = *((INT32 *)p);
3793 in = in + 2*wildoffset;
3794 in = in - 2*WILDOFFSET;
3816static void ResizeCoeff32(UBYTE **bout, UBYTE *bend, UBYTE *top)
3821 INT32 *out = (INT32 *)*bout;
3822 INT32 *end = (INT32 *)bend;
3824 if (
sizeof(WORD) == 2 ) {
3826 INT32 len = (end - 1 - out) / 2;
3830 if ( *p & 0xFFFF0000 ) --zeros;
3832 if ( *p & 0xFFFF0000 ) --zeros;
3835 sign = ( *in-- > 0 ) ? 1 : -1;
3837 if ( zeros == 2 ) p -= 2;
3840 if ( zeros < 2 ) *p-- = *in >> 16;
3841 *p-- = *in-- & 0x0000FFFF;
3842 for ( i = 1; i < len; ++i ) {
3844 *p-- = *in-- & 0x0000FFFF;
3846 if ( zeros < 2 ) *p-- = *in >> 16;
3847 *p-- = *in-- & 0x0000FFFF;
3848 for ( i = 1; i < len; ++i ) {
3850 *p-- = *in-- & 0x0000FFFF;
3853 *out = (out - p) * sign;
3854 *bout = (UBYTE *)(out+1);
3859 INT32 len = (end - 1 - out) / 2;
3861 *out = *(
unsigned INT16 *)out;
3863 *out = *(
unsigned INT16 *)out;
3869 *out = *(
unsigned INT16 *)out;
3871 for ( i = 1; i < len; ++i ) {
3873 *out = (
unsigned INT32)(*(
unsigned INT16 *)out)
3874 + ((
unsigned INT32)(*(
unsigned INT16 *)in) << 16);
3876 if ( ++i == len )
break;
3879 *out = *(
unsigned INT16 *)in;
3883 *out = *(
unsigned INT16 *)in;
3885 for ( i = 1; i < len; ++i ) {
3887 *out = (
unsigned INT32)(*(
unsigned INT16 *)out)
3888 + ((
unsigned INT32)(*(
unsigned INT16 *)in) << 16);
3890 if ( ++i == len )
break;
3893 *out = *(
unsigned INT16 *)in;
3897 if ( *in < 0 ) *out = -(out - p + 1);
3898 else *out = out - p + 1;
3902 if ( out > (INT32 *)top ) {
3903 MesPrint(
"Error in resizing coefficient!");
3906 *bout = (UBYTE *)out;
3915#define SAVEREVISION 0x02
3930 { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF },
3948 for ( i = 1; i < (int)
sizeof(int); ++i ) {
3952 for ( i = 0; i < (int)
sizeof(int); ++i ) sh.
endianness[i] = ((
char *)&endian)[i];
3964 for ( i = 0; i < 8; i++ ) dumw[i] = 0;
3965 dummy = (UBYTE *)dumw;
3966 dumw[0] = (WORD)MAXPOWER;
3967 for ( i = 0; i < 16; i++ ) sh.
maxpower[i] = dummy[i];
3968 dumw[0] = (WORD)WILDOFFSET;
3969 for ( i = 0; i < 16; i++ ) sh.
wildoffset[i] = dummy[i];
3973 return ( WriteFile(handle,(UBYTE *)(&sh),(LONG)(
sizeof(
STOREHEADER)))
3989static unsigned int CompactifySizeof(
unsigned int size)
3996 default: MesPrint(
"Error compactifying size.");
4022 static VOID (*flipJumpTable[4])(UBYTE *) =
4023 { Flip16, Flip32, Flip64, Flip128 };
4024 static VOID (*resizeJumpTable[4][4])(UBYTE *, UBYTE *) =
4025 { { Resize16t16, Resize32t16, Resize64t16, Resize128t16 },
4026 { Resize16t32, Resize32t32, Resize64t32, Resize128t32 },
4027 { Resize16t64, Resize32t64, Resize64t64, Resize128t64 },
4028 { Resize16t128, Resize32t128, Resize64t128, Resize128t128 } };
4029 static VOID (*resizeNCJumpTable[4][4])(UBYTE *, UBYTE *) =
4030 { { Resize16t16, Resize32t16NC, Resize64t16NC, Resize128t16NC },
4031 { Resize16t32, Resize32t32, Resize64t32NC, Resize128t32NC },
4032 { Resize16t64, Resize32t64, Resize64t64, Resize128t64NC },
4033 { Resize16t128, Resize32t128, Resize64t128, Resize128t128 } };
4036 WORD idxW = CompactifySizeof(
sizeof(WORD));
4037 WORD idxL = CompactifySizeof(
sizeof(LONG));
4038 WORD idxP = CompactifySizeof(
sizeof(
POSITION));
4039 WORD idxVP = CompactifySizeof(
sizeof(
void *));
4046 if ( ReadFile(AO.SaveData.Handle,(UBYTE *)(&AO.SaveHeader),
4048 return(MesPrint(
"Error reading save file header"));
4053 for ( i = 0; i < 8; ++i ) {
4054 if ( AO.SaveHeader.headermark[i] != 0xFF ) {
4057 SeekFile(AO.SaveData.Handle, &p, SEEK_SET);
4062 if ( AO.SaveHeader.revision != SAVEREVISION ) {
4063 return(MesPrint(
"Save file header from an old version. Cannot read this file."));
4067 for ( i = 1; i < (int)
sizeof(int); ++i ) {
4071 if ( ((
char *)&endian)[0] < ((
char *)&endian)[1] ) {
4073 AO.ResizeData = ResizeDataBE;
4077 AO.ResizeData = ResizeDataLE;
4081 if ( AO.SaveHeader.endianness[0] > AO.SaveHeader.endianness[1] ) {
4082 AO.transFlag = ( ((
char *)&endian)[0] < ((
char *)&endian)[1] );
4085 AO.transFlag = ( ((
char *)&endian)[0] > ((
char *)&endian)[1] );
4087 if ( (WORD)AO.SaveHeader.lenWORD !=
sizeof(WORD) ) AO.transFlag |= 0x02;
4088 if ( (WORD)AO.SaveHeader.lenLONG !=
sizeof(LONG) ) AO.transFlag |= 0x04;
4089 if ( (WORD)AO.SaveHeader.lenPOS !=
sizeof(
POSITION) ) AO.transFlag |= 0x08;
4090 if ( (WORD)AO.SaveHeader.lenPOINTER !=
sizeof(
void *) ) AO.transFlag |= 0x10;
4092 AO.FlipWORD = flipJumpTable[idxW];
4093 AO.FlipLONG = flipJumpTable[idxL];
4094 AO.FlipPOS = flipJumpTable[idxP];
4095 AO.FlipPOINTER = flipJumpTable[idxVP];
4098 AO.CheckPower = CheckPower32;
4099 AO.RenumberVec = RenumberVec32;
4101 AO.ResizeWORD = resizeJumpTable[idxW][CompactifySizeof(AO.SaveHeader.lenWORD)];
4102 AO.ResizeNCWORD = resizeNCJumpTable[idxW][CompactifySizeof(AO.SaveHeader.lenWORD)];
4103 AO.ResizeLONG = resizeJumpTable[idxL][CompactifySizeof(AO.SaveHeader.lenLONG)];
4104 AO.ResizePOS = resizeJumpTable[idxP][CompactifySizeof(AO.SaveHeader.lenPOS)];
4105 AO.ResizePOINTER = resizeJumpTable[idxVP][CompactifySizeof(AO.SaveHeader.lenPOINTER)];
4110 for ( i = 0; i < 8; i++ ) dumw[i] = 0;
4111 dummy = (UBYTE *)dumw;
4112 for ( i = 0; i < 16; i++ ) dummy[i] = AO.SaveHeader.maxpower[i];
4113 AO.mpower = dumw[0];
4140 if ( AO.transFlag ) {
4151 int lenW = AO.SaveHeader.lenWORD;
4152 int lenL = AO.SaveHeader.lenLONG;
4153 int lenP = AO.SaveHeader.lenPOS;
4156 if ( AO.bufferedInd ) {
4162 if ( ReadFile(AO.SaveData.Handle, (UBYTE *)fileind,
sizeof(
FILEINDEX))
4164 return ( MesPrint(
"Error(1) reading stored expression.") );
4168 if ( AO.transFlag & 1 ) {
4171 int padp = lenL - ((lenW*5+(MAXENAME + 1)) & (lenL-1));
4172 p = (UBYTE *)fileind;
4173 AO.FlipPOS(p); p += lenP;
4175 AO.ResizePOS(p, (UBYTE *)&
number);
4177 for ( i = 0; i <
number; ++i ) {
4178 AO.FlipPOS(p); p += lenP;
4179 AO.FlipPOS(p); p += lenP;
4180 AO.FlipPOS(p); p += lenP;
4181 AO.FlipLONG(p); p += lenL;
4182 AO.FlipWORD(p); p += lenW;
4183 AO.FlipWORD(p); p += lenW;
4184 AO.FlipWORD(p); p += lenW;
4185 AO.FlipWORD(p); p += lenW;
4186 AO.FlipWORD(p); p += lenW;
4192 if ( AO.transFlag > 1 ) {
4196 int padp = lenL - ((lenW*5+(MAXENAME + 1)) & (lenL-1));
4197 int padq =
sizeof(LONG) - ((
sizeof(WORD)*5+(MAXENAME + 1)) & (
sizeof(LONG)-1));
4199 p = (UBYTE *)fileind; q = (UBYTE *)&buffer;
4213 return ( MesPrint(
"Too many index entries.") );
4223 for ( i = 0; i < maxnumber; ++i ) {
4230 AO.ResizeLONG(p, q);
4231 p += lenL; q +=
sizeof(LONG);
4232 AO.ResizeWORD(p, q);
4233 p += lenW; q +=
sizeof(WORD);
4234 AO.ResizeWORD(p, q);
4235 p += lenW; q +=
sizeof(WORD);
4236 AO.ResizeWORD(p, q);
4237 p += lenW; q +=
sizeof(WORD);
4238 AO.ResizeWORD(p, q);
4239 p += lenW; q +=
sizeof(WORD);
4240 AO.ResizeWORD(p, q);
4241 p += lenW; q +=
sizeof(WORD);
4248 if ( AO.bufferedInd ) {
4250 SETBASEPOSITION(sbuffer.
number,AO.bufferedInd);
4251 q = (UBYTE *)&sbuffer +
sizeof(
POSITION) +
sizeof(LONG);
4252 for ( i = maxnumber; i <
number; ++i ) {
4259 AO.ResizeLONG(p, q);
4260 p += lenL; q +=
sizeof(LONG);
4261 AO.ResizeWORD(p, q);
4262 p += lenW; q +=
sizeof(WORD);
4263 AO.ResizeWORD(p, q);
4264 p += lenW; q +=
sizeof(WORD);
4265 AO.ResizeWORD(p, q);
4266 p += lenW; q +=
sizeof(WORD);
4267 AO.ResizeWORD(p, q);
4268 p += lenW; q +=
sizeof(WORD);
4269 AO.ResizeWORD(p, q);
4270 p += lenW; q +=
sizeof(WORD);
4278 p = (UBYTE *)fileind; q = (UBYTE *)&buffer; n =
sizeof(
FILEINDEX);
4283 return ( ReadFile(AO.SaveData.Handle, (UBYTE *)fileind,
sizeof(
FILEINDEX))
4327 if ( AO.transFlag ) {
4331 static WORD numReadSym;
4332 static WORD numReadInd;
4333 static WORD numReadVec;
4334 static WORD numReadFun;
4337 UBYTE *in, *out, *pp = 0, *end, *outbuf;
4339 WORD namelen, realnamelen;
4341 WORD lenW = AO.SaveHeader.lenWORD;
4342 WORD lenL = AO.SaveHeader.lenLONG;
4343 WORD lenP = AO.SaveHeader.lenPOINTER;
4344 WORD flip = AO.transFlag & 1;
4347 TELLFILE(AO.SaveData.Handle,&pos);
4355 if ( (lenW > (WORD)
sizeof(WORD))
4356 || ( (lenW == (WORD)
sizeof(WORD))
4357 && ( (lenL > (WORD)
sizeof(LONG))
4358 || ( (lenL == (WORD)
sizeof(LONG)) && lenP > (WORD)
sizeof(
void *))
4362 end = buffer + *size;
4369 LONG newsize = (top - buffer) / (1 +
sizeof(WORD)/lenW);
4373 if ( *size > newsize ) *size = newsize;
4376 if ( ( numread = ReadFile(AO.SaveData.Handle, in, *size) ) != *size ) {
4377 return ( MesPrint(
"Error(2) reading stored expression.") );
4384 if ( *stage == -1 ) {
4392 while ( in < end ) {
4394 if ( *stage == 0 ) {
4395 if ( ind->
nsymbols <= numReadSym ) {
4399 if ( end - in < AO.SaveHeader.sSym ) {
4404 AO.FlipLONG(pp); pp += lenL;
4405 while ( pp < in + AO.SaveHeader.sSym ) {
4406 AO.FlipWORD(pp); pp += lenW;
4409 pp = in + AO.SaveHeader.sSym;
4410 AO.ResizeLONG(in, out); in += lenL; out +=
sizeof(LONG);
4412 AO.ResizeWORD(in, out); in += lenW;
4413 if ( *((WORD *)out) == -AO.mpower ) *((WORD *)out) = -MAXPOWER;
4414 out +=
sizeof(WORD);
4415 AO.ResizeWORD(in, out); in += lenW;
4416 if ( *((WORD *)out) == AO.mpower ) *((WORD *)out) = MAXPOWER;
4417 out +=
sizeof(WORD);
4418 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4419 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4420 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4421 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4422 AO.ResizeWORD(in, out); in += lenW;
4423 realnamelen = *((WORD *)out);
4424 realnamelen +=
sizeof(
void *)-1; realnamelen &= -(
sizeof(
void *));
4425 out +=
sizeof(WORD);
4426 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4428 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4430 namelen = *((WORD *)out-1);
4431 if ( end - in < namelen ) {
4434 *((WORD *)out-1) = realnamelen;
4435 *size += AO.SaveHeader.sSym + namelen;
4436 *outsize +=
sizeof(
struct SyMbOl) + realnamelen;
4437 if ( realnamelen > namelen ) {
4440 out += realnamelen - namelen;
4443 int j = realnamelen;
4445 in += namelen - realnamelen;
4451 if ( *stage == 1 ) {
4452 if ( ind->
nindices <= numReadInd ) {
4456 if ( end - in < AO.SaveHeader.sInd ) {
4461 AO.FlipLONG(pp); pp += lenL;
4462 while ( pp < in + AO.SaveHeader.sInd ) {
4463 AO.FlipWORD(pp); pp += lenW;
4466 pp = in + AO.SaveHeader.sInd;
4467 AO.ResizeLONG(in, out); in += lenL; out +=
sizeof(LONG);
4468 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4469 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4470 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4471 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4472 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4473 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4474 AO.ResizeWORD(in, out); in += lenW;
4475 realnamelen = *((WORD *)out);
4476 realnamelen +=
sizeof(
void *)-1; realnamelen &= -(
sizeof(
void *));
4477 out +=
sizeof(WORD);
4479 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4481 namelen = *((WORD *)out-1);
4482 if ( end - in < namelen ) {
4485 *((WORD *)out-1) = realnamelen;
4486 *size += AO.SaveHeader.sInd + namelen;
4487 *outsize +=
sizeof(
struct InDeX) + realnamelen;
4488 if ( realnamelen > namelen ) {
4491 out += realnamelen - namelen;
4494 int j = realnamelen;
4496 in += namelen - realnamelen;
4502 if ( *stage == 2 ) {
4503 if ( ind->
nvectors <= numReadVec ) {
4507 if ( end - in < AO.SaveHeader.sVec ) {
4512 AO.FlipLONG(pp); pp += lenL;
4513 while ( pp < in + AO.SaveHeader.sVec ) {
4514 AO.FlipWORD(pp); pp += lenW;
4517 pp = in + AO.SaveHeader.sVec;
4518 AO.ResizeLONG(in, out); in += lenL; out +=
sizeof(LONG);
4519 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4520 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4521 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4522 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4523 AO.ResizeWORD(in, out); in += lenW;
4524 realnamelen = *((WORD *)out);
4525 realnamelen +=
sizeof(
void *)-1; realnamelen &= -(
sizeof(
void *));
4526 out +=
sizeof(WORD);
4527 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4529 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4531 namelen = *((WORD *)out-1);
4532 if ( end - in < namelen ) {
4535 *((WORD *)out-1) = realnamelen;
4536 *size += AO.SaveHeader.sVec + namelen;
4537 *outsize +=
sizeof(
struct VeCtOr) + realnamelen;
4538 if ( realnamelen > namelen ) {
4541 out += realnamelen - namelen;
4544 int j = realnamelen;
4546 in += namelen - realnamelen;
4552 if ( *stage == 3 ) {
4557 if ( end - in < AO.SaveHeader.sFun ) {
4562 AO.FlipPOINTER(pp); pp += lenP;
4563 AO.FlipLONG(pp); pp += lenL;
4564 AO.FlipLONG(pp); pp += lenL;
4565 while ( pp < in + AO.SaveHeader.sFun ) {
4566 AO.FlipWORD(pp); pp += lenW;
4569 pp = in + AO.SaveHeader.sFun;
4571 AO.ResizePOINTER(in, out); in += lenP; out +=
sizeof(
void *);
4572 AO.ResizeLONG(in, out); in += lenL; out +=
sizeof(LONG);
4573 AO.ResizeLONG(in, out); in += lenL; out +=
sizeof(LONG);
4574 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4575 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4576 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4577 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4578 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4579 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4580 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4581 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4582 AO.ResizeWORD(in, out); in += lenW;
4583 realnamelen = *((WORD *)out);
4584 realnamelen +=
sizeof(
void *)-1; realnamelen &= -(
sizeof(
void *));
4585 out +=
sizeof(WORD);
4586 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4588 AO.ResizeWORD(in, out); in += lenW; out +=
sizeof(WORD);
4590 namelen = *((WORD *)out-1);
4591 if ( end - in < namelen ) {
4594 *((WORD *)out-1) = realnamelen;
4595 *size += AO.SaveHeader.sFun + namelen;
4596 *outsize +=
sizeof(
struct FuNcTiOn) + realnamelen;
4597 if ( realnamelen > namelen ) {
4600 out += realnamelen - namelen;
4603 int j = realnamelen;
4605 in += namelen - realnamelen;
4609 AO.tensorList[((
FUNCTIONS)outbuf)->number+FUNCTION] =
4610 (UBYTE)(((
FUNCTIONS)outbuf)->spec == TENSORFUNCTION);
4614 if ( end - in >= lenW ) {
4615 if ( flip ) AO.FlipWORD(in);
4616 AO.ResizeWORD(in, out);
4618 *outsize +=
sizeof(WORD);
4621 if ( end - in >= lenW ) {
4622 if ( flip ) AO.FlipWORD(in);
4623 AO.ResizeWORD(in, out);
4625 *outsize +=
sizeof(WORD);
4628 if ( end - in >= lenW ) {
4629 if ( flip ) AO.FlipWORD(in);
4630 AO.ResizeWORD(in, out);
4632 *outsize +=
sizeof(WORD);
4642 SeekFile(AO.SaveData.Handle, &pos, SEEK_SET);
4645 return ( ReadFile(AO.SaveData.Handle, buffer, *size) != *size );
4683ReadSaveTerm32(UBYTE *bin, UBYTE *binend, UBYTE **bout, UBYTE *boutend, UBYTE *top,
int terminbuf)
4689 INT32 *r, *t, *coeff, *end, *newtermsize, *rend;
4691 INT32 *in = (INT32 *)bin;
4692 INT32 *out = (INT32 *)*bout;
4701 rend = (INT32 *)boutend;
4702 coeff = end - ABS(*(end-1));
4703 newtermsize = (INT32 *)*bout;
4704 out = newtermsize + 1;
4710 r = (INT32 *)AR.CompressBuffer;
4716 if ( (UBYTE *)in >= binend ) {
4719 *out = len = -j + 1 + *in;
4721 if ( (UBYTE *)end >= top ) {
4726 while ( ++j <= 0 ) {
4732 else if ( j == 0 ) {
4734 while ( (UBYTE *)in < binend ) {
4736 if ( (UBYTE *)out > top ) {
4737 return ( (UBYTE *)bin );
4743 *bout = (UBYTE *)out;
4744 return ( (UBYTE *)in );
4748 if ( (UBYTE *)end >= top ) {
4752 if ( (UBYTE *)(in + j) >= binend ) {
4753 *(AR.CompressBuffer) = rbuf;
4756 if ( (UBYTE *)out + j >= top ) {
4760 while ( --j >= 0 ) {
4766 r = (INT32 *)AR.CompressBuffer + 1;
4767 coeff = end - ABS(*(end-1));
4768 newtermsize = (INT32 *)*bout;
4769 out = newtermsize + 1;
4773 while ( out < coeff ) {
4781 if (
id == SYMBOL ) {
4785 if ( ABS(*out) >= MAXPOWER ) {
4788 INT32 num = *(out-1);
4793 if ( (UBYTE *)end > top )
return ( bin );
4803 *out++ = ABS(exp) & 0x0000FFFF;
4804 *out++ = ABS(exp) >> 16;
4807 *out++ = ( exp < 0 ) ? -5 : 5;
4818 else if (
id == DOTPRODUCT ) {
4820 AO.RenumberVec((UBYTE *)out);
4822 AO.RenumberVec((UBYTE *)out);
4825 if ( ABS(*out) >= MAXPOWER ) {
4828 INT32 num1 = *(out-2);
4829 INT32 num2 = *(out-1);
4834 if ( (UBYTE *)end > top )
return ( bin );
4842 *out++ = DOTPRODUCT;
4853 *out++ = ABS(exp) & 0x0000FFFF;
4854 *out++ = ABS(exp) >> 16;
4857 *out++ = ( exp < 0 ) ? -5 : 5;
4868 else if (
id == VECTOR ) {
4870 AO.RenumberVec((UBYTE *)out);
4875 else if (
id == INDEX ) {
4877 void *dummy = (
void *)AO.SaveHeader.wildoffset;
4878 INT32 vectoroffset = -2 * *((INT32 *)dummy);
4881 if ( *out < vectoroffset ) {
4882 AO.RenumberVec((UBYTE *)out);
4887 else if (
id == SUBEXPRESSION ) {
4893 else if (
id == DELTA ) {
4898 else if (
id == HAAKJE ) {
4903 else if (
id == GAMMA ||
id == LEVICIVITA || (
id >= FUNCTION && AO.tensorList[
id]) ) {
4905 void *dummy = (
void *)AO.SaveHeader.wildoffset;
4906 INT32 vectoroffset = -2 * *((INT32 *)dummy);
4909 if ( *out < vectoroffset ) {
4910 AO.RenumberVec((UBYTE *)out);
4915 else if (
id >= FUNCTION ) {
4932 if (
sizeof(WORD) == 2 ) {
4934 if ( *out > (1<<15)-1 || *out < -(1<<15)+1 ) {
4942 if ( (UBYTE *)end > top )
return ( bin );
4947 *out++ = ABS(num) & 0x0000FFFF;
4948 *out++ = ABS(num) >> 16;
4951 *out++ = ( num < 0 ) ? -5 : 5;
4967 AO.RenumberVec((UBYTE *)out);
4976 AO.RenumberVec((UBYTE *)out);
4980 if ( -*out >= FUNCTION ) {
4984 MesPrint(
"short function code %d not implemented.", *out);
4985 return ( (UBYTE *)in );
4991 INT32 *newargsize = out;
4992 argEnd = out + *out;
4995 while ( out < argEnd ) {
4996 INT32 *keepsizep = out + *out;
4997 INT32 lenbuf = *out;
5000 newbin =
ReadSaveTerm32((UBYTE *)r, binend, (UBYTE **)ppp, (UBYTE *)rend, top, 1);
5002 if ( newbin == (UBYTE *)r ) {
5003 return ( (UBYTE *)in );
5007 if ( out > keepsizep ) {
5010 INT32 extention = out - keepsizep;
5017 argEnd += extention;
5020 else if ( out < keepsizep ) {
5023 INT32 extention = keepsizep - out;
5030 argEnd -= extention;
5034 *newargsize = out - newargsize;
5039 MesPrint(
"ID %d not recognized.",
id);
5040 return ( (UBYTE *)in );
5043 *newsubtermp = out - newsubtermp + 1;
5046 if ( (UBYTE *)end >= top ) {
5052 *bout = (UBYTE *)out;
5054 ResizeCoeff32(bout, (UBYTE *)end, top);
5056 if ( *bout >= top ) {
5061 *newtermsize = (INT32 *)*bout - newtermsize;
5063 return ( (UBYTE *)in );
5094 if ( AO.transFlag ) {
5095 UBYTE *in, *end, *out, *outend, *p;
5098 WORD lenW = AO.SaveHeader.lenWORD;
5102 TELLFILE(AO.SaveData.Handle,&pos);
5106 half = (top-buffer)/2;
5107 if ( *size > half ) *size = half;
5108 if ( lenW < (WORD)
sizeof(WORD) ) {
5109 if ( *size * (LONG)
sizeof(WORD)/lenW > half ) *size = half*lenW/(LONG)
sizeof(WORD);
5112 if ( *size > half ) *size = half;
5123 if ( lenW ==
sizeof(WORD) ) in += half;
5126 outend = out + *size;
5128 if ( ReadFile(AO.SaveData.Handle, in, *size) != *size ) {
5129 return ( MesPrint(
"Error(3) reading stored expression.") );
5132 if ( AO.transFlag & 1 ) {
5135 while ( p <= end ) {
5136 AO.FlipWORD(p); p += lenW;
5141 if ( lenW > (WORD)
sizeof(WORD) ) {
5145 if ( outend > top ) outend = top;
5147 if ( p == in )
break;
5149 }
while ( in <= end - lenW );
5151 *size = in - buffer;
5156 while ( in < end ) {
5158 AO.ResizeNCWORD(in, out);
5159 in += lenW; out +=
sizeof(WORD);
5163 if ( lenW < (WORD)
sizeof(WORD) ) {
5165 while ( in < end ) {
5166 AO.ResizeWORD(in, out);
5167 in += lenW; out +=
sizeof(WORD);
5176 if ( p == in )
break;
5178 }
while ( in <= end -
sizeof(WORD) );
5179 *size = (in - buffer - half) * lenW / (ULONG)
sizeof(WORD);
5181 *outsize = out - buffer;
5183 SeekFile(AO.SaveData.Handle, &pos, SEEK_SET);
5188 return ( ReadFile(AO.SaveData.Handle, buffer, *size) != *size );
WORD WriteStoreHeader(WORD handle)
WORD ReadSaveVariables(UBYTE *buffer, UBYTE *top, LONG *size, LONG *outsize, INDEXENTRY *ind, LONG *stage)
UBYTE * ReadSaveTerm32(UBYTE *bin, UBYTE *binend, UBYTE **bout, UBYTE *boutend, UBYTE *top, int terminbuf)
WORD TermRenumber(WORD *term, RENUMBER renumber, WORD nexpr)
WORD ReadSaveExpression(UBYTE *buffer, UBYTE *top, LONG *size, LONG *outsize)
WORD ReadSaveIndex(FILEINDEX *fileind)
INDEXENTRY expression[INFILEINDEX]
struct FuNcTiOn * FUNCTIONS
struct ReNuMbEr * RENUMBER
struct FiLeInDeX FILEINDEX
struct StOrEcAcHe * STORECACHE