checkpoint.c

Go to the documentation of this file.

/*
    #[ Explanations :
*/
/*
    #] Explanations : 
    #[ License :
 *
 *   Copyright (C) 1984-2026 J.A.M. Vermaseren
 *   When using this file you are requested to refer to the publication
 *   J.A.M.Vermaseren "New features of FORM" math-ph/0010025
 *   This is considered a matter of courtesy as the development was paid
 *   for by FOM the Dutch physics granting agency and we would like to
 *   be able to track its scientific use to convince FOM of its value
 *   for the community.
 *
 *   This file is part of FORM.
 *
 *   FORM is free software: you can redistribute it and/or modify it under the
 *   terms of the GNU General Public License as published by the Free Software
 *   Foundation, either version 3 of the License, or (at your option) any later
 *   version.
 *
 *   FORM is distributed in the hope that it will be useful, but WITHOUT ANY
 *   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 *   FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 *   details.
 *
 *   You should have received a copy of the GNU General Public License along
 *   with FORM.  If not, see <http://www.gnu.org/licenses/>.
 */
/*
    #] License : 
    #[ Includes :
*/
 
#include "form3.h"
 
#include <errno.h>
 
/*
#define PRINTDEBUG
*/
 
/*
#define PRINTTIMEMARKS
*/
 
/*
    #] Includes : 
    #[ filenames and system commands :
*/
 
#ifdef WITHMPI
#define BASENAME_FMT "%c%04dFORMrecv"
static char BaseName[] = BASENAME_FMT;
#else
static char *BaseName = "FORMrecv";
#endif
static char *recoveryfile = 0;
static char *intermedfile = 0;
static char *sortfile = 0;
static char *hidefile = 0;
static char *storefile = 0;
 
static int done_snapshot = 0;
 
#ifdef WITHMPI
static int PF_fmt_pos;
 
static const char *PF_recoveryfile(char prefix, int id, int intermed)
{
    /*
     * Assume that InitRecovery() has been already called, namely
     * recoveryfile, intermedfile and PF_fmt_pos are already initialized.
     */
    static char *tmp_recovery = NULL;
    static char *tmp_intermed  = NULL;
    char *tmp, c;
    if ( tmp_recovery == NULL ) {
        if ( PF.numtasks > 9999 ) {  /* see BASENAME_FMT */
            MesPrint("Checkpoint: too many number of processors.");
            Terminate(-1);
        }
        tmp_recovery = (char *)Malloc1(strlen(recoveryfile) + strlen(intermedfile) + 2, "PF_recoveryfile");
        tmp_intermed = tmp_recovery + strlen(recoveryfile) + 1;
        strcpy(tmp_recovery, recoveryfile);
        strcpy(tmp_intermed, intermedfile);
    }
    tmp = intermed ? tmp_intermed : tmp_recovery;
    c = tmp[PF_fmt_pos + 13];  /* The magic number 13 comes from BASENAME_FMT. */
    sprintf(tmp + PF_fmt_pos, BASENAME_FMT, prefix, id);
    tmp[PF_fmt_pos + 13] = c;
    return tmp;
}
#endif
 
/*
    #] filenames and system commands : 
    #[ CheckRecoveryFile :
*/
 
#ifdef WITHMPI
 
static int PF_CheckRecoveryFile()
{
    int i,ret=0;
    FILE *fd;
    /* Check if the recovery file for the master exists. */
    if ( PF.me == MASTER ) {
        if ( (fd = fopen(recoveryfile, "r")) ) {
            fclose(fd);
            PF_BroadcastNumber(1);
        }
        else {
            PF_BroadcastNumber(0);
            return 0;
        }
    }
    else {
        if ( !PF_BroadcastNumber(0) )
            return 0;
    }
    /* Now the main part. */
    if (PF.me == MASTER){
        /*We have to have recovery files for the master and all the slaves:*/
        for(i=1; i<PF.numtasks;i++){
            const char *tmpnam = PF_recoveryfile('m', i, 0);
            if ( (fd = fopen(tmpnam, "r")) )
                fclose(fd);
            else
                break;
        }/*for(i=0; i<PF.numtasks;i++)*/
        if(i!=PF.numtasks){/*some files are absent*/
            int j;
            /*Send all slaves failure*/
            for(j=1; j<PF.numtasks;j++){
                ret=PF_SendFile(j, NULL);
                if(ret<0)
                    return(-1);
            }
            if(i==0)
                return(0);/*Ok, no recovery files at all.*/
            /*The master recovery file exists but some slave files are absent*/
            MesPrint("The file %s exists but some of the slave recovery files are absent.",
                            RecoveryFilename());
            return(-1);
        }/*if(i!=PF.numtasks)*/
        /*All the files are here.*/
        /*Send all slaves success and files:*/
        for(i=1; i<PF.numtasks;i++){
            const char *tmpnam = PF_recoveryfile('m', i, 0);
            fd = fopen(tmpnam, "r");
            ret=PF_SendFile(i, fd);/*if fd==NULL, PF_SendFile seds to a slave the failure tag*/
            if(fd == NULL)
                return(-1);
            else
                fclose(fd);
            if(ret<0)
                return(-1);
        }/*for(i=0; i<PF.numtasks;i++)*/
        return(1);      
    }/*if (PF.me == MASTER)*/
    /*Slave:*/
    /*Get the answer from the master:*/
    fd=fopen(recoveryfile,"w");
    if(fd == NULL) {
        MesPrint("Failed to open %s in write mode in process %w", recoveryfile);
        return(-1);
    }
    ret=PF_RecvFile(MASTER,fd);
    if(ret<0)
        return(-1);
    fclose(fd);
    if(ret==0){
        /*Nothing is found by the master*/
        remove(recoveryfile);
        return(0);
    }
    /*Recovery file is successfully transferred*/
    return(1);
}
#endif
 
int CheckRecoveryFile(void)
{
    int ret = 0;
#ifdef WITHMPI
    ret = PF_CheckRecoveryFile();
#else
    FILE *fd;
    if ( (fd = fopen(recoveryfile, "r")) ) {
        fclose(fd);
        ret = 1;
    }
#endif
    if ( ret < 0 ){/*In ParFORM CheckRecoveryFile() may return a fatal error.*/
        MesPrint("Fail checking recovery file");
        Terminate(-1);
    }
    else if  ( ret > 0 ) {
        if ( AC.CheckpointFlag != -1 ) {
            /* recovery file exists but recovery option is not given */
#ifdef WITHMPI
            if ( PF.me == MASTER ) {
#endif
            MesPrint("The recovery file %s exists, but the recovery option -R has not been given!", RecoveryFilename());
            MesPrint("FORM will be terminated to avoid unintentional loss of data.");
            MesPrint("Delete the recovery file manually, if you want to start FORM without recovery.");
#ifdef WITHMPI
            }
            if(PF.me != MASTER)
                remove(RecoveryFilename());
#endif
            Terminate(-1);
        }
    }
    else {
        if ( AC.CheckpointFlag == -1 ) {
            /* recovery option given but recovery file does not exist */
#ifdef WITHMPI
            if ( PF.me == MASTER )
#endif
            MesPrint("Option -R for recovery has been given, but the recovery file %s does not exist!", RecoveryFilename());
            Terminate(-1);
        }
    }
    return(ret);
}
 
/*
    #] CheckRecoveryFile : 
    #[ DeleteRecoveryFile :
*/
 
void DeleteRecoveryFile(void)
{
    if ( done_snapshot ) {
        remove(recoveryfile);
#ifdef WITHMPI
        if( PF.me == MASTER){
            int i;
            for(i=1; i<PF.numtasks;i++){
                const char *tmpnam = PF_recoveryfile('m', i, 0);
                remove(tmpnam);
            }/*for(i=1; i<PF.numtasks;i++)*/
            remove(storefile);
            remove(sortfile);
            remove(hidefile);
        }/*if( PF.me == MASTER)*/
#else
        remove(storefile);
        remove(sortfile);
        remove(hidefile);
#endif
    }
}
 
/*
    #] DeleteRecoveryFile : 
    #[ RecoveryFilename :
*/
 
char *RecoveryFilename(void)
{
    return(recoveryfile);
}
 
/*
    #] RecoveryFilename : 
    #[ InitRecovery :
*/
 
static char *InitName(char *str, char *ext)
{
    char *s, *d = str;
    if ( AM.TempDir ) {
        s = (char*)AM.TempDir;
        while ( *s ) { *d++ = *s++; }
        *d++ = SEPARATOR;
    }
    s = BaseName;
    while ( *s ) { *d++ = *s++; }
    *d++ = '.';
    s = ext;
    while ( *s ) { *d++ = *s++; }
    *d++ = 0;
    return d;
}
 
void InitRecovery(void)
{
    int lenpath = AM.TempDir ? strlen((char*)AM.TempDir)+1 : 0;
#ifdef WITHMPI
    sprintf(BaseName,BASENAME_FMT,(PF.me == MASTER)?'m':'s',PF.me);
    /*Now BaseName has a form ?XXXXFORMrecv where ? == 'm' for master and 's' for slave,
        XXXX is a zero - padded PF.me*/
    PF_fmt_pos = lenpath;
#endif  
    recoveryfile = (char*)Malloc1(5*(lenpath+strlen(BaseName)+4+1),"InitRecovery");
    intermedfile = InitName(recoveryfile, "tmp");
    sortfile     = InitName(intermedfile, "XXX");
    hidefile     = InitName(sortfile, "out");
    storefile    = InitName(hidefile, "hid");
                   InitName(storefile, "str");
}
 
/*
    #] InitRecovery : 
    #[ Debugging :
*/
 
#ifdef PRINTDEBUG
 
void print_BYTE(void *p)
{
    UBYTE h = (UBYTE)(*((UBYTE*)p) >> 4);
    UBYTE l = (UBYTE)(*((UBYTE*)p) & 0x0F);
    if ( h > 9 ) h += 55; else h += 48;
    if ( l > 9 ) l += 55; else l += 48;
    printf("%c%c ", h, l);
}
 
static void print_STR(UBYTE *p)
{
    if ( p ) {
        MesPrint("%s", (char*)p);
    }
    else {
        MesPrint("NULL");
    }
}
 
static void print_WORDB(WORD *buf, WORD *top)
{
    LONG size = top-buf;
    int i;
    while ( size > 0 ) {
        if ( size > MAXPOSITIVE ) i = MAXPOSITIVE;
        else i = size;
        size -= i;
        MesPrint("%a",i,buf);
        buf += i;
    }
}
 
static void print_VOIDP(void *p, size_t size)
{
    int i;
    if ( p ) {
        while ( size > 0 ) {
            if ( size > MAXPOSITIVE ) i = MAXPOSITIVE;
            else i = size;
            size -= i;
            MesPrint("%b",i,(UBYTE *)p);
            p = ((UBYTE *)p)+i;
        }
    }
    else {
        MesPrint("NULL");
    }
}
 
static void print_CHARS(UBYTE *p, size_t size)
{
    int i;
    while ( size > 0 ) {
        if ( size > MAXPOSITIVE ) i = MAXPOSITIVE;
        else i = size;
        size -= i;
        MesPrint("%C",i,(char *)p);
        p += i;
    }
}
 
static void print_WORDV(WORD *p, size_t size)
{
    int i;
    if ( p ) {
        while ( size > 0 ) {
            if ( size > MAXPOSITIVE ) i = MAXPOSITIVE;
            else i = size;
            size -= i;
            MesPrint("%a",i,p);
            p += i;
        }
    }
    else {
        MesPrint("NULL");
    }
}
 
static void print_INTV(int *p, size_t size)
{
    int iarray[8];
    WORD i = 0;
    if ( p ) {
        while ( size > 0 ) {
            if ( i >= 8 ) {
                MesPrint("%I",i,iarray);
                i = 0;
            }
            iarray[i++] = *p++;
            size--;
        }
        if ( i > 0 ) MesPrint("%I",i,iarray);
    }
    else {
        MesPrint("NULL");
    }
}
 
static void print_LONGV(LONG *p, size_t size)
{
    LONG larray[8];
    WORD i = 0;
    if ( p ) {
        while ( size > 0 ) {
            if ( i >= 8 ) {
                MesPrint("%I",i,larray);
                i = 0;
            }
            larray[i++] = *p++;
            size--;
        }
        if ( i > 0 ) MesPrint("%I",i,larray);
    }
    else {
        MesPrint("NULL");
    }
}
 
static void print_PRELOAD(PRELOAD *l)
{
    if ( l->size ) {
        print_CHARS(l->buffer, l->size);
    }
    MesPrint("%ld", l->size);
}
 
static void print_PREVAR(PREVAR *l)
{
    MesPrint("%s", l->name);
    print_STR(l->value);
    if ( l->nargs ) print_STR(l->argnames);
    MesPrint("%d", l->nargs);
    MesPrint("%d", l->wildarg);
}
 
static void print_DOLLARS(DOLLARS l)
{
    print_VOIDP(l->where, l->size);
    MesPrint("%ld", l->size);
    MesPrint("%ld", l->name);
    MesPrint("%s", AC.dollarnames->namebuffer+l->name);
    MesPrint("%d", l->type);
    MesPrint("%d", l->node);
    MesPrint("%d", l->index);
    MesPrint("%d", l->zero);
    MesPrint("%d", l->numdummies);
    MesPrint("%d", l->nfactors);
}
 
static void print_LIST(LIST *l)
{
    print_VOIDP(l->lijst, l->size);
    MesPrint("%s", l->message);
    MesPrint("%d", l->num);
    MesPrint("%d", l->maxnum);
    MesPrint("%d", l->size);
    MesPrint("%d", l->numglobal);
    MesPrint("%d", l->numtemp);
    MesPrint("%d", l->numclear);
}
 
static void print_DOLOOP(DOLOOP *l)
{
    print_PRELOAD(&(l->p));
    print_STR(l->name);
    if ( l->type != NUMERICALLOOP ) {
        print_STR(l->vars);
    }
    print_STR(l->contents);
    if ( l->type != LISTEDLOOP && l->type != NUMERICALLOOP ) {
        print_STR(l->dollarname);
    }
    MesPrint("%l", l->startlinenumber);
    MesPrint("%l", l->firstnum);
    MesPrint("%l", l->lastnum);
    MesPrint("%l", l->incnum);
    MesPrint("%d", l->type);
    MesPrint("%d", l->NoShowInput);
    MesPrint("%d", l->errorsinloop);
    MesPrint("%d", l->firstloopcall);
}
 
static void print_PROCEDURE(PROCEDURE *l)
{
    if ( l->loadmode != 1 ) {
        print_PRELOAD(&(l->p));
    }
    print_STR(l->name);
    MesPrint("%d", l->loadmode);
}
 
static void print_NAMETREE(NAMETREE *t)
{
    int i;
    for ( i=0; i<t->nodefill; ++i ) {
        MesPrint("%l %d %d %d %d %d %d\n", t->namenode[i].name,
             t->namenode[i].parent, t->namenode[i].left, t->namenode[i].right,
             t->namenode[i].balance, t->namenode[i].type, t->namenode[i].number );
    }
    print_CHARS(t->namebuffer, t->namefill);
    MesPrint("%l", t->namesize);
    MesPrint("%l", t->namefill);
    MesPrint("%l", t->nodesize);
    MesPrint("%l", t->nodefill);
    MesPrint("%l", t->oldnamefill);
    MesPrint("%l", t->oldnodefill);
    MesPrint("%l", t->globalnamefill);
    MesPrint("%l", t->globalnodefill);
    MesPrint("%l", t->clearnamefill);
    MesPrint("%l", t->clearnodefill);
    MesPrint("%d", t->headnode);
}
 
void print_CBUF(CBUF *c)
{
    int i;
    print_WORDV(c->Buffer, c->BufferSize);
    /*
    MesPrint("%x", c->Buffer);
    MesPrint("%x", c->lhs);
    MesPrint("%x", c->rhs);
    */
    for ( i=0; i<c->numlhs; ++i ) {
        if ( c->lhs[i]) MesPrint("%d", *(c->lhs[i]));
    }
    for ( i=0; i<c->numrhs; ++i ) {
        if ( c->rhs[i]) MesPrint("%d", *(c->rhs[i]));
    }
    MesPrint("%l", *c->CanCommu);
    MesPrint("%l", *c->NumTerms);
    MesPrint("%d", *c->numdum);
    for ( i=0; i<c->MaxTreeSize; ++i ) {
        MesPrint("%d %d %d %d %d", c->boomlijst[i].parent, c->boomlijst[i].left, c->boomlijst[i].right,
                c->boomlijst[i].value, c->boomlijst[i].blnce);
    }
}
 
