===================================================================
RCS file: /home/cvs/OpenXM_contrib2/asir2000/parse/parse.h,v
retrieving revision 1.14
retrieving revision 1.15
diff -u -p -r1.14 -r1.15
--- OpenXM_contrib2/asir2000/parse/parse.h	2001/09/05 09:01:28	1.14
+++ OpenXM_contrib2/asir2000/parse/parse.h	2001/10/09 01:36:24	1.15
@@ -45,7 +45,7 @@
  * 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.13 2001/09/03 08:52:39 noro Exp $ 
+ * $OpenXM: OpenXM_contrib2/asir2000/parse/parse.h,v 1.14 2001/09/05 09:01:28 noro Exp $ 
 */
 # if defined(VISUAL)
 #include <time.h>
@@ -116,17 +116,17 @@ struct oPV {
 
 typedef struct oPV *PV;
 
-struct oIN {
+struct oINFILE {
 	char *name;
 	FILE *fp;
 	int ln;
-	struct oIN *next;
+	struct oINFILE *next;
 	char *tname;
 	int encoded;
 	short vol;
 };
 
-typedef struct oIN *IN;
+typedef struct oINFILE *INFILE;
 
 struct oTKWD {
 	char *name;
@@ -302,7 +302,7 @@ switch ( id ) {\
 
 extern VS GPVS,CPVS,EPVS,APVS;
 extern ARF addfs, subfs, mulfs, divfs, remfs, pwrfs;
-extern IN asir_infile;
+extern INFILE asir_infile;
 extern NODE usrf,sysf,noargsysf,ubinf,parif,ONENODE;
 extern int nextbp,nextbplevel;
 extern int Verbose;
@@ -509,6 +509,7 @@ 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);
@@ -583,3 +584,340 @@ void divcomp(VL,COMP,COMP,COMP *);
 void chsgncomp(COMP,COMP *);
 void pwrcomp(VL,COMP,Obj,COMP *);
 int compcomp(VL,COMP,COMP);
+
+void mergedeglist(NODE d0,NODE d1,NODE *dr);
+void getdeglist(P p,V v,NODE *d);
+void restore_mvar(VL vl,P p,V v,P *r);
+void change_mvar(VL vl,P p,V v,P *r);
+void getcoef(VL vl,P p,V v,Q d,P *r);
+void ranp(int n,UP *nr);
+
+void _print_mp(int nv,MP m);
+int dp_homogeneous(DP p);
+int dp_nt(DP p);
+int dl_equal(int nv,DL dl1,DL dl2);
+DL lcm_of_DL(int nv,DL dl1,DL dl2,DL dl);
+void dp_rest(DP p,DP *rp);
+void dp_hm(DP p,DP *rp);
+void dltod(DL d,int n,DP *rp);
+void dp_subd(DP p1,DP p2,DP *rp);
+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);
+void _dp_nf_mod_destructive(NODE b,DP g,DP *ps,int mod,int full,DP *rp);
+void dp_true_nf_mod(NODE b,DP g,DP *ps,int mod,int full,DP *rp,P *dnp);
+void dp_nf_mod(NODE b,DP g,DP *ps,int mod,int full,DP *rp);
+void dp_nf_f(NODE b,DP g,DP *ps,int full,DP *rp);
+void dp_nf_z(NODE b,DP g,DP *ps,int full,int multiple,DP *rp);
+void dp_true_nf(NODE b,DP g,DP *ps,int full,DP *rp,P *dnp);
+void _dp_red_mod_destructive(DP p1,DP p2,int mod,DP *rp);
+void dp_red_mod(DP p0,DP p1,DP p2,int mod,DP *head,DP *rest,P *dnp);
+void dp_red_f(DP p1,DP p2,DP *rest);
+void dp_red(DP p0,DP p1,DP p2,DP *head,DP *rest,P *dnp,DP *multp);
+void _dp_sp_mod(DP p1,DP p2,int mod,DP *rp);
+void _dp_sp_mod_dup(DP p1,DP p2,int mod,DP *rp);
+void dp_sp_mod(DP p1,DP p2,int mod,DP *rp);
+void _dp_sp_dup(DP p1,DP p2,DP *rp);
+void dp_sp(DP p1,DP p2,DP *rp);
+void dp_dtov(DP dp,VECT *rp);
+void dp_cont(DP p,Q *rp);
+void dp_prim_mod(DP p,int mod,DP *rp);
+void heu_nezgcdnpz(VL vl,P *pl,int m,P *pr);
+void dp_prim(DP p,DP *rp);
+void dp_ptozp2_d(DP p0,DP p1,DP *hp,DP *rp);
+void dp_ptozp_d(DP p,DP *rp);
+void dp_vtod(Q *c,DP p,DP *rp);
+void insert_to_node(DL d,NODE *n,int nvar);
+int _dl_redble(DL d1,DL d2,int nvar);
+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);
+NODE dp_dllist(DP f);
+NODE mul_dllist(DL d,DP f);
+void pdl(NODE f);
+void dp_gr_main(LIST f,LIST v,Num homo,int modular,int field,struct order_spec *ord,LIST *rp);
+void dp_gr_mod_main(LIST f,LIST v,Num homo,int m,struct order_spec *ord,LIST *rp);
+void dp_f4_main(LIST f,LIST v,struct order_spec *ord,LIST *rp);
+void dp_f4_mod_main(LIST f,LIST v,int m,struct order_spec *ord,LIST *rp);
+NODE gb_f4(NODE f);
+NODE gb_f4_mod(NODE f,int m);
+NODE gb_f4_mod_old(NODE f,int m);
+int DPPlength(DP_pairs n);
+void printdl(DL dl);
+void pltovl(LIST l,VL *vl);
+void makesubst(VL v,NODE *s);
+void printsubst(NODE s);
+void vlminus(VL v,VL w,VL *d);
+int validhc(P a,int m,NODE s);
+void setup_arrays(NODE f,int m,NODE *r);
+void prim_part(DP f,int m,DP *r);
+NODE /* of DP */ NODE_sortb_insert( DP newdp, NODE /* of DP */ nd, int dec );
+NODE NODE_sortb( NODE node, int dec );
+NODE /* of index */ NODE_sortbi_insert( int newdpi, NODE /* of index */ nd, int dec );
+NODE NODE_sortbi( NODE node, int dec );
+void reduceall(NODE in,NODE *h);
+void reduceall_mod(NODE in,int m,NODE *h);
+int newps(DP a,int m,NODE subst);
+int newps_nosave(DP a,int m,NODE subst);
+int newps_mod(DP a,int m);
+void reducebase_dehomo(NODE f,NODE *g);
+NODE append_one(NODE f,int n);
+DP_pairs minp( DP_pairs d, DP_pairs *prest );
+void minsugar(DP_pairs d,DP_pairs *dm,DP_pairs *dr);
+NODE gb(NODE f,int m,NODE subst);
+NODE gb_mod(NODE f,int m);
+DP_pairs updpairs( DP_pairs d, NODE /* of index */ g, int t);
+DP_pairs newpairs( NODE /* of index */ g, int t );
+DP_pairs criterion_B( DP_pairs d, int s );
+DP_pairs criterion_M( DP_pairs d1 );
+int criterion_2( int dp1, int dp2 );
+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 gbcheck(NODE f);
+int membercheck(NODE f,NODE x);
+void dp_set_flag(Obj name,Obj value);
+void dp_make_flaglist(LIST *list);
+void dp_save(int index,Obj p,char *prefix);
+void dp_load(int index,DP *p);
+int dp_load_t(int index,DP *p);
+void init_stat();
+void print_stat();
+void dp_mulc_d(DP p,P c,DP *r);
+void _dp_nf(NODE b,DP g,DP *ps,int full,DP *rp);
+void _dp_nf_z(NODE b,DP g,DP *ps,int full,int multiple,DP *r);
+void dp_imul_d(DP p,Q q,DP *rp);
+void imulv(VECT w,Q c,VECT *rp);
+void dptoca(DP p,unsigned int **rp);
+int yylex();
+void purge_stdin();
+int afternl();
+int aftercomment();
+int myatoi(char *s);
+void yyerror(char *s);
+int Egetc(FILE *fp);
+void Eungetc(int c,FILE *fp);
+int readline_getc();
+void readline_ungetc();
+char *readline_console(char *prompt);
+void ox_usr1_handler(int sig);
+void env_init();
+void loadasirfile(char *name0);
+void execasirfile(char *name);
+void load_and_execfile(char *name);
+int loadfile(char *s);
+int loadfiles(NODE node);
+unsigned char encrypt_char(unsigned char c);
+unsigned char decrypt_char(unsigned char c);
+void encrypt_file(char *in,char *out);
+void decrypt_file(char *in,char *out);
+void get_vars(Obj t,VL *vlp);
+void get_vars_recursive(Obj obj,VL *vlp);
+int comp_obj(Obj *a,Obj *b);
+int generic_comp_obj(Obj *a,Obj *b);
+void sepvect(VECT v,int d,VECT *rp);
+int gauss_elim_mod(int **mat,int row,int col,int md);
+int generic_gauss_elim(MAT mat,MAT *nm,Q *dn,int **rindp,int **cindp);
+int generic_gauss_elim_hensel(MAT mat,MAT *nmmat,Q *dn,int **rindp,int **cindp);
+int gensolve_check(MAT mat,MAT nm,Q dn,int *rind,int *cind);
+int inttorat(N c,N m,N b,int *sgnp,N *nmp,N *dnp);
+int intmtoratm(MAT mat,N md,MAT nm,Q *dn);
+int intmtoratm_q(MAT mat,N md,MAT nm,Q *dn);
+void reduce_reducers_mod(int **mat,int row,int col,int md);
+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);
+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);
+int _generate_irreducible_polynomial(UP2 f,int d);
+int _generate_good_irreducible_polynomial(UP2 f,int d);
+void printqmat(Q **mat,int row,int col);
+void printimat(int **mat,int row,int col);
+void ixor(N n1,N n2,N *r);
+void ior(N n1,N n2,N *r);
+void iand(N n1,N n2,N *r);
+void isqrt(N a,N *r);
+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);
+int searchpvar(char *str);
+int getpvar(VS pvs,char *str,int searchonly);
+void closecurrentinput();
+void resetpvs();
+void savepvs();
+void restorepvs();
+void storeans(pointer p);
+void get_rootdir(char *name,int len);
+void set_rootdir(char *name);
+int process_id();
+void call_exe(char *name,char **av);
+void addquote(VL vl,QUOTE a,QUOTE b,QUOTE *c);
+void subquote(VL vl,QUOTE a,QUOTE b,QUOTE *c);
+void mulquote(VL vl,QUOTE a,QUOTE b,QUOTE *c);
+void divquote(VL vl,QUOTE a,QUOTE b,QUOTE *c);
+void pwrquote(VL vl,QUOTE a,QUOTE b,QUOTE *c);
+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 mptoquote(MP m,int n,QUOTE *c);
+void vartoquote(V v,QUOTE *c);
+void fnodetotree(FNODE f,LIST *rp);
+FNODE eval_pvar_in_fnode(FNODE f);
+FNODE subst_in_fnode(FNODE f,V v,FNODE g);
+char *get_attribute(char *key,LIST attr);
+void treetofnode(Obj obj,FNODE *f);
+void glob_init() ;
+void input_init(FILE *fp,char *name);
+void notdef(VL vl,Obj a,Obj b,Obj *c);
+void ExitAsir() ;
+void asir_terminate(int status);
+void param_init() ;
+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() ;
+void resetenv(char *s);
+void fatal(int n);
+void int_handler(int sig);
+void restore_handler() ;
+void segv_handler(int sig);
+void ill_handler(int sig);
+void alrm_handler(int sig);
+void bus_handler(int sig);
+void fpe_handler(int sig);
+void pipe_handler(int sig);
+void resize_buffer();
+void tty_init() ;
+void tty_reset() ;
+void set_lasterror(char *s);
+void error(char *s);
+void set_timer(int interval);
+void reset_timer();
+void copyright() ;
+void show_debug_window(int on);
+void init_cmdwin();
+void searchpf(char *name,FUNC *fp);
+void searchc(char *name,FUNC *fp);
+void mkpf(char *name,Obj body,int argc,V *args,
+	int (*parif)(),double (*libmf)(), int (*simp)(),PF *pfp);
+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);
+void appendpfins(V v,V *vp);
+void duppfins(V v,V *vp);
+void derivvar(VL vl,V pf,V v,Obj *a);
+void derivr(VL vl,Obj a,V v,Obj *b);
+void substr(VL vl,int partial,Obj a,V v,Obj b,Obj *c);
+void substpr(VL vl,int partial,Obj p,V v0,Obj p0,Obj *pr);
+void evalr(VL vl,Obj a,int prec,Obj *c);
+void evalp(VL vl,P p,int prec,P *pr);
+void evalv(VL vl,V v,int prec,Obj *rp);
+void evalins(PFINS ins,int prec,Obj *rp);
+void devalr(VL vl,Obj a,Obj *c);
+void devalp(VL vl,P p,P *pr);
+void devalv(VL vl,V v,Obj *rp);
+void devalins(PFINS ins,Obj *rp);
+void simplify_ins(PFINS ins,Obj *rp);
+void instov(PFINS ins,V *vp);
+void substfr(VL vl,Obj a,PF u,PF f,Obj *c);
+void substfp(VL vl,Obj p,PF u,PF f,Obj *pr);
+void substfv(VL vl,V v,PF u,PF f,Obj *c);
+int structdef(char *name,NODE member);
+void newstruct(int type,COMP *rp);
+int structtoindex(char *name);
+int membertoindex(int type,char *name);
+int getcompsize(int type);
+Obj memberofstruct(COMP a,char *name);
+void assign_to_member(COMP a,char *name,Obj obj);
+void node_concat_dup(NODE n1,NODE n2,NODE *nr);
+pointer evall(lid id,Obj a1,Obj a2);
+pointer eval(FNODE f);
+pointer evalstat(SNODE f);
+pointer evalnode(NODE node);
+pointer evalf(FUNC f,FNODE a,FNODE opt);
+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 evalpf(PF pf,NODE args);
+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);
+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);
+void debug(SNODE f);
+void setf(int ac,char **av);
+void setbp(char *p);
+void settp(char *p);
+void clearbp(FUNC f);
+int searchbp();
+void delbp(int ac,char **av);
+void showbps();
+void showbp(int n);
+void searchsn(SNODE *fp,int n,SNODE **fpp);
+void bp(SNODE f);
+void println(int ac,char **av,int l);
+void printvars(char *s,VS vs);
+void showpos();
+void showpos_to_string(char *buf);
+void change_stack(int level,NODE *pvss);
+void show_stack(VS vs);
+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();