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

Annotation of OpenXM/src/ox_toolkit/ox.c, Revision 1.38

1.1       ohara       1: /* -*- mode: C; coding: euc-japan -*- */
1.38    ! noro        2: /* $OpenXM: OpenXM/src/ox_toolkit/ox.c,v 1.37 2014/04/07 04:00:10 iwane Exp $ */
1.1       ohara       3:
1.8       ohara       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.
1.1       ohara       8: */
                      9:
                     10: #include <stdio.h>
                     11: #include <stdlib.h>
1.20      ohara      12: #include <stdarg.h>
1.1       ohara      13: #include <string.h>
                     14: #include <unistd.h>
                     15: #include <fcntl.h>
1.5       ohara      16: #include <sys/file.h>
1.13      ohara      17: #include <time.h>
1.1       ohara      18:
1.38    ! noro       19: #include <mpfr.h>
        !            20: /* XXX : defined in mpfr-impl.h */
        !            21: #define MPFR_PREC(x)      ((x)->_mpfr_prec)
        !            22: #define MPFR_EXP(x)       ((x)->_mpfr_exp)
        !            23: #define MPFR_MANT(x)      ((x)->_mpfr_d)
        !            24: #define MPFR_LAST_LIMB(x) ((MPFR_PREC (x) - 1) / GMP_NUMB_BITS)
        !            25: #define MPFR_LIMB_SIZE(x) (MPFR_LAST_LIMB (x) + 1)
        !            26:
        !            27: #if SIZEOF_LONG==4
        !            28: typedef long long L64;
        !            29: typedef unsigned long long UL64;
        !            30: #else
        !            31: typedef long L64;
        !            32: typedef unsigned long UL64;
        !            33: #endif
        !            34:
1.1       ohara      35: #include "mysocket.h"
1.12      ohara      36: #include "ox_toolkit.h"
1.1       ohara      37: #include "parse.h"
                     38:
1.20      ohara      39: static FILE *ox_stderr = NULL;
                     40:
1.17      ohara      41: /* sorting by the value of CMO_xxx.  (for debugging) */
1.13      ohara      42: static cmo_null*         receive_cmo_null(OXFILE *oxfp);
                     43: static cmo_int32*        receive_cmo_int32(OXFILE *oxfp);
                     44: static cmo_string*       receive_cmo_string(OXFILE *oxfp);
                     45: static cmo_mathcap*      receive_cmo_mathcap(OXFILE *oxfp);
                     46: static cmo_list*         receive_cmo_list(OXFILE *oxfp);
                     47: static cmo_monomial32*   receive_cmo_monomial32(OXFILE *oxfp);
                     48: static cmo_zero*         receive_cmo_zero(OXFILE *oxfp);
                     49: static cmo_dms_generic*  receive_cmo_dms_generic(OXFILE *oxfp);
                     50: static cmo_ring_by_name* receive_cmo_ring_by_name(OXFILE *oxfp);
                     51: static cmo_distributed_polynomial* receive_cmo_distributed_polynomial(OXFILE *oxfp);
1.26      ohara      52: static cmo_recursive_polynomial* receive_cmo_recursive_polynomial(OXFILE *oxfp);
                     53: static cmo_polynomial_in_one_variable* receive_cmo_polynomial_in_one_variable(OXFILE *oxfp);
1.32      ohara      54: static cmo_double*       receive_cmo_double(OXFILE *oxfp);
1.13      ohara      55: static cmo_error2*       receive_cmo_error2(OXFILE *oxfp);
                     56:
                     57: static int          send_cmo_null(OXFILE *oxfp, cmo_null* c);
                     58: static int          send_cmo_int32(OXFILE *oxfp, cmo_int32* m);
                     59: static int          send_cmo_string(OXFILE *oxfp, cmo_string* m);
                     60: static int          send_cmo_mathcap(OXFILE *oxfp, cmo_mathcap* c);
                     61: static int          send_cmo_list(OXFILE *oxfp, cmo_list* c);
                     62: static int          send_cmo_monomial32(OXFILE *oxfp, cmo_monomial32* c);
1.32      ohara      63: static int          send_cmo_double(OXFILE *oxfp, cmo_double* c);
1.22      ohara      64: static int          send_cmo_error2(OXFILE *oxfp, cmo_error2* c);
                     65: static int          send_cmo_distributed_polynomial(OXFILE *oxfp, cmo_distributed_polynomial* c);
1.26      ohara      66: static int send_cmo_polynomial_in_one_variable(OXFILE *oxfp, cmo_polynomial_in_one_variable* c);
                     67: static int send_cmo_recursive_polynomial(OXFILE *oxfp, cmo_recursive_polynomial* c);
1.22      ohara      68:
                     69: static cmo_zz*      receive_cmo_zz(OXFILE *oxfp);
                     70: static void         receive_mpz(OXFILE *oxfp, mpz_ptr mpz);
1.13      ohara      71: static int          send_cmo_zz(OXFILE *oxfp, cmo_zz* c);
                     72: static int          send_mpz(OXFILE *oxfp, mpz_ptr mpz);
1.38    ! noro       73: static void         receive_mpfr(OXFILE *oxfp, mpfr_ptr mpfr);
        !            74: static int          send_mpfr(OXFILE *oxfp, mpfr_ptr mpfr);
