*** lib/erl_interface/src/ei_printterm.c	Mon Oct  8 11:01:45 2001
--- ../otp_src_R8B-1.fixed/lib/erl_interface/src/ei_printterm.c	Tue Jun 18 12:51:14 2002
***************
*** 84,85 ****
--- 84,110 ----
  
+ static char *erl_big_to_str(erlang_big *b)
+ {
+     int buf_len;
+     char *s,*buf;
+     unsigned short *sp;
+     int i;
+ 
+     buf_len = 64+b->is_neg+10*b->arity;
+     if ( (buf=erl_malloc(buf_len)) == NULL) return NULL;
+ 
+     memset(buf,(char)0,buf_len);
+ 
+     s = buf;
+     if ( b->is_neg ) 
+         s += sprintf(s,"-");
+     s += sprintf(s,"#integer(%d) = {",b->arity);
+     for(sp=b->digits,i=0;i<b->arity;i++) {
+         s += sprintf(s,"%d",sp[i]);
+         if ( (i+1) != b->arity ) 
+             s += sprintf(s,",");
+     }
+     s += sprintf(s,"}");
+     return buf;
+ }
+ 
  static int print_term(FILE* fp, ei_x_buff* x,
***************
*** 95,97 ****
      long l;
!     unsigned long u;
  
--- 120,122 ----
      long l;
!     //unsigned long u;
  
***************
*** 208,216 ****
      case ERL_SMALL_BIG_EXT:
- 	if (ei_decode_ulong(buf, index, &u) < 0) goto err;
- 	ch_written += xprintf(fp, x, "%lu", u);
- 	break;
      case ERL_LARGE_BIG_EXT:
! 	ch_written += xprintf(fp, x, "BigNum");
! 	*index += n;
! 	break;
      case ERL_FLOAT_EXT:
--- 233,257 ----
      case ERL_SMALL_BIG_EXT:
      case ERL_LARGE_BIG_EXT:
!         {
!             erlang_big *b;
!             char *ds;
! 
!             b = ei_alloc_big(n);
!             if (ei_decode_big(buf, index, b) < 0) {
!                 ei_free_big(b);
!                 goto err;
!             }
!             
!             if ( (ds = erl_big_to_str(b)) == NULL ) {
!                 ei_free_big(b);
!                 goto err;
!             }
!             
!             ch_written += xprintf(fp, x, ds);
!             erl_free(ds);
!             ei_free_big(b);
!             
!         }
!         break;
! 
      case ERL_FLOAT_EXT:
***************
*** 340,345 ****
      case ERL_SMALL_BIG_EXT:
- 	if (ei_decode_ulong(buf, index, NULL) < 0) goto err;
- 	break;
      case ERL_LARGE_BIG_EXT:
! 	*index += n; /* !! Funkar detta? */
  	break;
--- 381,384 ----
      case ERL_SMALL_BIG_EXT:
      case ERL_LARGE_BIG_EXT:
!         if (ei_decode_big(buf,index,NULL) < 0) goto err;
  	break;
*** lib/erl_interface/src/eicode.h	Mon Oct  8 10:43:59 2001
--- ../otp_src_R8B-1.fixed/lib/erl_interface/src/eicode.h	Tue Jun 18 12:54:26 2002
***************
*** 84,85 ****
--- 84,91 ----
  
+ typedef struct {
+     unsigned arity;
+     int      is_neg;
+     void    *digits;
+ } erlang_big;
+ 
  /*
***************
*** 170,171 ****
--- 176,186 ----
  extern void free_fun(erlang_fun* f);
+ 
+ extern int ei_decode_big(const char *buf, int *index, erlang_big* p);
+ 
+ /* FIXME: should probably be moved */
+ extern erlang_big *ei_alloc_big(int arity);
+ extern void ei_free_big(erlang_big *b);
+ extern int ei_big_comp(erlang_big *x, erlang_big *y);
+ extern int ei_big_to_double(erlang_big *b, double *resp);
+ extern int ei_small_to_big(int small, erlang_big *b);
  
*** lib/erl_interface/src/erl_eterm.h	Mon Oct  8 10:29:05 2001
--- ../otp_src_R8B-1.fixed/lib/erl_interface/src/erl_eterm.h	Tue Jun 18 12:57:57 2002
***************
*** 48,49 ****
--- 48,50 ----
  #define ERL_FUNCTION    (15 | ERL_COMPOUND)
+ #define ERL_BIG         16
  
***************
*** 124,125 ****
--- 125,133 ----
  
+ typedef struct _big {
+   Erl_Header h;
+   int arity;
+   int is_neg;
+   unsigned short *digits;
+ } Erl_Big;
+ 
  /* Variables may only exist in patterns. 
***************
*** 165,166 ****
--- 173,175 ----
      Erl_Function  funcval;
+     Erl_Big       bigval;
    } uval;
***************
*** 233,234 ****
--- 242,248 ----
  
+ #define ERL_BIG_ARITY(x)     ((x)->uval.bigval.arity)
+ #define ERL_BIG_IS_NEG(x)    ((x)->uval.bigval.is_neg)
+ #define ERL_BIG_DIGITS(x)    ((x)->uval.bigval.digits)
+ #define ERL_BIG_DIGIT(x,i)   (ERL_BIG_DIGITS(x)[(i)])
+ 
  /*
***************
*** 253,254 ****
--- 267,269 ----
  #define ERL_IS_FUNCTION(x) (ERL_TYPE(x) == ERL_FUNCTION)
+ #define ERL_IS_BIG(x)      (ERL_TYPE(x) == ERL_BIG)
  
*** lib/erl_interface/src/erl_marshal.c	Mon Oct  8 10:29:12 2001
--- ../otp_src_R8B-1.fixed/lib/erl_interface/src/erl_marshal.c	Thu Jun 20 11:15:25 2002
***************
*** 47,48 ****
--- 47,50 ----
  
+ #include "eicode.h"
+ 
  #include "putget.h"
***************
*** 61,62 ****
--- 63,65 ----
   */
+ 
  #define CMP_ARRAY_SIZE 256
***************
*** 69,72 ****
  #endif
  
! #define ERL_REF_CMP 5
  
--- 72,101 ----
  #endif
+ static inline int cmp_floats(double f1, double f2);
+ 
+ #define ERL_NUM_CMP 1
+ #define ERL_REF_CMP 3
  
! #define IS_ERL_NUM(t) (cmp_array[t]==ERL_NUM_CMP)
! 
! #define CMP_NUM_CLASS_SIZE 256
! static unsigned char cmp_num_class[CMP_NUM_CLASS_SIZE]; 
! static int init_cmp_num_class_p=1; /* initialize array, the first time */
! 
! #define MK_CMP_NUM_CODE(x,y)    (((x)<<2)|(y))
! #define CMP_NUM_CLASS(x)        (cmp_num_class[x] & 0x03)
! #define CMP_NUM_CODE(x,y)       (MK_CMP_NUM_CODE(CMP_NUM_CLASS(x),CMP_NUM_CLASS(y)))
! 
! #define SMALL 1
! #define FLOAT 2
! #define BIG   3
! 
! #define SMALL_SMALL    MK_CMP_NUM_CODE(SMALL,SMALL)
! #define SMALL_FLOAT    MK_CMP_NUM_CODE(SMALL,FLOAT)
! #define SMALL_BIG      MK_CMP_NUM_CODE(SMALL,BIG)
! #define FLOAT_SMALL    MK_CMP_NUM_CODE(FLOAT,SMALL)
! #define FLOAT_FLOAT    MK_CMP_NUM_CODE(FLOAT,FLOAT)
! #define FLOAT_BIG      MK_CMP_NUM_CODE(FLOAT,BIG)
! #define BIG_SMALL      MK_CMP_NUM_CODE(BIG,SMALL)
! #define BIG_FLOAT      MK_CMP_NUM_CODE(BIG,FLOAT)
! #define BIG_BIG        MK_CMP_NUM_CODE(BIG,BIG)
  
***************
*** 76,94 ****
      memset(cmp_array, 0, CMP_ARRAY_SIZE);
!     cmp_array[ERL_NIL_EXT]           = 1;
!     cmp_array[ERL_SMALL_INTEGER_EXT] = 2;
!     cmp_array[ERL_INTEGER_EXT]       = 2;
!     cmp_array[ERL_FLOAT_EXT]         = 3;
!     cmp_array[ERL_ATOM_EXT]          = 4;
!     cmp_array[ERL_REFERENCE_EXT]     = 5;
!     cmp_array[ERL_NEW_REFERENCE_EXT] = 5;
!     cmp_array[ERL_FUN_EXT]           = 6;
!     cmp_array[ERL_PORT_EXT]          = 7;
!     cmp_array[ERL_PID_EXT]           = 8;
!     cmp_array[ERL_SMALL_TUPLE_EXT]   = 9;
!     cmp_array[ERL_LARGE_TUPLE_EXT]   = 9;
!     cmp_array[ERL_STRING_EXT]        = 10;
!     cmp_array[ERL_LIST_EXT]          = 10;
!     cmp_array[ERL_BINARY_EXT]        = 11;
      init_cmp_array_p = 0;
    }
  }
