===================================================================
RCS file: /home/cvs/OpenXM_contrib2/asir2000/io/cio.c,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -p -r1.13 -r1.14
--- OpenXM_contrib2/asir2000/io/cio.c	2015/08/04 06:20:45	1.13
+++ OpenXM_contrib2/asir2000/io/cio.c	2015/08/04 10:19:31	1.14
@@ -44,7 +44,7 @@
  * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY
  * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
  * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
- * $OpenXM: OpenXM_contrib2/asir2000/io/cio.c,v 1.12 2003/04/08 22:29:00 ohara Exp $ 
+ * $OpenXM: OpenXM_contrib2/asir2000/io/cio.c,v 1.13 2015/08/04 06:20:45 noro Exp $ 
 */
 #include "ca.h"
 #include "parse.h"
@@ -57,354 +57,361 @@
 
 int valid_as_cmo(Obj obj)
 {
-	NODE m;
+  NODE m;
   int nid;
 
-	if ( !obj )
-		return 1;
-	switch ( OID(obj) ) {
-		case O_MATHCAP: case O_P: case O_R: case O_DP: case O_STR:
-		case O_ERR: case O_USINT: case O_BYTEARRAY: case O_VOID:
-			return 1;
-		case O_N:
+  if ( !obj )
+    return 1;
+  switch ( OID(obj) ) {
+    case O_MATHCAP: case O_P: case O_R: case O_DP: case O_STR:
+    case O_ERR: case O_USINT: case O_BYTEARRAY: case O_VOID:
+      return 1;
+    case O_N:
       nid = NID((Num)obj);
-			if ( nid == N_Q || nid == N_R || nid == N_B )
-				return 1;
-			else
-				return 0;
-		case O_LIST:
-			for ( m = BDY((LIST)obj); m; m = NEXT(m) )
-				if ( !valid_as_cmo(BDY(m)) )
-					return 0;
-			return 1;
-		case O_QUOTE:
-			return 1;
-		default:
-			return 0;
-	}
+      if ( nid == N_Q || nid == N_R || nid == N_B )
+        return 1;
+      else
+        return 0;
+    case O_LIST:
+      for ( m = BDY((LIST)obj); m; m = NEXT(m) )
+        if ( !valid_as_cmo(BDY(m)) )
+          return 0;
+      return 1;
+    case O_QUOTE:
+      return 1;
+    default:
+      return 0;
+  }
 }
 
 void write_cmo(FILE *s,Obj obj)
 {
-	int r;
-	char errmsg[BUFSIZ];
-	LIST l;
+  int r;
+  char errmsg[BUFSIZ];
+  LIST l;
 
-	if ( !obj ) {
-		r = CMO_NULL; write_int(s,&r);
-		return;
-	}
-	switch ( OID(obj) ) {
-		case O_N:
-			switch ( NID((Num)obj) ) {
-				case N_Q:
-					write_cmo_q(s,(Q)obj);
-					break;
-				case N_R:
-					write_cmo_real(s,(Real)obj);
-					break;
+  if ( !obj ) {
+    r = CMO_NULL; write_int(s,&r);
+    return;
+  }
+  switch ( OID(obj) ) {
+    case O_N:
+      switch ( NID((Num)obj) ) {
+        case N_Q:
+          write_cmo_q(s,(Q)obj);
+          break;
+        case N_R:
+          write_cmo_real(s,(Real)obj);
+          break;
         case N_B:
-					write_cmo_bf(s,(BF)obj);
-					break;
-				default:
-					sprintf(errmsg, "write_cmo : number id=%d not implemented.",
-						NID((Num)obj));
-					error(errmsg);
-					break;
-			}
-			break;
-		case O_P:
-			write_cmo_p(s,(P)obj);
-			break;
-		case O_R:
-			write_cmo_r(s,(R)obj);
-			break;
-		case O_DP:
-			write_cmo_dp(s,(DP)obj);
-			break;
-		case O_LIST:
-			write_cmo_list(s,(LIST)obj);
-			break;
-		case O_STR:
-			write_cmo_string(s,(STRING)obj);
-			break;
-		case O_USINT:
-			write_cmo_uint(s,(USINT)obj);
-			break;
-		case O_MATHCAP:
-			write_cmo_mathcap(s,(MATHCAP)obj);
-			break;
-		case O_ERR:
-			write_cmo_error(s,(ERR)obj);
-			break;
-		case O_BYTEARRAY:
-			write_cmo_bytearray(s,(BYTEARRAY)obj);
-			break;
-		case O_VOID:
-			r = ((USINT)obj)->body; write_int(s,&r);
-			break;
-		case O_QUOTE:
-			fnodetotree(BDY((QUOTE)obj),&l);
-			write_cmo_tree(s,l);
-			break;
-		default:
-			sprintf(errmsg, "write_cmo : id=%d not implemented.",OID(obj));
-			error(errmsg);
-			break;
-	}
+          write_cmo_bf(s,(BF)obj);
+          break;
+        default:
+          sprintf(errmsg, "write_cmo : number id=%d not implemented.",
+            NID((Num)obj));
+          error(errmsg);
+          break;
+      }
+      break;
+    case O_P:
+      write_cmo_p(s,(P)obj);
+      break;
+    case O_R:
+      write_cmo_r(s,(R)obj);
+      break;
+    case O_DP:
+      write_cmo_dp(s,(DP)obj);
+      break;
+    case O_LIST:
+      write_cmo_list(s,(LIST)obj);
+      break;
+    case O_STR:
+      write_cmo_string(s,(STRING)obj);
+      break;
+    case O_USINT:
+      write_cmo_uint(s,(USINT)obj);
+      break;
+    case O_MATHCAP:
+      write_cmo_mathcap(s,(MATHCAP)obj);
+      break;
+    case O_ERR:
+      write_cmo_error(s,(ERR)obj);
+      break;
+    case O_BYTEARRAY:
+      write_cmo_bytearray(s,(BYTEARRAY)obj);
+      break;
+    case O_VOID:
+      r = ((USINT)obj)->body; write_int(s,&r);
+      break;
+    case O_QUOTE:
+      fnodetotree(BDY((QUOTE)obj),&l);
+      write_cmo_tree(s,l);
+      break;
+    default:
+      sprintf(errmsg, "write_cmo : id=%d not implemented.",OID(obj));
+      error(errmsg);
+      break;
+  }
 }
 
 int cmo_tag(Obj obj,int *tag)
 {
-	if ( !valid_as_cmo(obj) )
-		return 0;
-	if ( !obj ) {
-		*tag = CMO_NULL;
-		return 1;
-	}
-	switch ( OID(obj) ) {
-		case O_N:
-			switch ( NID((Num)obj) ) {
-				case N_Q:
-					*tag = DN((Q)obj) ? CMO_QQ : CMO_ZZ; break;
-				case N_R:
-					*tag = CMO_IEEE_DOUBLE_FLOAT; break;
+  if ( !valid_as_cmo(obj) )
+    return 0;
+  if ( !obj ) {
+    *tag = CMO_NULL;
+    return 1;
+  }
+  switch ( OID(obj) ) {
+    case O_N:
+      switch ( NID((Num)obj) ) {
+        case N_Q:
+          *tag = DN((Q)obj) ? CMO_QQ : CMO_ZZ; break;
+        case N_R:
+          *tag = CMO_IEEE_DOUBLE_FLOAT; break;
         case N_B:
-					*tag = CMO_BIGFLOAT; break;
-				default:
-					return 0;
-			}
-			break;
-		case O_P:
-			*tag = CMO_RECURSIVE_POLYNOMIAL; break;
-		case O_R:
-			*tag = CMO_RATIONAL; break;
-		case O_DP:
-			*tag = CMO_DISTRIBUTED_POLYNOMIAL; break;
-		case O_LIST:
-			*tag = CMO_LIST; break;
-		case O_STR:
-			*tag = CMO_STRING; break;
-		case O_USINT:
-			*tag = CMO_INT32; break;
-		case O_MATHCAP:
-			*tag = CMO_MATHCAP; break;
-		case O_ERR:
-			*tag = CMO_ERROR2; break;
-		case O_QUOTE:
-			*tag = CMO_TREE; break; break;
-		default:
-			return 0;
-	}
-	return 1;
+          *tag = CMO_BIGFLOAT; break;
+        default:
+          return 0;
+      }
+      break;
+    case O_P:
+      *tag = CMO_RECURSIVE_POLYNOMIAL; break;
+    case O_R:
+      *tag = CMO_RATIONAL; break;
+    case O_DP:
+      *tag = CMO_DISTRIBUTED_POLYNOMIAL; break;
+    case O_LIST:
+      *tag = CMO_LIST; break;
+    case O_STR:
+      *tag = CMO_STRING; break;
+    case O_USINT:
+      *tag = CMO_INT32; break;
+    case O_MATHCAP:
+      *tag = CMO_MATHCAP; break;
+    case O_ERR:
+      *tag = CMO_ERROR2; break;
+    case O_QUOTE:
+      *tag = CMO_TREE; break; break;
+    default:
+      return 0;
+  }
+  return 1;
 }
 
 void write_cmo_mathcap(FILE *s,MATHCAP mc)
 {
-	unsigned int r;
+  unsigned int r;
 
-	r = CMO_MATHCAP; write_int(s,&r);
-	write_cmo(s,(Obj)BDY(mc));
+  r = CMO_MATHCAP; write_int(s,&r);
+  write_cmo(s,(Obj)BDY(mc));
 }
 
 void write_cmo_uint(FILE *s,USINT ui)
 {
-	unsigned int r;
+  unsigned int r;
 
-	r = CMO_INT32; write_int(s,&r);
-	r = ui->body; write_int(s,&r);
+  r = CMO_INT32; write_int(s,&r);
+  r = ui->body; write_int(s,&r);
 }
 
 void write_cmo_q(FILE *s,Q q)
 {
-	int r;
+  int r;
 
-	if ( q && DN(q) ) {
-		r = CMO_QQ; write_int(s,&r);
-		write_cmo_zz(s,SGN(q),NM(q));	
-		write_cmo_zz(s,1,DN(q));	
-	} else {
-		r = CMO_ZZ; write_int(s,&r);
-		write_cmo_zz(s,SGN(q),NM(q));	
-	}
+  if ( q && DN(q) ) {
+    r = CMO_QQ; write_int(s,&r);
+    write_cmo_zz(s,SGN(q),NM(q));  
+    write_cmo_zz(s,1,DN(q));  
+  } else {
+    r = CMO_ZZ; write_int(s,&r);
+    write_cmo_zz(s,SGN(q),NM(q));  
+  }
 }
 
 void write_cmo_real(FILE *s,Real real)
 {
-	unsigned int r;
-	double dbl;
+  unsigned int r;
+  double dbl;
 
-	r = CMO_IEEE_DOUBLE_FLOAT; write_int(s,&r);
-	dbl = real->body; write_double(s,&dbl);
+  r = CMO_IEEE_DOUBLE_FLOAT; write_int(s,&r);
+  dbl = real->body; write_double(s,&dbl);
 }
 
 void write_cmo_bf(FILE *s,BF bf)
 {
-	unsigned int r;
-  int len,t;
-  L exp;	
+  unsigned int r,u,l;
+  int len,t,i;
+  L exp;  
+  UL *ptr;
 
-	r = CMO_BIGFLOAT; write_int(s,&r);
+  r = CMO_BIGFLOAT; write_int(s,&r);
   write_int(s,&MPFR_SIGN(bf->body));
   write_int(s,&MPFR_PREC(bf->body));
   exp = MPFR_EXP(bf->body);
   write_int64(s,&exp);
-	len = MPFR_LIMB_SIZE(bf->body);
-  write_int(s,&len);
+  len = MPFR_LIMB_SIZE(bf->body);
 #if SIZEOF_LONG == 4
-	write_intarray(s,MPFR_MANT(bf->body),len);
+  write_int(s,&len);
+  write_intarray(s,MPFR_MANT(bf->body),len);
 #else /* SIZEOF_LONG == 8 */
-	t = 2*len;
-	write_int(s,&t);
-	write_longarray(s,MPFR_MANT(bf->body),len);
+  t = 2*len;
+  write_int(s,&t);
+  ptr = (UL *)MPFR_MANT(bf->body);
+  for ( i = 0; i < len; i++ ) {
+	u = ptr[i]>>32;
+	l = ptr[i]&0xffffffff;
+    write_int(s,&u);
+    write_int(s,&l);
+  }
 #endif
 }
 
 void write_cmo_zz(FILE *s,int sgn,N n)
 {
-	int l,bytes;
+  int l,bytes;
 
 #if 1
-	l = PL(n);
-	bytes = sgn*l;
-	write_int(s,&bytes);
-	write_intarray(s,BD(n),l);
+  l = PL(n);
+  bytes = sgn*l;
+  write_int(s,&bytes);
+  write_intarray(s,BD(n),l);
 #else
-	l = PL(n); b = (unsigned int *)BD(n);
-	bytes = sgn*4*l;
-	write_int(s,&bytes);
-	for ( i = l-1; i >= 0; i-- ) {
-		t = b[i];
-		c = t>>24; write_char(s,&c);
-		c = (t>>16)&0xff; write_char(s,&c);
-		c = (t>>8)&0xff; write_char(s,&c);
-		c = t&0xff; write_char(s,&c);
-	}
+  l = PL(n); b = (unsigned int *)BD(n);
+  bytes = sgn*4*l;
+  write_int(s,&bytes);
+  for ( i = l-1; i >= 0; i-- ) {
+    t = b[i];
+    c = t>>24; write_char(s,&c);
+    c = (t>>16)&0xff; write_char(s,&c);
+    c = (t>>8)&0xff; write_char(s,&c);
+    c = t&0xff; write_char(s,&c);
+  }
 #endif
 }
 
 void write_cmo_p(FILE *s,P p)
 {
-	int r,i;
-	VL t,vl;
-	char *namestr;
-	STRING name;
+  int r,i;
+  VL t,vl;
+  char *namestr;
+  STRING name;
 
-	r = CMO_RECURSIVE_POLYNOMIAL; write_int(s,&r);
-	get_vars((Obj)p,&vl);
+  r = CMO_RECURSIVE_POLYNOMIAL; write_int(s,&r);
+  get_vars((Obj)p,&vl);
 
-	/* indeterminate list */
-	r = CMO_LIST; write_int(s,&r);
-	for ( t = vl, i = 0; t; t = NEXT(t), i++ );
-	write_int(s,&i);
-	r = CMO_INDETERMINATE;
-	for ( t = vl; t; t = NEXT(t) ) {
-		write_int(s,&r);
-/*		localname_to_cmoname(NAME(t->v),&namestr); */
-		namestr = NAME(t->v);
-		MKSTR(name,namestr);
-		write_cmo(s,(Obj)name);
-	}
+  /* indeterminate list */
+  r = CMO_LIST; write_int(s,&r);
+  for ( t = vl, i = 0; t; t = NEXT(t), i++ );
+  write_int(s,&i);
+  r = CMO_INDETERMINATE;
+  for ( t = vl; t; t = NEXT(t) ) {
+    write_int(s,&r);
+/*    localname_to_cmoname(NAME(t->v),&namestr); */
+    namestr = NAME(t->v);
+    MKSTR(name,namestr);
+    write_cmo(s,(Obj)name);
+  }
 
-	/* body */
-	write_cmo_upoly(s,vl,p);
+  /* body */
+  write_cmo_upoly(s,vl,p);
 }
 
 void write_cmo_upoly(FILE *s,VL vl,P p)
 {
-	int r,i;
-	V v;
-	DCP dc,dct;
-	VL vlt;
+  int r,i;
+  V v;
+  DCP dc,dct;
+  VL vlt;
 
-	if ( NUM(p) )
-		write_cmo(s,(Obj)p);
-	else {
-		r = CMO_UNIVARIATE_POLYNOMIAL; write_int(s,&r);
-		v = VR(p);
-		dc = DC(p);
-		for ( i = 0, dct = dc; dct; dct = NEXT(dct), i++ );
-		write_int(s,&i);
-		for ( i = 0, vlt = vl; vlt->v != v; vlt = NEXT(vlt), i++ );
-		write_int(s,&i);
-		for ( dct = dc; dct; dct = NEXT(dct) ) {
-			i = QTOS(DEG(dct)); write_int(s,&i);
-			write_cmo_upoly(s,vl,COEF(dct));
-		}
-	}
+  if ( NUM(p) )
+    write_cmo(s,(Obj)p);
+  else {
+    r = CMO_UNIVARIATE_POLYNOMIAL; write_int(s,&r);
+    v = VR(p);
+    dc = DC(p);
+    for ( i = 0, dct = dc; dct; dct = NEXT(dct), i++ );
+    write_int(s,&i);
+    for ( i = 0, vlt = vl; vlt->v != v; vlt = NEXT(vlt), i++ );
+    write_int(s,&i);
+    for ( dct = dc; dct; dct = NEXT(dct) ) {
+      i = QTOS(DEG(dct)); write_int(s,&i);
+      write_cmo_upoly(s,vl,COEF(dct));
+    }
+  }
 }
 
 void write_cmo_r(FILE *s,R f)
 {
-	int r;
+  int r;
 
-	r = CMO_RATIONAL; write_int(s,&r);
-	write_cmo(s,(Obj)NM(f));
-	write_cmo(s,(Obj)DN(f));
+  r = CMO_RATIONAL; write_int(s,&r);
+  write_cmo(s,(Obj)NM(f));
+  write_cmo(s,(Obj)DN(f));
 }
 
 void write_cmo_dp(FILE *s,DP dp)
 {
-	int i,n,nv,r;
-	MP m;
+  int i,n,nv,r;
+  MP m;
 
-	for ( n = 0, m = BDY(dp); m; m = NEXT(m), n++ );
-	r = CMO_DISTRIBUTED_POLYNOMIAL; write_int(s,&r);
-	r = n; write_int(s,&r);
-	r = CMO_DMS_GENERIC; write_int(s,&r);
-	nv = dp->nv;
-	for ( i = 0, m = BDY(dp); i < n; i++, m = NEXT(m) )
-		write_cmo_monomial(s,m,nv);
+  for ( n = 0, m = BDY(dp); m; m = NEXT(m), n++ );
+  r = CMO_DISTRIBUTED_POLYNOMIAL; write_int(s,&r);
+  r = n; write_int(s,&r);
+  r = CMO_DMS_GENERIC; write_int(s,&r);
+  nv = dp->nv;
+  for ( i = 0, m = BDY(dp); i < n; i++, m = NEXT(m) )
+    write_cmo_monomial(s,m,nv);
 }
 
 void write_cmo_monomial(FILE *s,MP m,int n)
 {
-	int i,r;
-	int *p;
+  int i,r;
+  int *p;
 
-	r = CMO_MONOMIAL32; write_int(s,&r);
-	write_int(s,&n);
-	for ( i = 0, p = m->dl->d; i < n; i++ ) {
-		write_int(s,p++);
-	}
-	write_cmo_q(s,(Q)m->c);
+  r = CMO_MONOMIAL32; write_int(s,&r);
+  write_int(s,&n);
+  for ( i = 0, p = m->dl->d; i < n; i++ ) {
+    write_int(s,p++);
+  }
+  write_cmo_q(s,(Q)m->c);
 }
 
 void write_cmo_list(FILE *s,LIST list)
 {
-	NODE m;
-	int i,n,r;
+  NODE m;
+  int i,n,r;
 
-	for ( n = 0, m = BDY(list); m; m = NEXT(m), n++ );
-	r = CMO_LIST; write_int(s,&r);
-	write_int(s,&n);
-	for ( i = 0, m = BDY(list); i < n; i++, m = NEXT(m) )
-		write_cmo(s,BDY(m));
+  for ( n = 0, m = BDY(list); m; m = NEXT(m), n++ );
+  r = CMO_LIST; write_int(s,&r);
+  write_int(s,&n);
+  for ( i = 0, m = BDY(list); i < n; i++, m = NEXT(m) )
+    write_cmo(s,BDY(m));
 }
 
 void write_cmo_string(FILE *s,STRING str)
 {
-	int r;
+  int r;
 
-	r = CMO_STRING; write_int(s,&r);
-	savestr(s,BDY(str));	
+  r = CMO_STRING; write_int(s,&r);
+  savestr(s,BDY(str));  
 }
 
 void write_cmo_bytearray(FILE *s,BYTEARRAY array)
 {
-	int r;
+  int r;
 
-	r = CMO_DATUM; write_int(s,&r);
-	write_int(s,&array->len);
-	write_string(s,array->body,array->len);
+  r = CMO_DATUM; write_int(s,&r);
+  write_int(s,&array->len);
+  write_string(s,array->body,array->len);
 }
 
 void write_cmo_error(FILE *s,ERR e)
 {
-	int r;
+  int r;
 
-	r = CMO_ERROR2; write_int(s,&r);
-	write_cmo(s,BDY(e));
+  r = CMO_ERROR2; write_int(s,&r);
+  write_cmo(s,BDY(e));
 }
 
 /* XXX */