1.3       ohara      75:
1.8       ohara      76: /* hook functions. (yet not implemented) */
1.2       ohara      77: static hook_t hook_before_send_cmo = NULL;
                     78: static hook_t hook_after_send_cmo  = NULL;
                     79:
                     80: int add_hook_before_send_cmo(hook_t func)
                     81: {
1.13      ohara      82:     hook_before_send_cmo = func;
                     83:     return 0;
1.2       ohara      84: }
                     85:
                     86: int add_hook_after_send_cmo(hook_t func)
                     87: {
1.13      ohara      88:     hook_after_send_cmo = func;
                     89:     return 0;
1.2       ohara      90: }
                     91:
1.13      ohara      92: static cmo *call_hook_before_send_cmo(OXFILE *oxfp, cmo *c)
1.2       ohara      93: {
1.13      ohara      94:     if (hook_before_send_cmo != NULL) {
                     95:         return hook_before_send_cmo(oxfp, c);
                     96:     }
                     97:     return c;
1.2       ohara      98: }
                     99:
1.13      ohara     100: static cmo *call_hook_after_send_cmo(OXFILE *oxfp, cmo *c)
1.2       ohara     101: {
1.13      ohara     102:     if (hook_after_send_cmo != NULL) {
                    103:         return hook_after_send_cmo(oxfp, c);
                    104:     }
                    105:     return c;
1.2       ohara     106: }
1.1       ohara     107:
1.7       ohara     108: /* Handling an error. */
1.1       ohara     109: static int current_received_serial = 0;
                    110:
1.7       ohara     111: /* If an error object be needed, then a server call the following function. */
1.1       ohara     112: cmo_error2* make_error_object(int err_code, cmo *ob)
                    113: {
                    114:     cmo_list* li = new_cmo_list();
1.13      ohara     115:     list_append(li, (cmo *)new_cmo_int32(current_received_serial));
                    116:     list_append(li, (cmo *)new_cmo_int32(err_code));
                    117:     list_append(li, ob);
1.1       ohara     118:     return new_cmo_error2((cmo *)li);
                    119: }
                    120:
1.7       ohara     121: /* getting a next serial number. */
1.13      ohara     122: int next_serial(OXFILE *oxfp)
1.1       ohara     123: {
1.13      ohara     124:     return oxfp->serial_number++;
1.1       ohara     125: }
                    126:
1.7       ohara     127: /* sending an object of int32 type. (not equal to cmo_int32 type)  */
1.13      ohara     128: int send_int32(OXFILE *oxfp, int int32)
1.1       ohara     129: {
1.13      ohara     130:     return oxfp->send_int32(oxfp, int32);
1.1       ohara     131: }
                    132:
1.13      ohara     133: /* receiving an object of int32 type. (not equal to cmo_int32 type)  */
                    134: int receive_int32(OXFILE *oxfp)
1.1       ohara     135: {
1.13      ohara     136:     return oxfp->receive_int32(oxfp);
1.1       ohara     137: }
                    138:
1.32      ohara     139: /* sending an object of int32 type. (not equal to cmo_int32 type)  */
                    140: int send_double(OXFILE *oxfp, double d)
                    141: {
                    142:     return oxfp->send_double(oxfp, d);
                    143: }
                    144:
                    145: /* receiving an object of int32 type. (not equal to cmo_int32 type)  */
                    146: double receive_double(OXFILE *oxfp)
                    147: {
                    148:     return oxfp->receive_double(oxfp);
                    149: }
                    150:
1.13      ohara     151: /* receiving an (OX_tag, serial number)  */
                    152: int receive_ox_tag(OXFILE *oxfp)
1.1       ohara     153: {
1.13      ohara     154:     int tag = receive_int32(oxfp);
1.16      ohara     155:     oxfp->received_serial_number = receive_int32(oxfp);
1.13      ohara     156:     return tag;
1.1       ohara     157: }
                    158:
1.13      ohara     159: /* sending an (OX_tag, serial number)  */
                    160: int send_ox_tag(OXFILE *oxfp, int tag)
1.3       ohara     161: {
1.13      ohara     162:     send_int32(oxfp, tag);
                    163:     return send_int32(oxfp, next_serial(oxfp));
1.1       ohara     164: }
                    165:
1.7       ohara     166: /* functions named receive_cmo_*. */
1.13      ohara     167: static cmo_null* receive_cmo_null(OXFILE *oxfp)
1.1       ohara     168: {
                    169:     return new_cmo_null();
                    170: }
                    171:
1.13      ohara     172: static cmo_int32* receive_cmo_int32(OXFILE *oxfp)
1.1       ohara     173: {
1.13      ohara     174:     int i = receive_int32(oxfp);
1.1       ohara     175:     return new_cmo_int32(i);
                    176: }
                    177:
1.13      ohara     178: static cmo_string* receive_cmo_string(OXFILE *oxfp)
1.1       ohara     179: {
1.13      ohara     180:     int len = receive_int32(oxfp);
1.25      ohara     181:     char* s = MALLOC(len+1);
1.1       ohara     182:     memset(s, '\0', len+1);
                    183:     if (len > 0) {
1.13      ohara     184:         oxf_read(s, 1, len, oxfp);
1.1       ohara     185:     }
                    186:     return new_cmo_string(s);
                    187: }
                    188:
1.13      ohara     189: static cmo_mathcap* receive_cmo_mathcap(OXFILE *oxfp)
1.1       ohara     190: {
1.13      ohara     191:     cmo* ob = receive_cmo(oxfp);
1.1       ohara     192:     return new_cmo_mathcap(ob);
                    193: }
                    194:
1.13      ohara     195: static cmo_list* receive_cmo_list(OXFILE *oxfp)
1.1       ohara     196: {
                    197:     cmo* ob;
                    198:     cmo_list* c = new_cmo_list();
1.13      ohara     199:     int len = receive_int32(oxfp);
1.1       ohara     200:
                    201:     while (len>0) {
1.13      ohara     202:         ob = receive_cmo(oxfp);
                    203:         list_append(c, ob);
1.1       ohara     204:         len--;
                    205:     }
                    206:     return c;
                    207: }
                    208:
1.13      ohara     209: static cmo_monomial32* receive_cmo_monomial32(OXFILE *oxfp)
1.1       ohara     210: {
                    211:     int i;
1.13      ohara     212:     int len = receive_int32(oxfp);
1.1       ohara     213:     cmo_monomial32* c = new_cmo_monomial32(len);
                    214:
                    215:     for(i=0; i<len; i++) {
1.13      ohara     216:         c->exps[i] = receive_int32(oxfp);
1.1       ohara     217:     }
1.13      ohara     218:     c->coef = receive_cmo(oxfp);
1.1       ohara     219:     return c;
                    220: }
                    221:
1.13      ohara     222: static cmo_zz* receive_cmo_zz(OXFILE *oxfp)
1.1       ohara     223: {
                    224:     cmo_zz* c = new_cmo_zz();
1.13      ohara     225:     receive_mpz(oxfp, c->mpz);
1.1       ohara     226:     return c;
                    227: }
                    228:
1.33      ohara     229: static cmo_qq* receive_cmo_qq(OXFILE *oxfp)
                    230: {
1.34      ohara     231:     mpz_t num, den;
                    232:     mpz_init(num);
                    233:     mpz_init(den);
                    234:     receive_mpz(oxfp, num);
                    235:     receive_mpz(oxfp, den);
                    236:     return new_cmo_qq_set_mpz(num, den);
1.33      ohara     237: }
                    238:
1.38    ! noro      239: static cmo_bf* receive_cmo_bf(OXFILE *oxfp)
        !           240: {
        !           241:     mpfr_t num;
        !           242:     mpfr_init(num);
        !           243:     receive_mpfr(oxfp, num);
        !           244:     return new_cmo_bf_set_mpfr(num);
        !           245: }
        !           246:
1.13      ohara     247: static cmo_zero* receive_cmo_zero(OXFILE *oxfp)
1.1       ohara     248: {
                    249:     return new_cmo_zero();
                    250: }
                    251:
1.13      ohara     252: static cmo_dms_generic* receive_cmo_dms_generic(OXFILE *oxfp)
1.1       ohara     253: {
                    254:     return new_cmo_dms_generic();
                    255: }
                    256:
1.13      ohara     257: static cmo_ring_by_name* receive_cmo_ring_by_name(OXFILE *oxfp)
1.1       ohara     258: {
1.13      ohara     259:     cmo* ob = receive_cmo(oxfp);
                    260:     /* We need to check semantics but yet ... */
1.1       ohara     261:     return new_cmo_ring_by_name(ob);
                    262: }
                    263:
1.26      ohara     264: static cmo_recursive_polynomial* receive_cmo_recursive_polynomial(OXFILE *oxfp)
                    265: {
1.27      ohara     266:        cmo_list* ringdef = (cmo_list *)receive_cmo(oxfp);
                    267:        cmo* coef         = receive_cmo(oxfp);
1.26      ohara     268:     return new_cmo_recursive_polynomial(ringdef, coef);
                    269: }
                    270:
1.13      ohara     271: static cmo_distributed_polynomial* receive_cmo_distributed_polynomial(OXFILE *oxfp)
1.1       ohara     272: {
                    273:     cmo* ob;
                    274:     cmo_distributed_polynomial* c = new_cmo_distributed_polynomial();
1.13      ohara     275:     int len = receive_int32(oxfp);
                    276:     c->ringdef = receive_cmo(oxfp);
1.1       ohara     277:
                    278:     while (len>0) {
1.13      ohara     279:         ob = receive_cmo(oxfp);
                    280:         list_append((cmo_list *)c, ob);
1.1       ohara     281:         len--;
                    282:     }
                    283:     return c;
                    284: }
                    285:
1.26      ohara     286: static cmo_polynomial_in_one_variable* receive_cmo_polynomial_in_one_variable(OXFILE *oxfp)
                    287: {
                    288:     cmo* coef;
                    289:     cmo_polynomial_in_one_variable* c;
                    290:     int len = receive_int32(oxfp);
                    291:     int var = receive_int32(oxfp);
                    292:     int exp;
                    293:     c = new_cmo_polynomial_in_one_variable(var);
                    294:     while (len>0) {
                    295:         exp  = receive_int32(oxfp);
                    296:         coef = receive_cmo(oxfp);
1.27      ohara     297:         list_append_monomial((cmo_list *)c, coef, exp);
1.26      ohara     298:         len--;
                    299:     }
                    300:     return c;
                    301: }
                    302:
1.32      ohara     303: static cmo_double* receive_cmo_double(OXFILE *oxfp)
                    304: {
                    305:        double d = receive_double(oxfp);
                    306:        return new_cmo_double(d);
                    307: }
                    308:
1.29      ohara     309: static cmo_indeterminate* receive_cmo_indeterminate(OXFILE *oxfp)
                    310: {
                    311:     cmo* ob = receive_cmo(oxfp);
                    312:     return new_cmo_indeterminate(ob);
                    313: }
                    314:
1.28      ohara     315: static cmo_tree* receive_cmo_tree(OXFILE *oxfp)
                    316: {
                    317:     cmo_string* name = (cmo_string *)receive_cmo(oxfp);
                    318:     cmo_list* attrib = (cmo_list *)receive_cmo(oxfp);
                    319:     cmo_list* leaves = (cmo_list *)receive_cmo(oxfp);
                    320:     return new_cmo_tree(name, attrib, leaves);
                    321: }
                    322:
                    323: static cmo_lambda* receive_cmo_lambda(OXFILE *oxfp)
                    324: {
                    325:     cmo_list* args = (cmo_list *)receive_cmo(oxfp);
                    326:     cmo_tree* body = (cmo_tree *)receive_cmo(oxfp);
                    327:     return new_cmo_lambda(args, body);
                    328: }
                    329:
1.13      ohara     330: static cmo_error2* receive_cmo_error2(OXFILE *oxfp)
1.1       ohara     331: {
1.13      ohara     332:     cmo* ob = receive_cmo(oxfp);
1.1       ohara     333:     return new_cmo_error2(ob);
                    334: }
                    335:
1.17      ohara     336: /* receive_cmo() is called after receive_ox_tag(). */
1.13      ohara     337: cmo* receive_cmo(OXFILE *oxfp)
1.1       ohara     338: {
1.24      ohara     339:     int tag = receive_int32(oxfp);
                    340:     return receive_cmo_tag(oxfp, tag);
                    341: }
                    342:
                    343: cmo *receive_cmo_tag(OXFILE *oxfp, int tag)
                    344: {
1.1       ohara     345:     cmo* m;
                    346:     switch(tag) {
                    347:     case CMO_NULL:
1.13      ohara     348:         m = receive_cmo_null(oxfp);
1.1       ohara     349:         break;
                    350:     case CMO_INT32:
1.13      ohara     351:         m = (cmo *)receive_cmo_int32(oxfp);
1.1       ohara     352:         break;
                    353:     case CMO_STRING:
1.13      ohara     354:         m = (cmo *)receive_cmo_string(oxfp);
1.1       ohara     355:         break;
                    356:     case CMO_MATHCAP:
1.13      ohara     357:         m = (cmo *)receive_cmo_mathcap(oxfp);
1.1       ohara     358:         break;
                    359:     case CMO_LIST:
1.13      ohara     360:         m = (cmo *)receive_cmo_list(oxfp);
1.1       ohara     361:         break;
                    362:     case CMO_MONOMIAL32:
1.13      ohara     363:         m = (cmo *)receive_cmo_monomial32(oxfp);
1.1       ohara     364:         break;
                    365:     case CMO_ZZ:
1.13      ohara     366:         m = (cmo *)receive_cmo_zz(oxfp);
1.1       ohara     367:         break;
1.33      ohara     368:     case CMO_QQ:
                    369:         m = (cmo *)receive_cmo_qq(oxfp);
                    370:         break;
1.38    ! noro      371:     case CMO_BIGFLOAT:
        !           372:         m = (cmo *)receive_cmo_bf(oxfp);
        !           373:         break;
1.1       ohara     374:     case CMO_ZERO:
1.13      ohara     375:         m = (cmo *)receive_cmo_zero(oxfp);
1.1       ohara     376:         break;
                    377:     case CMO_DMS_GENERIC:
1.13      ohara     378:         m = (cmo *)receive_cmo_dms_generic(oxfp);
1.1       ohara     379:         break;
                    380:     case CMO_RING_BY_NAME:
1.13      ohara     381:         m = (cmo *)receive_cmo_ring_by_name(oxfp);
1.1       ohara     382:         break;
                    383:     case CMO_DISTRIBUTED_POLYNOMIAL:
1.13      ohara     384:         m = (cmo *)receive_cmo_distributed_polynomial(oxfp);
1.1       ohara     385:         break;
1.26      ohara     386:     case CMO_RECURSIVE_POLYNOMIAL:
                    387:         m = (cmo *)receive_cmo_recursive_polynomial(oxfp);
                    388:         break;
                    389:     case CMO_POLYNOMIAL_IN_ONE_VARIABLE:
                    390:         m = (cmo *)receive_cmo_polynomial_in_one_variable(oxfp);
1.29      ohara     391:         break;
1.32      ohara     392:        case CMO_64BIT_MACHINE_DOUBLE:
                    393:        case CMO_IEEE_DOUBLE_FLOAT:
                    394:         m = (cmo *)receive_cmo_double(oxfp);
                    395:         break;
1.29      ohara     396:     case CMO_INDETERMINATE:
                    397:         m = (cmo *)receive_cmo_indeterminate(oxfp);
1.28      ohara     398:         break;
                    399:     case CMO_TREE:
                    400:         m = (cmo *)receive_cmo_tree(oxfp);
                    401:         break;
                    402:     case CMO_LAMBDA:
                    403:         m = (cmo *)receive_cmo_lambda(oxfp);
                    404:         break;
1.1       ohara     405:     case CMO_ERROR2:
1.13      ohara     406:         m = (cmo *)receive_cmo_error2(oxfp);
1.1       ohara     407:         break;
                    408:     case CMO_DATUM:
                    409:     default:
1.13      ohara     410:         m = NULL;
1.20      ohara     411:         ox_printf("the CMO (%d) is not implemented.\n", tag);
1.1       ohara     412:     }
                    413:     return m;
                    414: }
                    415:
1.13      ohara     416: static void receive_mpz(OXFILE *oxfp, mpz_ptr mpz)
1.1       ohara     417: {
                    418:     int i;
1.36      iwane     419:     int n = sizeof(mpz->_mp_d[0]) / sizeof(int);
1.13      ohara     420:     int size  = receive_int32(oxfp);
1.1       ohara     421:     int len   = abs(size);
1.36      iwane     422:     int *ptr;
                    423:     if (n == 1) {
                    424:         resize_mpz(mpz, size);
1.37      iwane     425:     } else if (size >= 0) {
                    426:         resize_mpz(mpz, (size+1) / n);
1.36      iwane     427:     } else {
1.37      iwane     428:         resize_mpz(mpz, (size-1) / n);
1.36      iwane     429:     }
                    430:
                    431:     ptr = (int *)mpz->_mp_d;
                    432:     for(i=0; i<len; i++) {
                    433:         ptr[i] = receive_int32(oxfp);
                    434:     }
1.1       ohara     435: }
                    436:
1.13      ohara     437: void send_ox_command(OXFILE *oxfp, int sm_command)
1.1       ohara     438: {
1.13      ohara     439:     send_ox_tag(oxfp, OX_COMMAND);
                    440:     send_int32(oxfp, sm_command);
                    441:     oxf_flush(oxfp);
1.1       ohara     442: }
                    443:
1.13      ohara     444: void ox_close(OXFILE *sv)
1.1       ohara     445: {
1.13      ohara     446:     send_ox_command(oxf_control(sv), SM_control_kill);
1.7       ohara     447:     sleep(2);
1.13      ohara     448:     /* We wait thar an OpenXM server terminates. */
1.20      ohara     449:     ox_printf("I have closed the connection to an Open XM server.\n");
1.1       ohara     450: }
                    451:
1.13      ohara     452: void ox_shutdown(OXFILE *sv)
1.3       ohara     453: {
1.13      ohara     454:     /* We need to use SM_shutdown but yet ... */
                    455:     ox_close(sv);
1.3       ohara     456: }
                    457:
1.13      ohara     458: void ox_cmo_rpc(OXFILE *sv, char *function, int argc, cmo *argv[])
1.3       ohara     459: {
1.13      ohara     460:     int i = argc;
                    461:     while(i-- > 0) {
                    462:         send_ox_cmo(sv, argv[i]);
                    463:     }
                    464:     send_ox_cmo(sv, (cmo *)new_cmo_int32(argc));
                    465:     send_ox_cmo(sv, (cmo *)new_cmo_string(function));
                    466:     send_ox_command(sv, SM_executeFunction);
1.3       ohara     467: }
                    468:
1.13      ohara     469: void ox_execute_string(OXFILE *sv, char* s)
1.3       ohara     470: {
1.13      ohara     471:     send_ox_cmo(sv, (cmo *)new_cmo_string(s));
                    472:     send_ox_command(sv, SM_executeStringByLocalParser);
1.3       ohara     473: }
                    474:
1.13      ohara     475: void ox_push_cmd(OXFILE *sv, int sm_code)
1.1       ohara     476: {
1.13      ohara     477:     send_ox_command(sv, sm_code);
1.1       ohara     478: }
                    479:
1.13      ohara     480: cmo_mathcap* ox_mathcap(OXFILE *sv)
1.1       ohara     481: {
1.13      ohara     482:     send_ox_command(sv, SM_mathcap);
                    483:     send_ox_command(sv, SM_popCMO);
                    484:     receive_ox_tag(sv);          /* OX_DATA */
                    485:     return (cmo_mathcap *)receive_cmo(sv);
1.1       ohara     486: }
                    487:
1.13      ohara     488: char* ox_popString(OXFILE *sv)
1.1       ohara     489: {
                    490:     cmo_string* m = NULL;
                    491:
1.13      ohara     492:     send_ox_command(sv, SM_popString);
                    493:     receive_ox_tag(sv); /* OX_DATA */
                    494:     m = (cmo_string *)receive_cmo(sv);
1.1       ohara     495:     return m->s;
                    496: }
                    497:
1.13      ohara     498: void ox_pops(OXFILE *sv, int num)
1.3       ohara     499: {
1.13      ohara     500:     send_ox_cmo(sv, (cmo *)new_cmo_int32(num));
                    501:     send_ox_command(sv, SM_pops);
1.3       ohara     502: }
                    503:
1.13      ohara     504: cmo* ox_pop_cmo(OXFILE *sv)
1.3       ohara     505: {
1.13      ohara     506:     send_ox_command(sv, SM_popCMO);
                    507:     receive_ox_tag(sv); /* OX_DATA */
                    508:     return receive_cmo(sv);
1.3       ohara     509: }
                    510:
1.13      ohara     511: void ox_push_cmo(OXFILE *sv, cmo *c)
1.3       ohara     512: {
1.13      ohara     513:     send_ox_cmo(sv, c);
1.3       ohara     514: }
                    515:
1.7       ohara     516: /* a dummy function for flushing a connection. */
1.13      ohara     517: int ox_flush(OXFILE *sv)
1.5       ohara     518: {
1.13      ohara     519:     return 1;
1.5       ohara     520: }
                    521:
1.13      ohara     522: void ox_reset(OXFILE *sv)
1.1       ohara     523: {
1.13      ohara     524:     send_ox_command(oxf_control(sv), SM_control_reset_connection);
1.31      iwane     525:     while(receive_ox_tag(sv) != OX_SYNC_BALL) {
                    526:         receive_cmo(sv); /* skipping a message. */
1.1       ohara     527:     }
                    528:
1.13      ohara     529:     send_ox_tag(sv, OX_SYNC_BALL);
1.20      ohara     530:     ox_printf("I have reset an Open XM server.\n");
1.1       ohara     531: }
                    532:
1.13      ohara     533: void send_ox(OXFILE *oxfp, ox *m)
1.1       ohara     534: {
                    535:     switch(m->tag) {
1.13      ohara     536:     case OX_DATA:
                    537:         send_ox_cmo(oxfp, ((ox_data *)m)->cmo);
1.1       ohara     538:         break;
1.13      ohara     539:     case OX_COMMAND:
                    540:         send_ox_command(oxfp, ((ox_command *)m)->command);
1.1       ohara     541:         break;
                    542:     default:
                    543:         /* CMO?? */
1.13      ohara     544:         send_ox_cmo(oxfp, (cmo *)m);
1.1       ohara     545:     }
                    546: }
                    547:
1.13      ohara     548: void send_ox_cmo(OXFILE *oxfp, cmo* m)
1.1       ohara     549: {
1.13      ohara     550:     send_ox_tag(oxfp, OX_DATA);
                    551:     send_cmo(oxfp, m);
                    552:     oxf_flush(oxfp);
1.1       ohara     553: }
                    554:
1.8       ohara     555: /* send_cmo_* functions */
1.13      ohara     556: static int send_cmo_null(OXFILE *oxfp, cmo_null* c)
1.1       ohara     557: {
                    558:     return 0;
                    559: }
                    560:
1.13      ohara     561: static int send_cmo_int32(OXFILE *oxfp, cmo_int32* m)
1.1       ohara     562: {
1.13      ohara     563:     return send_int32(oxfp, m->i);
1.1       ohara     564: }
                    565:
1.13      ohara     566: static int send_cmo_string(OXFILE *oxfp, cmo_string* m)
1.1       ohara     567: {
                    568:     int len = (m->s != NULL)? strlen(m->s): 0;
1.13      ohara     569:     send_int32(oxfp, len);
1.1       ohara     570:     if (len > 0) {
1.13      ohara     571:         oxf_write(m->s, 1, len, oxfp);
1.1       ohara     572:     }
                    573:     return 0;
                    574: }
                    575:
1.13      ohara     576: static int send_cmo_mathcap(OXFILE *oxfp, cmo_mathcap* c)
1.1       ohara     577: {
1.13      ohara     578:     send_cmo(oxfp, c->ob);
1.1       ohara     579:     return 0;
                    580: }
                    581:
1.13      ohara     582: static int send_cmo_list(OXFILE *oxfp, cmo_list* c)
1.1       ohara     583: {
1.13      ohara     584:     cell* el = list_first(c);
                    585:     int len = list_length(c);
                    586:     send_int32(oxfp, len);
                    587:
                    588:     while(!list_endof(c, el)) {
                    589:         send_cmo(oxfp, el->cmo);
                    590:         el = list_next(el);
1.1       ohara     591:     }
                    592:     return 0;
                    593: }
                    594:
1.13      ohara     595: static int send_cmo_distributed_polynomial(OXFILE *oxfp, cmo_distributed_polynomial* c)
1.1       ohara     596: {
1.13      ohara     597:     cell* el = list_first((cmo_list *)c);
                    598:     int len = list_length((cmo_list *)c);
                    599:     send_int32(oxfp, len);
                    600:     send_cmo(oxfp, c->ringdef);
                    601:     while(!list_endof((cmo_list *)c, el)) {
                    602:         send_cmo(oxfp, el->cmo);
                    603:         el = list_next(el);
1.1       ohara     604:     }
                    605:     return 0;
                    606: }
                    607:
1.26      ohara     608: static int send_cmo_polynomial_in_one_variable(OXFILE *oxfp, cmo_polynomial_in_one_variable* c)
                    609: {
1.27      ohara     610:     cell* el = list_first((cmo_list *)c);
                    611:     int len = list_length((cmo_list *)c);
1.26      ohara     612:     send_int32(oxfp, len);
                    613:        send_int32(oxfp, c->var);
                    614:
1.27      ohara     615:     while(!list_endof((cmo_list *)c, el)) {
                    616:         send_int32(oxfp, el->exp);
1.26      ohara     617:         send_cmo(oxfp, el->cmo);
                    618:         el = list_next(el);
                    619:     }
                    620:     return 0;
                    621: }
                    622:
1.32      ohara     623: static int send_cmo_double(OXFILE *oxfp, cmo_double* c)
                    624: {
                    625:     return send_double(oxfp, c->d);
                    626: }
                    627:
1.13      ohara     628: static int send_cmo_monomial32(OXFILE *oxfp, cmo_monomial32* c)
1.1       ohara     629: {
                    630:     int i;
                    631:     int len = c->length;
1.13      ohara     632:     send_int32(oxfp, len);
1.1       ohara     633:     for(i=0; i<len; i++) {
1.13      ohara     634:         send_int32(oxfp, c->exps[i]);
1.1       ohara     635:     }
1.13      ohara     636:     send_cmo(oxfp, c->coef);
1.1       ohara     637:     return 0;
                    638: }
                    639:
1.13      ohara     640: static int send_cmo_zz(OXFILE *oxfp, cmo_zz* c)
1.1       ohara     641: {
1.13      ohara     642:     send_mpz(oxfp, c->mpz);
1.1       ohara     643:     return 0;
                    644: }
                    645:
1.33      ohara     646: static int send_cmo_qq(OXFILE *oxfp, cmo_qq* c)
                    647: {
1.34      ohara     648:     send_mpz(oxfp, mpq_numref(c->mpq));
                    649:     send_mpz(oxfp, mpq_denref(c->mpq));
1.33      ohara     650:     return 0;
                    651: }
                    652:
1.38    ! noro      653: static int send_cmo_bf(OXFILE *oxfp, cmo_bf* c)
        !           654: {
        !           655:     send_mpfr(oxfp, c->mpfr);
        !           656:     return 0;
        !           657: }
        !           658:
1.26      ohara     659: static int send_cmo_recursive_polynomial(OXFILE *oxfp, cmo_recursive_polynomial* c)
                    660: {
1.27      ohara     661:        send_cmo(oxfp, (cmo *)c->ringdef);
1.26      ohara     662:     send_cmo(oxfp, c->coef);
                    663:     return 0;
                    664: }
                    665:
1.28      ohara     666: static int send_cmo_tree(OXFILE *oxfp, cmo_tree *c)
                    667: {
                    668:     send_cmo(oxfp, (cmo *)c->name);
                    669:     send_cmo(oxfp, (cmo *)c->attributes);
                    670:     send_cmo(oxfp, (cmo *)c->leaves);
                    671:     return 0;
                    672: }
                    673:
                    674: static int send_cmo_lambda(OXFILE *oxfp, cmo_lambda *c)
                    675: {
                    676:     send_cmo(oxfp, (cmo *)c->args);
                    677:     send_cmo(oxfp, (cmo *)c->body);
                    678:     return 0;
                    679: }
                    680:
1.13      ohara     681: static int send_cmo_error2(OXFILE *oxfp, cmo_error2* c)
1.1       ohara     682: {
1.13      ohara     683:     send_cmo(oxfp, c->ob);
1.1       ohara     684:     return 0;
                    685: }
                    686:
1.8       ohara     687: /* sending a CMO.  (Remarks: OX_tag is already sent.) */
1.13      ohara     688: void send_cmo(OXFILE *oxfp, cmo* c)
1.1       ohara     689: {
                    690:     int tag = c->tag;
                    691:
1.13      ohara     692:     c = call_hook_before_send_cmo(oxfp, c);
1.2       ohara     693:
1.13      ohara     694:     send_int32(oxfp, tag);
1.1       ohara     695:     switch(tag) {
                    696:     case CMO_NULL:
                    697:     case CMO_ZERO:
                    698:     case CMO_DMS_GENERIC:
1.13      ohara     699:         send_cmo_null(oxfp, c);  /* empty function. */
1.1       ohara     700:         break;
                    701:     case CMO_INT32:
1.13      ohara     702:         send_cmo_int32(oxfp, (cmo_int32 *)c);
1.1       ohara     703:         break;
                    704:     case CMO_STRING:
1.13      ohara     705:         send_cmo_string(oxfp, (cmo_string *)c);
1.1       ohara     706:         break;
                    707:     case CMO_MATHCAP:
                    708:     case CMO_ERROR2:
                    709:     case CMO_RING_BY_NAME:
                    710:     case CMO_INDETERMINATE:
1.13      ohara     711:         send_cmo_mathcap(oxfp, (cmo_mathcap *)c);
1.1       ohara     712:         break;
                    713:     case CMO_LIST:
1.13      ohara     714:         send_cmo_list(oxfp, (cmo_list *)c);
1.1       ohara     715:         break;
                    716:     case CMO_MONOMIAL32:
1.13      ohara     717:         send_cmo_monomial32(oxfp, (cmo_monomial32 *)c);
1.1       ohara     718:         break;
                    719:     case CMO_ZZ:
1.13      ohara     720:         send_cmo_zz(oxfp, (cmo_zz *)c);
1.33      ohara     721:         break;
                    722:     case CMO_QQ:
                    723:         send_cmo_qq(oxfp, (cmo_qq *)c);
1.1       ohara     724:         break;
1.38    ! noro      725:     case CMO_BIGFLOAT:
        !           726:         send_cmo_bf(oxfp, (cmo_bf *)c);
        !           727:         break;
1.1       ohara     728:     case CMO_DISTRIBUTED_POLYNOMIAL:
1.13      ohara     729:         send_cmo_distributed_polynomial(oxfp, (cmo_distributed_polynomial *)c);
1.26      ohara     730:         break;
                    731:     case CMO_RECURSIVE_POLYNOMIAL:
                    732:         send_cmo_recursive_polynomial(oxfp, (cmo_recursive_polynomial *)c);
                    733:         break;
                    734:     case CMO_POLYNOMIAL_IN_ONE_VARIABLE:
                    735:         send_cmo_polynomial_in_one_variable(oxfp, (cmo_polynomial_in_one_variable *)c);
1.28      ohara     736:         break;
1.32      ohara     737:        case CMO_64BIT_MACHINE_DOUBLE:
                    738:        case CMO_IEEE_DOUBLE_FLOAT:
                    739:                send_cmo_double(oxfp, (cmo_double *)c);
                    740:                break;
1.28      ohara     741:     case CMO_TREE:
                    742:         send_cmo_tree(oxfp, (cmo_tree *)c);
                    743:         break;
                    744:     case CMO_LAMBDA:
                    745:         send_cmo_lambda(oxfp, (cmo_lambda *)c);
1.1       ohara     746:         break;
                    747:     default:
1.13      ohara     748:         call_hook_after_send_cmo(oxfp, c);
1.1       ohara     749:     }
                    750: }
                    751:
