FORM  4.2.1
structs.h
Go to the documentation of this file.
1 
17 /* #[ License : */
18 /*
19  * Copyright (C) 1984-2017 J.A.M. Vermaseren
20  * When using this file you are requested to refer to the publication
21  * J.A.M.Vermaseren "New features of FORM" math-ph/0010025
22  * This is considered a matter of courtesy as the development was paid
23  * for by FOM the Dutch physics granting agency and we would like to
24  * be able to track its scientific use to convince FOM of its value
25  * for the community.
26  *
27  * This file is part of FORM.
28  *
29  * FORM is free software: you can redistribute it and/or modify it under the
30  * terms of the GNU General Public License as published by the Free Software
31  * Foundation, either version 3 of the License, or (at your option) any later
32  * version.
33  *
34  * FORM is distributed in the hope that it will be useful, but WITHOUT ANY
35  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
36  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
37  * details.
38  *
39  * You should have received a copy of the GNU General Public License along
40  * with FORM. If not, see <http://www.gnu.org/licenses/>.
41  */
42 /* #] License : */
43 
44 #ifndef __STRUCTS__
45 
46 #define __STRUCTS__
47 #ifdef _MSC_VER
48 #include <wchar.h> /* off_t */
49 #endif
50 /*
51  #[ sav&store :
52 */
53 
58 typedef struct PoSiTiOn {
59  off_t p1;
60 } POSITION;
61 
62 /* Next are the index structs for stored and saved expressions */
63 
74 typedef struct {
75  UBYTE headermark[8];
77  UBYTE lenWORD;
78  UBYTE lenLONG;
79  UBYTE lenPOS;
80  UBYTE lenPOINTER;
81  UBYTE endianness[16];
82  UBYTE sSym;
83  UBYTE sInd;
84  UBYTE sVec;
85  UBYTE sFun;
86  UBYTE maxpower[16];
87  UBYTE wildoffset[16];
88  UBYTE revision;
89  UBYTE reserved[512-8-4-16-4-16-16-1];
90 } STOREHEADER;
91 
92 STATIC_ASSERT(sizeof(STOREHEADER) == 512);
93 
99 typedef struct InDeXeNtRy {
104  WORD nsymbols;
105  WORD nindices;
106  WORD nvectors;
107  WORD nfunctions;
108  WORD size;
109  SBYTE name[MAXENAME+1];
110  PADPOSITION(0,1,0,5,MAXENAME+1);
111 } INDEXENTRY;
112 
118 #define INFILEINDEX ((512-2*sizeof(POSITION))/sizeof(INDEXENTRY))
119 
123 #define EMPTYININDEX (512-2*sizeof(POSITION)-INFILEINDEX*sizeof(INDEXENTRY))
124 
137 typedef struct FiLeInDeX {
142 } FILEINDEX;
143 
144 STATIC_ASSERT(sizeof(FILEINDEX) == 512);
145 
150 typedef struct FiLeDaTa {
151  FILEINDEX Index;
152  POSITION Fill;
153  POSITION Position;
154  WORD Handle;
155  WORD dirtyflag;
156  PADPOSITION(0,0,0,2,0);
157 } FILEDATA;
158 
165 typedef struct VaRrEnUm {
166  WORD *start;
167  WORD *lo;
168  WORD *hi;
169 } VARRENUM;
170 
177 typedef struct ReNuMbEr {
178  POSITION startposition;
179  /* First stage renumbering */
184  /* Second stage renumbering */
185  WORD *symnum;
186  WORD *indnum;
187  WORD *vecnum;
188  WORD *funnum;
189  PADPOSITION(4,0,0,0,sizeof(VARRENUM)*4);
190 } *RENUMBER;
191 
192 /*
193  #] sav&store :
194  #[ Variables :
195 */
196 
204 typedef struct {
205  void *lijst;
206  char *message;
207  int num;
208  int maxnum;
209  int size;
210  int numglobal;
211  int numtemp;
212  int numclear;
213  PADPOINTER(0,6,0,0);
214 } LIST;
215 
221 typedef struct {
222  char *name;
223  TFUN func;
224  int type;
225  int flags;
226 } KEYWORD;
227 
233 typedef struct {
234  char *name;
235  int *var;
236  int type;
237  int flags;
238 } KEYWORDV;
239 
246 typedef struct NaMeNode {
247  LONG name;
248  WORD parent;
249  WORD left;
250  WORD right;
251  WORD balance;
252  WORD type;
253  WORD number;
254  PADLONG(0,6,0);
255 } NAMENODE;
256 
264 typedef struct NaMeTree {
267  UBYTE *namebuffer;
270  LONG nodesize;
271  LONG nodefill;
272  LONG namesize;
273  LONG namefill;
274  LONG oldnamefill;
275  LONG oldnodefill;
281  WORD headnode;
282  PADPOINTER(10,0,1,0);
283 } NAMETREE;
284 
293 typedef struct tree {
294  int parent;
295  int left;
296  int right;
297  int value;
298  int blnce;
299  int usage;
300 } COMPTREE;
301 
306 typedef struct MiNmAx {
307  WORD mini;
308  WORD maxi;
309  WORD size;
310 } MINMAX;
311 
316 typedef struct BrAcKeTiNdEx { /* For indexing brackets in local expressions */
317  POSITION start; /* Place where bracket starts - start of expr */
318  POSITION next; /* Place of next indexed bracket in expr */
319  LONG bracket; /* Offset of position in bracketbuffer */
320  LONG termsinbracket;
321  PADPOSITION(0,2,0,0,0);
322 } BRACKETINDEX;
323 
328 typedef struct BrAcKeTiNfO {
331  LONG bracketbuffersize;
332  LONG indexbuffersize;
333  LONG bracketfill;
334  LONG indexfill;
335  WORD SortType;
336  PADPOINTER(4,0,1,0);
337 } BRACKETINFO;
338 
349 typedef struct TaBlEs {
351 #ifdef WITHPTHREADS
352  WORD **prototype;
353  WORD **pattern;
354 #else
355  WORD *prototype;
356  WORD *pattern;
357 #endif
359  WORD *flags;
361  UBYTE *argtail;
363  struct TaBlEs *spare;
364  WORD *buffers;
365  LONG totind;
366  LONG reserved;
367  LONG defined;
368  LONG mdefined;
370  int numind;
371  int bounds;
372  int strict;
373  int sparse;
374  int numtree;
375  int rootnum;
377  WORD bufnum;
378  WORD bufferssize;
379  WORD buffersfill;
380  WORD tablenum;
381  WORD mode;
382  WORD numdummies;
383  PADPOINTER(4,8,6,0);
384 } *TABLES;
385 
390 typedef struct ExPrEsSiOn {
391  POSITION onfile;
392  POSITION prototype;
393  POSITION size;
394  RENUMBER renum; /* For Renumbering of global stored expressions */
395  BRACKETINFO *bracketinfo;
396  BRACKETINFO *newbracketinfo;
397  WORD *renumlists;
399  WORD *inmem; /* If in memory like e.g. a polynomial */
400  LONG counter;
401  LONG name;
402  WORD hidelevel;
403  WORD vflags; /* Various flags */
404  WORD printflag;
405  WORD status;
406  WORD replace;
407  WORD node;
408  WORD whichbuffer;
409  WORD namesize;
410  WORD compression;
411  WORD numdummies;
412  WORD numfactors;
413  WORD sizeprototype;
414 #ifdef PARALLELCODE
415  WORD partodo; /* Whether to be done in parallel mode */
416  PADPOSITION(5,2,0,13,0);
417 #else
418  PADPOSITION(5,2,0,12,0);
419 #endif
420 } *EXPRESSIONS;
421 
426 typedef struct SyMbOl { /* Don't change unless altering .sav too */
427  LONG name; /* Location in names buffer */
428  WORD minpower; /* Minimum power admissible */
429  WORD maxpower; /* Maximum power admissible */
430  WORD complex; /* Properties wrt complex conjugation */
431  WORD number; /* Number when stored in file */
432  WORD flags; /* Used to indicate usage when storing */
433  WORD node;
434  WORD namesize;
435  WORD dimension; /* For dimensionality checks */
436  PADLONG(0,8,0);
437 } *SYMBOLS;
438 
443 typedef struct InDeX { /* Don't change unless altering .sav too */
444  LONG name; /* Location in names buffer */
445  WORD type; /* Regular or dummy */
446  WORD dimension; /* Value of d_(n,n) or -number of symbol */
447  WORD number; /* Number when stored in file */
448  WORD flags; /* Used to indicate usage when storing */
449  WORD nmin4; /* Used for n-4 if dimension < 0 */
450  WORD node;
451  WORD namesize;
452  PADLONG(0,7,0);
453 } *INDICES;
454 
459 typedef struct VeCtOr { /* Don't change unless altering .sav too */
460  LONG name; /* Location in names buffer */
461  WORD complex; /* Properties under complex conjugation */
462  WORD number; /* Number when stored in file */
463  WORD flags; /* Used to indicate usage when storing */
464  WORD node;
465  WORD namesize;
466  WORD dimension; /* For dimensionality checks */
467  PADLONG(0,6,0);
468 } *VECTORS;
469 
475 typedef struct FuNcTiOn { /* Don't change unless altering .sav too */
477  LONG symminfo;
478  LONG name;
479  WORD commute;
480  WORD complex;
481  WORD number;
482  WORD flags;
483  WORD spec;
484  WORD symmetric;
485  WORD node;
486  WORD namesize;
487  WORD dimension; /* For dimensionality checks */
488  WORD maxnumargs;
489  WORD minnumargs;
490  PADPOINTER(2,0,11,0);
491 } *FUNCTIONS;
492 
497 typedef struct SeTs {
498  LONG name; /* Location in names buffer */
499  WORD type; /* Symbol, vector, index or function */
500  WORD first; /* First element in setstore */
501  WORD last; /* Last element in setstore (excluding) */
502  WORD node;
503  WORD namesize;
504  WORD dimension; /* For dimensionality checks */
505  WORD flags; /* Like: ordered */
506  PADLONG(0,7,0);
507 } *SETS;
508 
513 typedef struct DuBiOuS { /* Undeclared objects. Just for compiler. */
514  LONG name; /* Location in names buffer */
515  WORD node;
516  WORD dummy;
517  PADLONG(0,2,0);
518 } *DUBIOUSV;
519 
520 typedef struct FaCdOlLaR {
521  WORD *where; /* A pointer(!) to the content */
522  LONG size;
523  WORD type; /* Type can be DOLNUMBER or DOLTERMS */
524  WORD value; /* in case it is a (short) number */
525  PADPOINTER(1,0,2,0);
526 } FACDOLLAR;
527 
528 typedef struct DoLlArS {
529  WORD *where; /* A pointer(!) to the object */
530  FACDOLLAR *factors; /* an array of factors. nfactors elements */
531 #ifdef WITHPTHREADS
532  pthread_mutex_t pthreadslockread;
533  pthread_mutex_t pthreadslockwrite;
534 #endif
535  LONG size; /* The number of words */
536  LONG name;
537  WORD type;
538  WORD node;
539  WORD index;
540  WORD zero;
541  WORD numdummies;
542  WORD nfactors;
543 #ifdef WITHPTHREADS
544  PADPOINTER(2,0,6,sizeof(pthread_mutex_t)*2);
545 #else
546  PADPOINTER(2,0,6,0);
547 #endif
548 } *DOLLARS;
549 
554 typedef struct MoDoPtDoLlArS {
555 #ifdef WITHPTHREADS
556  DOLLARS dstruct; /* If local dollar: list of DOLLARS for each thread */
557 #endif
558  WORD number;
559  WORD type;
560 #ifdef WITHPTHREADS
561  PADPOINTER(0,0,2,0);
562 #endif
563 } MODOPTDOLLAR;
564 
569 typedef struct fixedset {
570  char *name;
571  char *description;
572  int type;
573  int dimension;
574 } FIXEDSET;
575 
580 typedef struct TaBlEbAsEsUbInDeX {
581  POSITION where;
582  LONG size;
583  PADPOSITION(0,1,0,0,0);
585 
590 typedef struct TaBlEbAsE {
591  POSITION fillpoint;
592  POSITION current;
593  UBYTE *name;
594  int *tablenumbers; /* Number of each table */
595  TABLEBASESUBINDEX *subindex; /* For each table */
596  int numtables;
597  PADPOSITION(3,0,1,0,0);
598 } TABLEBASE;
599 
606 typedef struct {
607  WORD *location;
608  int numargs;
609  int numfunnies;
610  int numwildcards;
611  int symmet;
612  int tensor;
613  int commute;
614  PADPOINTER(0,6,0,0);
615 } FUN_INFO;
616 
617 /*
618  #] Variables :
619  #[ Files :
620 */
621 
633 typedef struct FiLe {
634  POSITION POposition; /* File position */
635  POSITION filesize; /* Because SEEK_END is unsafe on IBM */
636  WORD *PObuffer; /* Address of the intermediate buffer */
637  WORD *POstop; /* End of the buffer */
638  WORD *POfill; /* Fill position of the buffer */
639  WORD *POfull; /* Full buffer when only cached */
640 #ifdef WITHPTHREADS
641  WORD *wPObuffer; /* Address of the intermediate worker buffer */
642  WORD *wPOstop; /* End of the worker buffer */
643  WORD *wPOfill; /* Fill position of the worker buffer */
644  WORD *wPOfull; /* Full buffer when only worker cached */
645 #endif
646  char *name; /* name of the file */
647 #ifdef WITHZLIB
648  z_streamp zsp; /* The pointer to the stream struct for gzip */
649  Bytef *ziobuffer; /* The output buffer for compression */
650 #endif
651  ULONG numblocks; /* Number of blocks in file */
652  ULONG inbuffer; /* Block in the buffer */
653  LONG POsize; /* size of the buffer */
654 #ifdef WITHZLIB
655  LONG ziosize; /* size of the zoutbuffer */
656 #endif
657 #ifdef WITHPTHREADS
658  LONG wPOsize; /* size of the worker buffer */
659  pthread_mutex_t pthreadslock;
660 #endif
661  int handle;
662  int active; /* File is open or closed. Not used. */
663 #ifdef WITHPTHREADS
664 #ifdef WITHZLIB
665  PADPOSITION(11,5,2,0,sizeof(pthread_mutex_t));
666 #else
667  PADPOSITION(9,4,2,0,sizeof(pthread_mutex_t));
668 #endif
669 #else
670 #ifdef WITHZLIB
671  PADPOSITION(7,4,2,0,0);
672 #else
673  PADPOSITION(5,3,2,0,0);
674 #endif
675 #endif
676 } FILEHANDLE;
677 
687 typedef struct StreaM {
688  off_t fileposition;
689  off_t linenumber;
690  off_t prevline;
691  UBYTE *buffer;
692  UBYTE *pointer;
693  UBYTE *top;
694  UBYTE *FoldName;
695  UBYTE *name;
696  UBYTE *pname;
698  LONG buffersize;
699  LONG bufferposition;
700  LONG inbuffer;
701  int previous;
702  int handle;
703  int type;
704  int prevars;
705  int previousNoShowInput;
706  int eqnum;
707  int afterwards;
708  int olddelay;
709  int oldnoshowinput;
710  UBYTE isnextchar;
711  UBYTE nextchar[2];
712  UBYTE reserved;
713  PADPOSITION(6,3,9,0,4);
714 } STREAM;
715 
716 typedef struct SpecTatoR {
717  POSITION position; /* The place where we will be writing */
718  POSITION readpos; /* The place from which we read */
719  FILEHANDLE *fh;
720  char *name; /* We identify the spectator by the name of the expression */
721  WORD exprnumber; /* During running we use the number. */
722  WORD flags; /* local, global? */
723  PADPOSITION(2,0,0,2,0);
724 } SPECTATOR;
725 
726 /*
727  #] Files :
728  #[ Traces :
729 */
730 
740 typedef struct TrAcEs { /* For computing 4 dimensional traces */
741  WORD *accu; /* NUMBER * 2 */
742  WORD *accup;
743  WORD *termp;
744  WORD *perm; /* number */
745  WORD *inlist; /* number */
746  WORD *nt3; /* number/2 */
747  WORD *nt4; /* number/2 */
748  WORD *j3; /* number*2 */
749  WORD *j4; /* number*2 */
750  WORD *e3; /* number*2 */
751  WORD *e4; /* number */
752  WORD *eers; /* number/2 */
753  WORD *mepf; /* number/2 */
754  WORD *mdel; /* number/2 */
755  WORD *pepf; /* number*2 */
756  WORD *pdel; /* number*3/2 */
757  WORD sgn;
758  WORD stap;
759  WORD step1,kstep,mdum;
760  WORD gamm,ad,a3,a4,lc3,lc4;
761  WORD sign1,sign2,gamma5,num,level,factor,allsign;
762  WORD finalstep;
763  PADPOINTER(0,0,19,0);
764 } TRACES;
765 
773 typedef struct TrAcEn { /* For computing n dimensional traces */
774  WORD *accu; /* NUMBER */
775  WORD *accup;
776  WORD *termp;
777  WORD *perm; /* number */
778  WORD *inlist; /* number */
779  WORD sgn,num,level,factor,allsign;
780  PADPOINTER(0,0,5,0);
781 } *TRACEN;
782 
783 /*
784  #] Traces :
785  #[ Preprocessor :
786 */
787 
792 typedef struct pReVaR {
793  UBYTE *name;
794  UBYTE *value;
795  UBYTE *argnames;
796  int nargs;
797  int wildarg;
798  PADPOINTER(0,2,0,0);
799 } PREVAR;
800 
805 typedef struct {
806  WORD *buffer;
807  int oldcompiletype;
808  int oldparallelflag;
809  int oldnumpotmoddollars;
810  WORD size;
811  WORD numdollars;
812  WORD oldcbuf;
813  WORD oldrbuf;
814  WORD inscbuf;
815  WORD oldcnumlhs;
816  PADPOINTER(0,3,6,0);
817 } INSIDEINFO;
818 
824 typedef struct {
825  UBYTE *buffer;
826  LONG size;
827  PADPOINTER(1,0,0,0);
828 } PRELOAD;
829 
834 typedef struct {
835  PRELOAD p;
836  UBYTE *name;
837  int loadmode;
838  PADPOINTER(0,1,0,0);
839 } PROCEDURE;
840 
848 typedef struct DoLoOp {
850  UBYTE *name;
851  UBYTE *vars; /* for {} or name of expression */
852  UBYTE *contents;
853  UBYTE *dollarname;
854  LONG startlinenumber;
855  LONG firstnum;
856  LONG lastnum;
857  LONG incnum;
858  int type;
859  int NoShowInput;
860  int errorsinloop;
861  int firstloopcall;
862  WORD firstdollar; /* When >= 0 we have to get the value from a dollar */
863  WORD lastdollar; /* When >= 0 we have to get the value from a dollar */
864  WORD incdollar; /* When >= 0 we have to get the value from a dollar */
865  WORD NumPreTypes;
866  WORD PreIfLevel;
867  WORD PreSwitchLevel;
868  PADPOINTER(4,4,6,0);
869 } DOLOOP;
870 
878 struct bit_field { /* Assume 8 bits per byte */
879  UBYTE bit_0 : 1;
880  UBYTE bit_1 : 1;
881  UBYTE bit_2 : 1;
882  UBYTE bit_3 : 1;
883  UBYTE bit_4 : 1;
884  UBYTE bit_5 : 1;
885  UBYTE bit_6 : 1;
886  UBYTE bit_7 : 1;
887 /*
888  UINT bit_0 : 1;
889  UINT bit_1 : 1;
890  UINT bit_2 : 1;
891  UINT bit_3 : 1;
892  UINT bit_4 : 1;
893  UINT bit_5 : 1;
894  UINT bit_6 : 1;
895  UINT bit_7 : 1;
896 */
897 };
898 
903 typedef struct bit_field set_of_char[32];
904 
909 typedef struct bit_field *one_byte;
910 
915 typedef struct {
916  WORD newlogonly;
917  WORD newhandle;
918  WORD oldhandle;
919  WORD oldlogonly;
920  WORD oldprinttype;
921  WORD oldsilent;
922 } HANDLERS;
923 
924 /*
925  #] Preprocessor :
926  #[ Varia :
927 */
928 
929 typedef WORD (*FINISHUFFLE)(WORD *);
930 typedef WORD (*DO_UFFLE)(WORD *,WORD,WORD,WORD);
931 typedef WORD (*COMPARE)(WORD *,WORD *,WORD);
932 
938 typedef struct CbUf {
939  WORD *Buffer;
940  WORD *Top;
941  WORD *Pointer;
942  WORD **lhs;
943  WORD **rhs;
944  LONG *CanCommu;
945  LONG *NumTerms;
946  WORD *numdum;
947  WORD *dimension;
949  LONG BufferSize;
950  int numlhs;
951  int numrhs;
952  int maxlhs;
953  int maxrhs;
954  int mnumlhs;
955  int mnumrhs;
956  int numtree;
957  int rootnum;
958  int MaxTreeSize;
959  PADPOINTER(1,9,0,0);
960 } CBUF;
961 
969 typedef struct ChAnNeL {
970  char *name;
971  int handle;
972  PADPOINTER(0,1,0,0);
973 } CHANNEL;
974 
984 typedef struct {
985  UBYTE *parameter;
986  int type;
987  int flags;
988  LONG value;
990 
999 typedef struct NeStInG {
1000  WORD *termsize;
1001  WORD *funsize;
1002  WORD *argsize;
1003 } *NESTING;
1004 
1011 typedef struct StOrEcAcHe {
1012  POSITION position;
1013  POSITION toppos;
1014  struct StOrEcAcHe *next;
1015  WORD buffer[2];
1016  PADPOSITION(1,0,0,2,0);
1017 } *STORECACHE;
1018 
1024 typedef struct PeRmUtE {
1025  WORD *objects;
1026  WORD sign;
1027  WORD n;
1028  WORD cycle[MAXMATCH];
1029  PADPOINTER(0,0,MAXMATCH+2,0);
1030 } PERM;
1031 
1036 typedef struct PeRmUtEp {
1037  WORD **objects;
1038  WORD sign;
1039  WORD n;
1040  WORD cycle[MAXMATCH];
1041  PADPOINTER(0,0,MAXMATCH+2,0);
1042 } PERMP;
1043 
1049 typedef struct DiStRiBuTe {
1050  WORD *obj1;
1051  WORD *obj2;
1052  WORD *out;
1053  WORD sign;
1054  WORD n1;
1055  WORD n2;
1056  WORD n;
1057  WORD cycle[MAXMATCH];
1058  PADPOINTER(0,0,(MAXMATCH+4),0);
1059 } DISTRIBUTE;
1060 
1066 typedef struct PaRtI {
1067  WORD *psize; /* the sizes of the partitions */
1068  WORD *args; /* the offsets of the arguments to be partitioned */
1069  WORD *nargs; /* argument numbers (different number = different argument) */
1070  WORD *nfun; /* the functions into which the partitions go */
1071  WORD numargs; /* the number of arguments to be partitioned */
1072  WORD numpart; /* the number of partitions */
1073  WORD where; /* offset of the function in the term */
1074  PADPOINTER(0,0,3,0);
1075 } PARTI;
1076 
1086 typedef struct sOrT {
1087  FILEHANDLE file; /* The own sort file */
1088  POSITION SizeInFile[3]; /* Sizes in the various files */
1089  WORD *lBuffer; /* The large buffer */
1090  WORD *lTop; /* End of the large buffer */
1091  WORD *lFill; /* The filling point of the large buffer */
1092  WORD *used; /* auxiliary during actual sort */
1093  WORD *sBuffer; /* The small buffer */
1094  WORD *sTop; /* End of the small buffer */
1095  WORD *sTop2; /* End of the extension of the small buffer */
1096  WORD *sHalf; /* Halfway point in the extension */
1097  WORD *sFill; /* Filling point in the small buffer */
1098  WORD **sPointer; /* Pointers to terms in the small buffer */
1099  WORD **PoinFill; /* Filling point for pointers to the sm.buf */
1100  WORD **SplitScratch; /* Excess pointer space for the merge sort */
1101  WORD *cBuffer; /* Compress buffer (if it exists) */
1102  WORD **Patches; /* Positions of patches in large buffer */
1103  WORD **pStop; /* Ends of patches in the large buffer */
1104  WORD **poina; /* auxiliary during actual sort */
1105  WORD **poin2a; /* auxiliary during actual sort */
1106  WORD *ktoi; /* auxiliary during actual sort */
1107  WORD *tree; /* auxiliary during actual sort */
1108 #ifdef WITHZLIB
1109  WORD *fpcompressed; /* is output filepatch compressed? */
1110  WORD *fpincompressed; /* is input filepatch compressed? */
1111  z_streamp zsparray; /* the array of zstreams for decompression */
1112 #endif
1113  POSITION *fPatches; /* Positions of output file patches */
1114  POSITION *inPatches; /* Positions of input file patches */
1115  POSITION *fPatchesStop; /* Positions of output file patches */
1116  POSITION *iPatches; /* Input file patches, Points to fPatches or inPatches */
1117  FILEHANDLE *f; /* The actual output file */
1118  FILEHANDLE **ff; /* Handles for a staged sort */
1119  LONG sTerms; /* Terms in small buffer */
1120  LONG LargeSize; /* Size of large buffer (in words) */
1121  LONG SmallSize; /* Size of small buffer (in words) */
1122  LONG SmallEsize; /* Size of small + extension (in words) */
1123  LONG TermsInSmall; /* Maximum number of terms in small buffer */
1124  LONG Terms2InSmall; /* with extension for polyfuns etc. */
1125  LONG GenTerms; /* Number of generated terms */
1126  LONG TermsLeft; /* Number of terms still in existence */
1127  LONG GenSpace; /* Amount of space of generated terms */
1128  LONG SpaceLeft; /* Space needed for still existing terms */
1129  LONG putinsize; /* Size of buffer in putin */
1130  LONG ninterms; /* Which input term ? */
1131  int MaxPatches; /* Maximum number of patches in large buffer */
1132  int MaxFpatches; /* Maximum number of patches in one filesort */
1133  int type; /* Main, function or sub(routine) */
1134  int lPatch; /* Number of patches in the large buffer */
1135  int fPatchN1; /* Number of patches in input file */
1136  int PolyWise; /* Is there a polyfun and if so, where? */
1137  int PolyFlag; /* */
1138  int cBufferSize; /* Size of the compress buffer */
1139  int maxtermsize; /* Keeps track for buffer allocations */
1140  int newmaxtermsize; /* Auxiliary for maxtermsize */
1141  int outputmode; /* Tells where the output is going */
1142  int stagelevel; /* In case we have a 'staged' sort */
1143  WORD fPatchN; /* Number of patches on file (output) */
1144  WORD inNum; /* Number of patches on file (input) */
1145  WORD stage4; /* Are we using stage4? */
1146 #ifdef WITHZLIB
1147  PADPOSITION(28,12,12,3,0);
1148 #else
1149  PADPOSITION(25,12,12,3,0);
1150 #endif
1151 } SORTING;
1152 
1153 #ifdef WITHPTHREADS
1154 
1160 typedef struct SoRtBlOcK {
1161  pthread_mutex_t *MasterBlockLock;
1162  WORD **MasterStart;
1163  WORD **MasterFill;
1164  WORD **MasterStop;
1165  int MasterNumBlocks;
1166  int MasterBlock;
1167  int FillBlock;
1168  PADPOINTER(0,3,0,0);
1169 } SORTBLOCK;
1170 #endif
1171 
1172 #ifdef DEBUGGER
1173 typedef struct DeBuGgInG {
1174  int eflag;
1175  int printflag;
1176  int logfileflag;
1177  int stdoutflag;
1178 } DEBUGSTR;
1179 #endif
1180 
1181 #ifdef WITHPTHREADS
1182 
1188 typedef struct ThReAdBuCkEt {
1189  POSITION *deferbuffer; /* For Keep Brackets: remember position */
1190  WORD *threadbuffer; /* Here are the (primary) terms */
1191  WORD *compressbuffer; /* For keep brackets we need the compressbuffer */
1192  LONG threadbuffersize; /* Number of words in threadbuffer */
1193  LONG ddterms; /* Number of primary+secondary terms represented */
1194  LONG firstterm; /* The number of the first term in the bucket */
1195  LONG firstbracket; /* When doing complete brackets */
1196  LONG lastbracket; /* When doing complete brackets */
1197  pthread_mutex_t lock; /* For the load balancing phase */
1198  int free; /* Status of the bucket */
1199  int totnum; /* Total number of primary terms */
1200  int usenum; /* Which is the term being used at the moment */
1201  int busy; /* */
1202  int type; /* Doing brackets? */
1203  PADPOINTER(5,5,0,sizeof(pthread_mutex_t));
1204 } THREADBUCKET;
1205 
1206 #endif
1207 
1215 typedef struct {
1216  WORD *coefs; /* The array of coefficients */
1217  WORD numsym; /* The number of the symbol in the polynomial */
1218  WORD arraysize; /* The size of the allocation of coefs */
1219  WORD polysize; /* The maximum power in the polynomial */
1220  WORD modnum; /* The prime number of the modulus */
1221 } POLYMOD;
1222 
1223 typedef struct {
1224  WORD *outterm; /* Used in DoShuffle/Merge/FinishShuffle system */
1225  WORD *outfun;
1226  WORD *incoef;
1227  WORD *stop1;
1228  WORD *stop2;
1229  WORD *ststop1;
1230  WORD *ststop2;
1231  FINISHUFFLE finishuf;
1232  DO_UFFLE do_uffle;
1233  LONG combilast;
1234  WORD nincoef;
1235  WORD level;
1236  WORD thefunction;
1237  WORD option;
1238  PADPOINTER(1,0,4,0);
1239 } SHvariables;
1240 
1241 typedef struct { /* Used for computing calculational cost in optim.c */
1242  LONG add;
1243  LONG mul;
1244  LONG div;
1245  LONG pow;
1246 } COST;
1247 
1248 typedef struct {
1249  UWORD *a; /* The number array */
1250  UWORD *m; /* The modulus array */
1251  WORD na; /* Size of the number */
1252  WORD nm; /* size of the number in the modulus array */
1253 } MODNUM;
1254 
1255 /*
1256  Struct for optimizing outputs. If changed, do not forget to change
1257  the padding information in the AO struct.
1258 */
1259 typedef struct {
1260  union { /* we do this to allow padding */
1261  float fval;
1262  int ival[2]; /* This should be enough */
1263  } mctsconstant;
1264  int horner;
1265  int hornerdirection;
1266  int method;
1267  int mctstimelimit;
1268  int mctsnumexpand;
1269  int mctsnumkeep;
1270  int mctsnumrepeat;
1271  int greedytimelimit;
1272  int greedyminnum;
1273  int greedymaxperc;
1274  int printstats;
1275  int debugflags;
1276  int schemeflags;
1277  int mctsdecaymode;
1278  int saIter; /* Simulated annealing updates */
1279  union {
1280  float fval;
1281  int ival[2];
1282  } saMaxT; /* Maximum temperature of SA */
1283  union {
1284  float fval;
1285  int ival[2];
1286  } saMinT; /* Minimum temperature of SA */
1287 } OPTIMIZE;
1288 
1289 typedef struct {
1290  WORD *code;
1291  UBYTE *nameofexpr; /* It is easier to remember an expression by name */
1292  LONG codesize; /* We need this for the checkpoints */
1293  WORD exprnr; /* Problem here is: we renumber them in execute.c */
1294  WORD minvar;
1295  WORD maxvar;
1296 
1297  PADPOSITION(2,1,0,3,0);
1298 } OPTIMIZERESULT;
1299 
1300 typedef struct {
1301  WORD *lhs; /* Object to be replaced */
1302  WORD *rhs; /* Depending on the type it will be UBYTE* or WORD* */
1303  int type;
1304  int size; /* Size of the lhs */
1306 
1307 typedef struct {
1308  DICTIONARY_ELEMENT **elements;
1309  UBYTE *name;
1310  int sizeelements;
1311  int numelements;
1312  int numbers; /* deal with numbers */
1313  int variables; /* deal with single variables */
1314  int characters; /* deal with special characters */
1315  int funwith; /* deal with functions with arguments */
1316  int gnumelements; /* if .global shrinks the dictionary */
1317  int ranges;
1318 } DICTIONARY;
1319 
1320 typedef struct {
1321  WORD ncase;
1322  WORD value;
1323  WORD compbuffer;
1324 } SWITCHTABLE;
1325 
1326 typedef struct {
1327  SWITCHTABLE *table;
1328  SWITCHTABLE defaultcase;
1329  SWITCHTABLE endswitch;
1330  WORD typetable;
1331  WORD maxcase;
1332  WORD mincase;
1333  WORD numcases;
1334  WORD tablesize;
1335  WORD caseoffset;
1336  WORD iflevel;
1337  WORD whilelevel;
1338  WORD nestingsum;
1339  WORD padding;
1340 } SWITCH;
1341 
1342 /*
1343  The next typedef comes originally from declare.h but because new compilers
1344  do not like casting from void * to a function address we have to put it here
1345 */
1346 
1347 /*
1348  #] Varia :
1349  #[ A :
1350  #[ M : The M struct is for global settings at startup or .clear
1351 */
1352 
1360 struct M_const {
1361  POSITION zeropos; /* (M) is zero */
1363  UWORD *gcmod;
1364  UWORD *gpowmod;
1365  UBYTE *TempDir; /* (M) Path with where the temporary files go */
1366  UBYTE *TempSortDir; /* (M) Path with where the sort files go */
1367  UBYTE *IncDir; /* (M) Directory path for include files */
1368  UBYTE *InputFileName; /* (M) */
1369  UBYTE *LogFileName; /* (M) */
1370  UBYTE *OutBuffer; /* (M) Output buffer in pre.c */
1371  UBYTE *Path; /* (M) */
1372  UBYTE *SetupDir; /* (M) Directory with setup file */
1373  UBYTE *SetupFile; /* (M) Name of setup file */
1374  UBYTE *gFortran90Kind;
1375  UBYTE *gextrasym;
1376  UBYTE *ggextrasym;
1377  UBYTE *oldnumextrasymbols;
1378  SPECTATOR *SpectatorFiles;
1379 #ifdef WITHPTHREADS
1380  pthread_rwlock_t handlelock; /* (M) */
1381  pthread_mutex_t storefilelock; /* (M) */
1382  pthread_mutex_t sbuflock; /* (M) Lock for writing in the AM.sbuffer */
1383  LONG ThreadScratSize; /* (M) Size of Fscr[0/2] buffers of the workers */
1384  LONG ThreadScratOutSize; /* (M) Size of Fscr[1] buffers of the workers */
1385 #endif
1386  LONG MaxTer; /* (M) Maximum term size. Fixed at setup. In Bytes!!!*/
1387  LONG CompressSize; /* (M) Size of Compress buffer */
1388  LONG ScratSize; /* (M) Size of Fscr[] buffers */
1389  LONG HideSize; /* (M) Size of Fscr[2] buffer */
1390  LONG SizeStoreCache; /* (M) Size of the chaches for reading global expr. */
1391  LONG MaxStreamSize; /* (M) Maximum buffer size in reading streams */
1392  LONG SIOsize; /* (M) Sort InputOutput buffer size */
1393  LONG SLargeSize; /* (M) */
1394  LONG SSmallEsize; /* (M) */
1395  LONG SSmallSize; /* (M) */
1396  LONG STermsInSmall; /* (M) */
1397  LONG MaxBracketBufferSize; /* (M) Max Size for B+ or AB+ per expression */
1398  LONG hProcessBucketSize; /* (M) */
1399  LONG gProcessBucketSize; /* (M) */
1400  LONG shmWinSize; /* (M) size for shared memory window used in communications */
1401  LONG OldChildTime; /* (M) Zero time. Needed in timer. */
1402  LONG OldSecTime; /* (M) Zero time for measuring wall clock time */
1403  LONG OldMilliTime; /* (M) Same, but milli seconds */
1404  LONG WorkSize; /* (M) Size of WorkSpace */
1405  LONG gThreadBucketSize; /* (C) */
1406  LONG ggThreadBucketSize; /* (C) */
1407  LONG SumTime; /* Used in .clear */
1408  LONG SpectatorSize; /* Size of the buffer in bytes */
1409  LONG TimeLimit; /* Limit in sec to the total real time */
1410  int FileOnlyFlag; /* (M) Writing only to file */
1411  int Interact; /* (M) Interactive mode flag */
1412  int MaxParLevel; /* (M) Maximum nesting of parantheses */
1413  int OutBufSize; /* (M) size of OutBuffer */
1414  int SMaxFpatches; /* (M) */
1415  int SMaxPatches; /* (M) */
1416  int StdOut; /* (M) Regular output channel */
1417  int ginsidefirst; /* (M) Not used yet */
1418  int gDefDim; /* (M) */
1419  int gDefDim4; /* (M) */
1420  int NumFixedSets; /* (M) Number of the predefined sets */
1421  int NumFixedFunctions; /* (M) Number of built in functions */
1422  int rbufnum; /* (M) startup compiler buffer */
1423  int dbufnum; /* (M) dollar variables */
1424  int sbufnum; /* (M) subterm variables */
1425  int zbufnum; /* (M) special values */
1426  int SkipClears; /* (M) Number of .clear to skip at start */
1427  int gTokensWriteFlag; /* (M) */
1428  int gfunpowers; /* (M) */
1429  int gStatsFlag; /* (M) */
1430  int gNamesFlag; /* (M) */
1431  int gCodesFlag; /* (M) */
1432  int gSortType; /* (M) */
1433  int gproperorderflag; /* (M) */
1434  int hparallelflag; /* (M) */
1435  int gparallelflag; /* (M) */
1436  int totalnumberofthreads; /* (M) */
1437  int gSizeCommuteInSet;
1438  int gThreadStats;
1439  int ggThreadStats;
1440  int gFinalStats;
1441  int ggFinalStats;
1442  int gThreadsFlag;
1443  int ggThreadsFlag;
1444  int gThreadBalancing;
1445  int ggThreadBalancing;
1446  int gThreadSortFileSynch;
1447  int ggThreadSortFileSynch;
1448  int gProcessStats;
1449  int ggProcessStats;
1450  int gOldParallelStats;
1451  int ggOldParallelStats;
1452  int maxFlevels; /* () maximum function levels */
1453  int resetTimeOnClear; /* (M) */
1454  int gcNumDollars; /* () number of dollars for .clear */
1455  int MultiRun;
1456  int gNoSpacesInNumbers; /* For very long numbers */
1457  int ggNoSpacesInNumbers; /* For very long numbers */
1458  int gIsFortran90;
1459  int PrintTotalSize;
1460  int fbuffersize; /* Size for the AT.fbufnum factorization caches */
1461  int gOldFactArgFlag;
1462  int ggOldFactArgFlag;
1463  int gnumextrasym;
1464  int ggnumextrasym;
1465  int NumSpectatorFiles; /* Elements used in AM.spectatorfiles; */
1466  int SizeForSpectatorFiles; /* Size in AM.spectatorfiles; */
1467  int gOldGCDflag;
1468  int ggOldGCDflag;
1469  int gWTimeStatsFlag;
1470  int ggWTimeStatsFlag;
1471  int jumpratio;
1472  WORD MaxTal; /* (M) Maximum number of words in a number */
1473  WORD IndDum; /* (M) Basis value for dummy indices */
1474  WORD DumInd; /* (M) */
1475  WORD WilInd; /* (M) Offset for wildcard indices */
1476  WORD gncmod; /* (M) Global setting of modulus. size of gcmod */
1477  WORD gnpowmod; /* (M) Global printing as powers. size gpowmod */
1478  WORD gmodmode; /* (M) Global mode for modulus */
1479  WORD gUnitTrace; /* (M) Global value of Tr[1] */
1480  WORD gOutputMode; /* (M) */
1481  WORD gOutputSpaces; /* (M) */
1482  WORD gOutNumberType; /* (M) */
1483  WORD gCnumpows; /* (M) */
1484  WORD gUniTrace[4]; /* (M) */
1485  WORD MaxWildcards; /* (M) Maximum number of wildcards */
1486  WORD mTraceDum; /* (M) Position/Offset for generated dummies */
1487  WORD OffsetIndex; /* (M) */
1488  WORD OffsetVector; /* (M) */
1489  WORD RepMax; /* (M) Max repeat levels */
1490  WORD LogType; /* (M) Type of writing to log file */
1491  WORD ggStatsFlag; /* (M) */
1492  WORD gLineLength; /* (M) */
1493  WORD qError; /* (M) Only error checking {-c option} */
1494  WORD FortranCont; /* (M) Fortran Continuation character */
1495  WORD HoldFlag; /* (M) Exit on termination? */
1496  WORD Ordering[15]; /* (M) Auxiliary for ordering wildcards */
1497  WORD silent; /* (M) Silent flag. Only results in output. */
1498  WORD tracebackflag; /* (M) For tracing errors */
1499  WORD expnum; /* (M) internal number of ^ function */
1500  WORD denomnum; /* (M) internal number of / function */
1501  WORD facnum; /* (M) internal number of fac_ function */
1502  WORD invfacnum; /* (M) internal number of invfac_ function */
1503  WORD sumnum; /* (M) internal number of sum_ function */
1504  WORD sumpnum; /* (M) internal number of sump_ function */
1505  WORD OldOrderFlag; /* (M) Flag for allowing old statement order */
1506  WORD termfunnum; /* (M) internal number of term_ function */
1507  WORD matchfunnum; /* (M) internal number of match_ function */
1508  WORD countfunnum; /* (M) internal number of count_ function */
1509  WORD gPolyFun; /* (M) global value of PolyFun */
1510  WORD gPolyFunInv; /* (M) global value of Inverse of PolyFun */
1511  WORD gPolyFunType; /* (M) global value of PolyFun */
1512  WORD gPolyFunExp;
1513  WORD gPolyFunVar;
1514  WORD gPolyFunPow;
1515  WORD dollarzero; /* (M) for dollars with zero value */
1516  WORD atstartup; /* To protect against DATE_ ending in \n */
1517  WORD exitflag; /* (R) For the exit statement */
1518  WORD NumStoreCaches; /* () Number of storage caches per processor */
1519  WORD gIndentSpace; /* For indentation in output */
1520  WORD ggIndentSpace;
1523  WORD gextrasymbols;
1524  WORD ggextrasymbols;
1525  WORD zerorhs;
1526  WORD onerhs;
1527  WORD havesortdir;
1528  WORD vectorzero; /* p0_ */
1529  WORD ClearStore;
1530  WORD BracketFactors[8];
1531 #ifdef WITHPTHREADS
1532  PADPOSITION(17,26,62,83,(sizeof(pthread_rwlock_t)+sizeof(pthread_mutex_t)*2));
1533 #else
1534  PADPOSITION(17,24,62,83,0);
1535 #endif
1536 };
1537 /*
1538  #] M :
1539  #[ P : The P struct defines objects set by the preprocessor
1540 */
1548 struct P_const {
1549  LIST DollarList; /* (R) Dollar variables. Contains pointers
1550  to contents of the variables.*/
1551  LIST PreVarList; /* (R) List of preprocessor variables
1552  Points to contents. Can be changed */
1553  LIST LoopList; /* (P) List of do loops */
1554  LIST ProcList; /* (P) List of procedures */
1555  INSIDEINFO inside; /* Information during #inside/#endinside */
1556  UBYTE **PreSwitchStrings; /* (P) The string in a switch */
1557  UBYTE *preStart; /* (P) Preprocessor instruction buffer */
1558  UBYTE *preStop; /* (P) end of preStart */
1559  UBYTE *preFill; /* (P) Filling point in preStart */
1560  UBYTE *procedureExtension; /* (P) Extension for procedure files (prc) */
1561  UBYTE *cprocedureExtension; /* (P) Extension after .clear */
1562  LONG *PreAssignStack; /* For nesting #$name assignments */
1563  int *PreIfStack; /* (P) Tracks nesting of #if */
1564  int *PreSwitchModes; /* (P) Stack of switch status */
1565  int *PreTypes; /* (P) stack of #call, #do etc nesting */
1566 #ifdef WITHPTHREADS
1567  pthread_mutex_t PreVarLock; /* (P) */
1568 #endif
1569  LONG StopWatchZero; /* For `timer_' and #reset timer */
1570  LONG InOutBuf; /* (P) Characters in the output buf in pre.c */
1571  LONG pSize; /* (P) size of preStart */
1572  int PreAssignFlag; /* (C) Indicates #assign -> catch dollar */
1573  int PreContinuation; /* (C) Indicates whether the statement is new */
1574  int PreproFlag; /* (P) Internal use to mark work on prepro instr. */
1575  int iBufError; /* (P) Flag for errors with input buffer */
1576  int PreOut; /* (P) Flag for #+ #- */
1577  int PreSwitchLevel; /* (P) Nesting of #switch */
1578  int NumPreSwitchStrings; /* (P) Size of PreSwitchStrings */
1579  int MaxPreTypes; /* (P) Size of PreTypes */
1580  int NumPreTypes; /* (P) Number of nesting objects in PreTypes */
1581  int MaxPreIfLevel; /* (C) Maximum number of nested #if. Dynamic */
1582  int PreIfLevel; /* (C) Current position if PreIfStack */
1583  int PreInsideLevel; /* (C) #inside active? */
1584  int DelayPrevar; /* (P) Delaying prevar substitution */
1585  int AllowDelay; /* (P) Allow delayed prevar substitution */
1586  int lhdollarerror; /* (R) */
1587  int eat; /* () */
1588  int gNumPre; /* (P) Number of preprocessor variables for .clear */
1589  int PreDebug; /* (C) */
1590  int OpenDictionary;
1591  int PreAssignLevel; /* For nesting #$name = ...; assignments */
1592  int MaxPreAssignLevel; /* For nesting #$name = ...; assignments */
1593  WORD DebugFlag; /* (P) For debugging purposes */
1594  WORD preError; /* (P) Blocks certain types of execution */
1595  UBYTE ComChar; /* (P) Commentary character */
1596  UBYTE cComChar; /* (P) Old commentary character for .clear */
1597  PADPOINTER(3,21,2,2);
1598 };
1599 
1600 /*
1601  #] P :
1602  #[ C : The C struct defines objects changed by the compiler
1603 */
1604 
1613 struct C_const {
1615  POSITION StoreFileSize; /* () Size of store file */
1620  /* Later also for write? */
1633 /*
1634  Compile buffer variables
1635 */
1637 /*
1638  Objects for auto declarations
1639 */
1640  LIST AutoSymbolList; /* (C) */
1641  LIST AutoIndexList; /* (C) */
1642  LIST AutoVectorList; /* (C) */
1643  LIST AutoFunctionList; /* (C) */
1646  LIST *Symbols; /* (C) Pointer for autodeclare. Which list is
1647  it searching. Later also for subroutines */
1648  LIST *Indices; /* (C) id. */
1649  LIST *Vectors; /* (C) id. */
1650  LIST *Functions; /* (C) id. */
1651  NAMETREE **activenames;
1656  SWITCH *SwitchArray;
1657  WORD *SwitchHeap;
1658  LONG *termstack;
1660  UWORD *cmod;
1661  UWORD *powmod;
1662  UWORD *modpowers;
1663  UWORD *halfmod; /* (C) half the modulus when not zero */
1664  WORD *ProtoType; /* (C) The subexpression prototype {wildcards} */
1665  WORD *WildC; /* (C) Filling point for wildcards. */
1666  LONG *IfHeap;
1667  LONG *IfCount;
1668  LONG *IfStack;
1669  UBYTE *iBuffer;
1670  UBYTE *iPointer;
1671  UBYTE *iStop;
1672  UBYTE **LabelNames;
1673  WORD *FixIndices;
1675  UBYTE *WildcardNames;
1676  int *Labels;
1677  SBYTE *tokens;
1678  SBYTE *toptokens;
1679  SBYTE *endoftokens;
1681  UWORD *modinverses; /* Table for inverses of primes */
1682  UBYTE *Fortran90Kind; /* The kind of number in Fortran 90 as in _ki */
1683  WORD **MultiBracketBuf; /* Array of buffers for multi-level brackets */
1684  UBYTE *extrasym; /* Array with the name for extra symbols in ToPolynomial */
1685  WORD *doloopstack; /* To keep track of begin and end of doloops */
1686  WORD *doloopnest; /* To keep track of nesting of doloops etc */
1691  WORD *IfSumCheck;
1692  WORD *CommuteInSet; /* groups of noncommuting functions that can commute */
1693  UBYTE *TestValue; /* For debugging */
1694 #ifdef PARALLELCODE
1695  LONG *inputnumbers;
1696  WORD *pfirstnum;
1697 #endif
1698 #ifdef WITHPTHREADS
1699  pthread_mutex_t halfmodlock; /* () Lock for adding buffer for halfmod */
1700 #endif
1701  LONG argstack[MAXNEST]; /* (C) {contents} Stack for nesting of Argument */
1702  LONG insidestack[MAXNEST]; /* (C) {contents} Stack for Argument or Inside. */
1703  LONG inexprstack[MAXNEST]; /* (C) {contents} Stack for Argument or Inside. */
1704  LONG iBufferSize; /* (C) Size of the input buffer */
1705  LONG TransEname; /* (C) Used when a new definition overwrites
1706  an old expression. */
1707  LONG ProcessBucketSize; /* (C) */
1708  LONG mProcessBucketSize; /* (C) */
1709  LONG CModule; /* (C) Counter of current module */
1710  LONG ThreadBucketSize; /* (C) Roughly the maximum number of input terms */
1714  int cbufnum;
1715  int AutoDeclareFlag;
1717  int NoShowInput; /* (C) No listing of input as in .prc, #do */
1718  int ShortStats; /* (C) */
1719  int compiletype; /* (C) type of statement {DECLARATION etc} */
1720  int firstconstindex; /* (C) flag for giving first error message */
1721  int insidefirst; /* (C) Not used yet */
1722  int minsidefirst; /* (?) Not used yet */
1723  int wildflag; /* (C) Flag for marking use of wildcards */
1724  int NumLabels; /* (C) Number of labels {in Labels} */
1725  int MaxLabels; /* (C) Size of Labels array */
1726  int lDefDim; /* (C) */
1727  int lDefDim4; /* (C) */
1728  int NumWildcardNames; /* (C) Number of ?a variables */
1729  int WildcardBufferSize; /* (C) size of WildcardNames buffer */
1730  int MaxIf; /* (C) size of IfHeap, IfSumCheck, IfCount */
1731  int NumStreams; /* (C) */
1732  int MaxNumStreams; /* (C) */
1733  int firstctypemessage; /* (C) Flag for giving first st order error */
1734  int tablecheck; /* (C) For table checking */
1735  int idoption; /* (C) */
1736  int BottomLevel; /* (C) For propercount. Not used!!! */
1737  int CompileLevel; /* (C) Subexpression level */
1738  int TokensWriteFlag; /* (C) */
1739  int UnsureDollarMode; /* (C)?Controls error messages undefined $'s */
1740  int outsidefun; /* (C) Used for writing Tables to file */
1741  int funpowers; /* (C) */
1742  int WarnFlag; /* (C) */
1743  int StatsFlag; /* (C) */
1744  int NamesFlag; /* (C) */
1745  int CodesFlag; /* (C) */
1746  int SetupFlag; /* (C) */
1747  int SortType; /* (C) */
1748  int lSortType; /* (C) */
1749  int ThreadStats; /* (C) */
1750  int FinalStats; /* (C) */
1751  int OldParallelStats; /* (C) */
1752  int ThreadsFlag;
1753  int ThreadBalancing;
1754  int ThreadSortFileSynch;
1755  int ProcessStats; /* (C) */
1756  int BracketNormalize; /* (C) Indicates whether the bracket st is normalized */
1757  int maxtermlevel; /* (C) Size of termstack */
1758  int dumnumflag; /* (C) Where there dummy indices in tokenizer? */
1759  int bracketindexflag; /* (C) Are brackets going to be indexed? */
1760  int parallelflag; /* (C) parallel allowed? */
1761  int mparallelflag; /* (C) parallel allowed in this module? */
1762  int inparallelflag; /* (C) inparallel allowed? */
1763  int partodoflag; /* (C) parallel allowed? */
1764  int properorderflag; /* (C) clean normalizing. */
1765  int vetofilling; /* (C) vetoes overwriting in tablebase stubs */
1766  int tablefilling; /* (C) to notify AddRHS we are filling a table */
1767  int vetotablebasefill; /* (C) For the load in tablebase */
1768  int exprfillwarning; /* (C) Warning has been printed for expressions in fill statements */
1769  int lhdollarflag; /* (R) left hand dollar present */
1770  int NoCompress; /* (R) Controls native compression */
1771  int IsFortran90; /* Tells whether the Fortran is Fortran90 */
1772  int MultiBracketLevels; /* Number of elements in MultiBracketBuf */
1773  int topolynomialflag; /* To avoid ToPolynomial and FactArg together */
1774  int ffbufnum; /* Buffer number for user defined factorizations */
1775  int OldFactArgFlag;
1776  int MemDebugFlag; /* Only used when MALLOCDEBUG in tools.c */
1777  int OldGCDflag;
1778  int WTimeStatsFlag;
1779  int doloopstacksize;
1780  int dolooplevel;
1785  int SizeCommuteInSet; /* Size of the CommuteInSet buffer */
1786 #ifdef PARALLELCODE
1787  int numpfirstnum; /* For redefine */
1788  int sizepfirstnum; /* For redefine */
1789 #endif
1790  int origin; /* Determines whether .sort or ModuleOption */
1791  int vectorlikeLHS;
1792  WORD argsumcheck[MAXNEST]; /* (C) Checking of nesting */
1793  WORD insidesumcheck[MAXNEST];/* (C) Checking of nesting */
1794  WORD inexprsumcheck[MAXNEST];/* (C) Checking of nesting */
1795  WORD RepSumCheck[MAXREPEAT];/* (C) Checks nesting of repeat, if, argument */
1796  WORD lUniTrace[4]; /* (C) */
1797  WORD RepLevel; /* (C) Tracks nesting of repeat. */
1798  WORD arglevel; /* (C) level of nested argument statements */
1799  WORD insidelevel; /* (C) level of nested inside statements */
1800  WORD inexprlevel; /* (C) level of nested inexpr statements */
1801  WORD termlevel; /* (C) level of nested term statements */
1802  WORD MustTestTable; /* (C) Indicates whether tables have been changed */
1803  WORD DumNum; /* (C) */
1804  WORD ncmod; /* (C) Local setting of modulus. size of cmod */
1805  WORD npowmod; /* (C) Local printing as powers. size powmod */
1806  WORD modmode; /* (C) Mode for modulus calculus */
1807  WORD nhalfmod; /* relevant word size of halfmod when defined */
1808  WORD DirtPow; /* (C) Flag for changes in printing mod powers */
1809  WORD lUnitTrace; /* (C) Local value of Tr[1] */
1810  WORD NwildC; /* (C) Wildcard counter */
1811  WORD ComDefer; /* (C) defer brackets */
1812  WORD CollectFun; /* (C) Collect function number */
1813  WORD AltCollectFun; /* (C) Alternate Collect function number */
1814  WORD OutputMode; /* (C) */
1815  WORD Cnumpows;
1816  WORD OutputSpaces; /* (C) */
1817  WORD OutNumberType; /* (C) Controls RATIONAL/FLOAT output */
1818  WORD DidClean; /* (C) Test whether nametree needs cleaning */
1819  WORD IfLevel; /* (C) */
1820  WORD WhileLevel; /* (C) */
1821  WORD SwitchLevel;
1822  WORD SwitchInArray;
1823  WORD MaxSwitch;
1824  WORD LogHandle; /* (C) The Log File */
1825  WORD LineLength; /* (C) */
1826  WORD StoreHandle; /* (C) Handle of .str file */
1827  WORD HideLevel; /* (C) Hiding indicator */
1828  WORD lPolyFun; /* (C) local value of PolyFun */
1829  WORD lPolyFunInv; /* (C) local value of Inverse of PolyFun */
1830  WORD lPolyFunType; /* (C) local value of PolyFunType */
1831  WORD lPolyFunExp;
1832  WORD lPolyFunVar;
1833  WORD lPolyFunPow;
1834  WORD SymChangeFlag; /* (C) */
1835  WORD CollectPercentage; /* (C) Collect function percentage */
1836  WORD ShortStatsMax; /* For On FewerStatistics 10; */
1837  WORD extrasymbols; /* Flag for the extra symbsols output mode */
1838  WORD PolyRatFunChanged; /* Keeps track whether we changed in the compiler */
1839  WORD ToBeInFactors;
1840  WORD InnerTest; /* For debugging */
1841 #ifdef WITHMPI
1842  WORD RhsExprInModuleFlag; /* (C) Set by the compiler if RHS expressions exists. */
1843 #endif
1844  UBYTE Commercial[COMMERCIALSIZE+2]; /* (C) Message to be printed in statistics */
1845  UBYTE debugFlags[MAXFLAGS+2]; /* On/Off Flag number(s) */
1846 #if defined(WITHPTHREADS)
1847  PADPOSITION(49,8+3*MAXNEST,72,48+3*MAXNEST+MAXREPEAT,COMMERCIALSIZE+MAXFLAGS+4+sizeof(LIST)*17+sizeof(pthread_mutex_t));
1848 #elif defined(WITHMPI)
1849  PADPOSITION(49,8+3*MAXNEST,72,49+3*MAXNEST+MAXREPEAT,COMMERCIALSIZE+MAXFLAGS+4+sizeof(LIST)*17);
1850 #else
1851  PADPOSITION(47,8+3*MAXNEST,70,48+3*MAXNEST+MAXREPEAT,COMMERCIALSIZE+MAXFLAGS+4+sizeof(LIST)*17);
1852 #endif
1853 };
1854 /*
1855  #] C :
1856  #[ S : The S struct defines objects changed at the start of the run (Processor)
1857  Basically only set by the master.
1858 */
1866 struct S_const {
1867  POSITION MaxExprSize; /* ( ) Maximum size of in/out/sort */
1868 #ifdef WITHPTHREADS
1869  pthread_mutex_t inputslock;
1870  pthread_mutex_t outputslock;
1871  pthread_mutex_t MaxExprSizeLock;
1872 #endif
1873  POSITION *OldOnFile; /* (S) File positions of expressions */
1874  WORD *OldNumFactors; /* ( ) NumFactors in (old) expression */
1875  WORD *Oldvflags; /* ( ) vflags in (old) expression */
1876  int NumOldOnFile; /* (S) Number of expressions in OldOnFile */
1877  int NumOldNumFactors; /* (S) Number of expressions in OldNumFactors */
1878  int MultiThreaded; /* (S) Are we running multi-threaded? */
1879 #ifdef WITHPTHREADS
1880  int MasterSort; /* Final stage of sorting to the master */
1881 #endif
1882 #ifdef WITHMPI
1883  int printflag; /* controls MesPrint() on each slave */
1884 #endif
1885  int Balancing; /* For second stage loadbalancing */
1886  WORD ExecMode; /* (S) */
1887 
1888  WORD CollectOverFlag; /* (R) Indicates overflow at Collect */
1889 #ifdef WITHPTHREADS
1890  WORD sLevel; /* Copy of AR0.sLevel because it can get messy */
1891 #endif
1892 #if defined(WITHPTHREADS)
1893  PADPOSITION(3,0,5,3,sizeof(pthread_mutex_t)*3);
1894 #elif defined(WITHMPI)
1895  PADPOSITION(3,0,5,2,0);
1896 #else
1897  PADPOSITION(3,0,4,2,0);
1898 #endif
1899 };
1900 /*
1901  #] S :
1902  #[ R : The R struct defines objects changed at run time.
1903  They determine the environment that has to be transfered
1904  together with a term during multithreaded execution.
1905 */
1914 struct R_const {
1915  FILEDATA StoreData; /* (O) */
1916  FILEHANDLE Fscr[3]; /* (R) Dollars etc play with it too */
1917  FILEHANDLE FoStage4[2]; /* (R) In Sort. Stage 4. */
1918  POSITION DefPosition; /* (R) Deferred position of keep brackets. */
1919  FILEHANDLE *infile; /* (R) Points alternatingly to Fscr[0] or Fscr[1] */
1920  FILEHANDLE *outfile; /* (R) Points alternatingly to Fscr[1] or Fscr[0] */
1921  FILEHANDLE *hidefile; /* (R) Points to Fscr[2] */
1922 
1923  WORD *CompressBuffer; /* (M) */
1924  WORD *ComprTop; /* (M) */
1925  WORD *CompressPointer; /* (R) */
1926  COMPARE CompareRoutine;
1927  ULONG *wranfia;
1928 
1929  LONG OldTime; /* (R) Zero time. Needed in timer. */
1930  LONG InInBuf; /* (R) Characters in input buffer. Scratch files. */
1931  LONG InHiBuf; /* (R) Characters in hide buffer. Scratch file. */
1932  LONG pWorkSize; /* (R) Size of pWorkSpace */
1933  LONG lWorkSize; /* (R) Size of lWorkSpace */
1934  LONG posWorkSize; /* (R) Size of posWorkSpace */
1935  ULONG wranfseed;
1936  int NoCompress; /* (R) Controls native compression */
1937  int gzipCompress; /* (R) Controls gzip compression */
1938  int Cnumlhs; /* Local copy of cbuf[rbufnum].numlhs */
1939  int outtohide; /* Indicates that output is directly to hide */
1940 #ifdef WITHPTHREADS
1941  int exprtodo; /* The expression to do in parallel mode */
1942 #endif
1943  int wranfcall;
1944  int wranfnpair1;
1945  int wranfnpair2;
1946 #if ( BITSINWORD == 32 )
1947  WORD PrimeList[5000];
1948  WORD numinprimelist;
1949  WORD notfirstprime;
1950 #endif
1951  WORD GetFile; /* (R) Where to get the terms {like Hide} */
1952  WORD KeptInHold; /* (R) */
1953  WORD BracketOn; /* (R) Intensly used in poly_ */
1954  WORD MaxBracket; /* (R) Size of BrackBuf. Changed by poly_ */
1955  WORD CurDum; /* (R) Current maximum dummy number */
1956  WORD DeferFlag; /* (R) For defered brackets */
1957  WORD TePos; /* (R) */
1958  WORD sLevel; /* (R) Sorting level */
1959  WORD Stage4Name; /* (R) Sorting only */
1960  WORD GetOneFile; /* (R) Getting from hide or regular */
1961  WORD PolyFun; /* (C) Number of the PolyFun function */
1962  WORD PolyFunInv; /* (C) Number of the Inverse of the PolyFun function */
1963  WORD PolyFunType; /* () value of PolyFunType */
1964  WORD PolyFunExp;
1965  WORD PolyFunVar;
1966  WORD PolyFunPow;
1967  WORD Eside; /* () Tells which side of = sign */
1968  WORD MaxDum; /* Maximum dummy value in an expression */
1969  WORD level; /* Running level in Generator */
1970  WORD expchanged; /* (R) Info about expression */
1971  WORD expflags; /* (R) Info about expression */
1972  WORD CurExpr; /* (S) Number of current expression */
1973  WORD SortType; /* A copy of AC.SortType to play with */
1974  WORD ShortSortCount; /* For On FewerStatistics 10; */
1975 #if ( BITSINWORD == 32 )
1976 #ifdef WITHPTHREADS
1977  PADPOSITION(8,7,8,5026,0);
1978 #else
1979  PADPOSITION(8,7,7,5026,0);
1980 #endif
1981 #else
1982 #ifdef WITHPTHREADS
1983  PADPOSITION(8,7,8,24,0);
1984 #else
1985  PADPOSITION(8,7,7,24,0);
1986 #endif
1987 #endif
1988 };
1989 
1990 /*
1991  #] R :
1992  #[ T : These are variables that stay in each thread during multi threaded execution.
1993 */
2002 struct T_const {
2003 #ifdef WITHPTHREADS
2004  SORTBLOCK SB;
2005 #endif
2006  SORTING *S0; /* (-) The thread specific sort buffer */
2007  SORTING *SS; /* (R) Current sort buffer */
2008  NESTING Nest; /* (R) Nesting of function levels etc. */
2009  NESTING NestStop; /* (R) */
2010  NESTING NestPoin; /* (R) */
2011  WORD *BrackBuf; /* (R) Bracket buffer. Used by poly_ at runtime. */
2012  STORECACHE StoreCache; /* (R) Cache for picking up stored expr. */
2013  STORECACHE StoreCacheAlloc; /* (R) Permanent address of StoreCache to keep valgrind happy */
2014  WORD **pWorkSpace; /* (R) Workspace for pointers. Dynamic. */
2015  LONG *lWorkSpace; /* (R) WorkSpace for LONG. Dynamic. */
2016  POSITION *posWorkSpace; /* (R) WorkSpace for file positions */
2017  WORD *WorkSpace; /* (M) */
2018  WORD *WorkTop; /* (M) */
2019  WORD *WorkPointer; /* (R) Pointer in the WorkSpace heap. */
2020  int *RepCount; /* (M) Buffer for repeat nesting */
2021  int *RepTop; /* (M) Top of RepCount buffer */
2022  WORD *WildArgTaken; /* (N) Stack for wildcard pattern matching */
2023  UWORD *factorials; /* (T) buffer of factorials. Dynamic. */
2024  WORD *small_power_n; /* length of the number */
2025  UWORD **small_power; /* the number*/
2026  UWORD *bernoullis; /* (T) The buffer with bernoulli numbers. Dynamic. */
2027  WORD *primelist;
2028  LONG *pfac; /* (T) array of positions of factorials. Dynamic. */
2029  LONG *pBer; /* (T) array of positions of Bernoulli's. Dynamic. */
2030  WORD *TMaddr; /* (R) buffer for TestSub */
2031  WORD *WildMask; /* (N) Wildcard info during pattern matching */
2032  WORD *previousEfactor; /* () Cache for factors in expressions */
2033  WORD **TermMemHeap; /* For TermMalloc. Set zero in Checkpoint */
2034  UWORD **NumberMemHeap; /* For NumberMalloc. Set zero in Checkpoint */
2035  UWORD **CacheNumberMemHeap; /* For CacheNumberMalloc. Set zero in Checkpoint */
2036  BRACKETINFO *bracketinfo;
2037  WORD **ListPoly;
2038  WORD *ListSymbols;
2039  UWORD *NumMem;
2040  WORD *TopologiesTerm;
2041  WORD *TopologiesStart;
2042  PARTI partitions;
2043  LONG sBer; /* (T) Size of the bernoullis buffer */
2044  LONG pWorkPointer; /* (R) Offset-pointer in pWorkSpace */
2045  LONG lWorkPointer; /* (R) Offset-pointer in lWorkSpace */
2046  LONG posWorkPointer; /* (R) Offset-pointer in posWorkSpace */
2047  LONG InNumMem;
2048  int sfact; /* (T) size of the factorials buffer */
2049  int mfac; /* (T) size of the pfac array. */
2050  int ebufnum; /* (R) extra compiler buffer */
2051  int fbufnum; /* extra compiler buffer for factorization cache */
2052  int allbufnum; /* extra compiler buffer for id,all */
2053  int aebufnum; /* extra compiler buffer for id,all */
2054  int idallflag; /* indicates use of id,all buffers */
2055  int idallnum;
2056  int idallmaxnum;
2057  int WildcardBufferSize; /* () local copy for updates */
2058 #ifdef WITHPTHREADS
2059  int identity; /* () When we work with B->T */
2060  int LoadBalancing; /* Needed for synchronization */
2061 #ifdef WITHSORTBOTS
2062  int SortBotIn1; /* Input stream 1 for a SortBot */
2063  int SortBotIn2; /* Input stream 2 for a SortBot */
2064 #endif
2065 #endif
2066  int TermMemMax; /* For TermMalloc. Set zero in Checkpoint */
2067  int TermMemTop; /* For TermMalloc. Set zero in Checkpoint */
2068  int NumberMemMax; /* For NumberMalloc. Set zero in Checkpoint */
2069  int NumberMemTop; /* For NumberMalloc. Set zero in Checkpoint */
2070  int CacheNumberMemMax; /* For CacheNumberMalloc. Set zero in Checkpoint */
2071  int CacheNumberMemTop; /* For CacheNumberMalloc. Set zero in Checkpoint */
2072  int bracketindexflag; /* Are brackets going to be indexed? */
2073  int optimtimes; /* Number of the evaluation of the MCTS tree */
2074  int ListSymbolsSize;
2075  int NumListSymbols;
2076  int numpoly;
2077  int LeaveNegative;
2078  int TrimPower; /* Indicates trimming in polyratfun expansion */
2079  WORD small_power_maxx; /* size of the cache for small powers */
2080  WORD small_power_maxn; /* size of the cache for small powers */
2081  WORD dummysubexp[SUBEXPSIZE+4]; /* () used in normal.c */
2082  WORD comsym[8]; /* () Used in tools.c = {8,SYMBOL,4,0,1,1,1,3} */
2083  WORD comnum[4]; /* () Used in tools.c = { 4,1,1,3 } */
2084  WORD comfun[FUNHEAD+4]; /* () Used in tools.c = {7,FUNCTION,3,0,1,1,3} */
2085  /* or { 8,FUNCTION,4,0,0,1,1,3 } */
2086  WORD comind[7]; /* () Used in tools.c = {7,INDEX,3,0,1,1,3} */
2087  WORD MinVecArg[7+ARGHEAD]; /* (N) but should be more local */
2088  WORD FunArg[4+ARGHEAD+FUNHEAD]; /* (N) but can be more local */
2089  WORD locwildvalue[SUBEXPSIZE]; /* () Used in argument.c = {SUBEXPRESSION,SUBEXPSIZE,0,0,0} */
2090  WORD mulpat[SUBEXPSIZE+5]; /* () Used in argument.c = {TYPEMULT, SUBEXPSIZE+3, 0, */
2091  /* SUBEXPRESSION, SUBEXPSIZE, 0, 1, 0, 0, 0 } */
2092  WORD proexp[SUBEXPSIZE+5]; /* () Used in poly.c */
2093  WORD TMout[40]; /* (R) Passing info */
2094  WORD TMbuff; /* (R) Communication between TestSub and Genera */
2095  WORD TMdolfac; /* factor number for dollar */
2096  WORD nfac; /* (T) Number of highest stored factorial */
2097  WORD nBer; /* (T) Number of highest bernoulli number. */
2098  WORD mBer; /* (T) Size of buffer pBer. */
2099  WORD PolyAct; /* (R) Used for putting the PolyFun at end. ini at 0 */
2100  WORD RecFlag; /* (R) Used in TestSub. ini at zero. */
2101  WORD inprimelist;
2102  WORD sizeprimelist;
2103  WORD fromindex; /* Tells the compare routine whether call from index */
2104  WORD setinterntopo; /* Set of internal momenta for topogen */
2105  WORD setexterntopo; /* Set of external momenta for topogen */
2106  WORD TopologiesLevel;
2107  WORD TopologiesOptions[2];
2108 #ifdef WITHPTHREADS
2109 #ifdef WITHSORTBOTS
2110  PADPOINTER(5,27,105+SUBEXPSIZE*4+FUNHEAD*2+ARGHEAD*2,0);
2111 #else
2112  PADPOINTER(5,25,105+SUBEXPSIZE*4+FUNHEAD*2+ARGHEAD*2,0);
2113 #endif
2114 #else
2115  PADPOINTER(5,23,105+SUBEXPSIZE*4+FUNHEAD*2+ARGHEAD*2,0);
2116 #endif
2117 };
2118 /*
2119  #] T :
2120  #[ N : The N struct contains variables used in running information
2121  that is inside blocks that should not be split, like pattern
2122  matching, traces etc. They are local for each thread.
2123  They don't need initializations.
2124 */
2133 struct N_const {
2134  POSITION OldPosIn; /* (R) Used in sort. */
2135  POSITION OldPosOut; /* (R) Used in sort */
2136  POSITION theposition; /* () Used in index.c */
2137  WORD *EndNest; /* (R) Nesting of function levels etc. */
2138  WORD *Frozen; /* (R) Bracket info */
2139  WORD *FullProto; /* (R) Prototype of a subexpression or table */
2140  WORD *cTerm; /* (R) Current term for coef_ and term_ */
2141  int *RepPoint; /* (R) Pointer in RepCount buffer. Tracks repeat */
2142  WORD *WildValue; /* (N) Wildcard info during pattern matching */
2143  WORD *WildStop; /* (N) Wildcard info during pattern matching */
2144  WORD *argaddress; /* (N) Used in pattern matching of arguments */
2145  WORD *RepFunList; /* (N) For pattern matching */
2146  WORD *patstop; /* (N) Used in pattern matching */
2147  WORD *terstop; /* (N) Used in pattern matching */
2148  WORD *terstart; /* (N) Used in pattern matching */
2149  WORD *terfirstcomm; /* (N) Used in pattern matching */
2150  WORD *DumFound; /* (N) For renumbering indices {make local?} */
2151  WORD **DumPlace; /* (N) For renumbering indices {make local?} */
2152  WORD **DumFunPlace; /* (N) For renumbering indices {make local?} */
2153  WORD *UsedSymbol; /* (N) When storing terms of a global expr. */
2154  WORD *UsedVector; /* (N) When storing terms of a global expr. */
2155  WORD *UsedIndex; /* (N) When storing terms of a global expr. */
2156  WORD *UsedFunction; /* (N) When storing terms of a global expr. */
2157  WORD *MaskPointer; /* (N) For wildcard pattern matching */
2158  WORD *ForFindOnly; /* (N) For wildcard pattern matching */
2159  WORD *findTerm; /* (N) For wildcard pattern matching */
2160  WORD *findPattern; /* (N) For wildcard pattern matching */
2161 #ifdef WITHZLIB
2162  Bytef **ziobufnum; /* () Used in compress.c */
2163  Bytef *ziobuffers; /* () Used in compress.c */
2164 #endif
2165  WORD *dummyrenumlist; /* () Used in execute.c and store.c */
2166  int *funargs; /* () Used in lus.c */
2167  WORD **funlocs; /* () Used in lus.c */
2168  int *funinds; /* () Used in lus.c */
2169  UWORD *NoScrat2; /* () Used in normal.c */
2170  WORD *ReplaceScrat; /* () Used in normal.c */
2171  TRACES *tracestack; /* () used in opera.c */
2172  WORD *selecttermundo; /* () Used in pattern.c */
2173  WORD *patternbuffer; /* () Used in pattern.c */
2174  WORD *termbuffer; /* () Used in pattern.c */
2175  WORD **PoinScratch; /* () used in reshuf.c */
2176  WORD **FunScratch; /* () used in reshuf.c */
2177  WORD *RenumScratch; /* () used in reshuf.c */
2178  FUN_INFO *FunInfo; /* () Used in smart.c */
2179  WORD **SplitScratch; /* () Used in sort.c */
2180  WORD **SplitScratch1; /* () Used in sort.c */
2181  SORTING **FunSorts; /* () Used in sort.c */
2182  UWORD *SoScratC; /* () Used in sort.c */
2183  WORD *listinprint; /* () Used in proces.c and message.c */
2184  WORD *currentTerm; /* () Used in proces.c and message.c */
2185  WORD **arglist; /* () Used in function.c */
2186  int *tlistbuf; /* () used in lus.c */
2187 #ifdef WHICHSUBEXPRESSION
2188  UWORD *BinoScrat; /* () Used in proces.c */
2189 #endif
2190  WORD *compressSpace; /* () Used in sort.c */
2191 #ifdef WITHPTHREADS
2192  THREADBUCKET *threadbuck;
2193  EXPRESSIONS expr;
2194 #endif
2195  UWORD *SHcombi;
2196  WORD *poly_vars;
2197  UWORD *cmod; /* Local setting of modulus. Pointer to value. */
2198  SHvariables SHvar;
2199  LONG deferskipped; /* () Used in proces.c store.c and parallel.c */
2200  LONG InScratch; /* () Used in sort.c */
2201  LONG SplitScratchSize; /* () Used in sort.c */
2202  LONG InScratch1; /* () Used in sort.c */
2203  LONG SplitScratchSize1; /* () Used in sort.c */
2204  LONG ninterms; /* () Used in proces.c and sort.c */
2205 #ifdef WITHPTHREADS
2206  LONG inputnumber; /* () For use in redefine */
2207  LONG lastinindex;
2208 #endif
2209 #ifdef WHICHSUBEXPRESSION
2210  LONG last2; /* () Used in proces.c */
2211  LONG last3; /* () Used in proces.c */
2212 #endif
2213  LONG SHcombisize;
2214  int NumTotWildArgs; /* (N) Used in pattern matching */
2215  int UseFindOnly; /* (N) Controls pattern routines */
2216  int UsedOtherFind; /* (N) Controls pattern routines */
2217  int ErrorInDollar; /* (R) */
2218  int numfargs; /* () Used in lus.c */
2219  int numflocs; /* () Used in lus.c */
2220  int nargs; /* () Used in lus.c */
2221  int tohunt; /* () Used in lus.c */
2222  int numoffuns; /* () Used in lus.c */
2223  int funisize; /* () Used in lus.c */
2224  int RSsize; /* () Used in normal.c */
2225  int numtracesctack; /* () used in opera.c */
2226  int intracestack; /* () used in opera.c */
2227  int numfuninfo; /* () Used in smart.c */
2228  int NumFunSorts; /* () Used in sort.c */
2229  int MaxFunSorts; /* () Used in sort.c */
2230  int arglistsize; /* () Used in function.c */
2231  int tlistsize; /* () used in lus.c */
2232  int filenum; /* () used in setfile.c */
2233  int compressSize; /* () Used in sort.c */
2234  int polysortflag;
2235  int nogroundlevel; /* () Used to see whether pattern matching at groundlevel */
2236  int subsubveto; /* () Sabotage combining subexpressions in TestSub */
2237  WORD MaxRenumScratch; /* () used in reshuf.c */
2238  WORD oldtype; /* (N) WildCard info at pattern matching */
2239  WORD oldvalue; /* (N) WildCard info at pattern matching */
2240  WORD NumWild; /* (N) Used in Wildcard */
2241  WORD RepFunNum; /* (N) Used in pattern matching */
2242  WORD DisOrderFlag; /* (N) Disorder option? Used in pattern matching */
2243  WORD WildDirt; /* (N) dirty in wldcard substitution. */
2244  WORD NumFound; /* (N) in reshuf only. Local? */
2245  WORD WildReserve; /* (N) Used in the wildcards */
2246  WORD TeInFun; /* (R) Passing type of action */
2247  WORD TeSuOut; /* (R) Passing info. Local? */
2248  WORD WildArgs; /* (R) */
2249  WORD WildEat; /* (R) */
2250  WORD PolyNormFlag; /* (R) For polynomial arithmetic */
2251  WORD PolyFunTodo; /* deals with expansions and multiplications */
2252  WORD sizeselecttermundo; /* () Used in pattern.c */
2253  WORD patternbuffersize; /* () Used in pattern.c */
2254  WORD numlistinprint; /* () Used in process.c */
2255  WORD ncmod; /* () used as some type of flag to disable */
2256  WORD ExpectedSign;
2257  WORD SignCheck;
2258  WORD IndDum; /* Active dummy indices */
2259  WORD poly_num_vars;
2260  WORD idfunctionflag;
2261  WORD poly_vars_type; /* type of allocation. For free. */
2262  WORD tryterm; /* For EndSort(...,2) */
2263 #ifdef WHICHSUBEXPRESSION
2264  WORD nbino; /* () Used in proces.c */
2265  WORD last1; /* () Used in proces.c */
2266 #endif
2267 #ifdef WITHPTHREADS
2268 #ifdef WHICHSUBEXPRESSION
2269 #ifdef WITHZLIB
2270  PADPOSITION(55,11,23,28,sizeof(SHvariables));
2271 #else
2272  PADPOSITION(53,11,23,28,sizeof(SHvariables));
2273 #endif
2274 #else
2275 #ifdef WITHZLIB
2276  PADPOSITION(54,9,23,26,sizeof(SHvariables));
2277 #else
2278  PADPOSITION(52,9,23,26,sizeof(SHvariables));
2279 #endif
2280 #endif
2281 #else
2282 #ifdef WHICHSUBEXPRESSION
2283 #ifdef WITHZLIB
2284  PADPOSITION(53,9,23,28,sizeof(SHvariables));
2285 #else
2286  PADPOSITION(51,9,23,28,sizeof(SHvariables));
2287 #endif
2288 #else
2289 #ifdef WITHZLIB
2290  PADPOSITION(52,7,23,26,sizeof(SHvariables));
2291 #else
2292  PADPOSITION(50,7,23,26,sizeof(SHvariables));
2293 #endif
2294 #endif
2295 #endif
2296 };
2297 
2298 /*
2299  #] N :
2300  #[ O : The O struct concerns output variables
2301 */
2310 struct O_const {
2311  FILEDATA SaveData; /* (O) */
2312  STOREHEADER SaveHeader; /* () System Independent save-Files */
2313  OPTIMIZERESULT OptimizeResult;
2314  UBYTE *OutputLine; /* (O) Sits also in debug statements */
2315  UBYTE *OutStop; /* (O) Top of OutputLine buffer */
2316  UBYTE *OutFill; /* (O) Filling point in OutputLine buffer */
2317  WORD *bracket; /* (O) For writing brackets */
2318  WORD *termbuf; /* (O) For writing terms */
2319  WORD *tabstring;
2320  UBYTE *wpos; /* (O) Only when storing file {local?} */
2321  UBYTE *wpoin; /* (O) Only when storing file {local?} */
2322  UBYTE *DollarOutBuffer; /* (O) Outputbuffer for Dollars */
2323  UBYTE *CurBufWrt; /* (O) Name of currently written expr. */
2324  VOID (*FlipWORD)(UBYTE *); /* () Function pointers for translations. Initialized by ReadSaveHeader() */
2325  VOID (*FlipLONG)(UBYTE *);
2326  VOID (*FlipPOS)(UBYTE *);
2327  VOID (*FlipPOINTER)(UBYTE *);
2328  VOID (*ResizeData)(UBYTE *,int,UBYTE *,int);
2329  VOID (*ResizeWORD)(UBYTE *,UBYTE *);
2330  VOID (*ResizeNCWORD)(UBYTE *,UBYTE *);
2331  VOID (*ResizeLONG)(UBYTE *,UBYTE *);
2332  VOID (*ResizePOS)(UBYTE *,UBYTE *);
2333  VOID (*ResizePOINTER)(UBYTE *,UBYTE *);
2334  VOID (*CheckPower)(UBYTE *);
2335  VOID (*RenumberVec)(UBYTE *);
2336  DICTIONARY **Dictionaries;
2337  UBYTE *tensorList; /* Dynamically allocated list with functions that are tensorial. */
2338  WORD *inscheme; /* for feeding a Horner scheme to Optimize */
2339 /*----Leave NumInBrack as first non-pointer. This is used by the checkpoints--*/
2340  LONG NumInBrack; /* (O) For typing [] option in print */
2341  LONG wlen; /* (O) Used to store files. */
2342  LONG DollarOutSizeBuffer; /* (O) Size of DollarOutBuffer */
2343  LONG DollarInOutBuffer; /* (O) Characters in DollarOutBuffer */
2344 #if defined(mBSD) && defined(MICROTIME)
2345  LONG wrap; /* (O) For statistics time. wrap around */
2346  LONG wrapnum; /* (O) For statistics time. wrap around */
2347 #endif
2348  OPTIMIZE Optimize;
2349  int OutInBuffer; /* (O) Which routine does the writing */
2350  int NoSpacesInNumbers; /* For very long numbers */
2351  int BlockSpaces; /* For very long numbers */
2352  int CurrentDictionary;
2353  int SizeDictionaries;
2354  int NumDictionaries;
2355  int CurDictNumbers;
2356  int CurDictVariables;
2357  int CurDictSpecials;
2358  int CurDictFunWithArgs;
2359  int CurDictNumberWarning;
2360  int CurDictNotInFunctions;
2361  int CurDictInDollars;
2362  int gNumDictionaries;
2363  WORD schemenum; /* for feeding a Horner scheme to Optimize */
2364  WORD transFlag; /* () >0 indicades that translations have to be done */
2365  WORD powerFlag; /* () >0 indicades that some exponents/powers had to be adjusted */
2366  WORD mpower; /* For maxpower adjustment to larger value */
2367  WORD resizeFlag; /* () >0 indicades that something went wrong when resizing words */
2368  WORD bufferedInd; /* () Contains extra INDEXENTRIES, see ReadSaveIndex() for an explanation */
2369  WORD OutSkip; /* (O) How many chars to skip in output line */
2370  WORD IsBracket; /* (O) Controls brackets */
2371  WORD InFbrack; /* (O) For writing only */
2372  WORD PrintType; /* (O) */
2373  WORD FortFirst; /* (O) Only in sch.c */
2374  WORD DoubleFlag; /* (O) Output in double precision */
2375  WORD IndentSpace; /* For indentation in output */
2376  WORD FactorMode; /* When the output should be written as factors */
2377  WORD FactorNum; /* Number of factor currently treated */
2378  WORD ErrorBlock;
2379  WORD OptimizationLevel; /* Level of optimization in the output */
2380  UBYTE FortDotChar; /* (O) */
2381 /*
2382  For the padding, please count also the number of int's in the OPTIMIZE struct.
2383 */
2384 #if defined(mBSD) && defined(MICROTIME)
2385  PADPOSITION(25,6,35,17,1);
2386 #else
2387  PADPOSITION(25,4,35,17,1);
2388 #endif
2389 };
2390 /*
2391  #] O :
2392  #[ X : The X struct contains variables that deal with the external channel
2393 */
2401 struct X_const {
2402  UBYTE *currentPrompt;
2403  UBYTE *shellname; /* if !=NULL (default is "/bin/sh -c"), start in
2404  the specified subshell*/
2405  UBYTE *stderrname; /* If !=NULL (default if "/dev/null"), stderr is
2406  redirected to the specified file*/
2407  int timeout; /* timeout to initialize preset channels.
2408  If timeout<0, the preset channels are
2409  already initialized*/
2410  int killSignal; /* signal number, SIGKILL by default*/
2411  int killWholeGroup; /* if 0, the signal is sent only to a process,
2412  if !=0 (default) is sent to a whole process group*/
2413  int daemonize; /* if !=0 (default), start in a daemon mode */
2414  int currentExternalChannel;
2415  PADPOINTER(0,5,0,0);
2416 };
2417 /*
2418  #] X :
2419  #[ Definitions :
2420 */
2421 
2422 #ifdef WITHPTHREADS
2423 
2429 typedef struct AllGlobals {
2430  struct M_const M;
2431  struct C_const C;
2432  struct S_const S;
2433  struct O_const O;
2434  struct P_const P;
2435  struct X_const X;
2436  PADPOSITION(0,0,0,0,sizeof(struct P_const)+sizeof(struct X_const));
2437 } ALLGLOBALS;
2438 
2444 typedef struct AllPrivates {
2445  struct R_const R;
2446  struct N_const N;
2447  struct T_const T;
2448  PADPOSITION(0,0,0,0,sizeof(struct T_const));
2449 } ALLPRIVATES;
2450 
2451 #else
2452 
2457 typedef struct AllGlobals {
2458  struct M_const M;
2459  struct C_const C;
2460  struct S_const S;
2461  struct R_const R;
2462  struct N_const N;
2463  struct O_const O;
2464  struct P_const P;
2465  struct T_const T;
2466  struct X_const X;
2467  PADPOSITION(0,0,0,0,sizeof(struct P_const)+sizeof(struct T_const)+sizeof(struct X_const));
2468 } ALLGLOBALS;
2469 
2470 #endif
2471 
2472 /*
2473  #] Definitions :
2474  #] A :
2475  #[ FG :
2476 */
2477 
2478 #ifdef WITHPTHREADS
2479 #define PHEAD ALLPRIVATES *B,
2480 #define PHEAD0 ALLPRIVATES *B
2481 #define BHEAD B,
2482 #define BHEAD0 B
2483 #else
2484 #define PHEAD
2485 #define PHEAD0 VOID
2486 #define BHEAD
2487 #define BHEAD0
2488 #endif
2489 
2490 #ifdef ANSI
2491 typedef WORD (*WCN)(PHEAD WORD *,WORD *,WORD,WORD);
2492 typedef WORD (*WCN2)(PHEAD WORD *,WORD *);
2493 #else
2494 typedef WORD (*WCN)();
2495 typedef WORD (*WCN2)();
2496 #endif
2497 
2509 typedef struct FixedGlobals {
2510  WCN Operation[8];
2511  WCN2 OperaFind[6];
2512  char *VarType[10];
2513  char *ExprStat[21];
2514  char *FunNam[2];
2515  char *swmes[3];
2516  char *fname;
2517  char *fname2;
2518  UBYTE *s_one;
2519  WORD fnamebase;
2520  WORD fname2base;
2521  UINT cTable[256];
2522 } FIXEDGLOBALS;
2523 
2524 /*
2525  #] FG :
2526 */
2527 
2528 #endif
UBYTE * pointer
Definition: structs.h:692
WORD * tokenarglevel
Definition: structs.h:1680
WORD bufferssize
Definition: structs.h:378
struct VaRrEnUm VARRENUM
struct sOrT SORTING
int CheckpointFlag
Definition: structs.h:1781
LONG * NumTerms
Definition: structs.h:945
UBYTE revision
Definition: structs.h:88
WORD * buffers
Definition: structs.h:364
int value
Definition: structs.h:297
WORD number
Definition: structs.h:481
UBYTE sFun
Definition: structs.h:85
char * name
Definition: structs.h:970
LONG reserved
Definition: structs.h:366
NAMETREE * autonames
Definition: structs.h:1644
UBYTE * name
Definition: structs.h:793
struct ChAnNeL CHANNEL
LONG totind
Definition: structs.h:365
#define INFILEINDEX
Definition: structs.h:118
int numclear
Definition: structs.h:212
int numtree
Definition: structs.h:374
NAMETREE * exprnames
Definition: structs.h:1617
WORD left
Definition: structs.h:249
LONG clearnamefill
Definition: structs.h:279
struct CbUf CBUF
int parent
Definition: structs.h:294
LIST IndexList
Definition: structs.h:1625
LIST DubiousList
Definition: structs.h:1621
UBYTE * dollarname
Definition: structs.h:853
Definition: structs.h:443
WORD flags
Definition: structs.h:482
int prototypeSize
Definition: structs.h:369
UBYTE * buffer
Definition: structs.h:691
int right
Definition: structs.h:296
WORD size
Definition: structs.h:309
struct PaRtI PARTI
WORD * FixIndices
Definition: structs.h:1673
LONG namefill
Definition: structs.h:273
WORD SignCheck
Definition: structs.h:2257
WORD type
Definition: structs.h:252
Definition: structs.h:497
NAMENODE * namenode
Definition: structs.h:265
WORD * pattern
Definition: structs.h:356
struct AllGlobals ALLGLOBALS
WORD * bracketbuffer
Definition: structs.h:330
int left
Definition: structs.h:295
WORD nsymbols
Definition: structs.h:104
UBYTE * name
Definition: structs.h:850
Definition: structs.h:633
WORD nvectors
Definition: structs.h:106
LONG CheckpointStamp
Definition: structs.h:1711
POSITION position
Definition: structs.h:100
NAMETREE * dollarnames
Definition: structs.h:1616
VARRENUM indi
Definition: structs.h:181
int sparse
Definition: structs.h:373
LONG * termsortstack
Definition: structs.h:1659
LIST cbufList
Definition: structs.h:1636
SBYTE empty[EMPTYININDEX]
Definition: structs.h:141
UBYTE * iBuffer
Definition: structs.h:1669
LONG CompressSize
Definition: structs.h:103
struct TaBlEs * spare
Definition: structs.h:363
int NoShowInput
Definition: structs.h:1717
VARRENUM vect
Definition: structs.h:182
POSITION next
Definition: structs.h:138
LIST ModOptDolList
Definition: structs.h:1631
UWORD * cmod
Definition: structs.h:1660
int size
Definition: structs.h:209
int strict
Definition: structs.h:372
UBYTE * top
Definition: structs.h:693
LONG symminfo
Definition: structs.h:477
WORD number
Definition: structs.h:253
struct PeRmUtEp PERMP
Definition: structs.h:1241
STREAM * Streams
Definition: structs.h:1653
WORD mode
Definition: structs.h:381
int cbufnum
Definition: structs.h:1714
LONG nodefill
Definition: structs.h:271
LONG nodesize
Definition: structs.h:270
Definition: minos.h:94
struct pReVaR PREVAR
WORD node
Definition: structs.h:485
WORD ** lhs
Definition: structs.h:942
SBYTE * toptokens
Definition: structs.h:1678
UBYTE lenPOINTER
Definition: structs.h:80
int numind
Definition: structs.h:370
UBYTE sVec
Definition: structs.h:84
int numglobal
Definition: structs.h:210
LONG globalnodefill
Definition: structs.h:278
UBYTE sInd
Definition: structs.h:83
POSITION variables
Definition: structs.h:102
WORD mini
Definition: structs.h:307
LONG globalnamefill
Definition: structs.h:276
WORD * termsumcheck
Definition: structs.h:1674
UBYTE lenPOS
Definition: structs.h:79
int num
Definition: structs.h:207
Definition: structs.h:938
LIST PotModDolList
Definition: structs.h:1630
struct ReNuMbEr * RENUMBER
WORD parent
Definition: structs.h:248
SBYTE name[MAXENAME+1]
Definition: structs.h:109
UWORD * gpowmod
Definition: structs.h:1364
Definition: structs.h:293
WORD * Pointer
Definition: structs.h:941
WORD * IfSumCheck
Definition: structs.h:1691
struct FiLe FILEHANDLE
WORD * vecnum
Definition: structs.h:187
set_of_char separators
Definition: structs.h:1614
INDEXENTRY expression[INFILEINDEX]
Definition: structs.h:140
UBYTE * FoldName
Definition: structs.h:694
UWORD * gcmod
Definition: structs.h:1363
WORD * dimension
Definition: structs.h:947
TABLES tabl
Definition: structs.h:476
LONG name
Definition: structs.h:247
LIST SymbolList
Definition: structs.h:1628
WORD symmetric
Definition: structs.h:484
WORD * symnum
Definition: structs.h:185
WORD SortType
Definition: structs.h:335
int usage
Definition: structs.h:299
UBYTE sSym
Definition: structs.h:82
UBYTE lenWORD
Definition: structs.h:77
WORD * renumlists
Definition: structs.h:397
WORD ggShortStatsMax
Definition: structs.h:1522
int blnce
Definition: structs.h:298
WORD maxi
Definition: structs.h:308
int wildarg
Definition: structs.h:797
WORD * tablepointers
Definition: structs.h:350
LIST FunctionList
Definition: structs.h:1623
LIST TableBaseList
Definition: structs.h:1632
void * lijst
Definition: structs.h:205
UBYTE * iStop
Definition: structs.h:1671
UBYTE * argtail
Definition: structs.h:361
UBYTE * name
Definition: structs.h:695
WORD balance
Definition: structs.h:251
UBYTE lenLONG
Definition: structs.h:78
WORD tablenum
Definition: structs.h:380
UBYTE * iPointer
Definition: structs.h:1670
SORTING * S0
Definition: structs.h:1362
WORD ** rhs
Definition: structs.h:943
POSITION length
Definition: structs.h:101
char * message
Definition: structs.h:206
WORD * hi
Definition: structs.h:168
POSITION number
Definition: structs.h:139
int MaxTreeSize
Definition: structs.h:376
LONG * IfHeap
Definition: structs.h:1666
struct InDeXeNtRy INDEXENTRY
WORD bufnum
Definition: structs.h:377
struct TrAcEn * TRACEN
STREAM * CurrentStream
Definition: structs.h:1654
WORD buffersfill
Definition: structs.h:379
Definition: structs.h:1086
struct NeStInG * NESTING
WORD nindices
Definition: structs.h:105
WORD * numdum
Definition: structs.h:946
LIST SetElementList
Definition: structs.h:1626
WORD complex
Definition: structs.h:480
int numtemp
Definition: structs.h:211
int maxnum
Definition: structs.h:208
LONG * termstack
Definition: structs.h:1658
COMPTREE * boomlijst
Definition: structs.h:948
LONG defined
Definition: structs.h:367
struct StOrEcAcHe * STORECACHE
MINMAX * mm
Definition: structs.h:358
WORD size
Definition: structs.h:108
struct NaMeNode NAMENODE
BRACKETINDEX * indexbuffer
Definition: structs.h:329
COMPTREE * boomlijst
Definition: structs.h:360
WORD IndDum
Definition: structs.h:2258
LONG CheckpointInterval
Definition: structs.h:1712
WORD * prototype
Definition: structs.h:355
LONG name
Definition: structs.h:478
SBYTE * tokens
Definition: structs.h:1677
LONG namesize
Definition: structs.h:272
int bounds
Definition: structs.h:371
char * CheckpointRunBefore
Definition: structs.h:1689
LONG oldnamefill
Definition: structs.h:274
SBYTE * endoftokens
Definition: structs.h:1679
struct DoLoOp DOLOOP
LONG oldnodefill
Definition: structs.h:275
#define EMPTYININDEX
Definition: structs.h:123
WORD spec
Definition: structs.h:483
UWORD * powmod
Definition: structs.h:1661
WORD * Buffer
Definition: structs.h:939
WORD * start
Definition: structs.h:166
LONG BufferSize
Definition: structs.h:949
Definition: structs.h:204
UBYTE * WildcardNames
Definition: structs.h:1675
struct bit_field * one_byte
Definition: structs.h:909
WORD * indnum
Definition: structs.h:186
struct StreaM STREAM
WORD * Top
Definition: structs.h:940
struct tree COMPTREE
struct DiStRiBuTe DISTRIBUTE
NAMETREE * varnames
Definition: structs.h:1618
int nargs
Definition: structs.h:796
struct NaMeTree NAMETREE
UBYTE * namebuffer
Definition: structs.h:267
LONG * IfStack
Definition: structs.h:1668
struct TrAcEs TRACES
UBYTE * pname
Definition: structs.h:696
LIST VectorList
Definition: structs.h:1629
WORD right
Definition: structs.h:250
PRELOAD p
Definition: structs.h:849
LIST SetList
Definition: structs.h:1627
LIST ExpressionList
Definition: structs.h:1624
WORD namesize
Definition: structs.h:486
LONG mdefined
Definition: structs.h:368
LIST ChannelList
Definition: structs.h:1619
WORD headnode
Definition: structs.h:281
VARRENUM func
Definition: structs.h:183
int rootnum
Definition: structs.h:375
UBYTE * value
Definition: structs.h:794
struct FuNcTiOn * FUNCTIONS
LONG * IfCount
Definition: structs.h:1667
struct bit_field set_of_char[32]
Definition: structs.h:903
struct FiLeInDeX FILEINDEX
UBYTE * argnames
Definition: structs.h:795
struct PeRmUtE PERM
WORD * flags
Definition: structs.h:359
WORD nfunctions
Definition: structs.h:107
LONG clearnodefill
Definition: structs.h:280
int handle
Definition: structs.h:661
int handle
Definition: structs.h:971
UBYTE ** LabelNames
Definition: structs.h:1672
VARRENUM symb
Definition: structs.h:180
LONG * CanCommu
Definition: structs.h:944
char * CheckpointRunAfter
Definition: structs.h:1687
struct TaBlEs * TABLES
WORD commute
Definition: structs.h:479
struct FixedGlobals FIXEDGLOBALS
int * Labels
Definition: structs.h:1676
UWORD * modpowers
Definition: structs.h:1662
WORD * funnum
Definition: structs.h:188
WORD * lo
Definition: structs.h:167
WORD gShortStatsMax
Definition: structs.h:1521