@@ -417,208 +424,210 @@ void write_cmo_error(FILE *s,ERR e)
 
 void write_cmo_tree(FILE *s,LIST l)
 {
-	NODE n;
-	int r;
-	STRING prop,name,key;
+  NODE n;
+  int r;
+  STRING prop,name,key;
 
-	/* (CMO_TREE (CMO_LIST,n,key1,attr1,...,keyn,attn),(CMO_LIST,m,arg1,...,argm)) */
-	n = BDY(l);
-	prop = (STRING)BDY(n);	n = NEXT(n);
-	if ( !strcmp(BDY(prop),"internal") ) {
-		write_cmo(s,(Obj)BDY(n));
-	} else {
-		if ( strcmp(BDY(prop),"list") ) {
-			r = CMO_TREE; write_int(s,&r);
-			name = (STRING)BDY(n);
-			n = NEXT(n);
-			/* function name */
-			write_cmo(s,(Obj)name);
+  /* (CMO_TREE (CMO_LIST,n,key1,attr1,...,keyn,attn),(CMO_LIST,m,arg1,...,argm)) */
+  n = BDY(l);
+  prop = (STRING)BDY(n);  n = NEXT(n);
+  if ( !strcmp(BDY(prop),"internal") ) {
+    write_cmo(s,(Obj)BDY(n));
+  } else {
+    if ( strcmp(BDY(prop),"list") ) {
+      r = CMO_TREE; write_int(s,&r);
+      name = (STRING)BDY(n);
+      n = NEXT(n);
+      /* function name */
+      write_cmo(s,(Obj)name);
 
-			/* attribute list */
-			r = CMO_LIST; write_int(s,&r);
-			r = 2; write_int(s,&r);
-			MKSTR(key,"asir");
-			write_cmo(s,(Obj)key);
-			write_cmo(s,(Obj)prop);
-		}
+      /* attribute list */
+      r = CMO_LIST; write_int(s,&r);
+      r = 2; write_int(s,&r);
+      MKSTR(key,"asir");
+      write_cmo(s,(Obj)key);
+      write_cmo(s,(Obj)prop);
+    }
 
-		/* argument list */
-		r = CMO_LIST; write_int(s,&r);
-		/* len = number of arguments */
-		r = length(n); write_int(s,&r);
-		while ( n ) {
-			write_cmo_tree(s,BDY(n));
-			n = NEXT(n);
-		}
-	}
+    /* argument list */
+    r = CMO_LIST; write_int(s,&r);
+    /* len = number of arguments */
+    r = length(n); write_int(s,&r);
+    while ( n ) {
+      write_cmo_tree(s,BDY(n));
+      n = NEXT(n);
+    }
+  }
 }
 
 void read_cmo(FILE *s,Obj *rp)
 {
-	int id;
-	int sgn,dummy;
-	Q q;
-	N nm,dn;
-	P p,pnm,pdn;
-	Real real;
-	double dbl;
-	STRING str;
-	USINT t;
-	DP dp;
-	Obj obj;
-	ERR e;
+  int id;
+  int sgn,dummy;
+  Q q;
+  N nm,dn;
+  P p,pnm,pdn;
+  Real real;
+  double dbl;
+  STRING str;
+  USINT t;
+  DP dp;
+  Obj obj;
+  ERR e;
   BF bf;
-	MATHCAP mc;
-	BYTEARRAY array;
-	LIST list;
+  MATHCAP mc;
+  BYTEARRAY array;
+  LIST list;
 
-	read_int(s,&id);
-	switch ( id ) {
-	/* level 0 objects */
-		case CMO_NULL:
-			*rp = 0;
-			break;
-		case CMO_INT32:
-			read_cmo_uint(s,&t); *rp = (Obj)t;
-			break;
-		case CMO_DATUM:
-			loadbytearray(s,&array); *rp = (Obj)array;
-			break;
-		case CMO_STRING:
-			loadstring(s,&str); *rp = (Obj)str;
-			break;
-		case CMO_MATHCAP:
-			read_cmo(s,&obj); MKMATHCAP(mc,(LIST)obj);
-			*rp = (Obj)mc;
-			break;
-		case CMO_ERROR:
-			MKERR(e,0); *rp = (Obj)e;
-			break;
-		case CMO_ERROR2:
-			read_cmo(s,&obj); MKERR(e,obj); *rp = (Obj)e;
-			break;
-	/* level 1 objects */
-		case CMO_LIST:
-			read_cmo_list(s,rp);
-			break;
-		case CMO_MONOMIAL32:
-			read_cmo_monomial(s,&dp); *rp = (Obj)dp;
-			break;
-		case CMO_ZZ:
-			read_cmo_zz(s,&sgn,&nm);
-			NTOQ(nm,sgn,q); *rp = (Obj)q;
-			break;
-		case CMO_QQ:
-			read_cmo_zz(s,&sgn,&nm);
-			read_cmo_zz(s,&dummy,&dn);
-			NDTOQ(nm,dn,sgn,q); *rp = (Obj)q;
-			break;
-		case CMO_IEEE_DOUBLE_FLOAT:
-			read_double(s,&dbl); MKReal(dbl,real); *rp = (Obj)real;
-			break;
-		case CMO_BIGFLOAT:
-			read_cmo_bf(s,&bf); *rp = (Obj)bf;
-			break;
-		case CMO_DISTRIBUTED_POLYNOMIAL:
-			read_cmo_dp(s,&dp); *rp = (Obj)dp;
-			break;
-		case CMO_RECURSIVE_POLYNOMIAL:
-			read_cmo_p(s,&p); *rp = (Obj)p;
-			break;
-		case CMO_UNIVARIATE_POLYNOMIAL:
-			read_cmo_upoly(s,&p); *rp = (Obj)p;
-			break;
-		case CMO_INDETERMINATE:
-			read_cmo(s,rp);
-			break;
-		case CMO_RATIONAL:
-			read_cmo(s,&obj); pnm = (P)obj;
-			read_cmo(s,&obj); pdn = (P)obj;
-			divr(CO,(Obj)pnm,(Obj)pdn,rp);
-			break;
-		case CMO_ZERO:
-			*rp = 0;
-			break;
-		case CMO_DMS_OF_N_VARIABLES:
-			read_cmo(s,rp);
-			break;
-		case CMO_RING_BY_NAME:
-			read_cmo(s,rp);
-			break;
-		case CMO_TREE:
-			read_cmo_tree_as_list(s,&list);
+  read_int(s,&id);
+  switch ( id ) {
+  /* level 0 objects */
+    case CMO_NULL:
+      *rp = 0;
+      break;
+    case CMO_INT32:
+      read_cmo_uint(s,&t); *rp = (Obj)t;
+      break;
+    case CMO_DATUM:
+      loadbytearray(s,&array); *rp = (Obj)array;
+      break;
+    case CMO_STRING:
+      loadstring(s,&str); *rp = (Obj)str;
+      break;
+    case CMO_MATHCAP:
+      read_cmo(s,&obj); MKMATHCAP(mc,(LIST)obj);
+      *rp = (Obj)mc;
+      break;
+    case CMO_ERROR:
+      MKERR(e,0); *rp = (Obj)e;
+      break;
+    case CMO_ERROR2:
+      read_cmo(s,&obj); MKERR(e,obj); *rp = (Obj)e;
+      break;
+  /* level 1 objects */
+    case CMO_LIST:
+      read_cmo_list(s,rp);
+      break;
+    case CMO_MONOMIAL32:
+      read_cmo_monomial(s,&dp); *rp = (Obj)dp;
+      break;
+    case CMO_ZZ:
+      read_cmo_zz(s,&sgn,&nm);
+      NTOQ(nm,sgn,q); *rp = (Obj)q;
+      break;
+    case CMO_QQ:
+      read_cmo_zz(s,&sgn,&nm);
+      read_cmo_zz(s,&dummy,&dn);
+      NDTOQ(nm,dn,sgn,q); *rp = (Obj)q;
+      break;
+    case CMO_IEEE_DOUBLE_FLOAT:
+      read_double(s,&dbl); MKReal(dbl,real); *rp = (Obj)real;
+      break;
+    case CMO_BIGFLOAT:
+      read_cmo_bf(s,&bf); *rp = (Obj)bf;
+      break;
+    case CMO_DISTRIBUTED_POLYNOMIAL:
+      read_cmo_dp(s,&dp); *rp = (Obj)dp;
+      break;
+    case CMO_RECURSIVE_POLYNOMIAL:
+      read_cmo_p(s,&p); *rp = (Obj)p;
+      break;
+    case CMO_UNIVARIATE_POLYNOMIAL:
+      read_cmo_upoly(s,&p); *rp = (Obj)p;
+      break;
+    case CMO_INDETERMINATE:
+      read_cmo(s,rp);
+      break;
+    case CMO_RATIONAL:
+      read_cmo(s,&obj); pnm = (P)obj;
+      read_cmo(s,&obj); pdn = (P)obj;
+      divr(CO,(Obj)pnm,(Obj)pdn,rp);
+      break;
+    case CMO_ZERO:
+      *rp = 0;
+      break;
+    case CMO_DMS_OF_N_VARIABLES:
+      read_cmo(s,rp);
+      break;
+    case CMO_RING_BY_NAME:
+      read_cmo(s,rp);
+      break;
+    case CMO_TREE:
+      read_cmo_tree_as_list(s,&list);
 #if 0
-			treetofnode(list,&fn);
-			MKQUOTE(quote,fn);
-			*rp = (Obj)quote;
+      treetofnode(list,&fn);
+      MKQUOTE(quote,fn);
+      *rp = (Obj)quote;
 #else
-			*rp = (Obj)list;
+      *rp = (Obj)list;
 #endif
-			break;
-		default:
-			MKUSINT(t,id);
-			t->id = O_VOID;
-			*rp = (Obj)t;
-			break;
-	}
+      break;
+    default:
+      MKUSINT(t,id);
+      t->id = O_VOID;
+      *rp = (Obj)t;
+      break;
+  }
 }
 
 void read_cmo_uint(FILE *s,USINT *rp)
 {
-	unsigned int body;
+  unsigned int body;
 
-	read_int(s,&body);
-	MKUSINT(*rp,body);
+  read_int(s,&body);
+  MKUSINT(*rp,body);
 }
 
 void read_cmo_zz(FILE *s,int *sgn,N *rp)
 {
-	int l;
-	N n;
+  int l;
+  N n;
 
-	read_int(s,&l);
-	if ( l == 0 ) {
-		*sgn = 0;
-		*rp = 0;
-		return;
-	}
-	if ( l < 0 ) {
-		*sgn = -1; l = -l;
-	} else
-		*sgn = 1; 
+  read_int(s,&l);
+  if ( l == 0 ) {
+    *sgn = 0;
+    *rp = 0;
+    return;
+  }
+  if ( l < 0 ) {
+    *sgn = -1; l = -l;
+  } else
+    *sgn = 1; 
 #if 1
-	*rp = n = NALLOC(l); PL(n) = l;
-	read_intarray(s,BD(n),l);
+  *rp = n = NALLOC(l); PL(n) = l;
+  read_intarray(s,BD(n),l);
 #else
-	words = (l+3)/4;
-	*rp = n = NALLOC(words); PL(n) = words; b = BD(n);
-	h = 0;
-	switch ( l % 4 ) {
-		case 0:
-			read_char(s,&c); h = c;
-		case 3:
-			read_char(s,&c); h = (h<<8)|c;
-		case 2:
-			read_char(s,&c); h = (h<<8)|c;
-		case 1:
-			read_char(s,&c); h = (h<<8)|c;
-	}
-	b[words-1] = h;
-	for ( i = words-2; i >= 0; i-- ) {
-		read_char(s,&c); h = c;
-		read_char(s,&c); h = (h<<8)|c;
-		read_char(s,&c); h = (h<<8)|c;
-		read_char(s,&c); h = (h<<8)|c;
-		b[i] = h;
-	}
+  words = (l+3)/4;
+  *rp = n = NALLOC(words); PL(n) = words; b = BD(n);
+  h = 0;
+  switch ( l % 4 ) {
+    case 0:
+      read_char(s,&c); h = c;
+    case 3:
+      read_char(s,&c); h = (h<<8)|c;
+    case 2:
+      read_char(s,&c); h = (h<<8)|c;
+    case 1:
+      read_char(s,&c); h = (h<<8)|c;
+  }
+  b[words-1] = h;
+  for ( i = words-2; i >= 0; i-- ) {
+    read_char(s,&c); h = c;
+    read_char(s,&c); h = (h<<8)|c;
+    read_char(s,&c); h = (h<<8)|c;
+    read_char(s,&c); h = (h<<8)|c;
+    b[i] = h;
+  }
 #endif
 }
 
 void read_cmo_bf(FILE *s,BF *bf)
 {
-	BF r;
-  int sgn,prec,len;
-  L exp;	
+  BF r;
+  int sgn,prec,len,i;
+  unsigned int u,l;
+  UL *ptr;
+  L exp;  
 
   NEWBF(r);
   read_int(s,&sgn);
@@ -629,142 +638,148 @@ void read_cmo_bf(FILE *s,BF *bf)
   MPFR_SIGN(r->body) = sgn;
   MPFR_EXP(r->body) = exp;
 #if SIZEOF_LONG == 4
-	read_intarray(s,MPFR_MANT(r->body),len);
+  read_intarray(s,MPFR_MANT(r->body),len);
 #else /* SIZEOF_LONG == 8 */
-	read_longarray(s,MPFR_MANT(r->body),len>>1);
+  len >>= 1;
+  ptr = (UL *)MPFR_MANT(r->body);
+  for ( i = 0; i < len; i++ ) {
+    read_int(s,&u);
+    read_int(s,&l);
+    ptr[i] = ((UL)u)<<32|((UL)l)&0xffffffff;
+  }
 #endif
   *bf = r;
 }
 
 void read_cmo_list(FILE *s,Obj *rp)
 {
-	int len;
-	Obj *w;
-	int i;
-	NODE n0,n1;
-	LIST list;
+  int len;
+  Obj *w;
+  int i;
+  NODE n0,n1;
+  LIST list;
 
-	read_int(s,&len);
-	w = (Obj *)ALLOCA(len*sizeof(Obj));
-	for ( i = 0; i < len; i++ )
-		read_cmo(s,&w[i]);		
-	for ( i = len-1, n0 = 0; i >= 0; i-- ) {
-		MKNODE(n1,w[i],n0); n0 = n1;
-	}
-	MKLIST(list,n0);
-	*rp = (Obj)list;
+  read_int(s,&len);
+  w = (Obj *)ALLOCA(len*sizeof(Obj));
+  for ( i = 0; i < len; i++ )
+    read_cmo(s,&w[i]);    
+  for ( i = len-1, n0 = 0; i >= 0; i-- ) {
+    MKNODE(n1,w[i],n0); n0 = n1;
+  }
+  MKLIST(list,n0);
+  *rp = (Obj)list;
 }
 
 void read_cmo_dp(FILE *s,DP *rp)
 {
-	int len;
-	int i;
-	MP mp0,mp;
-	int nv,d;
-	DP dp;
-	Obj obj;
+  int len;
+  int i;
+  MP mp0,mp;
+  int nv,d;
+  DP dp;
+  Obj obj;
 
-	read_int(s,&len);
-	/* skip the ring definition */
-	read_cmo(s,&obj);
-	for ( mp0 = 0, i = 0, d = 0; i < len; i++ ) {
-		read_cmo(s,&obj); dp = (DP)obj;
-		if ( !mp0 ) {
-			nv = dp->nv;
-			mp0 = dp->body;
-			mp = mp0;
-		} else {
-			NEXT(mp) = dp->body;
-			mp = NEXT(mp);
-		}
-		d = MAX(d,dp->sugar);
-	}
-	MKDP(nv,mp0,dp);
-	dp->sugar = d; *rp = dp;
+  read_int(s,&len);
+  /* skip the ring definition */
+  read_cmo(s,&obj);
+  for ( mp0 = 0, i = 0, d = 0; i < len; i++ ) {
+    read_cmo(s,&obj); dp = (DP)obj;
+    if ( !mp0 ) {
+      nv = dp->nv;
+      mp0 = dp->body;
+      mp = mp0;
+    } else {
+      NEXT(mp) = dp->body;
+      mp = NEXT(mp);
+    }
+    d = MAX(d,dp->sugar);
+  }
+  MKDP(nv,mp0,dp);
+  dp->sugar = d; *rp = dp;
 }
 
 void read_cmo_monomial(FILE *s,DP *rp)
 {
-	Obj obj;
-	MP m;
-	DP dp;
-	int i,sugar,n;
-	DL dl;
+  Obj obj;
+  MP m;
+  DP dp;
+  int i,sugar,n;
+  DL dl;
 
-	read_int(s,&n);
-	NEWMP(m); NEWDL(dl,n); m->dl = dl;
-	read_intarray(s,dl->d,n);
-	for ( sugar = 0, i = 0; i < n; i++ )
-		sugar += dl->d[i];
-	dl->td = sugar;
-	read_cmo(s,&obj); m->c = (P)obj;
-	NEXT(m) = 0; MKDP(n,m,dp); dp->sugar = sugar; *rp = dp;
+  read_int(s,&n);
+  NEWMP(m); NEWDL(dl,n); m->dl = dl;
+  read_intarray(s,dl->d,n);
+  for ( sugar = 0, i = 0; i < n; i++ )
+    sugar += dl->d[i];
+  dl->td = sugar;
+  read_cmo(s,&obj); m->c = (P)obj;
+  NEXT(m) = 0; MKDP(n,m,dp); dp->sugar = sugar; *rp = dp;
 }
 
 static V *remote_vtab;
 
 void read_cmo_p(FILE *s,P *rp)
 {
-	Obj obj;
-	LIST vlist;
-	int nv,i;
-	V *vtab;
-	V v1,v2;
-	NODE t;
-	P v,p;
-	VL tvl,rvl;
-	char *name;
+  Obj obj;
+  LIST vlist;
+  int nv,i;
+  V *vtab;
+  V v1,v2;
+  NODE t;
+  P v,p;
+  VL tvl,rvl;
+  char *name;
 
-	read_cmo(s,&obj); vlist = (LIST)obj;
-	nv = length(BDY(vlist));
-	vtab = (V *)ALLOCA(nv*sizeof(V));
-	for ( i = 0, t = BDY(vlist); i < nv; t = NEXT(t), i++ ) {
-/*		cmoname_to_localname(BDY((STRING)BDY(t)),&name); */
-		name = BDY((STRING)BDY(t));
-		makevar(name,&v); vtab[i] = VR(v);
-	}
-	remote_vtab = vtab;
-	read_cmo(s,&obj); p = (P)obj;
-	for ( i = 0; i < nv-1; i++ ) {
-		v1 = vtab[i]; v2 = vtab[i+1];
-		for ( tvl = CO; tvl->v != v1 && tvl->v != v2; tvl = NEXT(tvl) );
-		if ( tvl->v == v2 )
-			break;
-	}
-	if ( i < nv-1 ) {
-		 for ( i = nv-1, rvl = 0; i >= 0; i-- ) {
-			NEWVL(tvl); tvl->v = vtab[i]; NEXT(tvl) = rvl; rvl = tvl;
-		 }
-		 reorderp(CO,rvl,p,rp);
-	} else
-		*rp = p;
+  read_cmo(s,&obj); vlist = (LIST)obj;
+  nv = length(BDY(vlist));
+  vtab = (V *)ALLOCA(nv*sizeof(V));
+  for ( i = 0, t = BDY(vlist); i < nv; t = NEXT(t), i++ ) {
+/*    cmoname_to_localname(BDY((STRING)BDY(t)),&name); */
+    name = BDY((STRING)BDY(t));
+    makevar(name,&v); vtab[i] = VR(v);
+  }
+  remote_vtab = vtab;
+  read_cmo(s,&obj); p = (P)obj;
+  for ( i = 0; i < nv-1; i++ ) {
+    v1 = vtab[i]; v2 = vtab[i+1];
+    for ( tvl = CO; tvl->v != v1 && tvl->v != v2; tvl = NEXT(tvl) );
+    if ( tvl->v == v2 )
+      break;
+  }
+  if ( i < nv-1 ) {
+     for ( i = nv-1, rvl = 0; i >= 0; i-- ) {
+      NEWVL(tvl); tvl->v = vtab[i]; NEXT(tvl) = rvl; rvl = tvl;
+     }
+     reorderp(CO,rvl,p,rp);
+  } else
+    *rp = p;
 }
 
 void read_cmo_upoly(FILE *s,P *rp)
 {
-	int n,ind,i,d;
-	Obj obj;
-	P c;
-	Q q;
-	DCP dc0,dc;
+  int n,ind,i,d;
+  Obj obj;
+  P c;
+  Q q;
+  DCP dc0,dc;
 
-	read_int(s,&n);
-	read_int(s,&ind);
-	for ( i = 0, dc0 = 0; i < n; i++ ) {
-		read_int(s,&d);
-		read_cmo(s,&obj); c = (P)obj;
-		if ( c ) {
-			if ( OID(c) == O_USINT ) {
-				UTOQ(((USINT)c)->body,q); c = (P)q;
-			}
-			NEXTDC(dc0,dc); 
-			STOQ(d,q);
-			dc->c = c; dc->d = q;
-		}
-	}
-	if ( dc0 )
-		NEXT(dc) = 0;
-	MKP(remote_vtab[ind],dc0,*rp);
+  read_int(s,&n);
+  read_int(s,&ind);
+  for ( i = 0, dc0 = 0; i < n; i++ ) {
+    read_int(s,&d);
+    read_cmo(s,&obj); c = (P)obj;
+    if ( c ) {
+      if ( OID(c) == O_USINT ) {
+        UTOQ(((USINT)c)->body,q); c = (P)q;
+      }
+      NEXTDC(dc0,dc); 
+      STOQ(d,q);
+      dc->c = c; dc->d = q;
+    }
+  }
+  if ( dc0 )
+    NEXT(dc) = 0;
+  MKP(remote_vtab[ind],dc0,*rp);
 }
 
 /* XXX */
@@ -772,28 +787,28 @@ void read_cmo_upoly(FILE *s,P *rp)
 extern struct oARF arf[];
 
 struct operator_tab {
-	char *name;
-	fid id;	
-	ARF arf;
-	cid cid;
+  char *name;
+  fid id;  
+  ARF arf;
+  cid cid;
 };
 
 static struct operator_tab optab[] = {
-	{"+",I_BOP,&arf[0],0}, /* XXX */
-	{"-",I_BOP,&arf[1],0},
-	{"*",I_BOP,&arf[2],0},
-	{"/",I_BOP,&arf[3],0},
-	{"%",I_BOP,&arf[4],0},
-	{"^",I_BOP,&arf[5],0},
-	{"==",I_COP,0,C_EQ},
-	{"!=",I_COP,0,C_NE},
-	{"<",I_COP,0,C_LT},
-	{"<=",I_COP,0,C_LE},
-	{">",I_COP,0,C_GT},
-	{">=",I_COP,0,C_GE},
-	{"&&",I_AND,0,0},
-	{"||",I_OR,0,0},
-	{"!",I_NOT,0,0},
+  {"+",I_BOP,&arf[0],0}, /* XXX */
+  {"-",I_BOP,&arf[1],0},
+  {"*",I_BOP,&arf[2],0},
+  {"/",I_BOP,&arf[3],0},
+  {"%",I_BOP,&arf[4],0},
+  {"^",I_BOP,&arf[5],0},
+  {"==",I_COP,0,C_EQ},
+  {"!=",I_COP,0,C_NE},
+  {"<",I_COP,0,C_LT},
+  {"<=",I_COP,0,C_LE},
+  {">",I_COP,0,C_GT},
+  {">=",I_COP,0,C_GE},
+  {"&&",I_AND,0,0},
+  {"||",I_OR,0,0},
+  {"!",I_NOT,0,0},
 };
 
 static int optab_len = sizeof(optab)/sizeof(struct operator_tab);