static void print_STREAM(STREAM *t)
{
    print_CHARS(t->buffer, t->inbuffer);
    MesPrint("%l", (LONG)(t->pointer-t->buffer));
    print_STR(t->FoldName);
    print_STR(t->name);
    if ( t->type == PREVARSTREAM || t->type == DOLLARSTREAM ) {
        print_STR(t->pname);
    }
    MesPrint("%l", (LONG)t->fileposition);
    MesPrint("%l", (LONG)t->linenumber);
    MesPrint("%l", (LONG)t->prevline);
    MesPrint("%l", t->buffersize);
    MesPrint("%l", t->bufferposition);
    MesPrint("%l", t->inbuffer);
    MesPrint("%d", t->previous);
    MesPrint("%d", t->handle);
    switch ( t->type ) {
        case FILESTREAM: MesPrint("%d == FILESTREAM", t->type); break;
        case PREVARSTREAM: MesPrint("%d == PREVARSTREAM", t->type); break;
        case PREREADSTREAM: MesPrint("%d == PREREADSTREAM", t->type); break;
        case PIPESTREAM: MesPrint("%d == PIPESTREAM", t->type); break;
        case PRECALCSTREAM: MesPrint("%d == PRECALCSTREAM", t->type); break;
        case DOLLARSTREAM: MesPrint("%d == DOLLARSTREAM", t->type); break;
        case PREREADSTREAM2: MesPrint("%d == PREREADSTREAM2", t->type); break;
        case EXTERNALCHANNELSTREAM: MesPrint("%d == EXTERNALCHANNELSTREAM", t->type); break;
        case PREREADSTREAM3: MesPrint("%d == PREREADSTREAM3", t->type); break;
        default: MesPrint("%d == UNKNOWN", t->type);
    }
}
 
static void print_M()
{
    MesPrint("%%%% M_const");
    MesPrint("%d", *AM.gcmod);
    MesPrint("%d", *AM.gpowmod);
    print_STR(AM.TempDir);
    print_STR(AM.TempSortDir);
    print_STR(AM.IncDir);
    print_STR(AM.InputFileName);
    print_STR(AM.LogFileName);
    print_STR(AM.OutBuffer);
    print_STR(AM.Path);
    print_STR(AM.SetupDir);
    print_STR(AM.SetupFile);
    MesPrint("--MARK  1");
    MesPrint("%l", (LONG)BASEPOSITION(AM.zeropos));
#ifdef WITHPTHREADS
    MesPrint("%l", AM.ThreadScratSize);
    MesPrint("%l", AM.ThreadScratOutSize);
#endif
    MesPrint("%l", AM.MaxTer);
    MesPrint("%l", AM.CompressSize);
    MesPrint("%l", AM.ScratSize);
    MesPrint("%l", AM.SizeStoreCache);
    MesPrint("%l", AM.MaxStreamSize);
    MesPrint("%l", AM.SIOsize);
    MesPrint("%l", AM.SLargeSize);
    MesPrint("%l", AM.SSmallEsize);
    MesPrint("%l", AM.SSmallSize);
    MesPrint("--MARK  2");
    MesPrint("%l", AM.STermsInSmall);
    MesPrint("%l", AM.MaxBracketBufferSize);
    MesPrint("%l", AM.hProcessBucketSize);
    MesPrint("%l", AM.gProcessBucketSize);
    MesPrint("%l", AM.shmWinSize);
    MesPrint("%l", AM.OldChildTime);
    MesPrint("%l", AM.OldSecTime);
    MesPrint("%l", AM.OldMilliTime);
    MesPrint("%l", AM.WorkSize);
    MesPrint("%l", AM.gThreadBucketSize);
    MesPrint("--MARK  3");
    MesPrint("%l", AM.ggThreadBucketSize);
    MesPrint("%d", AM.FileOnlyFlag);
    MesPrint("%d", AM.Interact);
    MesPrint("%d", AM.MaxParLevel);
    MesPrint("%d", AM.OutBufSize);
    MesPrint("%d", AM.SMaxFpatches);
    MesPrint("%d", AM.SMaxPatches);
    MesPrint("%d", AM.StdOut);
    MesPrint("%d", AM.ginsidefirst);
    MesPrint("%d", AM.gDefDim);
    MesPrint("%d", AM.gDefDim4);
    MesPrint("--MARK  4");
    MesPrint("%d", AM.NumFixedSets);
    MesPrint("%d", AM.NumFixedFunctions);
    MesPrint("%d", AM.rbufnum);
    MesPrint("%d", AM.dbufnum);
    MesPrint("%d", AM.SkipClears);
    MesPrint("%d", AM.gfunpowers);
    MesPrint("%d", AM.gStatsFlag);
    MesPrint("%d", AM.gNamesFlag);
    MesPrint("%d", AM.gCodesFlag);
    MesPrint("%d", AM.gTokensWriteFlag);
    MesPrint("%d", AM.gSortType);
    MesPrint("%d", AM.gproperorderflag);
    MesPrint("--MARK  5");
    MesPrint("%d", AM.hparallelflag);
    MesPrint("%d", AM.gparallelflag);
    MesPrint("%d", AM.totalnumberofthreads);
    MesPrint("%d", AM.gSizeCommuteInSet);
    MesPrint("%d", AM.gThreadStats);
    MesPrint("%d", AM.ggThreadStats);
    MesPrint("%d", AM.gFinalStats);
    MesPrint("%d", AM.ggFinalStats);
    MesPrint("%d", AM.gThreadsFlag);
    MesPrint("%d", AM.ggThreadsFlag);
    MesPrint("%d", AM.gThreadBalancing);
    MesPrint("%d", AM.ggThreadBalancing);
    MesPrint("%d", AM.gThreadSortFileSynch);
    MesPrint("%d", AM.ggThreadSortFileSynch);
    MesPrint("%d", AM.gProcessStats);
    MesPrint("%d", AM.ggProcessStats);
    MesPrint("%d", AM.gOldParallelStats);
    MesPrint("%d", AM.ggOldParallelStats);
    MesPrint("%d", AM.gWTimeStatsFlag);
    MesPrint("%d", AM.ggWTimeStatsFlag);
    MesPrint("%d", AM.maxFlevels);
    MesPrint("--MARK  6");
    MesPrint("%d", AM.resetTimeOnClear);
    MesPrint("%d", AM.gcNumDollars);
    MesPrint("%d", AM.MultiRun);
    MesPrint("%d", AM.gNoSpacesInNumbers);
    MesPrint("%d", AM.ggNoSpacesInNumbers);
    MesPrint("%d", AM.MaxTal);
    MesPrint("%d", AM.IndDum);
    MesPrint("%d", AM.DumInd);
    MesPrint("%d", AM.WilInd);
    MesPrint("%d", AM.gncmod);
    MesPrint("%d", AM.gnpowmod);
    MesPrint("%d", AM.gmodmode);
    MesPrint("--MARK  7");
    MesPrint("%d", AM.gUnitTrace);
    MesPrint("%d", AM.gOutputMode);
    MesPrint("%d", AM.gCnumpows);
    MesPrint("%d", AM.gOutputSpaces);
    MesPrint("%d", AM.gOutNumberType);
    MesPrint("%d %d %d %d", AM.gUniTrace[0], AM.gUniTrace[1], AM.gUniTrace[2], AM.gUniTrace[3]);
    MesPrint("%d", AM.MaxWildcards);
    MesPrint("%d", AM.mTraceDum);
    MesPrint("%d", AM.OffsetIndex);
    MesPrint("%d", AM.OffsetVector);
    MesPrint("%d", AM.RepMax);
    MesPrint("%d", AM.LogType);
    MesPrint("%d", AM.ggStatsFlag);
    MesPrint("%d", AM.gLineLength);
    MesPrint("%d", AM.qError);
    MesPrint("--MARK  8");
    MesPrint("%d", AM.FortranCont);
    MesPrint("%d", AM.HoldFlag);
    MesPrint("%d %d %d %d %d", AM.Ordering[0], AM.Ordering[1], AM.Ordering[2], AM.Ordering[3], AM.Ordering[4]);
    MesPrint("%d %d %d %d %d", AM.Ordering[5], AM.Ordering[6], AM.Ordering[7], AM.Ordering[8], AM.Ordering[9]);
    MesPrint("%d %d %d %d %d", AM.Ordering[10], AM.Ordering[11], AM.Ordering[12], AM.Ordering[13], AM.Ordering[14]);
    MesPrint("%d", AM.silent);
    MesPrint("%d", AM.tracebackflag);
    MesPrint("%d", AM.expnum);
    MesPrint("%d", AM.denomnum);
    MesPrint("%d", AM.facnum);
    MesPrint("%d", AM.invfacnum);
    MesPrint("%d", AM.sumnum);
    MesPrint("%d", AM.sumpnum);
    MesPrint("--MARK  9");
    MesPrint("%d", AM.OldOrderFlag);
    MesPrint("%d", AM.termfunnum);
    MesPrint("%d", AM.matchfunnum);
    MesPrint("%d", AM.countfunnum);
    MesPrint("%d", AM.gPolyFun);
    MesPrint("%d", AM.gPolyFunInv);
    MesPrint("%d", AM.gPolyFunType);
    MesPrint("%d", AM.gPolyFunExp);
    MesPrint("%d", AM.gPolyFunVar);
    MesPrint("%d", AM.gPolyFunPow);
    MesPrint("--MARK 10");
    MesPrint("%d", AM.dollarzero);
    MesPrint("%d", AM.atstartup);
    MesPrint("%d", AM.exitflag);
    MesPrint("%d", AM.NumStoreCaches);
    MesPrint("%d", AM.gIndentSpace);
    MesPrint("%d", AM.ggIndentSpace);
    MesPrint("%d", AM.gShortStatsMax);
    MesPrint("%d", AM.ggShortStatsMax);
    MesPrint("--MARK 11");
    MesPrint("%d", AM.FromStdin);
    MesPrint("%d", AM.IgnoreDeprecation);
    MesPrint("%%%% END M_const");
/*  fflush(0); */
}
 
static void print_P()
{
    int i;
    MesPrint("%%%% P_const");
    print_LIST(&AP.DollarList);
    for ( i=0; i<AP.DollarList.num; ++i ) {
        print_DOLLARS(&(Dollars[i]));
    }
    MesPrint("--MARK  1");
    print_LIST(&AP.PreVarList);
    for ( i=0; i<AP.PreVarList.num; ++i ) {
        print_PREVAR(&(PreVar[i]));
    }
    MesPrint("--MARK  2");
    print_LIST(&AP.LoopList);
    for ( i=0; i<AP.LoopList.num; ++i ) {
        print_DOLOOP(&(DoLoops[i]));
    }
    MesPrint("--MARK  3");
    print_LIST(&AP.ProcList);
    for ( i=0; i<AP.ProcList.num; ++i ) {
        print_PROCEDURE(&(Procedures[i]));
    }
    MesPrint("--MARK  4");
    for ( i=0; i<=AP.PreSwitchLevel; ++i ) {
        print_STR(AP.PreSwitchStrings[i]);
    }
    MesPrint("%l", AP.preStop-AP.preStart);
    if ( AP.preFill ) MesPrint("%l", AP.preFill-AP.preStart);
    print_CHARS(AP.preStart, AP.pSize);
    MesPrint("%s", AP.procedureExtension);
    MesPrint("%s", AP.cprocedureExtension);
    print_INTV(AP.PreIfStack, AP.MaxPreIfLevel);
    print_INTV(AP.PreSwitchModes, AP.NumPreSwitchStrings+1);
    print_INTV(AP.PreTypes, AP.NumPreTypes+1);
    MesPrint("%d", AP.PreAssignFlag);
    MesPrint("--MARK  5");
    MesPrint("%d", AP.PreContinuation);
    MesPrint("%l", AP.InOutBuf);
    MesPrint("%l", AP.pSize);
    MesPrint("%d", AP.PreproFlag);
    MesPrint("%d", AP.iBufError);
    MesPrint("%d", AP.PreOut);
    MesPrint("%d", AP.PreSwitchLevel);
    MesPrint("%d", AP.NumPreSwitchStrings);
    MesPrint("%d", AP.MaxPreTypes);
    MesPrint("--MARK  6");
    MesPrint("%d", AP.NumPreTypes);
    MesPrint("%d", AP.DelayPrevar);
    MesPrint("%d", AP.AllowDelay);
    MesPrint("%d", AP.lhdollarerror);
    MesPrint("%d", AP.eat);
    MesPrint("%d", AP.gNumPre);
    MesPrint("%d", AP.PreDebug);
    MesPrint("--MARK  7");
    MesPrint("%d", AP.DebugFlag);
    MesPrint("%d", AP.preError);
    MesPrint("%C", 1, &(AP.ComChar));
    MesPrint("%C", 1, &(AP.cComChar));
    MesPrint("%%%% END P_const");
/*  fflush(0); */
}
 