--- 105,135 ----
      memset(cmp_array, 0, CMP_ARRAY_SIZE);
!     cmp_array[ERL_SMALL_INTEGER_EXT] = 1;
!     cmp_array[ERL_INTEGER_EXT]       = 1;
!     cmp_array[ERL_FLOAT_EXT]         = 1;
!     cmp_array[ERL_SMALL_BIG_EXT]     = 1;
!     cmp_array[ERL_LARGE_BIG_EXT]     = 1;
!     cmp_array[ERL_ATOM_EXT]          = 2;
!     cmp_array[ERL_REFERENCE_EXT]     = 3;
!     cmp_array[ERL_NEW_REFERENCE_EXT] = 3;
!     cmp_array[ERL_FUN_EXT]           = 4;
!     cmp_array[ERL_NEW_FUN_EXT]       = 4;
!     cmp_array[ERL_PORT_EXT]          = 5;
!     cmp_array[ERL_PID_EXT]           = 6;
!     cmp_array[ERL_SMALL_TUPLE_EXT]   = 7;
!     cmp_array[ERL_LARGE_TUPLE_EXT]   = 7;
!     cmp_array[ERL_NIL_EXT]           = 8;
!     cmp_array[ERL_STRING_EXT]        = 9;
!     cmp_array[ERL_LIST_EXT]          = 9;
!     cmp_array[ERL_BINARY_EXT]        = 10;
      init_cmp_array_p = 0;
    }
+   if (init_cmp_num_class_p) {
+     memset(cmp_num_class, 0, CMP_NUM_CLASS_SIZE);
+     cmp_num_class[ERL_SMALL_INTEGER_EXT] = SMALL;
+     cmp_num_class[ERL_INTEGER_EXT]       = SMALL;
+     cmp_num_class[ERL_FLOAT_EXT]         = FLOAT;
+     cmp_num_class[ERL_SMALL_BIG_EXT]     = BIG;
+     cmp_num_class[ERL_LARGE_BIG_EXT]     = BIG;
+     init_cmp_num_class_p = 0;
+   }
  }
***************
*** 585,588 ****
  
      case ERL_SMALL_BIG_EXT:
! 	arity = *(*ext)++; 
  	goto big_cont;
--- 626,631 ----
  
+         /* NOTE: The arity below for bigs is not really the arity (= number of digits) */
+         /*       It is the byte count and this might cause problems in other parts...  */
      case ERL_SMALL_BIG_EXT:
!         arity = *(*ext)++; 
  	goto big_cont;
***************
*** 1008,1009 ****
--- 1051,1055 ----
  	return ERL_FUNCTION;
+     case ERL_SMALL_BIG_EXT:
+     case ERL_LARGE_BIG_EXT:
+         return ERL_BIG;
      default:
