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