1.13      ohara     752: static int send_mpz(OXFILE *oxfp, mpz_ptr mpz)
1.1       ohara     753: {
                    754:     int i;
1.35      iwane     755:        int n = sizeof(mpz->_mp_d[0]) / sizeof(int);
                    756:     int len = abs(mpz->_mp_size) * n;
                    757:        int *ptr = (int *)mpz->_mp_d;
1.37      iwane     758:     int size;
1.35      iwane     759:     send_int32(oxfp, mpz->_mp_size * n);
1.38    ! noro      760: #if 0
1.37      iwane     761:     if (len > 0 && ptr[len-1] == 0) {
                    762:         len--;
                    763:     }
                    764:     size = mpz->_mp_size < 0 ? -len : len;
                    765:     send_int32(oxfp, size);
1.38    ! noro      766: #endif
1.1       ohara     767:     for(i=0; i<len; i++) {
1.35      iwane     768:         send_int32(oxfp, ptr[i]);
1.1       ohara     769:     }
                    770:     return 0;
                    771: }
                    772:
1.38    ! noro      773: void send_int64(OXFILE *oxfp,UL64 a)
        !           774: {
        !           775:   send_int32(oxfp, a>>32);
        !           776:   send_int32(oxfp, a&0xffffffff);
        !           777: }
        !           778:
        !           779: UL64 receive_int64(OXFILE *oxfp)
        !           780: {
        !           781:   UL64 u,l;
        !           782:
        !           783:   u = receive_int32(oxfp);
        !           784:   l = receive_int32(oxfp);
        !           785:   return (u<<32)|l;
        !           786: }
        !           787:
        !           788: static void receive_mpfr(OXFILE *oxfp, mpfr_ptr mpfr)
        !           789: {
        !           790:   int sgn,prec,len,i;
        !           791:   long *ptr;
        !           792:   L64 exp;
        !           793:
        !           794:   sgn  = receive_int32(oxfp);
        !           795:   prec  = receive_int32(oxfp);
        !           796:   exp  = receive_int64(oxfp);
        !           797:   /* len = length as an int array (int = 4bytes) */
        !           798:   len  = receive_int32(oxfp);
        !           799:
        !           800:   mpfr_init2(mpfr,prec);
        !           801:   MPFR_SIGN(mpfr) = sgn;
        !           802:   ptr = mpfr->_mpfr_d;
        !           803:   mpfr->_mpfr_exp = exp;
        !           804: #if SIZEOF_LONG==4
        !           805:   for ( i = 0; i < len; i++ )
        !           806:     ptr[i] = receive_int32(oxfp);
        !           807: #else
        !           808:   len >>= 1;
        !           809:   for ( i = 0; i < len; i++ )
        !           810:     ptr[i] = receive_int64(oxfp);
        !           811: #endif
        !           812: }
        !           813:
        !           814: static int send_mpfr(OXFILE *oxfp, mpfr_ptr mpfr)
        !           815: {
        !           816:
        !           817:   int i,len;
        !           818:   long *ptr;
        !           819:
        !           820:   send_int32(oxfp, MPFR_SIGN(mpfr));
        !           821:   send_int32(oxfp, MPFR_PREC(mpfr));
        !           822:   send_int64(oxfp, MPFR_EXP(mpfr));
        !           823:   len = MPFR_LIMB_SIZE(mpfr);
        !           824:   ptr = MPFR_MANT(mpfr);
        !           825: #if SIZEOF_LONG==4
        !           826:   send_int32(oxfp, len);
        !           827:   for ( i = 0; i < len; i++ )
        !           828:     send_int32(oxfp,ptr[i]);
        !           829: #else /* SIZEOF_LONG==8 */
        !           830:   send_int32(oxfp, 2*len);
        !           831:   for ( i = 0; i < len; i++ )
        !           832:     send_int64(oxfp,ptr[i]);
        !           833: #endif
        !           834:     return 0;
        !           835: }
        !           836:
1.1       ohara     837: ox_data* new_ox_data(cmo* c)
                    838: {
1.25      ohara     839:     ox_data* m = MALLOC(sizeof(ox_data));
1.1       ohara     840:     m->tag = OX_DATA;
                    841:     m->cmo = c;
                    842:     return m;
                    843: }
                    844:
                    845: ox_command* new_ox_command(int sm_code)
                    846: {
1.25      ohara     847:     ox_command* m = MALLOC(sizeof(ox_command));
1.1       ohara     848:     m->tag = OX_COMMAND;
                    849:     m->command = sm_code;
                    850:     return m;
                    851: }
                    852:
                    853: ox_sync_ball* new_ox_sync_ball()
                    854: {
1.25      ohara     855:     ox_sync_ball *m = MALLOC(sizeof(ox_sync_ball));
1.1       ohara     856:     m->tag = OX_SYNC_BALL;
                    857:     return m;
1.19      ohara     858: }
                    859:
                    860: int ox_stderr_init(FILE *fp)
                    861: {
1.21      ohara     862:     ox_stderr = fp;
                    863:     if (ox_stderr != NULL) {
                    864:         setbuf(ox_stderr, NULL);
                    865:     }
1.27      ohara     866:     return 0;
1.20      ohara     867: }
                    868:
                    869: int ox_printf(char *format, ...)
                    870: {
1.21      ohara     871:     if (ox_stderr != NULL) {
                    872:         va_list ap;
                    873:         va_start(ap, format);
                    874:         vfprintf(ox_stderr, format, ap);
                    875:     }
1.27      ohara     876:     return 0;
1.1       ohara     877: }

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