=================================================================== RCS file: /home/cvs/OpenXM/src/ox_toolkit/ox.c,v retrieving revision 1.18 retrieving revision 1.36 diff -u -p -r1.18 -r1.36 --- OpenXM/src/ox_toolkit/ox.c 2000/12/05 08:30:25 1.18 +++ OpenXM/src/ox_toolkit/ox.c 2013/10/20 15:29:12 1.36 @@ -1,5 +1,5 @@ /* -*- mode: C; coding: euc-japan -*- */ -/* $OpenXM: OpenXM/src/ox_toolkit/ox.c,v 1.17 2000/12/03 16:15:03 ohara Exp $ */ +/* $OpenXM: OpenXM/src/ox_toolkit/ox.c,v 1.35 2013/10/20 14:58:20 iwane Exp $ */ /* This module includes functions for sending/receiveng CMO's. @@ -9,6 +9,7 @@ #include #include +#include #include #include #include @@ -19,6 +20,8 @@ #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); @@ -26,14 +29,14 @@ 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); @@ -41,11 +44,17 @@ 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; @@ -109,6 +118,18 @@ 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) { @@ -139,7 +160,7 @@ 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); @@ -187,6 +208,16 @@ 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(); @@ -204,6 +235,13 @@ 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; @@ -219,6 +257,50 @@ 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); @@ -228,8 +310,13 @@ 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); @@ -252,6 +339,9 @@ 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; @@ -264,14 +354,32 @@ 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(stderr, "the CMO (%d) is not implemented.\n", tag); + ox_printf("the CMO (%d) is not implemented.\n", tag); } return m; } @@ -279,12 +387,19 @@ 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); + } + ptr = (int *)mpz->_mp_d; for(i=0; i_mp_d[i] = receive_int32(oxfp); + ptr[i] = receive_int32(oxfp); } } @@ -298,11 +413,9 @@ 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(stderr, "I have closed the connection to an Open XM server.\n"); -#endif + ox_printf("I have closed the connection to an Open XM server.\n"); } void ox_shutdown(OXFILE *sv) @@ -383,9 +496,7 @@ void ox_reset(OXFILE *sv) } send_ox_tag(sv, OX_SYNC_BALL); -#ifdef DEBUG - fprintf(stderr, "I have reset an Open XM server.\n"); -#endif + ox_printf("I have reset an Open XM server.\n"); } void send_ox(OXFILE *oxfp, ox *m) @@ -463,6 +574,26 @@ 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; @@ -481,6 +612,35 @@ 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); @@ -522,9 +682,28 @@ 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); } @@ -533,17 +712,19 @@ void send_cmo(OXFILE *oxfp, cmo* c) static int send_mpz(OXFILE *oxfp, mpz_ptr mpz) { int i; - int len = abs(mpz->_mp_size); - send_int32(oxfp, mpz->_mp_size); + int n = sizeof(mpz->_mp_d[0]) / sizeof(int); + int len = abs(mpz->_mp_size) * n; + int *ptr = (int *)mpz->_mp_d; + send_int32(oxfp, mpz->_mp_size * n); for(i=0; i_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; @@ -551,7 +732,7 @@ 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; @@ -559,7 +740,26 @@ 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; + 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; }