structs.h

Go to the documentation of this file.

 
/* #[ License : */
/*
 *   Copyright (C) 1984-2026 J.A.M. Vermaseren
 *   When using this file you are requested to refer to the publication
 *   J.A.M.Vermaseren "New features of FORM" math-ph/0010025
 *   This is considered a matter of courtesy as the development was paid
 *   for by FOM the Dutch physics granting agency and we would like to
 *   be able to track its scientific use to convince FOM of its value
 *   for the community.
 *
 *   This file is part of FORM.
 *
 *   FORM is free software: you can redistribute it and/or modify it under the
 *   terms of the GNU General Public License as published by the Free Software
 *   Foundation, either version 3 of the License, or (at your option) any later
 *   version.
 *
 *   FORM is distributed in the hope that it will be useful, but WITHOUT ANY
 *   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 *   FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 *   details.
 *
 *   You should have received a copy of the GNU General Public License along
 *   with FORM.  If not, see <http://www.gnu.org/licenses/>.
 */
/* #] License : */ 
 
#ifndef __STRUCTS__
 
#define __STRUCTS__
#ifdef _MSC_VER
#include <wchar.h>  /* off_t */
#endif
 
/*
    #[ sav&store :
*/
 
typedef struct PoSiTiOn {
    off_t p1;
} POSITION;
 
/*  Next are the index structs for stored and saved expressions */
 
typedef struct {
    UBYTE headermark[8];  
    UBYTE lenWORD;        
    UBYTE lenLONG;        
    UBYTE lenPOS;         
    UBYTE lenPOINTER;     
    UBYTE endianness[16]; 
    UBYTE sSym;           
    UBYTE sInd;           
    UBYTE sVec;           
    UBYTE sFun;           
    UBYTE maxpower[16];   
    UBYTE wildoffset[16]; 
    UBYTE revision;       
    UBYTE reserved[512-8-4-16-4-16-16-1]; 
} STOREHEADER;
 
STATIC_ASSERT(sizeof(STOREHEADER) == 512);
 
typedef struct InDeXeNtRy {
    POSITION    position;       
    POSITION    length;         
    POSITION    variables;      
    LONG    CompressSize;       
    WORD    nsymbols;           
    WORD    nindices;           
    WORD    nvectors;           
    WORD    nfunctions;         
    WORD    size;               
    SBYTE   name[MAXENAME+1];   
} INDEXENTRY;
 
#define INFILEINDEX ((512-2*sizeof(POSITION))/sizeof(INDEXENTRY))
#define EMPTYININDEX (512-2*sizeof(POSITION)-INFILEINDEX*sizeof(INDEXENTRY))
 
typedef struct FiLeInDeX {
    POSITION    next;           
    POSITION    number;         
    INDEXENTRY expression[INFILEINDEX]; 
    SBYTE   empty[EMPTYININDEX];        
} FILEINDEX;
 
STATIC_ASSERT(sizeof(FILEINDEX) == 512);
 
typedef struct FiLeDaTa {
    FILEINDEX Index;
    POSITION Fill;
    POSITION Position;
    WORD Handle;
    WORD dirtyflag;
} FILEDATA;
 
typedef struct VaRrEnUm {
    WORD  *start;  
    WORD  *lo;     
    WORD  *hi;     
} VARRENUM;
 
typedef struct ReNuMbEr {
    POSITION   startposition;
    /* First stage renumbering */
    VARRENUM   symb;          
    VARRENUM   indi;          
    VARRENUM   vect;          
    VARRENUM   func;          
    /* Second stage renumbering */
    WORD       *symnum;       
    WORD       *indnum;       
    WORD       *vecnum;       
    WORD       *funnum;       
} *RENUMBER;
 
/*
    #] sav&store : 
    #[ Variables :
*/
 
typedef struct {
    void *lijst;       
    char *message;     
    int num;           
    int maxnum;        
    int size;          
    int numglobal;     
    int numtemp;       
    int numclear;      
} LIST;
 
typedef struct {
    char *name;
    TFUN func;
    int type;
    int flags;
} KEYWORD;
 
typedef struct {
    char *name;
    int *var;
    int type;
    int flags;
} KEYWORDV;
 
typedef struct NaMeNode {
    LONG name;      
    WORD parent;    
    WORD left;      
    WORD right;     
    WORD balance;   
    WORD type;      
    WORD number;    
} NAMENODE;
 
typedef struct NaMeTree {
    NAMENODE *namenode;      
    UBYTE    *namebuffer;    
    LONG     nodesize;       
    LONG     nodefill;       
    LONG     namesize;       
    LONG     namefill;       
    LONG     oldnamefill;    
    LONG     oldnodefill;    
    LONG     globalnamefill; 
    LONG     globalnodefill; 
    LONG     clearnamefill;  
    LONG     clearnodefill;  
    WORD     headnode;       
} NAMETREE;
 
typedef struct tree {
    int parent;  
    int left;    
    int right;   
    int value;   
    int blnce;   
    int usage;   
} COMPTREE;
 
typedef struct MiNmAx {
    WORD mini;          
    WORD maxi;          
    WORD size;          
} MINMAX;
 
typedef struct BrAcKeTiNdEx {   /* For indexing brackets in local expressions */
    POSITION start;             /* Place where bracket starts - start of expr */
    POSITION next;              /* Place of next indexed bracket in expr */
    LONG bracket;               /* Offset of position in bracketbuffer */
    LONG termsinbracket;
} BRACKETINDEX;
 
typedef struct BrAcKeTiNfO {
    BRACKETINDEX *indexbuffer; 
    WORD  *bracketbuffer;      
    LONG  bracketbuffersize;
    LONG  indexbuffersize;
    LONG  bracketfill;
    LONG  indexfill;
    WORD  SortType;            
} BRACKETINFO;
 
typedef struct TaBlEs {
    WORD    *tablepointers; 
#ifdef WITHPTHREADS
    WORD    **prototype;    
    WORD    **pattern;      
#else
    WORD    *prototype;     
    WORD    *pattern;       
#endif
    MINMAX  *mm;            
    WORD    *flags;         
    COMPTREE *boomlijst;    
    UBYTE   *argtail;       
    struct TaBlEs *spare;   
    WORD    *buffers;       
    LONG    totind;         
    LONG    reserved;       
    LONG    defined;        
    LONG    mdefined;       
    int     prototypeSize;  
    int     numind;         
    int     bounds;         
    int     strict;         
    int     sparse;         
    int     numtree;        
    int     rootnum;        
    int     MaxTreeSize;    
    WORD    bufnum;         
    WORD    bufferssize;    
    WORD    buffersfill;    
    WORD    tablenum;       
    WORD    mode;           
    WORD    numdummies;     
} *TABLES;
 
typedef struct ExPrEsSiOn {
    POSITION    onfile;
    POSITION    prototype;
    POSITION    size;
    RENUMBER renum;         /* For Renumbering of global stored expressions */
    BRACKETINFO *bracketinfo;
    BRACKETINFO *newbracketinfo;
    WORD    *renumlists;    
    WORD    *inmem;         /* If in memory like e.g. a polynomial */
    LONG    counter;
    LONG    name;
    WORD    hidelevel;
    WORD    vflags;         /* Various flags */
    WORD    printflag;
    WORD    status;
    WORD    replace;
    WORD    node;
    WORD    whichbuffer;
    WORD    namesize;
    WORD    compression;
    WORD    numdummies;
    WORD    numfactors;
    WORD    sizeprototype;
    WORD    uflags;         /* User flags */
#ifdef PARALLELCODE
    WORD    partodo;        /* Whether to be done in parallel mode */
#endif
} *EXPRESSIONS;
 
typedef struct SyMbOl {         /* Don't change unless altering .sav too */
    LONG    name;               /* Location in names buffer */
    WORD    minpower;           /* Minimum power admissible */
    WORD    maxpower;           /* Maximum power admissible */
    WORD    complex;            /* Properties wrt complex conjugation */
    WORD    number;             /* Number when stored in file */
    WORD    flags;              /* Used to indicate usage when storing */
    WORD    node;
    WORD    namesize;
    WORD    dimension;          /* For dimensionality checks */
#if BITSINWORD == 32
    UBYTE d_u_m_m_y[8];     /* Padding for sav compatibility */
#elif BITSINWORD == 16
    UBYTE d_u_m_m_y[4];     /* Padding for sav compatibility */
#endif
} *SYMBOLS;
#if BITSINWORD == 32
STATIC_ASSERT(sizeof(struct SyMbOl) == 48);
#elif BITSINWORD == 16
STATIC_ASSERT(sizeof(struct SyMbOl) == 24);
#endif
 
typedef struct InDeX {          /* Don't change unless altering .sav too */
    LONG    name;               /* Location in names buffer */
    WORD    type;               /* Regular or dummy */
    WORD    dimension;          /* Value of d_(n,n) or -number of symbol */
    WORD    number;             /* Number when stored in file */
    WORD    flags;              /* Used to indicate usage when storing */
    WORD    nmin4;              /* Used for n-4 if dimension < 0 */
    WORD    node;
    WORD    namesize;
} *INDICES;
#if BITSINWORD == 32
STATIC_ASSERT(sizeof(struct InDeX) == 40);
#elif BITSINWORD == 16
STATIC_ASSERT(sizeof(struct InDeX) == 20);
#endif
 
typedef struct VeCtOr {         /* Don't change unless altering .sav too */
    LONG    name;               /* Location in names buffer */
    WORD    complex;            /* Properties under complex conjugation */
    WORD    number;             /* Number when stored in file */
    WORD    flags;              /* Used to indicate usage when storing */
    WORD    node;
    WORD    namesize;
    WORD    dimension;          /* For dimensionality checks */
#if BITSINWORD == 32
    UBYTE d_u_m_m_y[8];     /* Padding for sav compatibility */
#elif BITSINWORD == 16
    UBYTE d_u_m_m_y[4];     /* Padding for sav compatibility */
#endif
} *VECTORS;
#if BITSINWORD == 32
STATIC_ASSERT(sizeof(struct VeCtOr) == 40);
#elif BITSINWORD == 16
STATIC_ASSERT(sizeof(struct VeCtOr) == 20);
#endif
 
typedef struct FuNcTiOn {  /* Don't change unless altering .sav too */
    TABLES  tabl;          
    LONG    symminfo;      
    LONG    name;          
    WORD    commute;       
    WORD    complex;       
    WORD    number;        
    WORD    flags;         
    WORD    spec;          
    WORD    symmetric;     
    WORD    node;          
    WORD    namesize;      
    WORD    dimension;     /* For dimensionality checks */
    WORD    maxnumargs;
    WORD    minnumargs;
} *FUNCTIONS;
#if BITSINWORD == 32
STATIC_ASSERT(sizeof(struct FuNcTiOn) == 72);
#elif BITSINWORD == 16
STATIC_ASSERT(sizeof(struct FuNcTiOn) == 36);
#endif
 
typedef struct SeTs {
    LONG    name;               /* Location in names buffer */
    WORD    type;               /* Symbol, vector, index or function */
    WORD    first;              /* First element in setstore */
    WORD    last;               /* Last element in setstore (excluding) */
    WORD    node;
    WORD    namesize;
    WORD    dimension;          /* For dimensionality checks */
    WORD    flags;              /* Like: ordered */
} *SETS;
 
