OpenXM_contrib2/asir2000/parse/parse.h - diff

Return to parse.h CVS log

Up to [local] / OpenXM_contrib2 / asir2000 / parse

Diff for /OpenXM_contrib2/asir2000/parse/parse.h between version 1.15 and 1.59

version 1.15, 2001/10/09 01:36:24

version 1.59, 2020/10/04 03:14:09

Line 45

* DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,

* PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.

* $OpenXM: OpenXM_contrib2/asir2000/parse/parse.h,v 1.14 2001/09/05 09:01:28 noro Exp $

* $OpenXM: OpenXM_contrib2/asir2000/parse/parse.h,v 1.58 2019/11/12 10:52:05 kondoh Exp $

# if defined(VISUAL)

# if defined(VISUAL) || defined(__MINGW32__)

#include <time.h>

#else

#include <sys/time.h>

Line 59

#define ABS(a) ((a)>0?(a):-(a))

#endif

#include <math.h>

#include <ctype.h>

/* identifiers for expressions */

typedef enum {

I_BOP, I_COP, I_AND, I_OR, I_NOT, I_CE,

I_PRESELF, I_POSTSELF,

I_FUNC, I_FUNC_OPT, I_IFUNC, I_MAP, I_RECMAP, I_PFDERIV,

I_ANS, I_PVAR, I_ASSPVAR,

I_FORMULA, I_LIST, I_STR, I_NEWCOMP, I_CAR, I_CDR, I_CAST,

I_COM, I_PROC, I_INDEX, I_EV, I_TIMER, I_GF2NGEN, I_GFPNGEN, I_GFSNGEN,

I_INDEX, I_EV, I_TIMER, I_GF2NGEN, I_GFPNGEN, I_GFSNGEN,

I_LOP, I_OPT, I_GETOPT, I_POINT, I_QUOTE, I_PAREN, I_MINUS

I_LOP, I_OPT, I_GETOPT, I_POINT, I_PAREN, I_MINUS,

I_NARYOP, I_CONS, I_FUNC_QARG, I_FUNC_HEAD, I_EVM

} fid;

/* identifiers for statements */

typedef enum {

S_BP, S_PFDEF,

S_SINGLE, S_CPLX,

S_IFELSE, S_FOR, S_DO,

S_BREAK, S_RETURN, S_CONTINUE

S_BREAK, S_RETURN, S_CONTINUE,

S_MODULE

} sid;

/* identifiers for comparison operators */

Line 96 typedef enum { A_UNDEF, A_BIN, A_USR, A_PURE, A_PARI }

Line 101 typedef enum { A_UNDEF, A_BIN, A_USR, A_PURE, A_PARI }

typedef enum { V_IND, V_UC, V_PF, V_SR } vid;

struct oVS {

typedef struct oVS {

unsigned int n;

unsigned int asize;

unsigned int at;

unsigned int level;

struct oFUNC *usrf;

struct oPV *va;

NODE opt;

};

} *VS;

typedef struct oVS *VS;

typedef struct oMODULE {

char *name;

VS pvs;

NODE usrf_list;

} *MODULE;

struct oPV {

typedef struct oPV {

char *name;

short attr,type;

pointer priv;

};

} *PV;

typedef struct oPV *PV;

typedef struct oINFILE {

char *name;

FILE *fp;

JMP_BUF jmpbuf;

int ready_for_longjmp;

int ln;

struct oINFILE *next;

char *tname;

int encoded;

short vol;

} *INFILE;

struct oINFILE {

char *name;

FILE *fp;

int ln;

struct oINFILE *next;

char *tname;

int encoded;

short vol;

};

typedef struct oINFILE *INFILE;

struct oTKWD {

char *name;

int token;

};

struct oARF {

typedef struct fid_spec {

char *name;

fid id;

void (*fp)();

farg_type type[10];

};

} *fid_spec_p;

typedef struct oARF *ARF;

typedef struct oARF {

char *name;

void (*fp)();

} *ARF;

struct oFUNC {

typedef struct oFUNC {

char *name;

char *name,*fullname;

int argc;

int type;

aid id;

int secure;

union {

aid id;

void (*binf)();

unsigned int quote;

struct oUSRF *usrf;

union {

struct oPF *puref;

void (*binf)();

} f;

struct oUSRF *usrf;

};

struct oPF *puref;

} f;

} *FUNC;