@@ -804,131 +819,131 @@ void read_cmo_tree(s,rp)
 FILE *s;
 FNODE *rp;
 {
-	int r,i,n;
-	char *opname;
-	STRING name,cd;
-	int op;
-	pointer *arg;
-	QUOTE quote;
-	FNODE fn;
-	NODE t,t1;
-	fid id;
-	Obj expr;
-	FUNC func;
+  int r,i,n;
+  char *opname;
+  STRING name,cd;
+  int op;
+  pointer *arg;
+  QUOTE quote;
+  FNODE fn;
+  NODE t,t1;
+  fid id;
+  Obj expr;
+  FUNC func;
 
-	read_cmo(s,&name);
-	read_cmo(s,&attr);
-	for ( i = 0; i < optab_len; i++ )
-		if ( !strcmp(optab[i].name,BDY(name)) )
-			break;
-	if ( i == optab_len ) {
-		/* may be a function name */
-		n = read_cmo_tree_arg(s,&arg);
-		for ( i = n-1, t = 0; i >= 0; i-- ) {
-			MKNODE(t1,arg[i],t); t = t1;		
-		}
-		searchf(sysf,BDY(name),&func); 
-		if ( !func )
-			searchf(ubinf,BDY(name),&func);
-		if ( !func )
-			searchpf(BDY(name),&func);
-		if ( !func )
-			searchf(usrf,BDY(name),&func);
-		if ( !func )
-			appenduf(BDY(name),&func);
-		*rp = mkfnode(2,I_FUNC,func,mkfnode(1,I_LIST,t));
-	} else {
-		opname = optab[i].name;
-		id = optab[i].id;
-		switch ( id ) {
-			case I_BOP:
-				read_cmo_tree_arg(s,&arg);
-				*rp = mkfnode(3,I_BOP,optab[i].arf,arg[0],arg[1]);
-				return;
-			case I_COP:
-				read_cmo_tree_arg(s,&arg);
-				*rp = mkfnode(3,I_COP,optab[i].cid,arg[0],arg[0]);
-				return;
-			case I_AND:
-				read_cmo_tree_arg(s,&arg);
-				*rp = mkfnode(2,I_AND,arg[0],arg[1]);
-				return;
-			case I_OR:
-				read_cmo_tree_arg(s,&arg);
-				*rp = mkfnode(2,I_OR,arg[0],arg[1]);
-				return;
-			case I_NOT:
-				read_cmo_tree_arg(s,&arg);
-				*rp = mkfnode(1,I_OR,arg[0]);
-				return;
-		}
-	}
+  read_cmo(s,&name);
+  read_cmo(s,&attr);
+  for ( i = 0; i < optab_len; i++ )
+    if ( !strcmp(optab[i].name,BDY(name)) )
+      break;
+  if ( i == optab_len ) {
+    /* may be a function name */
+    n = read_cmo_tree_arg(s,&arg);
+    for ( i = n-1, t = 0; i >= 0; i-- ) {
+      MKNODE(t1,arg[i],t); t = t1;    
+    }
+    searchf(sysf,BDY(name),&func); 
+    if ( !func )
+      searchf(ubinf,BDY(name),&func);
+    if ( !func )
+      searchpf(BDY(name),&func);
+    if ( !func )
+      searchf(usrf,BDY(name),&func);
+    if ( !func )
+      appenduf(BDY(name),&func);
+    *rp = mkfnode(2,I_FUNC,func,mkfnode(1,I_LIST,t));
+  } else {
+    opname = optab[i].name;
+    id = optab[i].id;
+    switch ( id ) {
+      case I_BOP:
+        read_cmo_tree_arg(s,&arg);
+        *rp = mkfnode(3,I_BOP,optab[i].arf,arg[0],arg[1]);
+        return;
+      case I_COP:
+        read_cmo_tree_arg(s,&arg);
+        *rp = mkfnode(3,I_COP,optab[i].cid,arg[0],arg[0]);
+        return;
+      case I_AND:
+        read_cmo_tree_arg(s,&arg);
+        *rp = mkfnode(2,I_AND,arg[0],arg[1]);
+        return;
+      case I_OR:
+        read_cmo_tree_arg(s,&arg);
+        *rp = mkfnode(2,I_OR,arg[0],arg[1]);
+        return;
+      case I_NOT:
+        read_cmo_tree_arg(s,&arg);
+        *rp = mkfnode(1,I_OR,arg[0]);
+        return;
+    }
+  }
 }
 
 int read_cmo_tree_arg(s,argp)
 FILE *s;
 pointer **argp;
 {
-	int id,n,i;
-	pointer *ap;
-	Obj t;
+  int id,n,i;
+  pointer *ap;
+  Obj t;
 
-	read_int(s,&id); /* id = CMO_LIST */
-	read_int(s,&n); /* n = the number of args */
-	*argp = ap = (pointer *) MALLOC(n*sizeof(pointer));
-	for ( i = 0; i < n; i++ ) {
-		read_cmo(s,&t);
-		if ( !t || (OID(t) != O_QUOTE) )
-			ap[i] = mkfnode(1,I_FORMULA,t);
-		else
-			ap[i] = BDY((QUOTE)t);
-	}
-	return n;
+  read_int(s,&id); /* id = CMO_LIST */
+  read_int(s,&n); /* n = the number of args */
+  *argp = ap = (pointer *) MALLOC(n*sizeof(pointer));
+  for ( i = 0; i < n; i++ ) {
+    read_cmo(s,&t);
+    if ( !t || (OID(t) != O_QUOTE) )
+      ap[i] = mkfnode(1,I_FORMULA,t);
+    else
+      ap[i] = BDY((QUOTE)t);
+  }
+  return n;
 }
 #else
 void read_cmo_tree_as_list(FILE *s,LIST *rp)
 {
-	Obj obj;
-	STRING name;
-	LIST attr,args;
-	NODE t0,t1;
+  Obj obj;
+  STRING name;
+  LIST attr,args;
+  NODE t0,t1;
 
-	read_cmo(s,&obj); name = (STRING)obj;
-	read_cmo(s,&obj); attr = (LIST)obj;
-	read_cmo(s,&obj); args = (LIST)obj;
-	MKNODE(t1,name,BDY(args));
-	MKNODE(t0,attr,t1);
-	MKLIST(*rp,t0);
+  read_cmo(s,&obj); name = (STRING)obj;
+  read_cmo(s,&obj); attr = (LIST)obj;
+  read_cmo(s,&obj); args = (LIST)obj;
+  MKNODE(t1,name,BDY(args));
+  MKNODE(t0,attr,t1);
+  MKLIST(*rp,t0);
 }
 #endif
 
 void localname_to_cmoname(char *a,char **b)
 {
-	int l;
-	char *t;
+  int l;
+  char *t;
 
-	l = strlen(a);
-	if ( l >= 2 && a[0] == '@' && isupper(a[1]) ) {
-		t = *b = (char *)MALLOC_ATOMIC(l);
-		strcpy(t,a+1);
-	} else {
-		t = *b = (char *)MALLOC_ATOMIC(l+1);
-		strcpy(t,a);
-	}
+  l = strlen(a);
+  if ( l >= 2 && a[0] == '@' && isupper(a[1]) ) {
+    t = *b = (char *)MALLOC_ATOMIC(l);
+    strcpy(t,a+1);
+  } else {
+    t = *b = (char *)MALLOC_ATOMIC(l+1);
+    strcpy(t,a);
+  }
 }
 
 void cmoname_to_localname(char *a,char **b)
 {
-	int l;
-	char *t;
+  int l;
+  char *t;
 
-	l = strlen(a);
-	if ( isupper(a[0]) ) {
-		t = *b = (char *)MALLOC_ATOMIC(l+2);
-		strcpy(t+1,a);
-		t[0] = '@';
-	} else {
-		t = *b = (char *)MALLOC_ATOMIC(l+1);
-		strcpy(t,a);
-	}
+  l = strlen(a);
+  if ( isupper(a[0]) ) {
+    t = *b = (char *)MALLOC_ATOMIC(l+2);
+    strcpy(t+1,a);
+    t[0] = '@';
+  } else {
+    t = *b = (char *)MALLOC_ATOMIC(l+1);
+    strcpy(t,a);
+  }
 }