typedef struct DuBiOuS {        /* Undeclared objects. Just for compiler. */
    LONG    name;               /* Location in names buffer */
    WORD    node;
    WORD    dummy;
} *DUBIOUSV;
 
typedef struct FaCdOlLaR {
    WORD    *where;             /* A pointer(!) to the content */
    LONG    size;
    WORD    type;               /* Type can be DOLNUMBER or DOLTERMS */
    WORD    value;              /* in case it is a (short) number */
} FACDOLLAR;
 
typedef struct DoLlArS {
    WORD    *where;             /* A pointer(!) to the object */
    FACDOLLAR *factors;         /* an array of factors. nfactors elements */
#ifdef WITHPTHREADS
    pthread_mutex_t pthreadslock;
#endif
    LONG    size;               /* The number of words */
    LONG    name;
    WORD    type;
    WORD    node;
    WORD    index;
    WORD    zero;
    WORD    numdummies;
    WORD    nfactors;
} *DOLLARS;
 
typedef struct MoDoPtDoLlArS {
#ifdef WITHPTHREADS
    DOLLARS dstruct;    /* If local dollar: list of DOLLARS for each thread */
#endif
    WORD    number;
    WORD    type;
} MODOPTDOLLAR;
 
typedef struct fixedset {
    char *name;
    char *description;
    int type;
    int dimension;
} FIXEDSET;
 
typedef struct TaBlEbAsEsUbInDeX {
    POSITION where;
    LONG size;
} TABLEBASESUBINDEX;
 
typedef struct TaBlEbAsE {
    POSITION fillpoint;
    POSITION current;
    UBYTE *name;
    int *tablenumbers;      /* Number of each table */
    TABLEBASESUBINDEX *subindex;        /* For each table */
    int numtables;
} TABLEBASE;
 
typedef struct {
    WORD *location;
    int numargs;
    int numfunnies;
    int numwildcards;
    int symmet;
    int tensor;
    int commute;
} FUN_INFO;
 
typedef struct PaRtIcLe {
    WORD number; /* Number of the function */
    WORD spin;   /* +/- dimension of SU(2) representation */
    WORD mass;   /* Number of symbol or 0 */
    WORD type;   /* -1: anti particle, 1: particle, 0: own antiparticle */
} PARTICLE;
 
typedef struct VeRtEx {
    PARTICLE particles[MAXPARTICLES];
    WORD couplings[2*MAXCOUPLINGS];
    WORD nparticles;
    WORD ncouplings;
    WORD type;
    WORD error;
    WORD externonly;
    WORD spare;
} VERTEX;
 
typedef struct MoDeL {
    VERTEX **vertices;
    WORD *couplings;
    UBYTE *name;
    void *grccmodel;
    WORD legcouple[MAXLEGS+2];
    WORD nparticles;
    WORD nvertices;
    WORD invertices;
    WORD sizevertices;
    WORD sizecouplings;
    WORD ncouplings;
    WORD error;
    WORD dummy;
} MODEL;
 
/*
 *  The struct NAMESPACE is used for the namespace info. It is a
 *  doubly linked list of nested namespaces.
 */
 
typedef struct NaMeSpAcE {
    struct NaMeSpAcE *previous;
    struct NaMeSpAcE *next;
    NAMETREE  *usenames;
    UBYTE     *name;
} NAMESPACE;
 
 
/*
    #] Variables : 
    #[ Files :
*/
 
typedef struct FiLe {
    POSITION POposition;        /* File position */
    POSITION filesize;          /* Because SEEK_END is unsafe on IBM */
    WORD *PObuffer;             /* Address of the intermediate buffer */
    WORD *POstop;               /* End of the buffer */
    WORD *POfill;               /* Fill position of the buffer */
    WORD *POfull;               /* Full buffer when only cached */
#ifdef WITHPTHREADS
    WORD *wPObuffer;             /* Address of the intermediate worker buffer */
    WORD *wPOstop;               /* End of the worker buffer */
    WORD *wPOfill;               /* Fill position of the worker buffer */
    WORD *wPOfull;               /* Full buffer when only worker cached */
#endif
    char *name;                 /* name of the file */
#ifdef WITHZLIB
    z_streamp zsp;              /* The pointer to the stream struct for gzip */
    Bytef *ziobuffer;           /* The output buffer for compression */
#endif
    ULONG numblocks;            /* Number of blocks in file */
    ULONG inbuffer;             /* Block in the buffer */
    LONG POsize;                /* size of the buffer */
#ifdef WITHZLIB
    LONG ziosize;               /* size of the zoutbuffer */
#endif
#ifdef WITHPTHREADS
    LONG wPOsize;                /* size of the worker buffer */
    pthread_mutex_t pthreadslock;
#endif
    int handle;                 
    int active;                 /* File is open or closed. Not used. */
} FILEHANDLE;
 
typedef struct StreaM {
    off_t fileposition;
    off_t linenumber;
    off_t prevline;
    UBYTE *buffer;        
    UBYTE *pointer;       
    UBYTE *top;           
    UBYTE *FoldName;      
    UBYTE *name;          
    UBYTE *pname;         
    LONG buffersize;
    LONG bufferposition;
    LONG inbuffer;
    int previous;
    int handle;
    int type;
    int prevars;
    int previousNoShowInput;
    int eqnum;
    int afterwards;
    int olddelay;
    int oldnoshowinput;
    UBYTE isnextchar;
    UBYTE nextchar[2];
    UBYTE reserved;
} STREAM;
 
typedef struct SpecTatoR {
    POSITION position;   /* The place where we will be writing */
    POSITION readpos;    /* The place from which we read */
    FILEHANDLE *fh;
    char *name;          /* We identify the spectator by the name of the expression */
    WORD exprnumber;     /* During running we use the number. */
    WORD flags;          /* local, global? */
} SPECTATOR;
 
/*
    #] Files : 
    #[ Traces :
*/
 
typedef struct TrAcEs {         /* For computing 4 dimensional traces */
    WORD        *accu;      /* NUMBER * 2 */
    WORD        *accup;
    WORD        *termp;
    WORD        *perm;      /* number */
    WORD        *inlist;    /* number */
    WORD        *nt3;       /* number/2 */
    WORD        *nt4;       /* number/2 */
    WORD        *j3;        /* number*2 */
    WORD        *j4;        /* number*2 */
    WORD        *e3;        /* number*2 */
    WORD        *e4;        /* number */
    WORD        *eers;      /* number/2 */
    WORD        *mepf;      /* number/2 */
    WORD        *mdel;      /* number/2 */
    WORD        *pepf;      /* number*2 */
    WORD        *pdel;      /* number*3/2 */
    WORD        sgn;
    WORD        stap;
    WORD        step1,kstep,mdum;
    WORD        gamm,ad,a3,a4,lc3,lc4;
    WORD        sign1,sign2,gamma5,num,level,factor,allsign;
    WORD        finalstep;
} TRACES;
 
typedef struct TrAcEn {         /* For computing n dimensional traces */
    WORD        *accu;      /* NUMBER */
    WORD        *accup;
    WORD        *termp;
    WORD        *perm;      /* number */
    WORD        *inlist;    /* number */
    WORD        sgn,num,level,factor,allsign;
} *TRACEN;
 
/*
    #] Traces : 
    #[ Preprocessor :
*/
 
typedef struct pReVaR {
    UBYTE *name;        
    UBYTE *value;       
    UBYTE *argnames;    
    int nargs;          
    int wildarg;        
} PREVAR;
 
typedef struct {
    WORD *buffer;
    int oldcompiletype;
    int oldparallelflag;
    int oldnumpotmoddollars;
    WORD size;
    WORD numdollars;
    WORD oldcbuf;
    WORD oldrbuf;
    WORD inscbuf;
    WORD oldcnumlhs;
} INSIDEINFO;
 
typedef struct {
    UBYTE   *buffer;
    LONG    size;
} PRELOAD;
 
typedef struct {
    PRELOAD p;
    UBYTE   *name;
    int     loadmode;
    int     mustfree;
} PROCEDURE;
 
typedef struct DoLoOp {
    PRELOAD p;          
    UBYTE *name;        
    UBYTE *vars;        /* for {} or name of expression */
    UBYTE *contents;
    UBYTE *dollarname;  
    LONG startlinenumber;
    LONG firstnum;
    LONG lastnum;
    LONG incnum;
    int type;
    int NoShowInput;
    int errorsinloop;
    int firstloopcall;
    WORD firstdollar;   /* When >= 0 we have to get the value from a dollar */
    WORD lastdollar;    /* When >= 0 we have to get the value from a dollar */
    WORD incdollar;     /* When >= 0 we have to get the value from a dollar */
    WORD NumPreTypes;
    WORD PreIfLevel;
    WORD PreSwitchLevel;
} DOLOOP;
 
struct  bit_field { /* Assume 8 bits per byte */
    UBYTE bit_0        : 1;
    UBYTE bit_1        : 1;
    UBYTE bit_2        : 1;
    UBYTE bit_3        : 1;
    UBYTE bit_4        : 1;
    UBYTE bit_5        : 1;
    UBYTE bit_6        : 1;
    UBYTE bit_7        : 1;
/*
    UINT bit_0        : 1;
    UINT bit_1        : 1;
    UINT bit_2        : 1;
    UINT bit_3        : 1;
    UINT bit_4        : 1;
    UINT bit_5        : 1;
    UINT bit_6        : 1;
    UINT bit_7        : 1;
*/
};
 
typedef struct bit_field set_of_char[32];
 
typedef struct bit_field *one_byte;
 
typedef struct {
    WORD newlogonly;
    WORD newhandle;
    WORD oldhandle;
    WORD oldlogonly;
    WORD oldprinttype;
    WORD oldsilent;
} HANDLERS;
 
/*
    #] Preprocessor : 
    #[ Varia :
*/
 
typedef int (*FINISHUFFLE)(WORD *);
typedef int (*DO_UFFLE)(WORD *,WORD,WORD,WORD);
 
#ifdef WITHPTHREADS
typedef WORD (*COMPAREDUMMY)(void *,WORD *,WORD *,WORD);
#else
typedef WORD (*COMPAREDUMMY)(WORD *,WORD *,WORD);
#endif
 
typedef struct CbUf {
    WORD *Buffer;         
    WORD *Top;            
    WORD *Pointer;        
    WORD **lhs;           
    WORD **rhs;           
    LONG *CanCommu;       
    LONG *NumTerms;       
    WORD *numdum;         
    WORD *dimension;      
    COMPTREE *boomlijst;  
    LONG BufferSize;      
    int numlhs;
    int numrhs;
    int maxlhs;
    int maxrhs;
    int mnumlhs;
    int mnumrhs;
    int numtree;
    int rootnum;
    int MaxTreeSize;
} CBUF;
 
typedef struct ChAnNeL {
    char *name;          
    int handle;          
} CHANNEL;
 
typedef struct {
    UBYTE *parameter;
    int type;
    int flags;
    // This ordering is assumed by initializer lists in many places. In this
    // case the struct should anyway not have additional padding between the
    // two int and the LONG members.
    LONG value;
} SETUPPARAMETERS;
 
typedef struct NeStInG {
    WORD *termsize;
    WORD *funsize;
    WORD *argsize;
} *NESTING;
 
typedef struct StOrEcAcHe {
    POSITION position;
    POSITION toppos;
    struct StOrEcAcHe *next;
    WORD buffer[2];
} *STORECACHE;
 
typedef struct PeRmUtE {
    WORD *objects;
    WORD sign;
    WORD n;
    WORD cycle[MAXMATCH];
} PERM;
 
typedef struct PeRmUtEp {
    WORD **objects;
    WORD sign;
    WORD n;
    WORD cycle[MAXMATCH];
} PERMP;
 
typedef struct DiStRiBuTe {
    WORD *obj1;
    WORD *obj2;
    WORD *out;
    WORD sign;
    WORD n1;
    WORD n2;
    WORD n;
    WORD cycle[MAXMATCH];
} DISTRIBUTE;
 
typedef struct PaRtI {
    WORD *psize;  /* the sizes of the partitions */
    WORD *args;   /* the offsets of the arguments to be partitioned */
    WORD *nargs;  /* argument numbers (different number = different argument) */
    WORD *nfun;   /* the functions into which the partitions go */
    WORD numargs; /* the number of arguments to be partitioned */
    WORD numpart; /* the number of partitions */
    WORD where;   /* offset of the function in the term */
} PARTI;
 
typedef struct sOrT {
    FILEHANDLE file;            /* The own sort file */
    POSITION SizeInFile[3];     /* Sizes in the various files */
    WORD *lBuffer;              /* The large buffer */
    WORD *lTop;                 /* End of the large buffer */
    WORD *lFill;                /* The filling point of the large buffer */
    WORD *used;                 /*  auxiliary during actual sort */
    WORD *sBuffer;              /* The small buffer */
    WORD *sTop;                 /* End of the small buffer */
    WORD *sTop2;                /* End of the extension of the small buffer */
    WORD *sHalf;                /* Halfway point in the extension */
    WORD *sFill;                /* Filling point in the small buffer */
    WORD **sPointer;            /* Pointers to terms in the small buffer */
    WORD **PoinFill;            /* Filling point for pointers to the sm.buf */
    WORD *cBuffer;              /* Compress buffer (if it exists) */
    WORD **Patches;             /* Positions of patches in large buffer */
    WORD **pStop;               /* Ends of patches in the large buffer */
    WORD **poina;               /*  auxiliary during actual sort */
    WORD **poin2a;              /*  auxiliary during actual sort */
    WORD *ktoi;                 /*  auxiliary during actual sort */
    WORD *tree;                 /*  auxiliary during actual sort */
#ifdef WITHZLIB
    WORD *fpcompressed;         /*  is output filepatch compressed? */
    WORD *fpincompressed;       /*  is input filepatch compressed? */
    z_streamp zsparray;         /*  the array of zstreams for decompression */
#endif
    POSITION *fPatches;         /* Positions of output file patches */
    POSITION *inPatches;        /* Positions of input file patches */
    POSITION *fPatchesStop;     /* Positions of output file patches */
    POSITION *iPatches;         /* Input file patches, Points to fPatches or inPatches */
    FILEHANDLE *f;              /* The actual output file */
    FILEHANDLE **ff;            /* Handles for a staged sort */
    LONG sTerms;                /* Terms in small buffer */
    LONG LargeSize;             /* Size of large buffer (in words) */
    LONG SmallSize;             /* Size of small buffer (in words) */
    LONG SmallEsize;            /* Size of small + extension (in words) */
    LONG TermsInSmall;          /* Maximum number of terms in small buffer */
    LONG Terms2InSmall;         /* with extension for polyfuns etc. */
    LONG GenTerms;              /* Number of generated terms */
    LONG TermsLeft;             /* Number of terms still in existence */
    LONG GenSpace;              /* Amount of space of generated terms */
    LONG SpaceLeft;             /* Space needed for still existing terms */
    LONG putinsize;             /* Size of buffer in putin */
    LONG ninterms;              /* Which input term ? */
    LONG verbComparisons;       /* Counters for "On SortVerbose;" statistics */
    LONG verbSBsortTerms;
    LONG verbSBsortCap;
    LONG verbLBsortPatches;
    LONG verbLBsortCap;
    LONG verbUnsortedSize;
    int MaxPatches;             /* Maximum number of patches in large buffer */
    int MaxFpatches;            /* Maximum number of patches in one filesort */
    int type;                   /* Main, function or sub(routine) */
    int lPatch;                 /* Number of patches in the large buffer */
    int fPatchN1;               /* Number of patches in input file */
    int PolyWise;               /* Is there a polyfun and if so, where? */
    int PolyFlag;               /*  */
    int cBufferSize;            /* Size of the compress buffer */
    int maxtermsize;            /* Keeps track for buffer allocations */
    int newmaxtermsize;         /* Auxiliary for maxtermsize */
    int outputmode;             /* Tells where the output is going */
    int stagelevel;             /* In case we have a 'staged' sort */
    WORD fPatchN;               /* Number of patches on file (output) */
    WORD inNum;                 /* Number of patches on file (input) */
    WORD stage4;                /* Are we using stage4? */
} SORTING;
 
#ifdef WITHPTHREADS
 
typedef struct SoRtBlOcK {
    pthread_mutex_t *MasterBlockLock;
    WORD    **MasterStart;
    WORD    **MasterFill;
    WORD    **MasterStop;
    LONG    *BlockTerms;
    int     MasterNumBlocks;
    int     MasterBlock;
    int     FillBlock;
} SORTBLOCK;
#endif
 
#ifdef DEBUGGER
typedef struct DeBuGgInG {
    int eflag;
    int printflag;
    int logfileflag;
    int stdoutflag;
} DEBUGSTR;
#endif
 
#ifdef WITHPTHREADS
 
typedef struct ThReAdBuCkEt {
    POSITION *deferbuffer;      /* For Keep Brackets: remember position */
    WORD *threadbuffer;         /* Here are the (primary) terms */
    WORD *compressbuffer;       /* For keep brackets we need the compressbuffer */
    LONG threadbuffersize;      /* Number of words in threadbuffer */
    LONG ddterms;               /* Number of primary+secondary terms represented */
    LONG firstterm;             /* The number of the first term in the bucket */
    LONG firstbracket;          /* When doing complete brackets */
    LONG lastbracket;           /* When doing complete brackets */
    pthread_mutex_t lock;       /* For the load balancing phase */
    int  free;                  /* Status of the bucket */
    int  totnum;                /* Total number of primary terms */
    int  usenum;                /* Which is the term being used at the moment */
    int  busy;                  /*  */
    int  type;                  /* Doing brackets? */
} THREADBUCKET;
 
#endif
 
typedef struct {
    WORD    *coefs;             /* The array of coefficients */
    WORD    numsym;             /* The number of the symbol in the polynomial */
    WORD    arraysize;          /* The size of the allocation of coefs */
    WORD    polysize;           /* The maximum power in the polynomial */
    WORD    modnum;             /* The prime number of the modulus */
} POLYMOD;
 
typedef struct {
    WORD    *outterm;            /* Used in DoShuffle/Merge/FinishShuffle system */
    WORD    *outfun;
    WORD    *incoef;
    WORD    *stop1;
    WORD    *stop2;
    WORD    *ststop1;
    WORD    *ststop2;
    FINISHUFFLE finishuf;
    DO_UFFLE    do_uffle;
    LONG    combilast;
    WORD    nincoef;
    WORD    level;
    WORD    thefunction;
    WORD    option;
} SHvariables;
 
typedef struct {                /* Used for computing calculational cost in optim.c */
    LONG    add;
    LONG    mul;
    LONG    div;
    LONG    pow;
} COST;
 
typedef struct {
    UWORD   *a;     /* The number array */
    UWORD   *m;     /* The modulus array */
    WORD    na;     /* Size of the number */
    WORD    nm;     /* size of the number in the modulus array */
} MODNUM;
 
/*
    Struct for optimizing outputs. If changed, do not forget to change
    the padding information in the AO struct.
*/
typedef struct {
    union { /* we do this to allow padding */
        float fval;
        int ival[2]; /* This should be enough */
    } mctsconstant;
    int   horner;
    int   hornerdirection;
    int   method;
    int   mctstimelimit;
    int   mctsnumexpand;
    int   mctsnumkeep;
    int   mctsnumrepeat;
    int   greedytimelimit;
    int   greedyminnum;
    int   greedymaxperc;
    int   printstats;
    int   debugflags;
    int   schemeflags;
    int   mctsdecaymode;
    int   saIter; /* Simulated annealing updates */
    union {
        float fval;
        int ival[2];
    } saMaxT; /* Maximum temperature of SA */
    union {
        float fval;
        int ival[2];
    } saMinT; /* Minimum temperature of SA */
    int    spare;
} OPTIMIZE;
 
typedef struct {
    WORD  *code;
    UBYTE *nameofexpr;  /* It is easier to remember an expression by name */
    LONG  codesize;     /* We need this for the checkpoints */
    WORD  exprnr;       /* Problem here is: we renumber them in execute.c */
    WORD  minvar;
    WORD  maxvar;
} OPTIMIZERESULT;
 
typedef struct {
    WORD *lhs;      /* Object to be replaced */
    WORD *rhs;      /* Depending on the type it will be UBYTE* or WORD* */
    int type;
    int size;       /* Size of the lhs */
} DICTIONARY_ELEMENT;
 
typedef struct {
    DICTIONARY_ELEMENT **elements;
    UBYTE *name;
    int sizeelements;
    int numelements;
    int numbers;        /* deal with numbers */
    int variables;      /* deal with single variables */
    int characters;     /* deal with special characters */
    int funwith;        /* deal with functions with arguments */
    int gnumelements;   /* if .global shrinks the dictionary */
    int ranges;
} DICTIONARY;
 
typedef struct {
    WORD ncase;
    WORD value;
    WORD compbuffer;
} SWITCHTABLE;
 
typedef struct {
    SWITCHTABLE *table;
    SWITCHTABLE defaultcase;
    SWITCHTABLE endswitch;
    WORD typetable;
    WORD maxcase;
    WORD mincase;
    WORD numcases;
    WORD tablesize;
    WORD caseoffset;
    WORD iflevel;
    WORD whilelevel;
    WORD nestingsum;
    WORD padding;
} SWITCH;
 
typedef struct {
    WORD *term;
    void *currentModel;
    void *currentMODEL;
    WORD *legcouple[MAXLEGS+1];
    LONG numtopo;
    LONG numdia;
    WORD diaoffset;
    WORD level;
    WORD externalset;
    WORD internalset;
    WORD numextern;
    WORD flags;
} TERMINFO;
 
