Return to dump.c CVS log

Up to [local] / OpenXM / src / ox_toolkit

Annotation of OpenXM/src/ox_toolkit/dump.c, Revision 1.5

1.1       ohara       1: /* -*- mode: C; coding: euc-japan -*- */
1.5     ! ohara       2: /* $OpenXM: OpenXM/src/ox_toolkit/dump.c,v 1.4 2003/09/15 09:31:41 ohara Exp $ */
1.1       ohara       3:
                      4: /*
                      5:    This module includes functions for sending/receiveng CMO's.
                      6:    Some commnets is written in Japanese by the EUC-JP coded
                      7:    character set.
                      8: */
                      9:
                     10: #include <stdio.h>
                     11: #include <stdlib.h>
                     12: #include <sys/param.h>
                     13: #include "ox_toolkit.h"
                     14:
                     15: static void dump_cmo_int32(cmo_int32* m);
                     16: static void dump_cmo_list(cmo_list* m);
                     17: static void dump_cmo_mathcap(cmo_mathcap* m);
                     18: static void dump_cmo_null(cmo_null* m);
                     19: static void dump_cmo_string(cmo_string* m);
                     20: static void dump_cmo_monomial32(cmo_monomial32* c);
                     21: static void dump_cmo_zz(cmo_zz* c);
1.2       ohara      22: static void dump_mpz(mpz_ptr mpz);
1.1       ohara      23: static void dump_string(void *s, int len);
                     24: static void dump_integer(int x);
                     25:
                     26: /* functions encoding cmo to binary */
                     27:
                     28: static int  d_ptr;
                     29: static char *d_buf;
                     30:
                     31: void dump_buffer_init(char *s)
                     32: {
                     33:     d_buf = s;
                     34:     d_ptr = 0;
                     35: }
                     36:
                     37: static void dump_string(void *s, int len)
                     38: {
                     39:     memcpy(&d_buf[d_ptr], s, len);
                     40:     d_ptr += len;
                     41: }
                     42:
                     43: static void dump_integer(int x)
                     44: {
                     45:     x = htonl(x);
                     46:     dump_string(&x, sizeof(int));
                     47: }
                     48:
                     49: static void dump_mpz(mpz_ptr mpz)
                     50: {
                     51:     int i;
                     52:     int len = abs(mpz->_mp_size);
                     53:     dump_integer(mpz->_mp_size);
                     54:     for(i=0; i<len; i++) {
                     55:         dump_integer(mpz->_mp_d[i]);
                     56:     }
                     57: }
                     58:
                     59: __inline__
                     60: static void dump_cmo_null(cmo_null* m)
                     61: {
                     62:     return;
                     63: }
                     64:
                     65: static void dump_cmo_int32(cmo_int32* m)
                     66: {
                     67:     dump_integer(m->i);
                     68: }
                     69:
                     70: static void dump_cmo_string(cmo_string* m)
                     71: {
                     72:     int len = strlen(m->s);
                     73:     dump_integer(len);
                     74:     dump_string(m->s, len);
                     75: }
                     76:
                     77: static void dump_cmo_mathcap(cmo_mathcap* c)
                     78: {
                     79:     dump_cmo(c->ob);
                     80: }
                     81:
                     82: static void dump_cmo_list(cmo_list* m)
                     83: {
                     84:     cell* cp = list_first(m);
                     85:     int len  = list_length(m);
                     86:     dump_integer(len);
                     87:     while(!list_endof(m, cp)) {
                     88:         dump_cmo(cp->cmo);
                     89:         cp = list_next(cp);
                     90:     }
                     91: }
                     92:
                     93: static void dump_cmo_monomial32(cmo_monomial32* c)
                     94: {
                     95:     int i;
                     96:     int length = c->length;
                     97:     dump_integer(c->length);
                     98:     for(i=0; i<length; i++) {
                     99:         dump_integer(c->exps[i]);
                    100:     }
                    101:     dump_cmo(c->coef);
                    102: }
                    103:
                    104: static void dump_cmo_zz(cmo_zz* c)
                    105: {
                    106:     dump_mpz(c->mpz);
                    107: }
                    108:
                    109: static void dump_cmo_distributed_polynomial(cmo_distributed_polynomial* m)
                    110: {
                    111:     cell* cp;
1.4       ohara     112:     dump_integer(list_length((cmo_list *)m));
1.1       ohara     113:     dump_cmo(m->ringdef);
1.4       ohara     114:     for(cp = list_first((cmo_list *)m); !list_endof((cmo_list *)m, cp); cp = list_next(cp)) {
1.1       ohara     115:         dump_cmo(cp->cmo);
                    116:     }
                    117: }
                    118:
                    119: /* after its tag is sent, we invoke each functions. */
                    120: void dump_cmo(cmo* m)
                    121: {
                    122:     dump_integer(m->tag);
                    123:     switch(m->tag) {
                    124:     case CMO_NULL:
                    125:     case CMO_ZERO:
                    126:     case CMO_DMS_GENERIC:
                    127:         dump_cmo_null(m);
                    128:         break;
                    129:     case CMO_INT32:
                    130:         dump_cmo_int32((cmo_int32 *)m);
                    131:         break;
                    132:     case CMO_STRING:
                    133:         dump_cmo_string((cmo_string *)m);
                    134:         break;
                    135:     case CMO_MATHCAP:
                    136:     case CMO_RING_BY_NAME:
                    137:     case CMO_INDETERMINATE:
                    138:     case CMO_ERROR2:
                    139:         dump_cmo_mathcap((cmo_mathcap *)m);
                    140:         break;
                    141:     case CMO_LIST:
                    142:         dump_cmo_list((cmo_list *)m);
                    143:         break;
                    144:     case CMO_MONOMIAL32:
                    145:         dump_cmo_monomial32((cmo_monomial32 *)m);
                    146:         break;
                    147:     case CMO_ZZ:
                    148:         dump_cmo_zz((cmo_zz *)m);
                    149:         break;
                    150:     case CMO_DISTRIBUTED_POLYNOMIAL:
                    151:         dump_cmo_distributed_polynomial((cmo_distributed_polynomial *)m);
                    152:         break;
                    153:     default:
1.5     ! ohara     154:                ;
1.1       ohara     155:     }
                    156: }
                    157:
                    158: void dump_ox_data(ox_data* m)
                    159: {
                    160:     dump_integer(OX_DATA);
                    161:     dump_integer(-1);
                    162:     dump_cmo(m->cmo);
                    163: }
                    164:
                    165: void dump_ox_command(ox_command* m)
                    166: {
                    167:     dump_integer(OX_COMMAND);
                    168:     dump_integer(-1);
                    169:     dump_integer(m->command);
                    170: }
                    171:
                    172: