9364948935

Committed 04 Jun 2024 09:49AM UTC coverage: 49.979% (-0.02%) from 49.999%

Build # 9364948935

Build Type

Pull #526

github

Committed by

web-flow

Commit Message

Merge 7062bd769 into 83e3d4185

Pull Request Pull Request #526: RFC: better debugging

Run Details

52 of 415 new or added lines in 46 files covered. (12.53%)

32 existing lines in 2 files now uncovered.

41391 of 82816 relevant lines covered (49.98%)

878690.77 hits per line

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

63.98

/sources/spectator.c

/** @file spectator.c
 *
 *        File contains the code for the spectator files and their control.
 *
 */
/* #[ 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"

/*
          #] includes : 
          #[ Commentary :

        We use an array of SPECTATOR structs in AM.SpectatorFiles.
        When a spectator is removed this leaves a hole. This means that
        we cannot use AM.NumSpectatorFiles but always have to scan up to
        AM.SizeForSpectatorFiles which is the size of the array.
        An element is in use when it has a name. This is the name of the
        expression that is associated with it. There is also the number of
        the expression, but because the expressions are frequently renumbered
        at the end of a module, we always search for the spectators by name.
        The expression number is only valid in the current module.
        During execution we use the number of the spectator.

        The FILEHANDLE struct is borrowed from the structs for the scratch
        files, but we do not keep copies for all workers as with the scratch
        files. This brings some limitations (but saves much space). Basically
        the reading can only be done by one master or worker. And because
        we use the buffer both for writing and for reading we cannot read and
        write in the same module.

        Processor can see that an expression is to be filled with a spectator
        because we replace the compiler buffer number in the prototype by
        -specnum-1. Of course, after this filling has taken place we should
        make sure that in the next module there is a nonnegative number there.
        The input is then obtained from GetFromSpectator instead from GetTerm.
        This needed an extra argument in ThreadsProcessor. InParallelProcessor
        can figure it out by itself. ParFORM still needs to be treated for this.

        The writing is to a single buffer. Hence it needs a lock. It is possible
        to give all workers their own buffers (at great memory cost) and merge
        the results when needed. That would be friendlier on ParFORM. We ALWAYS
        assume that the order of the terms in the spectator file is random.

        In the first version there is no compression in the file. This could
        change in later versions because both the writing and the reading are
        purely sequential. Brackets are not possible.

        Currently, ParFORM allows use of spectators only in the sequential
        mode. The parallelization is switched off in modules containing
        ToSpectator or CopySpectator. Workers never create or access to
        spectator files. Their file handles are always -1. We leave the
        parallelization of modules with spectators for future work.

          #] Commentary : 
          #[ CoCreateSpectator :

        Syntax: CreateSpectator name_of_expr "filename";
*/