/*
    Struct to hold temporary data in Normalize, so that it is not allocated
    on the stack each function call. The sizes of these arrays introduces a
    maximum complexity of terms which can be normalized. Each array is
    allocated dynamically, by AllocNormData, such that valgrind can detect
    errors if they are over-run.
*/
typedef struct NoRmDaTa {
    WORD  *psym;
    WORD  *pvec;
    WORD  *pdot;
    WORD  *pdel;
    WORD  *pind;
    WORD **peps;
    WORD **pden;
    WORD **pcom;
    WORD **pnco;
    WORD **pcon;
} NORMDATA;
 
/*
    #] Varia : 
    #[ A :
        #[ M : The M struct is for global settings at startup or .clear
*/
 
struct M_const {
    POSITION zeropos;              /* (M) is zero */
    SORTING *S0;                   
    UWORD   *gcmod;                
    UWORD   *gpowmod;              
    UBYTE   *TempDir;              /* (M) Path with where the temporary files go */
    UBYTE   *TempSortDir;          /* (M) Path with where the sort files go */
    UBYTE   *IncDir;               /* (M) Directory path for include files */
    UBYTE   *InputFileName;        /* (M) */
    UBYTE   *LogFileName;          /* (M) */
    UBYTE   *OutBuffer;            /* (M) Output buffer in pre.c */
    UBYTE   *Path;                 /* (M) */
    UBYTE   *SetupDir;             /* (M) Directory with setup file */
    UBYTE   *SetupFile;            /* (M) Name of setup file */
    UBYTE   *gFortran90Kind;
    UBYTE   *gextrasym;
    UBYTE   *ggextrasym;
    UBYTE   *oldnumextrasymbols;
    SPECTATOR *SpectatorFiles;
#ifdef WITHPTHREADS
    pthread_rwlock_t handlelock;   /* (M) */
    pthread_mutex_t storefilelock; /* (M) */
    pthread_mutex_t sbuflock;      /* (M) Lock for writing in the AM.sbuffer */
    LONG    ThreadScratSize;       /* (M) Size of Fscr[0/2] buffers of the workers */
    LONG    ThreadScratOutSize;    /* (M) Size of Fscr[1] buffers of the workers */
#endif
    LONG    MaxTer;                /* (M) Maximum term size. Fixed at setup. In Bytes!!!*/
    LONG    CompressSize;          /* (M) Size of Compress buffer */
    LONG    ScratSize;             /* (M) Size of Fscr[] buffers */
    LONG    HideSize;              /* (M) Size of Fscr[2] buffer */
    LONG    SizeStoreCache;        /* (M) Size of the caches for reading global expr. */
    LONG    MaxStreamSize;         /* (M) Maximum buffer size in reading streams */
    LONG    SIOsize;               /* (M) Sort InputOutput buffer size */
    LONG    SLargeSize;            /* (M) */
    LONG    SSmallEsize;           /* (M) */
    LONG    SSmallSize;            /* (M) */
    LONG    STermsInSmall;         /* (M) */
    LONG    MaxBracketBufferSize;  /* (M) Max Size for B+ or AB+ per expression */
    LONG    hProcessBucketSize;    /* (M) */
    LONG    gProcessBucketSize;    /* (M) */
    LONG    shmWinSize;            /* (M) size for shared memory window used in communications */
    LONG    OldChildTime;          /* (M) Zero time. Needed in timer. */
    LONG    OldSecTime;            /* (M) Zero time for measuring wall clock time */
    LONG    OldMilliTime;          /* (M) Same, but milli seconds */
    LONG    WorkSize;              /* (M) Size of WorkSpace */
    LONG    gThreadBucketSize;     /* (C) */
    LONG    ggThreadBucketSize;    /* (C) */
    LONG    SumTime;               /*     Used in .clear */
    LONG    SpectatorSize;         /*     Size of the buffer in bytes */
    LONG    TimeLimit;             /*     Limit in sec to the total real time */
#ifdef WITHFLOAT
    LONG    gDefaultPrecision;     /* (M) Default precision in bits for float_ */
    LONG    gMaxWeight;            /* (M) Maximum weight for MZV or Euler */
    LONG    ggDefaultPrecision;    /* (M) Default precision in bits for float_ */
    LONG    ggMaxWeight;           /* (M) Maximum weight for MZV or Euler */
#endif
    int     FileOnlyFlag;          /* (M) Writing only to file */
    int     Interact;              /* (M) Interactive mode flag */
    int     MaxParLevel;           /* (M) Maximum nesting of parentheses */
    int     OutBufSize;            /* (M) size of OutBuffer */
    int     SMaxFpatches;          /* (M) */
    int     SMaxPatches;           /* (M) */
    int     StdOut;                /* (M) Regular output channel */
    int     ginsidefirst;          /* (M) Not used yet */
    int     gDefDim;               /* (M) */
    int     gDefDim4;              /* (M) */
    int     NumFixedSets;          /* (M) Number of the predefined sets */
    int     NumFixedFunctions;     /* (M) Number of built in functions */
    int     rbufnum;               /* (M) startup compiler buffer */
    int     dbufnum;               /* (M) dollar variables */
    int     sbufnum;               /* (M) subterm variables */
    int     zbufnum;               /* (M) special values */
    int     SkipClears;            /* (M) Number of .clear to skip at start */
    int     gTokensWriteFlag;      /* (M) */
    int     gfunpowers;            /* (M) */
    int     gStatsFlag;            /* (M) */
    int     gNamesFlag;            /* (M) */
    int     gCodesFlag;            /* (M) */
    int     gSortType;             /* (M) */
    int     gproperorderflag;      /* (M) */
    int     hparallelflag;         /* (M) */
    int     gparallelflag;         /* (M) */
    int     totalnumberofthreads;  /* (M) */
    int     gSizeCommuteInSet;
    int     gThreadStats;
    int     ggThreadStats;
    int     gFinalStats;
    int     ggFinalStats;
    int     gThreadsFlag;
    int     ggThreadsFlag;
    int     gThreadBalancing;
    int     ggThreadBalancing;
    int     gThreadSortFileSynch;
    int     ggThreadSortFileSynch;
    int     gProcessStats;
    int     ggProcessStats;
    int     gOldParallelStats;
    int     ggOldParallelStats;
    int     maxFlevels;            /* () maximum function levels */
    int     resetTimeOnClear;      /* (M) */
    int     gcNumDollars;          /* () number of dollars for .clear */
    int     MultiRun;
    int     gNoSpacesInNumbers;    /* For very long numbers */
    int     ggNoSpacesInNumbers;   /* For very long numbers */
    int     gIsFortran90;
    int     PrintTotalSize;
    int     fbuffersize;           /* Size for the AT.fbufnum factorization caches */
    int     gOldFactArgFlag;
    int     ggOldFactArgFlag;
    int     gnumextrasym;
    int     ggnumextrasym;
    int     NumSpectatorFiles;     /* Elements used in AM.spectatorfiles; */
    int     SizeForSpectatorFiles; /* Size in AM.spectatorfiles; */
    int     gOldGCDflag;
    int     ggOldGCDflag;
    int     gWTimeStatsFlag;
    int     ggWTimeStatsFlag;
    int     jumpratio;
    WORD    MaxTal;                /* (M) Maximum number of words in a number */
    WORD    IndDum;                /* (M) Basis value for dummy indices */
    WORD    DumInd;                /* (M) */
    WORD    WilInd;                /* (M) Offset for wildcard indices */
    WORD    gncmod;                /* (M) Global setting of modulus. size of gcmod */
    WORD    gnpowmod;              /* (M) Global printing as powers. size gpowmod */
    WORD    gmodmode;              /* (M) Global mode for modulus */
    WORD    gUnitTrace;            /* (M) Global value of Tr[1] */
    WORD    gOutputMode;           /* (M) */
    WORD    gOutputSpaces;         /* (M) */
    WORD    gOutNumberType;        /* (M) */
    WORD    gCnumpows;             /* (M) */
    WORD    gUniTrace[4];          /* (M) */
    WORD    MaxWildcards;          /* (M) Maximum number of wildcards */
    WORD    mTraceDum;             /* (M) Position/Offset for generated dummies */
    WORD    OffsetIndex;           /* (M) */
    WORD    OffsetVector;          /* (M) */
    WORD    RepMax;                /* (M) Max repeat levels */
    WORD    LogType;               /* (M) Type of writing to log file */
    WORD    ggStatsFlag;           /* (M) */
    WORD    gLineLength;           /* (M) */
    WORD    qError;                /* (M) Only error checking {-c option} */
    WORD    FortranCont;           /* (M) Fortran Continuation character */
    WORD    HoldFlag;              /* (M) Exit on termination? */
    WORD    Ordering[15];          /* (M) Auxiliary for ordering wildcards */
    WORD    silent;                /* (M) Silent flag. Only results in output. */
    WORD    tracebackflag;         /* (M) For tracing errors */
    WORD    expnum;                /* (M) internal number of ^ function */
    WORD    denomnum;              /* (M) internal number of / function */
    WORD    facnum;                /* (M) internal number of fac_ function */
    WORD    invfacnum;             /* (M) internal number of invfac_ function */
    WORD    sumnum;                /* (M) internal number of sum_ function */
    WORD    sumpnum;               /* (M) internal number of sump_ function */
    WORD    OldOrderFlag;          /* (M) Flag for allowing old statement order */
    WORD    termfunnum;            /* (M) internal number of term_ function */
    WORD    matchfunnum;           /* (M) internal number of match_ function */
    WORD    countfunnum;           /* (M) internal number of count_ function */
    WORD    gPolyFun;              /* (M) global value of PolyFun */
    WORD    gPolyFunInv;           /* (M) global value of Inverse of PolyFun */
    WORD    gPolyFunType;          /* (M) global value of PolyFun */
    WORD    gPolyFunExp;
    WORD    gPolyFunVar;
    WORD    gPolyFunPow;
    WORD    dollarzero;            /* (M) for dollars with zero value */
    WORD    atstartup;             /* To protect against DATE_ ending in \n */
    WORD    exitflag;              /* (R) For the exit statement */
    WORD    NumStoreCaches;        /* () Number of storage caches per processor */
    WORD    gIndentSpace;          /* For indentation in output */
    WORD    ggIndentSpace;
    WORD    gShortStatsMax;        
    WORD    ggShortStatsMax;       
    WORD    gextrasymbols;
    WORD    ggextrasymbols;
    WORD    zerorhs;
    WORD    onerhs;
    WORD    havesortdir;
    WORD    vectorzero;            /* p0_ */
    WORD    ClearStore;
    WORD    BracketFactors[8];
    BOOL    FromStdin;             /* read the input from STDIN */
    BOOL    IgnoreDeprecation;     /* ignore deprecation warning */
};
/*
        #] M : 
        #[ P : The P struct defines objects set by the preprocessor
*/
struct P_const {
    LIST DollarList;               /* (R) Dollar variables. Contains pointers
                                       to contents of the variables.*/
    LIST PreVarList;               /* (R) List of preprocessor variables
                                       Points to contents. Can be changed */
    LIST LoopList;                 /* (P) List of do loops */
    LIST ProcList;                 /* (P) List of procedures */
    INSIDEINFO inside;             /*     Information during #inside/#endinside */
    NAMESPACE *firstnamespace;     /* is zero when no namespace specified */
    NAMESPACE *lastnamespace;      /* is zero when no namespace specified */
    UBYTE *fullname;               /* buffer for namespace expanded names */
    UBYTE **PreSwitchStrings;      /* (P) The string in a switch */
    UBYTE *preStart;               /* (P) Preprocessor instruction buffer */
    UBYTE *preStop;                /* (P) end of preStart */
    UBYTE *preFill;                /* (P) Filling point in preStart */
    UBYTE *procedureExtension;     /* (P) Extension for procedure files (prc) */
    UBYTE *cprocedureExtension;    /* (P) Extension after .clear */
    LONG  *PreAssignStack;         /* For nesting #$name assignments */
    int *PreIfStack;               /* (P) Tracks nesting of #if */
    int *PreSwitchModes;           /* (P) Stack of switch status */
    int *PreTypes;                 /* (P) stack of #call, #do etc nesting */
#ifdef WITHPTHREADS
    pthread_mutex_t PreVarLock;    /* (P) */
#endif
    LONG    StopWatchZero;         /* For `timer_' and #reset timer */
    LONG    InOutBuf;              /* (P) Characters in the output buf in pre.c */
    LONG    pSize;                 /* (P) size of preStart */
    int     PreAssignFlag;         /* (C) Indicates #assign -> catch dollar */
    int     PreContinuation;       /* (C) Indicates whether the statement is new */
    int     PreproFlag;            /* (P) Internal use to mark work on prepro instr. */
    int     iBufError;             /* (P) Flag for errors with input buffer */
    int     PreOut;                /* (P) Flag for #+ #- */
    int     PreSwitchLevel;        /* (P) Nesting of #switch */
    int     NumPreSwitchStrings;   /* (P) Size of PreSwitchStrings */
    int     MaxPreTypes;           /* (P) Size of PreTypes */
    int     NumPreTypes;           /* (P) Number of nesting objects in PreTypes */
    int     MaxPreIfLevel;         /* (C) Maximum number of nested #if. Dynamic */
    int     PreIfLevel;            /* (C) Current position if PreIfStack */
    int     PreInsideLevel;        /* (C) #inside active? */
    int     DelayPrevar;           /* (P) Delaying prevar substitution */
    int     AllowDelay;            /* (P) Allow delayed prevar substitution */
    int     lhdollarerror;         /* (R) */
    int     eat;                   /* () */
    int     gNumPre;               /* (P) Number of preprocessor variables for .clear */
    int     PreDebug;              /* (C) */
    int     OpenDictionary;
    int     PreAssignLevel;        /* For nesting #$name = ...; assignments */
    int     MaxPreAssignLevel;     /* For nesting #$name = ...; assignments */
    int     fullnamesize;          /* size of the fullname buffer */
    WORD    DebugFlag;             /* (P) For debugging purposes */
    WORD    preError;              /* (P) Blocks certain types of execution */
    UBYTE   ComChar;               /* (P) Commentary character */
    UBYTE   cComChar;              /* (P) Old commentary character for .clear */
};
 
