FORM 4.3
declare.h
Go to the documentation of this file.
1#ifndef __FDECLARE__
2#define __FDECLARE__
3
8
9/* #[ License : */
10/*
11 * Copyright (C) 1984-2022 J.A.M. Vermaseren
12 * When using this file you are requested to refer to the publication
13 * J.A.M.Vermaseren "New features of FORM" math-ph/0010025
14 * This is considered a matter of courtesy as the development was paid
15 * for by FOM the Dutch physics granting agency and we would like to
16 * be able to track its scientific use to convince FOM of its value
17 * for the community.
18 *
19 * This file is part of FORM.
20 *
21 * FORM is free software: you can redistribute it and/or modify it under the
22 * terms of the GNU General Public License as published by the Free Software
23 * Foundation, either version 3 of the License, or (at your option) any later
24 * version.
25 *
26 * FORM is distributed in the hope that it will be useful, but WITHOUT ANY
27 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
28 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
29 * details.
30 *
31 * You should have received a copy of the GNU General Public License along
32 * with FORM. If not, see <http://www.gnu.org/licenses/>.
33 */
34/* #] License : */
35
36/*
37 #[ Macro's :
38*/
39
40#define MaX(x,y) ((x) > (y) ? (x): (y))
41#define MiN(x,y) ((x) < (y) ? (x): (y))
42#define ABS(x) ( (x) < 0 ? -(x): (x) )
43#define SGN(x) ( (x) > 0 ? 1 : (x) < 0 ? -1 : 0 )
44#define REDLENG(x) ((((x)<0)?((x)+1):((x)-1))/2)
45#define INCLENG(x) (((x)<0)?(((x)*2)-1):(((x)*2)+1))
46#define GETCOEF(x,y) x += *x;y = x[-1];x -= ABS(y);y=REDLENG(y)
47#define GETSTOP(x,y) y=x+(*x)-1;y -= ABS(*y)-1
48#define StuffAdd(x,y) (((x)<0?-1:1)*(y)+((y)<0?-1:1)*(x))
49
50#define EXCHN(t1,t2,n) { WORD a,i; for(i=0;i<n;i++){a=t1[i];t1[i]=t2[i];t2[i]=a;} }
51#define EXCH(x,y) { WORD a = (x); (x) = (y); (y) = a; }
52
53#define TOKENTOLINE(x,y) if ( AC.OutputSpaces == NOSPACEFORMAT ) { \
54 TokenToLine((UBYTE *)(y)); } else { TokenToLine((UBYTE *)(x)); }
55
56#define UngetFromStream(stream,c) ((stream)->nextchar[(stream)->isnextchar++]=c)
57#ifdef WITHRETURN
58#define AddLineFeed(s,n) { (s)[(n)++] = CARRIAGERETURN; (s)[(n)++] = LINEFEED; }
59#else
60#define AddLineFeed(s,n) { (s)[(n)++] = LINEFEED; }
61#endif
62#define TryRecover(x) Terminate(-1)
63#define UngetChar(c) { pushbackchar = c; }
64#define ParseNumber(x,s) {(x)=0;while(*(s)>='0'&&*(s)<='9')(x)=10*(x)+*(s)++ -'0';}
65#define ParseSign(sgn,s) {(sgn)=0;while(*(s)=='-'||*(s)=='+'){\
66 if ( *(s)++ == '-' ) sgn ^= 1;}}
67#define ParseSignedNumber(x,s) { int sgn; ParseSign(sgn,s)\
68 ParseNumber(x,s) if ( sgn ) x = -x; }
69
70#define NCOPY(s,t,n) while ( --n >= 0 ) *s++ = *t++;
71
72/*#define NCOPY(s,t,n) { memcpy(s,t,n*sizeof(WORD)); s+=n; t+=n; n = -1; }*/
73#define NCOPYI(s,t,n) while ( --n >= 0 ) *s++ = *t++;
74#define NCOPYB(s,t,n) while ( --n >= 0 ) *s++ = *t++;
75#define NCOPYI32(s,t,n) while ( --n >= 0 ) *s++ = *t++;
76#define WCOPY(s,t,n) { int nn=n; WORD *ss=(WORD *)s, *tt=(WORD *)t; while ( --nn >= 0 ) *ss++=*tt++; }
77#define NeedNumber(x,s,err) { int sgn = 1; \
78 while ( *s == ' ' || *s == '\t' || *s == '-' || *s == '+' ) { \
79 if ( *s == '-' ) sgn = -sgn; s++; } \
80 if ( chartype[*s] != 1 ) goto err; \
81 ParseNumber(x,s) \
82 if ( sgn < 0 ) (x) = -(x); while ( *s == ' ' || *s == '\t' ) s++;\
83 }
84#define SKIPBLANKS(s) { while ( *(s) == ' ' || *(s) == '\t' ) (s)++; }
85#define FLUSHCONSOLE if ( AP.InOutBuf > 0 ) CharOut(LINEFEED)
86
87#define SKIPBRA1(s) { int lev1=0; s++; while(*s) { if(*s=='[')lev1++; \
88 else if(*s==']'&&--lev1<0)break; s++;} }
89#define SKIPBRA2(s) { int lev2=0; s++; while(*s) { if(*s=='{')lev2++; \
90 else if(*s=='}'&&--lev2<0)break; \
91 else if(*s=='[')SKIPBRA1(s) s++;} }
92#define SKIPBRA3(s) { int lev3=0; s++; while(*s) { if(*s=='(')lev3++; \
93 else if(*s==')'&&--lev3<0)break; \
94 else if(*s=='{')SKIPBRA2(s) \
95 else if(*s=='[')SKIPBRA1(s) s++;} }
96#define SKIPBRA4(s) { int lev4=0; s++; while(*s) { if(*s=='(')lev4++; \
97 else if(*s==')'&&--lev4<0)break; \
98 else if(*s=='[')SKIPBRA1(s) s++;} }
99#define SKIPBRA5(s) { int lev5=0; s++; while(*s) { if(*s=='{')lev5++; \
100 else if(*s=='}'&&--lev5<0)break; \
101 else if(*s=='(')SKIPBRA4(s) \
102 else if(*s=='[')SKIPBRA1(s) s++;} }
103
104/*
105#define CYCLE1(a,i) {WORD iX,jX; iX=*a; for(jX=1;jX<i;jX++)a[jX-1]=a[jX]; a[i-1]=iX;}
106*/
107#define CYCLE1(t,a,i) {t iX=*a; WORD jX; for(jX=1;jX<i;jX++)a[jX-1]=a[jX]; a[i-1]=iX;}
108
109#define AddToCB(c,wx) if(c->Pointer>=c->Top) \
110 DoubleCbuffer(c-cbuf,c->Pointer,21); \
111 *(c->Pointer)++ = wx;
112
113#define EXCHINOUT { FILEHANDLE *ffFi = AR.outfile; \
114 AR.outfile = AR.infile; AR.infile = ffFi; }
115#define BACKINOUT { FILEHANDLE *ffFi = AR.outfile; POSITION posi; \
116 AR.outfile = AR.infile; AR.infile = ffFi; \
117 SetEndScratch(AR.infile,&posi); }
118
119#define CopyArg(to,from) { if ( *from > 0 ) { int ica = *from; NCOPY(to,from,ica) } \
120 else if ( *from <= -FUNCTION ) *to++ = *from++; \
121 else { *to++ = *from++; *to++ = *from++; } }
122
123#if ARGHEAD > 2
124#define FILLARG(w) { int i = ARGHEAD-2; while ( --i >= 0 ) *w++ = 0; }
125#define COPYARG(w,t) { int i = ARGHEAD-2; while ( --i >= 0 ) *w++ = *t++; }
126#define ZEROARG(w) { int i; for ( i = 2; i < ARGHEAD; i++ ) w[i] = 0; }
127#else
128#define FILLARG(w)
129#define COPYARG(w,t)
130#define ZEROARG(w)
131#endif
132
133#if FUNHEAD > 2
134#define FILLFUN(w) { *w++ = 0; FILLFUN3(w) }
135#define COPYFUN(w,t) { *w++ = *t++; COPYFUN3(w,t) }
136#else
137#define FILLFUN(w)
138#define COPYFUN(w,t)
139#endif
140
141#if FUNHEAD > 3
142#define FILLFUN3(w) { int ie = FUNHEAD-3; while ( --ie >= 0 ) *w++ = 0; }
143#define COPYFUN3(w,t) { int ie = FUNHEAD-3; while ( --ie >= 0 ) *w++ = *t++; }
144#else
145#define COPYFUN3(w,t)
146#define FILLFUN3(w)
147#endif
148
149#if SUBEXPSIZE > 5
150#define FILLSUB(w) { int ie = SUBEXPSIZE-5; while ( --ie >= 0 ) *w++ = 0; }
151#define COPYSUB(w,ww) { int ie = SUBEXPSIZE-5; while ( --ie >= 0 ) *w++ = *ww++; }
152#else
153#define FILLSUB(w)
154#define COPYSUB(w,ww)
155#endif
156
157#if EXPRHEAD > 4
158#define FILLEXPR(w) { int ie = EXPRHEAD-4; while ( --ie >= 0 ) *w++ = 0; }
159#else
160#define FILLEXPR(w)
161#endif
162
163#define NEXTARG(x) if(*x>0) x += *x; else if(*x <= -FUNCTION)x++; else x += 2;
164#define COPY1ARG(s1,t1) { int ica; if ( (ica=*t1) > 0 ) { NCOPY(s1,t1,ica) } \
165 else if(*t1<=-FUNCTION){*s1++=*t1++;} else{*s1++=*t1++;*s1++=*t1++;} }
166
174#define ZeroFillRange(w,begin,end) do { \
175 int tmp_i; \
176 for ( tmp_i = begin; tmp_i < end; tmp_i++ ) { (w)[tmp_i] = 0; } \
177} while (0)
178
179#define TABLESIZE(a,b) (((WORD)sizeof(a))/((WORD)sizeof(b)))
180#define WORDDIF(x,y) (WORD)(x-y)
181#define wsizeof(a) ((WORD)sizeof(a))
182#define VARNAME(type,num) (AC.varnames->namebuffer+type[num].name)
183#define DOLLARNAME(type,num) (AC.dollarnames->namebuffer+type[num].name)
184#define EXPRNAME(num) (AC.exprnames->namebuffer+Expressions[num].name)
185
186#define PREV(x) prevorder?prevorder:x
187
188#define SETERROR(x) { Terminate(-1); return(-1); }
189
190/* use this macro to avoid the unused parameter warning */
191#define DUMMYUSE(x) (void)(x);
192
193#ifdef _FILE_OFFSET_BITS
194#if _FILE_OFFSET_BITS==64
195/*:[19mar2004 mt]*/
196
197#define ADDPOS(pp,x) (pp).p1 = ((pp).p1+(off_t)(x))
198#define SETBASELENGTH(ss,x) (ss).p1 = (off_t)(x)
199#define SETBASEPOSITION(pp,x) (pp).p1 = (off_t)(x)
200#define ISEQUALPOSINC(pp1,pp2,x) ( (pp1).p1 == ((pp2).p1+(off_t)(x)) )
201#define ISGEPOSINC(pp1,pp2,x) ( (pp1).p1 >= ((pp2).p1+(off_t)(x)) )
202#define DIVPOS(pp,n) ( (pp).p1/(off_t)(n) )
203#define MULPOS(pp,n) (pp).p1 *= (off_t)(n)
204
205#else
206
207#define ADDPOS(pp,x) (pp).p1 = ((pp).p1+(x))
208#define SETBASELENGTH(ss,x) (ss).p1 = (x)
209#define SETBASEPOSITION(pp,x) (pp).p1 = (x)
210#define ISEQUALPOSINC(pp1,pp2,x) ( (pp1).p1 == ((pp2).p1+(LONG)(x)) )
211#define ISGEPOSINC(pp1,pp2,x) ( (pp1).p1 >= ((pp2).p1+(LONG)(x)) )
212#define DIVPOS(pp,n) ( (pp).p1/(n) )
213#define MULPOS(pp,n) (pp).p1 *= (n)
214#endif
215#else
216
217#define ADDPOS(pp,x) (pp).p1 = ((pp).p1+(LONG)(x))
218#define SETBASELENGTH(ss,x) (ss).p1 = (LONG)(x)
219#define SETBASEPOSITION(pp,x) (pp).p1 = (LONG)(x)
220#define ISEQUALPOSINC(pp1,pp2,x) ( (pp1).p1 == ((pp2).p1+(LONG)(x)) )
221#define ISGEPOSINC(pp1,pp2,x) ( (pp1).p1 >= ((pp2).p1+(LONG)(x)) )
222#define DIVPOS(pp,n) ( (pp).p1/(LONG)(n) )
223#define MULPOS(pp,n) (pp).p1 *= (LONG)(n)
224
225#endif
226#define DIFPOS(ss,pp1,pp2) (ss).p1 = ((pp1).p1-(pp2).p1)
227#define DIFBASE(pp1,pp2) ((pp1).p1-(pp2).p1)
228#define ADD2POS(pp1,pp2) (pp1).p1 += (pp2).p1
229#define PUTZERO(pp) (pp).p1 = 0
230#define BASEPOSITION(pp) ((pp).p1)
231#define SETSTARTPOS(pp) (pp).p1 = -2
232#define NOTSTARTPOS(pp) ( (pp).p1 > -2 )
233#define ISMINPOS(pp) ( (pp).p1 == -1 )
234#define ISEQUALPOS(pp1,pp2) ( (pp1).p1 == (pp2).p1 )
235#define ISNOTEQUALPOS(pp1,pp2) ( (pp1).p1 != (pp2).p1 )
236#define ISLESSPOS(pp1,pp2) ( (pp1).p1 < (pp2).p1 )
237#define ISGEPOS(pp1,pp2) ( (pp1).p1 >= (pp2).p1 )
238#define ISNOTZEROPOS(pp) ( (pp).p1 != 0 )
239#define ISZEROPOS(pp) ( (pp).p1 == 0 )
240#define ISPOSPOS(pp) ( (pp).p1 > 0 )
241#define ISNEGPOS(pp) ( (pp).p1 < 0 )
242extern VOID TELLFILE(int,POSITION *);
243
244#define TOLONG(x) ((LONG)(x))
245
246#define Add2Com(x) { WORD cod[2]; cod[0] = x; cod[1] = 2; AddNtoL(2,cod); }
247#define Add3Com(x1,x2) { WORD cod[3]; cod[0] = x1; cod[1] = 3; cod[2] = x2; AddNtoL(3,cod); }
248#define Add4Com(x1,x2,x3) { WORD cod[4]; cod[0] = x1; cod[1] = 4; \
249 cod[2] = x2; cod[3] = x3; AddNtoL(4,cod); }
250#define Add5Com(x1,x2,x3,x4) { WORD cod[5]; cod[0] = x1; cod[1] = 5; \
251 cod[2] = x2; cod[3] = x3; cod[4] = x4; AddNtoL(5,cod); }
252
253/*
254 The temporary variable ppp is to avoid a compiler warning about strict aliassing
255*/
256#define WantAddPointers(x) while((AT.pWorkPointer+(x))>AR.pWorkSize){WORD ***ppp=&AT.pWorkSpace;\
257 ExpandBuffer((void **)ppp,&AR.pWorkSize,(int)(sizeof(WORD *)));}
258#define WantAddLongs(x) while((AT.lWorkPointer+(x))>AR.lWorkSize){LONG **ppp=&AT.lWorkSpace;\
259 ExpandBuffer((void **)ppp,&AR.lWorkSize,sizeof(LONG));}
260#define WantAddPositions(x) while((AT.posWorkPointer+(x))>AR.posWorkSize){POSITION **ppp=&AT.posWorkSpace;\
261 ExpandBuffer((void **)ppp,&AR.posWorkSize,sizeof(POSITION));}
262
263/* inline in form3.h (or config.h). */
264#define FORM_INLINE inline
265
266/*
267 Macro's for memory management. This can be done by routines, but that
268 would be slower. Inline routines could do this, but we don't want to
269 leave this to the friendliness of the compiler(s).
270 The routines can be found in the file tools.c
271*/
272#define MEMORYMACROS
273
274#ifdef MEMORYMACROS
275
276#define TermMalloc(x) ( (AT.TermMemTop <= 0 ) ? TermMallocAddMemory(BHEAD0), AT.TermMemHeap[--AT.TermMemTop]: AT.TermMemHeap[--AT.TermMemTop] )
277#define NumberMalloc(x) ( (AT.NumberMemTop <= 0 ) ? NumberMallocAddMemory(BHEAD0), AT.NumberMemHeap[--AT.NumberMemTop]: AT.NumberMemHeap[--AT.NumberMemTop] )
278#define CacheNumberMalloc(x) ( (AT.CacheNumberMemTop <= 0 ) ? CacheNumberMallocAddMemory(BHEAD0), AT.CacheNumberMemHeap[--AT.CacheNumberMemTop]: AT.CacheNumberMemHeap[--AT.CacheNumberMemTop] )
279#define TermFree(TermMem,x) AT.TermMemHeap[AT.TermMemTop++] = (WORD *)(TermMem)
280#define NumberFree(NumberMem,x) AT.NumberMemHeap[AT.NumberMemTop++] = (UWORD *)(NumberMem)
281#define CacheNumberFree(NumberMem,x) AT.CacheNumberMemHeap[AT.CacheNumberMemTop++] = (UWORD *)(NumberMem)
282
283#else
284
285#define TermMalloc(x) TermMalloc2(BHEAD (char *)(x))
286#define NumberMalloc(x) NumberMalloc2(BHEAD (char *)(x))
287#define CacheNumberMalloc(x) CacheNumberMalloc2(BHEAD (char *)(x))
288#define TermFree(x,y) TermFree2(BHEAD (WORD *)(x),(char *)(y))
289#define NumberFree(x,y) NumberFree2(BHEAD (UWORD *)(x),(char *)(y))
290#define CacheNumberFree(x,y) CacheNumberFree2(BHEAD (UWORD *)(x),(char *)(y))
291
292#endif
293
294/*
295 * Macros for checking nesting levels in the compiler, used as follows:
296 *
297 * AC.IfSumCheck[AC.IfLevel] = NestingChecksum();
298 * AC.IfLevel++;
299 *
300 * AC.IfLevel--;
301 * if ( AC.IfSumCheck[AC.IfLevel] != NestingChecksum() ) {
302 * MesNesting();
303 * }
304 *
305 * Note that NestingChecksum() also contains AC.IfLevel and so in this case
306 * using increment/decrement operators on it in the left-hand side may be
307 * confusing.
308 */
309#define NestingChecksum() (AC.IfLevel + AC.RepLevel + AC.arglevel + AC.insidelevel + AC.termlevel + AC.inexprlevel + AC.dolooplevel +AC.SwitchLevel)
310#define MesNesting() MesPrint("&Illegal nesting of if, repeat, argument, inside, term, inexpression and do")
311
312#define MarkPolyRatFunDirty(T) {if(*T&&AR.PolyFunType==2){WORD *TP,*TT;TT=T+*T;TT-=ABS(TT[-1]);\
313TP=T+1;while(TP<TT){if(*TP==AR.PolyFun){TP[2]|=(DIRTYFLAG|MUSTCLEANPRF);}TP+=TP[1];}}}
314
315/*
316 Macros for nesting input levels for #$name = ...; assign instructions.
317 Note that the level should never go below zero.
318*/
319#define PUSHPREASSIGNLEVEL AP.PreAssignLevel++; { GETIDENTITY \
320 if ( AP.PreAssignLevel >= AP.MaxPreAssignLevel ) { int i; \
321 LONG *ap = (LONG *)Malloc1(2*AP.MaxPreAssignLevel*sizeof(LONG *),"PreAssignStack"); \
322 for ( i = 0; i < AP.MaxPreAssignLevel; i++ ) ap[i] = AP.PreAssignStack[i]; \
323 M_free(AP.PreAssignStack,"PreAssignStack"); \
324 AP.MaxPreAssignLevel *= 2; AP.PreAssignStack = ap; \
325 } \
326 *AT.WorkPointer++ = AP.PreContinuation; AP.PreContinuation = 0; \
327 AP.PreAssignStack[AP.PreAssignLevel] = AC.iPointer - AC.iBuffer; }
328
329#define POPPREASSIGNLEVEL if ( AP.PreAssignLevel > 0 ) { GETIDENTITY \
330 AC.iPointer = AC.iBuffer + AP.PreAssignStack[AP.PreAssignLevel--]; \
331 AP.PreContinuation = *--AT.WorkPointer; \
332 *AC.iPointer = 0; }
333
334/*
335 MesPrint("P-level popped to %d with %d",AP.PreAssignLevel,(WORD)(AC.iPointer - AC.iBuffer));
336
337 #] Macro's :
338 #[ Inline functions :
339*/
340
341/*
342 * The following three functions give the unsigned absolute value of a signed
343 * integer even for the most negative integer. This is beyond the scope of
344 * the standard abs() function and its family, whose return-values are signed.
345 * In short, we should not use the unary minus operator with signed numbers
346 * unless we are sure that there are no integer overflows. Instead, we rely on
347 * two well-defined operations: (i) signed-to-unsigned conversion and
348 * (ii) unary minus of unsigned operands.
349 *
350 * See also:
351 * https://stackoverflow.com/a/4536188 (Unary minus and signed-to-unsigned conversion)
352 * https://stackoverflow.com/q/8026694 (C: unary minus operator behavior with unsigned operands)
353 * https://stackoverflow.com/q/1610947 (Why does stdlib.h's abs() family of functions return a signed value?)
354 * https://blog.regehr.org/archives/226 (A Guide to Undefined Behavior in C and C++, Part 2)
355 */
356static inline unsigned int IntAbs(int x)
357{
358 if ( x >= 0 ) return x;
359 return(-((unsigned int)x));
360}
361
362static inline UWORD WordAbs(WORD x)
363{
364 if ( x >= 0 ) return x;
365 return(-((UWORD)x));
366}
367
368static inline ULONG LongAbs(LONG x)
369{
370 if ( x >= 0 ) return x;
371 return(-((ULONG)x));
372}
373
374/*
375 * The following functions provide portable unsigned-to-signed conversions
376 * (to avoid the implementation-defined behaviour), which is expected to be
377 * optimized to a no-op.
378 *
379 * See also:
380 * https://stackoverflow.com/a/13208789 (Efficient unsigned-to-signed cast avoiding implementation-defined behavior)
381 */
382static inline int UnsignedToInt(unsigned int x)
383{
384 extern void Terminate(int);
385 if ( x <= INT_MAX ) return(x);
386 if ( x >= (unsigned int)INT_MIN ) return((int)(x - INT_MIN) + INT_MIN);
387 Terminate(1);
388 return(0);
389}
390
391static inline WORD UWordToWord(UWORD x)
392{
393 extern void Terminate(int);
394 if ( x <= WORD_MAX_VALUE ) return(x);
395 if ( x >= (UWORD)WORD_MIN_VALUE ) return((WORD)(x - WORD_MIN_VALUE) + WORD_MIN_VALUE);
396 Terminate(1);
397 return(0);
398}
399
400static inline LONG ULongToLong(ULONG x)
401{
402 extern void Terminate(int);
403 if ( x <= LONG_MAX_VALUE ) return(x);
404 if ( x >= (ULONG)LONG_MIN_VALUE ) return((LONG)(x - LONG_MIN_VALUE) + LONG_MIN_VALUE);
405 Terminate(1);
406 return(0);
407}
408
409/*
410 #] Inline functions :
411 #[ Thread objects :
412*/
413
420#ifdef WITHPTHREADS
421
422#define EXTERNLOCK(x) extern pthread_mutex_t x;
423#define INILOCK(x) pthread_mutex_t x = PTHREAD_MUTEX_INITIALIZER;
424#define EXTERNRWLOCK(x) extern pthread_rwlock_t x;
425#define INIRWLOCK(x) pthread_rwlock_t x = PTHREAD_RWLOCK_INITIALIZER;
426#ifdef DEBUGGINGLOCKS
427#include <asm/errno.h>
428#define LOCK(x) while ( pthread_mutex_trylock(&(x)) == EBUSY ) {}
429#define RWLOCKR(x) while ( pthread_rwlock_tryrdlock(&(x)) == EBUSY ) {}
430#define RWLOCKW(x) while ( pthread_rwlock_trywrlock(&(x)) == EBUSY ) {}
431#else
432#define LOCK(x) pthread_mutex_lock(&(x))
433#define RWLOCKR(x) pthread_rwlock_rdlock(&(x))
434#define RWLOCKW(x) pthread_rwlock_wrlock(&(x))
435#endif
436#define UNLOCK(x) pthread_mutex_unlock(&(x))
437#define UNRWLOCK(x) pthread_rwlock_unlock(&(x))
438#define MLOCK(x) LOCK(x)
439#define MUNLOCK(x) UNLOCK(x)
440
441#define GETBIDENTITY
442#define GETIDENTITY int identity = WhoAmI(); ALLPRIVATES *B = AB[identity];
443#else
444
445#define EXTERNLOCK(x)
446#define INILOCK(x)
447#define LOCK(x)
448#define UNLOCK(x)
449#define EXTERNRWLOCK(x)
450#define INIRWLOCK(x)
451#define RWLOCKR(x)
452#define RWLOCKW(x)
453#define UNRWLOCK(x)
454#ifdef WITHMPI
455#define MLOCK(x) do { if ( PF.me != MASTER ) PF_MLock(); } while (0)
456#define MUNLOCK(x) do { if ( PF.me != MASTER ) PF_MUnlock(); } while (0)
457#else
458#define MLOCK(x)
459#define MUNLOCK(x)
460#endif
461#define GETIDENTITY
462#define GETBIDENTITY
463
464#endif
465
466/*
467 #] Thread objects :
468 #[ Declarations :
469*/
470
471#ifdef TERMMALLOCDEBUG
472extern WORD **DebugHeap1, **DebugHeap2;
473#endif
474
478
479extern VOID StartVariables();
480extern VOID setSignalHandlers(VOID);
481extern UBYTE *CodeToLine(WORD,UBYTE *);
482extern UBYTE *AddArrayIndex(WORD ,UBYTE *);
483extern INDEXENTRY *FindInIndex(WORD,FILEDATA *,WORD,WORD);
484extern INDEXENTRY *NextFileIndex(POSITION *);
485extern WORD *PasteTerm(PHEAD WORD,WORD *,WORD *,WORD,WORD);
486extern UBYTE *StrCopy(UBYTE *,UBYTE *);
487extern UBYTE *WrtPower(UBYTE *,WORD);
488extern WORD AccumGCD(PHEAD UWORD *,WORD *,UWORD *,WORD);
489extern VOID AddArgs(PHEAD WORD *,WORD *,WORD *);
490extern WORD AddCoef(PHEAD WORD **,WORD **);
491extern WORD AddLong(UWORD *,WORD,UWORD *,WORD,UWORD *,WORD *);
492extern WORD AddPLon(UWORD *,WORD,UWORD *,WORD,UWORD *,WORD *);
493extern WORD AddPoly(PHEAD WORD **,WORD **);
494extern WORD AddRat(PHEAD UWORD *,WORD,UWORD *,WORD,UWORD *,WORD *);
495extern VOID AddToLine(UBYTE *);
496extern WORD AddWild(PHEAD WORD,WORD,WORD);
497extern WORD BigLong(UWORD *,WORD,UWORD *,WORD);
498extern WORD BinomGen(PHEAD WORD *,WORD,WORD **,WORD,WORD,WORD,WORD,WORD,UWORD *,WORD);
499extern WORD CheckWild(PHEAD WORD,WORD,WORD,WORD *);
500extern WORD Chisholm(PHEAD WORD *,WORD);
501extern WORD CleanExpr(WORD);
502extern VOID CleanUp(WORD);
503extern VOID ClearWild(PHEAD0);
504extern WORD CompareFunctions(WORD *,WORD *);
505extern WORD Commute(WORD *,WORD *);
506extern WORD DetCommu(WORD *);
507extern WORD DoesCommu(WORD *);
508extern int CompArg(WORD *,WORD *);
509extern WORD CompCoef(WORD *, WORD *);
510extern WORD CompGroup(PHEAD WORD,WORD **,WORD *,WORD *,WORD);
511extern WORD Compare1(WORD *,WORD *,WORD);
512extern WORD CountDo(WORD *,WORD *);
513extern WORD CountFun(WORD *,WORD *);
514extern WORD DimensionSubterm(WORD *);
515extern WORD DimensionTerm(WORD *);
516extern WORD DimensionExpression(PHEAD WORD *);
517extern WORD Deferred(PHEAD WORD *,WORD);
518extern WORD DeleteStore(WORD);
519extern WORD DetCurDum(PHEAD WORD *);
520extern VOID DetVars(WORD *,WORD);
521extern WORD Distribute(DISTRIBUTE *,WORD);
522extern WORD DivLong(UWORD *,WORD,UWORD *,WORD,UWORD *,WORD *,UWORD *,WORD *);
523extern WORD DivRat(PHEAD UWORD *,WORD,UWORD *,WORD,UWORD *,WORD *);
524extern WORD Divvy(PHEAD UWORD *,WORD *,UWORD *,WORD);
525extern WORD DoDelta(WORD *);
526extern WORD DoDelta3(PHEAD WORD *,WORD);
527extern WORD TestPartitions(WORD *, PARTI *);
528extern WORD DoPartitions(PHEAD WORD *,WORD);
529extern int CoCanonicalize(UBYTE *);
530extern int DoCanonicalize(PHEAD WORD *, WORD *);
531extern WORD GenTopologies(PHEAD WORD *,WORD);
532extern WORD GenDiagrams(PHEAD WORD *,WORD);
533extern int DoTopologyCanonicalize(PHEAD WORD *,WORD,WORD,WORD *);
534extern int DoShattering(PHEAD WORD *,WORD *,WORD *,WORD);
535extern WORD GenerateTopologies(PHEAD WORD,WORD,WORD,WORD);
536extern WORD DoTableExpansion(WORD *,WORD);
537extern WORD DoDistrib(PHEAD WORD *,WORD);
538extern WORD DoShuffle(WORD *,WORD,WORD,WORD);
539extern WORD DoPermutations(PHEAD WORD *,WORD);
540extern int Shuffle(WORD *, WORD *, WORD *);
541extern int FinishShuffle(WORD *);
542extern WORD DoStuffle(WORD *,WORD,WORD,WORD);
543extern int Stuffle(WORD *, WORD *, WORD *);
544extern int FinishStuffle(WORD *);
545extern WORD *StuffRootAdd(WORD *, WORD *, WORD *);
546extern WORD TestUse(WORD *,WORD);
547extern DBASE *FindTB(UBYTE *);
548extern int CheckTableDeclarations(DBASE *);
549extern WORD Apply(WORD *,WORD);
550extern int ApplyExec(WORD *,int,WORD);
551extern WORD ApplyReset(WORD);
552extern WORD TableReset(VOID);
553extern VOID ReWorkT(WORD *,WORD *,WORD);
554extern WORD GetIfDollarNum(WORD *, WORD *);
555extern int FindVar(WORD *,WORD *);
556extern WORD DoIfStatement(PHEAD WORD *,WORD *);
557extern WORD DoOnePow(PHEAD WORD *,WORD,WORD,WORD *,WORD *,WORD,WORD *);
558extern void DoRevert(WORD *,WORD *);
559extern WORD DoSumF1(PHEAD WORD *,WORD *,WORD,WORD);
560extern WORD DoSumF2(PHEAD WORD *,WORD *,WORD,WORD);
561extern WORD DoTheta(PHEAD WORD *);
562extern LONG EndSort(PHEAD WORD *,int);
563extern WORD EntVar(WORD,UBYTE *,WORD,WORD,WORD,WORD);
564extern WORD EpfCon(PHEAD WORD *,WORD *,WORD,WORD);
565extern WORD EpfFind(PHEAD WORD *,WORD *);
566extern WORD EpfGen(WORD,WORD *,WORD *,WORD *,WORD);
567extern WORD EqualArg(WORD *,WORD,WORD);
568extern WORD Evaluate(UBYTE **);
569extern int Factorial(PHEAD WORD,UWORD *,WORD *);
570extern int Bernoulli(WORD,UWORD *,WORD *);
571extern int FactorIn(PHEAD WORD *,WORD);
572extern int FactorInExpr(PHEAD WORD *,WORD);
573extern WORD FindAll(PHEAD WORD *,WORD *,WORD,WORD *);
574extern WORD FindMulti(PHEAD WORD *,WORD *);
575extern WORD FindOnce(PHEAD WORD *,WORD *);
576extern WORD FindOnly(PHEAD WORD *,WORD *);
577extern WORD FindRest(PHEAD WORD *,WORD *);
578extern WORD FindSpecial(WORD *);
579extern WORD FindrNumber(WORD,VARRENUM *);
580extern VOID FiniLine(VOID);
581extern WORD FiniTerm(PHEAD WORD *,WORD *,WORD *,WORD,WORD);
582extern WORD FlushOut(POSITION *,FILEHANDLE *,int);
583extern VOID FunLevel(PHEAD WORD *);
584extern VOID AdjustRenumScratch(PHEAD0);
585extern VOID GarbHand(VOID);
586extern WORD GcdLong(PHEAD UWORD *,WORD,UWORD *,WORD,UWORD *,WORD *);
587extern WORD LcmLong(PHEAD UWORD *,WORD,UWORD *,WORD,UWORD *,WORD *);
588extern VOID GCD(UWORD *,WORD,UWORD *,WORD,UWORD *,WORD *);
589extern ULONG GCD2(ULONG,ULONG);
590extern WORD Generator(PHEAD WORD *,WORD);
591extern WORD GetBinom(UWORD *,WORD *,WORD,WORD);
592extern WORD GetFromStore(WORD *,POSITION *,RENUMBER,WORD *,WORD);
593extern WORD GetLong(UBYTE *,UWORD *,WORD *);
594extern WORD GetMoreTerms(WORD *);
595extern WORD GetMoreFromMem(WORD *,WORD **);
596extern WORD GetOneTerm(PHEAD WORD *,FILEHANDLE *,POSITION *,int);
597extern RENUMBER GetTable(WORD,POSITION *,WORD);
598extern WORD GetTerm(PHEAD WORD *);
599extern WORD Glue(PHEAD WORD *,WORD *,WORD *,WORD);
600extern WORD InFunction(PHEAD WORD *,WORD *);
601extern VOID IniLine(WORD);
602extern WORD IniVars(VOID);
603extern VOID Initialize(VOID);
604extern WORD InsertTerm(PHEAD WORD *,WORD,WORD,WORD *,WORD *,WORD);
605extern VOID LongToLine(UWORD *,WORD);
606extern WORD MakeDirty(WORD *,WORD *,WORD);
607extern VOID MarkDirty(WORD *,WORD);
608extern VOID PolyFunDirty(PHEAD WORD *);
609extern VOID PolyFunClean(PHEAD WORD *);
610extern WORD MakeModTable(VOID);
611extern WORD MatchE(PHEAD WORD *,WORD *,WORD *,WORD);
612extern int MatchCy(PHEAD WORD *,WORD *,WORD *,WORD);
613extern int FunMatchCy(PHEAD WORD *,WORD *,WORD *,WORD);
614extern int FunMatchSy(PHEAD WORD *,WORD *,WORD *,WORD);
615extern int MatchArgument(PHEAD WORD *,WORD *);
616extern WORD MatchFunction(PHEAD WORD *,WORD *,WORD *);
617extern WORD MergePatches(WORD);
618extern WORD MesCerr(char *, UBYTE *);
619extern WORD MesComp(char *, UBYTE *, UBYTE *);
620extern WORD Modulus(WORD *);
621extern VOID MoveDummies(PHEAD WORD *,WORD);
622extern WORD MulLong(UWORD *,WORD,UWORD *,WORD,UWORD *,WORD *);
623extern WORD MulRat(PHEAD UWORD *,WORD,UWORD *,WORD,UWORD *,WORD *);
624extern WORD Mully(PHEAD UWORD *,WORD *,UWORD *,WORD);
625extern WORD MultDo(PHEAD WORD *,WORD *);
626extern WORD NewSort(PHEAD0);
627extern WORD ExtraSymbol(WORD,WORD,WORD,WORD *,WORD *);
628extern WORD Normalize(PHEAD WORD *);
629extern WORD BracketNormalize(PHEAD WORD *);
630extern VOID DropCoefficient(PHEAD WORD *);
631extern VOID DropSymbols(PHEAD WORD *);
632extern int PutInside(PHEAD WORD *, WORD *);
633extern WORD OpenTemp(VOID);
634extern VOID Pack(UWORD *,WORD *,UWORD *,WORD );
635extern LONG PasteFile(PHEAD WORD,WORD *,POSITION *,WORD **,RENUMBER,WORD *,WORD);
636extern WORD Permute(PERM *,WORD);
637extern WORD PermuteP(PERMP *,WORD);
638extern WORD PolyFunMul(PHEAD WORD *);
639extern WORD PopVariables(VOID);
640extern WORD PrepPoly(PHEAD WORD *,WORD);
641extern WORD Processor(VOID);
642extern WORD Product(UWORD *,WORD *,WORD);
643extern VOID PrtLong(UWORD *,WORD,UBYTE *);
644extern VOID PrtTerms(VOID);
645extern VOID PrintRunningTime(VOID);
646extern LONG GetRunningTime(VOID);
647extern WORD PutBracket(PHEAD WORD *);
648extern LONG PutIn(FILEHANDLE *,POSITION *,WORD *,WORD **,int);
649extern WORD PutInStore(INDEXENTRY *,WORD);
650extern WORD PutOut(PHEAD WORD *,POSITION *,FILEHANDLE *,WORD);
651extern UWORD Quotient(UWORD *,WORD *,WORD);
652extern WORD RaisPow(PHEAD UWORD *,WORD *,UWORD);
653extern VOID RaisPowCached (PHEAD WORD, WORD, UWORD **, WORD *);
654extern WORD RaisPowMod (WORD, WORD, WORD);
655extern int NormalModulus(UWORD *,WORD *);
656extern int MakeInverses(VOID);
657extern int GetModInverses(WORD,WORD,WORD *,WORD *);
658extern int GetLongModInverses(PHEAD UWORD *, WORD, UWORD *, WORD, UWORD *, WORD *, UWORD *, WORD *);
659extern VOID RatToLine(UWORD *,WORD);
660extern WORD RatioFind(PHEAD WORD *,WORD *);
661extern WORD RatioGen(PHEAD WORD *,WORD *,WORD,WORD);
662extern WORD ReNumber(PHEAD WORD *);
663extern WORD ReadSnum(UBYTE **);
664extern WORD Remain10(UWORD *,WORD *);
665extern WORD Remain4(UWORD *,WORD *);
666extern WORD ResetScratch(VOID);
667extern WORD ResolveSet(PHEAD WORD *,WORD *,WORD *);
668extern WORD RevertScratch(VOID);
669extern WORD ScanFunctions(PHEAD WORD *,WORD *,WORD);
670extern VOID SeekScratch(FILEHANDLE *,POSITION *);
671extern VOID SetEndScratch(FILEHANDLE *,POSITION *);
672extern VOID SetEndHScratch(FILEHANDLE *,POSITION *);
673extern WORD SetFileIndex(VOID);
674extern WORD Sflush(FILEHANDLE *);
675extern WORD Simplify(PHEAD UWORD *,WORD *,UWORD *,WORD *);
676extern WORD SortWild(WORD *,WORD);
677extern FILE *LocateBase(char **,char **);
678extern LONG SplitMerge(PHEAD WORD **,LONG);
679extern WORD StoreTerm(PHEAD WORD *);
680extern VOID SubPLon(UWORD *,WORD,UWORD *,WORD,UWORD *,WORD *);
681extern VOID Substitute(PHEAD WORD *,WORD *,WORD);
682extern WORD SymFind(PHEAD WORD *,WORD *);
683extern WORD SymGen(PHEAD WORD *,WORD *,WORD,WORD);
684extern WORD Symmetrize(PHEAD WORD *,WORD *,WORD,WORD,WORD);
685extern int FullSymmetrize(PHEAD WORD *,int);
686extern WORD TakeModulus(UWORD *,WORD *,UWORD *,WORD,WORD);
687extern WORD TakeNormalModulus(UWORD *,WORD *,UWORD *,WORD,WORD);
688extern VOID TalToLine(UWORD);
689extern WORD TenVec(PHEAD WORD *,WORD *,WORD,WORD);
690extern WORD TenVecFind(PHEAD WORD *,WORD *);
691extern WORD TermRenumber(WORD *,RENUMBER,WORD);
692extern VOID TestDrop(VOID);
693extern VOID PutInVflags(WORD);
694extern WORD TestMatch(PHEAD WORD *,WORD *);
695extern WORD TestSub(PHEAD WORD *,WORD);
696extern LONG TimeCPU(WORD);
697extern LONG TimeChildren(WORD);
698extern LONG TimeWallClock(WORD);
699extern LONG Timer(int);
700extern int GetTimerInfo(LONG **,LONG **);
701extern void WriteTimerInfo(LONG *,LONG *);
702extern LONG GetWorkerTimes(VOID);
703extern WORD ToStorage(EXPRESSIONS,POSITION *);
704extern VOID TokenToLine(UBYTE *);
705extern WORD Trace4(PHEAD WORD *,WORD *,WORD,WORD);
706extern WORD Trace4Gen(PHEAD TRACES *,WORD);
707extern WORD Trace4no(WORD,WORD *,TRACES *);
708extern WORD TraceFind(PHEAD WORD *,WORD *);
709extern WORD TraceN(PHEAD WORD *,WORD *,WORD,WORD);
710extern WORD TraceNgen(PHEAD TRACES *,WORD);
711extern WORD TraceNno(WORD,WORD *,TRACES *);
712extern WORD Traces(PHEAD WORD *,WORD *,WORD,WORD);
713extern WORD Trick(WORD *,TRACES *);
714extern WORD TryDo(PHEAD WORD *,WORD *,WORD);
715extern VOID UnPack(UWORD *,WORD,WORD *,WORD *);
716extern WORD VarStore(UBYTE *,WORD,WORD,WORD);
717extern WORD WildFill(PHEAD WORD *,WORD *,WORD *);
718extern WORD WriteAll(VOID);
719extern WORD WriteOne(UBYTE *,int,int,WORD);
720extern VOID WriteArgument(WORD *);
721extern WORD WriteExpression(WORD *,LONG);
722extern WORD WriteInnerTerm(WORD *,WORD);
723extern VOID WriteLists(VOID);
724extern VOID WriteSetup(VOID);
725extern VOID WriteStats(POSITION *,WORD);
726extern WORD WriteSubTerm(WORD *,WORD);
727extern WORD WriteTerm(WORD *,WORD *,WORD,WORD,WORD);
728extern WORD execarg(PHEAD WORD *,WORD);
729extern WORD execterm(PHEAD WORD *,WORD);
730extern VOID SpecialCleanup(PHEAD0);
731extern void SetMods();
732extern void UnSetMods();
733
734/*---------------------------------------------------------------------*/
735
736extern WORD DoExecute(WORD,WORD);
737extern VOID SetScratch(FILEHANDLE *,POSITION *);
738extern VOID Warning(char *);
739extern VOID HighWarning(char *);
740extern int SpareTable(TABLES);
741
742extern UBYTE *strDup1(UBYTE *,char *);
743extern VOID *Malloc(LONG);
744extern VOID *Malloc1(LONG,const char *);
745extern int DoTail(int,UBYTE **);
746extern int OpenInput(VOID);
747extern int PutPreVar(UBYTE *,UBYTE *,UBYTE *,int);
748extern VOID Error0(char *);
749extern VOID Error1(char *,UBYTE *);
750extern VOID Error2(char *,char *,UBYTE *);
751extern UBYTE ReadFromStream(STREAM *);
752extern UBYTE GetFromStream(STREAM *);
753extern UBYTE LookInStream(STREAM *);
754extern STREAM *OpenStream(UBYTE *,int,int,int);
755extern int LocateFile(UBYTE **,int);
756extern STREAM *CloseStream(STREAM *);
757extern VOID PositionStream(STREAM *,LONG);
758extern int ReverseStatements(STREAM *);
759extern int ProcessOption(UBYTE *,UBYTE *,int);
760extern int DoSetups(VOID);
761extern VOID Terminate(int);
762extern NAMENODE *GetNode(NAMETREE *,UBYTE *);
763extern int AddName(NAMETREE *,UBYTE *,WORD,WORD,int *);
764extern int GetName(NAMETREE *,UBYTE *,WORD *,int);
765extern UBYTE *GetFunction(UBYTE *,WORD *);
766extern UBYTE *GetNumber(UBYTE *,WORD *);
767extern int GetLastExprName(UBYTE *,WORD *);
768extern int GetAutoName(UBYTE *,WORD *);
769extern int GetVar(UBYTE *,WORD *,WORD *,int,int);
770extern int MakeDubious(NAMETREE *,UBYTE *,WORD *);
771extern int GetOName(NAMETREE *,UBYTE *,WORD *,int);
772extern VOID DumpTree(NAMETREE *);
773extern VOID DumpNode(NAMETREE *,WORD,WORD);
774extern VOID LinkTree(NAMETREE *,WORD,WORD);
775extern VOID CopyTree(NAMETREE *,NAMETREE *,WORD,WORD);
776extern int CompactifyTree(NAMETREE *,WORD);
777extern NAMETREE *MakeNameTree(VOID);
778extern VOID FreeNameTree(NAMETREE *);
779extern int AddExpression(UBYTE *,int,int);
780extern int AddSymbol(UBYTE *,int,int,int,int);
781extern int AddDollar(UBYTE *,WORD,WORD *,LONG);
782extern int ReplaceDollar(WORD,WORD,WORD *,LONG);
783extern int DollarRaiseLow(UBYTE *,LONG);
784extern int AddVector(UBYTE *,int,int);
785extern int AddDubious(UBYTE *);
786extern int AddIndex(UBYTE *,int,int);
787extern UBYTE *DoDimension(UBYTE *,int *,int *);
788extern int AddFunction(UBYTE *,int,int,int,int,int,int,int);
789extern int CoCommuteInSet(UBYTE *);
790extern int CoFunction(UBYTE *,int,int);
791extern int TestName(UBYTE *);
792extern int AddSet(UBYTE *,WORD);
793extern int DoElements(UBYTE *,SETS,UBYTE *);
794extern int DoTempSet(UBYTE *,UBYTE *);
795extern int NameConflict(int,UBYTE *);
796extern int OpenFile(char *);
797extern int OpenAddFile(char *);
798extern int ReOpenFile(char *);
799extern int CreateFile(char *);
800extern int CreateLogFile(char *);
801extern VOID CloseFile(int);
802extern int CopyFile(char *, char *);
803extern int CreateHandle(VOID);
804extern LONG ReadFile(int,UBYTE *,LONG);
805extern LONG ReadPosFile(PHEAD FILEHANDLE *,UBYTE *,LONG,POSITION *);
806extern LONG WriteFileToFile(int,UBYTE *,LONG);
807extern VOID SeekFile(int,POSITION *,int);
808extern LONG TellFile(int);
809extern void FlushFile(int);
810extern int GetPosFile(int,fpos_t *);
811extern int SetPosFile(int,fpos_t *);
812extern VOID SynchFile(int);
813extern VOID TruncateFile(int);
814extern int GetChannel(char *,int);
815extern int GetAppendChannel(char *);
816extern int CloseChannel(char *);
817extern VOID inictable(VOID);
818extern KEYWORD *findcommand(UBYTE *);
819extern int inicbufs(VOID);
820extern VOID StartFiles(VOID);
821extern UBYTE *MakeDate(VOID);
822extern VOID PreProcessor(VOID);
823extern VOID *FromList(LIST *);
824extern VOID *From0List(LIST *);
825extern VOID *FromVarList(LIST *);
826extern int DoubleList(VOID ***,int *,int,char *);
827extern int DoubleLList(VOID ***,LONG *,int,char *);
828extern void DoubleBuffer(void **,void **,int,char *);
829extern void ExpandBuffer(void **,LONG *,int);
830extern LONG iexp(LONG,int);
831extern int IsLikeVector(WORD *);
832extern int AreArgsEqual(WORD *,WORD *);
833extern int CompareArgs(WORD *,WORD *);
834extern UBYTE *SkipField(UBYTE *,int);
835extern int StrCmp(UBYTE *,UBYTE *);
836extern int StrICmp(UBYTE *,UBYTE *);
837extern int StrHICmp(UBYTE *,UBYTE *);
838extern int StrICont(UBYTE *,UBYTE *);
839extern int CmpArray(WORD *,WORD *,WORD);
840extern int ConWord(UBYTE *,UBYTE *);
841extern int StrLen(UBYTE *);
842extern UBYTE *GetPreVar(UBYTE *,int);
843extern void ToGeneral(WORD *,WORD *,WORD);
844extern WORD ToPolyFunGeneral(PHEAD WORD *);
845extern int ToFast(WORD *,WORD *);
846extern SETUPPARAMETERS *GetSetupPar(UBYTE *);
847extern int RecalcSetups(VOID);
848extern int AllocSetups(VOID);
849extern SORTING *AllocSort(LONG,LONG,LONG,LONG,int,int,LONG);
850extern VOID AllocSortFileName(SORTING *);
851extern UBYTE *LoadInputFile(UBYTE *,int);
852extern UBYTE GetInput(VOID);
853extern VOID ClearPushback(VOID);
854extern UBYTE GetChar(int);
855extern VOID CharOut(UBYTE);
856extern VOID UnsetAllowDelay(VOID);
857extern VOID PopPreVars(int);
858extern VOID IniModule(int);
859extern VOID IniSpecialModule(int);
860extern int ModuleInstruction(int *,int *);
861extern int PreProInstruction(VOID);
862extern int LoadInstruction(int);
863extern int LoadStatement(int);
864extern KEYWORD *FindKeyWord(UBYTE *,KEYWORD *,int);
865extern KEYWORD *FindInKeyWord(UBYTE *,KEYWORD *,int);
866extern int DoDefine(UBYTE *);
867extern int DoRedefine(UBYTE *);
868extern int TheDefine(UBYTE *,int);
869extern int TheUndefine(UBYTE *);
870extern int ClearMacro(UBYTE *);
871extern int DoUndefine(UBYTE *);
872extern int DoInclude(UBYTE *);
873extern int DoReverseInclude(UBYTE *);
874extern int Include(UBYTE *,int);
875/*[14apr2004 mt]:*/
876extern int DoExternal(UBYTE *);
877extern int DoToExternal(UBYTE *);
878extern int DoFromExternal(UBYTE *);
879extern int DoPrompt(UBYTE *);
880extern int DoSetExternal(UBYTE *);
881/*[10may2006 mt]:*/
882extern int DoSetExternalAttr(UBYTE *);
883/*:[10may2006 mt]*/
884extern int DoRmExternal(UBYTE *);
885/*:[14apr2004 mt]*/
886extern int DoFactDollar(UBYTE *);
887extern WORD GetDollarNumber(UBYTE **,DOLLARS);
888extern int DoSetRandom(UBYTE *);
889extern int DoOptimize(UBYTE *);
890extern int DoClearOptimize(UBYTE *);
891extern int DoSkipExtraSymbols(UBYTE *);
892extern int DoTimeOutAfter(UBYTE *);
893extern int DoMessage(UBYTE *);
894extern int DoPreOut(UBYTE *);
895extern int DoPreAppend(UBYTE *);
896extern int DoPreCreate(UBYTE *);
897extern int DoPreAssign(UBYTE *);
898extern int DoPreBreak(UBYTE *);
899extern int DoPreDefault(UBYTE *);
900extern int DoPreSwitch(UBYTE *);
901extern int DoPreEndSwitch(UBYTE *);
902extern int DoPreCase(UBYTE *);
903extern int DoPreShow(UBYTE *);
904extern int DoPreExchange(UBYTE *);
905extern int DoSystem(UBYTE *);
906extern int DoPipe(UBYTE *);
907extern VOID StartPrepro(VOID);
908extern int DoIfdef(UBYTE *,int);
909extern int DoIfydef(UBYTE *);
910extern int DoIfndef(UBYTE *);
911extern int DoElse(UBYTE *);
912extern int DoElseif(UBYTE *);
913extern int DoEndif(UBYTE *);
914extern int DoTerminate(UBYTE *);
915extern int DoIf(UBYTE *);
916extern int DoCall(UBYTE *);
917extern int DoDebug(UBYTE *);
918extern int DoDo(UBYTE *);
919extern int DoBreakDo(UBYTE *);
920extern int DoEnddo(UBYTE *);
921extern int DoEndprocedure(UBYTE *);
922extern int DoInside(UBYTE *);
923extern int DoEndInside(UBYTE *);
924extern int DoProcedure(UBYTE *);
925extern int DoPrePrintTimes(UBYTE *);
926extern int DoPreWrite(UBYTE *);
927extern int DoPreClose(UBYTE *);
928extern int DoPreRemove(UBYTE *);
929extern int DoCommentChar(UBYTE *);
930extern int DoPrcExtension(UBYTE *);
931extern int DoPreReset(UBYTE *);
932extern VOID WriteString(int,UBYTE *,int);
933extern VOID WriteUnfinString(int,UBYTE *,int);
934extern UBYTE *AddToString(UBYTE *,UBYTE *,int);
935extern UBYTE *PreCalc(VOID);
936extern UBYTE *PreEval(UBYTE *,LONG *);
937extern VOID NumToStr(UBYTE *,LONG);
938extern int PreCmp(int,int,UBYTE *,int,int,UBYTE *,int);
939extern int PreEq(int,int,UBYTE *,int,int,UBYTE *,int);
940extern UBYTE *pParseObject(UBYTE *,int *,LONG *);
941extern UBYTE *PreIfEval(UBYTE *,int *);
942extern int EvalPreIf(UBYTE *);
943extern int PreLoad(PRELOAD *,UBYTE *,UBYTE *,int,char *);
944extern int PreSkip(UBYTE *,UBYTE *,int);
945extern UBYTE *EndOfToken(UBYTE *);
946extern VOID SetSpecialMode(int,int);
947extern VOID MakeGlobal(VOID);
948extern int ExecModule(int);
949extern int ExecStore(VOID);
950extern VOID FullCleanUp(VOID);
951extern int DoExecStatement(VOID);
952extern int DoPipeStatement(VOID);
953extern int DoPolyfun(UBYTE *);
954extern int DoPolyratfun(UBYTE *);
955extern int CompileStatement(UBYTE *);
956extern UBYTE *ToToken(UBYTE *);
957extern int GetDollar(UBYTE *);
958extern int MesWork(VOID);
959extern int MesPrint(const char *,...);
960extern int MesCall(char *);
961extern UBYTE *NumCopy(WORD,UBYTE *);
962extern char *LongCopy(LONG,char *);
963extern char *LongLongCopy(off_t *,char *);
964extern VOID ReserveTempFiles(int);
965extern VOID PrintTerm(WORD *,char *);
966extern VOID PrintTermC(WORD *,char *);
967extern VOID PrintSubTerm(WORD *,char *);
968extern VOID PrintWords(WORD *,LONG);
969extern void PrintSeq(WORD *,char *);
970extern int ExpandTripleDots(int);
971extern LONG ComPress(WORD **,LONG *);
972extern VOID StageSort(FILEHANDLE *);
973
974#define M_alloc(x) malloc((size_t)(x))
975
976extern void M_free(VOID *,const char *);
977extern void ClearWildcardNames(VOID);
978extern int AddWildcardName(UBYTE *);
979extern int GetWildcardName(UBYTE *);
980extern void Globalize(int);
981extern void ResetVariables(int);
982extern void AddToPreTypes(int);
983extern void MessPreNesting(int);
984extern LONG GetStreamPosition(STREAM *);
985extern WORD *DoubleCbuffer(int,WORD *,int);
986extern WORD *AddLHS(int);
987extern WORD *AddRHS(int,int);
988extern int AddNtoL(int,WORD *);
989extern int AddNtoC(int,int,WORD *,int);
990extern VOID DoubleIfBuffers(VOID);
991extern STREAM *CreateStream(UBYTE *);
992
993extern int setonoff(UBYTE *,int *,int,int);
994extern int DoPrint(UBYTE *,int);
995extern int SetExpr(UBYTE *,int,int);
996extern void AddToCom(int,WORD *);
997extern int Add2ComStrings(int,WORD *,UBYTE *,UBYTE *);
998extern int DoSymmetrize(UBYTE *,int);
999extern int DoArgument(UBYTE *,int);
1000extern int ArgFactorize(PHEAD WORD *,WORD *);
1001extern WORD *TakeArgContent(PHEAD WORD *, WORD *);
1002extern WORD *MakeInteger(PHEAD WORD *,WORD *,WORD *);
1003extern WORD *MakeMod(PHEAD WORD *,WORD *,WORD *);
1004extern WORD FindArg(PHEAD WORD *);
1005extern WORD InsertArg(PHEAD WORD *,WORD *,int);
1006extern int CleanupArgCache(PHEAD WORD);
1007extern int ArgSymbolMerge(WORD *, WORD *);
1008extern int ArgDotproductMerge(WORD *, WORD *);
1009extern void SortWeights(LONG *,LONG *,WORD);
1010extern int DoBrackets(UBYTE *,int);
1011extern int DoPutInside(UBYTE *,int);
1012extern WORD *CountComp(UBYTE *,WORD *);
1013extern int CoAntiBracket(UBYTE *);
1014extern int CoAntiSymmetrize(UBYTE *);
1015extern int DoArgPlode(UBYTE *,int);
1016extern int CoArgExplode(UBYTE *);
1017extern int CoArgImplode(UBYTE *);
1018extern int CoArgument(UBYTE *);
1019extern int CoInside(UBYTE *);
1020extern int ExecInside(UBYTE *);
1021extern int CoInExpression(UBYTE *);
1022extern int CoInParallel(UBYTE *);
1023extern int CoNotInParallel(UBYTE *);
1024extern int DoInParallel(UBYTE *,int);
1025extern int CoEndInExpression(UBYTE *);
1026extern int CoBracket(UBYTE *);
1027extern int CoPutInside(UBYTE *);
1028extern int CoAntiPutInside(UBYTE *);
1029extern int CoMultiBracket(UBYTE *);
1030extern int CoCFunction(UBYTE *);
1031extern int CoCTensor(UBYTE *);
1032extern int CoCollect(UBYTE *);
1033extern int CoCompress(UBYTE *);
1034extern int CoContract(UBYTE *);
1035extern int CoCycleSymmetrize(UBYTE *);
1036extern int CoDelete(UBYTE *);
1037extern int CoTableBase(UBYTE *);
1038extern int CoApply(UBYTE *);
1039extern int CoDenominators(UBYTE *);
1040extern int CoDimension(UBYTE *);
1041extern int CoDiscard(UBYTE *);
1042extern int CoDisorder(UBYTE *);
1043extern int CoDrop(UBYTE *);
1044extern int CoDropCoefficient(UBYTE *);
1045extern int CoDropSymbols(UBYTE *);
1046extern int CoElse(UBYTE *);
1047extern int CoElseIf(UBYTE *);
1048extern int CoEndArgument(UBYTE *);
1049extern int CoEndInside(UBYTE *);
1050extern int CoEndIf(UBYTE *);
1051extern int CoEndRepeat(UBYTE *);
1052extern int CoEndTerm(UBYTE *);
1053extern int CoEndWhile(UBYTE *);
1054extern int CoExit(UBYTE *);
1055extern int CoFactArg(UBYTE *);
1056extern int CoFactDollar(UBYTE *);
1057extern int CoFactorize(UBYTE *);
1058extern int CoNFactorize(UBYTE *);
1059extern int CoUnFactorize(UBYTE *);
1060extern int CoNUnFactorize(UBYTE *);
1061extern int DoFactorize(UBYTE *,int);
1062extern int CoFill(UBYTE *);
1063extern int CoFillExpression(UBYTE *);
1064extern int CoFixIndex(UBYTE *);
1065extern int CoFormat(UBYTE *);
1066extern int CoGlobal(UBYTE *);
1067extern int CoGlobalFactorized(UBYTE *);
1068extern int CoGoTo(UBYTE *);
1069extern int CoId(UBYTE *);
1070extern int CoIdNew(UBYTE *);
1071extern int CoIdOld(UBYTE *);
1072extern int CoIf(UBYTE *);
1073extern int CoIfMatch(UBYTE *);
1074extern int CoIfNoMatch(UBYTE *);
1075extern int CoIndex(UBYTE *);
1076extern int CoInsideFirst(UBYTE *);
1077extern int CoKeep(UBYTE *);
1078extern int CoLabel(UBYTE *);
1079extern int CoLoad(UBYTE *);
1080extern int CoLocal(UBYTE *);
1081extern int CoLocalFactorized(UBYTE *);
1082extern int CoMany(UBYTE *);
1083extern int CoMerge(UBYTE *);
1084extern int CoStuffle(UBYTE *);
1085extern int CoMetric(UBYTE *);
1086extern int CoModOption(UBYTE *);
1087extern int CoModuleOption(UBYTE *);
1088extern int CoModulus(UBYTE *);
1089extern int CoMulti(UBYTE *);
1090extern int CoMultiply(UBYTE *);
1091extern int CoNFunction(UBYTE *);
1092extern int CoNPrint(UBYTE *);
1093extern int CoNTensor(UBYTE *);
1094extern int CoNWrite(UBYTE *);
1095extern int CoNoDrop(UBYTE *);
1096extern int CoNoSkip(UBYTE *);
1097extern int CoNormalize(UBYTE *);
1098extern int CoMakeInteger(UBYTE *);
1099extern int CoFlags(UBYTE *,int);
1100extern int CoOff(UBYTE *);
1101extern int CoOn(UBYTE *);
1102extern int CoOnce(UBYTE *);
1103extern int CoOnly(UBYTE *);
1104extern int CoOptimizeOption(UBYTE *);
1105extern int CoOptimize(UBYTE *);
1106extern int CoPolyFun(UBYTE *);
1107extern int CoPolyRatFun(UBYTE *);
1108extern int CoPrint(UBYTE *);
1109extern int CoPrintB(UBYTE *);
1110extern int CoProperCount(UBYTE *);
1111extern int CoUnitTrace(UBYTE *);
1112extern int CoRCycleSymmetrize(UBYTE *);
1113extern int CoRatio(UBYTE *);
1114extern int CoRedefine(UBYTE *);
1115extern int CoRenumber(UBYTE *);
1116extern int CoRepeat(UBYTE *);
1117extern int CoSave(UBYTE *);
1118extern int CoSelect(UBYTE *);
1119extern int CoSet(UBYTE *);
1120extern int CoSetExitFlag(UBYTE *);
1121extern int CoSkip(UBYTE *);
1122extern int CoProcessBucket(UBYTE *);
1123extern int CoPushHide(UBYTE *);
1124extern int CoPopHide(UBYTE *);
1125extern int CoHide(UBYTE *);
1126extern int CoIntoHide(UBYTE *);
1127extern int CoNoHide(UBYTE *);
1128extern int CoUnHide(UBYTE *);
1129extern int CoNoUnHide(UBYTE *);
1130extern int CoSort(UBYTE *);
1131extern int CoSplitArg(UBYTE *);
1132extern int CoSplitFirstArg(UBYTE *);
1133extern int CoSplitLastArg(UBYTE *);
1134extern int CoSum(UBYTE *);
1135extern int CoSymbol(UBYTE *);
1136extern int CoSymmetrize(UBYTE *);
1137extern int DoTable(UBYTE *,int);
1138extern int CoTable(UBYTE *);
1139extern int CoTerm(UBYTE *);
1140extern int CoNTable(UBYTE *);
1141extern int CoCTable(UBYTE *);
1142extern void EmptyTable(TABLES);
1143extern int CoToTensor(UBYTE *);
1144extern int CoToVector(UBYTE *);
1145extern int CoTrace4(UBYTE *);
1146extern int CoTraceN(UBYTE *);
1147extern int CoChisholm(UBYTE *);
1148extern int CoTransform(UBYTE *);
1149extern int CoClearTable(UBYTE *);
1150extern int DoChain(UBYTE *,int);
1151extern int CoChainin(UBYTE *);
1152extern int CoChainout(UBYTE *);
1153extern int CoTryReplace(UBYTE *);
1154extern int CoVector(UBYTE *);
1155extern int CoWhile(UBYTE *);
1156extern int CoWrite(UBYTE *);
1157extern int CoAuto(UBYTE *);
1158extern int CoSwitch(UBYTE *);
1159extern int CoCase(UBYTE *);
1160extern int CoBreak(UBYTE *);
1161extern int CoDefault(UBYTE *);
1162extern int CoEndSwitch(UBYTE *);
1163extern int CoTBaddto(UBYTE *);
1164extern int CoTBaudit(UBYTE *);
1165extern int CoTBcleanup(UBYTE *);
1166extern int CoTBcreate(UBYTE *);
1167extern int CoTBenter(UBYTE *);
1168extern int CoTBhelp(UBYTE *);
1169extern int CoTBload(UBYTE *);
1170extern int CoTBoff(UBYTE *);
1171extern int CoTBon(UBYTE *);
1172extern int CoTBopen(UBYTE *);
1173extern int CoTBreplace(UBYTE *);
1174extern int CoTBuse(UBYTE *);
1175extern int CoTestUse(UBYTE *);
1176extern int CoThreadBucket(UBYTE *);
1177extern int AddComString(int,WORD *,UBYTE *,int);
1178extern int CompileAlgebra(UBYTE *,int,WORD *);
1179extern int IsIdStatement(UBYTE *);
1180extern UBYTE *IsRHS(UBYTE *,UBYTE);
1181extern int ParenthesesTest(UBYTE *);
1182extern int tokenize(UBYTE *,WORD);
1183extern void WriteTokens(SBYTE *);
1184extern int simp1token(SBYTE *);
1185extern int simpwtoken(SBYTE *);
1186extern int simp2token(SBYTE *);
1187extern int simp3atoken(SBYTE *,int);
1188extern int simp3btoken(SBYTE *,int);
1189extern int simp4token(SBYTE *);
1190extern int simp5token(SBYTE *,int);
1191extern int simp6token(SBYTE *,int);
1192extern UBYTE *SkipAName(UBYTE *);
1193extern int TestTables(VOID);
1194extern int GetLabel(UBYTE *);
1195extern int CoIdExpression(UBYTE *,int);
1196extern int CoAssign(UBYTE *);
1197extern int DoExpr(UBYTE *,int,int);
1198extern int CompileSubExpressions(SBYTE *);
1199extern int CodeGenerator(SBYTE *);
1200extern int CompleteTerm(WORD *,UWORD *,UWORD *,WORD,WORD,int);
1201extern int CodeFactors(SBYTE *s);
1202extern WORD GenerateFactors(WORD,WORD);
1203extern int InsTree(int,int);
1204extern int FindTree(int,WORD *);
1205extern void RedoTree(CBUF *,int);
1206extern void ClearTree(int);
1207extern int CatchDollar(int);
1208extern int AssignDollar(PHEAD WORD *,WORD);
1209extern UBYTE *WriteDollarToBuffer(WORD,WORD);
1210extern UBYTE *WriteDollarFactorToBuffer(WORD,WORD,WORD);
1211extern void AddToDollarBuffer(UBYTE *);
1212extern int PutTermInDollar(WORD *,WORD);
1213extern void TermAssign(WORD *);
1214extern void WildDollars(PHEAD WORD *);
1215extern LONG numcommute(WORD *,LONG *);
1216extern int FullRenumber(PHEAD WORD *,WORD);
1217extern int Lus(WORD *,WORD,WORD,WORD,WORD,WORD);
1218extern int FindLus(int,int,int);
1219extern int CoReplaceLoop(UBYTE *);
1220extern int CoFindLoop(UBYTE *);
1221extern int DoFindLoop(UBYTE *,int);
1222extern int CoFunPowers(UBYTE *);
1223extern int SortTheList(int *,int);
1224extern int MatchIsPossible(WORD *,WORD *);
1225extern int StudyPattern(WORD *);
1226extern WORD DolToTensor(PHEAD WORD);
1227extern WORD DolToFunction(PHEAD WORD);
1228extern WORD DolToVector(PHEAD WORD);
1229extern WORD DolToNumber(PHEAD WORD);
1230extern WORD DolToSymbol(PHEAD WORD);
1231extern WORD DolToIndex(PHEAD WORD);
1232extern LONG DolToLong(PHEAD WORD);
1233extern int DollarFactorize(PHEAD WORD);
1234extern int CoPrintTable(UBYTE *);
1235extern int CoDeallocateTable(UBYTE *);
1236extern void CleanDollarFactors(DOLLARS);
1237extern WORD *TakeDollarContent(PHEAD WORD *,WORD **);
1238extern WORD *MakeDollarInteger(PHEAD WORD *,WORD **);
1239extern WORD *MakeDollarMod(PHEAD WORD *,WORD **);
1240extern int GetDolNum(PHEAD WORD *, WORD *);
1241extern void AddPotModdollar(WORD);
1242
1243extern int Optimize(WORD, int);
1244extern int ClearOptimize(VOID);
1245extern int LoadOpti(WORD);
1246extern int PutObject(WORD *,int);
1247extern void CleanOptiBuffer(VOID);
1248extern int PrintOptima(WORD);
1249extern int FindScratchName(VOID);
1250extern WORD MaxPowerOpti(LONG);
1251extern WORD HuntNumFactor(LONG,WORD *,int);
1252extern WORD HuntFactor(LONG,WORD *,int);
1253extern void HuntPairs(LONG,WORD);
1254extern void HuntBrackets(LONG);
1255extern int AddToOpti(WORD *,int);
1256extern LONG TestNewSca(LONG,WORD *,WORD *);
1257extern void NormOpti(WORD *);
1258extern void SortOpti(LONG);
1259extern void SplitOpti(WORD **,LONG);
1260extern void CombiOpti(VOID);
1261extern int TakeLongRoot(UWORD *,WORD *,WORD);
1262extern int TakeRatRoot(UWORD *,WORD *,WORD);
1263extern int MakeRational(WORD ,WORD , WORD *, WORD *);
1264extern int MakeLongRational(PHEAD UWORD *,WORD ,UWORD *,WORD ,UWORD *,WORD *);
1265extern void HuntPowers(LONG,WORD);
1266extern void HuntNumBrackets(LONG);
1267extern void ClearTableTree(TABLES);
1268extern int InsTableTree(TABLES,WORD *);
1269extern void RedoTableTree(TABLES,int);
1270extern int FindTableTree(TABLES,WORD *,int);
1271extern void finishcbuf(WORD);
1272extern void clearcbuf(WORD);
1273extern void CleanUpSort(int);
1274extern FILEHANDLE *AllocFileHandle(WORD,char *);
1275extern VOID DeAllocFileHandle(FILEHANDLE *);
1276extern VOID LowerSortLevel(VOID);
1277extern WORD *PolyRatFunSpecial(PHEAD WORD *, WORD *);
1278extern VOID SimpleSplitMergeRec(WORD *,WORD,WORD *);
1279extern VOID SimpleSplitMerge(WORD *,WORD);
1280extern WORD BinarySearch(WORD *,WORD,WORD);
1281extern int InsideDollar(PHEAD WORD *,WORD);
1282extern DOLLARS DolToTerms(PHEAD WORD);
1283extern WORD EvalDoLoopArg(PHEAD WORD *,WORD);
1284extern int SetExprCases(int,int,int);
1285extern int TestSelect(WORD *,WORD *);
1286extern VOID SubsInAll(PHEAD0);
1287extern VOID TransferBuffer(int,int,int);
1288extern int TakeIDfunction(PHEAD WORD *);
1289extern int MakeSetupAllocs(VOID);
1290extern int TryFileSetups(VOID);
1291extern void ExchangeExpressions(int,int);
1292extern void ExchangeDollars(int,int);
1293extern int GetFirstBracket(WORD *,int);
1294extern int GetFirstTerm(WORD *,int);
1295extern int GetContent(WORD *,int);
1296extern int CleanupTerm(WORD *);
1297extern WORD ContentMerge(PHEAD WORD *,WORD *);
1298extern UBYTE *PreIfDollarEval(UBYTE *,int *);
1299extern LONG TermsInDollar(WORD);
1300extern LONG SizeOfDollar(WORD);
1301extern LONG TermsInExpression(WORD);
1302extern LONG SizeOfExpression(WORD);
1303extern WORD *TranslateExpression(UBYTE *);
1304extern int IsSetMember(WORD *,WORD);
1305extern int IsMultipleOf(WORD *,WORD *);
1306extern int TwoExprCompare(WORD *,WORD *,int);
1307extern void UpdatePositions(VOID);
1308extern void M_check(VOID);
1309extern void M_print(VOID);
1310extern void M_check1(VOID);
1311extern void PrintTime(UBYTE *);
1312
1313extern POSITION *FindBracket(WORD,WORD *);
1314extern VOID PutBracketInIndex(PHEAD WORD *,POSITION *);
1315extern void ClearBracketIndex(WORD);
1316extern VOID OpenBracketIndex(WORD);
1317extern int DoNoParallel(UBYTE *);
1318extern int DoParallel(UBYTE *);
1319extern int DoModSum(UBYTE *);
1320extern int DoModMax(UBYTE *);
1321extern int DoModMin(UBYTE *);
1322extern int DoModLocal(UBYTE *);
1323extern UBYTE *DoModDollar(UBYTE *,int);
1324extern int DoProcessBucket(UBYTE *);
1325extern int DoinParallel(UBYTE *);
1326extern int DonotinParallel(UBYTE *);
1327
1328extern int FlipTable(FUNCTIONS,int);
1329extern int ChainIn(PHEAD WORD *,WORD);
1330extern int ChainOut(PHEAD WORD *,WORD);
1331extern int ArgumentImplode(PHEAD WORD *,WORD *);
1332extern int ArgumentExplode(PHEAD WORD *,WORD *);
1333extern int DenToFunction(WORD *,WORD);
1334
1335extern WORD HowMany(PHEAD WORD *,WORD *);
1336extern VOID RemoveDollars(VOID);
1337extern LONG CountTerms1(PHEAD0);
1338extern LONG TermsInBracket(PHEAD WORD *,WORD);
1339extern int Crash(VOID);
1340
1341extern char *str_dup(char *);
1342extern void convertblock(INDEXBLOCK *,INDEXBLOCK *,int);
1343extern void convertnamesblock(NAMESBLOCK *,NAMESBLOCK *,int);
1344extern void convertiniinfo(INIINFO *,INIINFO *,int);
1345extern int ReadIndex(DBASE *);
1346extern int WriteIndexBlock(DBASE *,MLONG);
1347extern int WriteNamesBlock(DBASE *,MLONG);
1348extern int WriteIndex(DBASE *);
1349extern int WriteIniInfo(DBASE *);
1350extern int ReadIniInfo(DBASE *);
1351extern int AddToIndex(DBASE *,MLONG);
1352extern DBASE *GetDbase(char *);
1353extern DBASE *OpenDbase(char *);
1354extern char *ReadObject(DBASE *,MLONG,char *);
1355extern char *ReadijObject(DBASE *,MLONG,MLONG,char *);
1356extern int ExistsObject(DBASE *,MLONG,char *);
1357extern int DeleteObject(DBASE *,MLONG,char *);
1358extern int WriteObject(DBASE *,MLONG,char *,char *,MLONG);
1359extern MLONG AddObject(DBASE *,MLONG,char *,char *);
1360extern int Cleanup(DBASE *);
1361extern DBASE *NewDbase(char *,MLONG);
1362extern void FreeTableBase(DBASE *);
1363extern int ComposeTableNames(DBASE *);
1364extern int PutTableNames(DBASE *);
1365extern MLONG AddTableName(DBASE *,char *,TABLES);
1366extern MLONG GetTableName(DBASE *,char *);
1367extern MLONG FindTableNumber(DBASE *,char *);
1368extern int TryEnvironment(VOID);
1369
1370#ifdef WITHZLIB
1371extern int SetupOutputGZIP(FILEHANDLE *);
1372extern int PutOutputGZIP(FILEHANDLE *);
1373extern int FlushOutputGZIP(FILEHANDLE *);
1374extern int SetupAllInputGZIP(SORTING *);
1375extern LONG FillInputGZIP(FILEHANDLE *,POSITION *,UBYTE *,LONG,int);
1376extern void ClearSortGZIP(FILEHANDLE *f);
1377#endif
1378
1379#ifdef WITHPTHREADS
1380extern VOID BeginIdentities(VOID);
1381extern int WhoAmI(VOID);
1382extern int StartAllThreads(int);
1383extern void StartHandleLock(VOID);
1384extern VOID TerminateAllThreads(VOID);
1385extern int GetAvailableThread(VOID);
1386extern int ConditionalGetAvailableThread(VOID);
1387extern int BalanceRunThread(PHEAD int,WORD *,WORD);
1388extern void WakeupThread(int,int);
1389extern int MasterWait(VOID);
1390extern int InParallelProcessor(VOID);
1391extern int ThreadsProcessor(EXPRESSIONS,WORD,WORD);
1392extern int MasterMerge(VOID);
1393extern int PutToMaster(PHEAD WORD *);
1394extern void SetWorkerFiles(VOID);
1395extern int MakeThreadBuckets(int,int);
1396extern int SendOneBucket(int);
1397extern int LoadOneThread(int,int,THREADBUCKET *,int);
1398extern void *RunSortBot(void *);
1399extern void MasterWaitAllSortBots(VOID);
1400extern int SortBotMerge(PHEAD0);
1401extern int SortBotOut(PHEAD WORD *);
1402extern void DefineSortBotTree(VOID);
1403extern int SortBotMasterMerge(VOID);
1404extern int SortBotWait(int);
1405extern void StartIdentity(VOID);
1406extern void FinishIdentity(void *);
1407extern int SetIdentity(int *);
1408extern ALLPRIVATES *InitializeOneThread(int);
1409extern void FinalizeOneThread(int);
1410extern void ClearAllThreads(VOID);
1411extern void *RunThread(void *);
1412extern void IAmAvailable(int);
1413extern int ThreadWait(int);
1414extern int ThreadClaimedBlock(int);
1415extern int GetThread(int);
1416extern int UpdateOneThread(int);
1417extern void MasterWaitAll(VOID);
1418extern void MasterWaitAllBlocks(VOID);
1419extern int MasterWaitThread(int);
1420extern void WakeupMasterFromThread(int,int);
1421extern int LoadReadjusted(VOID);
1422extern int IniSortBlocks(int);
1423extern int TreatIndexEntry(PHEAD LONG);
1424extern WORD GetTerm2(PHEAD WORD *);
1425extern void SetHideFiles(VOID);
1426
1427#endif
1428
1429extern int CopyExpression(FILEHANDLE *,FILEHANDLE *);
1430
1431extern int set_in(UBYTE, set_of_char);
1432extern one_byte set_set(UBYTE, set_of_char);
1433extern one_byte set_del(UBYTE, set_of_char);
1434extern one_byte set_sub (set_of_char, set_of_char, set_of_char);
1435extern int DoPreAddSeparator(UBYTE *);
1436extern int DoPreRmSeparator(UBYTE *);
1437
1438/*See the file extcmd.c*/
1439extern int openExternalChannel(UBYTE *,int,UBYTE *,UBYTE *);
1440extern int initPresetExternalChannels(UBYTE *, int);
1441extern int closeExternalChannel(int);
1442extern int selectExternalChannel(int);
1443extern int getCurrentExternalChannel(VOID);
1444extern VOID closeAllExternalChannels(VOID);
1445
1446typedef int (*WRITEBUFTOEXTCHANNEL)(char *,size_t);
1447typedef int (*GETCFROMEXTCHANNEL)(VOID);
1448typedef int (*SETTERMINATORFOREXTERNALCHANNEL)(char *);
1449typedef int (*SETKILLMODEFOREXTERNALCHANNEL)(int,int);
1450typedef LONG (*WRITEFILE)(int,UBYTE *,LONG);
1451typedef WORD (*GETTERM)(PHEAD WORD *);
1452
1453#define CompareTerms ((COMPARE)AR.CompareRoutine)
1454#define FiniShuffle AN.SHvar.finishuf
1455#define DoShtuffle ((DO_UFFLE)AN.SHvar.do_uffle)
1456
1457extern UBYTE *defineChannel(UBYTE*, HANDLERS*);
1458extern int writeToChannel(int,UBYTE *,HANDLERS*);
1459#ifdef WITHEXTERNALCHANNEL
1460extern LONG WriteToExternalChannel(int,UBYTE *,LONG);
1461#endif
1462extern int writeBufToExtChannelOk(char *,size_t);
1463extern int getcFromExtChannelOk(VOID);
1464extern int setKillModeForExternalChannelOk(int,int);
1465extern int setTerminatorForExternalChannelOk(char *);
1466extern int getcFromExtChannelFailure(VOID);
1467extern int setKillModeForExternalChannelFailure(int,int);
1468extern int setTerminatorForExternalChannelFailure(char *);
1469extern int writeBufToExtChannelFailure(char *,size_t);
1470
1471extern int ReleaseTB(VOID);
1472
1473extern int SymbolNormalize(WORD *);
1474extern int TestFunFlag(PHEAD WORD *);
1475extern WORD CompareSymbols(WORD *,WORD *,WORD);
1476extern WORD CompareHSymbols(WORD *,WORD *,WORD);
1477extern WORD NextPrime(PHEAD WORD);
1478extern WORD Moebius(PHEAD WORD);
1479extern UWORD wranf(PHEAD0);
1480extern UWORD iranf(PHEAD UWORD);
1481extern void iniwranf(PHEAD0);
1482extern UBYTE *PreRandom(UBYTE *);
1483
1484extern WORD *PolyNormPoly (PHEAD WORD);
1485extern WORD *EvaluateGcd(PHEAD WORD *);
1486extern int TreatPolyRatFun(PHEAD WORD *);
1487
1488extern WORD ReadSaveHeader(VOID);
1489extern WORD ReadSaveIndex(FILEINDEX *);
1490extern WORD ReadSaveExpression(UBYTE *,UBYTE *,LONG *,LONG *);
1491extern UBYTE *ReadSaveTerm32(UBYTE *,UBYTE *,UBYTE **,UBYTE *,UBYTE *,int);
1492extern WORD ReadSaveVariables(UBYTE *,UBYTE *,LONG *,LONG *,INDEXENTRY *,LONG *);
1493extern WORD WriteStoreHeader(WORD);
1494
1495extern void InitRecovery(VOID);
1496extern int CheckRecoveryFile(VOID);
1497extern void DeleteRecoveryFile(VOID);
1498extern char *RecoveryFilename(VOID);
1499extern int DoRecovery(int *);
1500extern void DoCheckpoint(int);
1501
1502extern VOID NumberMallocAddMemory(PHEAD0);
1503extern VOID CacheNumberMallocAddMemory(PHEAD0);
1504extern VOID TermMallocAddMemory(PHEAD0);
1505#ifndef MEMORYMACROS
1506extern WORD *TermMalloc2(PHEAD char *text);
1507extern VOID TermFree2(PHEAD WORD *term,char *text);
1508extern UWORD *NumberMalloc2(PHEAD char *text);
1509extern UWORD *CacheNumberMalloc2(PHEAD char *text);
1510extern VOID NumberFree2(PHEAD UWORD *NumberMem,char *text);
1511extern VOID CacheNumberFree2(PHEAD UWORD *NumberMem,char *text);
1512#endif
1513
1514extern void ExprStatus(EXPRESSIONS);
1515extern VOID iniTools(VOID);
1516extern int TestTerm(WORD *);
1517
1518extern WORD RunTransform(PHEAD WORD *term, WORD *params);
1519extern WORD RunEncode(PHEAD WORD *fun, WORD *args, WORD *info);
1520extern WORD RunDecode(PHEAD WORD *fun, WORD *args, WORD *info);
1521extern WORD RunReplace(PHEAD WORD *fun, WORD *args, WORD *info);
1522extern WORD RunImplode(WORD *fun, WORD *args);
1523extern WORD RunExplode(PHEAD WORD *fun, WORD *args);
1524extern int TestArgNum(int n, int totarg, WORD *args);
1525extern WORD PutArgInScratch(WORD *arg,UWORD *scrat);
1526extern UBYTE *ReadRange(UBYTE *s, WORD *out, int par);
1527extern int FindRange(PHEAD WORD *,WORD *,WORD *,WORD);
1528extern WORD RunPermute(PHEAD WORD *fun, WORD *args, WORD *info);
1529extern WORD RunReverse(PHEAD WORD *fun, WORD *args);
1530extern WORD RunCycle(PHEAD WORD *fun, WORD *args, WORD *info);
1531extern WORD RunAddArg(PHEAD WORD *fun, WORD *args);
1532extern WORD RunMulArg(PHEAD WORD *fun, WORD *args);
1533extern WORD RunIsLyndon(PHEAD WORD *fun, WORD *args, int par);
1534extern WORD RunToLyndon(PHEAD WORD *fun, WORD *args, int par);
1535extern WORD RunDropArg(PHEAD WORD *fun, WORD *args);
1536extern WORD RunSelectArg(PHEAD WORD *fun, WORD *args);
1537extern WORD RunDedup(PHEAD WORD *fun, WORD *args);
1538
1539extern int NormPolyTerm(PHEAD WORD *);
1540extern WORD ComparePoly(WORD *, WORD *, WORD);
1541extern int ConvertToPoly(PHEAD WORD *, WORD *,WORD *,WORD);
1542extern int LocalConvertToPoly(PHEAD WORD *, WORD *, WORD,WORD);
1543extern int ConvertFromPoly(PHEAD WORD *, WORD *, WORD, WORD, WORD, WORD);
1544extern WORD FindSubterm(WORD *);
1545extern WORD FindLocalSubterm(PHEAD WORD *, WORD);
1546extern void PrintSubtermList(int,int);
1547extern void PrintExtraSymbol(int,WORD *,int);
1548extern WORD FindSubexpression(WORD *);
1549
1550extern void UpdateMaxSize(VOID);
1551
1552extern int CoToPolynomial(UBYTE *);
1553extern int CoFromPolynomial(UBYTE *);
1554extern int CoArgToExtraSymbol(UBYTE *);
1555extern int CoExtraSymbols(UBYTE *);
1556extern UBYTE *GetDoParam(UBYTE *, WORD **, int);
1557extern WORD *GetIfDollarFactor(UBYTE **, WORD *);
1558extern int CoDo(UBYTE *);
1559extern int CoEndDo(UBYTE *);
1560extern int ExtraSymFun(PHEAD WORD *,WORD);
1561extern int PruneExtraSymbols(WORD);
1562extern int IniFbuffer(WORD);
1563extern void IniFbufs(VOID);
1564extern int GCDfunction(PHEAD WORD *,WORD);
1565extern WORD *GCDfunction3(PHEAD WORD *,WORD *);
1566extern WORD *GCDfunction4(PHEAD WORD *,WORD *);
1567extern int ReadPolyRatFun(PHEAD WORD *);
1568extern int FromPolyRatFun(PHEAD WORD *, WORD **, WORD **);
1569extern void PRFnormalize(PHEAD WORD *);
1570extern WORD *PRFadd(PHEAD WORD *, WORD *);
1571extern WORD *PolyDiv(PHEAD WORD *,WORD *,char *);
1572extern WORD *PolyGCD(PHEAD WORD *,WORD *);
1573extern WORD *PolyAdd(PHEAD WORD *,WORD *);
1574extern void GCDclean(PHEAD WORD *, WORD *);
1575extern int RatFunNormalize(PHEAD WORD *);
1576extern WORD *TakeSymbolContent(PHEAD WORD *,WORD *);
1577extern int GCDterms(PHEAD WORD *,WORD *,WORD *);
1578extern WORD *PutExtraSymbols(PHEAD WORD *,WORD,int *);
1579extern WORD *TakeExtraSymbols(PHEAD WORD *,WORD);
1580extern WORD *MultiplyWithTerm(PHEAD WORD *, WORD *,WORD);
1581extern WORD *TakeContent(PHEAD WORD *, WORD *);
1582extern int MergeSymbolLists(PHEAD WORD *, WORD *, int);
1583extern int MergeDotproductLists(PHEAD WORD *, WORD *, int);
1584extern WORD *CreateExpression(PHEAD WORD);
1585extern int DIVfunction(PHEAD WORD *,WORD,int);
1586extern WORD *MULfunc(PHEAD WORD *, WORD *);
1587extern WORD *ConvertArgument(PHEAD WORD *,int *);
1588extern int ExpandRat(PHEAD WORD *);
1589extern int InvPoly(PHEAD WORD *,WORD,WORD);
1590extern WORD TestDoLoop(PHEAD WORD *,WORD);
1591extern WORD TestEndDoLoop(PHEAD WORD *,WORD);
1592
1593extern WORD *poly_gcd(PHEAD WORD *, WORD *, WORD);
1594extern WORD *poly_div(PHEAD WORD *, WORD *, WORD);
1595extern WORD *poly_rem(PHEAD WORD *, WORD *, WORD);
1596extern WORD *poly_inverse(PHEAD WORD *, WORD *);
1597extern WORD *poly_mul(PHEAD WORD *, WORD *);
1598extern WORD *poly_ratfun_add(PHEAD WORD *, WORD *);
1599extern int poly_ratfun_normalize(PHEAD WORD *);
1600extern int poly_factorize_argument(PHEAD WORD *, WORD *);
1601extern WORD *poly_factorize_dollar(PHEAD WORD *);
1602extern int poly_factorize_expression(EXPRESSIONS);
1603extern int poly_unfactorize_expression(EXPRESSIONS);
1604extern void poly_free_poly_vars(PHEAD const char *);
1605
1606extern VOID optimize_print_code (int);
1607
1608#ifdef WITHPTHREADS
1609extern void find_Horner_MCTS_expand_tree();
1610extern void find_Horner_MCTS_expand_tree_threaded();
1612extern void optimize_expression_given_Horner_threaded();
1613#endif
1614
1615extern int DoPreAdd(UBYTE *s);
1616extern int DoPreUseDictionary(UBYTE *s);
1617extern int DoPreCloseDictionary(UBYTE *s);
1618extern int DoPreOpenDictionary(UBYTE *s);
1619extern void RemoveDictionary(DICTIONARY *dict);
1620extern void UnSetDictionary(VOID);
1621extern int SetDictionaryOptions(UBYTE *options);
1622extern int SelectDictionary(UBYTE *name,UBYTE *options);
1623extern int AddToDictionary(DICTIONARY *dict,UBYTE *left,UBYTE *right);
1624extern int AddDictionary(UBYTE *name);
1625extern int FindDictionary(UBYTE *name);
1626extern UBYTE *IsExponentSign(VOID);
1627extern UBYTE *IsMultiplySign(VOID);
1628extern VOID TransformRational(UWORD *a, WORD na);
1629extern void WriteDictionary(DICTIONARY *);
1630extern void ShrinkDictionary(DICTIONARY *);
1631extern void MultiplyToLine(VOID);
1632extern UBYTE *FindSymbol(WORD num);
1633extern UBYTE *FindVector(WORD num);
1634extern UBYTE *FindIndex(WORD num);
1635extern UBYTE *FindFunction(WORD num);
1636extern UBYTE *FindFunWithArgs(WORD *t);
1637extern UBYTE *FindExtraSymbol(WORD num);
1638extern LONG DictToBytes(DICTIONARY *dict,UBYTE *buf);
1639extern DICTIONARY *DictFromBytes(UBYTE *buf);
1640extern int CoCreateSpectator(UBYTE *inp);
1641extern int CoToSpectator(UBYTE *inp);
1642extern int CoRemoveSpectator(UBYTE *inp);
1643extern int CoEmptySpectator(UBYTE *inp);
1644extern int CoCopySpectator(UBYTE *inp);
1645extern int PutInSpectator(WORD *,WORD);
1646extern void ClearSpectators(WORD);
1647extern WORD GetFromSpectator(WORD *,WORD);
1648extern void FlushSpectators(VOID);
1649
1650extern WORD *PreGCD(PHEAD WORD *, WORD *,int);
1651extern WORD *FindCommonVariables(PHEAD int,int);
1652extern VOID AddToSymbolList(PHEAD WORD);
1653extern int AddToListPoly(PHEAD0);
1654extern int InvPoly(PHEAD WORD *,WORD,WORD);
1655
1656extern int ReadFromScratch(FILEHANDLE *,POSITION *,UBYTE *,POSITION *);
1657extern int AddToScratch(FILEHANDLE *,POSITION *,UBYTE *,POSITION *,int);
1658
1659extern int DoPreAppendPath(UBYTE *);
1660extern int DoPrePrependPath(UBYTE *);
1661
1662extern int DoSwitch(PHEAD WORD *, WORD *);
1663extern int DoEndSwitch(PHEAD WORD *, WORD *);
1664extern SWITCHTABLE *FindCase(WORD, WORD);
1665extern VOID SwitchSplitMergeRec(SWITCHTABLE *, WORD, SWITCHTABLE *);
1666extern VOID SwitchSplitMerge(SWITCHTABLE *, WORD);
1667extern int DoubleSwitchBuffers(VOID);
1668
1669extern int DistrN(int, int *, int, int *);
1670
1671/*
1672 #] Declarations :
1673*/
1674#endif
void InitRecovery()
Definition checkpoint.c:399
int CheckRecoveryFile()
Definition checkpoint.c:278
void DeleteRecoveryFile()
Definition checkpoint.c:333
char * RecoveryFilename()
Definition checkpoint.c:364
WORD * MakeMod(PHEAD WORD *, WORD *, WORD *)
Definition argument.c:3442
WORD FindArg(PHEAD WORD *)
Definition argument.c:2472
WORD * poly_ratfun_add(PHEAD WORD *, WORD *)
Definition polywrap.cc:600
WORD CompareSymbols(WORD *, WORD *, WORD)
Definition sort.c:2976
int poly_unfactorize_expression(EXPRESSIONS)
Definition polywrap.cc:1457
int LocalConvertToPoly(PHEAD WORD *, WORD *, WORD, WORD)
Definition notation.c:510
void finishcbuf(WORD)
Definition comtool.c:89
void clearcbuf(WORD)
Definition comtool.c:116
WORD * poly_factorize_dollar(PHEAD WORD *)
Definition polywrap.cc:1074
WORD InsertArg(PHEAD WORD *, WORD *, int)
Definition argument.c:2496
WORD PrepPoly(PHEAD WORD *, WORD)
Definition proces.c:4744
VOID StageSort(FILEHANDLE *)
Definition sort.c:4453
WORD CompCoef(WORD *, WORD *)
Definition reken.c:3037
LONG ComPress(WORD **, LONG *)
Definition sort.c:3074
WORD InFunction(PHEAD WORD *, WORD *)
Definition proces.c:2033
WORD * MakeDollarInteger(PHEAD WORD *, WORD **)
Definition dollar.c:3622
WORD * AddRHS(int, int)
Definition comtool.c:214
int DoPrePrependPath(UBYTE *)
Definition pre.c:6971
void AddPotModdollar(WORD)
Definition dollar.c:3954
void CleanUpSort(int)
Definition sort.c:4644
WORD * TakeArgContent(PHEAD WORD *, WORD *)
Definition argument.c:2725
VOID WriteStats(POSITION *, WORD)
Definition sort.c:93
WORD NewSort(PHEAD0)
Definition sort.c:592
VOID RaisPowCached(PHEAD WORD, WORD, UWORD **, WORD *)
Definition reken.c:1286
WORD PutOut(PHEAD WORD *, POSITION *, FILEHANDLE *, WORD)
Definition sort.c:1405
int poly_ratfun_normalize(PHEAD WORD *)
Definition polywrap.cc:719
WORD TermRenumber(WORD *, RENUMBER, WORD)
Definition store.c:2407
int DoRecovery(int *)
int AddNtoC(int, int, WORD *, int)
Definition comtool.c:317
LONG EndSort(PHEAD WORD *, int)
Definition sort.c:682
WORD * MakeDollarMod(PHEAD WORD *, WORD **)
Definition dollar.c:3796
void DoCheckpoint(int)
WORD * TakeSymbolContent(PHEAD WORD *, WORD *)
Definition ratio.c:2434
WORD * DoubleCbuffer(int, WORD *, int)
Definition comtool.c:143
LONG TimeWallClock(WORD)
Definition tools.c:3476
int TestTerm(WORD *)
Definition tools.c:3861
WORD * TakeContent(PHEAD WORD *, WORD *)
Definition ratio.c:1376
WORD AddPoly(PHEAD WORD **, WORD **)
Definition sort.c:2089
WORD MergePatches(WORD)
Definition sort.c:3577
int IniFbuffer(WORD)
Definition comtool.c:614
WORD InsertTerm(PHEAD WORD *, WORD, WORD, WORD *, WORD *, WORD)
Definition proces.c:2579
WORD Generator(PHEAD WORD *, WORD)
Definition proces.c:3101
WORD StoreTerm(PHEAD WORD *)
Definition sort.c:4333
LONG PasteFile(PHEAD WORD, WORD *, POSITION *, WORD **, RENUMBER, WORD *, WORD)
Definition proces.c:2715
WORD TestMatch(PHEAD WORD *, WORD *)
Definition pattern.c:97
int DoPreAppendPath(UBYTE *)
Definition pre.c:6954
WORD NextPrime(PHEAD WORD)
Definition reken.c:3654
int poly_factorize_expression(EXPRESSIONS)
Definition polywrap.cc:1100
int CopyFile(char *, char *)
Definition tools.c:1101
int CleanupArgCache(PHEAD WORD)
Definition argument.c:2531
WORD Sflush(FILEHANDLE *)
Definition sort.c:1319
VOID StartVariables()
Definition startup.c:866
int Optimize(WORD, int)
Definition optimize.cc:4587
LONG SplitMerge(PHEAD WORD **, LONG)
Definition sort.c:3240
UBYTE * ReadSaveTerm32(UBYTE *, UBYTE *, UBYTE **, UBYTE *, UBYTE *, int)
Definition store.c:4683
WORD ReadSaveVariables(UBYTE *, UBYTE *, LONG *, LONG *, INDEXENTRY *, LONG *)
Definition store.c:4323
VOID AddArgs(PHEAD WORD *, WORD *, WORD *)
Definition sort.c:2251
WORD TestSub(PHEAD WORD *, WORD)
Definition proces.c:681
WORD AddCoef(PHEAD WORD **, WORD **)
Definition sort.c:1962
WORD DoOnePow(PHEAD WORD *, WORD, WORD, WORD *, WORD *, WORD, WORD *)
Definition proces.c:4395
VOID optimize_print_code(int)
Definition optimize.cc:4474
WORD ReadSaveIndex(FILEINDEX *)
Definition store.c:4137
int NormalModulus(UWORD *, WORD *)
Definition reken.c:1393
int poly_factorize_argument(PHEAD WORD *, WORD *)
Definition polywrap.cc:1047
WORD WriteStoreHeader(WORD)
Definition store.c:3926
int AddNtoL(int, WORD *)
Definition comtool.c:288
WORD * PasteTerm(PHEAD WORD, WORD *, WORD *, WORD, WORD)
Definition proces.c:2837
WORD FlushOut(POSITION *, FILEHANDLE *, int)
Definition sort.c:1748
WORD SortWild(WORD *, WORD)
Definition sort.c:4552
WORD FiniTerm(PHEAD WORD *, WORD *, WORD *, WORD, WORD)
Definition proces.c:2902
LONG TimeCPU(WORD)
Definition tools.c:3550
int inicbufs(VOID)
Definition comtool.c:47
WORD Compare1(WORD *, WORD *, WORD)
Definition sort.c:2536
int GetModInverses(WORD, WORD, WORD *, WORD *)
Definition reken.c:1466
WORD PolyFunMul(PHEAD WORD *)
Definition proces.c:5132
WORD EvalDoLoopArg(PHEAD WORD *, WORD)
Definition dollar.c:2646
int PutPreVar(UBYTE *, UBYTE *, UBYTE *, int)
Definition pre.c:642
LONG PutIn(FILEHANDLE *, POSITION *, WORD *, WORD **, int)
Definition sort.c:1259
void SortWeights(LONG *, LONG *, WORD)
Definition argument.c:3487
int SymbolNormalize(WORD *)
Definition normal.c:5014
int TheDefine(UBYTE *, int)
Definition pre.c:1942
WORD * MakeInteger(PHEAD WORD *, WORD *, WORD *)
Definition argument.c:3271
WORD * poly_gcd(PHEAD WORD *, WORD *, WORD)
Definition polywrap.cc:124
WORD * AddLHS(int)
Definition comtool.c:188
WORD CompareHSymbols(WORD *, WORD *, WORD)
Definition sort.c:3020
WORD ReadSaveExpression(UBYTE *, UBYTE *, LONG *, LONG *)
Definition store.c:5092
WORD Deferred(PHEAD WORD *, WORD)
Definition proces.c:4616
int ClearOptimize()
Definition optimize.cc:4924
void optimize_expression_given_Horner()
Definition optimize.cc:4014
WORD Processor()
Definition proces.c:64
int MakeInverses()
Definition reken.c:1430
VOID GarbHand()
Definition sort.c:3462
VOID LowerSortLevel()
Definition sort.c:4727
WORD SetFileIndex()
Definition store.c:2300
WORD ReadSaveHeader()
Definition store.c:4019
struct TrAcEs TRACES
struct InDeXeNtRy INDEXENTRY
struct FuNcTiOn * FUNCTIONS
struct CbUf CBUF
struct PaRtI PARTI
struct PeRmUtEp PERMP
struct NaMeTree NAMETREE
struct ReNuMbEr * RENUMBER
struct DiStRiBuTe DISTRIBUTE
struct FiLe FILEHANDLE
struct VaRrEnUm VARRENUM
struct TaBlEs * TABLES
struct bit_field * one_byte
Definition structs.h:909
struct StreaM STREAM
struct FiLeInDeX FILEINDEX
struct PeRmUtE PERM
struct sOrT SORTING
struct bit_field set_of_char[32]
Definition structs.h:903
struct NaMeNode NAMENODE