int CoCreateSpectator(UBYTE *inp)
{
        UBYTE *p, *q, *filename, c, cc;
        WORD c1, c2, numexpr = 0, specnum, HadOne = 0;
        FILEHANDLE *fh;
        while ( *inp == ',' ) inp++;
        if ( ( q = SkipAName(inp) ) == 0 || q[-1] == '_' ) {
                MesPrint("&Illegal name for expression");
                return(1);
        }
        c = *q; *q = 0;
        if ( GetVar(inp,&c1,&c2,ALLVARIABLES,NOAUTO) != NAMENOTFOUND ) {
                if ( c2 == CEXPRESSION && 
                                Expressions[c1].status == DROPSPECTATOREXPRESSION ) {
                        numexpr = c1;
                        Expressions[numexpr].status = SPECTATOREXPRESSION;
                        HadOne = 1;
                }
                else {
                        MesPrint("&The name %s has been used already.",inp);
                        *q = c;
                        return(1);
                }
        }
        p = q+1;
        while ( *p == ',' ) p++;
        if ( *p != '"' ) goto Syntax;
        p++; filename = p;
        while ( *p && *p != '"' ) {
                if ( *p == '\\' ) p++;
                p++;
        }
        if ( *p != '"' ) goto Syntax;
        q = p+1;
        while ( *q && ( *q == ',' || *q == ' ' || *q == '\t' ) ) q++;
        if ( *q ) goto Syntax;
        cc = *p; *p = 0;
/*
        Now we need to: create a struct for the spectator file.
*/
        if ( HadOne == 0 )
                numexpr = EntVar(CEXPRESSION,inp,SPECTATOREXPRESSION,0,0,0);
        fh = AllocFileHandle(1,(char *)filename);
/*
        Make sure there is space in the AM.spectatorfiles array
*/
        if ( AM.NumSpectatorFiles >= AM.SizeForSpectatorFiles || AM.SpectatorFiles == 0 ) {
                int newsize, i;
                SPECTATOR *newspectators;
                if ( AM.SizeForSpectatorFiles == 0 ) {
                        newsize = 10;
                        AM.NumSpectatorFiles = AM.SizeForSpectatorFiles = 0;
                }
                else newsize = AM.SizeForSpectatorFiles*2;
                newspectators = (SPECTATOR *)Malloc1(newsize*sizeof(SPECTATOR),"Spectators");
                for ( i = 0; i < AM.NumSpectatorFiles; i++ )
                        newspectators[i] = AM.SpectatorFiles[i];
                for ( ; i < newsize; i++ ) {
                        newspectators[i].fh = 0;
                        newspectators[i].name = 0;
                        newspectators[i].exprnumber = -1;
                        newspectators[i].flags = 0;
                        PUTZERO(newspectators[i].position);
                        PUTZERO(newspectators[i].readpos);
                }
                AM.SizeForSpectatorFiles = newsize;
                if ( AM.SpectatorFiles != 0 ) M_free(AM.SpectatorFiles,"Spectators");
                AM.SpectatorFiles = newspectators;
                specnum = AM.NumSpectatorFiles++;
        }
        else {
                for ( specnum = 0; specnum < AM.SizeForSpectatorFiles; specnum++ ) {
                        if ( AM.SpectatorFiles[specnum].name == 0 ) break;
                }
                AM.NumSpectatorFiles++;
        }
        PUTZERO(AM.SpectatorFiles[specnum].position);
        AM.SpectatorFiles[specnum].name = (char *)(strDup1(inp,"Spectator expression name"));
        AM.SpectatorFiles[specnum].fh = fh;
        AM.SpectatorFiles[specnum].exprnumber = numexpr;
        *p = cc;
        return(0);
Syntax:
        MesPrint("&Proper syntax is: CreateSpectator,exprname,\"filename\";");
        return(-1);
}

/*
          #] CoCreateSpectator : 
          #[ CoToSpectator :
*/

int CoToSpectator(UBYTE *inp)
{
        UBYTE *q;
        WORD c1, numexpr;
        int i;
        while ( *inp == ',' ) inp++;
        if ( ( q = SkipAName(inp) ) == 0 || q[-1] == '_' ) {
                MesPrint("&Illegal name for expression");
                return(1);
        }
        if ( *q != 0 ) goto Syntax;
        if ( GetVar(inp,&c1,&numexpr,ALLVARIABLES,NOAUTO) == NAMENOTFOUND ||
                        c1 != CEXPRESSION ) {
                MesPrint("&%s is not a valid expression.",inp);
                return(1);
        }
        if ( Expressions[numexpr].status != SPECTATOREXPRESSION ) {
                MesPrint("&%s is not an active spectator.",inp);
                return(1);
        }
        for ( i = 0; i < AM.SizeForSpectatorFiles; i++ ) {
          if ( AM.SpectatorFiles[i].name != 0 ) {
                if ( StrCmp((UBYTE *)(AM.SpectatorFiles[i].name),(UBYTE *)(inp)) == 0 ) break;
          }
        }
        if ( i >= AM.SizeForSpectatorFiles ) {
                MesPrint("&Spectator %s not found.",inp);
                return(1);
        }
        if ( ( AM.SpectatorFiles[i].flags & READSPECTATORFLAG ) != 0 ) {
                MesPrint("&Spectator %s: It is not permitted to read from and write to the same spectator in one module.",inp);
                return(1);
        }
        AM.SpectatorFiles[i].exprnumber = numexpr;
        Add3Com(TYPETOSPECTATOR,i);
#ifdef WITHMPI
        /*
         * In ParFORM, ToSpectator has to be executed on the master.
         */
        AC.mparallelflag |= NOPARALLEL_SPECTATOR;
#endif
        return(0);
Syntax:
        MesPrint("&Proper syntax is: ToSpectator,exprname;");
        return(-1);
}

