[BACK]Return to cmo.c CVS log [TXT][DIR] Up to [local] / OpenXM / src / ox_toolkit

Diff for /OpenXM/src/ox_toolkit/cmo.c between version 1.4 and 1.11

version 1.4, 2003/01/11 11:42:31 version 1.11, 2003/06/02 10:25:56
Line 1 
Line 1 
 /* -*- mode: C; coding: euc-japan -*- */  /* -*- mode: C; coding: euc-japan -*- */
 /* $OpenXM: OpenXM/src/ox_toolkit/cmo.c,v 1.3 2000/12/14 01:39:31 ohara Exp $ */  /* $OpenXM: OpenXM/src/ox_toolkit/cmo.c,v 1.10 2003/03/30 08:05:22 ohara Exp $ */
   
 /*  /*
    This module includes functions for sending/receiveng CMO's.     This module includes functions for sending/receiveng CMO's.
Line 19  static char*        new_string_set_cmo_null();
Line 19  static char*        new_string_set_cmo_null();
 static char*        new_string_set_cmo_int32(int integer);  static char*        new_string_set_cmo_int32(int integer);
 static char*        new_string_set_cmo_list(cmo_list *c);  static char*        new_string_set_cmo_list(cmo_list *c);
 static char*        new_string_set_cmo_zz(cmo_zz *c);  static char*        new_string_set_cmo_zz(cmo_zz *c);
   static char*        new_string_set_cmo_double(cmo_double *m);
   
 /* functions for a cmo_list */  /* functions for a cmo_list */
 static cell* new_cell(cmo *ob)  static cell* new_cell(cmo *ob)
 {  {
     cell* h = malloc(sizeof(cell));      cell* h = MALLOC(sizeof(cell));
     h->next = NULL;      h->next = NULL;
     h->prev = NULL;      h->prev = NULL;
     h->cmo  = ob;      h->cmo  = ob;
Line 111  void resize_mpz(mpz_ptr mpz, int size)
Line 112  void resize_mpz(mpz_ptr mpz, int size)
 /* functions named new_cmo_*. */  /* functions named new_cmo_*. */
 cmo_null* new_cmo_null()  cmo_null* new_cmo_null()
 {  {
     cmo_null* m = malloc(sizeof(cmo_null));      cmo_null* m = MALLOC(sizeof(cmo_null));
     m->tag = CMO_NULL;      m->tag = CMO_NULL;
     return m;      return m;
 }  }
Line 119  cmo_null* new_cmo_null()
Line 120  cmo_null* new_cmo_null()
 cmo_int32* new_cmo_int32(int i)  cmo_int32* new_cmo_int32(int i)
 {  {
     cmo_int32* c;      cmo_int32* c;
     c = malloc(sizeof(cmo_int32));      c = MALLOC(sizeof(cmo_int32));
     c->tag     = CMO_INT32;      c->tag     = CMO_INT32;
     c->i = i;      c->i = i;
     return c;      return c;
Line 127  cmo_int32* new_cmo_int32(int i)
Line 128  cmo_int32* new_cmo_int32(int i)
   
 cmo_string* new_cmo_string(char* s)  cmo_string* new_cmo_string(char* s)
 {  {
     cmo_string* c = malloc(sizeof(cmo_string));      cmo_string* c = MALLOC(sizeof(cmo_string));
     c->tag = CMO_STRING;      c->tag = CMO_STRING;
     if (s != NULL) {      if (s != NULL) {
         c->s = malloc(strlen(s)+1);          c->s = MALLOC(strlen(s)+1);
         strcpy(c->s, s);          strcpy(c->s, s);
     }else {      }else {
         c->s = NULL;          c->s = NULL;
Line 140  cmo_string* new_cmo_string(char* s)
Line 141  cmo_string* new_cmo_string(char* s)
   
 cmo_mathcap* new_cmo_mathcap(cmo* ob)  cmo_mathcap* new_cmo_mathcap(cmo* ob)
 {  {
     cmo_mathcap* c = malloc(sizeof(cmo_mathcap));      cmo_mathcap* c = MALLOC(sizeof(cmo_mathcap));
     c->tag = CMO_MATHCAP;      c->tag = CMO_MATHCAP;
     c->ob  = ob;      c->ob  = ob;
     return c;      return c;
Line 148  cmo_mathcap* new_cmo_mathcap(cmo* ob)
Line 149  cmo_mathcap* new_cmo_mathcap(cmo* ob)
   
 cmo_list* new_cmo_list()  cmo_list* new_cmo_list()
 {  {
     cmo_list* c = malloc(sizeof(cmo_list));      cmo_list* c = MALLOC(sizeof(cmo_list));
     c->tag    = CMO_LIST;      c->tag    = CMO_LIST;
     c->length = 0;      c->length = 0;
     c->head->next = c->head;      c->head->next = c->head;
Line 158  cmo_list* new_cmo_list()
Line 159  cmo_list* new_cmo_list()
   
 cmo_monomial32* new_cmo_monomial32()  cmo_monomial32* new_cmo_monomial32()
 {  {
     cmo_monomial32* c = malloc(sizeof(cmo_monomial32));      cmo_monomial32* c = MALLOC(sizeof(cmo_monomial32));
     c->tag  = CMO_MONOMIAL32;      c->tag  = CMO_MONOMIAL32;
     return c;      return c;
 }  }
Line 168  cmo_monomial32* new_cmo_monomial32_size(int size)
Line 169  cmo_monomial32* new_cmo_monomial32_size(int size)
     cmo_monomial32* c = new_cmo_monomial32();      cmo_monomial32* c = new_cmo_monomial32();
     if (size>0) {      if (size>0) {
         c->length = size;          c->length = size;
         c->exps = malloc(sizeof(int)*size);          c->exps = MALLOC(sizeof(int)*size);
     }      }
     return c;      return c;
 }  }
   
 cmo_zz* new_cmo_zz()  cmo_zz* new_cmo_zz()
 {  {
     cmo_zz* c = malloc(sizeof(cmo_zz));      cmo_zz* c = MALLOC(sizeof(cmo_zz));
     c->tag  = CMO_ZZ;      c->tag  = CMO_ZZ;
     mpz_init(c->mpz);      mpz_init(c->mpz);
     return c;      return c;
Line 183  cmo_zz* new_cmo_zz()
Line 184  cmo_zz* new_cmo_zz()
   
 cmo_zz* new_cmo_zz_noinit()  cmo_zz* new_cmo_zz_noinit()
 {  {
     cmo_zz* c = malloc(sizeof(cmo_zz));      cmo_zz* c = MALLOC(sizeof(cmo_zz));
     c->tag  = CMO_ZZ;      c->tag  = CMO_ZZ;
     return c;      return c;
 }  }
Line 218  cmo_zz* new_cmo_zz_size(int size)
Line 219  cmo_zz* new_cmo_zz_size(int size)
   
 cmo_zero* new_cmo_zero()  cmo_zero* new_cmo_zero()
 {  {
     cmo_zero* m = malloc(sizeof(cmo_zero));      cmo_zero* m = MALLOC(sizeof(cmo_zero));
     m->tag = CMO_ZERO;      m->tag = CMO_ZERO;
     return m;      return m;
 }  }
   
   cmo_double *new_cmo_double(double d)
   {
       cmo_double* m = MALLOC(sizeof(cmo_double));
       m->tag = CMO_64BIT_MACHINE_DOUBLE;
       m->d = d;
       return m;
   }
   
 cmo_dms_generic* new_cmo_dms_generic()  cmo_dms_generic* new_cmo_dms_generic()
 {  {
     cmo_dms_generic* m = malloc(sizeof(cmo_dms_generic));      cmo_dms_generic* m = MALLOC(sizeof(cmo_dms_generic));
     m->tag = CMO_DMS_GENERIC;      m->tag = CMO_DMS_GENERIC;
     return m;      return m;
 }  }
   
 cmo_ring_by_name* new_cmo_ring_by_name(cmo* ob)  cmo_ring_by_name* new_cmo_ring_by_name(cmo* ob)
 {  {
     cmo_ring_by_name* c = malloc(sizeof(cmo_ring_by_name));      cmo_ring_by_name* c = MALLOC(sizeof(cmo_ring_by_name));
     c->tag = CMO_RING_BY_NAME;      c->tag = CMO_RING_BY_NAME;
     c->ob  = ob;      c->ob  = ob;
     return c;      return c;
Line 240  cmo_ring_by_name* new_cmo_ring_by_name(cmo* ob)
Line 249  cmo_ring_by_name* new_cmo_ring_by_name(cmo* ob)
   
 cmo_indeterminate* new_cmo_indeterminate(cmo* ob)  cmo_indeterminate* new_cmo_indeterminate(cmo* ob)
 {  {
     cmo_indeterminate* c = malloc(sizeof(cmo_indeterminate));      cmo_indeterminate* c = MALLOC(sizeof(cmo_indeterminate));
     c->tag = CMO_INDETERMINATE;      c->tag = CMO_INDETERMINATE;
     c->ob  = ob;      c->ob  = ob;
     return c;      return c;
Line 248  cmo_indeterminate* new_cmo_indeterminate(cmo* ob)
Line 257  cmo_indeterminate* new_cmo_indeterminate(cmo* ob)
   
 cmo_distributed_polynomial* new_cmo_distributed_polynomial()  cmo_distributed_polynomial* new_cmo_distributed_polynomial()
 {  {
     cmo_distributed_polynomial* c = malloc(sizeof(cmo_distributed_polynomial));      cmo_distributed_polynomial* c = MALLOC(sizeof(cmo_distributed_polynomial));
     c->tag     = CMO_DISTRIBUTED_POLYNOMIAL;      c->tag     = CMO_DISTRIBUTED_POLYNOMIAL;
     c->length  = 0;      c->length  = 0;
     c->head->next = c->head;      c->head->next = c->head;
Line 259  cmo_distributed_polynomial* new_cmo_distributed_polyno
Line 268  cmo_distributed_polynomial* new_cmo_distributed_polyno
   
 cmo_error2* new_cmo_error2(cmo* ob)  cmo_error2* new_cmo_error2(cmo* ob)
 {  {
     cmo_error2* c = malloc(sizeof(cmo_error2));      cmo_error2* c = MALLOC(sizeof(cmo_error2));
     c->tag = CMO_ERROR2;      c->tag = CMO_ERROR2;
     c->ob  = ob;      c->ob  = ob;
     return c;      return c;
Line 284  static char *new_string_set_cmo_int32(int integer)
Line 293  static char *new_string_set_cmo_int32(int integer)
     char *s;      char *s;
   
     sprintf(buff, "%d", integer);      sprintf(buff, "%d", integer);
     s = malloc(strlen(buff)+1);      s = MALLOC(strlen(buff)+1);
     strcpy(s, buff);      strcpy(s, buff);
   
     return s;      return s;
Line 296  static char *new_string_set_cmo_list(cmo_list *m)
Line 305  static char *new_string_set_cmo_list(cmo_list *m)
     int i;      int i;
     int size = 0;      int size = 0;
     int len = list_length(m);      int len = list_length(m);
     char **sp = malloc(len*sizeof(cmo *));      char **sp = ALLOCA(len*sizeof(cmo *));
   
     cell* cp = list_first(m);      cell* cp = list_first(m);
     for(i = 0; i < len; i++) {      for(i = 0; i < len; i++) {
Line 304  static char *new_string_set_cmo_list(cmo_list *m)
Line 313  static char *new_string_set_cmo_list(cmo_list *m)
         size += strlen(sp[i]) + 3;          size += strlen(sp[i]) + 3;
         cp = list_next(cp);          cp = list_next(cp);
     }      }
     s = malloc(size+2);      s = MALLOC(size+2);
     strcpy(s, "[ ");      strcpy(s, "[ ");
     for(i = 0; i < len - 1; i++) {      for(i = 0; i < len - 1; i++) {
         strcat(s, sp[i]);          strcat(s, sp[i]);
Line 312  static char *new_string_set_cmo_list(cmo_list *m)
Line 321  static char *new_string_set_cmo_list(cmo_list *m)
     }      }
     strcat(s, sp[len-1]);      strcat(s, sp[len-1]);
     strcat(s, " ]");      strcat(s, " ]");
     free(sp);  
     return s;      return s;
 }  }
   
   static char *new_string_set_cmo_double(cmo_double *m)
   {
       char buff[1024];
       char *s;
   
       sprintf(buff, "%lf", m->d);
       s = MALLOC(strlen(buff)+1);
       strcpy(s, buff);
   
       return s;
   }
   
 char *new_string_set_cmo(cmo *m)  char *new_string_set_cmo(cmo *m)
 {  {
     symbol_t symp;  
     switch(m->tag) {      switch(m->tag) {
     case CMO_ZZ:      case CMO_ZZ:
         return new_string_set_cmo_zz((cmo_zz *)m);          return new_string_set_cmo_zz((cmo_zz *)m);
Line 330  char *new_string_set_cmo(cmo *m)
Line 349  char *new_string_set_cmo(cmo *m)
         return new_string_set_cmo_null();          return new_string_set_cmo_null();
     case CMO_LIST:      case CMO_LIST:
         return new_string_set_cmo_list((cmo_list *)m);          return new_string_set_cmo_list((cmo_list *)m);
           case CMO_64BIT_MACHINE_DOUBLE:
           return new_string_set_cmo_int32(m);
     default:      default:
 #ifdef DEBUG          ox_printf("unconvertible <%s>\n", get_symbol_by_tag(m->tag));
         symp = lookup_by_tag(m->tag);  
         fprintf(ox_stderr, "I do not know how to convert %s to a string.\n", symp->key);  
 #endif  
         /* yet not implemented. */          /* yet not implemented. */
         return NULL;          return NULL;
     }      }
 }  }
   

Legend:
Removed from v.1.4  
changed lines
  Added in v.1.11

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>