[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.3 and 1.20

version 1.3, 2000/08/22 05:04:17 version 1.20, 2019/11/12 10:52:04
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.2 2000/08/21 08:31:38 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/io/bload.c,v 1.19 2018/03/29 01:32:53 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "parse.h"  #include "parse.h"
 #if INET  
 #include "com.h"  #include "com.h"
 #endif  
 #if PARI  
 #include "genpari.h"  
 int get_lg(GEN);  
 #endif  
   
 void loaderror(FILE *,ERR *);  
 void loadui(FILE *,USINT *);  
 void loaddp(FILE *,DP *);  
 void loadstr(FILE *,char **);  
 void loadstring(FILE *,STRING *);  
 void loadmat(FILE *,MAT *);  
 void loadvect(FILE *,VECT *);  
 void loadlist(FILE *,LIST *);  
 void loadr(FILE *,R *);  
 void loadp(FILE *,P *);  
 void loadgf2n(FILE *,GF2N *);  
 void loadgfpn(FILE *,GFPN *);  
 void loadlm(FILE *,LM *);  
 void loadmi(FILE *,MQ *);  
 void loadcplx(FILE *,C *);  
 void loadbf(FILE *,BF *);  
 void loadreal(FILE *,Real *);  
 void loadq(FILE *,Q *);  
 void loadnum(FILE *,Num *);  
 void loadgfmmat(FILE *,GFMMAT *);  
   
 V loadpfins(FILE *);  
   
 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 };    loadstring, 0, loaddp, loadui, loaderror,0,0,0,loadgfmmat,
 void (*nloadf[])() = { loadq, loadreal, 0, loadbf, loadcplx, loadmi, loadlm, loadgf2n, loadgfpn };    loadbytearray, 0, 0, 0, 0, 0, 0, 0, 0,  loadnbp };
   
 void loadobj(s,p)  #if defined(INTERVAL)
 FILE *s;  void loaditv();
 Obj *p;  void loaditvd();
   void (*nloadf[])() = { loadq, loadreal, 0, loadbf, loaditv, loaditvd, 0, loaditv, loadcplx, loadmi, loadlm, loadgf2n, loadgfpn, loadgfs, loadgfsn, loaddalg };
   #else
   void (*nloadf[])() = { loadq, loadreal, 0, loadbf, loadcplx, loadmi, loadlm, loadgf2n, loadgfpn, loadgfs, loadgfsn, loaddalg };
   #endif
   
   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(s,p)  void loadnum(FILE *s,Num *p)
 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(s,p)  void loadq(FILE *s,Q *p)
 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(s,p)  void loadreal(FILE *s,Real *p)
 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(s,p)  void loadbf(FILE *s,BF *p)
 FILE *s;  
 BF *p;  
 {  {
 #if PARI    BF r;
         GEN z;    char dmy;
         unsigned int uexpo,lexpo;    int sgn,prec;
         UL expo;    UL exp;
         char dmy;  
         int sign;  
         unsigned int len;  
         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;
 }  }
   
 void loadcplx(s,p)  #if defined(INTERVAL)
 FILE *s;  void loaditv(FILE *s,Itv *p)
 C *p;  
 {  {
         C q;    Itv 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);    NEWItvP(q); loadobj(s,(Obj *)&INF(q)); loadobj(s,(Obj *)&SUP(q));
         *p = q;    *p = q;
 }  }
   
 void loadmi(s,p)  void loaditvd(FILE *s,IntervalDouble *p)
 FILE *s;  
 MQ *p;  
 {  {
         MQ q;    IntervalDouble q;
         char dmy;    char dmy;
   
         read_char(s,&dmy);    read_char(s,&dmy);
         NEWMQ(q); read_int(s,(int *)&CONT(q));    NEWIntervalDouble(q);
         *p = q;    read_double(s,&INF(q));
     read_double(s,&SUP(q));
     *p = q;
 }  }
   #endif
   
 void loadlm(s,p)  void loadcplx(FILE *s,C *p)
 FILE *s;  
 LM *p;  
 {  {
         int size;    C q;
         char dmy;    char dmy;
         N body;  
   
         read_char(s,&dmy); read_int(s,&size);    read_char(s,&dmy);
         body = NALLOC(size); PL(body) = size;    NEWC(q); loadobj(s,(Obj *)&q->r); loadobj(s,(Obj *)&q->i);
         read_intarray(s,BD(body),size);    *p = q;
         MKLM(body,*p);  
 }  }
   
 void loadgf2n(s,p)  void loadmi(FILE *s,MQ *p)
 FILE *s;  
 GF2N *p;  
 {  {
         char dmy;    MQ q;
         int len;    char dmy;
         UP2 body;  
   
         read_char(s,&dmy); read_int(s,&len);    read_char(s,&dmy);
         NEWUP2(body,len); body->w = len;    NEWMQ(q); read_int(s,(int *)&CONT(q));
         read_intarray(s,body->b,len);    *p = q;
         MKGF2N(body,*p);  
 }  }
   
 void loadgfpn(s,p)  void loadlm(FILE *s,LM *p)
 FILE *s;  
 GFPN *p;  
 {  {
         char dmy;    int size;
         int d,i;    char dmy;
         UP body;    N body;
   
         read_char(s,&dmy); read_int(s,&d);    read_char(s,&dmy); read_int(s,&size);
         body = UPALLOC(d);    body = NALLOC(size); PL(body) = size;
         body->d = d;    read_intarray(s,BD(body),size);
         for ( i = 0; i <= d; i++ )    MKLM(body,*p);
                 loadobj(s,(Obj *)&body->c[i]);  
         MKGFPN(body,*p);  
 }  }
   
 void loadp(s,p)  void loadgf2n(FILE *s,GF2N *p)
 FILE *s;  
 P *p;  
 {  {
         V v;    char dmy;
         int n,vindex;    int len;
         DCP dc,dc0;    UP2 body;
         P t;  
   
         read_int(s,&vindex);    read_char(s,&dmy); read_int(s,&len);
         if ( vindex < 0 )    NEWUP2(body,len); body->w = len;
         /* v is a pure function */    read_intarray(s,body->b,len);
                 v = loadpfins(s);    MKGF2N(body,*p);
         else  
                 v = (V)load_convv(vindex);  
         read_int(s,&n);  
         for ( dc0 = 0; n; n-- ) {  
                 NEXTDC(dc0,dc); loadobj(s,(Obj *)&DEG(dc)); loadobj(s,(Obj *)&COEF(dc));  
         }  
         NEXT(dc) = 0;  
         MKP(v,dc0,t);  
         if ( vindex < 0 || file_vl )  
                 reorderp(CO,file_vl,t,p);  
         else  
                 *p = t;  
 }  }
   
   void loadgfpn(FILE *s,GFPN *p)
   {
     char dmy;
     int d,i;
     UP body;
   
     read_char(s,&dmy); read_int(s,&d);
     body = UPALLOC(d);
     body->d = d;
     for ( i = 0; i <= d; i++ )
       loadobj(s,(Obj *)&body->c[i]);
     MKGFPN(body,*p);
   }
   
   void loadgfs(FILE *s,GFS *p)
   {
     GFS q;
     char dmy;
   
     read_char(s,&dmy);
     NEWGFS(q); read_int(s,(int *)&CONT(q));
     *p = q;
   }
   
   void loadgfsn(FILE *s,GFSN *p)
   {
     char dmy;
     int d;
     UM body;
   
     read_char(s,&dmy); read_int(s,&d);
     body = UMALLOC(d); DEG(body) = d;
     read_intarray(s,COEF(body),d+1);
     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)
   {
     V v;
     int n,vindex;
     DCP dc,dc0;
     P t;
   
     read_int(s,&vindex);
     if ( vindex < 0 )
     /* v is a pure function */
       v = loadpfins(s);
     else
       v = (V)load_convv(vindex);
     read_int(s,&n);
     for ( dc0 = 0; n; n-- ) {
       NEXTDC(dc0,dc); loadobj(s,(Obj *)&DEG(dc)); loadobj(s,(Obj *)&COEF(dc));
     }
     NEXT(dc) = 0;
     MKP(v,dc0,t);
     if ( vindex < 0 || file_vl )
       reorderp(CO,file_vl,t,p);
     else
       *p = t;
   }
   
 /* |name(str)|argc(int)|darray(intarray)|args| */  /* |name(str)|argc(int)|darray(intarray)|args| */
   
 V loadpfins(s)  V loadpfins(FILE *s)
 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);  #if defined(INTERVAL)
         }      mkpf(name,0,argc,a,0,0,0,0,&pf);
         darray = (int *)ALLOCA(argc*sizeof(int));  #else
         args = (Obj *)ALLOCA(argc*sizeof(int));      mkpf(name,0,argc,a,0,0,0,&pf);
         read_intarray(s,darray,argc);  #endif
         for ( i = 0; i < argc; i++ )    }
                 loadobj(s,&args[i]);    darray = (int *)ALLOCA(argc*sizeof(int));
         _mkpfins_with_darray(pf,args,darray,&v);    args = (Obj *)ALLOCA(argc*sizeof(int));
         return v;    read_intarray(s,darray,argc);
     for ( i = 0; i < argc; i++ )
       loadobj(s,&args[i]);
     _mkpfins_with_darray(pf,args,darray,&v);
     return v;
 }  }
   
 void loadr(s,p)  void loadr(FILE *s,R *p)
 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(s,p)  void loadlist(FILE *s,LIST *p)
 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(s,p)  void loadvect(FILE *s,VECT *p)
 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(s,p)  void loadmat(FILE *s,MAT *p)
 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(s,p)  void loadstring(FILE *s,STRING *p)
 FILE *s;  
 STRING *p;  
 {  {
         char *t;    char *t;
   
         loadstr(s,&t); MKSTR(*p,t);    loadstr(s,&t); MKSTR(*p,t);
 }  }
   
 void loadstr(s,p)  void loadstr(FILE *s,char **p)
 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 loaddp(s,p)  void loadbytearray(FILE *s,BYTEARRAY *p)
 FILE *s;  
 DP *p;  
 {  {
         int nv,n,i,sugar;    int len;
         DP dp;    BYTEARRAY array;
         MP m,m0;  
         DL dl;  
   
         read_int(s,&nv); read_int(s,&sugar); read_int(s,&n);    read_int(s,&len);
         for ( i = 0, m0 = 0; i < n; i++ ) {    MKBYTEARRAY(array,len);
                 NEXTMP(m0,m);    if ( len ) {
                 loadobj(s,(Obj *)&(m->c));      read_string(s,array->body,len);
                 NEWDL(dl,nv); m->dl = dl;    }
                 read_int(s,&dl->td); read_intarray(s,&(dl->d[0]),nv);    *p = array;
         }  
         NEXT(m) = 0; MKDP(nv,m0,dp); dp->sugar = sugar; *p = dp;  
 }  }
   
 void loadui(s,u)  void loaddp(FILE *s,DP *p)
 FILE *s;  
 USINT *u;  
 {  {
         unsigned int b;    int nv,n,i,sugar;
     DP dp;
     MP m,m0;
     DL dl;
   
         read_int(s,&b); MKUSINT(*u,b);    read_int(s,&nv); read_int(s,&sugar); read_int(s,&n);
     for ( i = 0, m0 = 0; i < n; i++ ) {
       NEXTMP(m0,m);
       loadobj(s,(Obj *)&(m->c));
       NEWDL(dl,nv); m->dl = dl;
       read_int(s,&dl->td); read_intarray(s,&(dl->d[0]),nv);
     }
     NEXT(m) = 0; MKDP(nv,m0,dp); dp->sugar = sugar; *p = dp;
 }  }
   
 void loaderror(s,e)  void loadui(FILE *s,USINT *u)
 FILE *s;  
 ERR *e;  
 {  {
         Obj b;    unsigned int b;
   
         loadobj(s,&b); MKERR(*e,b);    read_int(s,&b); MKUSINT(*u,b);
 }  }
   
   void loaderror(FILE *s,ERR *e)
   {
     Obj b;
   
 void loadgfmmat(s,p)    loadobj(s,&b); MKERR(*e,b);
 FILE *s;  }
 GFMMAT *p;  
   
   void loadgfmmat(FILE *s,GFMMAT *p)
 {  {
         int i,j,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.3  
changed lines
  Added in v.1.20
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>