/*
        #] P : 
        #[ C : The C struct defines objects changed by the compiler
*/
 
struct C_const {
    set_of_char separators;        
    POSITION StoreFileSize;        /* () Size of store file */
    NAMETREE *dollarnames;         
    NAMETREE *exprnames;           
    NAMETREE *varnames;            
    LIST    ChannelList;           
                                   /*     Later also for write? */
    LIST    DubiousList;           
    LIST    FunctionList;          
    LIST    ExpressionList;        
    LIST    IndexList;             
    LIST    SetElementList;        
    LIST    SetList;               
    LIST    SymbolList;            
    LIST    VectorList;            
    LIST    PotModDolList;         
    LIST    ModOptDolList;         
    LIST    TableBaseList;         
/*
    Compile buffer variables
*/
    LIST    cbufList;              
/*
    Objects for auto declarations
*/
    LIST    AutoSymbolList;        /* (C) */
    LIST    AutoIndexList;         /* (C) */
    LIST    AutoVectorList;        /* (C) */
    LIST    AutoFunctionList;      /* (C) */
    NAMETREE *autonames;           
    LIST    *Symbols;              /* (C) Pointer for autodeclare. Which list is
                                      it searching. Later also for subroutines */
    LIST    *Indices;              /* (C) id. */
    LIST    *Vectors;              /* (C) id. */
    LIST    *Functions;            /* (C) id. */
    NAMETREE **activenames;        
    STREAM  *Streams;              
    STREAM  *CurrentStream;        
    SWITCH  *SwitchArray;
    MODEL   **models;
    WORD    *SwitchHeap;
    LONG    *termstack;            
    LONG    *termsortstack;        
    UWORD   *cmod;                 
    UWORD   *powmod;               
    UWORD   *modpowers;            
    UWORD   *halfmod;              /* (C) half the modulus when not zero */
    WORD    *ProtoType;            /* (C) The subexpression prototype {wildcards} */
    WORD    *WildC;                /* (C) Filling point for wildcards. */
    LONG    *IfHeap;               
    LONG    *IfCount;              
    LONG    *IfStack;              
    UBYTE   *iBuffer;              
    UBYTE   *iPointer;             
    UBYTE   *iStop;                
    UBYTE   **LabelNames;          
    WORD    *FixIndices;           
    WORD    *termsumcheck;         
    UBYTE   *WildcardNames;        
    int     *Labels;               
    SBYTE   *tokens;               
    SBYTE   *toptokens;            
    SBYTE   *endoftokens;          
    WORD    *tokenarglevel;        
    UWORD   *modinverses;          /* Table for inverses of primes */
    UBYTE   *Fortran90Kind;        /* The kind of number in Fortran 90 as in _ki */
    WORD    **MultiBracketBuf;     /* Array of buffers for multi-level brackets */
    UBYTE   *extrasym;             /* Array with the name for extra symbols in ToPolynomial */
    WORD    *doloopstack;          /* To keep track of begin and end of doloops */
    WORD    *doloopnest;           /* To keep track of nesting of doloops etc */
    char    *CheckpointRunAfter;   
    char    *CheckpointRunBefore;  
    WORD    *IfSumCheck;           
    WORD    *CommuteInSet;         /* groups of noncommuting functions that can commute */
    UBYTE   *TestValue;            /* For debugging */
#ifdef PARALLELCODE
    LONG    *inputnumbers;         
    WORD    *pfirstnum;            
#endif
#ifdef WITHPTHREADS
    pthread_mutex_t halfmodlock;   /* () Lock for adding buffer for halfmod */
#endif
    LONG    argstack[MAXNEST];     /* (C) {contents} Stack for nesting of Argument */
    LONG    insidestack[MAXNEST];  /* (C) {contents} Stack for Argument or Inside. */
    LONG    inexprstack[MAXNEST];  /* (C) {contents} Stack for Argument or Inside. */
    LONG    iBufferSize;           /* (C) Size of the input buffer */
    LONG    TransEname;            /* (C) Used when a new definition overwrites
                                       an old expression. */
    LONG    ProcessBucketSize;     /* (C) */
    LONG    mProcessBucketSize;    /* (C) */
    LONG    CModule;               /* (C) Counter of current module */
    LONG    ThreadBucketSize;      /* (C) Roughly the maximum number of input terms */
    LONG    CheckpointStamp;       
    LONG    CheckpointInterval;    
#ifdef WITHFLOAT
    LONG    DefaultPrecision;      /* (C) Default precision in bits for float_ */
    LONG    MaxWeight;             /* (C) Maximum weight for MZV or Euler */
    LONG    tDefaultPrecision;     /* (C) Default precision in bits for float_ */
    LONG    tMaxWeight;            /* (C) Maximum weight for MZV or Euler */
#endif
    int     cbufnum;               
    int     AutoDeclareFlag;       
    int     NoShowInput;           /* (C) No listing of input as in .prc, #do */
    int     ShortStats;            /* (C) */
    int     compiletype;           /* (C) type of statement {DECLARATION etc} */
    int     firstconstindex;       /* (C) flag for giving first error message */
    int     insidefirst;           /* (C) Not used yet */
    int     minsidefirst;          /* (?) Not used yet */
    int     wildflag;              /* (C) Flag for marking use of wildcards */
    int     NumLabels;             /* (C) Number of labels {in Labels} */
    int     MaxLabels;             /* (C) Size of Labels array */
    int     lDefDim;               /* (C) */
    int     lDefDim4;              /* (C) */
    int     NumWildcardNames;      /* (C) Number of ?a variables */
    int     WildcardBufferSize;    /* (C) size of WildcardNames buffer */
    int     MaxIf;                 /* (C) size of IfHeap, IfSumCheck, IfCount */
    int     NumStreams;            /* (C) */
    int     MaxNumStreams;         /* (C) */
    int     firstctypemessage;     /* (C) Flag for giving first st order error */
    int     tablecheck;            /* (C) For table checking */
    int     idoption;              /* (C) */
    int     BottomLevel;           /* (C) For propercount. Not used!!! */
    int     CompileLevel;          /* (C) Subexpression level */
    int     TokensWriteFlag;       /* (C) */
    int     UnsureDollarMode;      /* (C)?Controls error messages undefined $'s */
    int     outsidefun;            /* (C) Used for writing Tables to file */
    int     funpowers;             /* (C) */
    int     WarnFlag;              /* (C) */
    int     StatsFlag;             /* (C) */
    int     NamesFlag;             /* (C) */
    int     CodesFlag;             /* (C) */
    int     SetupFlag;             /* (C) */
    int     SortType;              /* (C) */
    int     lSortType;             /* (C) */
    int     ThreadStats;           /* (C) */
    int     FinalStats;            /* (C) */
    int     OldParallelStats;      /* (C) */
    int     ThreadsFlag;
    int     ThreadBalancing;
    int     ThreadSortFileSynch;
    int     ProcessStats;          /* (C) */
    int     BracketNormalize;      /* (C) Indicates whether the bracket st is normalized */
    int     maxtermlevel;          /* (C) Size of termstack */
    int     dumnumflag;            /* (C) Where there dummy indices in tokenizer? */
    int     bracketindexflag;      /* (C) Are brackets going to be indexed? */
    int     parallelflag;          /* (C) parallel allowed? */
    int     mparallelflag;         /* (C) parallel allowed in this module? */
    int     inparallelflag;        /* (C) inparallel allowed? */
    int     partodoflag;           /* (C) parallel allowed? */
    int     properorderflag;       /* (C) clean normalizing. */
    int     vetofilling;           /* (C) vetoes overwriting in tablebase stubs */
    int     tablefilling;          /* (C) to notify AddRHS we are filling a table */
    int     vetotablebasefill;     /* (C) For the load in tablebase */
    int     exprfillwarning;       /* (C) Warning has been printed for expressions in fill statements */
    int     lhdollarflag;          /* (R) left hand dollar present */
    int     NoCompress;            /* (R) Controls native compression */
    int     IsFortran90;           /* Tells whether the Fortran is Fortran90 */
    int     MultiBracketLevels;    /* Number of elements in MultiBracketBuf */
    int     topolynomialflag;      /* To avoid ToPolynomial and FactArg together */
    int     ffbufnum;              /* Buffer number for user defined factorizations */
    int     OldFactArgFlag;
    int     MemDebugFlag;          /* Only used when MALLOCDEBUG in tools.c */
    int     OldGCDflag;
    int     WTimeStatsFlag;
    int     SortReallocateFlag;    /* Controls reallocation of large+small buffer at module end.
                                        0 : Off
                                        1 : On, every module (set by On sortreallocate;)
                                        2 : On, single module (set by #sortreallocate) */
    int     PrintBacktraceFlag;    /* Print backtrace on terminate? */
    int    FlintPolyFlag;          /* Use Flint for polynomial arithmetic */
    int     HumanStatsFlag;        /* Print human-readable stats in the stats print? */
    int     GrccVerbose;           /* Enable extra print statements in grcc? */
    int     SortVerbose;           /* Enable extra sort stats information? */
    int     doloopstacksize;
    int     dolooplevel;
    int     CheckpointFlag;        
    int     SizeCommuteInSet;      /* Size of the CommuteInSet buffer */
#ifdef PARALLELCODE
    int     numpfirstnum;          /* For redefine */
    int     sizepfirstnum;         /* For redefine */
#endif
    int     origin;                /* Determines whether .sort or ModuleOption */
    int     vectorlikeLHS;
    int     nummodels;
    int     modelspace;
    int     ModelLevel;
    int     ShortStatsMax;         /* For  On FewerStatistics 10; */
    int     InnerTest;             /* For debugging */
    WORD    argsumcheck[MAXNEST];  /* (C) Checking of nesting */
    WORD    insidesumcheck[MAXNEST];/* (C) Checking of nesting */
    WORD    inexprsumcheck[MAXNEST];/* (C) Checking of nesting */
    WORD    RepSumCheck[MAXREPEAT];/* (C) Checks nesting of repeat, if, argument */
    WORD    lUniTrace[4];          /* (C) */
    WORD    RepLevel;              /* (C) Tracks nesting of repeat. */
    WORD    arglevel;              /* (C) level of nested argument statements */
    WORD    insidelevel;           /* (C) level of nested inside statements */
    WORD    inexprlevel;           /* (C) level of nested inexpr statements */
    WORD    termlevel;             /* (C) level of nested term statements */
    WORD    MustTestTable;         /* (C) Indicates whether tables have been changed */
    WORD    DumNum;                /* (C) */
    WORD    ncmod;                 /* (C) Local setting of modulus. size of cmod */
    WORD    npowmod;               /* (C) Local printing as powers. size powmod */
    WORD    modmode;               /* (C) Mode for modulus calculus */
    WORD    nhalfmod;              /* relevant word size of halfmod when defined */
    WORD    DirtPow;               /* (C) Flag for changes in printing mod powers */
    WORD    lUnitTrace;            /* (C) Local value of Tr[1] */
    WORD    NwildC;                /* (C) Wildcard counter */
    WORD    ComDefer;              /* (C) defer brackets */
    WORD    CollectFun;            /* (C) Collect function number */
    WORD    AltCollectFun;         /* (C) Alternate Collect function number */
    WORD    OutputMode;            /* (C) */
    WORD    Cnumpows;
    WORD    OutputSpaces;          /* (C) */
    WORD    OutNumberType;         /* (C) Controls RATIONAL/FLOAT output */
    WORD    DidClean;              /* (C) Test whether nametree needs cleaning */
    WORD    IfLevel;               /* (C) */
    WORD    WhileLevel;            /* (C) */
    WORD    SwitchLevel;
    WORD    SwitchInArray;
    WORD    MaxSwitch;
    WORD    LogHandle;             /* (C) The Log File */
    WORD    LineLength;            /* (C) */
    WORD    StoreHandle;           /* (C) Handle of .str file */
    WORD    HideLevel;             /* (C) Hiding indicator */
    WORD    lPolyFun;              /* (C) local value of PolyFun */
    WORD    lPolyFunInv;           /* (C) local value of Inverse of PolyFun */
    WORD    lPolyFunType;          /* (C) local value of PolyFunType */
    WORD    lPolyFunExp;
    WORD    lPolyFunVar;
    WORD    lPolyFunPow;
    WORD    SymChangeFlag;         /* (C) */
    WORD    CollectPercentage;     /* (C) Collect function percentage */
    WORD    extrasymbols;          /* Flag for the extra symbols output mode */
    WORD    PolyRatFunChanged;     /* Keeps track whether we changed in the compiler */
    WORD    ToBeInFactors;
#ifdef WITHMPI
    WORD    RhsExprInModuleFlag;   /* (C) Set by the compiler if RHS expressions exists. */
#endif
    UBYTE   Commercial[COMMERCIALSIZE+2]; /* (C) Message to be printed in statistics */
    UBYTE   debugFlags[MAXFLAGS+2];    /* On/Off Flag number(s) */
};
/*
        #] C : 
        #[ S : The S struct defines objects changed at the start of the run (Processor)
               Basically only set by the master.
*/
struct S_const {
    POSITION MaxExprSize;          /* ( ) Maximum size of in/out/sort */
#ifdef WITHPTHREADS
    pthread_mutex_t inputslock;
    pthread_mutex_t outputslock;
    pthread_mutex_t MaxExprSizeLock;
#endif
    POSITION *OldOnFile;           /* (S) File positions of expressions */
    WORD    *OldNumFactors;        /* ( ) NumFactors in (old) expression */
    WORD    *Oldvflags;            /* ( ) vflags in (old) expression */
    WORD    *Olduflags;            /* ( ) uflags in (old) expression */
#ifdef WITHFLOAT
    void    *delta_1;
#endif
    int     NumOldOnFile;          /* (S) Number of expressions in OldOnFile */
    int     NumOldNumFactors;      /* (S) Number of expressions in OldNumFactors */
    int     MultiThreaded;         /* (S) Are we running multi-threaded? */
#ifdef WITHPTHREADS
    int     MasterSort;            /* Final stage of sorting to the master */
#endif
#ifdef WITHMPI
    int     printflag;             /* controls MesPrint() on each slave */
#endif
    int     Balancing;             /* For second stage loadbalancing */
    WORD    ExecMode;              /* (S) */
 
    WORD    CollectOverFlag;       /* (R) Indicates overflow at Collect */
#ifdef WITHPTHREADS
    WORD    sLevel;                /* Copy of AR0.sLevel because it can get messy */
#endif
};
/*
        #] S : 
        #[ R : The R struct defines objects changed at run time.
               They determine the environment that has to be transferred
               together with a term during multithreaded execution.
*/
struct R_const {
    FILEDATA    StoreData;         /* (O) */
    FILEHANDLE  Fscr[3];           /* (R) Dollars etc play with it too */
    FILEHANDLE  FoStage4[2];       /* (R) In Sort. Stage 4. */
    POSITION DefPosition;          /* (R) Deferred position of keep brackets. */
    FILEHANDLE *infile;            /* (R) Points alternatingly to Fscr[0] or Fscr[1] */
    FILEHANDLE *outfile;           /* (R) Points alternatingly to Fscr[1] or Fscr[0] */
    FILEHANDLE *hidefile;          /* (R) Points to Fscr[2] */
 
    WORD    *CompressBuffer;       /* (M) */
    WORD    *ComprTop;             /* (M) */
    WORD    *CompressPointer;      /* (R) */
    COMPAREDUMMY CompareRoutine;
    ULONG   *wranfia;
    SBYTE   *moebiustable;
 
    LONG    OldTime;               /* (R) Zero time. Needed in timer. */
    LONG    InInBuf;               /* (R) Characters in input buffer. Scratch files. */
    LONG    InHiBuf;               /* (R) Characters in hide buffer. Scratch file. */
    LONG    pWorkSize;             /* (R) Size of pWorkSpace */
    LONG    lWorkSize;             /* (R) Size of lWorkSpace */
    LONG    posWorkSize;           /* (R) Size of posWorkSpace */
    ULONG   wranfseed;
    int     NoCompress;            /* (R) Controls native compression */
    int     gzipCompress;          /* (R) Controls gzip compression */
    int     Cnumlhs;               /* Local copy of cbuf[rbufnum].numlhs */
    int     outtohide;             /* Indicates that output is directly to hide */
#ifdef WITHPTHREADS
    int     exprtodo;              /* The expression to do in parallel mode */
#endif
    int     wranfcall;
    int     wranfnpair1;
    int     wranfnpair2;
#if ( BITSINWORD == 32 )
    WORD    PrimeList[5000];
    WORD    numinprimelist;
    WORD    notfirstprime;
#endif
    WORD    GetFile;               /* (R) Where to get the terms {like Hide} */
    WORD    KeptInHold;            /* (R) */
    WORD    BracketOn;             /* (R) Intensely used in poly_ */
    WORD    MaxBracket;            /* (R) Size of BrackBuf. Changed by poly_ */
    WORD    CurDum;                /* (R) Current maximum dummy number */
    WORD    DeferFlag;             /* (R) For deferred brackets */
    WORD    TePos;                 /* (R) */
    WORD    sLevel;                /* (R) Sorting level */
    WORD    Stage4Name;            /* (R) Sorting only */
    WORD    GetOneFile;            /* (R) Getting from hide or regular */
    WORD    PolyFun;               /* (C) Number of the PolyFun function */
    WORD    PolyFunInv;            /* (C) Number of the Inverse of the PolyFun function */
    WORD    PolyFunType;           /* () value of PolyFunType */
    WORD    PolyFunExp;
    WORD    PolyFunVar;
    WORD    PolyFunPow;
    WORD    Eside;                 /* () Tells which side of = sign */
    WORD    MaxDum;                /* Maximum dummy value in an expression */
    WORD    level;                 /* Running level in Generator */
    WORD    expchanged;            /* (R) Info about expression */
    WORD    expflags;              /* (R) Info about expression */
    WORD    CurExpr;               /* (S) Number of current expression */
    WORD    SortType;              /* A copy of AC.SortType to play with */
    WORD    ShortSortCount;        /* For On FewerStatistics 10; */
    WORD    modeloptions;
    WORD    funoffset;
    WORD    moebiustablesize;
};
 
/*
        #] R : 
        #[ T : These are variables that stay in each thread during multi threaded execution.
*/
struct T_const {
#ifdef WITHPTHREADS
    SORTBLOCK SB;
#endif
    SORTING *S0;                   /* (-) The thread specific sort buffer */
    SORTING *SS;                   /* (R) Current sort buffer */
    NESTING     Nest;              /* (R) Nesting of function levels etc. */
    NESTING     NestStop;          /* (R) */
    NESTING     NestPoin;          /* (R) */
    WORD    *BrackBuf;             /* (R) Bracket buffer. Used by poly_ at runtime. */
    STORECACHE  StoreCache;        /* (R) Cache for picking up stored expr. */
    STORECACHE  StoreCacheAlloc;   /* (R) Permanent address of StoreCache to keep valgrind happy */
    WORD    **pWorkSpace;          /* (R) Workspace for pointers. Dynamic. */
    LONG    *lWorkSpace;           /* (R) WorkSpace for LONG. Dynamic. */
    POSITION *posWorkSpace;        /* (R) WorkSpace for file positions */
    WORD    *WorkSpace;            /* (M) */
    WORD    *WorkTop;              /* (M) */
    WORD    *WorkPointer;          /* (R) Pointer in the WorkSpace heap. */
    int     *RepCount;             /* (M) Buffer for repeat nesting */
    int     *RepTop;               /* (M) Top of RepCount buffer */
    WORD    *WildArgTaken;         /* (N) Stack for wildcard pattern matching */
    UWORD   *factorials;           /* (T) buffer of factorials. Dynamic. */
    WORD    *small_power_n;        /*     length of the number */
    UWORD  **small_power;          /*     the number*/  
    UWORD   *bernoullis;           /* (T) The buffer with Bernoulli numbers. Dynamic. */
    WORD    *primelist;
    LONG    *pfac;                 /* (T) array of positions of factorials. Dynamic. */
    LONG    *pBer;                 /* (T) array of positions of Bernoulli's. Dynamic. */
    WORD    *TMaddr;               /* (R) buffer for TestSub */
    WORD    *WildMask;             /* (N) Wildcard info during pattern matching */
    WORD    *previousEfactor;      /* () Cache for factors in expressions */
    WORD    **TermMemHeap;        /* For TermMalloc. Set zero in Checkpoint */
    UWORD    **NumberMemHeap;      /* For NumberMalloc. Set zero in Checkpoint */
    UWORD    **CacheNumberMemHeap; /* For CacheNumberMalloc. Set zero in Checkpoint */
    BRACKETINFO *bracketinfo;
    WORD    **ListPoly;
    WORD    *ListSymbols;
    UWORD   *NumMem;
    WORD    *TopologiesTerm;
    WORD    *TopologiesStart;
#ifdef WITHFLOAT
    WORD    *indi1;
    WORD    *indi2;
    void    *mpf_tab1;
    void    *mpf_tab2;
    void    *aux_;
    void    *auxr_;
#endif
    NORMDATA **NormData;
    LONG    NormDataSize;
    LONG    NormDepth;
    PARTI   partitions;
    LONG    sBer;                  /* (T) Size of the Bernoullis buffer */
    LONG    pWorkPointer;          /* (R) Offset-pointer in pWorkSpace */
    LONG    lWorkPointer;          /* (R) Offset-pointer in lWorkSpace */
    LONG    posWorkPointer;        /* (R) Offset-pointer in posWorkSpace */
    LONG    InNumMem;
    int     sfact;                 /* (T) size of the factorials buffer */
    int     mfac;                  /* (T) size of the pfac array. */
    int     ebufnum;               /* (R) extra compiler buffer */
    int     fbufnum;               /* extra compiler buffer for factorization cache */
    int     allbufnum;             /* extra compiler buffer for id,all */
    int     aebufnum;              /* extra compiler buffer for id,all */
    int     idallflag;             /* indicates use of id,all buffers */
    int     idallnum;
    int     idallmaxnum;
    int     WildcardBufferSize;    /* () local copy for updates */
#ifdef WITHPTHREADS
    int     identity;              /* () When we work with B->T */
    int     LoadBalancing;         /* Needed for synchronization */
#ifdef WITHSORTBOTS
    int     SortBotIn1;            /* Input stream 1 for a SortBot */
    int     SortBotIn2;            /* Input stream 2 for a SortBot */
#endif
#endif
    int     TermMemMax;            /* For TermMalloc. Set zero in Checkpoint */
    int     TermMemTop;            /* For TermMalloc. Set zero in Checkpoint */
    int     NumberMemMax;          /* For NumberMalloc. Set zero in Checkpoint */
    int     NumberMemTop;          /* For NumberMalloc. Set zero in Checkpoint */
    int     CacheNumberMemMax;     /* For CacheNumberMalloc. Set zero in Checkpoint */
    int     CacheNumberMemTop;     /* For CacheNumberMalloc. Set zero in Checkpoint */
    int     bracketindexflag;      /* Are brackets going to be indexed? */
    int     optimtimes;            /* Number of the evaluation of the MCTS tree */
    int     ListSymbolsSize;
    int     NumListSymbols;
    int     numpoly;
    int     LeaveNegative;
    int     TrimPower;             /* Indicates trimming in polyratfun expansion */
    WORD    small_power_maxx;      /*     size of the cache for small powers  */
    WORD    small_power_maxn;      /*     size of the cache for small powers */
    WORD    dummysubexp[SUBEXPSIZE+4]; /* () used in normal.c */
    WORD    comsym[8];             /* () Used in tools.c = {8,SYMBOL,4,0,1,1,1,3} */
    WORD    comnum[4];             /* () Used in tools.c = { 4,1,1,3 } */
    WORD    comfun[FUNHEAD+4];     /* () Used in tools.c = {7,FUNCTION,3,0,1,1,3} */
                                   /*            or { 8,FUNCTION,4,0,0,1,1,3 } */
    WORD    comind[7];             /* () Used in tools.c = {7,INDEX,3,0,1,1,3} */
    WORD    MinVecArg[7+ARGHEAD];  /* (N) but should be more local */
    WORD    FunArg[4+ARGHEAD+FUNHEAD]; /* (N) but can be more local */
    WORD    locwildvalue[SUBEXPSIZE]; /* () Used in argument.c = {SUBEXPRESSION,SUBEXPSIZE,0,0,0} */
    WORD    mulpat[SUBEXPSIZE+5];  /* () Used in argument.c = {TYPEMULT, SUBEXPSIZE+3, 0, */
                                   /* SUBEXPRESSION, SUBEXPSIZE, 0, 1, 0, 0, 0 } */
    WORD    proexp[SUBEXPSIZE+5];  /* () Used in poly.c */
    WORD    TMout[40];             /* (R) Passing info */
    WORD    TMbuff;                /* (R) Communication between TestSub and Genera */
    WORD    TMdolfac;              /* factor number for dollar */
    WORD    nfac;                  /* (T) Number of highest stored factorial */
    WORD    nBer;                  /* (T) Number of highest Bernoulli number. */
    WORD    mBer;                  /* (T) Size of buffer pBer. */
    WORD    PolyAct;               /* (R) Used for putting the PolyFun at end. ini at 0 */
    WORD    RecFlag;               /* (R) Used in TestSub. ini at zero. */
    WORD    inprimelist;
    WORD    sizeprimelist;
    WORD    fromindex;             /* Tells the compare routine whether call from index */
    WORD    setinterntopo;         /* Set of internal momenta for topogen */
    WORD    setexterntopo;         /* Set of external momenta for topogen */
    WORD    TopologiesLevel;
    WORD    TopologiesOptions[2];
#ifdef WITHFLOAT
    WORD    FloatPos;
    WORD    SortFloatMode;
#endif
};
/*
        #] T : 
        #[ N : The N struct contains variables used in running information
               that is inside blocks that should not be split, like pattern
               matching, traces etc. They are local for each thread.
               They don't need initializations.
*/
struct N_const {
    POSITION OldPosIn;             /* (R) Used in sort. */
    POSITION OldPosOut;            /* (R) Used in sort */
    POSITION theposition;          /* () Used in index.c */
    WORD    *EndNest;              /* (R) Nesting of function levels etc. */
    WORD    *Frozen;               /* (R) Bracket info */
    WORD    *FullProto;            /* (R) Prototype of a subexpression or table */
    WORD    *cTerm;                /* (R) Current term for coef_ and term_ */
    int     *RepPoint;             /* (R) Pointer in RepCount buffer. Tracks repeat */
    WORD    *WildValue;            /* (N) Wildcard info during pattern matching */
    WORD    *WildStop;             /* (N) Wildcard info during pattern matching */
    WORD    *argaddress;           /* (N) Used in pattern matching of arguments */
    WORD    *RepFunList;           /* (N) For pattern matching */
    WORD    *patstop;              /* (N) Used in pattern matching */
    WORD    *terstop;              /* (N) Used in pattern matching */
    WORD    *terstart;             /* (N) Used in pattern matching */
    WORD    *terfirstcomm;         /* (N) Used in pattern matching */
    WORD    *DumFound;             /* (N) For renumbering indices {make local?} */
    WORD    **DumPlace;            /* (N) For renumbering indices {make local?} */
    WORD    **DumFunPlace;         /* (N) For renumbering indices {make local?} */
    WORD    *UsedSymbol;           /* (N) When storing terms of a global expr. */
    WORD    *UsedVector;           /* (N) When storing terms of a global expr. */
    WORD    *UsedIndex;            /* (N) When storing terms of a global expr. */
    WORD    *UsedFunction;         /* (N) When storing terms of a global expr. */
    WORD    *MaskPointer;          /* (N) For wildcard pattern matching */
    WORD    *ForFindOnly;          /* (N) For wildcard pattern matching */
    WORD    *findTerm;             /* (N) For wildcard pattern matching */
    WORD    *findPattern;          /* (N) For wildcard pattern matching */
#ifdef WITHZLIB
    Bytef   **ziobufnum;           /* () Used in compress.c */
    Bytef   *ziobuffers;           /* () Used in compress.c */
#endif
    WORD    *dummyrenumlist;       /* () Used in execute.c and store.c */
    int     *funargs;              /* () Used in lus.c */
    WORD    **funlocs;             /* () Used in lus.c */
    int     *funinds;              /* () Used in lus.c */
    UWORD   *NoScrat2;             /* () Used in normal.c */
    WORD    *ReplaceScrat;         /* () Used in normal.c */
    TRACES  *tracestack;           /* () used in opera.c */
    WORD    *selecttermundo;       /* () Used in pattern.c */
    WORD    *patternbuffer;        /* () Used in pattern.c */
    WORD    *termbuffer;           /* () Used in pattern.c */
    WORD    **PoinScratch;         /* () used in reshuf.c */
    WORD    **FunScratch;          /* () used in reshuf.c */
    WORD    *RenumScratch;         /* () used in reshuf.c */
    FUN_INFO *FunInfo;             /* () Used in smart.c */
    WORD    **SplitScratch;        /* () Used in sort.c */
    WORD    **SplitScratch1;       /* () Used in sort.c */
    SORTING **FunSorts;            /* () Used in sort.c */
    UWORD   *SoScratC;             /* () Used in sort.c */
    WORD    *listinprint;          /* () Used in proces.c and message.c */
    WORD    *currentTerm;          /* () Used in proces.c and message.c */
    WORD    **arglist;             /* () Used in function.c */
    int     *tlistbuf;             /* () used in lus.c */
#ifdef WHICHSUBEXPRESSION
    UWORD   *BinoScrat;            /* () Used in proces.c */
#endif
    WORD    *compressSpace;        /* () Used in sort.c */
#ifdef WITHPTHREADS
    THREADBUCKET *threadbuck;
    EXPRESSIONS expr;
#endif
    UWORD   *SHcombi;
    WORD    *poly_vars;
    UWORD   *cmod;                 /* Local setting of modulus. Pointer to value. */
    SHvariables SHvar;
    LONG    deferskipped;          /* () Used in proces.c store.c and parallel.c */
    LONG    InScratch;             /* () Used in sort.c */
    LONG    SplitScratchSize;      /* () Used in sort.c */
    LONG    InScratch1;            /* () Used in sort.c */
    LONG    SplitScratchSize1;     /* () Used in sort.c */
    LONG    ninterms;              /* () Used in proces.c and sort.c */
#ifdef WITHPTHREADS
    LONG    inputnumber;           /* () For use in redefine */
    LONG    lastinindex;
#endif
#ifdef WHICHSUBEXPRESSION
    LONG    last2;                 /* () Used in proces.c */
    LONG    last3;                 /* () Used in proces.c */
#endif
    LONG    SHcombisize;
    int     NumTotWildArgs;        /* (N) Used in pattern matching */
    int     UseFindOnly;           /* (N) Controls pattern routines */
    int     UsedOtherFind;         /* (N) Controls pattern routines */
    int     ErrorInDollar;         /* (R) */
    int     numfargs;              /* () Used in lus.c */
    int     numflocs;              /* () Used in lus.c */
    int     nargs;                 /* () Used in lus.c */
    int     tohunt;                /* () Used in lus.c */
    int     numoffuns;             /* () Used in lus.c */
    int     funisize;              /* () Used in lus.c */
    int     RSsize;                /* () Used in normal.c */
    int     numtracesctack;        /* () used in opera.c */
    int     intracestack;          /* () used in opera.c */
    int     numfuninfo;            /* () Used in smart.c */
    int     NumFunSorts;           /* () Used in sort.c */
    int     MaxFunSorts;           /* () Used in sort.c */
    int     arglistsize;           /* () Used in function.c */
    int     tlistsize;             /* () used in lus.c */
    int     filenum;               /* () used in setfile.c */
    int     compressSize;          /* () Used in sort.c */
    int     polysortflag;
    int     nogroundlevel;         /* () Used to see whether pattern matching at groundlevel */
    int     subsubveto;            /* () Sabotage combining subexpressions in TestSub */
    WORD    MaxRenumScratch;       /* () used in reshuf.c */
    WORD    oldtype;               /* (N) WildCard info at pattern matching */
    WORD    oldvalue;              /* (N) WildCard info at pattern matching */
    WORD    NumWild;               /* (N) Used in Wildcard */
    WORD    RepFunNum;             /* (N) Used in pattern matching */
    WORD    DisOrderFlag;          /* (N) Disorder option? Used in pattern matching */
    WORD    WildDirt;              /* (N) dirty in wildcard substitution. */
    WORD    NumFound;              /* (N) in reshuf only. Local? */
    WORD    WildReserve;           /* (N) Used in the wildcards */
    WORD    TeInFun;               /* (R) Passing type of action */
    WORD    TeSuOut;               /* (R) Passing info. Local? */
    WORD    WildArgs;              /* (R) */
    WORD    WildEat;               /* (R) */
    WORD    PolyNormFlag;          /* (R) For polynomial arithmetic */
    WORD    PolyFunTodo;           /* deals with expansions and multiplications */
    WORD    sizeselecttermundo;    /* () Used in pattern.c */
    WORD    patternbuffersize;     /* () Used in pattern.c */
    WORD    numlistinprint;        /* () Used in process.c */
    WORD    ncmod;                 /* () used as some type of flag to disable */
    WORD    ExpectedSign;          
    WORD    SignCheck;             
    WORD    IndDum;                /* Active dummy indices */
    WORD    poly_num_vars;
    WORD    idfunctionflag;
    WORD    poly_vars_type;        /* type of allocation. For free. */
    WORD    tryterm;               /* For EndSort(...,2) */
#ifdef WHICHSUBEXPRESSION
    WORD    nbino;                 /* () Used in proces.c */
    WORD    last1;                 /* () Used in proces.c */
#endif
};
 