/*
          #] CoToSpectator : 
          #[ CoRemoveSpectator :
*/

int CoRemoveSpectator(UBYTE *inp)
{
        UBYTE *q;
        WORD c1, numexpr;
        int i;
        SPECTATOR *sp;
        while ( *inp == ',' ) inp++;
        if ( ( q = SkipAName(inp) ) == 0 || q[-1] == '_' ) {
                MesPrint("&Illegal name for expression");
                return(1);
        }
        if ( *q != 0 ) goto Syntax;
        if ( GetVar(inp,&c1,&numexpr,ALLVARIABLES,NOAUTO) == NAMENOTFOUND ||
                        c1 != CEXPRESSION ) {
                MesPrint("&%s is not a valid expression.",inp);
                return(1);
        }
        if ( Expressions[numexpr].status != SPECTATOREXPRESSION ) {
                MesPrint("&%s is not a spectator.",inp);
                return(1);
        }
        for ( i = 0; i < AM.SizeForSpectatorFiles; i++ ) {
                if ( AM.SpectatorFiles[i].name != 0 ) {
                        if ( StrCmp((UBYTE *)(AM.SpectatorFiles[i].name),(UBYTE *)(inp)) == 0 ) {
                                break;
                        }
                }
        }
        if ( i >= AM.SizeForSpectatorFiles ) {
                MesPrint("&Spectator %s not found.",inp);
                return(1);
        }
        sp = AM.SpectatorFiles+i;
        Expressions[numexpr].status = DROPSPECTATOREXPRESSION;
        if ( sp->fh->handle != -1 ) {
                CloseFile(sp->fh->handle);
                sp->fh->handle = -1;
                remove(sp->fh->name);
        }
        M_free(sp->fh,"Temporary FileHandle");
        M_free(sp->name,"Spectator expression name");

        PUTZERO(sp->position);
        PUTZERO(sp->readpos);
        sp->fh = 0;
        sp->name = 0;
        sp->exprnumber = -1;
        sp->flags = 0;
        AM.NumSpectatorFiles--;
        return(0);
Syntax:
        MesPrint("&Proper syntax is: RemoveSpectator,exprname;");
        return(-1);
}

/*
          #] CoRemoveSpectator : 
          #[ CoEmptySpectator :
*/

int CoEmptySpectator(UBYTE *inp)
{
        UBYTE *q;
        WORD c1, numexpr;
        int i;
        SPECTATOR *sp;
        while ( *inp == ',' ) inp++;
        if ( ( q = SkipAName(inp) ) == 0 || q[-1] == '_' ) {
                MesPrint("&Illegal name for expression");
                return(1);
        }
        if ( *q != 0 ) goto Syntax;
        if ( GetVar(inp,&c1,&numexpr,ALLVARIABLES,NOAUTO) == NAMENOTFOUND ||
                        c1 != CEXPRESSION ) {
                MesPrint("&%s is not a valid expression.",inp);
                return(1);
        }
        if ( Expressions[numexpr].status != SPECTATOREXPRESSION ) {
                MesPrint("&%s is not a spectator.",inp);
                return(1);
        }
        for ( i = 0; i < AM.SizeForSpectatorFiles; i++ ) {
                if ( StrCmp((UBYTE *)(AM.SpectatorFiles[i].name),(UBYTE *)(inp)) == 0 ) break;
        }
        if ( i >= AM.SizeForSpectatorFiles ) {
                MesPrint("&Spectator %s not found.",inp);
                return(1);
        }
        sp = AM.SpectatorFiles+i;
        if ( sp->fh->handle != -1 ) {
                CloseFile(sp->fh->handle);
                sp->fh->handle = -1;
                remove(sp->fh->name);
        }
        sp->fh->POfill = sp->fh->POfull = sp->fh->PObuffer;
        PUTZERO(sp->position);
        PUTZERO(sp->readpos);
        return(0);
Syntax:
        MesPrint("&Proper syntax is: EmptySpectator,exprname;");
        return(-1);
}

/*
          #] CoEmptySpectator : 
          #[ PutInSpectator :

        We need to use locks! There is only one file.
        The code was copied (and modified) from PutOut.
        Here we use no compression.
*/

int PutInSpectator(WORD *term,WORD specnum)
{
        GETBIDENTITY
        WORD i, *p, ret;
        LONG RetCode;
        SPECTATOR *sp = &(AM.SpectatorFiles[specnum]);
        FILEHANDLE *fi = sp->fh;

        if ( ( i = *term ) <= 0 ) return(0);
        LOCK(fi->pthreadslock);
        ret = i;
        p = fi->POfill;
        do {
                if ( p >= fi->POstop ) {
                        if ( fi->handle < 0 ) {
                                if ( ( RetCode = CreateFile(fi->name) ) >= 0 ) {
                                        fi->handle = (WORD)RetCode;
                                        PUTZERO(fi->filesize);
                                        PUTZERO(fi->POposition);
                                }
                                else {
                                        MLOCK(ErrorMessageLock);
                                        MesPrint("Cannot create spectator file %s",fi->name);
                                        MUNLOCK(ErrorMessageLock);
                                        UNLOCK(fi->pthreadslock);
                                        return(-1);
                                }
                        }
                        SeekFile(fi->handle,&(sp->position),SEEK_SET);
                        if ( ( RetCode = WriteFile(fi->handle,(UBYTE *)(fi->PObuffer),fi->POsize) ) != fi->POsize ) {
                                MLOCK(ErrorMessageLock);
                                MesPrint("Error during spectator write. Disk full?");
                                MesPrint("Attempt to write %l bytes on file %d at position %15p",
                                                        fi->POsize,fi->handle,&(fi->POposition));
                                MesPrint("RetCode = %l, Buffer address = %l",RetCode,(LONG)(fi->PObuffer));
                                MUNLOCK(ErrorMessageLock);
                                UNLOCK(fi->pthreadslock);
                                return(-1);
                        }
                        ADDPOS(fi->filesize,fi->POsize);
                        p = fi->PObuffer;
                        ADDPOS(sp->position,fi->POsize);
                        fi->POposition = sp->position;
                } 
                *p++ = *term++;
        } while ( --i > 0 );
        fi->POfull = fi->POfill = p;
        Expressions[AM.SpectatorFiles[specnum].exprnumber].counter++;
        UNLOCK(fi->pthreadslock);
        return(ret);
}

/*
          #] PutInSpectator : 
          #[ FlushSpectators :
*/

void FlushSpectators(VOID)
{
        SPECTATOR *sp = AM.SpectatorFiles;
        FILEHANDLE *fh;
        LONG RetCode;
        int i;
        LONG size;
        if ( AM.NumSpectatorFiles <= 0 ) return;
        for ( i = 0; i < AM.SizeForSpectatorFiles; i++, sp++ ) {
                if ( sp->name == 0 ) continue;
                fh = sp->fh;
                if ( ( sp->flags & READSPECTATORFLAG ) != 0 ) { /* reset for writing */
                        sp->flags &= ~READSPECTATORFLAG;
                        fh->POfill = fh->PObuffer;
                        if ( fh->handle >= 0 ) {
                                SeekFile(fh->handle,&(sp->position),SEEK_SET);
                                fh->POposition = sp->position;
                        }
                        continue;
                }
                if ( fh->POfill <= fh->PObuffer ) continue; /* is clean */
                if ( fh->handle < 0 ) {        /* File needs to be created */
                        if ( ( RetCode = CreateFile(fh->name) ) >= 0 ) {
                                PUTZERO(fh->filesize);
                                PUTZERO(fh->POposition);
                                fh->handle = (WORD)RetCode;
                        }
                        else {
                                MLOCK(ErrorMessageLock);
                                MesPrint("Cannot create spectator file %s",fh->name);
                                MUNLOCK(ErrorMessageLock);
                                TERMINATE(-1);
                        }
                        PUTZERO(sp->position);
                }
                SeekFile(fh->handle,&(sp->position),SEEK_SET);
                size = (fh->POfill - fh->PObuffer)*sizeof(WORD);
                if ( ( RetCode = WriteFile(fh->handle,(UBYTE *)(fh->PObuffer),size) ) != size ) {
                        MLOCK(ErrorMessageLock);
                        MesPrint("Write error synching spectator file. Disk full?");
                        MesPrint("Attempt to write %l bytes on file %s at position %15p",
                                                size,fh->name,&(sp->position));
                        MUNLOCK(ErrorMessageLock);
                        TERMINATE(-1);
                }
                fh->POfill = fh->PObuffer;
                SeekFile(fh->handle,&(sp->position),SEEK_END);
                fh->POposition = sp->position;
        }
        return;
}

/*
          #] FlushSpectators : 
          #[ CoCopySpectator :
*/

