15701338753

Committed 17 Jun 2025 07:49AM UTC coverage: 50.382% (-0.004%) from 50.386%

Build # 15701338753

Build Type

Pull #662

github

Committed by

web-flow

Commit Message

Merge f1f68c050 into 207386593

Pull Request Pull Request #662: Cleanup: change VOID into void

Run Details

178 of 245 new or added lines in 34 files covered. (72.65%)

2 existing lines in 1 file now uncovered.

41784 of 82935 relevant lines covered (50.38%)

2640008.85 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

2.73

/sources/checkpoint.c

/*
          #[ Explanations :
*/
/** @file checkpoint.c
 * 
 *  Contains all functions that deal with the recovery mechanism controlled and
 *  activated by the On Checkpoint switch.
 *
 *  The main function are DoCheckpoint, DoRecovery, and DoSnapshot. If the
 *  checkpoints are activated DoCheckpoint is called every time a module is
 *  finished executing. If the conditions for the creation of a recovery
 *  snapshot are met DoCheckpoint calls DoSnapshot. DoRecovery is called once
 *  when FORM starts up with the command line argument -R. Most of the other
 *  code contains debugging facilities that are only compiled if the macro
 *  PRINTDEBUG is defined.
 *
 *  The recovery mechanism is atomic, i.e. only if everything went well, the
 *  final recovery file is created (and the older one overwritten) in a single
 *  step (copying). If some errors occur, a warning is issued and the program
 *  continues without having created a new recovery file. The only situation in
 *  which the creation of the recovery data leads to a termination of the
 *  running program is if not enough disk or memory space is left.
 *
 *  For ParFORM each slave creates its own recovery file, sends it to the 
 *  master and then it deletes the recovery file. The master stores all the 
 *  recovery files and on recovery it feeds these files to the slaves. It is
 *  nearly impossible to recover after some MPI fault so ParFORM terminates 
 *  on any recovery failure.
 *
 *  DoRecovery and DoSnapshot do the loading and saving of the recovery data,
 *  respectively. Every change in one functions needs to be accompanied by the
 *  appropriate change in the other function. The structure of both functions is
 *  quite similar. They handle the relevant global structs one after the other
 *  and then care about the copying of the hide and scratch files.
 *
 *  The names of the recovery, scratch and hide files are hard-coded in the
 *  variables in fold "filenames and system commands".
 *
 *  If the global structs AM,AP,AC,AR are changed, DoRecovery and DoSnapshot
 *  usually also have to be changed. Some structs are read/written as a whole
 *  (AP,AC), some are read/written only partly as a selection of their
 *  individual elements (AM,AR). If AM or AR have been changed by adding or
 *  removing an element that is important for the runtime status, then the
 *  reading/writing statements have to be added to or removed from DoRecovery
 *  and DoSnapshot. If AP or AC are changed, then for non-pointer variables (in
 *  the case of a struct it also means that none of its elements is a pointer)
 *  nothing has to be changed in the functions here. If pointers are involved,
 *  extra code has to be added (or removed). See the comments of DoRecovery and
 *  DoSnapshot.
 *
 */
/*
          #] Explanations : 
          #[ License :
 *
 *   Copyright (C) 1984-2023 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 :
*/

/**
 *  BaseName of recovery files
 */
#ifdef WITHMPI
#define BASENAME_FMT "%c%04dFORMrecv"
/**
 * The basenames for ParFORM will be created from BASENAME_FMT by means of 
 * sprintf(BaseName,BASENAME_FMT,(PF.me == MASTER)?'m':'s',PF.me);
 * in InitRecovery(). Here just reserve the space:
 */
static char BaseName[] = BASENAME_FMT;
#else
static char *BaseName = "FORMrecv";
#endif
/**
 *  filename for the recovery file
 */
static char *recoveryfile = 0;
/**
 *  filename for the intermediate recovery file. only if the write is
 *  completely successful, this file will be moved/renamed to the one
 *  named by recoveryfile. this offers atomicity for the snapshot generation.
 */
static char *intermedfile = 0;
/**
 *  filename of sort file copy
 */
static char *sortfile = 0;
/**
 *  filename of hide file copy
 */
static char *hidefile = 0;
/**
 *  filename of store file copy
 */
static char *storefile = 0;

/**
 *  >0 if at least once the respective file has been created.
 *  Checked by DeleteRecoveryFile().
 */
static int done_snapshot = 0;

#ifdef WITHMPI
/**
 *  The position at which BASENAME_FMT should be applied.
 *  Initialized in InitRecovery().
 */
static int PF_fmt_pos;

/**
 *  Returns the contents of recoveryfile or intermedfile but with the renaming
 *  specified by the arguments.
 */
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 :
*/

/**
 *  Checks whether a snapshot/recovery file exists.
 *  Returns 1 if it exists, 0 otherwise.
 */
#ifdef WITHMPI

/**
 * The master has all the recovery files. It checks whether these files
 * exist and sends proper files to slaves. On any error PF_CheckRecoveryFile()
 * returns -1 which leads to the program termination.
 */
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 :
*/

/**
 *  Deletes the recovery files. It is called by CleanUp() in the case of a
 *  successful completion.
 */
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 :
*/

/**
 *  Returns pointer to recovery filename. 
 */
char *RecoveryFilename(void)
{
        return(recoveryfile);
}

/*
          #] RecoveryFilename : 
          #[ InitRecovery :
*/

/**
 *  Utility function for 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;
}

/**
 *  Sets up the strings for the filenames of the recovery files.
 *  This functions should only be called once to avoid memory leaks and after
 *  AM.TempDir has been initialized.
 */
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 :
*/

/**
 *  Reads from the recovery file and restores all necessary variables and
 *  states in FORM, so that the execution can recommence in preprocessor() as
 *  if no restart of FORM had occurred.
 *
 *  The recovery file is read into memory as a whole. The pointer p then points
 *  into this memory at the next non-processed data. The macros by which
 *  variables are restored, like R_SET, automatically increase p appropriately.
 *
 *  If something goes wrong, the function returns with a non-zero value.
 *
 *  Allocated memory that would be lost when overwriting the global structs with
 *  data from the file is freed first. A major part of the code deals with the
 *  restoration of pointers. The idiom we use is to memorize the original
 *  pointer value (org), allocate new memory and copy the data from the file
 *  into this memory, calculate the offset between the old pointer value
 *  and the new allocated memory position (ofs), and then correct all affected
 *  pointers (+=ofs).
 *
 *  We rely on the fact that several variables (especially in AM) are already
 *  assigned the correct values by the startup functions. That means, in
 *  principle, that a change in the setup files between snapshot creation and
 *  recovery will be noticed.
 */
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
                d->pthreadslockread = dummylock;
                d->pthreadslockwrite = dummylock;
#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 :
*/

/**
 *  Writes all relevant information for a recovery to the recovery file. It
 *  writes first to an intermediate file and then only if everything went well
 *  it renames this intermediate file to the final recovery file. Then it copies
 *  the sort and store files if necessary.
 *
 *  The data is directly written to file from the structs or struct element.
 *
 *  No data is changed in the global structs and this function should never crash.
 *  Honorably exception might be: not enough memory for the allocation of the
 *  command strings (usually less than 100 bytes), or not enough disk space for
 *  the recovery file and the copies of the hide/scratch/store files.
 *
 *  If something goes wrong, the function returns with a non-zero value.
 */
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 :
*/

/**
 *  Checks whether a snapshot should be done. Calls DoSnapshot() to create the
 *  snapshot.
 */
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 : 
*/

form-dev / form / 15701338753

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous