1410 char *namebufout, *namebufhide;
1412 void *oldAMdollarzero;
1413 LIST PotModDolListBackup;
1414 LIST ModOptDolListBackup;
1417 MesPrint(
"Recovering ... %"); fflush(0);
1419 if ( !(fd = fopen(recoveryfile,
"r")) )
return(__LINE__);
1422 if ( fread(&pos,
sizeof(
POSITION), 1, fd) != 1 )
return(__LINE__);
1423 size = BASEPOSITION(pos) -
sizeof(
POSITION);
1424 buf = Malloc1(size,
"recovery buffer");
1425 if ( fread(buf, size, 1, fd) != 1 )
return(__LINE__);
1431 R_SET(*moduletype,
int);
1438 R_SET(AM.hparallelflag,
int);
1439 R_SET(AM.gparallelflag,
int);
1440 R_SET(AM.gCodesFlag,
int);
1441 R_SET(AM.gNamesFlag,
int);
1442 R_SET(AM.gStatsFlag,
int);
1443 R_SET(AM.gTokensWriteFlag,
int);
1444 R_SET(AM.gNoSpacesInNumbers,
int);
1445 R_SET(AM.gIndentSpace, WORD);
1446 R_SET(AM.gUnitTrace, WORD);
1447 R_SET(AM.gDefDim,
int);
1448 R_SET(AM.gDefDim4,
int);
1449 R_SET(AM.gncmod, WORD);
1450 R_SET(AM.gnpowmod, WORD);
1451 R_SET(AM.gmodmode, WORD);
1452 R_SET(AM.gOutputMode, WORD);
1453 R_SET(AM.gCnumpows, WORD);
1454 R_SET(AM.gOutputSpaces, WORD);
1455 R_SET(AM.gOutNumberType, WORD);
1456 R_SET(AM.gfunpowers,
int);
1457 R_SET(AM.gPolyFun, WORD);
1458 R_SET(AM.gPolyFunInv, WORD);
1459 R_SET(AM.gPolyFunType, WORD);
1460 R_SET(AM.gPolyFunExp, WORD);
1461 R_SET(AM.gPolyFunVar, WORD);
1462 R_SET(AM.gPolyFunPow, WORD);
1463 R_SET(AM.gProcessBucketSize, LONG);
1464 R_SET(AM.OldChildTime, LONG);
1465 R_SET(AM.OldSecTime, LONG);
1466 R_SET(AM.OldMilliTime, LONG);
1467 R_SET(AM.gproperorderflag,
int);
1468 R_SET(AM.gThreadBucketSize, LONG);
1469 R_SET(AM.gSizeCommuteInSet,
int);
1470 R_SET(AM.gThreadStats,
int);
1471 R_SET(AM.gFinalStats,
int);
1472 R_SET(AM.gThreadsFlag,
int);
1473 R_SET(AM.gThreadBalancing,
int);
1474 R_SET(AM.gThreadSortFileSynch,
int);
1475 R_SET(AM.gProcessStats,
int);
1476 R_SET(AM.gOldParallelStats,
int);
1477 R_SET(AM.gSortType,
int);
1478 R_SET(AM.gShortStatsMax, WORD);
1479 R_SET(AM.gIsFortran90,
int);
1480 R_SET(oldAMdollarzero,
void*);
1481 R_FREE(AM.gFortran90Kind);
1482 R_SET(AM.gFortran90Kind,UBYTE *);
1483 R_COPY_S(AM.gFortran90Kind,UBYTE *);
1485 R_COPY_S(AM.gextrasym,UBYTE *);
1486 R_COPY_S(AM.ggextrasym,UBYTE *);
1488 R_SET(AM.PrintTotalSize,
int);
1489 R_SET(AM.fbuffersize,
int);
1490 R_SET(AM.gOldFactArgFlag,
int);
1491 R_SET(AM.ggOldFactArgFlag,
int);
1493 R_SET(AM.gnumextrasym,
int);
1494 R_SET(AM.ggnumextrasym,
int);
1495 R_SET(AM.NumSpectatorFiles,
int);
1496 R_SET(AM.SizeForSpectatorFiles,
int);
1497 R_SET(AM.gOldGCDflag,
int);
1498 R_SET(AM.ggOldGCDflag,
int);
1499 R_SET(AM.gWTimeStatsFlag,
int);
1502 R_SET(AM.Path,UBYTE *);
1503 R_COPY_S(AM.Path,UBYTE *);
1505 R_SET(AM.FromStdin, BOOL);
1519 R_FREE_NAMETREE(AC.dollarnames);
1520 R_FREE_NAMETREE(AC.exprnames);
1521 R_FREE_NAMETREE(AC.varnames);
1522 for ( i=0; i<AC.ChannelList.num; ++i ) {
1523 R_FREE(channels[i].name);
1525 R_FREE(AC.ChannelList.lijst);
1526 R_FREE(AC.DubiousList.lijst);
1527 for ( i=0; i<AC.FunctionList.num; ++i ) {
1528 TABLES T = functions[i].tabl;
1552 R_FREE(AC.FunctionList.lijst);
1553 for ( i=0; i<AC.ExpressionList.num; ++i ) {
1554 if ( Expressions[i].renum ) {
1555 R_FREE(Expressions[i].renum->symb.lo);
1556 R_FREE(Expressions[i].renum);
1558 if ( Expressions[i].bracketinfo ) {
1559 R_FREE(Expressions[i].bracketinfo->indexbuffer);
1560 R_FREE(Expressions[i].bracketinfo->bracketbuffer);
1561 R_FREE(Expressions[i].bracketinfo);
1563 if ( Expressions[i].newbracketinfo ) {
1564 R_FREE(Expressions[i].newbracketinfo->indexbuffer);
1565 R_FREE(Expressions[i].newbracketinfo->bracketbuffer);
1566 R_FREE(Expressions[i].newbracketinfo);
1568 if ( Expressions[i].renumlists != AN.dummyrenumlist ) {
1569 R_FREE(Expressions[i].renumlists);
1571 R_FREE(Expressions[i].inmem);
1573 R_FREE(AC.ExpressionList.lijst);
1574 R_FREE(AC.IndexList.lijst);
1575 R_FREE(AC.SetElementList.lijst);
1576 R_FREE(AC.SetList.lijst);
1577 R_FREE(AC.SymbolList.lijst);
1578 R_FREE(AC.VectorList.lijst);
1579 for ( i=0; i<AC.TableBaseList.num; ++i ) {
1580 R_FREE(tablebases[i].iblocks);
1581 R_FREE(tablebases[i].nblocks);
1582 R_FREE(tablebases[i].name);
1583 R_FREE(tablebases[i].fullname);
1584 R_FREE(tablebases[i].tablenames);
1586 R_FREE(AC.TableBaseList.lijst);
1587 for ( i=0; i<AC.cbufList.num; ++i ) {
1588 R_FREE(cbuf[i].Buffer);
1589 R_FREE(cbuf[i].lhs);
1590 R_FREE(cbuf[i].rhs);
1591 R_FREE(cbuf[i].boomlijst);
1593 R_FREE(AC.cbufList.lijst);
1594 R_FREE(AC.AutoSymbolList.lijst);
1595 R_FREE(AC.AutoIndexList.lijst);
1596 R_FREE(AC.AutoVectorList.lijst);
1598 R_FREE(AC.AutoFunctionList.lijst);
1599 R_FREE_NAMETREE(AC.autonames);
1600 for ( i=0; i<AC.NumStreams; ++i ) {
1601 R_FREE_STREAM(AC.Streams[i]);
1604 R_FREE(AC.termstack);
1605 R_FREE(AC.termsortstack);
1607 R_FREE(AC.modpowers);
1612 for ( i=0; i<AC.NumLabels; ++i ) {
1613 R_FREE(AC.LabelNames[i]);
1615 R_FREE(AC.LabelNames);
1616 R_FREE(AC.FixIndices);
1617 R_FREE(AC.termsumcheck);
1618 R_FREE(AC.WildcardNames);
1620 R_FREE(AC.tokenarglevel);
1621 R_FREE(AC.modinverses);
1622 R_FREE(AC.Fortran90Kind);
1624 R_FREE(AC.inputnumbers);
1626 R_FREE(AC.IfSumCheck);
1627 R_FREE(AC.CommuteInSet);
1628 R_FREE(AC.CheckpointRunAfter);
1629 R_FREE(AC.CheckpointRunBefore);
1634 PotModDolListBackup = AC.PotModDolList;
1635 ModOptDolListBackup = AC.ModOptDolList;
1636 oldLogHandle = AC.LogHandle;
1641 AC = *((
struct C_const*)p); p = (
unsigned char*)p +
sizeof(
struct C_const);
1643 R_COPY_NAMETREE(AC.dollarnames);
1644 R_COPY_NAMETREE(AC.exprnames);
1645 R_COPY_NAMETREE(AC.varnames);
1647 R_COPY_LIST(AC.ChannelList);
1648 for ( i=0; i<AC.ChannelList.num; ++i ) {
1649 R_COPY_S(channels[i].name,
char*);
1650 channels[i].handle = ReOpenFile(channels[i].name);
1652 AC.ChannelList.message =
"channel buffer";
1654 AC.DubiousList.lijst = 0;
1655 AC.DubiousList.message =
"ambiguous variable";
1656 AC.DubiousList.num =
1657 AC.DubiousList.maxnum =
1658 AC.DubiousList.numglobal =
1659 AC.DubiousList.numtemp =
1660 AC.DubiousList.numclear = 0;
1662 R_COPY_LIST(AC.FunctionList);
1663 for ( i=0; i<AC.FunctionList.num; ++i ) {
1664 if ( functions[i].tabl ) {
1667 functions[i].tabl = tabl;
1676 TABLEEXTENSION*
sizeof(WORD)*(tabl->
totind), WORD*);
1683 for ( j=0; j<AM.totalnumberofthreads; ++j ) {
1690 for ( j=0; j<AM.totalnumberofthreads; ++j ) {
1704 R_COPY_B(tabl->
flags, tabl->
numind*(LONG)
sizeof(WORD), WORD*);
1707 R_COPY_S(tabl->
argtail,UBYTE*);
1710 if ( tabl->
spare ) {
1713 tabl->
spare = spare;
1722 TABLEEXTENSION*
sizeof(WORD)*(spare->
totind), WORD*);
1728 R_COPY_B(spare->
flags, spare->
numind*(LONG)
sizeof(WORD), WORD*);
1733 spare->
spare = tabl;
1738 AC.FunctionList.message =
"function";
1740 R_COPY_LIST(AC.ExpressionList);
1741 for ( i=0; i<AC.ExpressionList.num; ++i ) {
1745 org = (UBYTE*)ex->renum->
symb.
lo;
1746 R_SET(size,
size_t);
1747 R_COPY_B(ex->renum->
symb.
lo, size, WORD*);
1748 ofs = (UBYTE*)ex->renum->
symb.
lo - org;
1750 ex->renum->
symb.
hi = (WORD*)((UBYTE*)ex->renum->
symb.
hi + ofs);
1751 ex->renum->
indi.
lo = (WORD*)((UBYTE*)ex->renum->
indi.
lo + ofs);
1753 ex->renum->
indi.
hi = (WORD*)((UBYTE*)ex->renum->
indi.
hi + ofs);
1754 ex->renum->
vect.
lo = (WORD*)((UBYTE*)ex->renum->
vect.
lo + ofs);
1756 ex->renum->
vect.
hi = (WORD*)((UBYTE*)ex->renum->
vect.
hi + ofs);
1757 ex->renum->
func.
lo = (WORD*)((UBYTE*)ex->renum->
func.
lo + ofs);
1759 ex->renum->
func.
hi = (WORD*)((UBYTE*)ex->renum->
func.
hi + ofs);
1760 ex->renum->
symnum = (WORD*)((UBYTE*)ex->renum->
symnum + ofs);
1761 ex->renum->
indnum = (WORD*)((UBYTE*)ex->renum->
indnum + ofs);
1762 ex->renum->
vecnum = (WORD*)((UBYTE*)ex->renum->
vecnum + ofs);
1763 ex->renum->
funnum = (WORD*)((UBYTE*)ex->renum->
funnum + ofs);
1765 if ( ex->bracketinfo ) {
1768 R_COPY_B(ex->bracketinfo->
bracketbuffer, ex->bracketinfo->bracketbuffersize*
sizeof(WORD), WORD*);
1770 if ( ex->newbracketinfo ) {
1773 R_COPY_B(ex->newbracketinfo->
bracketbuffer, ex->newbracketinfo->bracketbuffersize*
sizeof(WORD), WORD*);
1781 R_SET(size,
size_t);
1782 R_COPY_B(ex->inmem, size, WORD*);
1785 AC.ExpressionList.message =
"expression";
1787 R_COPY_LIST(AC.IndexList);
1788 AC.IndexList.message =
"index";
1789 R_COPY_LIST(AC.SetElementList);
1790 AC.SetElementList.message =
"set element";
1791 R_COPY_LIST(AC.SetList);
1792 AC.SetList.message =
"set";
1793 R_COPY_LIST(AC.SymbolList);
1794 AC.SymbolList.message =
"symbol";
1795 R_COPY_LIST(AC.VectorList);
1796 AC.VectorList.message =
"vector";
1798 AC.PotModDolList = PotModDolListBackup;
1799 AC.ModOptDolList = ModOptDolListBackup;
1801 R_COPY_LIST(AC.TableBaseList);
1802 for ( i=0; i<AC.TableBaseList.num; ++i ) {
1803 if ( tablebases[i].iblocks ) {
1804 R_COPY_B(tablebases[i].iblocks, tablebases[i].info.numberofindexblocks*
sizeof(
INDEXBLOCK*),
INDEXBLOCK**);
1805 for ( j=0; j<tablebases[i].info.numberofindexblocks; ++j ) {
1806 if ( tablebases[i].iblocks[j] ) {
1811 if ( tablebases[i].nblocks ) {
1812 R_COPY_B(tablebases[i].nblocks, tablebases[i].info.numberofnamesblocks*
sizeof(
NAMESBLOCK*),
NAMESBLOCK**);
1813 for ( j=0; j<tablebases[i].info.numberofindexblocks; ++j ) {
1814 if ( tablebases[i].nblocks[j] ) {
1820 if ( ( tablebases[i].handle = fopen(tablebases[i].fullname,
"r+b") ) == NULL ) {
1821 MesPrint(
"ERROR: Could not reopen tablebase %s!",tablebases[i].name);
1824 R_COPY_S(tablebases[i].name,
char*);
1825 R_COPY_S(tablebases[i].fullname,
char*);
1826 R_COPY_S(tablebases[i].tablenames,
char*);
1828 AC.TableBaseList.message =
"list of tablebases";
1830 R_COPY_LIST(AC.cbufList);
1831 for ( i=0; i<AC.cbufList.num; ++i ) {
1832 org = (UBYTE*)cbuf[i].Buffer;
1833 R_COPY_B(cbuf[i].Buffer, cbuf[i].BufferSize*
sizeof(WORD), WORD*);
1834 ofs = (UBYTE*)cbuf[i].Buffer - org;
1835 cbuf[i].Top = (WORD*)((UBYTE*)cbuf[i].Top + ofs);
1836 cbuf[i].Pointer = (WORD*)((UBYTE*)cbuf[i].Pointer + ofs);
1837 R_COPY_B(cbuf[i].lhs, cbuf[i].maxlhs*(LONG)
sizeof(WORD*), WORD**);
1838 for ( j=1; j<=cbuf[i].numlhs; ++j ) {
1839 if ( cbuf[i].lhs[j] ) cbuf[i].lhs[j] = (WORD*)((UBYTE*)cbuf[i].lhs[j] + ofs);
1841 org = (UBYTE*)cbuf[i].rhs;
1842 R_COPY_B(cbuf[i].rhs, cbuf[i].maxrhs*(LONG)(
sizeof(WORD*)+2*
sizeof(LONG)+2*
sizeof(WORD)), WORD**);
1843 for ( j=1; j<=cbuf[i].numrhs; ++j ) {
1844 if ( cbuf[i].rhs[j] ) cbuf[i].rhs[j] = (WORD*)((UBYTE*)cbuf[i].rhs[j] + ofs);
1846 ofs = (UBYTE*)cbuf[i].rhs - org;
1847 cbuf[i].CanCommu = (LONG*)((UBYTE*)cbuf[i].CanCommu + ofs);
1848 cbuf[i].NumTerms = (LONG*)((UBYTE*)cbuf[i].NumTerms + ofs);
1849 cbuf[i].numdum = (WORD*)((UBYTE*)cbuf[i].numdum + ofs);
1850 cbuf[i].dimension = (WORD*)((UBYTE*)cbuf[i].dimension + ofs);
1851 if ( cbuf[i].boomlijst ) {
1852 R_COPY_B(cbuf[i].boomlijst, cbuf[i].MaxTreeSize*
sizeof(
COMPTREE),
COMPTREE*);
1855 AC.cbufList.message =
"compiler buffer";
1857 R_COPY_LIST(AC.AutoSymbolList);
1858 AC.AutoSymbolList.message =
"autosymbol";
1859 R_COPY_LIST(AC.AutoIndexList);
1860 AC.AutoIndexList.message =
"autoindex";
1861 R_COPY_LIST(AC.AutoVectorList);
1862 AC.AutoVectorList.message =
"autovector";
1863 R_COPY_LIST(AC.AutoFunctionList);
1864 AC.AutoFunctionList.message =
"autofunction";
1866 R_COPY_NAMETREE(AC.autonames);
1868 AC.Symbols = &(AC.SymbolList);
1869 AC.Indices = &(AC.IndexList);
1870 AC.Vectors = &(AC.VectorList);
1871 AC.Functions = &(AC.FunctionList);
1872 AC.activenames = &(AC.varnames);
1874 org = (UBYTE*)AC.Streams;
1875 R_COPY_B(AC.Streams, AC.MaxNumStreams*(LONG)
sizeof(
STREAM),
STREAM*);
1876 for ( i=0; i<AC.NumStreams; ++i ) {
1877 if ( AC.Streams[i].type != FILESTREAM ) {
1879 org2 = AC.Streams[i].buffer;
1880 if ( AC.Streams[i].inbuffer ) {
1881 R_COPY_B(AC.Streams[i].buffer, AC.Streams[i].inbuffer, UBYTE*);
1883 ofs = AC.Streams[i].buffer - org2;
1884 AC.Streams[i].pointer += ofs;
1885 AC.Streams[i].top += ofs;
1888 p = (
unsigned char*)p + AC.Streams[i].inbuffer;
1890 AC.Streams[i].buffersize = AC.Streams[i].inbuffer;
1891 R_COPY_S(AC.Streams[i].FoldName,UBYTE*);
1892 R_COPY_S(AC.Streams[i].name,UBYTE*);
1893 if ( AC.Streams[i].type == PREVARSTREAM || AC.Streams[i].type == DOLLARSTREAM ) {
1894 AC.Streams[i].pname = AC.Streams[i].name;
1896 else if ( AC.Streams[i].type == FILESTREAM ) {
1898 org2 = AC.Streams[i].buffer;
1899 AC.Streams[i].buffer = (UBYTE*)Malloc1(AC.Streams[i].buffersize,
"buffer");
1900 ofs = AC.Streams[i].buffer - org2;
1901 AC.Streams[i].pointer += ofs;
1902 AC.Streams[i].top += ofs;
1906 AC.Streams[i].handle = OpenFile((
char *)(AC.Streams[i].name));
1907 if ( AC.Streams[i].handle == -1 ) {
1908 MesPrint(
"ERROR: Could not reopen stream %s!",AC.Streams[i].name);
1914 ADDPOS(pos, AC.Streams[i].bufferposition);
1915 SeekFile(AC.Streams[i].handle, &pos, SEEK_SET);
1917 AC.Streams[i].inbuffer = ReadFile(AC.Streams[i].handle, AC.Streams[i].buffer, AC.Streams[i].inbuffer);
1919 SETBASEPOSITION(pos, AC.Streams[i].fileposition);
1920 SeekFile(AC.Streams[i].handle, &pos, SEEK_SET);
1932 ofs = (UBYTE*)AC.Streams - org;
1933 AC.CurrentStream = (
STREAM*)((UBYTE*)AC.CurrentStream + ofs);
1935 if ( AC.termstack ) {
1936 R_COPY_B(AC.termstack, AC.maxtermlevel*(LONG)
sizeof(LONG), LONG*);
1939 if ( AC.termsortstack ) {
1940 R_COPY_B(AC.termsortstack, AC.maxtermlevel*(LONG)
sizeof(LONG), LONG*);
1944 R_COPY_B(AC.cmod, AM.MaxTal*4*(LONG)
sizeof(UWORD), UWORD*);
1945 AM.gcmod = AC.cmod + AM.MaxTal;
1946 AC.powmod = AM.gcmod + AM.MaxTal;
1947 AM.gpowmod = AC.powmod + AM.MaxTal;
1955 ofs = AC.IfStack - AC.IfHeap;
1956 R_COPY_B(AC.IfHeap, (LONG)
sizeof(LONG)*(AC.MaxIf+1), LONG*);
1957 AC.IfStack = AC.IfHeap + ofs;
1958 R_COPY_B(AC.IfCount, (LONG)
sizeof(LONG)*(AC.MaxIf+1), LONG*);
1962 size = AC.iStop - AC.iBuffer + 2;
1963 R_COPY_B(AC.iBuffer, size, UBYTE*);
1964 ofs = AC.iBuffer - org;
1968 if ( AC.LabelNames ) {
1969 org = (UBYTE*)AC.LabelNames;
1970 R_COPY_B(AC.LabelNames, AC.MaxLabels*(LONG)(
sizeof(UBYTE*)+
sizeof(WORD)), UBYTE**);
1971 for ( i=0; i<AC.NumLabels; ++i ) {
1972 R_COPY_S(AC.LabelNames[i],UBYTE*);
1974 ofs = (UBYTE*)AC.LabelNames - org;
1975 AC.Labels = (
int*)((UBYTE*)AC.Labels + ofs);
1978 R_COPY_B(AC.FixIndices, AM.OffsetIndex*(LONG)
sizeof(WORD), WORD*);
1980 if ( AC.termsumcheck ) {
1981 R_COPY_B(AC.termsumcheck, AC.maxtermlevel*(LONG)
sizeof(WORD), WORD*);
1984 R_COPY_B(AC.WildcardNames, AC.WildcardBufferSize, UBYTE*);
1987 size = AC.toptokens - AC.tokens;
1989 org = (UBYTE*)AC.tokens;
1990 R_COPY_B(AC.tokens, size, SBYTE*);
1991 ofs = (UBYTE*)AC.tokens - org;
1992 AC.endoftokens += ofs;
1993 AC.toptokens += ofs;
1997 AC.endoftokens = AC.tokens;
1998 AC.toptokens = AC.tokens;
2002 R_COPY_B(AC.tokenarglevel, AM.MaxParLevel*(LONG)
sizeof(WORD), WORD*);
2006 R_COPY_S(AC.Fortran90Kind,UBYTE *);
2009 if ( AC.inputnumbers ) {
2010 org = (UBYTE*)AC.inputnumbers;
2011 R_COPY_B(AC.inputnumbers, AC.sizepfirstnum*(LONG)(
sizeof(WORD)+
sizeof(LONG)), LONG*);
2012 ofs = (UBYTE*)AC.inputnumbers - org;
2013 AC.pfirstnum = (WORD*)((UBYTE*)AC.pfirstnum + ofs);
2015 AC.halfmodlock = dummylock;
2018 if ( AC.IfSumCheck ) {
2019 R_COPY_B(AC.IfSumCheck, (LONG)
sizeof(WORD)*(AC.MaxIf+1), WORD*);
2021 if ( AC.CommuteInSet ) {
2022 R_COPY_B(AC.CommuteInSet, (LONG)
sizeof(WORD)*(AC.SizeCommuteInSet+1), WORD*);
2025 AC.LogHandle = oldLogHandle;
2027 R_COPY_S(AC.CheckpointRunAfter,
char*);
2028 R_COPY_S(AC.CheckpointRunBefore,
char*);
2030 R_COPY_S(AC.extrasym,UBYTE *);
2044 for ( i=0; i<AP.DollarList.num; ++i ) {
2045 if ( Dollars[i].size ) {
2046 R_FREE(Dollars[i].where);
2048 CleanDollarFactors(Dollars+i);
2050 R_FREE(AP.DollarList.lijst);
2052 for ( i=0; i<AP.PreVarList.num; ++i ) {
2053 R_FREE(PreVar[i].name);
2055 R_FREE(AP.PreVarList.lijst);
2057 for ( i=0; i<AP.LoopList.num; ++i ) {
2058 R_FREE(DoLoops[i].p.buffer);
2059 if ( DoLoops[i].dollarname ) {
2060 R_FREE(DoLoops[i].dollarname);
2063 R_FREE(AP.LoopList.lijst);
2065 for ( i=0; i<AP.ProcList.num; ++i ) {
2066 R_FREE(Procedures[i].p.buffer);
2067 R_FREE(Procedures[i].name);
2069 R_FREE(AP.ProcList.lijst);
2071 for ( i=1; i<=AP.PreSwitchLevel; ++i ) {
2072 R_FREE(AP.PreSwitchStrings[i]);
2074 R_FREE(AP.PreSwitchStrings);
2075 R_FREE(AP.preStart);
2076 R_FREE(AP.procedureExtension);
2077 R_FREE(AP.cprocedureExtension);
2078 R_FREE(AP.PreIfStack);
2079 R_FREE(AP.PreSwitchModes);
2080 R_FREE(AP.PreTypes);
2087 AP = *((
struct P_const*)p); p = (
unsigned char*)p +
sizeof(
struct P_const);
2089 AP.PreVarLock = dummylock;
2092 R_COPY_LIST(AP.DollarList);
2093 for ( i=0; i<AP.DollarList.num; ++i ) {
2095 size = d->size *
sizeof(WORD);
2096 if ( size && d->where && d->where != oldAMdollarzero ) {
2097 R_COPY_B(d->where, size,
void*);
2100 d->pthreadslockread = dummylock;
2101 d->pthreadslockwrite = dummylock;
2103 if ( d->nfactors > 1 ) {
2105 for ( j = 0; j < d->nfactors; j++ ) {
2106 if ( d->factors[j].size > 0 ) {
2107 R_COPY_B(d->factors[i].where,
sizeof(WORD)*(d->factors[j].size+1),WORD*);
2112 AP.DollarList.message =
"$-variable";
2114 R_COPY_LIST(AP.PreVarList);
2115 for ( i=0; i<AP.PreVarList.num; ++i ) {
2116 R_SET(size,
size_t);
2117 org = PreVar[i].name;
2118 R_COPY_B(PreVar[i].name, size, UBYTE*);
2119 ofs = PreVar[i].name - org;
2120 if ( PreVar[i].value ) PreVar[i].value += ofs;
2121 if ( PreVar[i].argnames ) PreVar[i].argnames += ofs;
2123 AP.PreVarList.message =
"PreVariable";
2125 R_COPY_LIST(AP.LoopList);
2126 for ( i=0; i<AP.LoopList.num; ++i ) {
2127 org = DoLoops[i].p.buffer;
2128 R_COPY_B(DoLoops[i].p.buffer, DoLoops[i].p.size, UBYTE*);
2129 ofs = DoLoops[i].p.buffer - org;
2130 if ( DoLoops[i].name ) DoLoops[i].name += ofs;
2131 if ( DoLoops[i].vars ) DoLoops[i].vars += ofs;
2132 if ( DoLoops[i].contents ) DoLoops[i].contents += ofs;
2133 if ( DoLoops[i].type == ONEEXPRESSION ) {
2134 R_COPY_S(DoLoops[i].dollarname,UBYTE*);
2137 AP.LoopList.message =
"doloop";
2139 R_COPY_LIST(AP.ProcList);
2140 for ( i=0; i<AP.ProcList.num; ++i ) {
2141 if ( Procedures[i].p.size ) {
2142 if ( Procedures[i].loadmode != 1 ) {
2143 R_COPY_B(Procedures[i].p.buffer, Procedures[i].p.size, UBYTE*);
2147 Procedures[i].p.buffer = Procedures[j].p.buffer;
2150 R_COPY_S(Procedures[i].name,UBYTE*);
2152 AP.ProcList.message =
"procedure";
2154 size = (AP.NumPreSwitchStrings+1)*(LONG)
sizeof(UBYTE*);
2155 R_COPY_B(AP.PreSwitchStrings, size, UBYTE**);
2156 for ( i=1; i<=AP.PreSwitchLevel; ++i ) {
2157 R_COPY_S(AP.PreSwitchStrings[i],UBYTE*);
2161 R_COPY_B(AP.preStart, AP.pSize, UBYTE*);
2162 ofs = AP.preStart - org;
2163 if ( AP.preFill ) AP.preFill += ofs;
2164 if ( AP.preStop ) AP.preStop += ofs;
2166 R_COPY_S(AP.procedureExtension,UBYTE*);
2167 R_COPY_S(AP.cprocedureExtension,UBYTE*);
2169 R_COPY_B(AP.PreAssignStack,AP.MaxPreAssignLevel*(LONG)
sizeof(LONG),LONG*);
2170 R_COPY_B(AP.PreIfStack, AP.MaxPreIfLevel*(LONG)
sizeof(
int),
int*);
2171 R_COPY_B(AP.PreSwitchModes, (AP.NumPreSwitchStrings+1)*(LONG)
sizeof(
int),
int*);
2172 R_COPY_B(AP.PreTypes, (AP.MaxPreTypes+1)*(LONG)
sizeof(
int),
int*);
2183 AR.infile = AR.Fscr+1;
2184 AR.outfile = AR.Fscr;
2185 AR.hidefile = AR.Fscr+2;
2188 AR.infile = AR.Fscr;
2189 AR.outfile = AR.Fscr+1;
2190 AR.hidefile = AR.Fscr+2;
2198 namebufout = AR.outfile->name;
2199 namebufhide = AR.hidefile->name;
2200 R_FREE(AR.outfile->PObuffer);
2202 R_FREE(AR.outfile->zsp);
2203 R_FREE(AR.outfile->ziobuffer);
2205 namebufhide = AR.hidefile->name;
2206 R_FREE(AR.hidefile->PObuffer);
2208 R_FREE(AR.hidefile->zsp);
2209 R_FREE(AR.hidefile->ziobuffer);
2217 org = (UBYTE*)AR.outfile->PObuffer;
2218 size = AR.outfile->POfull - AR.outfile->PObuffer;
2219 AR.outfile->PObuffer = (WORD*)Malloc1(AR.outfile->POsize,
"PObuffer");
2221 memcpy(AR.outfile->PObuffer, p, size*
sizeof(WORD));
2222 p = (
unsigned char*)p + size*
sizeof(WORD);
2224 ofs = (UBYTE*)AR.outfile->PObuffer - org;
2225 AR.outfile->POstop = (WORD*)((UBYTE*)AR.outfile->POstop + ofs);
2226 AR.outfile->POfill = (WORD*)((UBYTE*)AR.outfile->POfill + ofs);
2227 AR.outfile->POfull = (WORD*)((UBYTE*)AR.outfile->POfull + ofs);
2228 AR.outfile->name = namebufout;
2230 AR.outfile->wPObuffer = AR.outfile->PObuffer;
2231 AR.outfile->wPOstop = AR.outfile->POstop;
2232 AR.outfile->wPOfill = AR.outfile->POfill;
2233 AR.outfile->wPOfull = AR.outfile->POfull;
2237 AR.outfile->zsp = 0;
2238 AR.outfile->ziobuffer = 0;
2244 if ( AR.outfile->handle >= 0 ) {
2245 if (
CopyFile(sortfile, AR.outfile->name) ) {
2246 MesPrint(
"ERROR: Could not copy old output sort file %s!",sortfile);
2249 AR.outfile->handle = ReOpenFile(AR.outfile->name);
2250 if ( AR.outfile->handle == -1 ) {
2251 MesPrint(
"ERROR: Could not reopen output sort file %s!",AR.outfile->name);
2254 SeekFile(AR.outfile->handle, &AR.outfile->POposition, SEEK_SET);
2259 AR.hidefile->name = namebufhide;
2260 if ( AR.hidefile->PObuffer ) {
2261 org = (UBYTE*)AR.hidefile->PObuffer;
2262 size = AR.hidefile->POfull - AR.hidefile->PObuffer;
2263 AR.hidefile->PObuffer = (WORD*)Malloc1(AR.hidefile->POsize,
"PObuffer");
2265 memcpy(AR.hidefile->PObuffer, p, size*
sizeof(WORD));
2266 p = (
unsigned char*)p + size*
sizeof(WORD);
2268 ofs = (UBYTE*)AR.hidefile->PObuffer - org;
2269 AR.hidefile->POstop = (WORD*)((UBYTE*)AR.hidefile->POstop + ofs);
2270 AR.hidefile->POfill = (WORD*)((UBYTE*)AR.hidefile->POfill + ofs);
2271 AR.hidefile->POfull = (WORD*)((UBYTE*)AR.hidefile->POfull + ofs);
2273 AR.hidefile->wPObuffer = AR.hidefile->PObuffer;
2274 AR.hidefile->wPOstop = AR.hidefile->POstop;
2275 AR.hidefile->wPOfill = AR.hidefile->POfill;
2276 AR.hidefile->wPOfull = AR.hidefile->POfull;
2281 AR.hidefile->zsp = 0;
2282 AR.hidefile->ziobuffer = 0;
2285 if ( AR.hidefile->handle >= 0 ) {
2286 if (
CopyFile(hidefile, AR.hidefile->name) ) {
2287 MesPrint(
"ERROR: Could not copy old hide file %s!",hidefile);
2290 AR.hidefile->handle = ReOpenFile(AR.hidefile->name);
2291 if ( AR.hidefile->handle == -1 ) {
2292 MesPrint(
"ERROR: Could not reopen hide file %s!",AR.hidefile->name);
2295 SeekFile(AR.hidefile->handle, &AR.hidefile->POposition, SEEK_SET);
2300 if ( ISNOTZEROPOS(pos) ) {
2301 CloseFile(AR.StoreData.Handle);
2303 if (
CopyFile(storefile, FG.fname) ) {
2304 MesPrint(
"ERROR: Could not copy old store file %s!",storefile);
2307 AR.StoreData.Handle = (WORD)ReOpenFile(FG.fname);
2308 SeekFile(AR.StoreData.Handle, &AR.StoreData.Position, SEEK_SET);
2312 R_SET(AR.OldTime, LONG);
2313 R_SET(AR.InInBuf, LONG);
2314 R_SET(AR.InHiBuf, LONG);
2316 R_SET(AR.NoCompress,
int);
2317 R_SET(AR.gzipCompress,
int);
2319 R_SET(AR.outtohide,
int);
2321 R_SET(AR.GetFile, WORD);
2322 R_SET(AR.KeptInHold, WORD);
2323 R_SET(AR.BracketOn, WORD);
2324 R_SET(AR.MaxBracket, WORD);
2325 R_SET(AR.CurDum, WORD);
2326 R_SET(AR.DeferFlag, WORD);
2327 R_SET(AR.TePos, WORD);
2328 R_SET(AR.sLevel, WORD);
2329 R_SET(AR.Stage4Name, WORD);
2330 R_SET(AR.GetOneFile, WORD);
2331 R_SET(AR.PolyFun, WORD);
2332 R_SET(AR.PolyFunInv, WORD);
2333 R_SET(AR.PolyFunType, WORD);
2334 R_SET(AR.PolyFunExp, WORD);
2335 R_SET(AR.PolyFunVar, WORD);
2336 R_SET(AR.PolyFunPow, WORD);
2337 R_SET(AR.Eside, WORD);
2338 R_SET(AR.MaxDum, WORD);
2339 R_SET(AR.level, WORD);
2340 R_SET(AR.expchanged, WORD);
2341 R_SET(AR.expflags, WORD);
2342 R_SET(AR.CurExpr, WORD);
2343 R_SET(AR.SortType, WORD);
2344 R_SET(AR.ShortSortCount, WORD);
2349 AR.CompressPointer = AR.CompressBuffer;
2352 for ( j = 0; j < AM.totalnumberofthreads; j++ ) {
2353 R_SET(AB[j]->R.wranfnpair1,
int);
2354 R_SET(AB[j]->R.wranfnpair2,
int);
2355 R_SET(AB[j]->R.wranfcall,
int);
2356 R_SET(AB[j]->R.wranfseed, ULONG);
2357 R_SET(AB[j]->R.wranfia,ULONG*);
2358 if ( AB[j]->R.wranfia ) {
2359 R_COPY_B(AB[j]->R.wranfia,
sizeof(ULONG)*AB[j]->R.wranfnpair2, ULONG*);
2363 R_SET(AR.wranfnpair1,
int);
2364 R_SET(AR.wranfnpair2,
int);
2365 R_SET(AR.wranfcall,
int);
2366 R_SET(AR.wranfseed, ULONG);
2367 R_SET(AR.wranfia,ULONG*);
2369 R_COPY_B(AR.wranfia,
sizeof(ULONG)*AR.wranfnpair2, ULONG*);
2382 l =
sizeof(A.O) - ((UBYTE *)(&(A.O.NumInBrack))-(UBYTE *)(&A.O));
2383 memcpy(&(A.O.NumInBrack), p, l); p = (
unsigned char*)p + l;
2390 if ( A.O.OptimizeResult.codesize > 0 ) {
2391 R_COPY_B(A.O.OptimizeResult.code,A.O.OptimizeResult.codesize*
sizeof(WORD),WORD *);
2393 R_COPY_S(A.O.OptimizeResult.nameofexpr,UBYTE *);
2398 if ( AO.SizeDictionaries > 0 ) {
2401 for ( i = 0; i < AO.NumDictionaries; i++ ) {
2403 AO.Dictionaries[i] = DictFromBytes(p);
2412 R_SET(numtasks,
int);
2413 if(numtasks!=PF.numtasks){
2414 MesPrint(
"%d number of tasks expected instead of %d; use mpirun -np %d",
2415 numtasks,PF.numtasks,numtasks);
2421 R_SET(PF.rhsInParallel,
int);
2422 R_SET(PF.exprbufsize,
int);
2430 for ( j=1; j<AM.totalnumberofthreads; ++j ) {
2432 AB[j]->R.OldTime = -(*((LONG*)p+j));
2434 WriteTimerInfo((LONG*)p,(LONG *)((
unsigned char*)p + i*(LONG)
sizeof(LONG)));
2435 p = (
unsigned char*)p + 2*i*(LONG)
sizeof(LONG);
2438 if ( fclose(fd) )
return(__LINE__);
2440 M_free(buf,
"recovery buffer");
2451 MesPrint(
"done."); fflush(0);