int CoCopySpectator(UBYTE *inp)
{
        GETIDENTITY
        UBYTE *q, c, *exprname, *p;
        WORD c1, c2, numexpr;
        int specnum, error = 0;
        SPECTATOR *sp;
        while ( *inp == ',' ) inp++;
        if ( ( q = SkipAName(inp) ) == 0 || q[-1] == '_' ) {
                MesPrint("&Illegal name for expression");
                return(1);
        }
        if ( *q == 0 ) goto Syntax;
        c = *q; *q = 0;
        if ( GetVar(inp,&c1,&c2,ALLVARIABLES,NOAUTO) != NAMENOTFOUND ) {
                MesPrint("&%s is the name of an existing variable.",inp);
                return(1);
        }
        numexpr = EntVar(CEXPRESSION,inp,LOCALEXPRESSION,0,0,0);
        p = q;
        exprname = inp;
        *q = c;
        while ( *q == ' ' || *q == ',' || *q == '\t' ) q++;
        if ( *q != '=' ) goto Syntax;
        q++;
        while ( *q == ' ' || *q == ',' || *q == '\t' ) q++;
        inp = q;
        if ( ( q = SkipAName(inp) ) == 0 || q[-1] == '_' ) {
                MesPrint("&Illegal name for spectator expression");
                return(1);
        }
        if ( *q != 0 ) goto Syntax;
        if ( AM.NumSpectatorFiles <= 0 ) {
                MesPrint("&CopySpectator: There are no spectator expressions!");
                return(1);
        }
        sp = AM.SpectatorFiles;
        for ( specnum = 0; specnum < AM.SizeForSpectatorFiles; specnum++, sp++ ) {
          if ( sp->name != 0 ) {
                if ( StrCmp((UBYTE *)(sp->name),(UBYTE *)(inp)) == 0 ) break;
          }
        }
        if ( specnum >= AM.SizeForSpectatorFiles ) {
                MesPrint("&Spectator %s not found.",inp);
                return(1);
        }
        sp->flags |= READSPECTATORFLAG;
        PUTZERO(sp->fh->POposition);
        PUTZERO(sp->readpos);
        sp->fh->POfill = sp->fh->PObuffer;
        if ( sp->fh->handle >= 0 ) {
                SeekFile(sp->fh->handle,&(sp->fh->POposition),SEEK_SET);
        }
/*
        Now we have:
        1: The name of the target expression: numexpr
        2: The spectator: sp (or specnum).
        Time for some action. We need:
        a: Write a prototype to create the expression
        b: Signal to Processor that this is a spectator.
           We do this by giving a negative compiler buffer number.
*/
        {
                WORD *OldWork, *w;
                POSITION pos;
                OldWork = w = AT.WorkPointer;
                *w++ = TYPEEXPRESSION;
                *w++ = 3+SUBEXPSIZE;
                *w++ = numexpr;
                AC.ProtoType = w;
                AR.CurExpr = numexpr;                                /* Block expression numexpr */
                *w++ = SUBEXPRESSION;
                *w++ = SUBEXPSIZE;
                *w++ = numexpr;
                *w++ = 1;
                *w++ = -specnum-1;                /* Indicates "spectator" to Processor */
                FILLSUB(w)
                *w++ = 1;
                *w++ = 1;
                *w++ = 3;
                *w++ = 0;
                SeekScratch(AR.outfile,&pos);
                Expressions[numexpr].counter = 1; 
                Expressions[numexpr].onfile = pos; 
                Expressions[numexpr].whichbuffer = 0;
#ifdef PARALLELCODE
                Expressions[numexpr].partodo = AC.inparallelflag; 
#endif
                OldWork[2] = w - OldWork - 3;
                AT.WorkPointer = w;

                if ( PutOut(BHEAD OldWork+2,&pos,AR.outfile,0) < 0 ) {
                        c = *p; *p = 0;
                        MesPrint("&Cannot create expression %s",exprname);
                        *p = c;
                        error = -1;
                }
                else {
                        OldWork[2] = 4+SUBEXPSIZE;
                        OldWork[4] = SUBEXPSIZE;
                        OldWork[5] = numexpr;
                        OldWork[SUBEXPSIZE+3] = 1;
                        OldWork[SUBEXPSIZE+4] = 1;
                        OldWork[SUBEXPSIZE+5] = 3;
                        OldWork[SUBEXPSIZE+6] = 0;
                        if ( PutOut(BHEAD OldWork+2,&pos,AR.outfile,0) < 0
                        || FlushOut(&pos,AR.outfile,0) ) {
                                c = *p; *p = 0;
                                MesPrint("&Cannot create expression %s",exprname);
                                *p = c;
                                error = -1;
                        }
                        AR.outfile->POfull = AR.outfile->POfill;
                }
                OldWork[2] = numexpr;
/*
                Seems unnecessary (13-feb-2018)

                AddNtoL(OldWork[1],OldWork);
*/
                AT.WorkPointer = OldWork;
                if ( AC.dumnumflag ) Add2Com(TYPEDETCURDUM)
        }
#ifdef WITHMPI
        /*
         * In ParFORM, substitutions of spectators has to be done on the master.
         */
        AC.mparallelflag |= NOPARALLEL_SPECTATOR;
#endif
        return(error);
Syntax:
        MesPrint("&Proper syntax is: CopySpectator,exprname=spectatorname;");
        return(-1);
}

/*
          #] CoCopySpectator : 
          #[ GetFromSpectator :

        Note that if we did things right, we do not need a lock for the reading.
*/