static void print_C()
{
    int i;
    UBYTE buf[40], *t;
    MesPrint("%%%% C_const");
    for ( i=0; i<32; ++i ) {
        t = buf;
        t = NumCopy((WORD)(AC.separators[i].bit_7),t);
        t = NumCopy((WORD)(AC.separators[i].bit_6),t);
        t = NumCopy((WORD)(AC.separators[i].bit_5),t);
        t = NumCopy((WORD)(AC.separators[i].bit_4),t);
        t = NumCopy((WORD)(AC.separators[i].bit_3),t);
        t = NumCopy((WORD)(AC.separators[i].bit_2),t);
        t = NumCopy((WORD)(AC.separators[i].bit_1),t);
        t = NumCopy((WORD)(AC.separators[i].bit_0),t);
        MesPrint("%s ",buf);
    }
    print_NAMETREE(AC.dollarnames);
    print_NAMETREE(AC.exprnames);
    print_NAMETREE(AC.varnames);
    MesPrint("--MARK  1");
    print_LIST(&AC.ChannelList);
    for ( i=0; i<AC.ChannelList.num; ++i ) {
        MesPrint("%s %d", channels[i].name, channels[i].handle);
    }
    MesPrint("--MARK  2");
    print_LIST(&AC.DubiousList);
    MesPrint("--MARK  3");
    print_LIST(&AC.FunctionList);
    for ( i=0; i<AC.FunctionList.num; ++i ) {
        if ( functions[i].tabl ) {
 
        }
        MesPrint("%l", functions[i].symminfo);
        MesPrint("%l", functions[i].name);
        MesPrint("%d", functions[i].namesize);
    }
    MesPrint("--MARK  4");
    print_LIST(&AC.ExpressionList);
    print_LIST(&AC.IndexList);
    print_LIST(&AC.SetElementList);
    print_LIST(&AC.SetList);
    MesPrint("--MARK  5");
    print_LIST(&AC.SymbolList);
    print_LIST(&AC.VectorList);
    print_LIST(&AC.PotModDolList);
    print_LIST(&AC.ModOptDolList);
    print_LIST(&AC.TableBaseList);
 
/*
    print_LIST(&AC.cbufList);
    for ( i=0; i<AC.cbufList.num; ++i ) {
        MesPrint("cbufList.num == %d", i);
        print_CBUF(cbuf+i);
    }
    MesPrint("%d", AC.cbufnum);
*/
    MesPrint("--MARK  6");
 
    print_LIST(&AC.AutoSymbolList);
    print_LIST(&AC.AutoIndexList);
    print_LIST(&AC.AutoVectorList);
    print_LIST(&AC.AutoFunctionList);
 
    print_NAMETREE(AC.autonames);
    MesPrint("--MARK  7");
 
    print_LIST(AC.Symbols);
    print_LIST(AC.Indices);
    print_LIST(AC.Vectors);
    print_LIST(AC.Functions);
    MesPrint("--MARK  8");
 
    print_NAMETREE(*AC.activenames);
    
    MesPrint("--MARK  9");
 
    MesPrint("%d", AC.AutoDeclareFlag);
 
    for ( i=0; i<AC.NumStreams; ++i ) {
        MesPrint("Stream %d\n", i);
        print_STREAM(AC.Streams+i);
    }
    print_STREAM(AC.CurrentStream);
    MesPrint("--MARK 10");
 
    print_LONGV(AC.termstack, AC.maxtermlevel);
    print_LONGV(AC.termsortstack, AC.maxtermlevel);
    print_VOIDP(AC.cmod, AM.MaxTal*4*sizeof(UWORD));
    print_WORDV((WORD *)(AC.cmod), 1);
    print_WORDV((WORD *)(AC.powmod), 1);
    print_WORDV((WORD*)AC.modpowers, 1);
    print_WORDV((WORD*)AC.halfmod, 1);
    MesPrint("--MARK 10-2");
    /*
    print_WORDV(AC.ProtoType, AC.ProtoType[1]);
    print_WORDV(AC.WildC, 1);
    */
 
    MesPrint("--MARK 11");
    /* IfHeap ... Labels */
 
    print_CHARS((UBYTE*)AC.tokens, AC.toptokens-AC.tokens);
    MesPrint("%l", AC.endoftokens-AC.tokens);
    print_WORDV(AC.tokenarglevel, AM.MaxParLevel);
    print_WORDV((WORD*)AC.modinverses, ABS(AC.ncmod));
#ifdef WITHPTHREADS
    print_LONGV(AC.inputnumbers, AC.sizepfirstnum+AC.sizepfirstnum*sizeof(WORD)/sizeof(LONG));
    print_WORDV(AC.pfirstnum, 1);
#endif
    MesPrint("--MARK 12");
    print_LONGV(AC.argstack, MAXNEST);
    print_LONGV(AC.insidestack, MAXNEST);
    print_LONGV(AC.inexprstack, MAXNEST);
    MesPrint("%l", AC.iBufferSize);
    MesPrint("%l", AC.TransEname);
    MesPrint("%l", AC.ProcessBucketSize);
    MesPrint("%l", AC.mProcessBucketSize);
    MesPrint("%l", AC.CModule);
    MesPrint("%l", AC.ThreadBucketSize);
    MesPrint("%d", AC.NoShowInput);
    MesPrint("%d", AC.ShortStats);
    MesPrint("%d", AC.compiletype);
    MesPrint("%d", AC.firstconstindex);
    MesPrint("%d", AC.insidefirst);
    MesPrint("%d", AC.minsidefirst);
    MesPrint("%d", AC.wildflag);
    MesPrint("%d", AC.NumLabels);
    MesPrint("%d", AC.MaxLabels);
    MesPrint("--MARK 13");
    MesPrint("%d", AC.lDefDim);
    MesPrint("%d", AC.lDefDim4);
    MesPrint("%d", AC.NumWildcardNames);
    MesPrint("%d", AC.WildcardBufferSize);
    MesPrint("%d", AC.MaxIf);
    MesPrint("%d", AC.NumStreams);
    MesPrint("%d", AC.MaxNumStreams);
    MesPrint("%d", AC.firstctypemessage);
    MesPrint("%d", AC.tablecheck);
    MesPrint("%d", AC.idoption);
    MesPrint("%d", AC.BottomLevel);
    MesPrint("%d", AC.CompileLevel);
    MesPrint("%d", AC.TokensWriteFlag);
    MesPrint("%d", AC.UnsureDollarMode);
    MesPrint("%d", AC.outsidefun);
    MesPrint("%d", AC.funpowers);
    MesPrint("--MARK 14");
    MesPrint("%d", AC.WarnFlag);
    MesPrint("%d", AC.StatsFlag);
    MesPrint("%d", AC.NamesFlag);
    MesPrint("%d", AC.CodesFlag);
    MesPrint("%d", AC.TokensWriteFlag);
    MesPrint("%d", AC.SetupFlag);
    MesPrint("%d", AC.SortType);
    MesPrint("%d", AC.lSortType);
    MesPrint("%d", AC.ThreadStats);
    MesPrint("%d", AC.FinalStats);
    MesPrint("%d", AC.ThreadsFlag);
    MesPrint("%d", AC.ThreadBalancing);
    MesPrint("%d", AC.ThreadSortFileSynch);
    MesPrint("%d", AC.ProcessStats);
    MesPrint("%d", AC.OldParallelStats);
    MesPrint("%d", AC.WTimeStatsFlag);
    MesPrint("%d", AC.BracketNormalize);
    MesPrint("%d", AC.maxtermlevel);
    MesPrint("%d", AC.dumnumflag);
    MesPrint("--MARK 15");
    MesPrint("%d", AC.bracketindexflag);
    MesPrint("%d", AC.parallelflag);
    MesPrint("%d", AC.mparallelflag);
    MesPrint("%d", AC.properorderflag);
    MesPrint("%d", AC.vetofilling);
    MesPrint("%d", AC.tablefilling);
    MesPrint("%d", AC.vetotablebasefill);
    MesPrint("%d", AC.exprfillwarning);
    MesPrint("%d", AC.lhdollarflag);
    MesPrint("%d", AC.NoCompress);
#ifdef WITHPTHREADS
    MesPrint("%d", AC.numpfirstnum);
    MesPrint("%d", AC.sizepfirstnum);
#endif
    MesPrint("%d", AC.RepLevel);
    MesPrint("%d", AC.arglevel);
    MesPrint("%d", AC.insidelevel);
    MesPrint("%d", AC.inexprlevel);
    MesPrint("%d", AC.termlevel);
    MesPrint("--MARK 16");
    print_WORDV(AC.argsumcheck, MAXNEST);
    print_WORDV(AC.insidesumcheck, MAXNEST);
    print_WORDV(AC.inexprsumcheck, MAXNEST);
    MesPrint("%d", AC.MustTestTable);
    MesPrint("%d", AC.DumNum);
    MesPrint("%d", AC.ncmod);
    MesPrint("%d", AC.npowmod);
    MesPrint("%d", AC.modmode);
    MesPrint("%d", AC.nhalfmod);
    MesPrint("%d", AC.DirtPow);
    MesPrint("%d", AC.lUnitTrace);
    MesPrint("%d", AC.NwildC);
    MesPrint("%d", AC.ComDefer);
    MesPrint("%d", AC.CollectFun);
    MesPrint("%d", AC.AltCollectFun);
    MesPrint("--MARK 17");
    MesPrint("%d", AC.OutputMode);
    MesPrint("%d", AC.Cnumpows);
    MesPrint("%d", AC.OutputSpaces);
    MesPrint("%d", AC.OutNumberType);
    print_WORDV(AC.lUniTrace, 4);
    print_WORDV(AC.RepSumCheck, MAXREPEAT);
    MesPrint("%d", AC.DidClean);
    MesPrint("%d", AC.IfLevel);
    MesPrint("%d", AC.WhileLevel);
    print_WORDV(AC.IfSumCheck, (AC.MaxIf+1));
    MesPrint("%d", AC.LogHandle);
    MesPrint("%d", AC.LineLength);
    MesPrint("%d", AC.StoreHandle);
    MesPrint("%d", AC.HideLevel);
    MesPrint("%d", AC.lPolyFun);
    MesPrint("%d", AC.lPolyFunInv);
    MesPrint("%d", AC.lPolyFunType);
    MesPrint("%d", AC.lPolyFunExp);
    MesPrint("%d", AC.lPolyFunVar);
    MesPrint("%d", AC.lPolyFunPow);
    MesPrint("%d", AC.SymChangeFlag);
    MesPrint("%d", AC.CollectPercentage);
    MesPrint("%d", AC.ShortStatsMax);
    MesPrint("--MARK 18");
 
    print_CHARS(AC.Commercial, COMMERCIALSIZE+2);
 
    MesPrint("%", AC.CheckpointFlag);
    MesPrint("%l", AC.CheckpointStamp);
    print_STR((unsigned char*)AC.CheckpointRunAfter);
    print_STR((unsigned char*)AC.CheckpointRunBefore);
    MesPrint("%l", AC.CheckpointInterval);
 
    MesPrint("%%%% END C_const");
/*  fflush(0); */
}
 
static void print_R()
{
    GETIDENTITY
    int i;
    MesPrint("%%%% R_const");
    MesPrint("%l", (LONG)(AR.infile-AR.Fscr));
    MesPrint("%s", AR.infile->name);
    MesPrint("%l", (LONG)(AR.outfile-AR.Fscr));
    MesPrint("%s", AR.outfile->name);
    MesPrint("%l", AR.hidefile-AR.Fscr);
    MesPrint("%s", AR.hidefile->name);
    for ( i=0; i<3; ++i ) {
        MesPrint("FSCR %d", i);
        print_WORDB(AR.Fscr[i].PObuffer, AR.Fscr[i].POfull);
    }
    /* ... */
    MesPrint("%l", AR.OldTime);
    MesPrint("%l", AR.InInBuf);
    MesPrint("%l", AR.InHiBuf);
    MesPrint("%l", AR.pWorkSize);
    MesPrint("%l", AR.lWorkSize);
    MesPrint("%l", AR.posWorkSize);
    MesPrint("%d", AR.NoCompress);
    MesPrint("%d", AR.gzipCompress);
    MesPrint("%d", AR.Cnumlhs);
#ifdef WITHPTHREADS
    MesPrint("%d", AR.exprtodo);
#endif
    MesPrint("%d", AR.GetFile);
    MesPrint("%d", AR.KeptInHold);
    MesPrint("%d", AR.BracketOn);
    MesPrint("%d", AR.MaxBracket);
    MesPrint("%d", AR.CurDum);
    MesPrint("%d", AR.DeferFlag);
    MesPrint("%d", AR.TePos);
    MesPrint("%d", AR.sLevel);
    MesPrint("%d", AR.Stage4Name);
    MesPrint("%d", AR.GetOneFile);
    MesPrint("%d", AR.PolyFun);
    MesPrint("%d", AR.PolyFunInv);
    MesPrint("%d", AR.PolyFunType);
    MesPrint("%d", AR.PolyFunExp);
    MesPrint("%d", AR.PolyFunVar);
    MesPrint("%d", AR.PolyFunPow);
    MesPrint("%d", AR.Eside);
    MesPrint("%d", AR.MaxDum);
    MesPrint("%d", AR.level);
    MesPrint("%d", AR.expchanged);
    MesPrint("%d", AR.expflags);
    MesPrint("%d", AR.CurExpr);
    MesPrint("%d", AR.SortType);
    MesPrint("%d", AR.ShortSortCount);
    MesPrint("%%%% END R_const");
/*  fflush(0); */
}
 
#endif /* ifdef PRINTDEBUG */
 
/*
    #] Debugging : 
    #[ Cached file operation functions :
*/
 
#define CACHED_SNAPSHOT
 
#define CACHE_SIZE 4096
 
#ifdef CACHED_SNAPSHOT
unsigned char cache_buffer[CACHE_SIZE];
size_t cache_fill = 0;
 
size_t fwrite_cached(const void *ptr, size_t size, size_t nmemb, FILE *fd)
{
    size_t fullsize = size*nmemb;
    if ( fullsize+cache_fill >= CACHE_SIZE ) {
        size_t overlap = CACHE_SIZE-cache_fill;
        memcpy(cache_buffer+cache_fill, (unsigned char*)ptr, overlap);
        if ( fwrite(cache_buffer, 1, CACHE_SIZE, fd) != CACHE_SIZE ) return 0;
        fullsize -= overlap;
        if ( fullsize >= CACHE_SIZE ) {
            cache_fill = fullsize % CACHE_SIZE;
            if ( cache_fill ) memcpy(cache_buffer, (unsigned char*)ptr+overlap+fullsize-cache_fill, cache_fill);
            if ( fwrite((unsigned char*)ptr+overlap, 1, fullsize-cache_fill, fd) != fullsize-cache_fill ) return 0;
        }
        else {
            memcpy(cache_buffer, (unsigned char*)ptr+overlap, fullsize);
            cache_fill = fullsize;
        }
    }
    else {
        memcpy(cache_buffer+cache_fill, (unsigned char*)ptr, fullsize);
        cache_fill += fullsize;
    }
    return nmemb;
}
 
size_t flush_cache(FILE *fd)
{
    if ( cache_fill ) {
        size_t retval = fwrite(cache_buffer, 1, cache_fill, fd);
        if ( retval != cache_fill ) {
            cache_fill = 0;
            return 0;
        }
        cache_fill = 0;
    }
    return 1;
}
#else
size_t fwrite_cached(const void *ptr, size_t size, size_t nmemb, FILE *fd)
{
    return fwrite(ptr, size, nmemb, fd);
}
 
size_t flush_cache(FILE *fd)
{
    DUMMYUSE(fd)
    return 1;
}
#endif
 
/*
    #] Cached file operation functions : 
    #[ Helper Macros :
*/
 
/* some helper macros to streamline the code in DoSnapshot() and DoRecovery() */
 
/* freeing memory */
 
