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

Diff for /OpenXM_contrib2/asir2000/builtin/subst.c between version 1.6 and 1.12

version 1.6, 2003/11/27 08:28:40 version 1.12, 2018/03/27 06:29:19
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/subst.c,v 1.5 2001/10/09 01:36:07 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/builtin/subst.c,v 1.11 2017/09/06 06:25:26 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
   
 void Psubst(), Ppsubst(), Psubstf(), Psubst_quote();  void Psubst(), Ppsubst(), Psubstf(), Psubst_quote();
   void Psubstr2np();
   
 struct ftab subst_tab[] = {  struct ftab subst_tab[] = {
         {"subst",Psubst,-99999999},          {"subst",Psubst,-99999999},
           {"substr2np",Psubstr2np,-3},
         {"subst_quote",Psubst_quote,-99999999},          {"subst_quote",Psubst_quote,-99999999},
         {"psubst",Ppsubst,-99999999},          {"psubst",Ppsubst,-99999999},
         {"substf",Psubstf,-99999999},          {"substf",Psubstf,-99999999},
         {0,0,0},          {0,0,0},
 };  };
   
   extern Obj VOIDobj;
   
   /* substr2np(P,[[v,a],...]) or substr2np(P,[v1,...],[a1,...]) */
   
   void Psubstr2np(NODE arg,Obj *rp)
   {
     Obj a,b;
     P nm,dn,p,q;
     R r;
     VL vl,tvl;
     int nv,i,ac,j;
     NODE slist,t,ps,u,vlist;
     P s;
     P *svect;
     V v;
     V *vvect;
   
     a = (Obj)ARG0(arg);
     if ( !a || NUM(a) ) {
       *rp = a;
       return;
     }
     asir_assert(ARG0(arg),O_R,"substr2np");
     asir_assert(ARG1(arg),O_LIST,"substr2np");
     get_vars(a,&vl);
     for ( i = 0, tvl = vl; tvl; tvl = NEXT(tvl), i++ );
     nv = i;
     vvect = (V *)MALLOC((nv)*sizeof(V));
     for ( i = 0, tvl = vl; tvl; tvl = NEXT(tvl), i++ ) vvect[i] = tvl->v;
     svect = (P *)MALLOC((nv)*sizeof(P));
     ac = argc(arg);
     if ( ac == 2 ) {
       slist = BDY((LIST)ARG1(arg));
       for ( i = 0; i < nv; i++ ) svect[i] = (P)VOIDobj;
       for ( t = slist; t; t = NEXT(t) ) {
         ps = BDY((LIST)BDY(t)); p = (P)BDY(ps); s = (P)BDY(NEXT(ps));
         asir_assert(p,O_P,"substr2np"); asir_assert(s,O_P,"substr2np");
         v = VR(p);
         for ( i = 0; i < nv; i++ ) if ( vvect[i] == v ) break;
         svect[i] = s;
       }
     } else if ( ac == 3 ) {
       asir_assert(ARG2(arg),O_LIST,"substr2np");
       vlist = BDY((LIST)ARG1(arg));
       slist = BDY((LIST)ARG2(arg));
       for ( i = 0; i < nv; i++ ) svect[i] = (P)VOIDobj;
         for ( u = vlist, t = slist; u && t; u = NEXT(u), t = NEXT(t) ) {
           v = VR((P)BDY(u));
           for ( i = 0; i < nv; i++ ) if ( vvect[i] == v ) break;
           svect[i] = (P)BDY(t);
         }
       } else
         error("substr2np : argument mismatch");
     for ( i = 0; i < nv; i++ ) {
       if ( (int)(vvect[i]->attr) == V_PF ) {
         MKV(vvect[i],p);
         for ( j = 0; j < nv; j++ )
           if ( j != i ) {
             substr(CO,0,(Obj)p,vvect[j],(Obj)svect[j],&b); p = (P)b;
           }
         if ( OID(svect[i]) == O_VOID ) svect[i] = p;
         else if ( arf_comp(CO,(Obj)p,(Obj)svect[i]) )
           error("substr2np : inconsistent values for substitution");
       }
     }
     switch ( OID(a) ) {
       case O_P:
         substpp(CO,(P)a,vvect,svect,nv,&nm); *rp = (Obj)nm;
         return;
       case O_R:
         substpp(CO,(P)NM((R)a),vvect,svect,nv,&nm);
         substpp(CO,(P)DN((R)a),vvect,svect,nv,&dn);
         if ( !dn )
           error("substr2np: division by 0");
         else if ( !nm )
           *rp = 0;
         else if ( NUM(dn) ) {
           divsp(CO,nm,dn,&p);
           *rp = (Obj)p;
         } else {
           MKRAT(nm,dn,0,r);
           *rp = (Obj)r;
         }
         return;
       default:
         error("substr2np: invalid argument");
     }
   }
   
 void Psubst(arg,rp)  void Psubst(arg,rp)
 NODE arg;  NODE arg;
 Obj *rp;  Obj *rp;
Line 75  Obj *rp;
Line 166  Obj *rp;
         struct oNODE arg0;          struct oNODE arg0;
         MP m,mp,mp0;          MP m,mp,mp0;
         DP d;          DP d;
           VL lastvl,vl,tvl,prev,cur;
   
         if ( !arg ) {          if ( !arg ) {
                 *rp = 0; return;                  *rp = 0; return;
Line 84  Obj *rp;
Line 176  Obj *rp;
                 *rp = 0;                  *rp = 0;
                 return;                  return;
         }          }
           lastvl = LASTCO;
         switch ( OID(a) ) {          switch ( OID(a) ) {
                 case O_N: case O_P: case O_R:                  case O_N: case O_P: case O_R:
                         reductr(CO,(Obj)ARG0(arg),&a);                          reductr(CO,(Obj)ARG0(arg),&a);
Line 91  Obj *rp;
Line 184  Obj *rp;
                         if ( arg && (l = (LIST)ARG0(arg)) && OID(l) == O_LIST )                          if ( arg && (l = (LIST)ARG0(arg)) && OID(l) == O_LIST )
                                 arg = BDY(l);                                  arg = BDY(l);
                         while ( arg ) {                          while ( arg ) {
                                 asir_assert(BDY(arg),O_P,"subst");                                  if ( !BDY(arg) || OID((Obj)BDY(arg)) != O_P )
                                           error("subst : invalid argument");
                                 v = VR((P)BDY(arg)); arg = NEXT(arg);                                  v = VR((P)BDY(arg)); arg = NEXT(arg);
                                 if ( !arg )                                  if ( !arg )
                                         error("subst : invalid argument");                                          error("subst : invalid argument");
Line 161  Obj *rp;
Line 255  Obj *rp;
   
                         break;                          break;
                 default:                  default:
                         error("subst invalid argument");                          error("subst : invalid argument");
           }
           if ( lastvl != LASTCO ) {
                   get_vars_recursive(*rp,&vl);
                   prev = lastvl; cur = NEXT(prev);
                   while ( cur ) {
                           v = cur->v;
                           for ( tvl = vl; tvl && tvl->v != v; tvl = NEXT(tvl) );
                           if ( !tvl ) NEXT(prev) = NEXT(cur);
                           else prev = cur;
                           cur = NEXT(cur);
                   }
                   update_LASTCO();
         }          }
 }  }
   
Legend:
Removed from v.1.6  
changed lines
  Added in v.1.12
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>