WORD GetFromSpectator(WORD *term,WORD specnum)
{
        SPECTATOR *sp = &(AM.SpectatorFiles[specnum]);
        FILEHANDLE *fh = sp->fh;
        WORD i, size, *t = term;
        LONG InIn;
        if ( fh-> handle < 0 ) {
                *term = 0;
                return(0);
        }
/*
        sp->position marks the 'end' of the file: the point where writing should
        take place. sp->readpos marks from where to read.
        fh->POposition marks where the file is currently positioned.
        Note that when we read, we need to 
*/
        if ( ISZEROPOS(sp->readpos) ) {        /* we start reading. Fill buffer. */
FillBuffer:
                SeekFile(fh->handle,&(sp->readpos),SEEK_SET);
                InIn = ReadFile(fh->handle,(UBYTE *)(fh->PObuffer),fh->POsize);
                if ( InIn < 0 || ( InIn & 1 ) ) {
                        MLOCK(ErrorMessageLock);
                        MesPrint("Error reading information for %s spectator",sp->name);
                        MUNLOCK(ErrorMessageLock);
                        TERMINATE(-1);
                }
                InIn /= sizeof(WORD);
                if ( InIn == 0 ) { *term = 0; return(0); }
                SeekFile(fh->handle,&(sp->readpos),SEEK_CUR);
                fh->POposition = sp->readpos;
                fh->POfull = fh->PObuffer+InIn;
                fh->POfill = fh->PObuffer;
        }
        if ( fh->POfill == fh->POfull ) { /* not even the size of the term! */
                if ( ISLESSPOS(sp->readpos,sp->position) ) goto FillBuffer;
                *term = 0;
                return(0);
        }
        size = *fh->POfill++; *t++ = size;
        for ( i = 1; i < size; i++ ) {
                if ( fh->POfill >= fh->POfull ) {
                        SeekFile(fh->handle,&(sp->readpos),SEEK_SET);
                        InIn = ReadFile(fh->handle,(UBYTE *)(fh->PObuffer),fh->POsize);
                        if ( InIn < 0 || ( InIn & 1 ) ) {
                                MLOCK(ErrorMessageLock);
                                MesPrint("Error reading information for %s spectator",sp->name);
                                MUNLOCK(ErrorMessageLock);
                                TERMINATE(-1);
                        }
                        InIn /= sizeof(WORD);
                        if ( InIn == 0 ) {
                                MLOCK(ErrorMessageLock);
                                MesPrint("Reading incomplete information for %s spectator",sp->name);
                                MUNLOCK(ErrorMessageLock);
                                TERMINATE(-1);
                        }
                        SeekFile(fh->handle,&(sp->readpos),SEEK_CUR);
                        fh->POposition = sp->readpos;
                        fh->POfull = fh->PObuffer+InIn;
                        fh->POfill = fh->PObuffer;
                }
                *t++ = *fh->POfill++;
        }
        return(size);
}

/*
          #] GetFromSpectator : 
          #[ ClearSpectators :

        Removes all spectators.
        In case of .store, the ones that are protected by .global stay.
*/

void ClearSpectators(WORD par)
{
        SPECTATOR *sp = AM.SpectatorFiles;
        WORD numexpr, c1;
        int i;
        if ( AM.NumSpectatorFiles > 0 ) {
                for ( i = 0; i < AM.SizeForSpectatorFiles; i++, sp++ ) {
                        if ( sp->name == 0 ) continue;
                        if ( ( sp->flags & GLOBALSPECTATORFLAG ) == 1 && par == STOREMODULE ) continue;

                        if ( GetVar((UBYTE *)(sp->name),&c1,&numexpr,ALLVARIABLES,NOAUTO) == NAMENOTFOUND ||
                                c1 != CEXPRESSION ) {
                                MesPrint("&%s is not a valid expression.",sp->name);
                                continue;
                        }
                        Expressions[numexpr].status = DROPPEDEXPRESSION;
                        if ( sp->fh->handle != -1 ) {
                                CloseFile(sp->fh->handle);
                                sp->fh->handle = -1;
                                remove(sp->fh->name);
                        }
                        M_free(sp->fh,"Temporary FileHandle");
                        M_free(sp->name,"Spectator expression name");
                        PUTZERO(sp->position);
                        sp->fh = 0;
                        sp->name = 0;
                        sp->exprnumber = -1;
                        sp->flags = 0;
                        AM.NumSpectatorFiles--;
                }
        }
}

/*
          #] ClearSpectators : 
*/

vermaseren / form / 9364948935

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