#define R_FREE(ARG) \
    if ( ARG ) M_free(ARG, #ARG);
 
#define R_FREE_NAMETREE(ARG) \
    R_FREE(ARG->namenode); \
    R_FREE(ARG->namebuffer); \
    R_FREE(ARG);
 
#define R_FREE_STREAM(ARG) \
    R_FREE(ARG.buffer); \
    R_FREE(ARG.FoldName); \
    R_FREE(ARG.name);
 
/* reading a single variable */
 
#define R_SET(VAR,TYPE) \
    VAR = *((TYPE*)p); p = (unsigned char*)p + sizeof(TYPE);
 
/* general buffer */
 
#define R_COPY_B(VAR,SIZE,CAST) \
    VAR = (CAST)Malloc1(SIZE,#VAR); \
    memcpy(VAR, p, SIZE); p = (unsigned char*)p + SIZE;
 
#define S_WRITE_B(BUF,LEN) \
    if ( fwrite_cached(BUF, 1, LEN, fd) != (size_t)(LEN) ) return(__LINE__);
 
#define S_FLUSH_B \
    if ( flush_cache(fd) != 1 ) return(__LINE__);
 
/* character strings */
 
#define R_COPY_S(VAR,CAST) \
    if ( VAR ) { \
        VAR = (CAST)Malloc1(strlen(p)+1,"R_COPY_S"); \
        strcpy((char*)VAR, p); p = (unsigned char*)p + strlen(p) + 1; \
    }
 
#define S_WRITE_S(STR) \
    if ( STR ) { \
        l = strlen((char*)STR) + 1; \
        if ( fwrite_cached(STR, 1, l, fd) != (size_t)l ) return(__LINE__); \
    }
 
/* LIST */
 
#define R_COPY_LIST(ARG) \
    if ( ARG.maxnum ) { \
        R_COPY_B(ARG.lijst, ARG.size*ARG.maxnum, void*) \
    }
 
#define S_WRITE_LIST(LST) \
    if ( LST.maxnum ) { \
        S_WRITE_B((char*)LST.lijst, LST.maxnum*LST.size) \
    }
 
/* NAMETREE */
 
#define R_COPY_NAMETREE(ARG) \
    R_COPY_B(ARG, sizeof(NAMETREE), NAMETREE*); \
    if ( ARG->namenode ) { \
        R_COPY_B(ARG->namenode, ARG->nodesize*sizeof(NAMENODE), NAMENODE*); \
    } \
    if ( ARG->namebuffer ) { \
        R_COPY_B(ARG->namebuffer, ARG->namesize, UBYTE*); \
    }
 
#define S_WRITE_NAMETREE(ARG) \
    S_WRITE_B(ARG, sizeof(NAMETREE)); \
    if ( ARG->namenode ) { \
        S_WRITE_B(ARG->namenode, ARG->nodesize*sizeof(struct NaMeNode)); \
    } \
    if ( ARG->namebuffer ) { \
        S_WRITE_B(ARG->namebuffer, ARG->namesize); \
    }
 
/* DOLLAR */
 
#define S_WRITE_DOLLAR(ARG) \
    if ( ARG.size && ARG.where && ARG.where != &(AM.dollarzero) ) { \
        S_WRITE_B(ARG.where, ARG.size*sizeof(WORD)) \
    }
 
/* Printing time marks with ANNOUNCE macro */
 
#ifdef PRINTTIMEMARKS
time_t announce_time;
#define ANNOUNCE(str) time(&announce_time); MesPrint("TIMEMARK %s  %s", ctime(&announce_time), #str);
#else
#define ANNOUNCE(str)
#endif
 
/*
    #] Helper Macros : 
    #[ DoRecovery :
*/
 
int DoRecovery(int *moduletype)
{
    GETIDENTITY
    FILE *fd;
    POSITION pos;
    void *buf, *p;
    LONG size, l;
    int i, j;
    UBYTE *org;
    char *namebufout, *namebufhide;
    LONG ofs;
    void *oldAMdollarzero;
    LIST PotModDolListBackup;
    LIST ModOptDolListBackup;
    WORD oldLogHandle;
 
    MesPrint("Recovering ... %"); fflush(0);
 
    if ( !(fd = fopen(recoveryfile, "r")) ) return(__LINE__);
 
    /* load the complete recovery file into a buffer */
    if ( fread(&pos, sizeof(POSITION), 1, fd) != 1 ) return(__LINE__);
    size = BASEPOSITION(pos) - sizeof(POSITION);
    buf = Malloc1(size, "recovery buffer");
    if ( fread(buf, size, 1, fd) != 1 ) return(__LINE__);
 
    /* pointer p will go through the buffer in the following */
    p = buf;
 
    /* read moduletype */
    R_SET(*moduletype, int);
 
    /*#[ AM : */
 
    /* only certain elements will be restored. the rest of AM should have gotten
     * the correct values at startup. */
 
    R_SET(AM.hparallelflag, int);
    R_SET(AM.gparallelflag, int);
    R_SET(AM.gCodesFlag, int);
    R_SET(AM.gNamesFlag, int);
    R_SET(AM.gStatsFlag, int);
    R_SET(AM.gTokensWriteFlag, int);
    R_SET(AM.gNoSpacesInNumbers, int);
    R_SET(AM.gIndentSpace, WORD);
    R_SET(AM.gUnitTrace, WORD);
    R_SET(AM.gDefDim, int);
    R_SET(AM.gDefDim4, int);
    R_SET(AM.gncmod, WORD);
    R_SET(AM.gnpowmod, WORD);
    R_SET(AM.gmodmode, WORD);
    R_SET(AM.gOutputMode, WORD);
    R_SET(AM.gCnumpows, WORD);
    R_SET(AM.gOutputSpaces, WORD);
    R_SET(AM.gOutNumberType, WORD);
    R_SET(AM.gfunpowers, int);
    R_SET(AM.gPolyFun, WORD);
    R_SET(AM.gPolyFunInv, WORD);
    R_SET(AM.gPolyFunType, WORD);
    R_SET(AM.gPolyFunExp, WORD);
    R_SET(AM.gPolyFunVar, WORD);
    R_SET(AM.gPolyFunPow, WORD);
    R_SET(AM.gProcessBucketSize, LONG);
    R_SET(AM.OldChildTime, LONG);
    R_SET(AM.OldSecTime, LONG);
    R_SET(AM.OldMilliTime, LONG);
    R_SET(AM.gproperorderflag, int);
    R_SET(AM.gThreadBucketSize, LONG);
    R_SET(AM.gSizeCommuteInSet, int);
    R_SET(AM.gThreadStats, int);
    R_SET(AM.gFinalStats, int);
    R_SET(AM.gThreadsFlag, int);
    R_SET(AM.gThreadBalancing, int);
    R_SET(AM.gThreadSortFileSynch, int);
    R_SET(AM.gProcessStats, int);
    R_SET(AM.gOldParallelStats, int);
    R_SET(AM.gSortType, int);
    R_SET(AM.gShortStatsMax, WORD);
    R_SET(AM.gIsFortran90, int);
    R_SET(oldAMdollarzero, void*);
    R_FREE(AM.gFortran90Kind);
    R_SET(AM.gFortran90Kind,UBYTE *);
    R_COPY_S(AM.gFortran90Kind,UBYTE *);
 
    R_COPY_S(AM.gextrasym,UBYTE *);
    R_COPY_S(AM.ggextrasym,UBYTE *);
 
    R_SET(AM.PrintTotalSize,int);
    R_SET(AM.fbuffersize,int);
    R_SET(AM.gOldFactArgFlag,int);
    R_SET(AM.ggOldFactArgFlag,int);
 
    R_SET(AM.gnumextrasym,int);
    R_SET(AM.ggnumextrasym,int);
    R_SET(AM.NumSpectatorFiles,int);
    R_SET(AM.SizeForSpectatorFiles,int);
    R_SET(AM.gOldGCDflag,int);
    R_SET(AM.ggOldGCDflag,int);
    R_SET(AM.gWTimeStatsFlag, int);
 
    R_FREE(AM.Path);
    R_SET(AM.Path,UBYTE *);
    R_COPY_S(AM.Path,UBYTE *);
 
    R_SET(AM.FromStdin, BOOL);
    R_SET(AM.IgnoreDeprecation, BOOL);
 
#ifdef PRINTDEBUG
    print_M();
#endif
 
    /*#] AM : */ 
    /*#[ AC : */
 
    /* #[ AC free pointers */
 
    /* AC will be overwritten by data from the recovery file, therefore
     * dynamically allocated memory must be freed first. */
 
    R_FREE_NAMETREE(AC.dollarnames);
    R_FREE_NAMETREE(AC.exprnames);
    R_FREE_NAMETREE(AC.varnames);
    for ( i=0; i<AC.ChannelList.num; ++i ) {
        R_FREE(channels[i].name);
    }
    R_FREE(AC.ChannelList.lijst);
    R_FREE(AC.DubiousList.lijst);
    for ( i=0; i<AC.FunctionList.num; ++i ) {
        TABLES T = functions[i].tabl;
        if ( T ) {
            R_FREE(T->buffers);
            R_FREE(T->mm);
            R_FREE(T->flags);
            R_FREE(T->prototype);
            R_FREE(T->tablepointers);
            if ( T->sparse ) {
                R_FREE(T->boomlijst);
                R_FREE(T->argtail);
            }
            if ( T->spare ) {
                R_FREE(T->spare->buffers);
                R_FREE(T->spare->mm);
                R_FREE(T->spare->flags);
                R_FREE(T->spare->tablepointers);
                if ( T->spare->sparse ) {
                    R_FREE(T->spare->boomlijst);
                }
                R_FREE(T->spare);
            }
            R_FREE(T);
        }
    }
    R_FREE(AC.FunctionList.lijst);
    for ( i=0; i<AC.ExpressionList.num; ++i ) {
        if ( Expressions[i].renum ) {
            R_FREE(Expressions[i].renum->symb.lo);
            R_FREE(Expressions[i].renum);
        }
        if ( Expressions[i].bracketinfo ) {
            R_FREE(Expressions[i].bracketinfo->indexbuffer);
            R_FREE(Expressions[i].bracketinfo->bracketbuffer);
            R_FREE(Expressions[i].bracketinfo);
        }
        if ( Expressions[i].newbracketinfo ) {
            R_FREE(Expressions[i].newbracketinfo->indexbuffer);
            R_FREE(Expressions[i].newbracketinfo->bracketbuffer);
            R_FREE(Expressions[i].newbracketinfo);
        }
        if ( Expressions[i].renumlists != AN.dummyrenumlist ) { 
            R_FREE(Expressions[i].renumlists);
        }
        R_FREE(Expressions[i].inmem);
    }
    R_FREE(AC.ExpressionList.lijst);
    R_FREE(AC.IndexList.lijst);
    R_FREE(AC.SetElementList.lijst);
    R_FREE(AC.SetList.lijst);
    R_FREE(AC.SymbolList.lijst);
    R_FREE(AC.VectorList.lijst);
    for ( i=0; i<AC.TableBaseList.num; ++i ) {
        R_FREE(tablebases[i].iblocks);
        R_FREE(tablebases[i].nblocks);
        R_FREE(tablebases[i].name);
        R_FREE(tablebases[i].fullname);
        R_FREE(tablebases[i].tablenames);
    }
    R_FREE(AC.TableBaseList.lijst);
    for ( i=0; i<AC.cbufList.num; ++i ) {
        R_FREE(cbuf[i].Buffer);
        R_FREE(cbuf[i].lhs);
        R_FREE(cbuf[i].rhs);
        R_FREE(cbuf[i].boomlijst);
    }
    R_FREE(AC.cbufList.lijst);
    R_FREE(AC.AutoSymbolList.lijst);
    R_FREE(AC.AutoIndexList.lijst);
    R_FREE(AC.AutoVectorList.lijst);
    /* Tables cannot be auto-declared, therefore no extra code here */
    R_FREE(AC.AutoFunctionList.lijst);
    R_FREE_NAMETREE(AC.autonames);
    for ( i=0; i<AC.NumStreams; ++i ) {
        R_FREE_STREAM(AC.Streams[i]);
    }
    R_FREE(AC.Streams);
    R_FREE(AC.termstack);
    R_FREE(AC.termsortstack);
    R_FREE(AC.cmod);
    R_FREE(AC.modpowers);
    R_FREE(AC.halfmod);
    R_FREE(AC.IfHeap);
    R_FREE(AC.IfCount);
    R_FREE(AC.iBuffer);
    for ( i=0; i<AC.NumLabels; ++i ) {
        R_FREE(AC.LabelNames[i]);
    }
    R_FREE(AC.LabelNames);
    R_FREE(AC.FixIndices);
    R_FREE(AC.termsumcheck);
    R_FREE(AC.WildcardNames);
    R_FREE(AC.tokens);
    R_FREE(AC.tokenarglevel);
    R_FREE(AC.modinverses);
    R_FREE(AC.Fortran90Kind);
#ifdef WITHPTHREADS
    R_FREE(AC.inputnumbers);
#endif
    R_FREE(AC.IfSumCheck);
    R_FREE(AC.CommuteInSet);
    R_FREE(AC.CheckpointRunAfter);
    R_FREE(AC.CheckpointRunBefore);
 
    /* #] AC free pointers */
 
    /* backup some lists in order to restore it to the initial setup */
    PotModDolListBackup = AC.PotModDolList;
    ModOptDolListBackup = AC.ModOptDolList;
    oldLogHandle = AC.LogHandle;
 
    /* first we copy AC as a whole and then restore the pointer structures step
       by step. */
 
    AC = *((struct C_const*)p); p = (unsigned char*)p + sizeof(struct C_const);
    
    R_COPY_NAMETREE(AC.dollarnames);
    R_COPY_NAMETREE(AC.exprnames);
    R_COPY_NAMETREE(AC.varnames);
 
    R_COPY_LIST(AC.ChannelList);
    for ( i=0; i<AC.ChannelList.num; ++i ) {
        R_COPY_S(channels[i].name,char*);
        channels[i].handle = ReOpenFile(channels[i].name);
    }
    AC.ChannelList.message = "channel buffer";
 
    AC.DubiousList.lijst = 0;
    AC.DubiousList.message = "ambiguous variable";
    AC.DubiousList.num =
    AC.DubiousList.maxnum =
    AC.DubiousList.numglobal =
    AC.DubiousList.numtemp =
    AC.DubiousList.numclear = 0;
 
    R_COPY_LIST(AC.FunctionList);
    for ( i=0; i<AC.FunctionList.num; ++i ) {
        if ( functions[i].tabl ) {
            TABLES tabl;
            R_COPY_B(tabl, sizeof(struct TaBlEs), TABLES);
            functions[i].tabl = tabl;
            if ( tabl->tablepointers ) {
                if ( tabl->sparse ) {
                    R_COPY_B(tabl->tablepointers,
                        tabl->reserved*sizeof(WORD)*(tabl->numind+TABLEEXTENSION),
                        WORD*);
                }
                else {
                    R_COPY_B(tabl->tablepointers, 
                        TABLEEXTENSION*sizeof(WORD)*(tabl->totind), WORD*);
                }
            }
            org = (UBYTE*)tabl->prototype;
#ifdef WITHPTHREADS
            R_COPY_B(tabl->prototype, tabl->prototypeSize, WORD**);
            ofs = (UBYTE*)tabl->prototype - org;
            for ( j=0; j<AM.totalnumberofthreads; ++j ) {
                if ( tabl->prototype[j] ) {
                    tabl->prototype[j] = (WORD*)((UBYTE*)tabl->prototype[j] + ofs);
                }
            }
            if ( tabl->pattern ) {
                tabl->pattern = (WORD**)((UBYTE*)tabl->pattern + ofs);
                for ( j=0; j<AM.totalnumberofthreads; ++j ) {
                    if ( tabl->pattern[j] ) {
                        tabl->pattern[j] = (WORD*)((UBYTE*)tabl->pattern[j] + ofs);
                    }
                }
            }
#else
            ofs = tabl->pattern - tabl->prototype;
            R_COPY_B(tabl->prototype, tabl->prototypeSize, WORD*);
            if ( tabl->pattern ) {
                tabl->pattern = tabl->prototype + ofs;
            }
#endif
            R_COPY_B(tabl->mm, tabl->numind*(LONG)sizeof(MINMAX), MINMAX*);
            R_COPY_B(tabl->flags, tabl->numind*(LONG)sizeof(WORD), WORD*);
            if ( tabl->sparse ) {
                R_COPY_B(tabl->boomlijst, tabl->MaxTreeSize*(LONG)sizeof(COMPTREE), COMPTREE*);
                R_COPY_S(tabl->argtail,UBYTE*);
            }
            R_COPY_B(tabl->buffers, tabl->bufferssize*(LONG)sizeof(WORD), WORD*);
            if ( tabl->spare ) {
                TABLES spare;
                R_COPY_B(spare, sizeof(struct TaBlEs), TABLES);
                tabl->spare = spare;
                if ( spare->tablepointers ) {
                    if ( spare->sparse ) {
                        R_COPY_B(spare->tablepointers,
                            spare->reserved*sizeof(WORD)*(spare->numind+TABLEEXTENSION),
                            WORD*);
                    }
                    else {
                        R_COPY_B(spare->tablepointers,
                            TABLEEXTENSION*sizeof(WORD)*(spare->totind), WORD*);
                    }
                }
                spare->prototype = tabl->prototype;
                spare->pattern = tabl->pattern;
                R_COPY_B(spare->mm, spare->numind*(LONG)sizeof(MINMAX), MINMAX*);
                R_COPY_B(spare->flags, spare->numind*(LONG)sizeof(WORD), WORD*);
                if ( tabl->sparse ) {
                    R_COPY_B(spare->boomlijst, spare->MaxTreeSize*(LONG)sizeof(COMPTREE), COMPTREE*);
                    spare->argtail = tabl->argtail;
                }
                spare->spare = tabl;
                R_COPY_B(spare->buffers, spare->bufferssize*(LONG)sizeof(WORD), WORD*);
            }
        }
    }
    AC.FunctionList.message = "function";
 
    R_COPY_LIST(AC.ExpressionList);
    for ( i=0; i<AC.ExpressionList.num; ++i ) {
        EXPRESSIONS ex = Expressions + i;
        if ( ex->renum ) {
            R_COPY_B(ex->renum, sizeof(struct ReNuMbEr), RENUMBER);
            org = (UBYTE*)ex->renum->symb.lo;
            R_SET(size, size_t);
            R_COPY_B(ex->renum->symb.lo, size, WORD*);
            ofs = (UBYTE*)ex->renum->symb.lo - org;
            ex->renum->symb.start = (WORD*)((UBYTE*)ex->renum->symb.start + ofs);
            ex->renum->symb.hi = (WORD*)((UBYTE*)ex->renum->symb.hi + ofs);
            ex->renum->indi.lo = (WORD*)((UBYTE*)ex->renum->indi.lo + ofs);
            ex->renum->indi.start = (WORD*)((UBYTE*)ex->renum->indi.start + ofs);
            ex->renum->indi.hi = (WORD*)((UBYTE*)ex->renum->indi.hi + ofs);
            ex->renum->vect.lo = (WORD*)((UBYTE*)ex->renum->vect.lo + ofs);
            ex->renum->vect.start = (WORD*)((UBYTE*)ex->renum->vect.start + ofs);
            ex->renum->vect.hi = (WORD*)((UBYTE*)ex->renum->vect.hi + ofs);
            ex->renum->func.lo = (WORD*)((UBYTE*)ex->renum->func.lo + ofs);
            ex->renum->func.start = (WORD*)((UBYTE*)ex->renum->func.start + ofs);
            ex->renum->func.hi = (WORD*)((UBYTE*)ex->renum->func.hi + ofs);
            ex->renum->symnum = (WORD*)((UBYTE*)ex->renum->symnum + ofs);
            ex->renum->indnum = (WORD*)((UBYTE*)ex->renum->indnum + ofs);
            ex->renum->vecnum = (WORD*)((UBYTE*)ex->renum->vecnum + ofs);
            ex->renum->funnum = (WORD*)((UBYTE*)ex->renum->funnum + ofs);
        }
        if ( ex->bracketinfo ) {
            R_COPY_B(ex->bracketinfo, sizeof(BRACKETINFO), BRACKETINFO*);
            R_COPY_B(ex->bracketinfo->indexbuffer, ex->bracketinfo->indexbuffersize*sizeof(BRACKETINDEX), BRACKETINDEX*);
            R_COPY_B(ex->bracketinfo->bracketbuffer, ex->bracketinfo->bracketbuffersize*sizeof(WORD), WORD*);
        }
        if ( ex->newbracketinfo ) {
            R_COPY_B(ex->newbracketinfo, sizeof(BRACKETINFO), BRACKETINFO*);
            R_COPY_B(ex->newbracketinfo->indexbuffer, ex->newbracketinfo->indexbuffersize*sizeof(BRACKETINDEX), BRACKETINDEX*);
            R_COPY_B(ex->newbracketinfo->bracketbuffer, ex->newbracketinfo->bracketbuffersize*sizeof(WORD), WORD*);
        }
#ifdef WITHPTHREADS
        ex->renumlists = 0;
#else
        ex->renumlists = AN.dummyrenumlist;
#endif
        if ( ex->inmem ) {
            R_SET(size, size_t);
            R_COPY_B(ex->inmem, size, WORD*);
        }
    }
    AC.ExpressionList.message = "expression";
 
    R_COPY_LIST(AC.IndexList);
    AC.IndexList.message = "index";
    R_COPY_LIST(AC.SetElementList);
    AC.SetElementList.message = "set element";
    R_COPY_LIST(AC.SetList);
    AC.SetList.message = "set";
    R_COPY_LIST(AC.SymbolList);
    AC.SymbolList.message = "symbol";
    R_COPY_LIST(AC.VectorList);
    AC.VectorList.message = "vector";
 
    AC.PotModDolList = PotModDolListBackup;
    AC.ModOptDolList = ModOptDolListBackup;
 
    R_COPY_LIST(AC.TableBaseList);
    for ( i=0; i<AC.TableBaseList.num; ++i ) {
        if ( tablebases[i].iblocks ) {
            R_COPY_B(tablebases[i].iblocks, tablebases[i].info.numberofindexblocks*sizeof(INDEXBLOCK*),INDEXBLOCK**);
            for ( j=0; j<tablebases[i].info.numberofindexblocks; ++j ) {
                if ( tablebases[i].iblocks[j] ) {
                    R_COPY_B(tablebases[i].iblocks[j], sizeof(INDEXBLOCK), INDEXBLOCK*);
                }
            }
        }
        if ( tablebases[i].nblocks ) {
            R_COPY_B(tablebases[i].nblocks, tablebases[i].info.numberofnamesblocks*sizeof(NAMESBLOCK*),NAMESBLOCK**);
            for ( j=0; j<tablebases[i].info.numberofindexblocks; ++j ) {
                if ( tablebases[i].nblocks[j] ) {
                    R_COPY_B(tablebases[i].nblocks[j], sizeof(NAMESBLOCK), NAMESBLOCK*);
                }
            }
        }
        /* reopen file */
        if ( ( tablebases[i].handle = fopen(tablebases[i].fullname, "r+b") ) == NULL ) {
            MesPrint("ERROR: Could not reopen tablebase %s!",tablebases[i].name);
            Terminate(-1);
        }
        R_COPY_S(tablebases[i].name,char*);
        R_COPY_S(tablebases[i].fullname,char*);
        R_COPY_S(tablebases[i].tablenames,char*);
    }
    AC.TableBaseList.message = "list of tablebases";
 
    R_COPY_LIST(AC.cbufList);
    for ( i=0; i<AC.cbufList.num; ++i ) {
        org = (UBYTE*)cbuf[i].Buffer;
        R_COPY_B(cbuf[i].Buffer, cbuf[i].BufferSize*sizeof(WORD), WORD*);
        ofs = (UBYTE*)cbuf[i].Buffer - org;
        cbuf[i].Top = (WORD*)((UBYTE*)cbuf[i].Top + ofs);
        cbuf[i].Pointer = (WORD*)((UBYTE*)cbuf[i].Pointer + ofs);
        R_COPY_B(cbuf[i].lhs, cbuf[i].maxlhs*(LONG)sizeof(WORD*), WORD**);
        for ( j=1; j<=cbuf[i].numlhs; ++j ) {
            if ( cbuf[i].lhs[j] ) cbuf[i].lhs[j] = (WORD*)((UBYTE*)cbuf[i].lhs[j] + ofs);
        }
        org = (UBYTE*)cbuf[i].rhs;
        R_COPY_B(cbuf[i].rhs, cbuf[i].maxrhs*(LONG)(sizeof(WORD*)+2*sizeof(LONG)+2*sizeof(WORD)), WORD**);
        for ( j=1; j<=cbuf[i].numrhs; ++j ) {
            if ( cbuf[i].rhs[j] ) cbuf[i].rhs[j] = (WORD*)((UBYTE*)cbuf[i].rhs[j] + ofs);
        }
        ofs = (UBYTE*)cbuf[i].rhs - org;
        cbuf[i].CanCommu = (LONG*)((UBYTE*)cbuf[i].CanCommu + ofs);
        cbuf[i].NumTerms = (LONG*)((UBYTE*)cbuf[i].NumTerms + ofs);
        cbuf[i].numdum = (WORD*)((UBYTE*)cbuf[i].numdum + ofs);
        cbuf[i].dimension = (WORD*)((UBYTE*)cbuf[i].dimension + ofs);
        if ( cbuf[i].boomlijst ) {
            R_COPY_B(cbuf[i].boomlijst, cbuf[i].MaxTreeSize*sizeof(COMPTREE), COMPTREE*);
        }
    }
    AC.cbufList.message = "compiler buffer";
 
    R_COPY_LIST(AC.AutoSymbolList);
    AC.AutoSymbolList.message = "autosymbol";
    R_COPY_LIST(AC.AutoIndexList);
    AC.AutoIndexList.message = "autoindex";
    R_COPY_LIST(AC.AutoVectorList);
    AC.AutoVectorList.message = "autovector";
    R_COPY_LIST(AC.AutoFunctionList);
    AC.AutoFunctionList.message = "autofunction";
 
    R_COPY_NAMETREE(AC.autonames);
 
    AC.Symbols = &(AC.SymbolList);
    AC.Indices = &(AC.IndexList);
    AC.Vectors = &(AC.VectorList);
    AC.Functions = &(AC.FunctionList);
    AC.activenames = &(AC.varnames);
 
    org = (UBYTE*)AC.Streams;
    R_COPY_B(AC.Streams, AC.MaxNumStreams*(LONG)sizeof(STREAM), STREAM*);
    for ( i=0; i<AC.NumStreams; ++i ) {
        if ( AC.Streams[i].type != FILESTREAM ) {
            UBYTE *org2;
            org2 = AC.Streams[i].buffer;
            if ( AC.Streams[i].inbuffer ) {
                R_COPY_B(AC.Streams[i].buffer, AC.Streams[i].inbuffer, UBYTE*);
            }
            ofs = AC.Streams[i].buffer - org2;
            AC.Streams[i].pointer += ofs;
            AC.Streams[i].top += ofs;
        }
        else {
            p = (unsigned char*)p + AC.Streams[i].inbuffer;
        }
        AC.Streams[i].buffersize = AC.Streams[i].inbuffer;
        R_COPY_S(AC.Streams[i].FoldName,UBYTE*);
        R_COPY_S(AC.Streams[i].name,UBYTE*);
        if ( AC.Streams[i].type == PREVARSTREAM || AC.Streams[i].type == DOLLARSTREAM ) {
            AC.Streams[i].pname = AC.Streams[i].name;
        }
        else if ( AC.Streams[i].type == FILESTREAM ) {
            UBYTE *org2;
            org2 = AC.Streams[i].buffer;
            AC.Streams[i].buffer = (UBYTE*)Malloc1(AC.Streams[i].buffersize, "buffer");
            ofs = AC.Streams[i].buffer - org2;
            AC.Streams[i].pointer += ofs;
            AC.Streams[i].top += ofs;
 
            /* open file except for already opened main input file */
            if ( i ) {
                AC.Streams[i].handle = OpenFile((char *)(AC.Streams[i].name));
                if ( AC.Streams[i].handle == -1 ) {
                    MesPrint("ERROR: Could not reopen stream %s!",AC.Streams[i].name);
                    Terminate(-1);
                }
            }
            
            PUTZERO(pos);
            ADDPOS(pos, AC.Streams[i].bufferposition);
            SeekFile(AC.Streams[i].handle, &pos, SEEK_SET);
 
            AC.Streams[i].inbuffer = ReadFile(AC.Streams[i].handle, AC.Streams[i].buffer, AC.Streams[i].inbuffer);
 
            SETBASEPOSITION(pos, AC.Streams[i].fileposition);
            SeekFile(AC.Streams[i].handle, &pos, SEEK_SET);
        }
        /* 
         * Ideally, we should check if we have a type PREREADSTREAM, PREREADSTREAM2, and
         * PRECALCSTREAM here. If so, we should free element name and point it
         * to the name element of the embracing stream's struct. In practice,
         * this is undoable without adding new data to STREAM. Since we create
         * only a small memory leak here (some few byte for each existing
         * stream of these types) and only once when we do a recovery, we
         * tolerate this leak and keep it STREAM as it is.
         */
    }
    ofs = (UBYTE*)AC.Streams - org;
    AC.CurrentStream = (STREAM*)((UBYTE*)AC.CurrentStream + ofs);
 
    if ( AC.termstack ) {
        R_COPY_B(AC.termstack, AC.maxtermlevel*(LONG)sizeof(LONG), LONG*);
    }
 
    if ( AC.termsortstack ) {
        R_COPY_B(AC.termsortstack, AC.maxtermlevel*(LONG)sizeof(LONG), LONG*);
    }
 
    /* exception: here we also change values from struct AM */
    R_COPY_B(AC.cmod, AM.MaxTal*4*(LONG)sizeof(UWORD), UWORD*);
    AM.gcmod = AC.cmod + AM.MaxTal;
    AC.powmod = AM.gcmod + AM.MaxTal;
    AM.gpowmod = AC.powmod + AM.MaxTal;
 
    AC.modpowers = 0;
    AC.halfmod = 0;
 
    /* we don't care about AC.ProtoType/WildC */
 
    if ( AC.IfHeap ) {
        ofs = AC.IfStack - AC.IfHeap;
        R_COPY_B(AC.IfHeap, (LONG)sizeof(LONG)*(AC.MaxIf+1), LONG*);
        AC.IfStack = AC.IfHeap + ofs;
        R_COPY_B(AC.IfCount, (LONG)sizeof(LONG)*(AC.MaxIf+1), LONG*);
    }
 
    org = AC.iBuffer;
    size = AC.iStop - AC.iBuffer + 2;
    R_COPY_B(AC.iBuffer, size, UBYTE*);
    ofs = AC.iBuffer - org;
    AC.iPointer += ofs;
    AC.iStop += ofs;
 
    if ( AC.LabelNames ) {
        org = (UBYTE*)AC.LabelNames;
        R_COPY_B(AC.LabelNames, AC.MaxLabels*(LONG)(sizeof(UBYTE*)+sizeof(WORD)), UBYTE**);
        for ( i=0; i<AC.NumLabels; ++i ) {
            R_COPY_S(AC.LabelNames[i],UBYTE*);
        }
        ofs = (UBYTE*)AC.LabelNames - org;
        AC.Labels = (int*)((UBYTE*)AC.Labels + ofs);
    }
    
    R_COPY_B(AC.FixIndices, AM.OffsetIndex*(LONG)sizeof(WORD), WORD*);
 
    if ( AC.termsumcheck ) {
        R_COPY_B(AC.termsumcheck, AC.maxtermlevel*(LONG)sizeof(WORD), WORD*);
    }
 
    R_COPY_B(AC.WildcardNames, AC.WildcardBufferSize, UBYTE*);
 
    if ( AC.tokens ) {
        size = AC.toptokens - AC.tokens;
        if ( size ) {
            org = (UBYTE*)AC.tokens;
            R_COPY_B(AC.tokens, size, SBYTE*);
            ofs = (UBYTE*)AC.tokens - org;
            AC.endoftokens += ofs;
            AC.toptokens += ofs;
        }
        else {
            AC.tokens = 0;
            AC.endoftokens = AC.tokens;
            AC.toptokens = AC.tokens;
        }
    }
 
    R_COPY_B(AC.tokenarglevel, AM.MaxParLevel*(LONG)sizeof(WORD), WORD*);
 
    AC.modinverses = 0;
 
    R_COPY_S(AC.Fortran90Kind,UBYTE *);
 
#ifdef WITHPTHREADS
    if ( AC.inputnumbers ) {
        org = (UBYTE*)AC.inputnumbers;
        R_COPY_B(AC.inputnumbers, AC.sizepfirstnum*(LONG)(sizeof(WORD)+sizeof(LONG)), LONG*);
        ofs = (UBYTE*)AC.inputnumbers - org;
        AC.pfirstnum = (WORD*)((UBYTE*)AC.pfirstnum + ofs);
    }
    AC.halfmodlock = dummylock;
#endif /* ifdef WITHPTHREADS */
 
    if ( AC.IfSumCheck ) {
        R_COPY_B(AC.IfSumCheck, (LONG)sizeof(WORD)*(AC.MaxIf+1), WORD*);
    }
    if ( AC.CommuteInSet ) {
        R_COPY_B(AC.CommuteInSet, (LONG)sizeof(WORD)*(AC.SizeCommuteInSet+1), WORD*);
    }
 
    AC.LogHandle = oldLogHandle;
 
    R_COPY_S(AC.CheckpointRunAfter,char*);
    R_COPY_S(AC.CheckpointRunBefore,char*);
 
    R_COPY_S(AC.extrasym,UBYTE *);
 
#ifdef PRINTDEBUG
    print_C();
#endif
 
    /*#] AC : */ 
    /*#[ AP : */
 
    /* #[ AP free pointers */
 
    /* AP will be overwritten by data from the recovery file, therefore
     * dynamically allocated memory must be freed first. */
 
    for ( i=0; i<AP.DollarList.num; ++i ) {
        if ( Dollars[i].size ) {
            R_FREE(Dollars[i].where);
        }
        CleanDollarFactors(Dollars+i);
    }
    R_FREE(AP.DollarList.lijst);
 
    for ( i=0; i<AP.PreVarList.num; ++i ) {
        R_FREE(PreVar[i].name);
    }
    R_FREE(AP.PreVarList.lijst);
 
    for ( i=0; i<AP.LoopList.num; ++i ) {
        R_FREE(DoLoops[i].p.buffer);
        if ( DoLoops[i].dollarname ) {
            R_FREE(DoLoops[i].dollarname);
        }
    }
    R_FREE(AP.LoopList.lijst);
    
    for ( i=0; i<AP.ProcList.num; ++i ) {
        R_FREE(Procedures[i].p.buffer);
        R_FREE(Procedures[i].name);
    }
    R_FREE(AP.ProcList.lijst);
 
    for ( i=1; i<=AP.PreSwitchLevel; ++i ) {
        R_FREE(AP.PreSwitchStrings[i]);
    }
    R_FREE(AP.PreSwitchStrings);
    R_FREE(AP.preStart);
    R_FREE(AP.procedureExtension);
    R_FREE(AP.cprocedureExtension);
    R_FREE(AP.PreIfStack);
    R_FREE(AP.PreSwitchModes);
    R_FREE(AP.PreTypes);
 
    /* #] AP free pointers */
    
    /* first we copy AP as a whole and then restore the pointer structures step
       by step. */
 
    AP = *((struct P_const*)p); p = (unsigned char*)p + sizeof(struct P_const);
#ifdef WITHPTHREADS
    AP.PreVarLock = dummylock;
#endif
 
    R_COPY_LIST(AP.DollarList);
    for ( i=0; i<AP.DollarList.num; ++i ) {
        DOLLARS d = Dollars + i;
        size = d->size * sizeof(WORD);
        if ( size && d->where && d->where != oldAMdollarzero ) {
            R_COPY_B(d->where, size, void*);
        }
#ifdef WITHPTHREADS
        INIRECLOCK(d->pthreadslock);
#endif
        if ( d->nfactors > 1 ) {
            R_COPY_B(d->factors,sizeof(FACDOLLAR)*d->nfactors,FACDOLLAR*);
            for ( j = 0; j < d->nfactors; j++ ) {
                if ( d->factors[j].size > 0 ) {
                    R_COPY_B(d->factors[i].where,sizeof(WORD)*(d->factors[j].size+1),WORD*);
                }
            }
        }
    }
    AP.DollarList.message = "$-variable";
 
    R_COPY_LIST(AP.PreVarList);
    for ( i=0; i<AP.PreVarList.num; ++i ) {
        R_SET(size, size_t);
        org = PreVar[i].name;
        R_COPY_B(PreVar[i].name, size, UBYTE*);
        ofs = PreVar[i].name - org;
        if ( PreVar[i].value ) PreVar[i].value += ofs;
        if ( PreVar[i].argnames ) PreVar[i].argnames += ofs;
    }
    AP.PreVarList.message = "PreVariable";
 
    R_COPY_LIST(AP.LoopList);
    for ( i=0; i<AP.LoopList.num; ++i ) {
        org = DoLoops[i].p.buffer;
        R_COPY_B(DoLoops[i].p.buffer, DoLoops[i].p.size, UBYTE*);
        ofs = DoLoops[i].p.buffer - org;
        if ( DoLoops[i].name ) DoLoops[i].name += ofs;
        if ( DoLoops[i].vars ) DoLoops[i].vars += ofs;
        if ( DoLoops[i].contents ) DoLoops[i].contents += ofs;
        if ( DoLoops[i].type == ONEEXPRESSION ) {
            R_COPY_S(DoLoops[i].dollarname,UBYTE*);
        }
    }
    AP.LoopList.message = "doloop";
 
    R_COPY_LIST(AP.ProcList);
    for ( i=0; i<AP.ProcList.num; ++i ) {
        if ( Procedures[i].p.size ) {
            if ( Procedures[i].loadmode != 1 ) {
                R_COPY_B(Procedures[i].p.buffer, Procedures[i].p.size, UBYTE*);
            }
            else {
                R_SET(j, int);
                Procedures[i].p.buffer = Procedures[j].p.buffer;
            }
        }
        R_COPY_S(Procedures[i].name,UBYTE*);
    }
    AP.ProcList.message = "procedure";
 
    size = (AP.NumPreSwitchStrings+1)*(LONG)sizeof(UBYTE*);
    R_COPY_B(AP.PreSwitchStrings, size, UBYTE**);
    for ( i=1; i<=AP.PreSwitchLevel; ++i ) {
        R_COPY_S(AP.PreSwitchStrings[i],UBYTE*);
    }
 
    org = AP.preStart;
    R_COPY_B(AP.preStart, AP.pSize, UBYTE*);
    ofs = AP.preStart - org;
    if ( AP.preFill ) AP.preFill += ofs;
    if ( AP.preStop ) AP.preStop += ofs;
 
    R_COPY_S(AP.procedureExtension,UBYTE*);
    R_COPY_S(AP.cprocedureExtension,UBYTE*);
 
    R_COPY_B(AP.PreAssignStack,AP.MaxPreAssignLevel*(LONG)sizeof(LONG),LONG*);
    R_COPY_B(AP.PreIfStack, AP.MaxPreIfLevel*(LONG)sizeof(int), int*);
    R_COPY_B(AP.PreSwitchModes, (AP.NumPreSwitchStrings+1)*(LONG)sizeof(int), int*);
    R_COPY_B(AP.PreTypes, (AP.MaxPreTypes+1)*(LONG)sizeof(int), int*);
 
#ifdef PRINTDEBUG
    print_P();
#endif
 
    /*#] AP : */ 
    /*#[ AR : */
 
    R_SET(ofs,LONG);
    if ( ofs ) {
        AR.infile = AR.Fscr+1;
        AR.outfile = AR.Fscr;
        AR.hidefile = AR.Fscr+2;
    }
    else {
        AR.infile = AR.Fscr;
        AR.outfile = AR.Fscr+1;
        AR.hidefile = AR.Fscr+2;
    }
 
    /* #[ AR free pointers */
 
    /* Parts of AR will be overwritten by data from the recovery file, therefore
     * dynamically allocated memory must be freed first. */
 
    namebufout = AR.outfile->name;
    namebufhide = AR.hidefile->name;
    R_FREE(AR.outfile->PObuffer);
#ifdef WITHZLIB
    R_FREE(AR.outfile->zsp);
    R_FREE(AR.outfile->ziobuffer);
#endif
    namebufhide = AR.hidefile->name;
    R_FREE(AR.hidefile->PObuffer);
#ifdef WITHZLIB
    R_FREE(AR.hidefile->zsp);
    R_FREE(AR.hidefile->ziobuffer);
#endif
    /* no files should be opened -> nothing to do with handle */
 
    /* #] AR free pointers */
    
    /* outfile */
    R_SET(*AR.outfile, FILEHANDLE);
    org = (UBYTE*)AR.outfile->PObuffer;
    size = AR.outfile->POfull - AR.outfile->PObuffer;
    AR.outfile->PObuffer = (WORD*)Malloc1(AR.outfile->POsize, "PObuffer");
    if ( size ) {
        memcpy(AR.outfile->PObuffer, p, size*sizeof(WORD));
        p = (unsigned char*)p + size*sizeof(WORD);
    }
    ofs = (UBYTE*)AR.outfile->PObuffer - org;
    AR.outfile->POstop = (WORD*)((UBYTE*)AR.outfile->POstop + ofs);
    AR.outfile->POfill = (WORD*)((UBYTE*)AR.outfile->POfill + ofs);
    AR.outfile->POfull = (WORD*)((UBYTE*)AR.outfile->POfull + ofs);
    AR.outfile->name = namebufout;
#ifdef WITHPTHREADS
    AR.outfile->wPObuffer = AR.outfile->PObuffer;
    AR.outfile->wPOstop = AR.outfile->POstop;
    AR.outfile->wPOfill = AR.outfile->POfill;
    AR.outfile->wPOfull = AR.outfile->POfull;
#endif
#ifdef WITHZLIB
    /* zsp and ziobuffer will be allocated when used */
    AR.outfile->zsp = 0;
    AR.outfile->ziobuffer = 0;
#endif
    /* reopen old outfile */
#ifdef WITHMPI
    if(PF.me==MASTER)
#endif
    if ( AR.outfile->handle >= 0 ) {
        if ( CopyFile(sortfile, AR.outfile->name) ) {
            MesPrint("ERROR: Could not copy old output sort file %s!",sortfile);
            Terminate(-1);
        }
        AR.outfile->handle = ReOpenFile(AR.outfile->name);
        if ( AR.outfile->handle == -1 ) {
            MesPrint("ERROR: Could not reopen output sort file %s!",AR.outfile->name);
            Terminate(-1);
        }
        SeekFile(AR.outfile->handle, &AR.outfile->POposition, SEEK_SET);
    }
 
    /* hidefile */
    R_SET(*AR.hidefile, FILEHANDLE);
    AR.hidefile->name = namebufhide;
    if ( AR.hidefile->PObuffer ) {
        org = (UBYTE*)AR.hidefile->PObuffer;
        size = AR.hidefile->POfull - AR.hidefile->PObuffer;
        AR.hidefile->PObuffer = (WORD*)Malloc1(AR.hidefile->POsize, "PObuffer");
        if ( size ) {
            memcpy(AR.hidefile->PObuffer, p, size*sizeof(WORD));
            p = (unsigned char*)p + size*sizeof(WORD);
        }
        ofs = (UBYTE*)AR.hidefile->PObuffer - org;
        AR.hidefile->POstop = (WORD*)((UBYTE*)AR.hidefile->POstop + ofs);
        AR.hidefile->POfill = (WORD*)((UBYTE*)AR.hidefile->POfill + ofs);
        AR.hidefile->POfull = (WORD*)((UBYTE*)AR.hidefile->POfull + ofs);
#ifdef WITHPTHREADS
        AR.hidefile->wPObuffer = AR.hidefile->PObuffer;
        AR.hidefile->wPOstop = AR.hidefile->POstop;
        AR.hidefile->wPOfill = AR.hidefile->POfill;
        AR.hidefile->wPOfull = AR.hidefile->POfull;
#endif
    }
#ifdef WITHZLIB
        /* zsp and ziobuffer will be allocated when used */
        AR.hidefile->zsp = 0;
        AR.hidefile->ziobuffer = 0;
#endif
    /* reopen old hidefile */
    if ( AR.hidefile->handle >= 0 ) {
        if ( CopyFile(hidefile, AR.hidefile->name) ) {
            MesPrint("ERROR: Could not copy old hide file %s!",hidefile);
            Terminate(-1);
        }
        AR.hidefile->handle = ReOpenFile(AR.hidefile->name);
        if ( AR.hidefile->handle == -1 ) {
            MesPrint("ERROR: Could not reopen hide file %s!",AR.hidefile->name);
            Terminate(-1);
        }
        SeekFile(AR.hidefile->handle, &AR.hidefile->POposition, SEEK_SET);
    }
 
    /* store file */
    R_SET(pos, POSITION);
    if ( ISNOTZEROPOS(pos) ) {
        CloseFile(AR.StoreData.Handle);
        R_SET(AR.StoreData, FILEDATA);
        if ( CopyFile(storefile, FG.fname) ) {
            MesPrint("ERROR: Could not copy old store file %s!",storefile);
            Terminate(-1);
        }
        AR.StoreData.Handle = (WORD)ReOpenFile(FG.fname);
        SeekFile(AR.StoreData.Handle, &AR.StoreData.Position, SEEK_SET);
    }
 
    R_SET(AR.DefPosition, POSITION);
    R_SET(AR.OldTime, LONG);
    R_SET(AR.InInBuf, LONG);
    R_SET(AR.InHiBuf, LONG);
 
    R_SET(AR.NoCompress, int);
    R_SET(AR.gzipCompress, int);
 
    R_SET(AR.outtohide, int);
 
    R_SET(AR.GetFile, WORD);
    R_SET(AR.KeptInHold, WORD);
    R_SET(AR.BracketOn, WORD);
    R_SET(AR.MaxBracket, WORD);
    R_SET(AR.CurDum, WORD);
    R_SET(AR.DeferFlag, WORD);
    R_SET(AR.TePos, WORD);
    R_SET(AR.sLevel, WORD);
    R_SET(AR.Stage4Name, WORD);
    R_SET(AR.GetOneFile, WORD);
    R_SET(AR.PolyFun, WORD);
    R_SET(AR.PolyFunInv, WORD);
    R_SET(AR.PolyFunType, WORD);
    R_SET(AR.PolyFunExp, WORD);
    R_SET(AR.PolyFunVar, WORD);
    R_SET(AR.PolyFunPow, WORD);
    R_SET(AR.Eside, WORD);
    R_SET(AR.MaxDum, WORD);
    R_SET(AR.level, WORD);
    R_SET(AR.expchanged, WORD);
    R_SET(AR.expflags, WORD);
    R_SET(AR.CurExpr, WORD);
    R_SET(AR.SortType, WORD);
    R_SET(AR.ShortSortCount, WORD);
 
    /* this is usually done in Process(), but sometimes FORM does not
       end up executing Process() before it uses the AR.CompressPointer,
       so we need to explicitly set it here. */
    AR.CompressPointer = AR.CompressBuffer;
 
#ifdef WITHPTHREADS
    for ( j = 0; j < AM.totalnumberofthreads; j++ ) {
        R_SET(AB[j]->R.wranfnpair1, int);
        R_SET(AB[j]->R.wranfnpair2, int);
        R_SET(AB[j]->R.wranfcall, int);
        R_SET(AB[j]->R.wranfseed, ULONG);
        R_SET(AB[j]->R.wranfia,ULONG*);
        if ( AB[j]->R.wranfia ) {
            R_COPY_B(AB[j]->R.wranfia, sizeof(ULONG)*AB[j]->R.wranfnpair2, ULONG*);
        }
    }
#else
    R_SET(AR.wranfnpair1, int);
    R_SET(AR.wranfnpair2, int);
    R_SET(AR.wranfcall, int);
    R_SET(AR.wranfseed, ULONG);
    R_SET(AR.wranfia,ULONG*);
    if ( AR.wranfia ) {
        R_COPY_B(AR.wranfia, sizeof(ULONG)*AR.wranfnpair2, ULONG*);
    }
#endif
 
#ifdef PRINTDEBUG
    print_R();
#endif
 
    /*#] AR : */ 
    /*#[ AO :*/
/*
    We copy all non-pointer variables.
*/
    l = sizeof(A.O) - ((UBYTE *)(&(A.O.NumInBrack))-(UBYTE *)(&A.O));
    memcpy(&(A.O.NumInBrack), p, l); p = (unsigned char*)p + l;
/*
    Now the variables in OptimizeResult
*/
    memcpy(&(A.O.OptimizeResult),p,sizeof(OPTIMIZERESULT));
        p = (unsigned char*)p + sizeof(OPTIMIZERESULT);
 
    if ( A.O.OptimizeResult.codesize > 0 ) {
        R_COPY_B(A.O.OptimizeResult.code,A.O.OptimizeResult.codesize*sizeof(WORD),WORD *);
    }
    R_COPY_S(A.O.OptimizeResult.nameofexpr,UBYTE *);
/*
    And now the dictionaries. We know how many there are. We also know
    how many elements the array AO.Dictionaries should have.
*/
    if ( AO.SizeDictionaries > 0 ) {
        AO.Dictionaries = (DICTIONARY **)Malloc1(AO.SizeDictionaries*sizeof(DICTIONARY *),
                    "Dictionaries");
        for ( i = 0; i < AO.NumDictionaries; i++ ) {
            R_SET(l,LONG)
            AO.Dictionaries[i] = DictFromBytes(p);
            p = (char *)p + l;
        }
    }
    /*#] AO :*/ 
#ifdef WITHMPI
    /*#[ PF : */
    {/*Block*/
        int numtasks;
        R_SET(numtasks, int);
        if(numtasks!=PF.numtasks){
            MesPrint("%d number of tasks expected instead of %d; use mpirun -np %d",
                            numtasks,PF.numtasks,numtasks);
            if(PF.me!=MASTER)
                remove(RecoveryFilename());
            Terminate(-1);
        }
    }/*Block*/
    R_SET(PF.rhsInParallel, int);
    R_SET(PF.exprbufsize, int);
    R_SET(PF.log, int);
    /*#] PF : */ 
#endif
 
#ifdef WITHPTHREADS
    /* read timing information of individual threads */
    R_SET(i, int);
    for ( j=1; j<AM.totalnumberofthreads; ++j ) {
        /* ... and correcting OldTime */
        AB[j]->R.OldTime = -(*((LONG*)p+j));
    }
    WriteTimerInfo((LONG*)p,(LONG *)((unsigned char*)p + i*(LONG)sizeof(LONG)));
    p = (unsigned char*)p + 2*i*(LONG)sizeof(LONG);
#endif /* ifdef WITHPTHREADS */
 
    if ( fclose(fd) ) return(__LINE__);
 
    M_free(buf,"recovery buffer");
 
    /* cares about data in S_const */
    UpdatePositions();
    AT.SS = AT.S0;
/*
    Set the checkpoint parameter right for the next checkpoint.
*/
    AC.CheckpointStamp = TimeWallClock(1);
    
    done_snapshot = 1;
    MesPrint("done."); fflush(0);
 
    return(0);
}
 
/*
    #] DoRecovery : 
    #[ DoSnapshot :
*/
 
static int DoSnapshot(int moduletype)
{
    GETIDENTITY
    FILE *fd;
    POSITION pos;
    int i, j;
    LONG l;
    WORD *w;
    void *adr;
#ifdef WITHPTHREADS
    LONG *longp,*longpp;
#endif /* ifdef WITHPTHREADS */
 
    MesPrint("Saving recovery point ... %"); fflush(0);
#ifdef PRINTTIMEMARKS
    MesPrint("\n");
#endif
 
    if ( !(fd = fopen(intermedfile, "wb")) ) return(__LINE__);
 
    /* reserve space in the file for a length field */
    if ( fwrite(&pos, 1, sizeof(POSITION), fd) != sizeof(POSITION) ) return(__LINE__);
 
    /* write moduletype */
    if ( fwrite(&moduletype, 1, sizeof(int), fd) != sizeof(int) ) return(__LINE__);
 
    /*#[ AM :*/
 
    /* since most values don't change during execution, AM doesn't need to be
     * written as a whole. all values will be correctly set when starting up
     * anyway. only the exceptions need to be taken care of. see MakeGlobal()
     * and PopVariables() in execute.c. */
 
    ANNOUNCE(AM)
    S_WRITE_B(&AM.hparallelflag, sizeof(int));
    S_WRITE_B(&AM.gparallelflag, sizeof(int));
    S_WRITE_B(&AM.gCodesFlag, sizeof(int));
    S_WRITE_B(&AM.gNamesFlag, sizeof(int));
    S_WRITE_B(&AM.gStatsFlag, sizeof(int));
    S_WRITE_B(&AM.gTokensWriteFlag, sizeof(int));
    S_WRITE_B(&AM.gNoSpacesInNumbers, sizeof(int));
    S_WRITE_B(&AM.gIndentSpace, sizeof(WORD));
    S_WRITE_B(&AM.gUnitTrace, sizeof(WORD));
    S_WRITE_B(&AM.gDefDim, sizeof(int));
    S_WRITE_B(&AM.gDefDim4, sizeof(int));
    S_WRITE_B(&AM.gncmod, sizeof(WORD));
    S_WRITE_B(&AM.gnpowmod, sizeof(WORD));
    S_WRITE_B(&AM.gmodmode, sizeof(WORD));
    S_WRITE_B(&AM.gOutputMode, sizeof(WORD));
    S_WRITE_B(&AM.gCnumpows, sizeof(WORD));
    S_WRITE_B(&AM.gOutputSpaces, sizeof(WORD));
    S_WRITE_B(&AM.gOutNumberType, sizeof(WORD));
    S_WRITE_B(&AM.gfunpowers, sizeof(int));
    S_WRITE_B(&AM.gPolyFun, sizeof(WORD));
    S_WRITE_B(&AM.gPolyFunInv, sizeof(WORD));
    S_WRITE_B(&AM.gPolyFunType, sizeof(WORD));
    S_WRITE_B(&AM.gPolyFunExp, sizeof(WORD));
    S_WRITE_B(&AM.gPolyFunVar, sizeof(WORD));
    S_WRITE_B(&AM.gPolyFunPow, sizeof(WORD));
    S_WRITE_B(&AM.gProcessBucketSize, sizeof(LONG));
    S_WRITE_B(&AM.OldChildTime, sizeof(LONG));
    S_WRITE_B(&AM.OldSecTime, sizeof(LONG));
    S_WRITE_B(&AM.OldMilliTime, sizeof(LONG));
    S_WRITE_B(&AM.gproperorderflag, sizeof(int));
    S_WRITE_B(&AM.gThreadBucketSize, sizeof(LONG));
    S_WRITE_B(&AM.gSizeCommuteInSet, sizeof(int));
    S_WRITE_B(&AM.gThreadStats, sizeof(int));
    S_WRITE_B(&AM.gFinalStats, sizeof(int));
    S_WRITE_B(&AM.gThreadsFlag, sizeof(int));
    S_WRITE_B(&AM.gThreadBalancing, sizeof(int));
    S_WRITE_B(&AM.gThreadSortFileSynch, sizeof(int));
    S_WRITE_B(&AM.gProcessStats, sizeof(int));
    S_WRITE_B(&AM.gOldParallelStats, sizeof(int));
    S_WRITE_B(&AM.gSortType, sizeof(int));
    S_WRITE_B(&AM.gShortStatsMax, sizeof(WORD));
    S_WRITE_B(&AM.gIsFortran90, sizeof(int));
    adr = &AM.dollarzero;
    S_WRITE_B(&adr, sizeof(void*));
    S_WRITE_B(&AM.gFortran90Kind,sizeof(UBYTE *));
    S_WRITE_S(AM.gFortran90Kind);
 
    S_WRITE_S(AM.gextrasym);
    S_WRITE_S(AM.ggextrasym);
 
    S_WRITE_B(&AM.PrintTotalSize,sizeof(int));
    S_WRITE_B(&AM.fbuffersize,sizeof(int));
    S_WRITE_B(&AM.gOldFactArgFlag,sizeof(int));
    S_WRITE_B(&AM.ggOldFactArgFlag,sizeof(int));
 
    S_WRITE_B(&AM.gnumextrasym,sizeof(int));
    S_WRITE_B(&AM.ggnumextrasym,sizeof(int));
    S_WRITE_B(&AM.NumSpectatorFiles,sizeof(int));
    S_WRITE_B(&AM.SizeForSpectatorFiles,sizeof(int));
    S_WRITE_B(&AM.gOldGCDflag,sizeof(int));
    S_WRITE_B(&AM.ggOldGCDflag,sizeof(int));
    S_WRITE_B(&AM.gWTimeStatsFlag, sizeof(int));
 
    S_WRITE_B(&AM.Path,sizeof(UBYTE *));
    S_WRITE_S(AM.Path);
 
    S_WRITE_B(&AM.FromStdin,sizeof(BOOL));
    S_WRITE_B(&AM.IgnoreDeprecation,sizeof(BOOL));
 
    /*#] AM :*/ 
    /*#[ AC :*/
 
    /* we write AC as a whole and then write all additional data step by step.
     * AC.DubiousList doesn't need to be treated, because it should be empty. */
 
    ANNOUNCE(AC)
    S_WRITE_B(&AC, sizeof(struct C_const));
 
    S_WRITE_NAMETREE(AC.dollarnames);
    S_WRITE_NAMETREE(AC.exprnames);
    S_WRITE_NAMETREE(AC.varnames);
    
    S_WRITE_LIST(AC.ChannelList);
    for ( i=0; i<AC.ChannelList.num; ++i ) {
        S_WRITE_S(channels[i].name);
    }
 
    ANNOUNCE(AC.FunctionList)
    S_WRITE_LIST(AC.FunctionList);
    for ( i=0; i<AC.FunctionList.num; ++i ) {
        /* if the function is a table */
        if ( functions[i].tabl ) {
            TABLES tabl = functions[i].tabl;
            S_WRITE_B(tabl, sizeof(struct TaBlEs));
            if ( tabl->tablepointers ) {
                if ( tabl->sparse ) {
                    /* sparse tables. reserved holds number of allocated
                     * elements. the size of an element is numind plus
                     * TABLEEXTENSION times the size of WORD. */
                    S_WRITE_B(tabl->tablepointers,
                        tabl->reserved*sizeof(WORD)*(tabl->numind+TABLEEXTENSION));
                }
                else {
                    /* matrix like tables. */
                    S_WRITE_B(tabl->tablepointers,
                        TABLEEXTENSION*sizeof(WORD)*(tabl->totind));
                }
            }
            S_WRITE_B(tabl->prototype, tabl->prototypeSize);
            S_WRITE_B(tabl->mm, tabl->numind*(LONG)sizeof(MINMAX));
            S_WRITE_B(tabl->flags, tabl->numind*(LONG)sizeof(WORD));
            if ( tabl->sparse ) {
                S_WRITE_B(tabl->boomlijst, tabl->MaxTreeSize*(LONG)sizeof(COMPTREE));
                S_WRITE_S(tabl->argtail);
            }
            S_WRITE_B(tabl->buffers, tabl->bufferssize*(LONG)sizeof(WORD));
            if ( tabl->spare ) {
                TABLES spare = tabl->spare;
                S_WRITE_B(spare, sizeof(struct TaBlEs));
                if ( spare->tablepointers ) {
                    if ( spare->sparse ) {
                        /* sparse tables */
                        S_WRITE_B(spare->tablepointers,
                            spare->reserved*sizeof(WORD)*(spare->numind+TABLEEXTENSION));
                    }
                    else {
                        /* matrix like tables */
                        S_WRITE_B(spare->tablepointers,
                            TABLEEXTENSION*sizeof(WORD)*(spare->totind));
                    }
                }
                S_WRITE_B(spare->mm, spare->numind*(LONG)sizeof(MINMAX));
                S_WRITE_B(spare->flags, spare->numind*(LONG)sizeof(WORD));
                if ( spare->sparse ) {
                    S_WRITE_B(spare->boomlijst, spare->MaxTreeSize*(LONG)sizeof(COMPTREE));
                }
                S_WRITE_B(spare->buffers, spare->bufferssize*(LONG)sizeof(WORD));
            }
        }
    }
 
    ANNOUNCE(AC.ExpressionList)
    S_WRITE_LIST(AC.ExpressionList);
    for ( i=0; i<AC.ExpressionList.num; ++i ) {
        EXPRESSIONS ex = Expressions + i;
        if ( ex->renum ) {
            S_WRITE_B(ex->renum, sizeof(struct ReNuMbEr));
            /* there is one dynamically allocated buffer for struct ReNuMbEr and
             * symb.lo points to its beginning. the size of the buffer is not
             * stored anywhere but we know it is 2*sizeof(WORD)*N, where N is
             * the number of all vectors, indices, functions and symbols. since
             * funum points into the buffer at a distance 2N-[Number of
             * functions] from symb.lo (see GetTable() in store.c), we can
             * calculate the buffer size by some pointer arithmetic. the size is
             * then written to the file. */
            l = ex->renum->funnum - ex->renum->symb.lo;
            l += ex->renum->funnum - ex->renum->func.lo;
            S_WRITE_B(&l, sizeof(size_t));
            S_WRITE_B(ex->renum->symb.lo, l);
        }
        if ( ex->bracketinfo ) {
            S_WRITE_B(ex->bracketinfo, sizeof(BRACKETINFO));
            S_WRITE_B(ex->bracketinfo->indexbuffer, ex->bracketinfo->indexbuffersize*sizeof(BRACKETINDEX));
            S_WRITE_B(ex->bracketinfo->bracketbuffer, ex->bracketinfo->bracketbuffersize*sizeof(WORD));
        }
        if ( ex->newbracketinfo ) {
            S_WRITE_B(ex->newbracketinfo, sizeof(BRACKETINFO));
            S_WRITE_B(ex->newbracketinfo->indexbuffer, ex->newbracketinfo->indexbuffersize*sizeof(BRACKETINDEX));
            S_WRITE_B(ex->newbracketinfo->bracketbuffer, ex->newbracketinfo->bracketbuffersize*sizeof(WORD));
        }
        /* don't need to write ex->renumlists */
        if ( ex->inmem ) {
            /* size of the inmem buffer has to be determined. we use the fact
             * that the end of an expression is marked by a zero. */
            w = ex->inmem;
            while ( *w++ ) ;
            l = w - ex->inmem;
            S_WRITE_B(&l, sizeof(size_t));
            S_WRITE_B(ex->inmem, l);
        }
    }
    
    ANNOUNCE(AC.IndexList)
    S_WRITE_LIST(AC.IndexList);
    S_WRITE_LIST(AC.SetElementList);
    S_WRITE_LIST(AC.SetList);
    S_WRITE_LIST(AC.SymbolList);
    S_WRITE_LIST(AC.VectorList);
 
    ANNOUNCE(AC.TableBaseList)
    S_WRITE_LIST(AC.TableBaseList);
    for ( i=0; i<AC.TableBaseList.num; ++i ) {
        /* see struct dbase in minos.h */
        if ( tablebases[i].iblocks ) {
            S_WRITE_B(tablebases[i].iblocks, tablebases[i].info.numberofindexblocks * sizeof(INDEXBLOCK*));
            for ( j=0; j<tablebases[i].info.numberofindexblocks; ++j ) {
                if ( tablebases[i].iblocks[j] ) {
                    S_WRITE_B(tablebases[i].iblocks[j], sizeof(INDEXBLOCK));
                }
            }
        }
        if ( tablebases[i].nblocks ) {
            S_WRITE_B(tablebases[i].nblocks, tablebases[i].info.numberofnamesblocks * sizeof(NAMESBLOCK*));
            for ( j=0; j<tablebases[i].info.numberofnamesblocks; ++j ) {
                if ( tablebases[i].nblocks[j] ) {
                    S_WRITE_B(tablebases[i].nblocks[j], sizeof(NAMESBLOCK));
                }
            }
        }
        S_WRITE_S(tablebases[i].name);
        S_WRITE_S(tablebases[i].fullname);
        S_WRITE_S(tablebases[i].tablenames);
    }
 
    ANNOUNCE(AC.cbufList)
    S_WRITE_LIST(AC.cbufList);
    for ( i=0; i<AC.cbufList.num; ++i ) {
        S_WRITE_B(cbuf[i].Buffer, cbuf[i].BufferSize*sizeof(WORD));
        /* see inicbufs in comtool.c */
        S_WRITE_B(cbuf[i].lhs, cbuf[i].maxlhs*(LONG)sizeof(WORD*));
        S_WRITE_B(cbuf[i].rhs, cbuf[i].maxrhs*(LONG)(sizeof(WORD*)+2*sizeof(LONG)+2*sizeof(WORD)));
        if ( cbuf[i].boomlijst ) {
            S_WRITE_B(cbuf[i].boomlijst, cbuf[i].MaxTreeSize*(LONG)sizeof(COMPTREE));
        }
    }
 
    S_WRITE_LIST(AC.AutoSymbolList);
    S_WRITE_LIST(AC.AutoIndexList);
    S_WRITE_LIST(AC.AutoVectorList);
    S_WRITE_LIST(AC.AutoFunctionList);
 
    S_WRITE_NAMETREE(AC.autonames);
 
    ANNOUNCE(AC.Streams)
    S_WRITE_B(AC.Streams, AC.MaxNumStreams*(LONG)sizeof(STREAM));
    for ( i=0; i<AC.NumStreams; ++i ) {
        if ( AC.Streams[i].inbuffer ) {
            S_WRITE_B(AC.Streams[i].buffer, AC.Streams[i].inbuffer);
        }
        S_WRITE_S(AC.Streams[i].FoldName);
        S_WRITE_S(AC.Streams[i].name);
    }
 
    if ( AC.termstack ) {
        S_WRITE_B(AC.termstack, AC.maxtermlevel*(LONG)sizeof(LONG));
    }
 
    if ( AC.termsortstack ) {
        S_WRITE_B(AC.termsortstack, AC.maxtermlevel*(LONG)sizeof(LONG));
    }
 
    S_WRITE_B(AC.cmod, AM.MaxTal*4*(LONG)sizeof(UWORD));
 
    if ( AC.IfHeap ) {
        S_WRITE_B(AC.IfHeap, (LONG)sizeof(LONG)*(AC.MaxIf+1));
        S_WRITE_B(AC.IfCount, (LONG)sizeof(LONG)*(AC.MaxIf+1));
    }
 
    l = AC.iStop - AC.iBuffer + 2;
    S_WRITE_B(AC.iBuffer, l);
 
    if ( AC.LabelNames ) {
        S_WRITE_B(AC.LabelNames, AC.MaxLabels*(LONG)(sizeof(UBYTE*)+sizeof(WORD)));
        for ( i=0; i<AC.NumLabels; ++i ) {
            S_WRITE_S(AC.LabelNames[i]);
        }
    }
 
    S_WRITE_B(AC.FixIndices, AM.OffsetIndex*(LONG)sizeof(WORD));
 
    if ( AC.termsumcheck ) {
        S_WRITE_B(AC.termsumcheck, AC.maxtermlevel*(LONG)sizeof(WORD));
    }
 
    S_WRITE_B(AC.WildcardNames, AC.WildcardBufferSize);
 
    if ( AC.tokens ) {
        l = AC.toptokens - AC.tokens;
        if ( l ) {
            S_WRITE_B(AC.tokens, l);
        }
    }
 
    S_WRITE_B(AC.tokenarglevel, AM.MaxParLevel*(LONG)sizeof(WORD));
 
    S_WRITE_S(AC.Fortran90Kind);
    
#ifdef WITHPTHREADS
    if ( AC.inputnumbers ) {
        S_WRITE_B(AC.inputnumbers, AC.sizepfirstnum*(LONG)(sizeof(WORD)+sizeof(LONG)));
    }
#endif /* ifdef WITHPTHREADS */
 
    if ( AC.IfSumCheck ) {
        S_WRITE_B(AC.IfSumCheck, (LONG)sizeof(WORD)*(AC.MaxIf+1));
    }
    if ( AC.CommuteInSet ) {
        S_WRITE_B(AC.CommuteInSet, (LONG)sizeof(WORD)*(AC.SizeCommuteInSet+1));
    }
 
    S_WRITE_S(AC.CheckpointRunAfter);
    S_WRITE_S(AC.CheckpointRunBefore);
 
    S_WRITE_S(AC.extrasym);
 
    /*#] AC :*/ 
    /*#[ AP :*/
 
    /* we write AP as a whole and then write all additional data step by step. */
 
    ANNOUNCE(AP)
    S_WRITE_B(&AP, sizeof(struct P_const));
 
    S_WRITE_LIST(AP.DollarList);
    for ( i=0; i<AP.DollarList.num; ++i ) {
        DOLLARS d = Dollars + i;
        S_WRITE_DOLLAR(Dollars[i]);
        if ( d->nfactors > 1 ) {
            S_WRITE_B(&(d->factors),sizeof(FACDOLLAR)*d->nfactors);
            for ( j = 0; j < d->nfactors; j++ ) {
                if ( d->factors[j].size > 0 ) {
                    S_WRITE_B(&(d->factors[i].where),sizeof(WORD)*(d->factors[j].size+1));
                }
            }
        }
    }
 
    S_WRITE_LIST(AP.PreVarList);
    for ( i=0; i<AP.PreVarList.num; ++i ) {
        /* there is one dynamically allocated buffer in struct pReVaR holding
         * the strings name, value and several argnames. the size of the buffer
         * can be calculated by adding up their string lengths. */
        l = strlen((char*)PreVar[i].name) + 1;
        if ( PreVar[i].value ) {
            l += strlen((char*)(PreVar[i].name+l)) + 1;
        }
        for ( j=0; j<PreVar[i].nargs; ++j ) {
            l += strlen((char*)(PreVar[i].name+l)) + 1;
        }
        S_WRITE_B(&l, sizeof(size_t));
        S_WRITE_B(PreVar[i].name, l);
    }
 
    ANNOUNCE(AP.LoopList)
    S_WRITE_LIST(AP.LoopList);
    for ( i=0; i<AP.LoopList.num; ++i ) {
        S_WRITE_B(DoLoops[i].p.buffer, DoLoops[i].p.size);
        if ( DoLoops[i].type == ONEEXPRESSION ) {
            /* do loops with an expression keep this expression in a dynamically
             * allocated buffer in dollarname */
            S_WRITE_S(DoLoops[i].dollarname);
        }
    }
 
    S_WRITE_LIST(AP.ProcList);
    for ( i=0; i<AP.ProcList.num; ++i ) {
        if ( Procedures[i].p.size ) {
            if ( Procedures[i].loadmode != 1 ) {
                S_WRITE_B(Procedures[i].p.buffer, Procedures[i].p.size);
            }
            else {
                for ( j=0; j<AP.ProcList.num; ++j ) {
                    if ( Procedures[i].p.buffer == Procedures[j].p.buffer ) {
                        break;
                    }
                }
                if ( j == AP.ProcList.num ) {
                    MesPrint("Error writing procedures to recovery file!");
                }
                S_WRITE_B(&j, sizeof(int));
            }
        }
        S_WRITE_S(Procedures[i].name);
    }
 
    S_WRITE_B(AP.PreSwitchStrings, (AP.NumPreSwitchStrings+1)*(LONG)sizeof(UBYTE*));
    for ( i=1; i<=AP.PreSwitchLevel; ++i ) {
        S_WRITE_S(AP.PreSwitchStrings[i]);
    }
 
    S_WRITE_B(AP.preStart, AP.pSize);
    
    S_WRITE_S(AP.procedureExtension);
    S_WRITE_S(AP.cprocedureExtension);
 
    S_WRITE_B(AP.PreAssignStack, AP.MaxPreAssignLevel*(LONG)sizeof(LONG));
    S_WRITE_B(AP.PreIfStack, AP.MaxPreIfLevel*(LONG)sizeof(int));
    S_WRITE_B(AP.PreSwitchModes, (AP.NumPreSwitchStrings+1)*(LONG)sizeof(int));
    S_WRITE_B(AP.PreTypes, (AP.MaxPreTypes+1)*(LONG)sizeof(int));
 
    /*#] AP :*/ 
    /*#[ AR :*/
 
    ANNOUNCE(AR)
    /* to remember which entry in AR.Fscr corresponds to the infile */
    l = AR.infile - AR.Fscr;
    S_WRITE_B(&l, sizeof(LONG));
    
    /* write the FILEHANDLEs */
    S_WRITE_B(AR.outfile, sizeof(FILEHANDLE));
    l = AR.outfile->POfull - AR.outfile->PObuffer;
    if ( l ) {
        S_WRITE_B(AR.outfile->PObuffer, l*sizeof(WORD));
    }
    S_WRITE_B(AR.hidefile, sizeof(FILEHANDLE));
    l = AR.hidefile->POfull - AR.hidefile->PObuffer;
    if ( l ) {
        S_WRITE_B(AR.hidefile->PObuffer, l*sizeof(WORD));
    }
 
    S_WRITE_B(&AR.StoreData.Fill, sizeof(POSITION));
    if ( ISNOTZEROPOS(AR.StoreData.Fill) ) {
        S_WRITE_B(&AR.StoreData, sizeof(FILEDATA));
    }
 
    S_WRITE_B(&AR.DefPosition, sizeof(POSITION));
 
    l = TimeCPU(1); l = -l;
    S_WRITE_B(&l, sizeof(LONG));
 
    ANNOUNCE(AR.InInBuf)
    S_WRITE_B(&AR.InInBuf, sizeof(LONG));
    S_WRITE_B(&AR.InHiBuf, sizeof(LONG));
    
    S_WRITE_B(&AR.NoCompress, sizeof(int));
    S_WRITE_B(&AR.gzipCompress, sizeof(int));
    
    S_WRITE_B(&AR.outtohide, sizeof(int));
 
    S_WRITE_B(&AR.GetFile, sizeof(WORD));
    S_WRITE_B(&AR.KeptInHold, sizeof(WORD));
    S_WRITE_B(&AR.BracketOn, sizeof(WORD));
    S_WRITE_B(&AR.MaxBracket, sizeof(WORD));
    S_WRITE_B(&AR.CurDum, sizeof(WORD));
    S_WRITE_B(&AR.DeferFlag, sizeof(WORD));
    S_WRITE_B(&AR.TePos, sizeof(WORD));
    S_WRITE_B(&AR.sLevel, sizeof(WORD));
    S_WRITE_B(&AR.Stage4Name, sizeof(WORD));
    S_WRITE_B(&AR.GetOneFile, sizeof(WORD));
    S_WRITE_B(&AR.PolyFun, sizeof(WORD));
    S_WRITE_B(&AR.PolyFunInv, sizeof(WORD));
    S_WRITE_B(&AR.PolyFunType, sizeof(WORD));
    S_WRITE_B(&AR.PolyFunExp, sizeof(WORD));
    S_WRITE_B(&AR.PolyFunVar, sizeof(WORD));
    S_WRITE_B(&AR.PolyFunPow, sizeof(WORD));
    S_WRITE_B(&AR.Eside, sizeof(WORD));
    S_WRITE_B(&AR.MaxDum, sizeof(WORD));
    S_WRITE_B(&AR.level, sizeof(WORD));
    S_WRITE_B(&AR.expchanged, sizeof(WORD));
    S_WRITE_B(&AR.expflags, sizeof(WORD));
    S_WRITE_B(&AR.CurExpr, sizeof(WORD));
    S_WRITE_B(&AR.SortType, sizeof(WORD));
    S_WRITE_B(&AR.ShortSortCount, sizeof(WORD));
 
#ifdef WITHPTHREADS
    for ( j = 0; j < AM.totalnumberofthreads; j++ ) {
        S_WRITE_B(&(AB[j]->R.wranfnpair1), sizeof(int));
        S_WRITE_B(&(AB[j]->R.wranfnpair2), sizeof(int));
        S_WRITE_B(&(AB[j]->R.wranfcall), sizeof(int));
        S_WRITE_B(&(AB[j]->R.wranfseed), sizeof(ULONG));
        S_WRITE_B(&(AB[j]->R.wranfia),sizeof(ULONG *));
        if ( AB[j]->R.wranfia ) {
            S_WRITE_B(AB[j]->R.wranfia, sizeof(ULONG)*AB[j]->R.wranfnpair2);
        }
    }
#else
    S_WRITE_B(&(AR.wranfnpair1), sizeof(int));
    S_WRITE_B(&(AR.wranfnpair2), sizeof(int));
    S_WRITE_B(&(AR.wranfcall), sizeof(int));
    S_WRITE_B(&(AR.wranfseed), sizeof(ULONG));
    S_WRITE_B(&(AR.wranfia),sizeof(ULONG *));
    if ( AR.wranfia ) {
        S_WRITE_B(AR.wranfia, sizeof(ULONG)*AR.wranfnpair2);
    }
#endif
 
    /*#] AR :*/ 
    /*#[ AO :*/
/*
    We copy all non-pointer variables.
*/
    ANNOUNCE(AO)
    l = sizeof(A.O) - ((UBYTE *)(&(A.O.NumInBrack))-(UBYTE *)(&A.O));
    S_WRITE_B(&(A.O.NumInBrack),l);
/*
    Now the variables in OptimizeResult
*/
    S_WRITE_B(&(A.O.OptimizeResult),sizeof(OPTIMIZERESULT));
    if ( A.O.OptimizeResult.codesize > 0 ) {
        S_WRITE_B(A.O.OptimizeResult.code,A.O.OptimizeResult.codesize*sizeof(WORD));
    }
    S_WRITE_S(A.O.OptimizeResult.nameofexpr);
/*
    And now the dictionaries.
    We write each dictionary to a buffer and get the size of that buffer.
    Then we write the size and the buffer.
*/
    for ( i = 0; i < AO.NumDictionaries; i++ ) {
        l = DictToBytes(AO.Dictionaries[i],(UBYTE *)(AT.WorkPointer));
        S_WRITE_B(&l,sizeof(LONG));
        S_WRITE_B(AT.WorkPointer,l);
    }
 
    /*#] AO :*/ 
    /*#[ PF :*/
#ifdef WITHMPI
    S_WRITE_B(&PF.numtasks, sizeof(int));
    S_WRITE_B(&PF.rhsInParallel, sizeof(int));
    S_WRITE_B(&PF.exprbufsize, sizeof(int));
    S_WRITE_B(&PF.log, sizeof(int));
#endif
    /*#] PF :*/ 
 
#ifdef WITHPTHREADS
 
    ANNOUNCE(GetTimerInfo)
/*
    write timing information of individual threads
*/
    i = GetTimerInfo(&longp,&longpp);
    S_WRITE_B(&i, sizeof(int));
    S_WRITE_B(longp, i*(LONG)sizeof(LONG));
    S_WRITE_B(&i, sizeof(int));
    S_WRITE_B(longpp, i*(LONG)sizeof(LONG));
 
#endif
 
    S_FLUSH_B /* because we will call fwrite() directly in the following code */
 
    /* save length of data at the beginning of the file */
    ANNOUNCE(file length)
    SETBASEPOSITION(pos, (ftell(fd)));
    fseek(fd, 0, SEEK_SET);
    if ( fwrite(&pos, 1, sizeof(POSITION), fd) != sizeof(POSITION) ) return(__LINE__);
    fseek(fd, BASEPOSITION(pos), SEEK_SET);
 
    ANNOUNCE(file close)
    if ( fclose(fd) ) return(__LINE__);
#ifdef WITHMPI
    if ( PF.me == MASTER ) {
#endif
/*
        copy store file if necessary
*/
        ANNOUNCE(copy store file)
        if ( ISNOTZEROPOS(AR.StoreData.Fill) ) {
            if ( CopyFile(FG.fname, storefile) ) return(__LINE__);
        }
/*
        copy sort file if necessary
*/
        ANNOUNCE(copy sort file)
        if ( AR.outfile->handle >= 0 ) {
            if ( CopyFile(AR.outfile->name, sortfile) ) return(__LINE__);
        }
/*
        copy hide file if necessary
*/
        ANNOUNCE(copy hide file)
        if ( AR.hidefile->handle >= 0 ) {
            if ( CopyFile(AR.hidefile->name, hidefile) ) return(__LINE__);
        }
#ifdef WITHMPI
    }
    /*
     * For ParFORM, the renaming will be performed after the master got
     * all recovery files from the slaves.
     */
#else
/*
    make the intermediate file the recovery file
*/
    ANNOUNCE(rename intermediate file)
    if ( rename(intermedfile, recoveryfile) ) return(__LINE__);
 
    done_snapshot = 1;
 
    MesPrint("done."); fflush(0);
#endif
 
#ifdef PRINTDEBUG
    print_M();
    print_C();
    print_P();
    print_R();
#endif
 
    return(0);
}
 
/*
    #] DoSnapshot : 
    #[ DoCheckpoint :
*/
 
void DoCheckpoint(int moduletype)
{
    int error;
    LONG timestamp = TimeWallClock(1);
#ifdef WITHMPI
    if(PF.me == MASTER){
#endif
    if ( timestamp - AC.CheckpointStamp >= AC.CheckpointInterval ) {
        char argbuf[20];
        int retvalue = 0;
        if ( AC.CheckpointRunBefore ) {
            size_t l, l2;
            char *str;
            l = strlen(AC.CheckpointRunBefore);
            NumToStr((UBYTE*)argbuf, AC.CModule);
            l2 = strlen(argbuf);
            str = (char*)Malloc1(l+l2+2, "callbefore");
            strcpy(str, AC.CheckpointRunBefore);
            *(str+l) = ' ';
            strcpy(str+l+1, argbuf);
            retvalue = system(str);
            M_free(str, "callbefore");
            if ( retvalue ) {
                MesPrint("Script returned error -> no recovery file will be created.");
            }
        }
#ifdef WITHMPI
        /* Confirm slaves to make snapshots. */
        PF_BroadcastNumber(retvalue == 0);
#endif
        if ( retvalue == 0 ) {
            if ( (error = DoSnapshot(moduletype)) ) {
                MesPrint("Error creating recovery files: %d", error);
            }
#ifdef WITHMPI
            {
            int i;
            /*get recovery files from slaves:*/
            for(i=1; i<PF.numtasks;i++){
                FILE *fd;
                const char *tmpnam = PF_recoveryfile('m', i, 1);
                fd = fopen(tmpnam, "w");
                if(fd == NULL){
                    MesPrint("Error opening recovery file for slave %d",i);
                    Terminate(-1);
                }/*if(fd == NULL)*/
                retvalue=PF_RecvFile(i,fd);
                if(retvalue<=0){
                    MesPrint("Error receiving recovery file from slave %d",i);
                    Terminate(-1);
                }/*if(retvalue<=0)*/
                fclose(fd);
            }/*for(i=0; i<PF.numtasks;i++)*/
            /*
             * Make the intermediate files the recovery files.
             */
            ANNOUNCE(rename intermediate file)
            for ( i = 0; i < PF.numtasks; i++ ) {
                const char *src = PF_recoveryfile('m', i, 1);
                const char *dst = PF_recoveryfile('m', i, 0);
                if ( rename(src, dst) ) {
                    MesPrint("Error renaming recovery file %s -> %s", src, dst);
                }
            }
            done_snapshot = 1;
            MesPrint("done."); fflush(0);
            }
#endif
        }
        if ( AC.CheckpointRunAfter ) {
            size_t l, l2;
            char *str;
            l = strlen(AC.CheckpointRunAfter);
            NumToStr((UBYTE*)argbuf, AC.CModule);
            l2 = strlen(argbuf);
            str = (char*)Malloc1(l+l2+2, "callafter");
            strcpy(str, AC.CheckpointRunAfter);
            *(str+l) = ' ';
            strcpy(str+l+1, argbuf);
            retvalue = system(str);
            M_free(str, "callafter");
            if ( retvalue ) {
                MesPrint("Error calling script after recovery.");
            }
        }
        AC.CheckpointStamp = TimeWallClock(1);
    }
#ifdef WITHMPI
    else{/* timestamp - AC.CheckpointStamp < AC.CheckpointInterval*/
        /* The slaves don't need to make snapshots. */
        PF_BroadcastNumber(0);
    }
    }/*if(PF.me == MASTER)*/
    else{/*Slave*/
        int i;
        /* Check if the slave needs to make a snapshot. */
        if ( PF_BroadcastNumber(0) ) {
            error = DoSnapshot(moduletype);
            if(error == 0){
                FILE *fd;
                /*
                 * Send the recovery file to the master. Note that no renaming
                 * has been performed and what we have to send is actually sitting
                 * in the intermediate file.
                 */
                fd = fopen(intermedfile, "r");
                i=PF_SendFile(MASTER, fd);/*if fd==NULL, PF_SendFile seds to a slave the failure tag*/
                if(fd == NULL)
                    Terminate(-1);
                fclose(fd);
                if(i<=0)
                    Terminate(-1);
                /*Now the slave need not the recovery file so remove it:*/
                remove(intermedfile);
            }
            else{
                /*send the error tag to the master:*/
                PF_SendFile(MASTER,NULL);/*if fd==NULL, PF_SendFile seds to a slave the failure tag*/
                Terminate(-1);
            }
            done_snapshot = 1;
        }/*if(tag=PF_DATA_MSGTAG)*/
    }/*if(PF.me != MASTER)*/
#endif
}
 
/*
    #] DoCheckpoint : 
*/