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

Diff for /OpenXM_contrib2/asir2000/io/bload.c between version 1.13 and 1.19

version 1.13, 2003/12/22 09:33:47 version 1.19, 2018/03/29 01:32:53
Line 44 
Line 44 
  * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY   * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY
  * 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/io/bload.c,v 1.12 2003/02/14 22:29:15 ohara Exp $   * $OpenXM: OpenXM_contrib2/asir2000/io/bload.c,v 1.18 2017/08/31 09:11:04 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
 #include "com.h"  #include "com.h"
 #if defined(PARI)  
 #include "genpari.h"  
 int get_lg(GEN);  
 #endif  
   
 extern VL file_vl;  extern VL file_vl;
   
   void loadnbp(FILE *s,NBP *p);
   
 void (*loadf[])() = { 0, loadnum, loadp, loadr, loadlist, loadvect, loadmat,  void (*loadf[])() = { 0, loadnum, loadp, loadr, loadlist, loadvect, loadmat,
         loadstring, 0, loaddp, loadui, loaderror,0,0,0,loadgfmmat, loadbytearray };    loadstring, 0, loaddp, loadui, loaderror,0,0,0,loadgfmmat,
     loadbytearray, 0, 0, 0, 0, 0, 0, 0, 0,  loadnbp };
   
 #if defined(INTERVAL)  #if defined(INTERVAL)
 void loaditv();  void loaditv();
 void loaditvd();  void loaditvd();
 void (*nloadf[])() = { loadq, loadreal, 0, loadbf, loaditv, loaditvd, 0, loaditv, loadcplx, loadmi, loadlm, loadgf2n, loadgfpn, loadgfs, loadgfsn };  void (*nloadf[])() = { loadq, loadreal, 0, loadbf, loaditv, loaditvd, 0, loaditv, loadcplx, loadmi, loadlm, loadgf2n, loadgfpn, loadgfs, loadgfsn, loaddalg };
 #else  #else
 void (*nloadf[])() = { loadq, loadreal, 0, loadbf, loadcplx, loadmi, loadlm, loadgf2n, loadgfpn, loadgfs, loadgfsn };  void (*nloadf[])() = { loadq, loadreal, 0, loadbf, loadcplx, loadmi, loadlm, loadgf2n, loadgfpn, loadgfs, loadgfsn, loaddalg };
 #endif  #endif
   
 void loadobj(FILE *s,Obj *p)  void loadobj(FILE *s,Obj *p)
 {  {
         short id;    short id;
   
         read_short(s,&id);    read_short(s,&id);
         if ( !id )    if ( !id )
                 *p = 0;      *p = 0;
         else if ( !loadf[id] )    else if ( !loadf[id] )
                 error("loadobj : not implemented");      error("loadobj : not implemented");
         else    else
                 (*loadf[id])(s,p);      (*loadf[id])(s,p);
 }  }
   
 void loadnum(FILE *s,Num *p)  void loadnum(FILE *s,Num *p)
 {  {
         char nid;    char nid;
   
         read_char(s,&nid);    read_char(s,&nid);
         if ( !nloadf[nid] )    if ( !nloadf[nid] )
                 error("loadnum : not implemented");      error("loadnum : not implemented");
         else    else
                 (*nloadf[nid])(s,p);      (*nloadf[nid])(s,p);
 }  }
   
 void loadq(FILE *s,Q *p)  void loadq(FILE *s,Q *p)
 {  {
         int size[2];    int size[2];
         char sgn;    char sgn;
         int len = 2;    int len = 2;
         N nm,dn;    N nm,dn;
   
         read_char(s,&sgn); read_intarray(s,size,len);    read_char(s,&sgn); read_intarray(s,size,len);
         nm = NALLOC(size[0]); PL(nm) = size[0];    nm = NALLOC(size[0]); PL(nm) = size[0];
         read_intarray(s,BD(nm),size[0]);    read_intarray(s,BD(nm),size[0]);
         if ( size[1] ) {    if ( size[1] ) {
                 dn = NALLOC(size[1]); PL(dn) = size[1];      dn = NALLOC(size[1]); PL(dn) = size[1];
                 read_intarray(s,BD(dn),size[1]);      read_intarray(s,BD(dn),size[1]);
         } else    } else
                 dn = 0;      dn = 0;
         NDTOQ(nm,dn,sgn,*p);    NDTOQ(nm,dn,sgn,*p);
 }  }
   
 void loadreal(FILE *s,Real *p)  void loadreal(FILE *s,Real *p)
 {  {
         Real q;    Real q;
         char dmy;    char dmy;
   
         read_char(s,&dmy);    read_char(s,&dmy);
         NEWReal(q); read_double(s,&BDY(q));    NEWReal(q); read_double(s,&BDY(q));
         *p = q;    *p = q;
 }  }
   
 void loadbf(FILE *s,BF *p)  void loadbf(FILE *s,BF *p)
 {  {
 #if defined(PARI)    BF r;
         GEN z;    char dmy;
         unsigned int uexpo,lexpo;    int sgn,prec;
         char dmy;    UL exp;
         int sign;  
         unsigned int len;  
         unsigned long expo;  
         BF q;  
   
         read_char(s,&dmy);    int len;
         read_int(s,&sign);    read_char(s,&dmy);
         read_int(s,&uexpo);    NEWBF(r);
         read_int(s,&lexpo);    read_int(s,&sgn);
     read_int(s,&prec);
 #if defined(LONG_IS_32BIT)    read_int64(s,&exp);
         if ( uexpo )    read_int(s,&len);
                 error("loadbf : exponent too large");    mpfr_init2(r->body,prec);
         read_int(s,&len);    MPFR_SIGN(r->body) = sgn;
         NEWBF(q,len+2);    MPFR_EXP(r->body) = (int)exp;
         z = (GEN)BDY(q);  #if defined(VISUAL)
         settyp(z,t_REAL);  #if !defined(_WIN64)
         setlg(z,len+2);    read_intarray(s,(int *)r->body->_mpfr_d,len);
         setsigne(z,(long)sign);  #else
         setexpo(z,(long)lexpo);    read_longarray(s,(long long*)r->body->_mpfr_d,len);
         read_intarray(s,(int *)(z+2),len);  
 #elif defined(LONG_IS_64BIT)  
         expo = (((UL)uexpo)<<32)|((UL)lexpo);  
         read_int(s,&len);  
         NEWBF(q,(len+5)/2); /* 2+(len+1)/2 */  
         z = (GEN)BDY(q);  
         settyp(z,t_REAL);  
         setlg(z,(len+5)/2);  
         setsigne(z,(long)sign);  
         setexpo(z,(long)expo);  
         read_longarray(s,z+2,len);  
 #endif  #endif
         *p = q;  
 #else  #else
         error("loadbf : PARI is not combined");  #if SIZEOF_LONG == 4
     read_intarray(s,(int *)r->body->_mpfr_d,len);
   #else /* SIZEOF_LONG == 8 */
     read_longarray(s,(long *)r->body->_mpfr_d,len);
 #endif  #endif
   #endif
     *p = r;
 }  }
   
 #if defined(INTERVAL)  #if defined(INTERVAL)
 void loaditv(FILE *s,Itv *p)  void loaditv(FILE *s,Itv *p)
 {  {
         Itv q;    Itv q;
         char dmy;    char dmy;
   
         read_char(s,&dmy);    read_char(s,&dmy);
         NEWItvP(q); loadobj(s,(Obj *)&INF(q)); loadobj(s,(Obj *)&SUP(q));    NEWItvP(q); loadobj(s,(Obj *)&INF(q)); loadobj(s,(Obj *)&SUP(q));
         *p = q;    *p = q;
 }  }
   
 void loaditvd(FILE *s,IntervalDouble *p)  void loaditvd(FILE *s,IntervalDouble *p)
 {  {
         IntervalDouble q;    IntervalDouble q;
         char dmy;    char dmy;
   
         read_char(s,&dmy);    read_char(s,&dmy);
         NEWIntervalDouble(q);    NEWIntervalDouble(q);
         read_double(s,&INF(q));    read_double(s,&INF(q));
         read_double(s,&SUP(q));    read_double(s,&SUP(q));
         *p = q;    *p = q;
 }  }
 #endif  #endif
   
 void loadcplx(FILE *s,C *p)  void loadcplx(FILE *s,C *p)
 {  {
         C q;    C q;
         char dmy;    char dmy;
   
         read_char(s,&dmy);    read_char(s,&dmy);
         NEWC(q); loadobj(s,(Obj *)&q->r); loadobj(s,(Obj *)&q->i);    NEWC(q); loadobj(s,(Obj *)&q->r); loadobj(s,(Obj *)&q->i);
         *p = q;    *p = q;
 }  }
   
 void loadmi(FILE *s,MQ *p)  void loadmi(FILE *s,MQ *p)
 {  {
         MQ q;    MQ q;
         char dmy;    char dmy;
   
         read_char(s,&dmy);    read_char(s,&dmy);
         NEWMQ(q); read_int(s,(int *)&CONT(q));    NEWMQ(q); read_int(s,(int *)&CONT(q));
         *p = q;    *p = q;
 }  }
   
 void loadlm(FILE *s,LM *p)  void loadlm(FILE *s,LM *p)
 {  {
         int size;    int size;
         char dmy;    char dmy;
         N body;    N body;
   
         read_char(s,&dmy); read_int(s,&size);    read_char(s,&dmy); read_int(s,&size);
         body = NALLOC(size); PL(body) = size;    body = NALLOC(size); PL(body) = size;
         read_intarray(s,BD(body),size);    read_intarray(s,BD(body),size);
         MKLM(body,*p);    MKLM(body,*p);
 }  }
   
 void loadgf2n(FILE *s,GF2N *p)  void loadgf2n(FILE *s,GF2N *p)
 {  {
         char dmy;    char dmy;
         int len;    int len;
         UP2 body;    UP2 body;
   
         read_char(s,&dmy); read_int(s,&len);    read_char(s,&dmy); read_int(s,&len);
         NEWUP2(body,len); body->w = len;    NEWUP2(body,len); body->w = len;
         read_intarray(s,body->b,len);    read_intarray(s,body->b,len);
         MKGF2N(body,*p);    MKGF2N(body,*p);
 }  }
   
 void loadgfpn(FILE *s,GFPN *p)  void loadgfpn(FILE *s,GFPN *p)
 {  {
         char dmy;    char dmy;
         int d,i;    int d,i;
         UP body;    UP body;
   
         read_char(s,&dmy); read_int(s,&d);    read_char(s,&dmy); read_int(s,&d);
         body = UPALLOC(d);    body = UPALLOC(d);
         body->d = d;    body->d = d;
         for ( i = 0; i <= d; i++ )    for ( i = 0; i <= d; i++ )
                 loadobj(s,(Obj *)&body->c[i]);      loadobj(s,(Obj *)&body->c[i]);
         MKGFPN(body,*p);    MKGFPN(body,*p);
 }  }
   
 void loadgfs(FILE *s,GFS *p)  void loadgfs(FILE *s,GFS *p)
 {  {
         GFS q;    GFS q;
         char dmy;    char dmy;
   
         read_char(s,&dmy);    read_char(s,&dmy);
         NEWGFS(q); read_int(s,(int *)&CONT(q));    NEWGFS(q); read_int(s,(int *)&CONT(q));
         *p = q;    *p = q;
 }  }
   
 void loadgfsn(FILE *s,GFSN *p)  void loadgfsn(FILE *s,GFSN *p)
 {  {
         char dmy;    char dmy;
         int d;    int d;
         UM body;    UM body;
   
         read_char(s,&dmy); read_int(s,&d);    read_char(s,&dmy); read_int(s,&d);
         body = UMALLOC(d); DEG(body) = d;    body = UMALLOC(d); DEG(body) = d;
         read_intarray(s,COEF(body),d+1);    read_intarray(s,COEF(body),d+1);
         MKGFSN(body,*p);    MKGFSN(body,*p);
 }  }
   
   void loaddalg(FILE *s,DAlg *p)
   {
     char dmy;
     Obj nm,dn;
   
     read_char(s,&dmy);
     loadobj(s,&nm);
     loadobj(s,&dn);
     MKDAlg((DP)nm,(Q)dn,*p);
   }
   
 void loadp(FILE *s,P *p)  void loadp(FILE *s,P *p)
 {  {
         V v;    V v;
         int n,vindex;    int n,vindex;
         DCP dc,dc0;    DCP dc,dc0;
         P t;    P t;
   
         read_int(s,&vindex);    read_int(s,&vindex);
         if ( vindex < 0 )    if ( vindex < 0 )
         /* v is a pure function */    /* v is a pure function */
                 v = loadpfins(s);      v = loadpfins(s);
         else    else
                 v = (V)load_convv(vindex);      v = (V)load_convv(vindex);
         read_int(s,&n);    read_int(s,&n);
         for ( dc0 = 0; n; n-- ) {    for ( dc0 = 0; n; n-- ) {
                 NEXTDC(dc0,dc); loadobj(s,(Obj *)&DEG(dc)); loadobj(s,(Obj *)&COEF(dc));      NEXTDC(dc0,dc); loadobj(s,(Obj *)&DEG(dc)); loadobj(s,(Obj *)&COEF(dc));
         }    }
         NEXT(dc) = 0;    NEXT(dc) = 0;
         MKP(v,dc0,t);    MKP(v,dc0,t);
         if ( vindex < 0 || file_vl )    if ( vindex < 0 || file_vl )
                 reorderp(CO,file_vl,t,p);      reorderp(CO,file_vl,t,p);
         else    else
                 *p = t;      *p = t;
 }  }
   
 /* |name(str)|argc(int)|darray(intarray)|args| */  /* |name(str)|argc(int)|darray(intarray)|args| */
   
 V loadpfins(FILE *s)  V loadpfins(FILE *s)
 {  {
         char *name;    char *name;
         FUNC fp;    FUNC fp;
         int argc,i;    int argc,i;
         V v;    V v;
         int *darray;    int *darray;
         Obj *args;    Obj *args;
         PF pf;    PF pf;
         char *buf;    char *buf;
         V *a;    V *a;
         P u;    P u;
   
         loadstr(s,&name);    loadstr(s,&name);
         read_int(s,&argc);    read_int(s,&argc);
         searchpf(name,&fp);    searchpf(name,&fp);
         if ( fp ) {    if ( fp ) {
                 pf = fp->f.puref;      pf = fp->f.puref;
                 if ( pf->argc != argc )      if ( pf->argc != argc )
                         error("loadpfins : argument mismatch");        error("loadpfins : argument mismatch");
         } else {    } else {
                 a = (V *)MALLOC(argc*sizeof(V));      a = (V *)MALLOC(argc*sizeof(V));
                 buf = (char *)ALLOCA(BUFSIZ);      buf = (char *)ALLOCA(BUFSIZ);
                 for ( i = 0; i < argc; i++ ) {      for ( i = 0; i < argc; i++ ) {
                         sprintf(buf,"_%c",'a'+i);        sprintf(buf,"_%c",'a'+i);
                         makevar(buf,&u); a[i] = VR(u);        makevar(buf,&u); a[i] = VR(u);
                 }      }
                 mkpf(name,0,argc,a,0,0,0,&pf);      mkpf(name,0,argc,a,0,0,0,&pf);
         }    }
         darray = (int *)ALLOCA(argc*sizeof(int));    darray = (int *)ALLOCA(argc*sizeof(int));
         args = (Obj *)ALLOCA(argc*sizeof(int));    args = (Obj *)ALLOCA(argc*sizeof(int));
         read_intarray(s,darray,argc);    read_intarray(s,darray,argc);
         for ( i = 0; i < argc; i++ )    for ( i = 0; i < argc; i++ )
                 loadobj(s,&args[i]);      loadobj(s,&args[i]);
         _mkpfins_with_darray(pf,args,darray,&v);    _mkpfins_with_darray(pf,args,darray,&v);
         return v;    return v;
 }  }
   
 void loadr(FILE *s,R *p)  void loadr(FILE *s,R *p)
 {  {
         R r;    R r;
   
         NEWR(r); read_short(s,&r->reduced);    NEWR(r); read_short(s,&r->reduced);
         loadobj(s,(Obj *)&NM(r)); loadobj(s,(Obj *)&DN(r)); *p = r;    loadobj(s,(Obj *)&NM(r)); loadobj(s,(Obj *)&DN(r)); *p = r;
 }  }
   
 void loadlist(FILE *s,LIST *p)  void loadlist(FILE *s,LIST *p)
 {  {
         int n;    int n;
         NODE tn,tn0;    NODE tn,tn0;
   
         read_int(s,&n);    read_int(s,&n);
         for ( tn0 = 0; n; n-- ) {    for ( tn0 = 0; n; n-- ) {
                 NEXTNODE(tn0,tn); loadobj(s,(Obj *)&BDY(tn));      NEXTNODE(tn0,tn); loadobj(s,(Obj *)&BDY(tn));
         }    }
         if ( tn0 )    if ( tn0 )
                 NEXT(tn) = 0;      NEXT(tn) = 0;
         MKLIST(*p,tn0);    MKLIST(*p,tn0);
 }  }
   
 void loadvect(FILE *s,VECT *p)  void loadvect(FILE *s,VECT *p)
 {  {
         int i,len;    int i,len;
         VECT vect;    VECT vect;
   
         read_int(s,&len); MKVECT(vect,len);    read_int(s,&len); MKVECT(vect,len);
         for ( i = 0; i < len; i++ )    for ( i = 0; i < len; i++ )
                 loadobj(s,(Obj *)&BDY(vect)[i]);      loadobj(s,(Obj *)&BDY(vect)[i]);
         *p = vect;    *p = vect;
 }  }
   
 void loadmat(FILE *s,MAT *p)  void loadmat(FILE *s,MAT *p)
 {  {
         int row,col,i,j;    int row,col,i,j;
         MAT mat;    MAT mat;
   
         read_int(s,&row); read_int(s,&col); MKMAT(mat,row,col);    read_int(s,&row); read_int(s,&col); MKMAT(mat,row,col);
         for ( i = 0; i < row; i++ )    for ( i = 0; i < row; i++ )
                 for ( j = 0; j < col; j++ )      for ( j = 0; j < col; j++ )
                         loadobj(s,(Obj *)&BDY(mat)[i][j]);        loadobj(s,(Obj *)&BDY(mat)[i][j]);
         *p = mat;    *p = mat;
 }  }
   
 void loadstring(FILE *s,STRING *p)  void loadstring(FILE *s,STRING *p)
 {  {
         char *t;    char *t;
   
         loadstr(s,&t); MKSTR(*p,t);    loadstr(s,&t); MKSTR(*p,t);
 }  }
   
 void loadstr(FILE *s,char **p)  void loadstr(FILE *s,char **p)
 {  {
         int len;    int len;
         char *t;    char *t;
   
         read_int(s,&len);    read_int(s,&len);
         if ( len ) {    if ( len ) {
                 t = (char *)MALLOC(len+1); read_string(s,t,len); t[len] = 0;      t = (char *)MALLOC(len+1); read_string(s,t,len); t[len] = 0;
         } else    } else
                 t = "";      t = "";
         *p = t;    *p = t;
 }  }
   
 void loadbytearray(FILE *s,BYTEARRAY *p)  void loadbytearray(FILE *s,BYTEARRAY *p)
 {  {
         int len;    int len;
         BYTEARRAY array;    BYTEARRAY array;
   
         read_int(s,&len);    read_int(s,&len);
         MKBYTEARRAY(array,len);    MKBYTEARRAY(array,len);
         if ( len ) {    if ( len ) {
                 read_string(s,array->body,len);      read_string(s,array->body,len);
         }    }
         *p = array;    *p = array;
 }  }
   
 void loaddp(FILE *s,DP *p)  void loaddp(FILE *s,DP *p)
 {  {
         int nv,n,i,sugar;    int nv,n,i,sugar;
         DP dp;    DP dp;
         MP m,m0;    MP m,m0;
         DL dl;    DL dl;
   
         read_int(s,&nv); read_int(s,&sugar); read_int(s,&n);    read_int(s,&nv); read_int(s,&sugar); read_int(s,&n);
         for ( i = 0, m0 = 0; i < n; i++ ) {    for ( i = 0, m0 = 0; i < n; i++ ) {
                 NEXTMP(m0,m);      NEXTMP(m0,m);
                 loadobj(s,(Obj *)&(m->c));      loadobj(s,(Obj *)&(m->c));
                 NEWDL(dl,nv); m->dl = dl;      NEWDL(dl,nv); m->dl = dl;
                 read_int(s,&dl->td); read_intarray(s,&(dl->d[0]),nv);      read_int(s,&dl->td); read_intarray(s,&(dl->d[0]),nv);
         }    }
         NEXT(m) = 0; MKDP(nv,m0,dp); dp->sugar = sugar; *p = dp;    NEXT(m) = 0; MKDP(nv,m0,dp); dp->sugar = sugar; *p = dp;
 }  }
   
 void loadui(FILE *s,USINT *u)  void loadui(FILE *s,USINT *u)
 {  {
         unsigned int b;    unsigned int b;
   
         read_int(s,&b); MKUSINT(*u,b);    read_int(s,&b); MKUSINT(*u,b);
 }  }
   
 void loaderror(FILE *s,ERR *e)  void loaderror(FILE *s,ERR *e)
 {  {
         Obj b;    Obj b;
   
         loadobj(s,&b); MKERR(*e,b);    loadobj(s,&b); MKERR(*e,b);
 }  }
   
   
 void loadgfmmat(FILE *s,GFMMAT *p)  void loadgfmmat(FILE *s,GFMMAT *p)
 {  {
         int i,row,col;    int i,row,col;
         unsigned int **a;    unsigned int **a;
         GFMMAT mat;    GFMMAT mat;
   
         read_int(s,&row); read_int(s,&col);    read_int(s,&row); read_int(s,&col);
         a = (unsigned int **)almat(row,col);    a = (unsigned int **)almat(row,col);
         TOGFMMAT(row,col,a,mat);    TOGFMMAT(row,col,a,mat);
         for ( i = 0; i < row; i++ )    for ( i = 0; i < row; i++ )
                 read_intarray(s,a[i],col);      read_intarray(s,a[i],col);
         *p = mat;    *p = mat;
   }
   
   void loadnbp(FILE *s,NBP *p)
   {
     int n,i;
     NBM m;
     NODE r0,r;
   
     read_int(s,&n);
     for ( i = 0, r0 = 0; i < n; i++ ) {
       NEWNBM(m);
       loadobj(s,(Obj *)&m->c);
       read_int(s,&m->d);
       NEWNBMBDY(m,m->d); read_intarray(s,m->b,(m->d+31)/32);
       NEXTNODE(r0,r); BDY(r) = (pointer)m;
     }
     if ( r0 ) NEXT(r) = 0;
     MKNBP(*p,r0);
 }  }
Legend:
Removed from v.1.13  
changed lines
  Added in v.1.19
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>