typedef struct oFUNC *FUNC;

typedef struct oUSRF {

char *fname;

MODULE module;

int startl,endl;

NODE args;

VS pvs;

char *desc;

struct oSNODE *body;

} *USRF;

struct oUSRF {

typedef struct oPF {

char *fname;

char *name;

short vol;

int argc;

int startl,endl;

Obj body;

NODE args;

V *args;

VS pvs;

Obj *deriv;

char *desc;

NODE ins;

struct oSNODE *body;

int (*pari)();

};

double (*libm)();

int (*simplify)();

#if defined(INTERVAL)

void (**intervalfunc)();

#endif

} *PF;

typedef struct oUSRF *USRF;

typedef struct oPFAD {

Obj arg;

int d;

} *PFAD;

struct oPF {

typedef struct oPFINS {

char *name;

struct oPF *pf;

int argc;

struct oPFAD ad[1];

Obj body;

} *PFINS;

V *args;

Obj *deriv;

NODE ins;

int (*pari)();

double (*libm)();

int (*simplify)();

};

typedef struct oPF *PF;

struct oPFAD {

Obj arg;

int d;

};

typedef struct oPFAD *PFAD;

struct oPFINS {

struct oPF *pf;

struct oPFAD ad[1];

};

typedef struct oPFINS *PFINS;

#define NEWPF(p) ((p)=(PF)MALLOC(sizeof(struct oPF)))

struct oFNODE {

typedef struct oFNODE {

fid id;

short id;

pointer arg[1];

unsigned normalized:1;

};

unsigned expanded:2;

unsigned coef:1;

pointer arg[1];

} *FNODE;

typedef struct oFNODE *FNODE;

#define NEWFNODE(a,b) \

((a)=(FNODE)MALLOC(sizeof(struct oFNODE)+sizeof(pointer)*(b-1)))

struct oSNODE {

typedef struct oSNODE {

sid id;

int ln;

pointer arg[1];

};

} *SNODE;

typedef struct oSNODE *SNODE;

#define NEWSNODE(a,b) \

((a)=(SNODE)MALLOC(sizeof(struct oSNODE)+sizeof(pointer)*(b-1)),(a)->ln=asir_infile->ln)

struct oPVI {

typedef struct oPVI {

int pv;

NODE index;

};

} *PVI;

typedef struct oPVI *PVI;

typedef struct oNODE2 {

pointer body1,body2;

struct oNODE2 *next;

} *NODE2;

struct oNODE2 {

pointer body1,body2;

struct oNODE2 *next;

};

typedef struct oNODE2 *NODE2;

struct ftab {

char *name;

void (*f)();

int argc;

unsigned int quote;

};

#define MKPVI(a,b,c)\

Line 262 struct ftab {

Line 263 struct ftab {

#define asir_assert(ptr,id,message)\

switch ( id ) {\

case O_N: case O_P: case O_R:\

if( (ptr) && (OID(ptr) > (id)) ) {\

fprintf(stderr,message);\

error(" : invalid argument");\

break;\

case O_DP:\

if( (ptr) && (OID(ptr) != (id)) ) {\

fprintf(stderr,message);\

error(" : invalid argument");\

break;\

default:\

if( !(ptr) || (OID(ptr) != (id)) ) {\

fprintf(stderr,message);\

error(" : invalid argument");\

break;\

}

#define DEFSIZE 32

#define MSB (1<<31)

#define PVGLOBAL(i) (((unsigned int)(i))|(1<<30))

#define PVMGLOBAL(i) (((unsigned int)(i))|(2<<30))

#define PVPATTERN(i) (((unsigned int)(i))|(3<<30))

#define PVATTR(i) (((unsigned int)(i))>>30)

#define PVIND(i) (((unsigned int)(i))&0x3fffffff)

#define GETPV(i,p) \

((int)(i)>=0 ? (int)((p)=CPVS->va[(unsigned int)(i)].priv)\

(PVATTR(i)==0?(int)((p)=CPVS->va[(unsigned int)(i)].priv)\

: (int)((p)=GPVS->va[(unsigned int)(i)&(~MSB)].priv))

:PVATTR(i)==1?(int)((p)=GPVS->va[PVIND(i)].priv)\

:PVATTR(i)==2?(int)((p)=MPVS->va[PVIND(i)].priv)\

:(int)((p)=PPVS->va[PVIND(i)].priv))

#define GETPVREF(i,p) \

(PVATTR(i)==0?(int)((p)=&(CPVS->va[(unsigned int)(i)].priv))\

:PVATTR(i)==1?(int)((p)=&(GPVS->va[PVIND(i)].priv))\

:PVATTR(i)==2?(int)((p)=&(MPVS->va[PVIND(i)].priv))\

:(int)((p)=&(PPVS->va[PVIND(i)].priv)))

#define GETPVNAME(i,p) \

((int)(i)>=0 ? (int)((p)=CPVS->va[(unsigned int)(i)].name)\

(PVATTR(i)==0?(int)((p)=CPVS->va[(unsigned int)(i)].name)\

: (int)((p)=GPVS->va[(unsigned int)(i)&(~MSB)].name))

:PVATTR(i)==1?(int)((p)=GPVS->va[PVIND(i)].name)\

:PVATTR(i)==2?(int)((p)=MPVS->va[PVIND(i)].name)\

:(int)((p)=PPVS->va[PVIND(i)].name))

#define ASSPV(i,p) \

((int)(i)>=0 ? (int)(CPVS->va[(unsigned int)(i)].priv=(pointer)(p))\

(PVATTR(i)==0?(int)(CPVS->va[(unsigned int)(i)].priv=(pointer)(p))\

: (int)(GPVS->va[(unsigned int)(i)&(~MSB)].priv=(pointer)(p)))

:PVATTR(i)==1?(int)(GPVS->va[PVIND(i)].priv=(pointer)(p))\

:PVATTR(i)==2?(int)(MPVS->va[PVIND(i)].priv=(pointer)(p))\

:(int)(PPVS->va[PVIND(i)].priv=(pointer)(p)))

#define NEWNODE2(a) ((a)=(NODE2)MALLOC(sizeof(struct oNODE2)))

#define MKNODE2(a,b,c,d) \

Line 300 switch ( id ) {\

Line 319 switch ( id ) {\

#define BDY1(a) ((a)->body1)

#define BDY2(a) ((a)->body2)

extern VS GPVS,CPVS,EPVS,APVS;

extern VS GPVS,CPVS,EPVS,APVS,MPVS,PPVS;

extern MODULE CUR_MODULE;

extern NODE MODULE_LIST;

extern char *CUR_FUNC;

extern ARF addfs, subfs, mulfs, divfs, remfs, pwrfs;

extern INFILE asir_infile;

extern NODE usrf,sysf,noargsysf,ubinf,parif,ONENODE;

extern int nextbp,nextbplevel;

extern int Verbose;

extern int do_quiet;

extern SYMBOL Symbol_grlex, Symbol_glex, Symbol_lex;

extern NODE current_option;

#if defined(VISUAL_LIB)

#include <w_stdio.h>

Line 322 extern int Verbose;

Line 347 extern int Verbose;

#define fflush w_fflush

#endif

#if defined(VISUAL) || (defined(__MACH__) && defined(__ppc__))

#if defined(__GNUC__) || defined(VISUAL) || defined(__MINGW32__) || (defined(__MACH__) && defined(__ppc__)) || defined(__FreeBSD__)

NODE mknode(int,...);

FNODE mkfnode(int,fid,...);

SNODE mksnode(int,sid,...);

Line 341 void dp_ptozp_d(DP,DP *);

Line 366 void dp_ptozp_d(DP,DP *);

void dp_vtod(Q *,DP,DP *);

void dp_idivv_hist(Q,DP *);

void dp_igcdv_hist(DP,Q *);

void dp_ptozp3(DP,Q *,DP *);

void dp_ptozp2(DP,DP,DP *,DP *);

void dp_ptozp(DP,DP *);

void dp_nf_tab_mod(DP,LIST *,int,DP *);

Line 351 void dp_mbase(NODE,NODE *);

Line 377 void dp_mbase(NODE,NODE *);

void dp_dtov(DP,VECT *);

void dp_cont(DP,Q *);

void dp_idiv(DP,Q,DP *);

void dtodpm(DP d,int pos,DPM *dp);

void dpm_nf_z(NODE b,DPM g,DPM *ps,int full,int multiple,DPM *rp);

void dpm_nf_f(NODE b,DPM g,DPM *ps,int full,DPM *rp);

void weyl_actd(VL vl,DP p1,DP p2,DP *pr);

void dpm_sp(DPM p1,DPM p2,DPM *rp);

void initdpm(struct order_spec *spec,int type);

void dpm_ht(DPM p,DPM *rp);

void dpm_hm(DPM p,DPM *rp);

int dpm_redble(DPM p1,DPM p2);

void lumtop_unsigned(V v,int mod,int bound,LUM f,P *g);

int dp_nt(DP);

void dp_dehomo(DP,DP *);

void dp_homo(DP,DP *);

Line 376 void dp_mod(DP,int,NODE,DP *);

Line 411 void dp_mod(DP,int,NODE,DP *);

void dp_prim_mod(DP,int,DP *);

void dp_prim(DP,DP *);

void heu_nezgcdnpz(VL,P *,int,P *);

void homogenize_order(struct order_spec *,int,struct order_spec *);

void homogenize_order(struct order_spec *,int,struct order_spec **);

int create_order_spec(Obj,struct order_spec *);

int create_order_spec(VL,Obj,struct order_spec **);

int dl_equal(int,DL,DL);

void qltozl(Q *,int,Q *);

int cmpdl_matrix(int,DL,DL);

int cmpdl_order_pair(int,DL,DL);

int cmpdl_elim(int,DL,DL);

int cmpdl_blexrev(int,DL,DL);

int cmpdl_bgradrev(int,DL,DL);

int cmpdl_brevrev(int,DL,DL);

int cmpdl_brevgradlex(int,DL,DL);

int cmpdl_bgradlex(int,DL,DL);

int cmpdl_blex(int,DL,DL);

int cmpdl_revgradlex(int,DL,DL);

int cmpdl_gradlex(int,DL,DL);

int cmpdl_revlex(int,DL,DL);

int cmpdl_lex(int,DL,DL);

int compd(VL,DP,DP);

void adddl(int,DL,DL,DL *);

void divsdc(VL,DP,P,DP *);

void muldc(VL,DP,P,DP *);

void muldm(VL,DP,MP,DP *);

void muld(VL,DP,DP,DP *);

void chsgnd(DP,DP *);

void subd(VL,DP,DP,DP *);

void addd(VL,DP,DP,DP *);

int sugard(MP);

void nodetod(NODE,DP *);

void dtop(VL,VL,DP,P *);

void ptod(VL,VL,P,DP *);

void initd(struct order_spec *);

int mainparse(SNODE *);

int exprparse(FUNC,char *,FNODE *);

Line 432 void input_init(FILE *,char *);

Line 440 void input_init(FILE *,char *);

void asir_terminate(int);

void param_init(void);

void sprompt(char *);

void cppname_init();

void process_args(int,char **);

void sig_init(void);

void asir_save_handler(void);

Line 446 void tty_reset(void);

Line 455 void tty_reset(void);

void set_timer(int);

void reset_timer(void);

void int_handler(int);

void segv_handler(int);

void bus_handler(int);

void fpe_handler(int);

Line 465 int yyparse(void);

Line 473 int yyparse(void);

void nodetod(NODE,DP *);

void poppvs(void);

int length(NODE);

int get_heapsize(void);

size_t get_heapsize(void);

int searchpvar(char *);

void mkparif(char *,FUNC *);

void makevar(char *,P *);

void mkpvs(void);

void mkpvs(char *);

MODULE mkmodule(char *);

void stoarg(char *,int *,char **);

void yyerror(char *);

void closecurrentinput(void);

void asir_terminate(int);

void searchasirpath(char *,char **);

void get_vars(Obj,VL *);

void appendbinf(NODE *,char *,void(*)(),int);

void appendbinf(NODE *,char *,void(*)(),int,unsigned int);

void appendubinf(char *,void(*)(),int);

void appendubinf(char *,void(*)(),int,unsigned int);

void parif_init(void);

void sysf_init(void);

void makesrvar(FUNC, P *);

Line 493 void printv(VL,V);

Line 502 void printv(VL,V);

void sprintv(VL,V);

int arf_comp(VL, Obj, Obj);

int complist(VL, LIST, LIST);

int getcompsize(int);

int getpvar(VS,char *,int);

int gettype(unsigned int);

int indextotype(int,int);

int loadfile(char *);

int loadfiles(NODE);

int makepvar(char *);

unsigned int makepvar(char *);

int membertoindex(int,char *);

int qcoefp(Obj);

int qcoefr(Obj);

int rangecheck(Obj,int);

int structtoindex(char *);

pointer eval(FNODE);

pointer evalf(FUNC,FNODE,FNODE);

pointer bevalf(FUNC,NODE);

pointer evalif(FNODE,FNODE);

pointer evalnode(NODE node);

pointer evalpf(PF,NODE);

pointer evalparif(FUNC,NODE);

pointer evalpv(int,FNODE,pointer);

pointer evalstat(SNODE f);

void _mkpfins(PF ,Obj *,V *);

void appendpfins(V ,V *);

void appenduf(char *,FUNC *);

Line 547 void getmemberp(FNODE,Obj **);

Line 545 void getmemberp(FNODE,Obj **);

void help(char *);

void instov(PFINS ,V *);

Obj memberofstruct(COMP,char *);

void mkpf(char *,Obj ,int ,V *,int (*)(),double (*)(),int (*)(),PF *);

#if defined(INTERVAL)

void mkpf(char *,Obj ,int ,V *,int (*)(),double (*)(),int (*)(),void (*[])(), PF *);

#else

void mkpf(char *,Obj ,int ,V *,int (*)(),double (*)(),int (*)(), PF *);

#endif

void mkpfins(PF ,V *,V *);

void mkuf(char *,char *,NODE,SNODE,int,int,char *);

void mkuf(char *,char *,NODE,SNODE,int,int,char *,MODULE);

void newstruct(int,struct oCOMP **);

void optobj(Obj *);

void println(int, char **, int);

Line 605 int dp_redble(DP p1,DP p2);

Line 607 int dp_redble(DP p1,DP p2);

void sortbynm(Q *w,int n);

int comp_nm(Q *a,Q *b);

void qltozl(Q *w,int n,Q *dvr);

void homogenize_order(struct order_spec *old,int n,struct order_spec *new);

void dp_rat(DP p,DP *rp);

void dp_mod(DP p,int mod,NODE subst,DP *rp);

void dp_dehomo(DP p,DP *rp);

void dp_homo(DP p,DP *rp);

int create_order_spec(Obj obj,struct order_spec *spec);

void dp_nf_tab_mod(DP p,LIST *tab,int mod,DP *rp);

void dp_lnf_mod(DP p1,DP p2,NODE g,int mod,DP *r1p,DP *r2p);

void dp_lnf_f(DP p1,DP p2,NODE g,DP *r1p,DP *r2p);

Line 643 void dp_mbase(NODE hlist,NODE *mbase);

void dp_idiv(DP p,Q c,DP *rp);

void dp_ptozp2(DP p0,DP p1,DP *hp,DP *rp);

void dp_ptozp(DP p,DP *rp);

int eqdl(int nv,DL dl1,DL dl2);

void _dpmod_to_vect(DP f,DL *at,int *b);

void _tf_to_vect_compress(NODE tf,DL *at,CDP *b);

void dp_to_vect(DP f,DL *at,Q *b);

Line 690 DP_pairs criterion_F( DP_pairs d1 );

Line 689 DP_pairs criterion_F( DP_pairs d1 );

NODE updbase(NODE g,int t);

NODE /* of index */ remove_reducibles(NODE /* of index */ nd, int newdp );

int dl_redble(DL dl1,DL dl2);

int dl_weight(DL dl);

int dl_weyl_weight(DL dl);

int gbcheck(NODE f);

int membercheck(NODE f,NODE x);

void dp_set_flag(Obj name,Obj value);

Line 744 void reduce_reducers_mod(int **mat,int row,int col,int

Line 743 void reduce_reducers_mod(int **mat,int row,int col,int

void pre_reduce_mod(int **mat,int row,int col,int nred,int md);

void reduce_sp_by_red_mod(int *sp,int **redmat,int *ind,int nred,int col,int md);

void red_by_compress(int m,unsigned int *p,unsigned int *r,

unsigned int *ri,unsigned int hc,int len);

void red_by_vect(int m,unsigned int *p,unsigned int *r,unsigned int hc,int len);

void reduce_sp_by_red_mod_compress (int *sp,CDP *redmat,int *ind,

int nred,int col,int md);

int generic_gauss_elim_mod(int **mat0,int row,int col,int md,int *colstat);

int lu_gfmmat(GFMMAT mat,unsigned int md,int *perm);

int find_lhs_and_lu_mod(unsigned int **a,int row,int col,

unsigned int md,int **rinfo,int **cinfo);

void solve_by_lu_mod(int **a,int n,int md,int **b,int l);

void solve_by_lu_mod(int **a,int n,int md,int **b,int l,int normalize);

int gauss_elim_mod1(int **mat,int row,int col,int md);

int gauss_elim_geninv_mod(unsigned int **mat,int row,int col,int md);

void solve_by_lu_gfmmat(GFMMAT lu,unsigned int md,unsigned int *b,unsigned int *x);

void mat_to_gfmmat(MAT m,unsigned int md,GFMMAT *rp);

int gauss_elim_geninv_mod_swap(unsigned int **mat,int row,int col,

unsigned int md,unsigned int ***invmatp,int **indexp);

void inner_product_int(Q *a,Q *b,int n,Q *r);

void inner_product_mat_int_mod(Q **a,int **b,int n,int k,int l,Q *r);

int generate_ONB_polynomial(UP2 *rp,int m,int type);

Line 774 void igcd_cofactor(Q a,Q b,Q *gcd,Q *ca,Q *cb);

Line 773 void igcd_cofactor(Q a,Q b,Q *gcd,Q *ca,Q *cb);

int comp_n(N *a,N *b);

int TypeT_NB_check(unsigned int m, unsigned int t);

int small_jacobi(int a,int m);

void mkpvs();

void pushpvs(FUNC f);

void poppvs();

int makepvar(char *str);

unsigned int makepvar(char *str);

int searchpvar(char *str);

int getpvar(VS pvs,char *str,int searchonly);

void closecurrentinput();

Line 798 void chsgnquote(QUOTE a,QUOTE *c);

Line 796 void chsgnquote(QUOTE a,QUOTE *c);

void objtoquote(Obj a,QUOTE *c);

void polytoquote(P a,QUOTE *c);

void dptoquote(DP a,QUOTE *c);

void dctoquote(DCP dc,QUOTE v,QUOTE *c);

void dctoquote(DCP dc,QUOTE v,QUOTE *c,int *sgn);

void mptoquote(MP m,int n,QUOTE *c);

void mptoquote(MP m,int n,QUOTE *c,int *sgn);

void vartoquote(V v,QUOTE *c);

void fnodetotree(FNODE f,LIST *rp);

FNODE eval_pvar_in_fnode(FNODE f);

Line 816 void prompt() ;

Line 814 void prompt() ;

void sprompt(char *ptr);

void process_args(int ac,char **av);

void sig_init() ;

static void (*old_int)(int);;

void asir_save_handler() ;

void asir_set_handler() ;

void asir_reset_handler() ;

Line 842 void show_debug_window(int on);

Line 839 void show_debug_window(int on);

void init_cmdwin();

void searchpf(char *name,FUNC *fp);

void searchc(char *name,FUNC *fp);

#if defined(INTERVAL)

void mkpf(char *name,Obj body,int argc,V *args,

int (*parif)(),double (*libmf)(), int (*simp)(),PF *pfp);

int (*parif)(),double (*libmf)(), int (*simp)(), void (*intervalfunc[])(), PF *pfp);

#else

void mkpf(char *name,Obj body,int argc,V *args,

int (*parif)(),double (*libmf)(), int (*simp)(), PF *pfp);

#endif

void mkpfins(PF pf,V *args,V *vp);

void _mkpfins(PF pf,Obj *args,V *vp);

void _mkpfins_with_darray(PF pf,Obj *args,int *darray,V *vp);

Line 879 pointer eval(FNODE f);

Line 881 pointer eval(FNODE f);

pointer evalstat(SNODE f);

pointer evalnode(NODE node);

pointer evalf(FUNC f,FNODE a,FNODE opt);

pointer evalparif(FUNC f,NODE a);

pointer evalf_deriv(FUNC f,FNODE a,FNODE deriv);

pointer evalmapf(FUNC f,FNODE a);

pointer eval_rec_mapf(FUNC f,FNODE a);

pointer beval_rec_mapf(FUNC f,NODE node);

pointer bevalf(FUNC f,NODE a);

pointer evalif(FNODE f,FNODE a);

pointer bevalf_with_opts(FUNC f,NODE a,NODE opts);

pointer evalpf(PF pf,NODE args);

pointer evalif(FNODE f,FNODE a,FNODE opt);

pointer evalpf(PF pf,NODE args,NODE deriv);

void evalnodebody(NODE sn,NODE *dnp);

void gen_searchf(char *name,FUNC *r);

void searchf(NODE fn,char *name,FUNC *r);

void appenduf(char *name,FUNC *r);

void mkparif(char *name,FUNC *r);

void mkuf(char *name,char *fname,NODE args,SNODE body,int startl,int endl,char *desc);

void mkuf(char *name,char *fname,NODE args,SNODE body,int startl,int endl,char *desc,MODULE module);

Obj getopt_from_cpvs(char *key);

void des_enc(unsigned long *, unsigned char *, unsigned long *);

unsigned long round_func(unsigned long , unsigned char *);

unsigned long s_box_func(unsigned char *);

void des_dec(unsigned long *, unsigned char *, unsigned long *);

void key_schedule(unsigned char *,unsigned char *);

void debug_init();

void add_alias(char *com,char *alias);

void show_alias(char *alias);

Line 921 int estimate_length(VL vl,pointer p);

Line 926 int estimate_length(VL vl,pointer p);

void send_progress(short per,char *msg);

void set_error(int code,char *reason,char *action);

double get_current_time();

int get_opt(char *key0,Obj *r);

#if defined(VISUAL) || defined(__MINGW32__)

void ox_plot_main();

#else

void ox_plot_main(int argc,char **argv);

#endif

void launch_main(int argc,char **argv);

void ox_main(int argc,char **argv);

void get_fid_spec(fid id,fid_spec_p *spec);

FNODE strip_paren(FNODE f);

NODE flatten_fnodenode(NODE n,char *opname);

FNODE flatten_fnode(FNODE f,char *opname);

int compquote(VL vl,QUOTE q1,QUOTE q2);

int compqa(VL vl,QUOTEARG q1,QUOTEARG q2);

int compfnode(FNODE f1,FNODE f2);

void shuffle_mulnbp(VL vl,NBP p1,NBP p2, NBP *rp);

void harmonic_mulnbp(VL vl,NBP p1,NBP p2, NBP *rp);

void mulnbmnbp(VL vl,NBM m,NBP p, NBP *rp);

void mulnbpnbm(VL vl,NBP p,NBM m, NBP *rp);

P separate_nbm(NBM a,NBP *a0,NBP *ah,NBP *ar);

P separate_tail_nbm(NBM a,NBP *a0,NBP *ar,NBP *at);

P separate_xky_nbm(NBM a,NBP *a0,NBP *ah,NBP *ar);

int fnode_is_var(FNODE f);

int fnode_is_coef(FNODE f);

int fnode_is_number(FNODE f);

int fnode_is_rational(FNODE f);

int fnode_is_integer(FNODE f);

int fnode_is_nonnegative_integer(FNODE f);

int fnode_is_one(FNODE f);

int fnode_is_minusone(FNODE f);

int fnode_is_dependent(FNODE f,V v);

int nfnode_comp(FNODE f1,FNODE f2);

int nfnode_comp_lex(FNODE f1,FNODE f2);

int nfnode_match(FNODE f,FNODE pat,NODE *rp);

int nfnode_match_naryadd(FNODE f,FNODE p,NODE *rp);

int nfnode_match_narymul(FNODE f,FNODE p,NODE *rp);

int exprparse_create_var(FUNC f,char *str,SNODE *statp);

int obj_is_dependent(Obj a,V v);

void instoobj(PFINS ins,Obj *rp);

void goto_toplevel(char *s);

void add_bucket(GeoBucket g,NODE d,int nv);

void gen_searchf_searchonly(char *name,FUNC *r,int global);

void update_LASTCO();

void order_init();

void GC_init(void);

void showpos_to_list(LIST *r);

void mp_abs(NODE arg,Num *rp);

void print_crossref(FUNC f);

void ox_usr1_handler(int sig);

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>