/*
        #] N : 
        #[ O : The O struct concerns output variables
*/
struct O_const {
    FILEDATA    SaveData;          /* (O) */
    STOREHEADER SaveHeader;        /* ()  System Independent save-Files */
    OPTIMIZERESULT OptimizeResult;
    UBYTE   *OutputLine;           /* (O) Sits also in debug statements */
    UBYTE   *OutStop;              /* (O) Top of OutputLine buffer */
    UBYTE   *OutFill;              /* (O) Filling point in OutputLine buffer */
    WORD    *bracket;              /* (O) For writing brackets */
    WORD    *termbuf;              /* (O) For writing terms */
    WORD    *tabstring;
    UBYTE   *wpos;                 /* (O) Only when storing file {local?} */
    UBYTE   *wpoin;                /* (O) Only when storing file {local?} */
    UBYTE   *DollarOutBuffer;      /* (O) Outputbuffer for Dollars */
    UBYTE   *CurBufWrt;            /* (O) Name of currently written expr. */
    void    (*FlipWORD)(UBYTE *);  /* ()  Function pointers for translations. Initialized by ReadSaveHeader() */
    void    (*FlipLONG)(UBYTE *);
    void    (*FlipPOS)(UBYTE *);
    void    (*FlipPOINTER)(UBYTE *);
    void    (*ResizeData)(UBYTE *,int,UBYTE *,int);
    void    (*ResizeWORD)(UBYTE *,UBYTE *);
    void    (*ResizeNCWORD)(UBYTE *,UBYTE *);
    void    (*ResizeLONG)(UBYTE *,UBYTE *);
    void    (*ResizePOS)(UBYTE *,UBYTE *);
    void    (*ResizePOINTER)(UBYTE *,UBYTE *);
    void    (*CheckPower)(UBYTE *);
    void    (*RenumberVec)(UBYTE *);
    DICTIONARY **Dictionaries;
    UBYTE   *tensorList;           /* Dynamically allocated list with functions that are tensorial. */
    WORD    *inscheme;             /* for feeding a Horner scheme to Optimize */
#ifdef WITHFLOAT
    UBYTE   *floatspace;
    LONG    floatsize;
#endif
/*----Leave NumInBrack as first non-pointer. This is used by the checkpoints--*/
    LONG    NumInBrack;            /* (O) For typing [] option in print */
    LONG    wlen;                  /* (O) Used to store files. */
    LONG    DollarOutSizeBuffer;   /* (O) Size of DollarOutBuffer */
    LONG    DollarInOutBuffer;     /* (O) Characters in DollarOutBuffer */
#if defined(mBSD) && defined(MICROTIME)
    LONG    wrap;                  /* (O) For statistics time. wrap around */
    LONG    wrapnum;               /* (O) For statistics time. wrap around */
#endif
    OPTIMIZE Optimize;          
    int     OutInBuffer;           /* (O) Which routine does the writing */
    int     NoSpacesInNumbers;     /*     For very long numbers */
    int     BlockSpaces;           /*     For very long numbers */
    int     CurrentDictionary;
    int     SizeDictionaries;
    int     NumDictionaries;
    int     CurDictNumbers;
    int     CurDictVariables;
    int     CurDictSpecials;
    int     CurDictFunWithArgs;
    int     CurDictNumberWarning;
    int     CurDictNotInFunctions;
    int     CurDictInDollars;
    int     gNumDictionaries;
    int     IndentSpace;           /* For indentation in output */
#ifdef WITHFLOAT
    int     FloatPrec;
#endif
    WORD    schemenum;             /* for feeding a Horner scheme to Optimize */
    WORD    transFlag;             /* ()  >0 indicates that translations have to be done */
    WORD    powerFlag;             /* ()  >0 indicates that some exponents/powers had to be adjusted */
    WORD    mpower;                /*     For maxpower adjustment to larger value */
    WORD    resizeFlag;            /* ()  >0 indicates that something went wrong when resizing words */
    WORD    bufferedInd;           /* ()  Contains extra INDEXENTRIES, see ReadSaveIndex() for an explanation */
    WORD    OutSkip;               /* (O) How many chars to skip in output line */
    WORD    IsBracket;             /* (O) Controls brackets */
    WORD    InFbrack;              /* (O) For writing only */
    WORD    PrintType;             /* (O) */
    WORD    FortFirst;             /* (O) Only in sch.c */
    WORD    DoubleFlag;            /* (O) Output in double precision */
    WORD    FactorMode;            /* When the output should be written as factors */
    WORD    FactorNum;             /* Number of factor currently treated */
    WORD    ErrorBlock;
    WORD    OptimizationLevel;     /* Level of optimization in the output */
    UBYTE   FortDotChar;           /* (O) */
/*
    For the padding, please count also the number of int's in the OPTIMIZE struct.
*/
};
/*
        #] O : 
        #[ X : The X struct contains variables that deal with the external channel
*/
struct X_const {
    UBYTE *currentPrompt;
    UBYTE *shellname;          /* if !=NULL (default is "/bin/sh -c"), start in 
                                  the specified subshell*/
    UBYTE *stderrname;         /* If !=NULL (default if "/dev/null"), stderr is 
                                  redirected to the specified file*/
    int timeout;               /* timeout to initialize preset channels.
                                  If timeout<0, the preset channels are 
                                  already initialized*/
    int killSignal;            /* signal number, SIGKILL by default*/
    int killWholeGroup;        /* if 0, the signal is sent only to a process, 
                                  if !=0 (default) is sent to a whole process group*/
    int daemonize;             /* if !=0 (default), start in a daemon mode */
    int currentExternalChannel;
};
/*
        #] X : 
        #[ Definitions :
 
    Note: we changed the definition from C to Cc in version 5.
    The reason is that everywhere the pointer to the compiler
    buffer was called C as well. Somehow that gave no problems but
    who knows what the future might bring.
*/
 
#ifdef WITHPTHREADS
 
typedef struct AllGlobals {
    struct M_const M;
    struct C_const Cc;
    struct S_const S;
    struct O_const O;
    struct P_const P;
    struct X_const X;
} ALLGLOBALS;
 
typedef struct AllPrivates {
    struct R_const R;
    struct N_const N;
    struct T_const T;
} ALLPRIVATES;
 
#else
 
typedef struct AllGlobals {
    struct M_const M;
    struct C_const Cc;
    struct S_const S;
    struct R_const R;
    struct N_const N;
    struct O_const O;
    struct P_const P;
    struct T_const T;
    struct X_const X;
} ALLGLOBALS;
 
#endif
 
/*
        #] Definitions : 
    #] A : 
    #[ FG :
*/
 
#ifdef WITHPTHREADS
#define PHEAD  ALLPRIVATES *B,
#define PHEAD0 ALLPRIVATES *B
#define BHEAD  B,
#define BHEAD0 B
#else
#define PHEAD
#define PHEAD0 void
#define BHEAD
#define BHEAD0
#endif
 
typedef int (*WCN)(PHEAD WORD *,WORD *,WORD,WORD);
typedef int (*WCN2)(PHEAD WORD *,WORD *);
 
typedef WORD (*COMPARE)(PHEAD WORD *,WORD *,WORD);
 
typedef struct FixedGlobals {
    WCN     Operation[8];
    WCN2    OperaFind[6];
    char    *VarType[10];
    char    *ExprStat[21];
    char    *FunNam[2];
    char    *swmes[3];
    char    *fname;
    char    *fname2;
    UBYTE   *s_one;
    WORD    fnamebase;
    WORD    fname2base;
    WORD    fnamesize;
    WORD    fname2size;
    UINT    cTable[256];
} FIXEDGLOBALS;
 
/*
    #] FG : 
*/
 
#endif