***************
*** 1041,1042 ****
--- 1087,1090 ----
      case ERL_FLOAT_EXT:
+     case ERL_SMALL_BIG_EXT:
+     case ERL_LARGE_BIG_EXT:
  	return 0;
***************
*** 1169,1170 ****
--- 1217,1226 ----
  	break;
+     case ERL_SMALL_BIG_EXT:
+         i = *(*ext);
+         *ext += i + 1;
+         break;
+     case ERL_LARGE_BIG_EXT:
+ 	i = get32be(*ext);
+         *ext += i + 4;
+         break;
      default:
***************
*** 1409,1417 ****
        *e2 += 31;
! #if defined(VXWORKS) && CPU == PPC860
!       return erl_fp_compare((unsigned *) &ff1, (unsigned *) &ff2);
! #else
!       if (ff1 < ff2) return -1;
!       if (ff1 > ff2) return 1;
!       return 0;
! #endif
      case ERL_BINARY_EXT:
--- 1465,1468 ----
        *e2 += 31;
!       return cmp_floats(ff1,ff2);
! 
      case ERL_BINARY_EXT:
***************
*** 1436,1437 ****
--- 1487,1695 ----
  
+ /* Number compare */
+ 
+ static inline int cmp_floats(double f1, double f2)
+ {
+ #if defined(VXWORKS) && CPU == PPC860
+       return erl_fp_compare((unsigned *) &f1, (unsigned *) &f2);
+ #else
+       if (f1<f2) return -1;
+       else if (f1>f2) return 1;
+       else return 0;
+ #endif
+ }
+ 
+ static int cmp_small_big(unsigned char**e1, unsigned char **e2)
+ {
+     int i1,i2;
+     int t2;
+     int n2;
+     long l1;
+     int res;
+ 
+     erlang_big *b1,*b2;
+ 
+     i1 = i2 = 0;
+     if ( ei_decode_long(*e1,&i1,&l1) < 0 ) return -1;
+     
+     ei_get_type(*e2,&i2,&t2,&n2);
+     
+     /* any small will fit in two digits */
+     if ( (b1 = ei_alloc_big(2)) == NULL ) return -1;
+     if ( ei_small_to_big(l1,b1) < 0 ) {
+         ei_free_big(b1);
+         return -1;
+     }
+     
+     if ( (b2 = ei_alloc_big(n2)) == NULL ) {
+         ei_free_big(b1);
+         return 1;
+     }
+ 
+     if ( ei_decode_big(*e2,&i2,b2) < 0 ) {
+         ei_free_big(b1);
+         ei_free_big(b2);
+         return 1;
+     }
+     
+     res = ei_big_comp(b1,b2);
+     
+     ei_free_big(b1);
+     ei_free_big(b2);
+ 
+     return res;
+ }
+ 
+ static int cmp_small_float(unsigned char**e1, unsigned char **e2)
+ {
+     int i1,i2;
+     long l1;
+     double f1,f2;
+ 
+     // small -> float -> float_comp
+ 
+     i1 = i2 = 0;
+     if ( ei_decode_long(*e1,&i1,&l1) < 0 ) return -1;
+     if ( ei_decode_double(*e2,&i2,&f2) < 0 ) return 1;
+     
+     f1 = l1;
+ 
+     return cmp_floats(f1,f2);
+ }
+ 
+ static int cmp_float_big(unsigned char**e1, unsigned char **e2)
+ {
+     int res;
+     int i1,i2;
+     int t2,n2;
+     double f1,f2;
+     erlang_big *b2;
+     
+     // big -> float if overflow return big sign else float_comp
+     
+     i1 = i2 = 0;
+     if ( ei_decode_double(*e1,&i1,&f1) < 0 ) return -1;
+     
+     if (ei_get_type(*e2,&i2,&t2,&n2) < 0) return 1;
+     if ((b2 = ei_alloc_big(n2)) == NULL) return 1;
+     if (ei_decode_big(*e2,&i2,b2) < 0) return 1;
+     
+     /* convert the big to float */
+     if ( ei_big_to_double(b2,&f2) < 0 ) {
+         /* exception look at the sign */
+         res = b2->is_neg ? 1 : -1;
+         ei_free_big(b2);
+         return res;
+     }
+     
+     ei_free_big(b2);
+ 
+     return cmp_floats(f1,f2);
+ }
+ 
+ static int cmp_small_small(unsigned char**e1, unsigned char **e2)
+ {
+     int i1,i2;
+     long l1,l2;
+ 
+     i1 = i2 = 0;
+     if ( ei_decode_long(*e1,&i1,&l1) < 0 ) {
+         fprintf(stderr,"Failed to decode 1\r\n");
+         return -1;
+     }
+     if ( ei_decode_long(*e2,&i2,&l2) < 0 ) {
+         fprintf(stderr,"Failed to decode 2\r\n");
+         return 1;
+     }
+     
+     if ( l1 < l2 ) return -1;
+     else if ( l1 > l2 ) return 1;
+     else return 0;
+ }
+ 
+ static int cmp_float_float(unsigned char**e1, unsigned char **e2)
+ {
+     int i1,i2;
+     double f1,f2;
+ 
+     i1 = i2 = 0;
+     if ( ei_decode_double(*e1,&i1,&f1) < 0 ) return -1;
+     if ( ei_decode_double(*e2,&i2,&f2) < 0 ) return 1;
+     
+     return cmp_floats(f1,f2);
+ }
+ 
+ static int cmp_big_big(unsigned char**e1, unsigned char **e2)
+ {
+     int res;
+     int i1,i2;
+     int t1,t2;
+     int n1,n2;
+     erlang_big *b1,*b2;
+ 
+     i1 = i2 = 0;
+     ei_get_type(*e1,&i1,&t1,&n1);
+     ei_get_type(*e2,&i2,&t2,&n2);
+     
+     b1 = ei_alloc_big(n1);
+     b2 = ei_alloc_big(n2);
+     
+     ei_decode_big(*e1,&i1,b1);
+     ei_decode_big(*e2,&i2,b2);
+     
+     res = ei_big_comp(b1,b2);
+     
+     ei_free_big(b1);
+     ei_free_big(b2);
+ 
+     return res;
+ }
+ 
+ static int cmp_number(unsigned char**e1, unsigned char **e2)
+ {
+     switch (CMP_NUM_CODE(**e1,**e2)) {
+ 
+       case SMALL_BIG:
+         //fprintf(stderr,"compare small_big\r\n");
+         return cmp_small_big(e1,e2);
+ 
+       case BIG_SMALL:
+         //fprintf(stderr,"compare sbig_small\r\n");
+         return -cmp_small_big(e2,e1);
+ 
+       case SMALL_FLOAT:
+         //fprintf(stderr,"compare small_float\r\n");
+         return cmp_small_float(e1,e2);
+         
+       case FLOAT_SMALL:
+         //fprintf(stderr,"compare float_small\r\n");
+         return -cmp_small_float(e2,e1);
+ 
+       case FLOAT_BIG:
+         //fprintf(stderr,"compare float_big\r\n");
+         return cmp_float_big(e1,e2);
+ 
+       case BIG_FLOAT:
+         //fprintf(stderr,"compare big_float\r\n");
+         return -cmp_float_big(e2,e1);
+ 
+       case SMALL_SMALL:
+         //fprintf(stderr,"compare small_small\r\n");
+         return cmp_small_small(e1,e2);
+ 
+       case FLOAT_FLOAT:
+         //fprintf(stderr,"compare float_float\r\n");
+         return cmp_float_float(e1,e2);
+ 
+       case BIG_BIG:
+         //fprintf(stderr,"compare big_big\r\n");
+         return cmp_big_big(e1,e2);
+ 
+       default:
+         // should never get here ...
+         //fprintf(stderr,"compare standard\r\n");
+         return cmp_exe2(e1,e2);
+     }
+ 
+ }
+ 
  /* 
***************
*** 1450,1451 ****
--- 1708,1710 ----
    if (**e2 == ERL_VERSION_MAGIC) (*e2)++;
+ 
    if (cmp_array[**e1] < cmp_array[**e2]) return -1;
***************
*** 1453,1454 ****
--- 1712,1716 ----
    
+   if (IS_ERL_NUM(**e1)) 
+       return cmp_number(e1,e2);
+ 
    if (cmp_array[**e1] == ERL_REF_CMP)
*** lib/erl_interface/src/get_type.c	Mon Sep 20 23:15:31 1999
--- ../otp_src_R8B-1.fixed/lib/erl_interface/src/get_type.c	Tue Jun 18 12:58:44 2002
***************
*** 44,46 ****
      break;
!   
    default:
--- 44,54 ----
      break;
!     
!   case ERL_SMALL_BIG_EXT:
!     *len = (get8(s)+1)/2; /* big arity */
!     break;
! 
!   case ERL_LARGE_BIG_EXT:
!     *len = (get32be(s)+1)/2; /* big arity */
!     break;
! 
    default:
*** lib/erl_interface/src/decode_big.c	Thu Jun 20 10:59:27 2002
--- ../otp_src_R8B-1.fixed/lib/erl_interface/src/decode_big.c	Tue Jun 18 13:00:29 2002
***************
*** 0 ****
--- 1,229 ----
+ /* ``The contents of this file are subject to the Erlang Public License,
+  * Version 1.1, (the "License"); you may not use this file except in
+  * compliance with the License. You should have received a copy of the
+  * Erlang Public License along with this software. If not, it can be
+  * retrieved via the world wide web at http://www.erlang.org/.
+  * 
+  * Software distributed under the License is distributed on an "AS IS"
+  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+  * the License for the specific language governing rights and limitations
+  * under the License.
+  * 
+  * The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+  * Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+  * AB. All Rights Reserved.''
+  * 
+  *     $Id$
+  */
+ #include <string.h>
+ #include "ei.h"
+ #include "putget.h"
+ 
+ extern int ei_decode_big(const char *buf, int *index, erlang_big *b)
+ {
+   long digit_bytes;
+   const char *s = buf + *index;
+   const char *s0 = s;
+ 
+   switch ( get8(s) ) {
+     case ERL_SMALL_BIG_EXT:
+       digit_bytes = get8(s);
+       break;
+     case ERL_LARGE_BIG_EXT:
+       digit_bytes = get32be(s);
+       break;
+     default:
+       return -1;
+   }
+   if ( b ) {
+       if ( ((digit_bytes+1)/2) != b->arity ) {
+           return -1;
+       }
+       b->is_neg = get8(s);
+       memmove(b->digits,s,digit_bytes);
+   } else {
+       s++; // skip sign byte 
+   }
+ 
+   s += digit_bytes;
+ 
+   *index += s-s0; 
+   
+   return 0; 
+ }
+ 
+ 
+ erlang_big *ei_alloc_big(int arity)
+ {
+     erlang_big *b;
+ 
+     if ( (b = erl_malloc(sizeof(erlang_big))) == NULL) return NULL;
+     memset(b,(char)0,sizeof(erlang_big));
+     if ( (b->digits = erl_malloc(arity*2)) == NULL) {
+         erl_free(b);
+         return 0;
+     }
+     
+     b->arity = arity;
+     memset(b->digits,(char)0,arity*2);
+     return b;
+ }
+ 
+ void ei_free_big(erlang_big *b)
+ {
+     if (!b) return;
+     if (b->digits) erl_free(b->digits);
+     erl_free(b);
+ }
+ 
+ /* big compare functions */
+ 
+ typedef unsigned short Uint16;
+ typedef unsigned int Uint;
+ 
+ typedef Uint16 digit_t;
+ typedef Uint dsize_t;
+ 
+ static int I_comp(digit_t *x, dsize_t xl, digit_t *y, dsize_t yl)
+ {
+     if (xl<yl) {
+         return -1;
+     } else if (xl>yl) {
+         return 1;
+     } else {
+         if ( x == y ) return 0;
+         x += (xl-1);
+         y += (yl-1);
+         while( (xl>0) && (*x==*y) ) {
+             x--;
+             y--;
+             xl--;
+         }
+         if ( xl == 0 ) return 0;
+         return ( *x < *y ) ? -1 : 1;
+     }
+ }
+ 
+ int ei_big_comp(erlang_big *x, erlang_big *y)
+ {
+     if ( x->is_neg == y->is_neg ) {
+         int c = I_comp(x->digits,x->arity,y->digits,y->arity);
+         if ( x->is_neg ) 
+             return -c;
+         else
+             return c;
+     } else {
+         return x->is_neg ? -1 : 1;
+     }
+ }
+ 
+ #define D_EXP      16
+ #define D_BASE     (1<<D_EXP)
+ 
+ #define D_DECIMAL_EXP   4           /* 10^4 == 10000 */
+ #define D_DECIMAL_BASE  10000       /* Max decimal exponent in a digit */
+ 
+ #define DLOW(x)        ((digit_t)((x) & (D_BASE-1)))
+ #define DHIGH(x)       ((digit_t)((x) >> D_EXP))
+ 
+ /*
+  * Handling of floating point exceptions.
+  */
+ 
+ 
+ //extern volatile int erl_fp_exception;
+ static volatile int erl_fp_exception;
+ 
+ #ifdef USE_ISINF_ISNAN		/* simulate finite() */
+ #  define finite(f) (!isinf(f) && !isnan(f))
+ #  define HAVE_FINITE
+ #endif
+ 
+ #ifdef NO_FPE_SIGNALS
+ #  define ERTS_FP_CHECK_INIT() do {} while (0)
+ #  define ERTS_FP_ERROR(f, Action) if (!finite(f)) { Action; } else {}
+ #  define ERTS_SAVE_FP_EXCEPTION()
+ #  define ERTS_RESTORE_FP_EXCEPTION()
+ #else
+ #  define ERTS_FP_CHECK_INIT() do {erl_fp_exception = 0;} while (0)
+ #  if defined(__i386__) && defined(__GNUC__)
+ //extern void erts_restore_x87(void);
+ 
+ static void unmask_fpe(void)
+ {
+     unsigned short cw;
+     __asm__ __volatile__("fstcw %0" : "=m"(cw));
+     cw &= ~(0x01|0x04|0x08);   /* unmask IM, ZM, OM */
+     __asm__ __volatile__("fldcw %0" : : "m"(cw));
+ }
+ 
+ void erts_restore_x87(void)
+ {
+     __asm__ __volatile__("fninit");
+     unmask_fpe();
+ }
+ 
+ static __inline__ int erts_check_x87(double f)
+ {
+     __asm__ __volatile__("fwait" : "=m"(erl_fp_exception) : "m"(f));
+     if( !erl_fp_exception )
+        return 0;
+     erts_restore_x87();
+     return 1;
+ }
+ #  define ERTS_FP_ERROR(f, Action) do { if( erts_check_x87((f)) ) { Action; } } while (0)
+ #  else
+ #  define ERTS_FP_ERROR(f, Action) if (erl_fp_exception) { Action; } else {}
+ #  endif
+ #  define ERTS_SAVE_FP_EXCEPTION() int old_erl_fp_exception = erl_fp_exception
+ #  define ERTS_RESTORE_FP_EXCEPTION() \
+               do {erl_fp_exception = old_erl_fp_exception;} while (0)
+ #endif
+ 
+ 
+ int ei_big_to_double(erlang_big *b, double *resp)
+ {
+     double d = 0.0;
+     double d_base = 1.0;
+ 
+     digit_t* s = (digit_t *)b->digits;
+     dsize_t xl = b->arity;
+     short xsgn = b->is_neg;
+ 
+     ERTS_SAVE_FP_EXCEPTION();
+ 
+     ERTS_FP_CHECK_INIT();
+     while(xl--) {
+ 	digit_t ds = *s;
+ 	double d_next = ds * d_base + d;
+ 
+ 	ERTS_FP_ERROR(d_next, ERTS_RESTORE_FP_EXCEPTION(); {fprintf(stderr,"\r\n### fp exception ###\r\n"); return -1;});
+ 	s++;
+ 	d = d_next;
+ 	d_base *= D_BASE;
+     }
+ 
+     /*
+      * Note: The last multiplication in the loop could trigger an exception,
+      * which we will ignore because the result will never be used.
+      */
+ 
+     *resp = xsgn ? -d : d;
+     ERTS_FP_ERROR(*resp,;);
+     ERTS_RESTORE_FP_EXCEPTION();
+     return 0;
+ }
+ 
+ int ei_small_to_big(int small, erlang_big *b)
+ {
+     digit_t *d;
+ 
+     if ( b->arity < 2 ) return -1;
+ 
+     b->is_neg = ( small < 0 );
+     d = (digit_t *)b->digits;
+     d[0] = DLOW(small);
+     d[1] = DHIGH(small);
+ 
+     return 0;
+ }
*** lib/erl_interface/src/Makefile.in	Thu Feb 14 22:20:56 2002
--- ../otp_src_R8B-1.fixed/lib/erl_interface/src/Makefile.in	Tue Jun 18 13:19:55 2002
***************
*** 114,116 ****
  
! IDL_OBJS = $(addprefix $(OBJDIR)/,decode_atom.o decode_binary.o decode_boolean.o decode_char.o decode_double.o decode_intlist.o decode_list_header.o decode_long.o decode_pid.o decode_port.o decode_ref.o decode_string.o decode_trace.o decode_tuple_header.o decode_ulong.o decode_version.o encode_atom.o encode_binary.o encode_boolean.o encode_char.o encode_double.o encode_list_header.o encode_long.o encode_pid.o encode_port.o encode_ref.o encode_string.o encode_trace.o encode_tuple_header.o encode_ulong.o encode_version.o get_type.o receive.o send.o send_exit.o send_link.o send_reg.o show_msg.o trace.o whereis.o eimd5.o ei_format.o ei_decode_term.o decode_fun.o encode_fun.o ei_x_encode.o)
  
--- 114,116 ----
  
! IDL_OBJS = $(addprefix $(OBJDIR)/,decode_atom.o decode_big.o decode_binary.o decode_boolean.o decode_char.o decode_double.o decode_intlist.o decode_list_header.o decode_long.o decode_pid.o decode_port.o decode_ref.o decode_string.o decode_trace.o decode_tuple_header.o decode_ulong.o decode_version.o encode_atom.o encode_binary.o encode_boolean.o encode_char.o encode_double.o encode_list_header.o encode_long.o encode_pid.o encode_port.o encode_ref.o encode_string.o encode_trace.o encode_tuple_header.o encode_ulong.o encode_version.o get_type.o receive.o send.o send_exit.o send_link.o send_reg.o show_msg.o trace.o whereis.o eimd5.o ei_format.o ei_decode_term.o decode_fun.o encode_fun.o ei_x_encode.o)