[BACK]Return to strobj.c CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / builtin

Diff for /OpenXM_contrib2/asir2000/builtin/strobj.c between version 1.108 and 1.124

version 1.108, 2005/12/11 07:21:43 version 1.124, 2015/08/14 13:51:54
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/builtin/strobj.c,v 1.107 2005/12/11 05:27:30 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/builtin/strobj.c,v 1.123 2015/08/06 10:01:52 fujimoto Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
Line 60  extern jmp_buf environnement;
Line 60  extern jmp_buf environnement;
   
 #if defined(__GNUC__)  #if defined(__GNUC__)
 #define INLINE inline  #define INLINE inline
 #elif defined(VISUAL)  #elif defined(VISUAL) || defined(__MINGW32__)
 #define INLINE __inline  #define INLINE __inline
 #else  #else
 #define INLINE  #define INLINE
Line 76  struct TeXSymbol {
Line 76  struct TeXSymbol {
 #define IS_BINARYPWR(f) (((f)->id==I_BOP) &&(OPNAME(f)=='^'))  #define IS_BINARYPWR(f) (((f)->id==I_BOP) &&(OPNAME(f)=='^'))
 #define IS_NARYADD(f) (((f)->id==I_NARYOP) &&(OPNAME(f)=='+'))  #define IS_NARYADD(f) (((f)->id==I_NARYOP) &&(OPNAME(f)=='+'))
 #define IS_NARYMUL(f) (((f)->id==I_NARYOP) &&(OPNAME(f)=='*'))  #define IS_NARYMUL(f) (((f)->id==I_NARYOP) &&(OPNAME(f)=='*'))
   #define IS_MUL(f) (((f)->id==I_NARYOP||(f)->id==I_BOP) &&(OPNAME(f)=='*'))
   
 extern char *parse_strp;  extern char *parse_strp;
   
Line 94  void Pflatten_quote();
Line 95  void Pflatten_quote();
   
 void Pqt_is_integer(),Pqt_is_rational(),Pqt_is_number(),Pqt_is_coef();  void Pqt_is_integer(),Pqt_is_rational(),Pqt_is_number(),Pqt_is_coef();
 void Pqt_is_dependent(),Pqt_is_function(),Pqt_is_var();  void Pqt_is_dependent(),Pqt_is_function(),Pqt_is_var();
 void Pqt_set_ord(),Pqt_set_coef();  void Pqt_set_ord(),Pqt_set_coef(),Pqt_set_weight();
 void Pqt_normalize();  void Pqt_normalize();
 void Pnqt_comp();  void Pnqt_comp(),Pnqt_weight();
 void Pnqt_match();  void Pnqt_match();
 void Pnqt_match_rewrite();  void Pnqt_match_rewrite();
   
 void Pqt_to_nbp();  void Pqt_to_nbp();
 void Pshuffle_mul(), Pharmonic_mul();  void Pshuffle_mul(), Pharmonic_mul();
 void Pnbp_hm(), Pnbp_ht(), Pnbp_hc(), Pnbp_rest();  void Pnbp_hm(), Pnbp_ht(), Pnbp_hc(), Pnbp_rest();
 void Pnbm_deg();  void Pnbp_tm(), Pnbp_tt(), Pnbp_tc(), Pnbp_trest();
   void Pnbm_deg(), Pnbm_index();
 void Pnbm_hp_rest();  void Pnbm_hp_rest();
 void Pnbm_hxky(), Pnbm_xky_rest();  void Pnbm_hxky(), Pnbm_xky_rest();
 void Pnbm_hv(), Pnbm_rest();  void Pnbm_hv(), Pnbm_tv(), Pnbm_rest(),Pnbm_trest();
   
 void Pquote_to_funargs(),Pfunargs_to_quote(),Pget_function_name();  void Pquote_to_funargs(),Pfunargs_to_quote(),Pget_function_name();
 void Pqt_match(),Pget_quote_id();  void Pqt_match(),Pget_quote_id();
Line 165  struct ftab str_tab[] = {
Line 167  struct ftab str_tab[] = {
   
         {"qt_set_coef",Pqt_set_coef,-1},          {"qt_set_coef",Pqt_set_coef,-1},
         {"qt_set_ord",Pqt_set_ord,-1},          {"qt_set_ord",Pqt_set_ord,-1},
           {"qt_set_weight",Pqt_set_weight,-1},
         {"qt_normalize",Pqt_normalize,-2},          {"qt_normalize",Pqt_normalize,-2},
         {"qt_match",Pqt_match,2},          {"qt_match",Pqt_match,2},
         {"nqt_match_rewrite",Pnqt_match_rewrite,3},          {"nqt_match_rewrite",Pnqt_match_rewrite,3},
   
           {"nqt_weight",Pnqt_weight,1},
         {"nqt_comp",Pnqt_comp,2},          {"nqt_comp",Pnqt_comp,2},
         {"nqt_match",Pnqt_match,-3},          {"nqt_match",Pnqt_match,-3},
         {"qt_to_nbp",Pqt_to_nbp,1},          {"qt_to_nbp",Pqt_to_nbp,1},
Line 179  struct ftab str_tab[] = {
Line 183  struct ftab str_tab[] = {
         {"nbp_ht", Pnbp_ht,1},          {"nbp_ht", Pnbp_ht,1},
         {"nbp_hc", Pnbp_hc,1},          {"nbp_hc", Pnbp_hc,1},
         {"nbp_rest", Pnbp_rest,1},          {"nbp_rest", Pnbp_rest,1},
           {"nbp_tm", Pnbp_tm,1},
           {"nbp_tt", Pnbp_tt,1},
           {"nbp_tc", Pnbp_tc,1},
           {"nbp_trest", Pnbp_trest,1},
         {"nbm_deg", Pnbm_deg,1},          {"nbm_deg", Pnbm_deg,1},
           {"nbm_index", Pnbm_index,1},
         {"nbm_hxky", Pnbm_hxky,1},          {"nbm_hxky", Pnbm_hxky,1},
         {"nbm_xky_rest", Pnbm_xky_rest,1},          {"nbm_xky_rest", Pnbm_xky_rest,1},
         {"nbm_hp_rest", Pnbm_hp_rest,1},          {"nbm_hp_rest", Pnbm_hp_rest,1},
         {"nbm_hv", Pnbm_hv,1},          {"nbm_hv", Pnbm_hv,1},
           {"nbm_tv", Pnbm_tv,1},
         {"nbm_rest", Pnbm_rest,1},          {"nbm_rest", Pnbm_rest,1},
           {"nbm_trest", Pnbm_trest,1},
   
         {"qt_to_nary",Pqt_to_nary,1},          {"qt_to_nary",Pqt_to_nary,1},
         {"qt_to_bin",Pqt_to_bin,2},          {"qt_to_bin",Pqt_to_bin,2},
Line 459  int register_conv_func(Obj arg)
Line 470  int register_conv_func(Obj arg)
         if ( !arg ) {          if ( !arg ) {
                 convfunc = 0;                  convfunc = 0;
                 return 1;                  return 1;
         } else if ( OID(arg) == O_P && (int)(VR((P)arg))->attr == V_SR ) {          } else if ( OID(arg) == O_P && (long)(VR((P)arg))->attr == V_SR ) {
                 convfunc = (FUNC)(VR((P)arg)->priv);                  convfunc = (FUNC)(VR((P)arg)->priv);
                 /* f must be a function which takes single argument */                  /* f must be a function which takes single argument */
                 return 1;                  return 1;
Line 838  void do_assign(NODE arg)
Line 849  void do_assign(NODE arg)
   
         for ( t = arg; t; t = NEXT(t) ) {          for ( t = arg; t; t = NEXT(t) ) {
                 pair = BDY((LIST)BDY(t));                  pair = BDY((LIST)BDY(t));
                 pv = (int)FA0((FNODE)BDY((QUOTE)BDY(pair)));                  pv = (long)FA0((FNODE)BDY((QUOTE)BDY(pair)));
                 value = (QUOTE)(BDY(NEXT(pair)));                  value = (QUOTE)(BDY(NEXT(pair)));
                 ASSPV(pv,value);                  ASSPV(pv,value);
         }          }
Line 1277  NODE arg;
Line 1288  NODE arg;
 Obj *rp;  Obj *rp;
 {  {
         FNODE fnode;          FNODE fnode;
           SNODE snode;
         char *cmd;          char *cmd;
 #if defined(PARI)  #if defined(PARI)
         void recover(int);          void recover(int);
Line 1290  Obj *rp;
Line 1302  Obj *rp;
 #  endif  #  endif
 #endif  #endif
         cmd = BDY((STRING)ARG0(arg));          cmd = BDY((STRING)ARG0(arg));
   #if 0
         exprparse_create_var(0,cmd,&fnode);          exprparse_create_var(0,cmd,&fnode);
         *rp = eval(fnode);          *rp = eval(fnode);
   #else
           exprparse_create_var(0,cmd,&snode);
           *rp = evalstat(snode);
   #endif
 }  }
   
 void Prtostr(arg,rp)  void Prtostr(arg,rp)
Line 1313  NODE arg;
Line 1330  NODE arg;
 P *rp;  P *rp;
 {  {
         char *p;          char *p;
           FUNC f;
   
         p = BDY((STRING)ARG0(arg));          p = BDY((STRING)ARG0(arg));
 #if 0  #if 0
Line 1326  P *rp;
Line 1344  P *rp;
                         makevar(p,rp);                          makevar(p,rp);
         }          }
 #else  #else
         makevar(p,rp);          gen_searchf_searchonly(p,&f);
           if ( f )
                   makesrvar(f,rp);
           else
                   makevar(p,rp);
 #endif  #endif
 }  }
   
Line 1414  char *symbol_name(char *name)
Line 1436  char *symbol_name(char *name)
   
 void Pget_function_name(NODE arg,STRING *rp)  void Pget_function_name(NODE arg,STRING *rp)
 {  {
                 QUOTEARG qa;          QUOTEARG qa;
                 ARF f;  
                 char *opname;  
   
                 qa = (QUOTEARG)BDY(arg);          qa = (QUOTEARG)BDY(arg);
                 if ( !qa || OID(qa) != O_QUOTEARG || qa->type != A_arf )          if ( !qa || OID(qa) != O_QUOTEARG ) {
                   *rp = 0; return;
           }
           switch ( qa->type ) {
                   case A_arf:
                           MKSTR(*rp,((ARF)BDY(qa))->name);
                           break;
                   case A_func:
                           MKSTR(*rp,((FUNC)BDY(qa))->name);
                           break;
                   default:
                         *rp = 0;                          *rp = 0;
                 else {                          break;
                         f = (ARF)BDY(qa);          }
                         opname = f->name;  
                         MKSTR(*rp,opname);  
                 }  
 }  }
   
 FNODE strip_paren(FNODE);  FNODE strip_paren(FNODE);
   void objtotex_tb(Obj obj,TB tb);
   
 void fnodetotex_tb(FNODE f,TB tb)  void fnodetotex_tb(FNODE f,TB tb)
 {  {
Line 1437  void fnodetotex_tb(FNODE f,TB tb)
Line 1465  void fnodetotex_tb(FNODE f,TB tb)
         char *opname,*vname_conv,*prefix_conv;          char *opname,*vname_conv,*prefix_conv;
         Obj obj;          Obj obj;
         int i,len,allzero,elen,elen2,si;          int i,len,allzero,elen,elen2,si;
         C cplx;  
         char *r;          char *r;
         FNODE fi,f2,f1;          FNODE fi,f2,f1;
   
Line 1505  void fnodetotex_tb(FNODE f,TB tb)
Line 1532  void fnodetotex_tb(FNODE f,TB tb)
                                         write_tb("}",tb);                                          write_tb("}",tb);
                                         break;                                          break;
                                 case '^':                                  case '^':
                                         fnodetotex_tb((FNODE)FA1(f),tb);                                          f1 = (FNODE)FA1(f);
                                           if ( fnode_is_var(f1) )
                                                   fnodetotex_tb(f1,tb);
                                           else {
                                                   write_tb("(",tb);
                                                   fnodetotex_tb(f1,tb);
                                                   write_tb(")",tb);
                                           }
                                         write_tb("^{",tb);                                          write_tb("^{",tb);
                                         fnodetotex_tb(strip_paren((FNODE)FA2(f)),tb);                                          fnodetotex_tb(strip_paren((FNODE)FA2(f)),tb);
                                         write_tb("} ",tb);                                          write_tb("} ",tb);
Line 1522  void fnodetotex_tb(FNODE f,TB tb)
Line 1556  void fnodetotex_tb(FNODE f,TB tb)
                         break;                          break;
                 case I_NARYOP:                  case I_NARYOP:
                         args = (NODE)FA1(f);                          args = (NODE)FA1(f);
                         write_tb("(",tb);  
                         switch ( OPNAME(f) ) {                          switch ( OPNAME(f) ) {
                                 case '+':                                  case '+':
                                         fnodetotex_tb((FNODE)BDY(args),tb);                                          fnodetotex_tb((FNODE)BDY(args),tb);
                                         for ( args = NEXT(args); args; args = NEXT(args) ) {                                          for ( args = NEXT(args); args; args = NEXT(args) ) {
                                                 write_tb("+",tb);                                                  write_tb("+",tb);
                                                 fnodetotex_tb((FNODE)BDY(args),tb);                                                  f1 = (FNODE)BDY(args);
                                                   /* if ( fnode_is_var(f1) || IS_MUL(f1) )
                                                           fnodetotex_tb(f1,tb);
                                                   else */ {
                                                           write_tb("(",tb);
                                                           fnodetotex_tb(f1,tb);
                                                           write_tb(")",tb);
                                                   }
                                         }                                          }
                                         break;                                          break;
                                 case '*':                                  case '*':
                                         f1 = (FNODE)BDY(args);                                          f1 = (FNODE)BDY(args);
                                         if ( f1->id == I_FORMULA && MUNIQ(FA0(f1)) )                                          if ( f1->id == I_FORMULA && MUNIQ(FA0(f1)) ) {
                                                 write_tb("-",tb);                                                  write_tb("- ",tb); args = NEXT(args);
                                         else                                          }
                                                 fnodetotex_tb(f1,tb);                                          for ( ; args; args = NEXT(args) ) {
                                         write_tb(" ",tb);  
                                         for ( args = NEXT(args); args; args = NEXT(args) ) {  
                                                 /* XXX special care for DP */  
                                                 f2 = (FNODE)BDY(args);                                                  f2 = (FNODE)BDY(args);
                                                 if ( f2->id == I_EV ) {                                                  if ( fnode_is_var(f2) || IS_BINARYPWR(f2) )
                                                         n = (NODE)FA0(f2);  
                                                         for ( i = 0; n; n = NEXT(n), i++ ) {  
                                                                 fi = (FNODE)BDY(n);  
                                                                 if ( fi->id != I_FORMULA || FA0(fi) )  
                                                                         break;  
                                                         }  
                                                         if ( n )  
                                                                 fnodetotex_tb(f2,tb);  
                                                 } else  
                                                         fnodetotex_tb(f2,tb);                                                          fnodetotex_tb(f2,tb);
                                                   else {
                                                           write_tb("(",tb);
                                                           fnodetotex_tb(f2,tb);
                                                           write_tb(")",tb);
                                                   }
                                         }                                          }
                                         break;                                          break;
                                 default:                                  default:
                                         error("invalid nary op");                                          error("invalid nary op");
                                         break;                                          break;
                         }                          }
                         write_tb(")",tb);  
                         break;                          break;
   
                 case I_COP:                  case I_COP:
Line 1783  void fnodetotex_tb(FNODE f,TB tb)
Line 1815  void fnodetotex_tb(FNODE f,TB tb)
   
                 /* internal object */                  /* internal object */
                 case I_FORMULA:                  case I_FORMULA:
                         obj = (Obj)FA0(f);                          objtotex_tb((Obj)FA0(f),tb);
                         if ( !obj )  
                                 write_tb("0",tb);  
                         else if ( OID(obj) == O_N && NID(obj) == N_C ) {  
                                 cplx = (C)obj;  
                                 write_tb("(",tb);  
                                 if ( cplx->r ) {  
                                         r = objtostr((Obj)cplx->r); write_tb(r,tb);  
                                 }  
                                 if ( cplx->i ) {  
                                         if ( cplx->r && compnum(0,cplx->i,0) > 0 ) {  
                                                 write_tb("+",tb);  
                                                 if ( !UNIQ(cplx->i) ) {  
                                                         r = objtostr((Obj)cplx->i); write_tb(r,tb);  
                                                 }  
                                         } else if ( MUNIQ(cplx->i) )  
                                                 write_tb("-",tb);  
                                         else if ( !UNIQ(cplx->i) ) {  
                                                 r = objtostr((Obj)cplx->i); write_tb(r,tb);  
                                         }  
                                         write_tb("\\sqrt{-1}",tb);  
                                 }  
                                 write_tb(")",tb);  
                         } else if ( OID(obj) == O_P )  
                                 write_tb(conv_rule(VR((P)obj)->name),tb);  
                         else  
                                 write_tb(objtostr(obj),tb);  
                         break;                          break;
   
                 /* program variable */                  /* program variable */
Line 1825  void fnodetotex_tb(FNODE f,TB tb)
Line 1831  void fnodetotex_tb(FNODE f,TB tb)
         }          }
 }  }
   
   void objtotex_tb(Obj obj,TB tb)
   {
           C cplx;
           char *r;
           P t;
           DCP dc;
           char *v;
   
           if ( !obj ) {
                   write_tb("0",tb);
                   return;
           }
           switch ( OID(obj) ) {
                   case O_N:
                           switch ( NID(obj) ) {
                                   case N_C:
                                           cplx = (C)obj;
                                           write_tb("(",tb);
                                           if ( cplx->r ) {
                                                   r = objtostr((Obj)cplx->r); write_tb(r,tb);
                                           }
                                           if ( cplx->i ) {
                                                   if ( cplx->r && compnum(0,cplx->i,0) > 0 ) {
                                                           write_tb("+",tb);
                                                           if ( !UNIQ(cplx->i) ) {
                                                                   r = objtostr((Obj)cplx->i); write_tb(r,tb);
                                                           }
                                                   } else if ( MUNIQ(cplx->i) )
                                                           write_tb("-",tb);
                                                   else if ( !UNIQ(cplx->i) ) {
                                                           r = objtostr((Obj)cplx->i); write_tb(r,tb);
                                                   }
                                                   write_tb("\\sqrt{-1}",tb);
                                           }
                                           write_tb(")",tb);
                                           break;
                                   default:
                                           write_tb(objtostr(obj),tb);
                                           break;
                           }
                           break;
                   case O_P:
                           v = conv_rule(VR((P)obj)->name);
                           for ( dc = DC((P)obj); dc; dc = NEXT(dc) ) {
                                   if ( !DEG(dc) )
                                           objtotex_tb((Obj)COEF(dc),tb);
                                   else {
                                           if ( NUM(COEF(dc)) && UNIQ((Q)COEF(dc)) )
                                                   ;
                                           else if ( NUM(COEF(dc)) && MUNIQ((Q)COEF(dc)) )
                                                   write_tb("-",tb);
                                           else if ( NUM(COEF(dc)) || !NEXT(DC(COEF(dc))))
                                                   objtotex_tb((Obj)COEF(dc),tb);
                                           else {
                                                   write_tb("(",tb); objtotex_tb((Obj)COEF(dc),tb);
                                                   write_tb(")",tb);
                                           }
                                           write_tb(v,tb);
                                           if ( cmpq(DEG(dc),ONE) ) {
                                                   write_tb("^",tb);
                                                   if ( INT(DEG(dc)) && SGN(DEG(dc))>0 ) {
                                                           write_tb("{",tb);
                                                           objtotex_tb((Obj)DEG(dc),tb);
                                                           write_tb("}",tb);
                                                   } else {
                                                           write_tb("{",tb); objtotex_tb((Obj)DEG(dc),tb);
                                                           write_tb("}",tb);
                                                   }
                                           }
                                   }
                                   if ( NEXT(dc) ) {
                                           t = COEF(NEXT(dc));
                                           if ( !DEG(NEXT(dc)) ) {
                                                   if ( NUM(t) ) {
                                                           if ( !mmono(t) ) write_tb("+",tb);
                                                   } else {
                                                           if ( !mmono(COEF(DC(t))) ) write_tb("+",tb);
                                                   }
                                           } else {
                                                   if ( !mmono(t) ) write_tb("+",tb);
                                           }
                                   }
                           }
                           break;
                   case O_R:
                           write_tb("\\frac{",tb);
                           objtotex_tb((Obj)NM((R)obj),tb);
                           write_tb("}{",tb);
                           objtotex_tb((Obj)DN((R)obj),tb);
                           write_tb("}",tb);
                           break;
                   default:
                           write_tb(objtostr(obj),tb);
                           break;
           }
   }
   
 char *objtostr(Obj obj)  char *objtostr(Obj obj)
 {  {
         int len;          int len;
Line 1940  int top_is_minus(FNODE f)
Line 2043  int top_is_minus(FNODE f)
                                         case O_N:                                          case O_N:
                                                 return mmono((P)obj);                                                  return mmono((P)obj);
                                         case O_P:                                          case O_P:
   #if 0
                                                 /* must be a variable */                                                  /* must be a variable */
                                                 opname = conv_rule(VR((P)obj)->name);                                                  opname = conv_rule(VR((P)obj)->name);
                                                 return opname[0]=='-';                                                  return opname[0]=='-';
   #else
                                                   return mmono((P)obj);
   #endif
                                         default:                                          default:
                                                 /* ??? */                                                  /* ??? */
                                                 len = estimate_length(CO,obj);                                                  len = estimate_length(CO,obj);
Line 2166  VL reordvars(VL vl0,NODE head)
Line 2273  VL reordvars(VL vl0,NODE head)
         return vl;          return vl;
 }  }
   
   struct wtab {
           V v;
           int w;
   };
   
   struct wtab *qt_weight_tab;
 VL qt_current_ord, qt_current_coef;  VL qt_current_ord, qt_current_coef;
 LIST qt_current_ord_obj,qt_current_coef_obj;  LIST qt_current_ord_obj,qt_current_coef_obj,qt_current_weight_obj;
   LIST qt_current_weight_obj;
   
 void Pqt_set_ord(NODE arg,LIST *rp)  void Pqt_set_ord(NODE arg,LIST *rp)
 {  {
Line 2177  void Pqt_set_ord(NODE arg,LIST *rp)
Line 2291  void Pqt_set_ord(NODE arg,LIST *rp)
   
         if ( !argc(arg) )          if ( !argc(arg) )
                 *rp = qt_current_ord_obj;                  *rp = qt_current_ord_obj;
         else {          else if ( !ARG0(arg) ) {
                   qt_current_ord_obj = 0;
                   qt_current_ord = 0;
           } else {
                 qt_current_ord = reordvars(CO,BDY((LIST)ARG0(arg)));                  qt_current_ord = reordvars(CO,BDY((LIST)ARG0(arg)));
                 for ( r0 = 0, vl = qt_current_ord; vl; vl = NEXT(vl) ) {                  for ( r0 = 0, vl = qt_current_ord; vl; vl = NEXT(vl) ) {
                         NEXTNODE(r0,r); MKV(vl->v,v); BDY(r) = v;                          NEXTNODE(r0,r); MKV(vl->v,v); BDY(r) = v;
Line 2188  void Pqt_set_ord(NODE arg,LIST *rp)
Line 2305  void Pqt_set_ord(NODE arg,LIST *rp)
         }          }
 }  }
   
   void Pqt_set_weight(NODE arg,LIST *rp)
   {
           NODE n,pair;
           int l,i;
           struct wtab *tab;
   
           if ( !argc(arg) )
                   *rp = qt_current_weight_obj;
           else if ( !ARG0(arg) ) {
                   qt_current_weight_obj = 0;
                   qt_weight_tab = 0;
           } else {
                   n = BDY((LIST)ARG0(arg));
                   l = length(n);
                   tab = qt_weight_tab = (struct wtab *)MALLOC((l+1)*sizeof(struct wtab));
                   for ( i = 0; i < l; i++, n = NEXT(n) ) {
                           pair = BDY((LIST)BDY(n));
                           tab[i].v = VR((P)ARG0(pair));
                           tab[i].w = QTOS((Q)ARG1(pair));
                   }
                   tab[i].v = 0;
                   qt_current_weight_obj = (LIST)ARG0(arg);
                   *rp = qt_current_weight_obj;
           }
   }
   
 void Pqt_set_coef(NODE arg,LIST *rp)  void Pqt_set_coef(NODE arg,LIST *rp)
 {  {
         NODE r0,r,n;          NODE r0,r,n;
Line 2196  void Pqt_set_coef(NODE arg,LIST *rp)
Line 2339  void Pqt_set_coef(NODE arg,LIST *rp)
   
         if ( !argc(arg) )          if ( !argc(arg) )
                 *rp = qt_current_coef_obj;                  *rp = qt_current_coef_obj;
         else {          else if ( !ARG0(arg) ) {
                   qt_current_coef_obj = 0;
                   qt_current_coef = 0;
           } else {
                 n = BDY((LIST)ARG0(arg));                  n = BDY((LIST)ARG0(arg));
                 for ( vl0 = 0, r0 = 0; n; n = NEXT(n) ) {                  for ( vl0 = 0, r0 = 0; n; n = NEXT(n) ) {
                         NEXTNODE(r0,r);                          NEXTNODE(r0,r);
Line 2288  void Pnbp_ht(NODE arg, NBP *rp)
Line 2434  void Pnbp_ht(NODE arg, NBP *rp)
         else {          else {
                 m = (NBM)BDY(BDY(p));                  m = (NBM)BDY(BDY(p));
                 NEWNBM(m1);                  NEWNBM(m1);
                 m1->d = m->d; m1->c = ONE; m1->b = m->b;                  m1->d = m->d; m1->c = (P)ONE; m1->b = m->b;
                 MKNODE(n,m1,0);                  MKNODE(n,m1,0);
                 MKNBP(*rp,n);                  MKNBP(*rp,n);
         }          }
 }  }
   
 void Pnbp_hc(NODE arg, Q *rp)  void Pnbp_hc(NODE arg, P *rp)
 {  {
         NBP p;          NBP p;
         NBM m;          NBM m;
Line 2322  void Pnbp_rest(NODE arg, NBP *rp)
Line 2468  void Pnbp_rest(NODE arg, NBP *rp)
         }          }
 }  }
   
   void Pnbp_tm(NODE arg, NBP *rp)
   {
           NBP p;
           NODE n;
           NBM m;
   
           p = (NBP)ARG0(arg);
           if ( !p ) *rp = 0;
           else {
                   for ( n = BDY(p); NEXT(n); n = NEXT(n) );
                   m = (NBM)BDY(n);
                   MKNODE(n,m,0);
                   MKNBP(*rp,n);
           }
   }
   
   void Pnbp_tt(NODE arg, NBP *rp)
   {
           NBP p;
           NODE n;
           NBM m,m1;
   
           p = (NBP)ARG0(arg);
           if ( !p ) *rp = 0;
           else {
                   for ( n = BDY(p); NEXT(n); n = NEXT(n) );
                   m = (NBM)BDY(n);
                   NEWNBM(m1);
                   m1->d = m->d; m1->c = (P)ONE; m1->b = m->b;
                   MKNODE(n,m1,0);
                   MKNBP(*rp,n);
           }
   }
   
   void Pnbp_tc(NODE arg, P *rp)
   {
           NBP p;
           NBM m;
           NODE n;
   
           p = (NBP)ARG0(arg);
           if ( !p ) *rp = 0;
           else {
                   for ( n = BDY(p); NEXT(n); n = NEXT(n) );
                   m = (NBM)BDY(n);
                   *rp = m->c;
           }
   }
   
   void Pnbp_trest(NODE arg, NBP *rp)
   {
           NBP p;
           NODE n,r,r0;
   
           p = (NBP)ARG0(arg);
           if ( !p ) *rp = 0;
           else {
                   n = BDY(p);
                   for ( r0 = 0; NEXT(n); n = NEXT(n) ) {
                           NEXTNODE(r0,r);
                           BDY(r) = (pointer)BDY(n);
                   }
                   if ( r0 ) {
                           NEXT(r) = 0;
                           MKNBP(*rp,r0);
                   } else
                           *rp = 0;
           }
   }
   
 void Pnbm_deg(NODE arg, Q *rp)  void Pnbm_deg(NODE arg, Q *rp)
 {  {
         NBP p;          NBP p;
Line 2336  void Pnbm_deg(NODE arg, Q *rp)
Line 2552  void Pnbm_deg(NODE arg, Q *rp)
         }          }
 }  }
   
   void Pnbm_index(NODE arg, Q *rp)
   {
           NBP p;
           NBM m;
           unsigned int *b;
           int d,i,r;
   
           p = (NBP)ARG0(arg);
           if ( !p )
                   STOQ(0,*rp);
           else {
                   m = (NBM)BDY(BDY(p));
                   d = m->d;
                   if ( d > 32 )
                           error("nbm_index : weight too large");
                   b = m->b;
                   for ( r = 0, i = d-2; i > 0; i-- )
                           if ( !NBM_GET(b,i) ) r |= (1<<(d-2-i));
                   STOQ(r,*rp);
           }
   }
   
 void Pnbm_hp_rest(NODE arg, LIST *rp)  void Pnbm_hp_rest(NODE arg, LIST *rp)
 {  {
         NBP p,h,r;          NBP p,h,r;
Line 2357  void Pnbm_hp_rest(NODE arg, LIST *rp)
Line 2595  void Pnbm_hp_rest(NODE arg, LIST *rp)
                         for ( i = 1; i < d; i++ )                          for ( i = 1; i < d; i++ )
                                 if ( NBM_GET(b,i) != v ) break;                                  if ( NBM_GET(b,i) != v ) break;
                         NEWNBM(m1); NEWNBMBDY(m1,i);                          NEWNBM(m1); NEWNBMBDY(m1,i);
                         b1 = m1->b; m1->d = i; m1->c = ONE;                          b1 = m1->b; m1->d = i; m1->c = (P)ONE;
                         if ( v ) for ( j = 0; j < i; j++ ) NBM_SET(b1,j);                          if ( v ) for ( j = 0; j < i; j++ ) NBM_SET(b1,j);
                         else for ( j = 0; j < i; j++ ) NBM_CLR(b1,j);                          else for ( j = 0; j < i; j++ ) NBM_CLR(b1,j);
                         MKNODE(n,m1,0); MKNBP(h,n);                          MKNODE(n,m1,0); MKNBP(h,n);
   
                         d1 = d-i;                          d1 = d-i;
                         NEWNBM(m1); NEWNBMBDY(m1,d1);                          NEWNBM(m1); NEWNBMBDY(m1,d1);
                         b1 = m1->b; m1->d = d1; m1->c = ONE;                          b1 = m1->b; m1->d = d1; m1->c = (P)ONE;
                         for ( j = 0, k = i; j < d1; j++, k++ )                          for ( j = 0, k = i; j < d1; j++, k++ )
                                 if ( NBM_GET(b,k) ) NBM_SET(b1,j);                                  if ( NBM_GET(b,k) ) NBM_SET(b1,j);
                                 else NBM_CLR(b1,j);                                  else NBM_CLR(b1,j);
Line 2419  void Pnbm_rest(NODE arg, NBP *rp)
Line 2657  void Pnbm_rest(NODE arg, NBP *rp)
                 separate_nbm((NBM)BDY(BDY(p)),0,0,rp);                  separate_nbm((NBM)BDY(BDY(p)),0,0,rp);
 }  }
   
   void Pnbm_tv(NODE arg, NBP *rp)
   {
           NBP p;
   
           p = (NBP)ARG0(arg);
           if ( !p )
                   *rp = 0;
           else
                   separate_tail_nbm((NBM)BDY(BDY(p)),0,0,rp);
   }
   
   void Pnbm_trest(NODE arg, NBP *rp)
   {
           NBP p;
   
           p = (NBP)ARG0(arg);
           if ( !p )
                   *rp = 0;
           else
                   separate_tail_nbm((NBM)BDY(BDY(p)),0,rp,0);
   }
   
 NBP fnode_to_nbp(FNODE f)  NBP fnode_to_nbp(FNODE f)
 {  {
         Q r;          Q r;
Line 2432  NBP fnode_to_nbp(FNODE f)
Line 2692  NBP fnode_to_nbp(FNODE f)
                 r = eval(f);                  r = eval(f);
                 NEWNBM(m);                  NEWNBM(m);
                 if ( OID(r) == O_N ) {                  if ( OID(r) == O_N ) {
                         m->d = 0; m->c = (Q)r; m->b = 0;                          m->d = 0; m->c = (P)r; m->b = 0;
                 } else {                  } else {
                         v = VR((P)r);                          v = VR((P)r);
                         m->d = 1; m->c = ONE; NEWNBMBDY(m,1);                          m->d = 1; m->c = (P)ONE; NEWNBMBDY(m,1);
                         if ( !strcmp(NAME(v),"x") ) NBM_SET(m->b,0);                          if ( !strcmp(NAME(v),"x") ) NBM_SET(m->b,0);
                         else NBM_CLR(m->b,0);                          else NBM_CLR(m->b,0);
                 }                  }
Line 2463  NBP fnode_to_nbp(FNODE f)
Line 2723  NBP fnode_to_nbp(FNODE f)
         }          }
 }  }
   
   void Pnqt_weight(NODE arg,Q *rp)
   {
           QUOTE q;
           FNODE f;
           int w;
   
           q = (QUOTE)ARG0(arg); f = (FNODE)BDY(q);
           f = fnode_normalize(f,0);
           w = nfnode_weight(qt_weight_tab,f);
           STOQ(w,*rp);
   }
   
 void Pnqt_comp(NODE arg,Q *rp)  void Pnqt_comp(NODE arg,Q *rp)
 {  {
         QUOTE q1,q2;          QUOTE q1,q2;
Line 2520  int fnode_is_coef(FNODE f)
Line 2792  int fnode_is_coef(FNODE f)
                         else if ( OID(obj) == O_P || OID(obj) == O_R) {                          else if ( OID(obj) == O_P || OID(obj) == O_R) {
                                 get_vars_recursive(obj,&vl);                                  get_vars_recursive(obj,&vl);
                                 for ( t = vl; t; t = NEXT(t) ) {                                  for ( t = vl; t; t = NEXT(t) ) {
                                           if ( t->v->attr == (pointer)V_PF ) continue;
                                         for ( s = qt_current_coef; s; s = NEXT(s) )                                          for ( s = qt_current_coef; s; s = NEXT(s) )
                                                 if ( t->v == s->v ) break;                                                  if ( t->v == s->v ) break;
                                         if ( !s ) return 0;                                          if ( !s )
                                                   return 0;
                                 }                                  }
                                 return 1;                                  return 1;
                         } else return 0;                          } else return 0;
Line 2832  FNODE fnode_node_to_nary(ARF op,NODE n)
Line 3106  FNODE fnode_node_to_nary(ARF op,NODE n)
 {  {
         if ( !n ) {          if ( !n ) {
                 if ( op->name[0] == '+' )                  if ( op->name[0] == '+' )
                         return mkfnode(1,I_FORMULA,0);                          return mkfnode(1,I_FORMULA,NULLP);
                 else                  else
                         return mkfnode(1,I_FORMULA,ONE);                          return mkfnode(1,I_FORMULA,ONE);
         } else if ( !NEXT(n) ) return BDY(n);          } else if ( !NEXT(n) ) return BDY(n);
Line 2845  FNODE nfnode_mul(FNODE f1,FNODE f2,int expand)
Line 3119  FNODE nfnode_mul(FNODE f1,FNODE f2,int expand)
         FNODE b1,b2,e1,e2,cc,t,t1;          FNODE b1,b2,e1,e2,cc,t,t1;
         FNODE *m;          FNODE *m;
         int s;          int s;
         Obj c1,c2,c;          Obj c1,c2,c,e;
         Num e;  
         int l1,l,i,j;          int l1,l,i,j;
   
         if ( IS_ZERO(f1) || IS_ZERO(f2) ) return mkfnode(1,I_FORMULA,0);          if ( IS_ZERO(f1) || IS_ZERO(f2) ) return mkfnode(1,I_FORMULA,NULLP);
         else if ( fnode_is_coef(f1) )          else if ( fnode_is_coef(f1) )
                 return nfnode_mul_coef((Obj)eval(f1),f2,expand);                  return nfnode_mul_coef((Obj)eval(f1),f2,expand);
         else if ( fnode_is_coef(f2) )          else if ( fnode_is_coef(f2) )
                 return nfnode_mul_coef((Obj)eval(f2),f1,expand);                  return nfnode_mul_coef((Obj)eval(f2),f1,expand);
   
         if ( expand && IS_NARYADD(f1) ) {          if ( expand && IS_NARYADD(f1) ) {
                 t = mkfnode(1,I_FORMULA,0);                  t = mkfnode(1,I_FORMULA,NULLP);
                 for ( n1 = (NODE)FA1(f1); n1; n1 = NEXT(n1) ) {                  for ( n1 = (NODE)FA1(f1); n1; n1 = NEXT(n1) ) {
                         t1 = nfnode_mul(BDY(n1),f2,expand);                          t1 = nfnode_mul(BDY(n1),f2,expand);
                         t = nfnode_add(t,t1,expand);                          t = nfnode_add(t,t1,expand);
Line 2864  FNODE nfnode_mul(FNODE f1,FNODE f2,int expand)
Line 3137  FNODE nfnode_mul(FNODE f1,FNODE f2,int expand)
                 return t;                  return t;
         }          }
         if ( expand && IS_NARYADD(f2) ) {          if ( expand && IS_NARYADD(f2) ) {
                 t = mkfnode(1,I_FORMULA,0);                  t = mkfnode(1,I_FORMULA,NULLP);
                 for ( n2 = (NODE)FA1(f2); n2; n2 = NEXT(n2) ) {                  for ( n2 = (NODE)FA1(f2); n2; n2 = NEXT(n2) ) {
                         t1 = nfnode_mul(f1,BDY(n2),expand);                          t1 = nfnode_mul(f1,BDY(n2),expand);
                         t = nfnode_add(t,t1,expand);                          t = nfnode_add(t,t1,expand);
Line 2874  FNODE nfnode_mul(FNODE f1,FNODE f2,int expand)
Line 3147  FNODE nfnode_mul(FNODE f1,FNODE f2,int expand)
   
         fnode_coef_body(f1,&c1,&b1); fnode_coef_body(f2,&c2,&b2);          fnode_coef_body(f1,&c1,&b1); fnode_coef_body(f2,&c2,&b2);
         arf_mul(CO,c1,c2,&c);          arf_mul(CO,c1,c2,&c);
         if ( !c ) return mkfnode(1,I_FORMULA,0);          if ( !c ) return mkfnode(1,I_FORMULA,NULLP);
   
   
         n1 = (NODE)FA1(to_narymul(b1)); n2 = (NODE)FA1(to_narymul(b2));          n1 = (NODE)FA1(to_narymul(b1)); n2 = (NODE)FA1(to_narymul(b2));
Line 2882  FNODE nfnode_mul(FNODE f1,FNODE f2,int expand)
Line 3155  FNODE nfnode_mul(FNODE f1,FNODE f2,int expand)
         m = (FNODE *)ALLOCA(l*sizeof(FNODE));          m = (FNODE *)ALLOCA(l*sizeof(FNODE));
         for ( r = n1, i = 0; i < l1; r = NEXT(r), i++ ) m[i] = BDY(r);          for ( r = n1, i = 0; i < l1; r = NEXT(r), i++ ) m[i] = BDY(r);
         for ( r = n2; r; r = NEXT(r) ) {          for ( r = n2; r; r = NEXT(r) ) {
                 if ( i == 0 || (expand == 2) )                  if ( i == 0 )
                         m[i++] = BDY(r);                          m[i++] = BDY(r);
                 else {                  else {
                         fnode_base_exp(m[i-1],&b1,&e1); fnode_base_exp(BDY(r),&b2,&e2);                          fnode_base_exp(m[i-1],&b1,&e1); fnode_base_exp(BDY(r),&b2,&e2);
                         if ( compfnode(b1,b2) ) break;                          if ( compfnode(b1,b2) ) break;
                         addnum(0,eval(e1),eval(e2),&e);                          arf_add(CO,eval(e1),eval(e2),&e);
                         if ( !e ) i--;                          if ( !e ) i--;
                         else if ( UNIQ(e) )                          else if ( expand == 2 ) {
                                   if ( INT(e) && SGN((Q)e) < 0 ) {
                                           t1 = mkfnode(3,I_BOP,pwrfs,b1,mkfnode(1,I_FORMULA,e));
                                           /* r=(r0|rest)->(r0,t1|rest) */
                                           t = BDY(r);
                                           MKNODE(r1,t1,NEXT(r));
                                           MKNODE(r,t,r1);
                                           i--;
                                   } else
                                           m[i++] = BDY(r);
                           } else if ( UNIQ(e) )
                                 m[i-1] = b1;                                  m[i-1] = b1;
                         else                          else
                                 m[i-1] = mkfnode(3,I_BOP,pwrfs,b1,mkfnode(1,I_FORMULA,e));                                  m[i-1] = mkfnode(3,I_BOP,pwrfs,b1,mkfnode(1,I_FORMULA,e));
Line 2914  FNODE nfnode_pwr(FNODE f1,FNODE f2,int expand)
Line 3197  FNODE nfnode_pwr(FNODE f1,FNODE f2,int expand)
         Q q;          Q q;
   
         if ( IS_ZERO(f2) ) return mkfnode(1,I_FORMULA,ONE);          if ( IS_ZERO(f2) ) return mkfnode(1,I_FORMULA,ONE);
         else if ( IS_ZERO(f1) ) return mkfnode(1,I_FORMULA,0);          else if ( IS_ZERO(f1) ) return mkfnode(1,I_FORMULA,NULLP);
         else if ( fnode_is_coef(f1) ) {          else if ( fnode_is_coef(f1) ) {
                 if ( fnode_is_integer(f2) ) {                  if ( fnode_is_integer(f2) ) {
                         if ( fnode_is_one(f2) ) return f1;                          if ( fnode_is_one(f2) ) return f1;
Line 2973  FNODE fnode_expand_pwr(FNODE f,int n,int expand)
Line 3256  FNODE fnode_expand_pwr(FNODE f,int n,int expand)
         Q q;          Q q;
   
         if ( !n ) return mkfnode(1,I_FORMULA,ONE);          if ( !n ) return mkfnode(1,I_FORMULA,ONE);
         else if ( IS_ZERO(f) ) return mkfnode(1,I_FORMULA,0);          else if ( IS_ZERO(f) ) return mkfnode(1,I_FORMULA,NULLP);
         else if ( n == 1 ) return f;          else if ( n == 1 ) return f;
         else {          else {
                 switch ( expand ) {                  switch ( expand ) {
Line 3036  FNODE nfnode_mul_coef(Obj c,FNODE f,int expand)
Line 3319  FNODE nfnode_mul_coef(Obj c,FNODE f,int expand)
         NODE n,r,r0;          NODE n,r,r0;
   
         if ( !c )          if ( !c )
                 return mkfnode(I_FORMULA,0);                  return mkfnode(1,I_FORMULA,NULLP);
         else {          else {
                 fnode_coef_body(f,&c1,&b1);                  fnode_coef_body(f,&c1,&b1);
                 arf_mul(CO,c,c1,&c2);                  arf_mul(CO,c,c1,&c2);
Line 3083  void fnode_coef_body(FNODE f,Obj *cp,FNODE *bp)
Line 3366  void fnode_coef_body(FNODE f,Obj *cp,FNODE *bp)
         }          }
 }  }
   
 int nfnode_comp_pwr(FNODE f1,FNODE f2);  int nfnode_weight(struct wtab *tab,FNODE f)
   {
           NODE n;
           int w,w1;
           int i;
           Q a2;
           V v;
   
           switch ( f->id ) {
                   case I_FORMULA:
                           if ( fnode_is_coef(f) ) return 0;
                           else if ( fnode_is_var(f) ) {
                                   if ( !tab ) return 0;
                                   v = VR((P)FA0(f));
                                   for ( i = 0; tab[i].v; i++ )
                                           if ( v == tab[i].v ) return tab[i].w;
                                   return 0;
                           } else return 0;
   
                   /* XXX */
                   case I_PVAR: return 1;
                   /* XXX */
                   case I_FUNC: I_FUNC: I_FUNC_QARG:
                           /* w(f) = 1 */
                           /* w(f(a1,...,an)=w(a1)+...+w(an) */
                           n = FA0((FNODE)FA1(f));
                           for ( w = 0; n; n = NEXT(n) )
                                   w += nfnode_weight(tab,BDY(n));
                           return w;
                   case I_NARYOP:
                           n = (NODE)FA1(f);
                           if ( IS_NARYADD(f) )
                                   for ( w = nfnode_weight(tab,BDY(n)),
                                           n = NEXT(n); n; n = NEXT(n) ) {
                                           w1 = nfnode_weight(tab,BDY(n));
                                           w = MAX(w,w1);
                                   }
                           else
                                   for ( w = 0; n; n = NEXT(n) )
                                           w += nfnode_weight(tab,BDY(n));
                           return w;
                   case I_BOP:
                           /* must be binary power */
                           /* XXX w(2^x)=0 ? */
                           if ( fnode_is_rational(FA2(f)) ) {
                                   a2 = (Q)eval(FA2(f));
                                   w = QTOS(a2);
                           } else
                                   w = nfnode_weight(tab,FA2(f));
                           return nfnode_weight(tab,FA1(f))*w;
                   default:
                           error("nfnode_weight : not_implemented");
           }
   }
   
 int nfnode_comp(FNODE f1,FNODE f2)  int nfnode_comp(FNODE f1,FNODE f2)
 {  {
           int w1,w2;
   
           if ( qt_weight_tab ) {
                   w1 = nfnode_weight(qt_weight_tab,f1);
                   w2 = nfnode_weight(qt_weight_tab,f2);
                   if ( w1 > w2 ) return 1;
                   if ( w1 < w2 ) return -1;
           }
           return nfnode_comp_lex(f1,f2);
   }
   
   int nfnode_comp_lex(FNODE f1,FNODE f2)
   {
         NODE n1,n2;          NODE n1,n2;
         int r,i1,i2,ret;          int r,i1,i2,ret;
         char *nm1,*nm2;          char *nm1,*nm2;
         FNODE b1,b2,e1,e2,g,a1,a2,fn1,fn2;          FNODE b1,b2,e1,e2,g,a1,a2,fn1,fn2,h1,h2;
         Num ee,ee1;          Num ee,ee1;
         Obj c1,c2;          Obj c1,c2;
           int w1,w2;
   
         if ( IS_NARYADD(f1) || IS_NARYADD(f2) ) {          if ( IS_NARYADD(f1) || IS_NARYADD(f2) ) {
                 f1 = to_naryadd(f1); f2 = to_naryadd(f2);                  f1 = to_naryadd(f1); f2 = to_naryadd(f2);
                 n1 = (NODE)FA1(f1); n2 = (NODE)FA1(f2);                  n1 = (NODE)FA1(f1); n2 = (NODE)FA1(f2);
                 while ( n1 && n2 )                  for ( ; n1 && n2; n1 = NEXT(n1), n2 = NEXT(n2) ) {
                         if ( r = nfnode_comp(BDY(n1),BDY(n2)) ) return r;                          r = nfnode_comp_lex(BDY(n1),BDY(n2));
                         else {                          if ( r ) return r;
                                 n1 = NEXT(n1); n2 = NEXT(n2);                  }
                         }                  if ( !n1 && !n2 ) return 0;
                 return n1?1:(n2?-1:0);                  h1 = n1 ? (FNODE)BDY(n1) : mkfnode(1,I_FORMULA,NULLP);
                   h2 = n2 ? (FNODE)BDY(n2) : mkfnode(1,I_FORMULA,NULLP);
                   return nfnode_comp_lex(h1,h2);
         }          }
         if ( IS_NARYMUL(f1) || IS_NARYMUL(f2) ) {          if ( IS_NARYMUL(f1) || IS_NARYMUL(f2) ) {
                 fnode_coef_body(f1,&c1,&b1);                  fnode_coef_body(f1,&c1,&b1);
Line 3110  int nfnode_comp(FNODE f1,FNODE f2)
Line 3462  int nfnode_comp(FNODE f1,FNODE f2)
                 if ( !compfnode(b1,b2) ) return arf_comp(CO,c1,c2);                  if ( !compfnode(b1,b2) ) return arf_comp(CO,c1,c2);
                 b1 = to_narymul(b1); b2 = to_narymul(b2);                  b1 = to_narymul(b1); b2 = to_narymul(b2);
                 n1 = (NODE)FA1(b1); n2 = (NODE)FA1(b2);                  n1 = (NODE)FA1(b1); n2 = (NODE)FA1(b2);
                 while ( 1 ) {                  for ( ; n1 && n2; n1 = NEXT(n1), n2 = NEXT(n2) ) {
                         while ( n1 && n2 && !compfnode(BDY(n1),BDY(n2)) ) {                          r = nfnode_comp_lex(BDY(n1),BDY(n2));
                                 n1 = NEXT(n1); n2 = NEXT(n2);                          if ( r ) return r;
                         }  
                         if ( !n1 || !n2 ) {  
                                 return n1?1:(n2?-1:0);  
                         }  
                         fnode_base_exp(BDY(n1),&b1,&e1);  
                         fnode_base_exp(BDY(n2),&b2,&e2);  
   
                         if ( r = nfnode_comp(b1,b2) ) {  
                                 if ( r > 0 )  
                                         return nfnode_comp(e1,mkfnode(1,I_FORMULA,0));  
                                 else if ( r < 0 )  
                                         return nfnode_comp(mkfnode(1,I_FORMULA,0),e2);  
                         } else {  
                                 n1 = NEXT(n1); n2 = NEXT(n2);  
                                 if ( fnode_is_number(e1) && fnode_is_number(e2) ) {  
                                         /* f1 = t b^e1 ... , f2 = t b^e2 ... */  
                                         subnum(0,eval(e1),eval(e2),&ee);  
                                         r = compnum(0,ee,0);  
                                         if ( r > 0 ) {  
                                                 g = mkfnode(3,I_BOP,pwrfs,b1,mkfnode(1,I_FORMULA,ee));  
                                                 MKNODE(n1,g,n1);  
                                         } else if ( r < 0 ) {  
                                                 chsgnnum(ee,&ee1);  
                                                 g = mkfnode(3,I_BOP,pwrfs,b1,mkfnode(1,I_FORMULA,ee1));  
                                                 MKNODE(n2,g,n2);  
                                         }  
                                 } else {  
                                         r = nfnode_comp(e1,e2);  
                                         if ( r > 0 ) return 1;  
                                         else if ( r < 0 ) return -1;  
                                 }  
                         }  
                 }                  }
                   if ( !n1 && !n2 ) return 0;
                   h1 = n1 ? (FNODE)BDY(n1) : mkfnode(1,I_FORMULA,ONE);
                   h2 = n2 ? (FNODE)BDY(n2) : mkfnode(1,I_FORMULA,ONE);
                   return nfnode_comp_lex(h1,h2);
         }          }
         if ( IS_BINARYPWR(f1) || IS_BINARYPWR(f2) )          if ( IS_BINARYPWR(f1) || IS_BINARYPWR(f2) ) {
                 return nfnode_comp_pwr(f1,f2);                  fnode_base_exp(f1,&b1,&e1);
                   fnode_base_exp(f2,&b2,&e2);
                   if ( r = nfnode_comp_lex(b1,b2) ) {
                           if ( r > 0 )
                                   return nfnode_comp_lex(e1,mkfnode(1,I_FORMULA,NULLP));
                           else if ( r < 0 )
                                   return nfnode_comp_lex(mkfnode(1,I_FORMULA,NULLP),e2);
                   } else return nfnode_comp_lex(e1,e2);
           }
   
         /* now, IDs of f1 and f2 must be I_FORMULA, I_FUNC, I_IFUNC or I_PVAR */          /* now, IDs of f1 and f2 must be I_FORMULA, I_FUNC, I_IFUNC or I_PVAR */
         /* I_IFUNC > I_PVAR > I_FUNC=I_FUNC_QARG > I_FORMULA */          /* I_IFUNC > I_PVAR > I_FUNC=I_FUNC_QARG > I_FORMULA */
Line 3160  int nfnode_comp(FNODE f1,FNODE f2)
Line 3492  int nfnode_comp(FNODE f1,FNODE f2)
                                 case I_FUNC: case I_IFUNC: case I_PVAR:                                  case I_FUNC: case I_IFUNC: case I_PVAR:
                                         return -1;                                          return -1;
                                 default:                                  default:
                                         error("nfnode_comp : undefined");                                          error("nfnode_comp_lex : undefined");
                         }                          }
                         break;                          break;
                 case I_FUNC: case I_FUNC_QARG:                  case I_FUNC: case I_FUNC_QARG:
Line 3178  int nfnode_comp(FNODE f1,FNODE f2)
Line 3510  int nfnode_comp(FNODE f1,FNODE f2)
                                                 /* compare args */                                                  /* compare args */
                                                 n1 = FA0((FNODE)FA1(f1)); n2 = FA0((FNODE)FA1(f2));                                                  n1 = FA0((FNODE)FA1(f1)); n2 = FA0((FNODE)FA1(f2));
                                                 while ( n1 && n2 )                                                  while ( n1 && n2 )
                                                         if ( r = nfnode_comp(BDY(n1),BDY(n2)) ) return r;                                                          if ( r = nfnode_comp_lex(BDY(n1),BDY(n2)) ) return r;
                                                         else {                                                          else {
                                                                 n1 = NEXT(n1); n2 = NEXT(n2);                                                                  n1 = NEXT(n1); n2 = NEXT(n2);
                                                         }                                                          }
Line 3186  int nfnode_comp(FNODE f1,FNODE f2)
Line 3518  int nfnode_comp(FNODE f1,FNODE f2)
                                         }                                          }
                                         break;                                          break;
                                 default:                                  default:
                                         error("nfnode_comp : undefined");                                          error("nfnode_comp_lex : undefined");
                         }                          }
                 case I_PVAR:                  case I_PVAR:
                         switch ( f2->id ) {                          switch ( f2->id ) {
Line 3200  int nfnode_comp(FNODE f1,FNODE f2)
Line 3532  int nfnode_comp(FNODE f1,FNODE f2)
                                         else if ( i1 < i2 ) return -1;                                          else if ( i1 < i2 ) return -1;
                                         else return 0;                                          else return 0;
                                 default:                                  default:
                                         error("nfnode_comp : undefined");                                          error("nfnode_comp_lex : undefined");
                         }                          }
                         break;                          break;
                 case I_IFUNC:                  case I_IFUNC:
Line 3216  int nfnode_comp(FNODE f1,FNODE f2)
Line 3548  int nfnode_comp(FNODE f1,FNODE f2)
                                                 /* compare args */                                                  /* compare args */
                                                 n1 = FA0((FNODE)FA1(f1)); n2 = FA0((FNODE)FA1(f2));                                                  n1 = FA0((FNODE)FA1(f1)); n2 = FA0((FNODE)FA1(f2));
                                                 while ( n1 && n2 )                                                  while ( n1 && n2 )
                                                         if ( r = nfnode_comp(BDY(n1),BDY(n2)) ) return r;                                                          if ( r = nfnode_comp_lex(BDY(n1),BDY(n2)) ) return r;
                                                         else {                                                          else {
                                                                 n1 = NEXT(n1); n2 = NEXT(n2);                                                                  n1 = NEXT(n1); n2 = NEXT(n2);
                                                         }                                                          }
Line 3225  int nfnode_comp(FNODE f1,FNODE f2)
Line 3557  int nfnode_comp(FNODE f1,FNODE f2)
                                         break;                                          break;
   
                                 default:                                  default:
                                         error("nfnode_comp : undefined");                                          error("nfnode_comp_lex : undefined");
                         }                          }
                         break;                          break;
                 default:                  default:
                         error("nfnode_comp : undefined");                          error("nfnode_comp_lex : undefined");
         }          }
 }  }
   
 int nfnode_comp_pwr(FNODE f1,FNODE f2)  
 {  
         FNODE b1,b2,e1,e2;  
         int r;  
   
         fnode_base_exp(f1,&b1,&e1);  
         fnode_base_exp(f2,&b2,&e2);  
         if ( r = nfnode_comp(b1,b2) ) {  
                 if ( r > 0 )  
                         return nfnode_comp(e1,mkfnode(1,I_FORMULA,0));  
                 else if ( r < 0 )  
                         return nfnode_comp(mkfnode(1,I_FORMULA,0),e2);  
         } else return nfnode_comp(e1,e2);  
 }  
   
 NODE append_node(NODE a1,NODE a2)  NODE append_node(NODE a1,NODE a2)
 {  {
         NODE t,t0;          NODE t,t0;
Line 3320  int nfnode_match(FNODE f,FNODE pat,NODE *rp)
Line 3637  int nfnode_match(FNODE f,FNODE pat,NODE *rp)
                         } else {                          } else {
                                 /* XXX : I_FUNC_HEAD is a dummy id to pass FUNC */                                  /* XXX : I_FUNC_HEAD is a dummy id to pass FUNC */
                                 fh = mkfnode(1,I_FUNC_HEAD,FA0(f));                                  fh = mkfnode(1,I_FUNC_HEAD,FA0(f));
                                 m = mknode(1,mknode(2,FA0((FNODE)FA0(pat)),fh),0);                                  m = mknode(1,mknode(2,FA0((FNODE)FA0(pat)),fh),NULLP);
                         }                          }
                         /* FA1(f) and FA1(pat) are I_LIST */                          /* FA1(f) and FA1(pat) are I_LIST */
                         fa = (NODE)FA0((FNODE)FA1(f));                          fa = (NODE)FA0((FNODE)FA1(f));
Legend:
Removed from v.1.108  
changed lines
  Added in v.1.124
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>