[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.25

1.1       ohara       1: /* -*- mode: C; coding: euc-japan -*- */
1.25    ! ohara       2: /* $OpenXM: OpenXM/src/ox_toolkit/ox.c,v 1.24 2003/05/25 16:35:40 ohara 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:
                     19: #include "mysocket.h"
1.12      ohara      20: #include "ox_toolkit.h"
1.1       ohara      21: #include "parse.h"
                     22:
1.20      ohara      23: static FILE *ox_stderr = NULL;
                     24:
1.17      ohara      25: /* sorting by the value of CMO_xxx.  (for debugging) */
1.13      ohara      26: static cmo_null*         receive_cmo_null(OXFILE *oxfp);
                     27: static cmo_int32*        receive_cmo_int32(OXFILE *oxfp);
                     28: static cmo_string*       receive_cmo_string(OXFILE *oxfp);
                     29: static cmo_mathcap*      receive_cmo_mathcap(OXFILE *oxfp);
                     30: static cmo_list*         receive_cmo_list(OXFILE *oxfp);
                     31: static cmo_monomial32*   receive_cmo_monomial32(OXFILE *oxfp);
                     32: static cmo_zero*         receive_cmo_zero(OXFILE *oxfp);
                     33: static cmo_dms_generic*  receive_cmo_dms_generic(OXFILE *oxfp);
                     34: static cmo_ring_by_name* receive_cmo_ring_by_name(OXFILE *oxfp);
                     35: static cmo_distributed_polynomial* receive_cmo_distributed_polynomial(OXFILE *oxfp);
                     36: static cmo_error2*       receive_cmo_error2(OXFILE *oxfp);
                     37:
                     38: static int          send_cmo_null(OXFILE *oxfp, cmo_null* c);
                     39: static int          send_cmo_int32(OXFILE *oxfp, cmo_int32* m);
                     40: static int          send_cmo_string(OXFILE *oxfp, cmo_string* m);
                     41: static int          send_cmo_mathcap(OXFILE *oxfp, cmo_mathcap* c);
                     42: static int          send_cmo_list(OXFILE *oxfp, cmo_list* c);
                     43: static int          send_cmo_monomial32(OXFILE *oxfp, cmo_monomial32* c);
1.22      ohara      44: static int          send_cmo_error2(OXFILE *oxfp, cmo_error2* c);
                     45: static int          send_cmo_distributed_polynomial(OXFILE *oxfp, cmo_distributed_polynomial* c);
                     46:
                     47: static cmo_zz*      receive_cmo_zz(OXFILE *oxfp);
                     48: static void         receive_mpz(OXFILE *oxfp, mpz_ptr mpz);
1.13      ohara      49: static int          send_cmo_zz(OXFILE *oxfp, cmo_zz* c);
                     50: static int          send_mpz(OXFILE *oxfp, mpz_ptr mpz);
1.3       ohara      51:
1.8       ohara      52: /* hook functions. (yet not implemented) */
1.2       ohara      53: static hook_t hook_before_send_cmo = NULL;
                     54: static hook_t hook_after_send_cmo  = NULL;
                     55:
                     56: int add_hook_before_send_cmo(hook_t func)
                     57: {
1.13      ohara      58:     hook_before_send_cmo = func;
                     59:     return 0;
1.2       ohara      60: }
                     61:
                     62: int add_hook_after_send_cmo(hook_t func)
                     63: {
1.13      ohara      64:     hook_after_send_cmo = func;
                     65:     return 0;
1.2       ohara      66: }
                     67:
1.13      ohara      68: static cmo *call_hook_before_send_cmo(OXFILE *oxfp, cmo *c)
1.2       ohara      69: {
1.13      ohara      70:     if (hook_before_send_cmo != NULL) {
                     71:         return hook_before_send_cmo(oxfp, c);
                     72:     }
                     73:     return c;
1.2       ohara      74: }
                     75:
1.13      ohara      76: static cmo *call_hook_after_send_cmo(OXFILE *oxfp, cmo *c)
1.2       ohara      77: {
1.13      ohara      78:     if (hook_after_send_cmo != NULL) {
                     79:         return hook_after_send_cmo(oxfp, c);
                     80:     }
                     81:     return c;
1.2       ohara      82: }
1.1       ohara      83:
1.7       ohara      84: /* Handling an error. */
1.1       ohara      85: static int current_received_serial = 0;
                     86:
1.7       ohara      87: /* If an error object be needed, then a server call the following function. */
1.1       ohara      88: cmo_error2* make_error_object(int err_code, cmo *ob)
                     89: {
                     90:     cmo_list* li = new_cmo_list();
1.13      ohara      91:     list_append(li, (cmo *)new_cmo_int32(current_received_serial));
                     92:     list_append(li, (cmo *)new_cmo_int32(err_code));
                     93:     list_append(li, ob);
1.1       ohara      94:     return new_cmo_error2((cmo *)li);
                     95: }
                     96:
1.7       ohara      97: /* getting a next serial number. */
1.13      ohara      98: int next_serial(OXFILE *oxfp)
1.1       ohara      99: {
1.13      ohara     100:     return oxfp->serial_number++;
1.1       ohara     101: }
                    102:
1.7       ohara     103: /* sending an object of int32 type. (not equal to cmo_int32 type)  */
1.13      ohara     104: int send_int32(OXFILE *oxfp, int int32)
1.1       ohara     105: {
1.13      ohara     106:     return oxfp->send_int32(oxfp, int32);
1.1       ohara     107: }
                    108:
1.13      ohara     109: /* receiving an object of int32 type. (not equal to cmo_int32 type)  */
                    110: int receive_int32(OXFILE *oxfp)
1.1       ohara     111: {
1.13      ohara     112:     return oxfp->receive_int32(oxfp);
1.1       ohara     113: }
                    114:
1.13      ohara     115: /* receiving an (OX_tag, serial number)  */
                    116: int receive_ox_tag(OXFILE *oxfp)
1.1       ohara     117: {
1.13      ohara     118:     int tag = receive_int32(oxfp);
1.16      ohara     119:     oxfp->received_serial_number = receive_int32(oxfp);
1.13      ohara     120:     return tag;
1.1       ohara     121: }
                    122:
1.13      ohara     123: /* sending an (OX_tag, serial number)  */
                    124: int send_ox_tag(OXFILE *oxfp, int tag)
1.3       ohara     125: {
1.13      ohara     126:     send_int32(oxfp, tag);
                    127:     return send_int32(oxfp, next_serial(oxfp));
1.1       ohara     128: }
                    129:
1.7       ohara     130: /* functions named receive_cmo_*. */
1.13      ohara     131: static cmo_null* receive_cmo_null(OXFILE *oxfp)
1.1       ohara     132: {
                    133:     return new_cmo_null();
                    134: }
                    135:
1.13      ohara     136: static cmo_int32* receive_cmo_int32(OXFILE *oxfp)
1.1       ohara     137: {
1.13      ohara     138:     int i = receive_int32(oxfp);
1.1       ohara     139:     return new_cmo_int32(i);
                    140: }
                    141:
1.13      ohara     142: static cmo_string* receive_cmo_string(OXFILE *oxfp)
1.1       ohara     143: {
1.13      ohara     144:     int len = receive_int32(oxfp);
1.25    ! ohara     145:     char* s = MALLOC(len+1);
1.1       ohara     146:     memset(s, '\0', len+1);
                    147:     if (len > 0) {
1.13      ohara     148:         oxf_read(s, 1, len, oxfp);
1.1       ohara     149:     }
                    150:     return new_cmo_string(s);
                    151: }
                    152:
1.13      ohara     153: static cmo_mathcap* receive_cmo_mathcap(OXFILE *oxfp)
1.1       ohara     154: {
1.13      ohara     155:     cmo* ob = receive_cmo(oxfp);
1.1       ohara     156:     return new_cmo_mathcap(ob);
                    157: }
                    158:
1.13      ohara     159: static cmo_list* receive_cmo_list(OXFILE *oxfp)
1.1       ohara     160: {
                    161:     cmo* ob;
                    162:     cmo_list* c = new_cmo_list();
1.13      ohara     163:     int len = receive_int32(oxfp);
1.1       ohara     164:
                    165:     while (len>0) {
1.13      ohara     166:         ob = receive_cmo(oxfp);
                    167:         list_append(c, ob);
1.1       ohara     168:         len--;
                    169:     }
                    170:     return c;
                    171: }
                    172:
1.13      ohara     173: static cmo_monomial32* receive_cmo_monomial32(OXFILE *oxfp)
1.1       ohara     174: {
                    175:     int i;
1.13      ohara     176:     int len = receive_int32(oxfp);
1.1       ohara     177:     cmo_monomial32* c = new_cmo_monomial32(len);
                    178:
                    179:     for(i=0; i<len; i++) {
1.13      ohara     180:         c->exps[i] = receive_int32(oxfp);
1.1       ohara     181:     }
1.13      ohara     182:     c->coef = receive_cmo(oxfp);
1.1       ohara     183:     return c;
                    184: }
                    185:
1.13      ohara     186: static cmo_zz* receive_cmo_zz(OXFILE *oxfp)
1.1       ohara     187: {
                    188:     cmo_zz* c = new_cmo_zz();
1.13      ohara     189:     receive_mpz(oxfp, c->mpz);
1.1       ohara     190:     return c;
                    191: }
                    192:
1.13      ohara     193: static cmo_zero* receive_cmo_zero(OXFILE *oxfp)
1.1       ohara     194: {
                    195:     return new_cmo_zero();
                    196: }
                    197:
1.13      ohara     198: static cmo_dms_generic* receive_cmo_dms_generic(OXFILE *oxfp)
1.1       ohara     199: {
                    200:     return new_cmo_dms_generic();
                    201: }
                    202:
1.13      ohara     203: static cmo_ring_by_name* receive_cmo_ring_by_name(OXFILE *oxfp)
1.1       ohara     204: {
1.13      ohara     205:     cmo* ob = receive_cmo(oxfp);
                    206:     /* We need to check semantics but yet ... */
1.1       ohara     207:     return new_cmo_ring_by_name(ob);
                    208: }
                    209:
1.13      ohara     210: static cmo_distributed_polynomial* receive_cmo_distributed_polynomial(OXFILE *oxfp)
1.1       ohara     211: {
                    212:     cmo* ob;
                    213:     cmo_distributed_polynomial* c = new_cmo_distributed_polynomial();
1.13      ohara     214:     int len = receive_int32(oxfp);
                    215:     c->ringdef = receive_cmo(oxfp);
1.1       ohara     216:
                    217:     while (len>0) {
1.13      ohara     218:         ob = receive_cmo(oxfp);
                    219:         list_append((cmo_list *)c, ob);
1.1       ohara     220:         len--;
                    221:     }
                    222:     return c;
                    223: }
                    224:
1.13      ohara     225: static cmo_error2* receive_cmo_error2(OXFILE *oxfp)
1.1       ohara     226: {
1.13      ohara     227:     cmo* ob = receive_cmo(oxfp);
1.1       ohara     228:     return new_cmo_error2(ob);
                    229: }
                    230:
1.17      ohara     231: /* receive_cmo() is called after receive_ox_tag(). */
1.13      ohara     232: cmo* receive_cmo(OXFILE *oxfp)
1.1       ohara     233: {
1.24      ohara     234:     int tag = receive_int32(oxfp);
                    235:     return receive_cmo_tag(oxfp, tag);
                    236: }
                    237:
                    238: cmo *receive_cmo_tag(OXFILE *oxfp, int tag)
                    239: {
1.1       ohara     240:     cmo* m;
                    241:     switch(tag) {
                    242:     case CMO_NULL:
1.13      ohara     243:         m = receive_cmo_null(oxfp);
1.1       ohara     244:         break;
                    245:     case CMO_INT32:
1.13      ohara     246:         m = (cmo *)receive_cmo_int32(oxfp);
1.1       ohara     247:         break;
                    248:     case CMO_STRING:
1.13      ohara     249:         m = (cmo *)receive_cmo_string(oxfp);
1.1       ohara     250:         break;
                    251:     case CMO_MATHCAP:
1.13      ohara     252:         m = (cmo *)receive_cmo_mathcap(oxfp);
1.1       ohara     253:         break;
                    254:     case CMO_LIST:
1.13      ohara     255:         m = (cmo *)receive_cmo_list(oxfp);
1.1       ohara     256:         break;
                    257:     case CMO_MONOMIAL32:
1.13      ohara     258:         m = (cmo *)receive_cmo_monomial32(oxfp);
1.1       ohara     259:         break;
                    260:     case CMO_ZZ:
1.13      ohara     261:         m = (cmo *)receive_cmo_zz(oxfp);
1.1       ohara     262:         break;
                    263:     case CMO_ZERO:
1.13      ohara     264:         m = (cmo *)receive_cmo_zero(oxfp);
1.1       ohara     265:         break;
                    266:     case CMO_DMS_GENERIC:
1.13      ohara     267:         m = (cmo *)receive_cmo_dms_generic(oxfp);
1.1       ohara     268:         break;
                    269:     case CMO_RING_BY_NAME:
1.13      ohara     270:         m = (cmo *)receive_cmo_ring_by_name(oxfp);
1.1       ohara     271:         break;
                    272:     case CMO_DISTRIBUTED_POLYNOMIAL:
1.13      ohara     273:         m = (cmo *)receive_cmo_distributed_polynomial(oxfp);
1.1       ohara     274:         break;
                    275:     case CMO_ERROR2:
1.13      ohara     276:         m = (cmo *)receive_cmo_error2(oxfp);
1.1       ohara     277:         break;
                    278:     case CMO_DATUM:
                    279:     case CMO_QQ:
                    280:     default:
1.13      ohara     281:         m = NULL;
1.20      ohara     282:         ox_printf("the CMO (%d) is not implemented.\n", tag);
1.1       ohara     283:     }
                    284:     return m;
                    285: }
                    286:
1.13      ohara     287: static void receive_mpz(OXFILE *oxfp, mpz_ptr mpz)
1.1       ohara     288: {
                    289:     int i;
1.13      ohara     290:     int size  = receive_int32(oxfp);
1.1       ohara     291:     int len   = abs(size);
                    292:     resize_mpz(mpz, size);
                    293:
                    294:     for(i=0; i<len; i++) {
1.13      ohara     295:         mpz->_mp_d[i] = receive_int32(oxfp);
1.1       ohara     296:     }
                    297: }
                    298:
1.13      ohara     299: void send_ox_command(OXFILE *oxfp, int sm_command)
1.1       ohara     300: {
1.13      ohara     301:     send_ox_tag(oxfp, OX_COMMAND);
                    302:     send_int32(oxfp, sm_command);
                    303:     oxf_flush(oxfp);
1.1       ohara     304: }
                    305:
1.13      ohara     306: void ox_close(OXFILE *sv)
1.1       ohara     307: {
1.13      ohara     308:     send_ox_command(oxf_control(sv), SM_control_kill);
1.7       ohara     309:     sleep(2);
1.13      ohara     310:     /* We wait thar an OpenXM server terminates. */
1.20      ohara     311:     ox_printf("I have closed the connection to an Open XM server.\n");
1.1       ohara     312: }
                    313:
1.13      ohara     314: void ox_shutdown(OXFILE *sv)
1.3       ohara     315: {
1.13      ohara     316:     /* We need to use SM_shutdown but yet ... */
                    317:     ox_close(sv);
1.3       ohara     318: }
                    319:
1.13      ohara     320: void ox_cmo_rpc(OXFILE *sv, char *function, int argc, cmo *argv[])
1.3       ohara     321: {
1.13      ohara     322:     int i = argc;
                    323:     while(i-- > 0) {
                    324:         send_ox_cmo(sv, argv[i]);
                    325:     }
                    326:     send_ox_cmo(sv, (cmo *)new_cmo_int32(argc));
                    327:     send_ox_cmo(sv, (cmo *)new_cmo_string(function));
                    328:     send_ox_command(sv, SM_executeFunction);
1.3       ohara     329: }
                    330:
1.13      ohara     331: void ox_execute_string(OXFILE *sv, char* s)
1.3       ohara     332: {
1.13      ohara     333:     send_ox_cmo(sv, (cmo *)new_cmo_string(s));
                    334:     send_ox_command(sv, SM_executeStringByLocalParser);
1.3       ohara     335: }
                    336:
1.13      ohara     337: void ox_push_cmd(OXFILE *sv, int sm_code)
1.1       ohara     338: {
1.13      ohara     339:     send_ox_command(sv, sm_code);
1.1       ohara     340: }
                    341:
1.13      ohara     342: cmo_mathcap* ox_mathcap(OXFILE *sv)
1.1       ohara     343: {
1.13      ohara     344:     send_ox_command(sv, SM_mathcap);
                    345:     send_ox_command(sv, SM_popCMO);
                    346:     receive_ox_tag(sv);          /* OX_DATA */
                    347:     return (cmo_mathcap *)receive_cmo(sv);
1.1       ohara     348: }
                    349:
1.13      ohara     350: char* ox_popString(OXFILE *sv)
1.1       ohara     351: {
                    352:     cmo_string* m = NULL;
                    353:
1.13      ohara     354:     send_ox_command(sv, SM_popString);
                    355:     receive_ox_tag(sv); /* OX_DATA */
                    356:     m = (cmo_string *)receive_cmo(sv);
1.1       ohara     357:     return m->s;
                    358: }
                    359:
1.13      ohara     360: void ox_pops(OXFILE *sv, int num)
1.3       ohara     361: {
1.13      ohara     362:     send_ox_cmo(sv, (cmo *)new_cmo_int32(num));
                    363:     send_ox_command(sv, SM_pops);
1.3       ohara     364: }
                    365:
1.13      ohara     366: cmo* ox_pop_cmo(OXFILE *sv)
1.3       ohara     367: {
1.13      ohara     368:     send_ox_command(sv, SM_popCMO);
                    369:     receive_ox_tag(sv); /* OX_DATA */
                    370:     return receive_cmo(sv);
1.3       ohara     371: }
                    372:
1.13      ohara     373: void ox_push_cmo(OXFILE *sv, cmo *c)
1.3       ohara     374: {
1.13      ohara     375:     send_ox_cmo(sv, c);
1.3       ohara     376: }
                    377:
1.7       ohara     378: /* a dummy function for flushing a connection. */
1.13      ohara     379: int ox_flush(OXFILE *sv)
1.5       ohara     380: {
1.13      ohara     381:     return 1;
1.5       ohara     382: }
                    383:
1.13      ohara     384: void ox_reset(OXFILE *sv)
1.1       ohara     385: {
1.13      ohara     386:     send_ox_command(oxf_control(sv), SM_control_reset_connection);
                    387:     while(receive_ox_tag(sv) != OX_SYNC_BALL) {
                    388:         receive_cmo(sv); /* skipping a message. */
1.1       ohara     389:     }
                    390:
1.13      ohara     391:     send_ox_tag(sv, OX_SYNC_BALL);
1.20      ohara     392:     ox_printf("I have reset an Open XM server.\n");
1.1       ohara     393: }
                    394:
1.13      ohara     395: void send_ox(OXFILE *oxfp, ox *m)
1.1       ohara     396: {
                    397:     switch(m->tag) {
1.13      ohara     398:     case OX_DATA:
                    399:         send_ox_cmo(oxfp, ((ox_data *)m)->cmo);
1.1       ohara     400:         break;
1.13      ohara     401:     case OX_COMMAND:
                    402:         send_ox_command(oxfp, ((ox_command *)m)->command);
1.1       ohara     403:         break;
                    404:     default:
                    405:         /* CMO?? */
1.13      ohara     406:         send_ox_cmo(oxfp, (cmo *)m);
1.1       ohara     407:     }
                    408: }
                    409:
1.13      ohara     410: void send_ox_cmo(OXFILE *oxfp, cmo* m)
1.1       ohara     411: {
1.13      ohara     412:     send_ox_tag(oxfp, OX_DATA);
                    413:     send_cmo(oxfp, m);
                    414:     oxf_flush(oxfp);
1.1       ohara     415: }
                    416:
1.8       ohara     417: /* send_cmo_* functions */
1.13      ohara     418: static int send_cmo_null(OXFILE *oxfp, cmo_null* c)
1.1       ohara     419: {
                    420:     return 0;
                    421: }
                    422:
1.13      ohara     423: static int send_cmo_int32(OXFILE *oxfp, cmo_int32* m)
1.1       ohara     424: {
1.13      ohara     425:     return send_int32(oxfp, m->i);
1.1       ohara     426: }
                    427:
1.13      ohara     428: static int send_cmo_string(OXFILE *oxfp, cmo_string* m)
1.1       ohara     429: {
                    430:     int len = (m->s != NULL)? strlen(m->s): 0;
1.13      ohara     431:     send_int32(oxfp, len);
1.1       ohara     432:     if (len > 0) {
1.13      ohara     433:         oxf_write(m->s, 1, len, oxfp);
1.1       ohara     434:     }
                    435:     return 0;
                    436: }
                    437:
1.13      ohara     438: static int send_cmo_mathcap(OXFILE *oxfp, cmo_mathcap* c)
1.1       ohara     439: {
1.13      ohara     440:     send_cmo(oxfp, c->ob);
1.1       ohara     441:     return 0;
                    442: }
                    443:
1.13      ohara     444: static int send_cmo_list(OXFILE *oxfp, cmo_list* c)
1.1       ohara     445: {
1.13      ohara     446:     cell* el = list_first(c);
                    447:     int len = list_length(c);
                    448:     send_int32(oxfp, len);
                    449:
                    450:     while(!list_endof(c, el)) {
                    451:         send_cmo(oxfp, el->cmo);
                    452:         el = list_next(el);
1.1       ohara     453:     }
                    454:     return 0;
                    455: }
                    456:
1.13      ohara     457: static int send_cmo_distributed_polynomial(OXFILE *oxfp, cmo_distributed_polynomial* c)
1.1       ohara     458: {
1.13      ohara     459:     cell* el = list_first((cmo_list *)c);
                    460:     int len = list_length((cmo_list *)c);
                    461:     send_int32(oxfp, len);
                    462:     send_cmo(oxfp, c->ringdef);
                    463:     while(!list_endof((cmo_list *)c, el)) {
                    464:         send_cmo(oxfp, el->cmo);
                    465:         el = list_next(el);
1.1       ohara     466:     }
                    467:     return 0;
                    468: }
                    469:
1.13      ohara     470: static int send_cmo_monomial32(OXFILE *oxfp, cmo_monomial32* c)
1.1       ohara     471: {
                    472:     int i;
                    473:     int len = c->length;
1.13      ohara     474:     send_int32(oxfp, len);
1.1       ohara     475:     for(i=0; i<len; i++) {
1.13      ohara     476:         send_int32(oxfp, c->exps[i]);
1.1       ohara     477:     }
1.13      ohara     478:     send_cmo(oxfp, c->coef);
1.1       ohara     479:     return 0;
                    480: }
                    481:
1.13      ohara     482: static int send_cmo_zz(OXFILE *oxfp, cmo_zz* c)
1.1       ohara     483: {
1.13      ohara     484:     send_mpz(oxfp, c->mpz);
1.1       ohara     485:     return 0;
                    486: }
                    487:
1.13      ohara     488: static int send_cmo_error2(OXFILE *oxfp, cmo_error2* c)
1.1       ohara     489: {
1.13      ohara     490:     send_cmo(oxfp, c->ob);
1.1       ohara     491:     return 0;
                    492: }
                    493:
1.8       ohara     494: /* sending a CMO.  (Remarks: OX_tag is already sent.) */
1.13      ohara     495: void send_cmo(OXFILE *oxfp, cmo* c)
1.1       ohara     496: {
                    497:     int tag = c->tag;
                    498:
1.13      ohara     499:     c = call_hook_before_send_cmo(oxfp, c);
1.2       ohara     500:
1.13      ohara     501:     send_int32(oxfp, tag);
1.1       ohara     502:     switch(tag) {
                    503:     case CMO_NULL:
                    504:     case CMO_ZERO:
                    505:     case CMO_DMS_GENERIC:
1.13      ohara     506:         send_cmo_null(oxfp, c);  /* empty function. */
1.1       ohara     507:         break;
                    508:     case CMO_INT32:
1.13      ohara     509:         send_cmo_int32(oxfp, (cmo_int32 *)c);
1.1       ohara     510:         break;
                    511:     case CMO_STRING:
1.13      ohara     512:         send_cmo_string(oxfp, (cmo_string *)c);
1.1       ohara     513:         break;
                    514:     case CMO_MATHCAP:
                    515:     case CMO_ERROR2:
                    516:     case CMO_RING_BY_NAME:
                    517:     case CMO_INDETERMINATE:
1.13      ohara     518:         send_cmo_mathcap(oxfp, (cmo_mathcap *)c);
1.1       ohara     519:         break;
                    520:     case CMO_LIST:
1.13      ohara     521:         send_cmo_list(oxfp, (cmo_list *)c);
1.1       ohara     522:         break;
                    523:     case CMO_MONOMIAL32:
1.13      ohara     524:         send_cmo_monomial32(oxfp, (cmo_monomial32 *)c);
1.1       ohara     525:         break;
                    526:     case CMO_ZZ:
1.13      ohara     527:         send_cmo_zz(oxfp, (cmo_zz *)c);
1.1       ohara     528:         break;
                    529:     case CMO_DISTRIBUTED_POLYNOMIAL:
1.13      ohara     530:         send_cmo_distributed_polynomial(oxfp, (cmo_distributed_polynomial *)c);
1.1       ohara     531:         break;
                    532:     default:
1.13      ohara     533:         call_hook_after_send_cmo(oxfp, c);
1.1       ohara     534:     }
                    535: }
                    536:
1.13      ohara     537: static int send_mpz(OXFILE *oxfp, mpz_ptr mpz)
1.1       ohara     538: {
                    539:     int i;
                    540:     int len = abs(mpz->_mp_size);
1.13      ohara     541:     send_int32(oxfp, mpz->_mp_size);
1.1       ohara     542:     for(i=0; i<len; i++) {
1.13      ohara     543:         send_int32(oxfp, mpz->_mp_d[i]);
1.1       ohara     544:     }
                    545:     return 0;
                    546: }
                    547:
                    548: ox_data* new_ox_data(cmo* c)
                    549: {
1.25    ! ohara     550:     ox_data* m = MALLOC(sizeof(ox_data));
1.1       ohara     551:     m->tag = OX_DATA;
                    552:     m->cmo = c;
                    553:     return m;
                    554: }
                    555:
                    556: ox_command* new_ox_command(int sm_code)
                    557: {
1.25    ! ohara     558:     ox_command* m = MALLOC(sizeof(ox_command));
1.1       ohara     559:     m->tag = OX_COMMAND;
                    560:     m->command = sm_code;
                    561:     return m;
                    562: }
                    563:
                    564: ox_sync_ball* new_ox_sync_ball()
                    565: {
1.25    ! ohara     566:     ox_sync_ball *m = MALLOC(sizeof(ox_sync_ball));
1.1       ohara     567:     m->tag = OX_SYNC_BALL;
                    568:     return m;
1.19      ohara     569: }
                    570:
                    571: int ox_stderr_init(FILE *fp)
                    572: {
1.21      ohara     573:     ox_stderr = fp;
                    574:     if (ox_stderr != NULL) {
                    575:         setbuf(ox_stderr, NULL);
                    576:     }
1.20      ohara     577: }
                    578:
                    579: int ox_printf(char *format, ...)
                    580: {
1.21      ohara     581:     if (ox_stderr != NULL) {
                    582:         va_list ap;
                    583:         va_start(ap, format);
                    584:         vfprintf(ox_stderr, format, ap);
                    585:     }
1.1       ohara     586: }

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