OpenXM/src/ox_toolkit/ox.c - diff

Return to ox.c CVS log

Up to [local] / OpenXM / src / ox_toolkit

Diff for /OpenXM/src/ox_toolkit/ox.c between version 1.19 and 1.35

version 1.19, 2003/01/11 11:42:31

version 1.35, 2013/10/20 14:58:20

Line 1

/* -*- mode: C; coding: euc-japan -*- */

/* $OpenXM: OpenXM/src/ox_toolkit/ox.c,v 1.18 2000/12/05 08:30:25 ohara Exp $ */

/* $OpenXM: OpenXM/src/ox_toolkit/ox.c,v 1.34 2007/03/14 10:30:54 ohara Exp $ */

This module includes functions for sending/receiveng CMO's.

Line 9

#include <stdio.h>

#include <stdlib.h>

#include <stdarg.h>

#include <string.h>

#include <unistd.h>

#include <fcntl.h>

Line 19

Line 20

#include "ox_toolkit.h"

#include "parse.h"

static FILE *ox_stderr = NULL;

/* sorting by the value of CMO_xxx. (for debugging) */

static cmo_null* receive_cmo_null(OXFILE *oxfp);

static cmo_int32* receive_cmo_int32(OXFILE *oxfp);

Line 26 static cmo_string* receive_cmo_string(OXFILE *ox

Line 29 static cmo_string* receive_cmo_string(OXFILE *ox

static cmo_mathcap* receive_cmo_mathcap(OXFILE *oxfp);

static cmo_list* receive_cmo_list(OXFILE *oxfp);

static cmo_monomial32* receive_cmo_monomial32(OXFILE *oxfp);

static cmo_zz* receive_cmo_zz(OXFILE *oxfp);

static cmo_zero* receive_cmo_zero(OXFILE *oxfp);

static cmo_dms_generic* receive_cmo_dms_generic(OXFILE *oxfp);

static cmo_ring_by_name* receive_cmo_ring_by_name(OXFILE *oxfp);

static cmo_distributed_polynomial* receive_cmo_distributed_polynomial(OXFILE *oxfp);

static cmo_recursive_polynomial* receive_cmo_recursive_polynomial(OXFILE *oxfp);

static cmo_polynomial_in_one_variable* receive_cmo_polynomial_in_one_variable(OXFILE *oxfp);

static cmo_double* receive_cmo_double(OXFILE *oxfp);

static cmo_error2* receive_cmo_error2(OXFILE *oxfp);

static void receive_mpz(OXFILE *oxfp, mpz_ptr mpz);

static int send_cmo_null(OXFILE *oxfp, cmo_null* c);

static int send_cmo_int32(OXFILE *oxfp, cmo_int32* m);

Line 41 static int send_cmo_string(OXFILE *oxfp, cmo_

Line 44 static int send_cmo_string(OXFILE *oxfp, cmo_

static int send_cmo_mathcap(OXFILE *oxfp, cmo_mathcap* c);

static int send_cmo_list(OXFILE *oxfp, cmo_list* c);

static int send_cmo_monomial32(OXFILE *oxfp, cmo_monomial32* c);

static int send_cmo_zz(OXFILE *oxfp, cmo_zz* c);

static int send_cmo_double(OXFILE *oxfp, cmo_double* c);

static int send_cmo_error2(OXFILE *oxfp, cmo_error2* c);

static int send_mpz(OXFILE *oxfp, mpz_ptr mpz);

static int send_cmo_distributed_polynomial(OXFILE *oxfp, cmo_distributed_polynomial* c);

static int send_cmo_polynomial_in_one_variable(OXFILE *oxfp, cmo_polynomial_in_one_variable* c);

static int send_cmo_recursive_polynomial(OXFILE *oxfp, cmo_recursive_polynomial* c);

static cmo_zz* receive_cmo_zz(OXFILE *oxfp);

static void receive_mpz(OXFILE *oxfp, mpz_ptr mpz);

static int send_cmo_zz(OXFILE *oxfp, cmo_zz* c);

static int send_mpz(OXFILE *oxfp, mpz_ptr mpz);

/* hook functions. (yet not implemented) */

static hook_t hook_before_send_cmo = NULL;

static hook_t hook_after_send_cmo = NULL;

Line 109 int receive_int32(OXFILE *oxfp)

Line 118 int receive_int32(OXFILE *oxfp)

return oxfp->receive_int32(oxfp);

}

/* sending an object of int32 type. (not equal to cmo_int32 type) */

int send_double(OXFILE *oxfp, double d)

{

return oxfp->send_double(oxfp, d);

}

/* receiving an object of int32 type. (not equal to cmo_int32 type) */

double receive_double(OXFILE *oxfp)

{

return oxfp->receive_double(oxfp);

}

/* receiving an (OX_tag, serial number) */

int receive_ox_tag(OXFILE *oxfp)

{

Line 139 static cmo_int32* receive_cmo_int32(OXFILE *oxfp)

Line 160 static cmo_int32* receive_cmo_int32(OXFILE *oxfp)

static cmo_string* receive_cmo_string(OXFILE *oxfp)

{

int len = receive_int32(oxfp);

char* s = malloc(len+1);

char* s = MALLOC(len+1);

memset(s, '\0', len+1);

if (len > 0) {

oxf_read(s, 1, len, oxfp);

Line 187 static cmo_zz* receive_cmo_zz(OXFILE *oxfp)

Line 208 static cmo_zz* receive_cmo_zz(OXFILE *oxfp)

return c;

}

static cmo_qq* receive_cmo_qq(OXFILE *oxfp)

{

mpz_t num, den;

mpz_init(num);

mpz_init(den);

receive_mpz(oxfp, num);

receive_mpz(oxfp, den);

return new_cmo_qq_set_mpz(num, den);

}

static cmo_zero* receive_cmo_zero(OXFILE *oxfp)

{

return new_cmo_zero();

Line 204 static cmo_ring_by_name* receive_cmo_ring_by_name(OXFI

Line 235 static cmo_ring_by_name* receive_cmo_ring_by_name(OXFI

return new_cmo_ring_by_name(ob);

}

static cmo_recursive_polynomial* receive_cmo_recursive_polynomial(OXFILE *oxfp)

{

cmo_list* ringdef = (cmo_list *)receive_cmo(oxfp);

cmo* coef = receive_cmo(oxfp);

return new_cmo_recursive_polynomial(ringdef, coef);

}

static cmo_distributed_polynomial* receive_cmo_distributed_polynomial(OXFILE *oxfp)

{

cmo* ob;

Line 219 static cmo_distributed_polynomial* receive_cmo_distrib

Line 257 static cmo_distributed_polynomial* receive_cmo_distrib

return c;

}

static cmo_polynomial_in_one_variable* receive_cmo_polynomial_in_one_variable(OXFILE *oxfp)

{

cmo* coef;

cmo_polynomial_in_one_variable* c;

int len = receive_int32(oxfp);

int var = receive_int32(oxfp);

int exp;

c = new_cmo_polynomial_in_one_variable(var);

while (len>0) {

exp = receive_int32(oxfp);

coef = receive_cmo(oxfp);

list_append_monomial((cmo_list *)c, coef, exp);

len--;

}

return c;

}

static cmo_double* receive_cmo_double(OXFILE *oxfp)

{

double d = receive_double(oxfp);

return new_cmo_double(d);

}

static cmo_indeterminate* receive_cmo_indeterminate(OXFILE *oxfp)

{

cmo* ob = receive_cmo(oxfp);

return new_cmo_indeterminate(ob);

}

static cmo_tree* receive_cmo_tree(OXFILE *oxfp)

{

cmo_string* name = (cmo_string *)receive_cmo(oxfp);

cmo_list* attrib = (cmo_list *)receive_cmo(oxfp);

cmo_list* leaves = (cmo_list *)receive_cmo(oxfp);

return new_cmo_tree(name, attrib, leaves);

}

static cmo_lambda* receive_cmo_lambda(OXFILE *oxfp)

{

cmo_list* args = (cmo_list *)receive_cmo(oxfp);

cmo_tree* body = (cmo_tree *)receive_cmo(oxfp);

return new_cmo_lambda(args, body);

}

static cmo_error2* receive_cmo_error2(OXFILE *oxfp)

{

cmo* ob = receive_cmo(oxfp);

Line 228 static cmo_error2* receive_cmo_error2(OXFILE *oxfp)

Line 310 static cmo_error2* receive_cmo_error2(OXFILE *oxfp)

/* receive_cmo() is called after receive_ox_tag(). */

cmo* receive_cmo(OXFILE *oxfp)

{

cmo* m;

int tag = receive_int32(oxfp);

return receive_cmo_tag(oxfp, tag);

}

cmo *receive_cmo_tag(OXFILE *oxfp, int tag)

{

cmo* m;

switch(tag) {

case CMO_NULL:

m = receive_cmo_null(oxfp);

Line 252 cmo* receive_cmo(OXFILE *oxfp)

Line 339 cmo* receive_cmo(OXFILE *oxfp)

case CMO_ZZ:

m = (cmo *)receive_cmo_zz(oxfp);

break;

case CMO_QQ:

m = (cmo *)receive_cmo_qq(oxfp);

break;

case CMO_ZERO:

m = (cmo *)receive_cmo_zero(oxfp);

break;

Line 264 cmo* receive_cmo(OXFILE *oxfp)

Line 354 cmo* receive_cmo(OXFILE *oxfp)

case CMO_DISTRIBUTED_POLYNOMIAL:

m = (cmo *)receive_cmo_distributed_polynomial(oxfp);

break;

case CMO_RECURSIVE_POLYNOMIAL:

m = (cmo *)receive_cmo_recursive_polynomial(oxfp);

break;

case CMO_POLYNOMIAL_IN_ONE_VARIABLE:

m = (cmo *)receive_cmo_polynomial_in_one_variable(oxfp);

break;

case CMO_64BIT_MACHINE_DOUBLE:

case CMO_IEEE_DOUBLE_FLOAT:

m = (cmo *)receive_cmo_double(oxfp);

break;

case CMO_INDETERMINATE:

m = (cmo *)receive_cmo_indeterminate(oxfp);

break;

case CMO_TREE:

m = (cmo *)receive_cmo_tree(oxfp);

break;

case CMO_LAMBDA:

m = (cmo *)receive_cmo_lambda(oxfp);

break;

case CMO_ERROR2:

m = (cmo *)receive_cmo_error2(oxfp);

break;

case CMO_DATUM:

case CMO_QQ:

default:

m = NULL;

fprintf(ox_stderr, "the CMO (%d) is not implemented.\n", tag);

ox_printf("the CMO (%d) is not implemented.\n", tag);

}

return m;

}

Line 279 cmo* receive_cmo(OXFILE *oxfp)

Line 387 cmo* receive_cmo(OXFILE *oxfp)

static void receive_mpz(OXFILE *oxfp, mpz_ptr mpz)

{

int i;

int n = sizeof(mpz->_mp_d[0]) / sizeof(int);

int size = receive_int32(oxfp);

int len = abs(size);

resize_mpz(mpz, size);

int *ptr;

if (n == 1) {

resize_mpz(mpz, size);

} else {

resize_mpz(mpz, (size+1) / n);

}

for(i=0; i<len; i++) {

ptr = (int *)mpz->_mp_d;

mpz->_mp_d[i] = receive_int32(oxfp);

for(i= len-1; i>=0; i--) {

}

ptr[i] = receive_int32(oxfp);

}

void send_ox_command(OXFILE *oxfp, int sm_command)

Line 298 void send_ox_command(OXFILE *oxfp, int sm_command)

Line 413 void send_ox_command(OXFILE *oxfp, int sm_command)

void ox_close(OXFILE *sv)

{

send_ox_command(oxf_control(sv), SM_control_kill);

#ifdef DEBUG

sleep(2);

/* We wait thar an OpenXM server terminates. */

fprintf(ox_stderr, "I have closed the connection to an Open XM server.\n");

ox_printf("I have closed the connection to an Open XM server.\n");

#endif

}

void ox_shutdown(OXFILE *sv)

Line 383 void ox_reset(OXFILE *sv)

Line 496 void ox_reset(OXFILE *sv)

}

send_ox_tag(sv, OX_SYNC_BALL);

#ifdef DEBUG

ox_printf("I have reset an Open XM server.\n");

fprintf(ox_stderr, "I have reset an Open XM server.\n");

#endif

}

void send_ox(OXFILE *oxfp, ox *m)

Line 463 static int send_cmo_distributed_polynomial(OXFILE *oxf

Line 574 static int send_cmo_distributed_polynomial(OXFILE *oxf

return 0;

}

static int send_cmo_polynomial_in_one_variable(OXFILE *oxfp, cmo_polynomial_in_one_variable* c)

{

cell* el = list_first((cmo_list *)c);

int len = list_length((cmo_list *)c);

send_int32(oxfp, len);

send_int32(oxfp, c->var);

while(!list_endof((cmo_list *)c, el)) {

send_int32(oxfp, el->exp);

send_cmo(oxfp, el->cmo);

el = list_next(el);

}

return 0;

}

static int send_cmo_double(OXFILE *oxfp, cmo_double* c)

{

return send_double(oxfp, c->d);

}

static int send_cmo_monomial32(OXFILE *oxfp, cmo_monomial32* c)

{

int i;

Line 481 static int send_cmo_zz(OXFILE *oxfp, cmo_zz* c)

Line 612 static int send_cmo_zz(OXFILE *oxfp, cmo_zz* c)

return 0;

}

static int send_cmo_qq(OXFILE *oxfp, cmo_qq* c)

{

send_mpz(oxfp, mpq_numref(c->mpq));

send_mpz(oxfp, mpq_denref(c->mpq));

return 0;

}

static int send_cmo_recursive_polynomial(OXFILE *oxfp, cmo_recursive_polynomial* c)

{

send_cmo(oxfp, (cmo *)c->ringdef);

send_cmo(oxfp, c->coef);

return 0;

}

static int send_cmo_tree(OXFILE *oxfp, cmo_tree *c)

{

send_cmo(oxfp, (cmo *)c->name);

send_cmo(oxfp, (cmo *)c->attributes);

send_cmo(oxfp, (cmo *)c->leaves);

return 0;

}

static int send_cmo_lambda(OXFILE *oxfp, cmo_lambda *c)

{

send_cmo(oxfp, (cmo *)c->args);

send_cmo(oxfp, (cmo *)c->body);

return 0;

}

static int send_cmo_error2(OXFILE *oxfp, cmo_error2* c)

{

send_cmo(oxfp, c->ob);

Line 522 void send_cmo(OXFILE *oxfp, cmo* c)

Line 682 void send_cmo(OXFILE *oxfp, cmo* c)

case CMO_ZZ:

send_cmo_zz(oxfp, (cmo_zz *)c);

break;

case CMO_QQ:

send_cmo_qq(oxfp, (cmo_qq *)c);

break;

case CMO_DISTRIBUTED_POLYNOMIAL:

send_cmo_distributed_polynomial(oxfp, (cmo_distributed_polynomial *)c);

break;

case CMO_RECURSIVE_POLYNOMIAL:

send_cmo_recursive_polynomial(oxfp, (cmo_recursive_polynomial *)c);

break;

case CMO_POLYNOMIAL_IN_ONE_VARIABLE:

send_cmo_polynomial_in_one_variable(oxfp, (cmo_polynomial_in_one_variable *)c);

break;

case CMO_64BIT_MACHINE_DOUBLE:

case CMO_IEEE_DOUBLE_FLOAT:

send_cmo_double(oxfp, (cmo_double *)c);

break;

case CMO_TREE:

send_cmo_tree(oxfp, (cmo_tree *)c);

break;

case CMO_LAMBDA:

send_cmo_lambda(oxfp, (cmo_lambda *)c);

break;

default:

call_hook_after_send_cmo(oxfp, c);

}

Line 533 void send_cmo(OXFILE *oxfp, cmo* c)

Line 712 void send_cmo(OXFILE *oxfp, cmo* c)

static int send_mpz(OXFILE *oxfp, mpz_ptr mpz)

{

int i;

int len = abs(mpz->_mp_size);

int n = sizeof(mpz->_mp_d[0]) / sizeof(int);

send_int32(oxfp, mpz->_mp_size);

int len = abs(mpz->_mp_size) * n;

int *ptr = (int *)mpz->_mp_d;

send_int32(oxfp, mpz->_mp_size * n);

for(i=0; i<len; i++) {

send_int32(oxfp, mpz->_mp_d[i]);

send_int32(oxfp, ptr[i]);

}

return 0;

}

ox_data* new_ox_data(cmo* c)

{

ox_data* m = malloc(sizeof(ox_data));

ox_data* m = MALLOC(sizeof(ox_data));

m->tag = OX_DATA;

m->cmo = c;

return m;

Line 551 ox_data* new_ox_data(cmo* c)

Line 732 ox_data* new_ox_data(cmo* c)

ox_command* new_ox_command(int sm_code)

{

ox_command* m = malloc(sizeof(ox_command));

ox_command* m = MALLOC(sizeof(ox_command));

m->tag = OX_COMMAND;

m->command = sm_code;

return m;

Line 559 ox_command* new_ox_command(int sm_code)

Line 740 ox_command* new_ox_command(int sm_code)

ox_sync_ball* new_ox_sync_ball()

{

ox_sync_ball *m = malloc(sizeof(ox_sync_ball));

ox_sync_ball *m = MALLOC(sizeof(ox_sync_ball));

m->tag = OX_SYNC_BALL;

return m;

}

int ox_stderr_init(FILE *fp)

{

ox_stderr = (fp != NULL)? fp: (stderr);

ox_stderr = fp;

setbuf(ox_stderr, NULL);

if (ox_stderr != NULL) {

setbuf(ox_stderr, NULL);

}

return 0;

}

int ox_printf(char *format, ...)

{

if (ox_stderr != NULL) {

va_list ap;

va_start(ap, format);

vfprintf(ox_stderr, format, ap);

}

return 0;

}

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