[BACK]Return to parse.h CVS log [TXT][DIR] 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 
Line 45 
  * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,   * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
  * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.   * 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>  #include <time.h>
 #else  #else
 #include <sys/time.h>  #include <sys/time.h>
Line 59 
Line 59 
 #define ABS(a) ((a)>0?(a):-(a))  #define ABS(a) ((a)>0?(a):-(a))
 #endif  #endif
   
   #include <math.h>
   #include <ctype.h>
   
 /* identifiers for expressions */  /* identifiers for expressions */
   
 typedef enum {  typedef enum {
         I_BOP, I_COP, I_AND, I_OR, I_NOT, I_CE,    I_BOP, I_COP, I_AND, I_OR, I_NOT, I_CE,
         I_PRESELF, I_POSTSELF,    I_PRESELF, I_POSTSELF,
         I_FUNC, I_FUNC_OPT, I_IFUNC, I_MAP, I_RECMAP, I_PFDERIV,    I_FUNC, I_FUNC_OPT, I_IFUNC, I_MAP, I_RECMAP, I_PFDERIV,
         I_ANS, I_PVAR, I_ASSPVAR,    I_ANS, I_PVAR, I_ASSPVAR,
         I_FORMULA, I_LIST, I_STR, I_NEWCOMP, I_CAR, I_CDR, I_CAST,    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;  } fid;
   
 /* identifiers for statements */  /* identifiers for statements */
   
 typedef enum {  typedef enum {
         S_BP, S_PFDEF,    S_BP, S_PFDEF,
         S_SINGLE, S_CPLX,    S_SINGLE, S_CPLX,
         S_IFELSE, S_FOR, S_DO,    S_IFELSE, S_FOR, S_DO,
         S_BREAK, S_RETURN, S_CONTINUE    S_BREAK, S_RETURN, S_CONTINUE,
     S_MODULE
 } sid;  } sid;
   
 /* identifiers for comparison operators */  /* 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;  typedef enum { V_IND, V_UC, V_PF, V_SR } vid;
   
 struct oVS {  typedef struct oVS {
         unsigned int n;    unsigned int n;
         unsigned int asize;    unsigned int asize;
         unsigned int at;    unsigned int at;
         unsigned int level;    unsigned int level;
         struct oFUNC *usrf;    struct oFUNC *usrf;
         struct oPV *va;    struct oPV *va;
         NODE opt;    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;    char *name;
         short attr,type;    short attr,type;
         pointer priv;    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 {  struct oTKWD {
         char *name;    char *name;
         int token;    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 argc;
         int type;    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)))  #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) \  #define NEWFNODE(a,b) \
 ((a)=(FNODE)MALLOC(sizeof(struct oFNODE)+sizeof(pointer)*(b-1)))  ((a)=(FNODE)MALLOC(sizeof(struct oFNODE)+sizeof(pointer)*(b-1)))
   
 struct oSNODE {  typedef struct oSNODE {
         sid id;    sid id;
         int ln;    int ln;
         pointer arg[1];    pointer arg[1];
 };  } *SNODE;
   
 typedef struct oSNODE *SNODE;  
   
 #define NEWSNODE(a,b) \  #define NEWSNODE(a,b) \
 ((a)=(SNODE)MALLOC(sizeof(struct oSNODE)+sizeof(pointer)*(b-1)),(a)->ln=asir_infile->ln)  ((a)=(SNODE)MALLOC(sizeof(struct oSNODE)+sizeof(pointer)*(b-1)),(a)->ln=asir_infile->ln)
   
 struct oPVI {  typedef struct oPVI {
         int pv;    int pv;
         NODE index;    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 {  struct ftab {
         char *name;    char *name;
         void (*f)();    void (*f)();
         int argc;    int argc;
     unsigned int quote;
 };  };
   
 #define MKPVI(a,b,c)\  #define MKPVI(a,b,c)\
Line 262  struct ftab {
Line 263  struct ftab {
   
 #define asir_assert(ptr,id,message)\  #define asir_assert(ptr,id,message)\
 switch ( id ) {\  switch ( id ) {\
         case O_N: case O_P: case O_R:\    case O_N: case O_P: case O_R:\
                 if( (ptr) && (OID(ptr) > (id)) ) {\      if( (ptr) && (OID(ptr) > (id)) ) {\
                         fprintf(stderr,message);\        fprintf(stderr,message);\
                         error(" : invalid argument");\        error(" : invalid argument");\
                 }\      }\
                 break;\      break;\
         case O_DP:\    case O_DP:\
                 if( (ptr) && (OID(ptr) != (id)) ) {\      if( (ptr) && (OID(ptr) != (id)) ) {\
                         fprintf(stderr,message);\        fprintf(stderr,message);\
                         error(" : invalid argument");\        error(" : invalid argument");\
                 }\      }\
                 break;\      break;\
         default:\    default:\
                 if( !(ptr) || (OID(ptr) != (id)) ) {\      if( !(ptr) || (OID(ptr) != (id)) ) {\
                         fprintf(stderr,message);\        fprintf(stderr,message);\
                         error(" : invalid argument");\        error(" : invalid argument");\
                 }\      }\
                 break;\      break;\
 }  }
   
 #define DEFSIZE 32  #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) \  #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) \  #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) \  #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 NEWNODE2(a) ((a)=(NODE2)MALLOC(sizeof(struct oNODE2)))
 #define MKNODE2(a,b,c,d) \  #define MKNODE2(a,b,c,d) \
Line 300  switch ( id ) {\
Line 319  switch ( id ) {\
 #define BDY1(a) ((a)->body1)  #define BDY1(a) ((a)->body1)
 #define BDY2(a) ((a)->body2)  #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 ARF addfs, subfs, mulfs, divfs, remfs, pwrfs;
 extern INFILE asir_infile;  extern INFILE asir_infile;
 extern NODE usrf,sysf,noargsysf,ubinf,parif,ONENODE;  extern NODE usrf,sysf,noargsysf,ubinf,parif,ONENODE;
 extern int nextbp,nextbplevel;  extern int nextbp,nextbplevel;
 extern int Verbose;  extern int Verbose;
   extern int do_quiet;
   extern SYMBOL Symbol_grlex, Symbol_glex, Symbol_lex;
   extern NODE current_option;
   
 #if defined(VISUAL_LIB)  #if defined(VISUAL_LIB)
 #include <w_stdio.h>  #include <w_stdio.h>
Line 322  extern int Verbose;
Line 347  extern int Verbose;
 #define fflush w_fflush  #define fflush w_fflush
 #endif  #endif
   
 #if defined(VISUAL) || (defined(__MACH__) && defined(__ppc__))  #if defined(__GNUC__) || defined(VISUAL) || defined(__MINGW32__) || (defined(__MACH__) && defined(__ppc__)) || defined(__FreeBSD__)
 NODE mknode(int,...);  NODE mknode(int,...);
 FNODE mkfnode(int,fid,...);  FNODE mkfnode(int,fid,...);
 SNODE mksnode(int,sid,...);  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_vtod(Q *,DP,DP *);
 void dp_idivv_hist(Q,DP *);  void dp_idivv_hist(Q,DP *);
 void dp_igcdv_hist(DP,Q *);  void dp_igcdv_hist(DP,Q *);
   void dp_ptozp3(DP,Q *,DP *);
 void dp_ptozp2(DP,DP,DP *,DP *);  void dp_ptozp2(DP,DP,DP *,DP *);
 void dp_ptozp(DP,DP *);  void dp_ptozp(DP,DP *);
 void dp_nf_tab_mod(DP,LIST *,int,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_dtov(DP,VECT *);
 void dp_cont(DP,Q *);  void dp_cont(DP,Q *);
 void dp_idiv(DP,Q,DP *);  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);  int dp_nt(DP);
 void dp_dehomo(DP,DP *);  void dp_dehomo(DP,DP *);
 void dp_homo(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_mod(DP,int,DP *);
 void dp_prim(DP,DP *);  void dp_prim(DP,DP *);
 void heu_nezgcdnpz(VL,P *,int,P *);  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);  int dl_equal(int,DL,DL);
 void qltozl(Q *,int,Q *);  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 mainparse(SNODE *);
 int exprparse(FUNC,char *,FNODE *);  int exprparse(FUNC,char *,FNODE *);
Line 432  void input_init(FILE *,char *);
Line 440  void input_init(FILE *,char *);
 void asir_terminate(int);  void asir_terminate(int);
 void param_init(void);  void param_init(void);
 void sprompt(char *);  void sprompt(char *);
   void cppname_init();
 void process_args(int,char **);  void process_args(int,char **);
 void sig_init(void);  void sig_init(void);
 void asir_save_handler(void);  void asir_save_handler(void);
Line 446  void tty_reset(void);
Line 455  void tty_reset(void);
 void set_timer(int);  void set_timer(int);
 void reset_timer(void);  void reset_timer(void);
 void int_handler(int);  void int_handler(int);
 void int_handler(int);  
 void segv_handler(int);  void segv_handler(int);
 void bus_handler(int);  void bus_handler(int);
 void fpe_handler(int);  void fpe_handler(int);
Line 465  int yyparse(void);
Line 473  int yyparse(void);
 void nodetod(NODE,DP *);  void nodetod(NODE,DP *);
 void poppvs(void);  void poppvs(void);
 int length(NODE);  int length(NODE);
 int get_heapsize(void);  size_t get_heapsize(void);
 int searchpvar(char *);  int searchpvar(char *);
 void mkparif(char *,FUNC *);  void mkparif(char *,FUNC *);
 void makevar(char *,P *);  void makevar(char *,P *);
 void mkpvs(void);  void mkpvs(char *);
   MODULE mkmodule(char *);
 void stoarg(char *,int *,char **);  void stoarg(char *,int *,char **);
 void yyerror(char *);  void yyerror(char *);
 void closecurrentinput(void);  void closecurrentinput(void);
 void asir_terminate(int);  void asir_terminate(int);
 void searchasirpath(char *,char **);  void searchasirpath(char *,char **);
 void get_vars(Obj,VL *);  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 parif_init(void);
 void sysf_init(void);  void sysf_init(void);
 void makesrvar(FUNC, P *);  void makesrvar(FUNC, P *);
Line 493  void printv(VL,V);
Line 502  void printv(VL,V);
 void sprintv(VL,V);  void sprintv(VL,V);
 int arf_comp(VL, Obj, Obj);  int arf_comp(VL, Obj, Obj);
 int complist(VL, LIST, LIST);  int complist(VL, LIST, LIST);
 int complist(VL, LIST, LIST);  
 int getcompsize(int);  int getcompsize(int);
 int getpvar(VS,char *,int);  int getpvar(VS,char *,int);
 int getpvar(VS,char *,int);  
 int gettype(unsigned int);  int gettype(unsigned int);
 int indextotype(int,int);  int indextotype(int,int);
 int loadfile(char *);  int loadfile(char *);
 int loadfiles(NODE);  int loadfiles(NODE);
 int makepvar(char *);  unsigned int makepvar(char *);
 int membertoindex(int,char *);  int membertoindex(int,char *);
 int qcoefp(Obj);  int qcoefp(Obj);
 int qcoefr(Obj);  int qcoefr(Obj);
 int rangecheck(Obj,int);  int rangecheck(Obj,int);
 int structtoindex(char *);  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 _mkpfins(PF ,Obj *,V *);
 void appendpfins(V ,V *);  void appendpfins(V ,V *);
 void appenduf(char *,FUNC *);  void appenduf(char *,FUNC *);
Line 547  void getmemberp(FNODE,Obj **);
Line 545  void getmemberp(FNODE,Obj **);
 void help(char *);  void help(char *);
 void instov(PFINS ,V *);  void instov(PFINS ,V *);
 Obj memberofstruct(COMP,char *);  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 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 newstruct(int,struct oCOMP **);
 void optobj(Obj *);  void optobj(Obj *);
 void println(int, char **, int);  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);  void sortbynm(Q *w,int n);
 int comp_nm(Q *a,Q *b);  int comp_nm(Q *a,Q *b);
 void qltozl(Q *w,int n,Q *dvr);  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_rat(DP p,DP *rp);
 void dp_mod(DP p,int mod,NODE subst,DP *rp);  void dp_mod(DP p,int mod,NODE subst,DP *rp);
 void dp_dehomo(DP p,DP *rp);  void dp_dehomo(DP p,DP *rp);
 void dp_homo(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_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_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_lnf_f(DP p1,DP p2,NODE g,DP *r1p,DP *r2p);
Line 643  void dp_mbase(NODE hlist,NODE *mbase);
Line 643  void dp_mbase(NODE hlist,NODE *mbase);
 void dp_idiv(DP p,Q c,DP *rp);  void dp_idiv(DP p,Q c,DP *rp);
 void dp_ptozp2(DP p0,DP p1,DP *hp,DP *rp);  void dp_ptozp2(DP p0,DP p1,DP *hp,DP *rp);
 void dp_ptozp(DP p,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 _dpmod_to_vect(DP f,DL *at,int *b);
 void _tf_to_vect_compress(NODE tf,DL *at,CDP *b);  void _tf_to_vect_compress(NODE tf,DL *at,CDP *b);
 void dp_to_vect(DP f,DL *at,Q *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 updbase(NODE g,int t);
 NODE /* of index */ remove_reducibles(NODE /* of index */ nd, int newdp );  NODE /* of index */ remove_reducibles(NODE /* of index */ nd, int newdp );
 int dl_redble(DL dl1,DL dl2);  int dl_redble(DL dl1,DL dl2);
 int dl_weight(DL dl);  int dl_weyl_weight(DL dl);
 int gbcheck(NODE f);  int gbcheck(NODE f);
 int membercheck(NODE f,NODE x);  int membercheck(NODE f,NODE x);
 void dp_set_flag(Obj name,Obj value);  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 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 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,  void red_by_compress(int m,unsigned int *p,unsigned int *r,
         unsigned int *ri,unsigned int hc,int len);    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 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,  void reduce_sp_by_red_mod_compress (int *sp,CDP *redmat,int *ind,
         int nred,int col,int md);    int nred,int col,int md);
 int generic_gauss_elim_mod(int **mat0,int row,int col,int md,int *colstat);  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 lu_gfmmat(GFMMAT mat,unsigned int md,int *perm);
 int find_lhs_and_lu_mod(unsigned int **a,int row,int col,  int find_lhs_and_lu_mod(unsigned int **a,int row,int col,
         unsigned int md,int **rinfo,int **cinfo);    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_mod1(int **mat,int row,int col,int md);
 int gauss_elim_geninv_mod(unsigned 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 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);  void mat_to_gfmmat(MAT m,unsigned int md,GFMMAT *rp);
 int gauss_elim_geninv_mod_swap(unsigned int **mat,int row,int col,  int gauss_elim_geninv_mod_swap(unsigned int **mat,int row,int col,
         unsigned int md,unsigned int ***invmatp,int **indexp);    unsigned int md,unsigned int ***invmatp,int **indexp);
 void inner_product_int(Q *a,Q *b,int n,Q *r);  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);  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_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 comp_n(N *a,N *b);
 int TypeT_NB_check(unsigned int m, unsigned int t);  int TypeT_NB_check(unsigned int m, unsigned int t);
 int small_jacobi(int a,int m);  int small_jacobi(int a,int m);
 void mkpvs();  
 void pushpvs(FUNC f);  void pushpvs(FUNC f);
 void poppvs();  void poppvs();
 int makepvar(char *str);  unsigned int makepvar(char *str);
 int searchpvar(char *str);  int searchpvar(char *str);
 int getpvar(VS pvs,char *str,int searchonly);  int getpvar(VS pvs,char *str,int searchonly);
 void closecurrentinput();  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 objtoquote(Obj a,QUOTE *c);
 void polytoquote(P a,QUOTE *c);  void polytoquote(P a,QUOTE *c);
 void dptoquote(DP 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 vartoquote(V v,QUOTE *c);
 void fnodetotree(FNODE f,LIST *rp);  void fnodetotree(FNODE f,LIST *rp);
 FNODE eval_pvar_in_fnode(FNODE f);  FNODE eval_pvar_in_fnode(FNODE f);
Line 816  void prompt() ;
Line 814  void prompt() ;
 void sprompt(char *ptr);  void sprompt(char *ptr);
 void process_args(int ac,char **av);  void process_args(int ac,char **av);
 void sig_init() ;  void sig_init() ;
 static void (*old_int)(int);;  
 void asir_save_handler() ;  void asir_save_handler() ;
 void asir_set_handler() ;  void asir_set_handler() ;
 void asir_reset_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 init_cmdwin();
 void searchpf(char *name,FUNC *fp);  void searchpf(char *name,FUNC *fp);
 void searchc(char *name,FUNC *fp);  void searchc(char *name,FUNC *fp);
   #if defined(INTERVAL)
 void mkpf(char *name,Obj body,int argc,V *args,  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,V *args,V *vp);
 void _mkpfins(PF pf,Obj *args,V *vp);  void _mkpfins(PF pf,Obj *args,V *vp);
 void _mkpfins_with_darray(PF pf,Obj *args,int *darray,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 evalstat(SNODE f);
 pointer evalnode(NODE node);  pointer evalnode(NODE node);
 pointer evalf(FUNC f,FNODE a,FNODE opt);  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 evalmapf(FUNC f,FNODE a);
 pointer eval_rec_mapf(FUNC f,FNODE a);  pointer eval_rec_mapf(FUNC f,FNODE a);
 pointer beval_rec_mapf(FUNC f,NODE node);  pointer beval_rec_mapf(FUNC f,NODE node);
 pointer bevalf(FUNC f,NODE a);  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 evalnodebody(NODE sn,NODE *dnp);
 void gen_searchf(char *name,FUNC *r);  void gen_searchf(char *name,FUNC *r);
 void searchf(NODE fn,char *name,FUNC *r);  void searchf(NODE fn,char *name,FUNC *r);
 void appenduf(char *name,FUNC *r);  void appenduf(char *name,FUNC *r);
 void mkparif(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);  Obj getopt_from_cpvs(char *key);
 void    des_enc(unsigned long *, unsigned char *, unsigned long *);  void  des_enc(unsigned long *, unsigned char *, unsigned long *);
 unsigned long   round_func(unsigned long , unsigned char *);  unsigned long  round_func(unsigned long , unsigned char *);
 unsigned long   s_box_func(unsigned char *);  unsigned long  s_box_func(unsigned char *);
 void    des_dec(unsigned long *, unsigned char *, unsigned long *);  void  des_dec(unsigned long *, unsigned char *, unsigned long *);
 void    key_schedule(unsigned char *,unsigned char *);  void  key_schedule(unsigned char *,unsigned char *);
 void debug_init();  void debug_init();
 void add_alias(char *com,char *alias);  void add_alias(char *com,char *alias);
 void show_alias(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 send_progress(short per,char *msg);
 void set_error(int code,char *reason,char *action);  void set_error(int code,char *reason,char *action);
 double get_current_time();  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);

Legend:
Removed from v.1.15  
changed lines
  Added in v.1.59

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