OpenXM/src/ox_math/ox.c - diff

Return to ox.c CVS log

Up to [local] / OpenXM / src / ox_math

Diff for /OpenXM/src/ox_math/Attic/ox.c between version 1.1 and 1.9

version 1.1, 1999/10/29 08:06:41

version 1.9, 1999/11/04 19:33:17

Line 1

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

/* $OpenXM$ */

/* $OpenXM: OpenXM/src/ox_math/ox.c,v 1.8 1999/11/04 18:13:47 ohara Exp $ */

/* $Id$ */

関数の名前付け規約(その2):

Line 43 static int cmolen_cmo_mathcap(cmo_mathcap* c)

Line 42 static int cmolen_cmo_mathcap(cmo_mathcap* c)

static int cmolen_cmo_null(cmo_null* c);

static int cmolen_cmo_string(cmo_string* c);

static int cmolen_cmo_zz(cmo_zz* c);

static int cmolen_cmo_monomial32(cmo_monomial32* c);

static char* dump_cmo_int32(char* array, cmo_int32* m);

static int dump_cmo_int32(cmo_int32* m);

static char* dump_cmo_list(char* array, cmo_list* m);

static int dump_cmo_list(cmo_list* m);

static char* dump_cmo_mathcap(char* array, cmo_mathcap* m);

static int dump_cmo_mathcap(cmo_mathcap* m);

static char* dump_cmo_null(char* array, cmo_null* m);

static int dump_cmo_null(cmo_null* m);

static char* dump_cmo_string(char* array, cmo_string* m);

static int dump_cmo_string(cmo_string* m);

static char* dump_cmo_zz(char* array, cmo_zz* c);

static int dump_cmo_monomial32(cmo_monomial32* c);

static char* dump_integer(char* array, int x);

static int dump_cmo_zz(cmo_zz* c);

static char* dump_mpz(char* array, mpz_ptr mpz);

static int dump_string(char *s, int len);

static int dump_integer(int x);

static int dump_mpz(mpz_ptr mpz);

static int funcs(int cmo_type);

static int read_password(int fd, char* passwd);

static int login_with_otp(int fd, char* passwd);

static cmo_error* receive_cmo_error(int fd);

static char *create_otp();

static cmo_int32* receive_cmo_int32(int fd);

static cmo_list* receive_cmo_list(int fd);

/* CMO_xxx の値順にならべること(デバッグのため) */

static cmo_mathcap* receive_cmo_mathcap(int fd);

static cmo_null* receive_cmo_null(int fd);

static cmo_int32* receive_cmo_int32(int fd);

static cmo_string* receive_cmo_string(int fd);

static cmo_mathcap* receive_cmo_mathcap(int fd);

static cmo_list* receive_cmo_list(int fd);

static cmo_monomial32* receive_cmo_monomial32(int fd);

static cmo_zz* receive_cmo_zz(int fd);

static cmo_zero* receive_cmo_zero(int fd);

static cmo_dms_generic* receive_cmo_dms_generic(int fd);

static cmo_ring_by_name* receive_cmo_ring_by_name(int fd);

static cmo_distributed_polynomial* receive_cmo_distributed_polynomial(int fd);

static cmo_error2* receive_cmo_error2(int fd);

static void receive_mpz(int fd, mpz_ptr mpz);

static int send_cmo_error(int fd, cmo_error* c);

static int send_cmo_int32(int fd, cmo_int32* m);

static int send_cmo_list(int fd, cmo_list* c);

static int send_cmo_mathcap(int fd, cmo_mathcap* c);

static int send_cmo_null(int fd, cmo_null* c);

static int send_cmo_int32(int fd, cmo_int32* m);

static int send_cmo_string(int fd, cmo_string* m);

static int send_cmo_mathcap(int fd, cmo_mathcap* c);

static int send_cmo_list(int fd, cmo_list* c);

static int send_cmo_monomial32(int fd, cmo_monomial32* c);

static int send_cmo_zz(int fd, cmo_zz* c);

static int send_cmo_error2(int fd, cmo_error2* c);

static int send_mpz(int fd, mpz_ptr mpz);

static int send_cmo_distributed_polynomial(int fd, cmo_distributed_polynomial* c);

/* エラーハンドリングのため */

static int current_received_serial = 0;

/* エラーを起こしたときはサーバは次のようにすればよい. */

cmo_error* gen_error_object(int err_code)

cmo_error2* gen_error_object(int err_code)

{

cmo_list* li = new_cmo_list();

append_cmo_list(li, (cmo *)new_cmo_int32(current_received_serial));

append_cmo_list(li, (cmo *)new_cmo_int32(err_code));

/* 他の情報を加えるならココ */

return new_cmo_error(li);

return new_cmo_error2((cmo *)li);

}

/* add at Mon Sep 7 15:51:28 JST 1998 */

Line 130 int send_ox_tag(int fd, int tag)

Line 142 int send_ox_tag(int fd, int tag)

return send_int32(fd, next_serial());

}

/* CMO_LIST 関係の関数群 */

cell* new_cell(cmo* newcmo)

cell* new_cell()

{

cell* h = malloc(sizeof(cell));

h->next = NULL;

h->cmo = newcmo;

h->cmo = NULL;

return h;

}

static cell* *tailp(cmo_list* this) {

cell* next_cell(cell* this)

cell **cp = &this->head;

{

while (*cp != NULL) {

return this->next;

cp = &((*cp)->next);

}

static cell *tail(cmo_list* this) {

cell *cp = this->head;

while (cp->next != NULL) {

cp = cp->next;

}

return cp;

}

int length_cmo_list(cmo_list* this)

{

return this->length;

}

int append_cmo_list(cmo_list* this, cmo* newcmo)

{

/* リストの最後尾のNULLを保持している変数へのポインタ */

cell *cp = tail(this);

cell **cp = tailp(this);

cp->cmo = newcmo;

*cp = new_cell(newcmo);

cp->next = new_cell();

this->length++;

return 0;

}

int length_cmo_list(cmo_list* this)

{

return this->length;

}

/** receive_cmo_XXX 関数群 **/

static cmo_error* receive_cmo_error(int fd)

static cmo_null* receive_cmo_null(int fd)

{

cmo_list* li = (cmo_list *)receive_cmo(fd);

return new_cmo_null();

return new_cmo_error(li);

}

static cmo_int32* receive_cmo_int32(int fd)

Line 175 static cmo_int32* receive_cmo_int32(int fd)

Line 190 static cmo_int32* receive_cmo_int32(int fd)

return new_cmo_int32(i);

}

static cmo_string* receive_cmo_string(int fd)

{

int len = receive_int32(fd);

char* s = malloc(len+1);

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

if (len > 0) {

read(fd, s, len);

}

return new_cmo_string(s);

}

static cmo_mathcap* receive_cmo_mathcap(int fd)

{

cmo* ob = receive_cmo(fd);

return new_cmo_mathcap(ob);

}

static cmo_list* receive_cmo_list(int fd)

{

cmo* newcmo;

cmo* ob;

cmo_list* c = new_cmo_list();

int len = receive_int32(fd);

while (len>0) {

newcmo = receive_cmo(fd);

ob = receive_cmo(fd);

append_cmo_list(c, newcmo);

append_cmo_list(c, ob);

len--;

}

return c;

}

static cmo_mathcap* receive_cmo_mathcap(int fd)

static cmo_monomial32* receive_cmo_monomial32(int fd)

{

cmo_list* li = (cmo_list *)receive_cmo(fd);

int i;

return new_cmo_mathcap(li);

int len = receive_int32(fd);

cmo_monomial32* c = new_cmo_monomial32(len);

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

c->exps[i] = receive_int32(fd);

}

c->coef = receive_cmo(fd);

return c;

}

static cmo_null* receive_cmo_null(int fd)

static cmo_zz* receive_cmo_zz(int fd)

{

return new_cmo_null();

cmo_zz* c = new_cmo_zz();

receive_mpz(fd, c->mpz);

return c;

}

static cmo_string* receive_cmo_string(int fd)

static cmo_zero* receive_cmo_zero(int fd)

{

return new_cmo_zero();

}

static cmo_dms_generic* receive_cmo_dms_generic(int fd)

{

return new_cmo_dms_generic();

}

static cmo_ring_by_name* receive_cmo_ring_by_name(int fd)

{

cmo* ob = receive_cmo(fd);

/* 意味的チェックが必要 */

return new_cmo_ring_by_name(ob);

}

static cmo_distributed_polynomial* receive_cmo_distributed_polynomial(int fd)

{

cmo* ob;

cmo_distributed_polynomial* c = new_cmo_distributed_polynomial();

int len = receive_int32(fd);

char* s = malloc(len+1);

c->ringdef = receive_cmo(fd);

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

if (len > 0) {

while (len>0) {

read(fd, s, len);

ob = receive_cmo(fd);

append_cmo_list(c, ob);

len--;

}

return new_cmo_string(s);

return c;

}

static cmo_zz* receive_cmo_zz(int fd)

static cmo_error2* receive_cmo_error2(int fd)

{

cmo_zz* c = new_cmo_zz();

cmo* ob = receive_cmo(fd);

receive_mpz(fd, c->mpz);

return new_cmo_error2(ob);

return c;

}

/* receive_ox_tag() == OX_DATA の後に呼び出される */

/* 関数ポインタを使った方がきれいに書けるような気がする. */

/* if (foo[tag] != NULL) foo[tag](fd); とか */

cmo* receive_cmo(int fd)

{

cmo* m;

int tag;

tag = receive_int32(fd);

switch(tag) {

case CMO_NULL:

m = receive_cmo_null(fd);

break;

case CMO_INT32:

m = (cmo *)receive_cmo_int32(fd);

break;

case CMO_STRING:

m = (cmo *)receive_cmo_string(fd);

break;

case CMO_MATHCAP:

m = (cmo *)receive_cmo_mathcap(fd);

break;

case CMO_LIST:

m = (cmo *)receive_cmo_list(fd);

break;

case CMO_MONOMIAL32:

m = (cmo *)receive_cmo_monomial32(fd);

break;

case CMO_ZZ:

m = (cmo *)receive_cmo_zz(fd);

break;

case CMO_ZERO:

m = (cmo *)receive_cmo_zero(fd);

break;

case CMO_DMS_GENERIC:

m = (cmo *)receive_cmo_dms_generic(fd);

break;

case CMO_RING_BY_NAME:

m = (cmo *)receive_cmo_ring_by_name(fd);

break;

case CMO_DISTRIBUTED_POLYNOMIAL:

m = (cmo *)receive_cmo_distributed_polynomial(fd);

break;

case CMO_ERROR2:

m = (cmo *)receive_cmo_error2(fd);

break;

case CMO_DATUM:

case CMO_QQ:

default:

fprintf(stderr, "unknown cmo-type: tag = (%d)\n", m->tag);

}

return m;

}

static void receive_mpz(int fd, mpz_ptr mpz)

{

int i;

Line 237 void resize_mpz(mpz_ptr mpz, int size)

Line 353 void resize_mpz(mpz_ptr mpz, int size)

}

/** new_cmo_XXX 関数群 **/

cmo_error* new_cmo_error(cmo_list* li)

cmo_null* new_cmo_null()

{

cmo_error* c = malloc(sizeof(cmo_error));

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

c->tag = CMO_ERROR2;

m->tag = CMO_NULL;

c->li = li;

return m;

return c;

}

cmo_int32* new_cmo_int32(int i)

Line 254 cmo_int32* new_cmo_int32(int i)

Line 369 cmo_int32* new_cmo_int32(int i)

return c;

}

cmo_list* new_cmo_list()

cmo_string* new_cmo_string(char* s)

{

cmo_list* c = malloc(sizeof(cmo_list));

cmo_string* c = malloc(sizeof(cmo_string));

c->tag = CMO_LIST;

c->tag = CMO_STRING;

c->length = 0;

if (s != NULL) {

c->head = NULL;

c->s = malloc(strlen(s)+1);

strcpy(c->s, s);

}else {

c->s = NULL;

}

return c;

}

cmo_mathcap* new_cmo_mathcap(cmo_list* li)

cmo_mathcap* new_cmo_mathcap(cmo* ob)

{

cmo_mathcap* c = malloc(sizeof(cmo_mathcap));

c->tag = CMO_MATHCAP;

c->li = li;

c->ob = ob;

return c;

}

cmo_null* new_cmo_null()

cmo_list* new_cmo_list()

{

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

cmo_list* c = malloc(sizeof(cmo_list));

m->tag = CMO_NULL;

c->tag = CMO_LIST;

return m;

c->length = 0;

c->head->next = NULL;

return c;

}

cmo_string* new_cmo_string(char* s)

cmo_monomial32* new_cmo_monomial32()

{

cmo_string* c = malloc(sizeof(cmo_string));

cmo_monomial32* c = malloc(sizeof(cmo_monomial32));

c->tag = CMO_STRING;

c->tag = CMO_MONOMIAL32;

c->s = s;

return c;

}

cmo_monomial32* new_cmo_monomial32_size(int size)

{

cmo_monomial32* c = new_cmo_monomial32();

if (size>0) {

c->length = size;

c->exps = malloc(sizeof(int)*size);

}

return c;

}

cmo_zz* new_cmo_zz()

{

cmo_zz* c = malloc(sizeof(cmo_zz));

Line 308 cmo_zz* new_cmo_zz_set_si(int i)

Line 438 cmo_zz* new_cmo_zz_set_si(int i)

return c;

}

cmo_zz *new_cmo_zz_set_string(char *s)

{

cmo_zz* c = new_cmo_zz_noinit();

mpz_init_set_str(c->mpz, s, 10);

return c;

}

cmo_zz* new_cmo_zz_size(int size)

{

cmo_zz* c = new_cmo_zz();

Line 315 cmo_zz* new_cmo_zz_size(int size)

Line 452 cmo_zz* new_cmo_zz_size(int size)

return c;

}

/* receive_ox_tag() == OX_DATA の後に呼び出される */

cmo_zero* new_cmo_zero()

/* 関数ポインタを使った方がきれいに書けるような気がする. */

/* if (foo[tag] != NULL) foo[tag](fd); とか */

cmo* receive_cmo(int fd)

{

cmo* m;

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

int tag;

m->tag = CMO_ZERO;

tag = receive_int32(fd);

return m;

}

switch(tag) {

cmo_dms_generic* new_cmo_dms_generic()

case CMO_NULL:

{

m = receive_cmo_null(fd);

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

break;

m->tag = CMO_DMS_GENERIC;

case CMO_INT32:

m = (cmo *)receive_cmo_int32(fd);

break;

case CMO_STRING:

m = (cmo *)receive_cmo_string(fd);

break;

case CMO_ZZ:

m = (cmo *)receive_cmo_zz(fd);

break;

case CMO_LIST:

m = (cmo *)receive_cmo_list(fd);

break;

case CMO_MATHCAP:

m = (cmo *)receive_cmo_mathcap(fd);

break;

case CMO_ERROR2:

m = (cmo *)receive_cmo_error(fd);

break;

case CMO_DATUM:

case CMO_QQ:

case CMO_ZERO:

case CMO_DMS:

default:

fprintf(stderr, "unknown cmo-type: tag = (%d)\n", m->tag);

}

return m;

}

cmo_ring_by_name* new_cmo_ring_by_name(cmo* ob)

{

cmo_ring_by_name* c = malloc(sizeof(cmo_ring_by_name));

c->tag = CMO_RING_BY_NAME;

c->ob = ob;

return c;

}

cmo_indeterminate* new_cmo_indeterminate(cmo* ob)

{

cmo_indeterminate* c = malloc(sizeof(cmo_indeterminate));

c->tag = CMO_INDETERMINATE;

c->ob = ob;

return c;

}

cmo_distributed_polynomial* new_cmo_distributed_polynomial()

{

cmo_distributed_polynomial* c = malloc(sizeof(cmo_distributed_polynomial));

c->tag = CMO_DISTRIBUTED_POLYNOMIAL;

c->length = 0;

c->head->next = NULL;

c->ringdef = NULL;

return c;

}

cmo_error2* new_cmo_error2(cmo* ob)

{

cmo_error2* c = malloc(sizeof(cmo_error2));

c->tag = CMO_ERROR2;

c->ob = ob;

return c;

}

void send_ox_command(int fd, int sm_command)

{

send_ox_tag(fd, OX_COMMAND);

Line 407 int print_cmo_list(cmo_list* li)

Line 550 int print_cmo_list(cmo_list* li)

int print_cmo_mathcap(cmo_mathcap* c)

{

fprintf(stderr, "\n");

print_cmo((cmo *)c->li);

print_cmo(c->ob);

}

int print_cmo_string(cmo_string* c)

Line 415 int print_cmo_string(cmo_string* c)

Line 558 int print_cmo_string(cmo_string* c)

fprintf(stderr, "cmo_string = (%s)\n", c->s);

}

/* ox_start() から呼び出す */

static int read_password(int fd, char* passwd)

{

char buff[1024];

int n;

if ((n = read(fd, buff, 1024)) != strlen(passwd)) {

fprintf(stderr, "Socket#%d: Login incorrect.\n", fd);

fprintf(stderr, "password = (%s), received = (%s).\n", passwd, buff);

fprintf(stderr, " = (%d), received = (%d).\n", strlen(passwd), n);

}

fflush(stderr);

}

void ox_close(ox_file_t sv)

{

send_ox_command(sv->control, SM_control_kill);

#if DEBUG

sleep(2); /* OpenXM server の終了を待つ. あまり意味はない. */

fprintf(stderr, "I have closed an Open XM server.\n");

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

#endif

}

Line 472 cmo* ox_pop_cmo(ox_file_t sv, int fd)

Line 602 cmo* ox_pop_cmo(ox_file_t sv, int fd)

return receive_cmo(fd);

}

/* 手抜き. (後で改善しよう...) */

static char *create_otp()

{

static char otp[] = "otpasswd";

return otp;

}

/* OneTimePassword の処理 */

static int login_with_otp(int fd, char* passwd)

{

char buff[1024];

int n = read(fd, buff, 1024);

int len = strlen(passwd)+1;

if (n != len) {

fprintf(stderr, "Socket#%d: Login incorrect.\n", fd);

fprintf(stderr, "password = (%s), length = (%d).\n", passwd, len);

fprintf(stderr, "received = (%d), length = (%d).\n", buff, n);

fflush(stderr);

}

(-reverse 版の ox_start)

ox_start はクライアントが呼び出すための関数である.

サーバでは使われない. prog1 はコントロールサーバであり,

-ox, -reverse, -data, -control, -pass, -host

Line 482 cmo* ox_pop_cmo(ox_file_t sv, int fd)

Line 634 cmo* ox_pop_cmo(ox_file_t sv, int fd)

ox_file_t ox_start(char* host, char* prog1, char* prog2)

{

static char pass[] = "passwd";

char *pass = create_otp();

char ctl[16], dat[16];

short portControl = 0; /* short であることに注意 */

short portStream = 0;

Line 502 ox_file_t ox_start(char* host, char* prog1, char* prog

Line 654 ox_file_t ox_start(char* host, char* prog1, char* prog

}

sv->control = mysocketAccept(sv->control);

read_password(sv->control, pass);

login_with_otp(sv->control, pass);

decideByteOrder(sv->control, sv->control, 0);

decideByteOrderClient(sv->control, 0);

/* 10マイクロ秒, 時間稼ぎする. */

usleep(10);

sv->stream = mysocketAccept(sv->stream);

read_password(sv->stream, pass);

login_with_otp(sv->stream, pass);

decideByteOrder(sv->stream, sv->stream, 0);

decideByteOrderClient(sv->stream, 0);

return sv;

}

(-insecure 版の ox_start) まだ、中身はありません。

ox_start_insecure_nonreverse はクライアントが呼び出すための関数である.

接続時には, sv->control を先にオープンする.

既定値:

portControl = 1200

portStream = 1300

ox_file_t ox_start_insecure_nonreverse(char* host, short portControl, short portStream)

{

ox_file_t sv = malloc(sizeof(__ox_file_struct));

sv->control = mysocketOpen(host, portControl);

#if 0

/* ox は insecure のとき byte order の決定が正しくできないようだ... */

decideByteOrderClient(sv->control, 0);

#endif

/* 10マイクロ秒, 時間稼ぎする. */

usleep(10);

sv->stream = mysocketOpen(host, portStream);

decideByteOrderClient(sv->stream, 0);

return sv;

}

void ox_reset(ox_file_t sv)

{

send_ox_command(sv->control, SM_control_reset_connection);

Line 529 void ox_reset(ox_file_t sv)

Line 707 void ox_reset(ox_file_t sv)

#endif

}

/* 以下は parse.c で必要とする関数たち */

/* 以下は bconv.c で必要とする関数群である. */

/* cmolen 関数は cmo の(送信時の)バイト長を返す */

/* cmolen_XXX 関数は tag を除いたバイト長を返す */

/* cmolen 関数は cmo の(送信時の)バイト長を返す. */

/* cmolen_XXX 関数は cmo_XXX の tag を除いたバイト長を返す. */

static int cmolen_cmo_null(cmo_null* c)

{

return 0;

}

static int cmolen_cmo_int32(cmo_int32* c)

{

return sizeof(int);

}

static int cmolen_cmo_string(cmo_string* c)

{

return sizeof(int)+strlen(c->s);

}

static int cmolen_cmo_mathcap(cmo_mathcap* c)

{

return cmolen_cmo(c->ob);

}

static int cmolen_cmo_list(cmo_list* c)

{

int size = sizeof(c->head);

int size = sizeof(int);

cell* cp = c->head;

while(cp != NULL) {

while(cp->next != NULL) {

size += cmolen_cmo(cp->cmo);

cp = cp->next;

}

return size;

}

static int cmolen_cmo_mathcap(cmo_mathcap* c)

static int cmolen_cmo_monomial32(cmo_monomial32* c)

{

return cmolen_cmo((cmo *)c->li);

int len = (c->length + 1)*sizeof(int);

return len + cmolen_cmo(c->coef);

}

static int cmolen_cmo_null(cmo_null* c)

{

return 0;

}

static int cmolen_cmo_string(cmo_string* c)

{

return sizeof(int)+strlen(c->s);

}

static int cmolen_cmo_zz(cmo_zz* c)

{

int len = abs(c->mpz->_mp_size);

return sizeof(len) + len*sizeof(int);

}

static int cmolen_cmo_distributed_polynomial(cmo_distributed_polynomial* c)

{

return cmolen_cmo_list((cmo_list *)c) + cmolen_cmo(c->ringdef);

}

/* CMO がバイトエンコードされた場合のバイト列の長さを求める */

int cmolen_cmo(cmo* c)

{

Line 578 int cmolen_cmo(cmo* c)

Line 768 int cmolen_cmo(cmo* c)

switch(c->tag) {

case CMO_NULL:

case CMO_ZERO:

case CMO_DMS_GENERIC:

size += cmolen_cmo_null(c);

break;

case CMO_INT32:

Line 586 int cmolen_cmo(cmo* c)

Line 778 int cmolen_cmo(cmo* c)

case CMO_STRING:

size += cmolen_cmo_string((cmo_string *)c);

break;

case CMO_MATHCAP:

case CMO_RING_BY_NAME:

case CMO_INDETERMINATE:

case CMO_ERROR2:

size += cmolen_cmo_mathcap((cmo_mathcap *)c);

break;

case CMO_LIST:

size += cmolen_cmo_list((cmo_list *)c);

break;

case CMO_MONOMIAL32:

size += cmolen_cmo_monomial32((cmo_monomial32 *)c);

break;

case CMO_ZZ:

size += cmolen_cmo_zz((cmo_zz *)c);

break;

case CMO_MATHCAP:

case CMO_DISTRIBUTED_POLYNOMIAL:

size += cmolen_cmo_mathcap((cmo_mathcap *)c);

size += cmolen_cmo_distributed_polynomial((cmo_distributed_polynomial *)c);

break;

default:

}

return size;

}

static char* dump_cmo_int32(char* array, cmo_int32* m)

static int d_ptr;

static char *d_buf;

int init_dump_buffer(char *s)

{

return dump_integer(array, m->i);

d_buf = s;

d_ptr = 0;

}

static char* dump_cmo_list(char* array, cmo_list* m)

static int dump_cmo_null(cmo_null* m)

{

return 0;

}

static int dump_cmo_int32(cmo_int32* m)

{

dump_integer(m->i);

}

static int dump_cmo_string(cmo_string* m)

{

int len = strlen(m->s);

dump_integer(len);

dump_string(m->s, len);

}

static int dump_cmo_mathcap(cmo_mathcap* c)

{

dump_cmo(c->ob);

}

static int dump_cmo_list(cmo_list* m)

{

cell* cp = m->head;

int len = length_cmo_list(m);

array = dump_integer(array, len);

dump_integer(len);

while(cp != NULL) {

while(cp->next != NULL) {

array = dump_cmo(array, cp->cmo);

dump_cmo(cp->cmo);

cp = cp->next;

}

return array;

}

static char* dump_cmo_mathcap(char* array, cmo_mathcap* c)

static int dump_cmo_monomial32(cmo_monomial32* c)

{

return dump_cmo(array, (cmo *)c->li);

int i;

int length = c->length;

dump_integer(c->length);

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

dump_integer(c->exps[i]);

}

dump_cmo(c->coef);

}

static char* dump_cmo_null(char* array, cmo_null* m)

static int dump_cmo_zz(cmo_zz* c)

{

return array;

dump_mpz(c->mpz);

}

static char* dump_cmo_string(char* array, cmo_string* m)

static int dump_cmo_distributed_polynomial(cmo_distributed_polynomial* m)

{

int len = strlen(m->s);

cell* cp = m->head;

array = dump_integer(array, len);

int len = length_cmo_list((cmo_list *)m);

memcpy(array, m->s, len);

dump_integer(len);

return array + len;

dump_cmo(m->ringdef);

while(cp != NULL) {

dump_cmo(cp->cmo);

cp = cp->next;

}

static char* dump_cmo_zz(char* array, cmo_zz* c)

{

return dump_mpz(array, c->mpz);

}

/* タグを書き出してから、各関数を呼び出す */

char* dump_cmo(char* array, cmo* m)

int dump_cmo(cmo* m)

{

array = dump_integer(array, m->tag);

dump_integer(m->tag);

switch(m->tag) {

case CMO_NULL:

return dump_cmo_null(array, m);

case CMO_ZERO:

case CMO_DMS_GENERIC:

dump_cmo_null(m);

break;

case CMO_INT32:

return dump_cmo_int32(array, (cmo_int32 *)m);

dump_cmo_int32((cmo_int32 *)m);

break;

case CMO_STRING:

return dump_cmo_string(array, (cmo_string *)m);

dump_cmo_string((cmo_string *)m);

break;

case CMO_MATHCAP:

case CMO_RING_BY_NAME:

case CMO_INDETERMINATE:

case CMO_ERROR2:

dump_cmo_mathcap((cmo_mathcap *)m);

break;

case CMO_LIST:

return dump_cmo_list(array, (cmo_list *)m);

dump_cmo_list((cmo_list *)m);

break;

case CMO_MONOMIAL32:

dump_cmo_monomial32((cmo_monomial32 *)m);

break;

case CMO_ZZ:

return dump_cmo_zz(array, (cmo_zz *)m);

dump_cmo_zz((cmo_zz *)m);

case CMO_MATHCAP:

break;

return dump_cmo_mathcap(array, (cmo_mathcap *)m);

case CMO_DISTRIBUTED_POLYNOMIAL:

dump_cmo_distributed_polynomial((cmo_distributed_polynomial *)m);

break;

default:

return NULL;

}

static char* dump_integer(char* array, int x)

static int dump_mpz(mpz_ptr mpz)

{

int nx = htonl(x);

memcpy(array, &nx, sizeof(int));

return array + sizeof(int);

}

static char* dump_mpz(char* array, mpz_ptr mpz)

{

int i;

int len = abs(mpz->_mp_size);

array = dump_integer(array, mpz->_mp_size);

dump_integer(mpz->_mp_size);

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

array = dump_integer(array, mpz->_mp_d[i]);

dump_integer(mpz->_mp_d[i]);

}

return array;

return;

}

static int dump_string(char *s, int len)

{

memcpy(&d_buf[d_ptr], s, len);

d_ptr += len;

}

static int dump_integer(int x)

{

int nx = htonl(x);

dump_string((char *)&nx, sizeof(int));

}

int dump_ox_data(ox_data* m)

{

dump_integer(OX_DATA);

dump_integer(-1);

dump_cmo(m->cmo);

}

int dump_ox_command(ox_command* m)

{

dump_integer(OX_COMMAND);

dump_integer(-1);

dump_integer(m->command);

}

int send_ox(ox_file_t s, ox *m)

{

int tag = m->tag;

Line 708 int send_ox_cmo(int fd, cmo* m)

Line 973 int send_ox_cmo(int fd, cmo* m)

send_cmo(fd, m);

}

int append_cell(cell* this, cell* cp);

/* send_cmo_xxx 関数群 */

static int send_cmo_null(int fd, cmo_null* c)

{

return 0;

}

cell* next_cell(cell* this)

static int send_cmo_int32(int fd, cmo_int32* m)

{

return this->next;

send_int32(fd, m->i);

}

static int send_cmo_error(int fd, cmo_error* c)

static int send_cmo_string(int fd, cmo_string* m)

{

send_cmo(fd, (cmo *)c->li);

int len = (m->s != NULL)? strlen(m->s): 0;

send_int32(fd, len);

if (len > 0) {

write(fd, m->s, len);

}

return 0;

}

static int send_cmo_int32(int fd, cmo_int32* m)

static int send_cmo_mathcap(int fd, cmo_mathcap* c)

{

send_int32(fd, m->i);

send_cmo(fd, c->ob);

return 0;

}

static int send_cmo_list(int fd, cmo_list* c)

Line 732 static int send_cmo_list(int fd, cmo_list* c)

Line 1006 static int send_cmo_list(int fd, cmo_list* c)

int len = length_cmo_list(c);

send_int32(fd, len);

while(cp != NULL) {

while(cp->next != NULL) {

send_cmo(fd, cp->cmo);

cp = cp->next;

}

return 0;

}

static int send_cmo_mathcap(int fd, cmo_mathcap* c)

static int send_cmo_distributed_polynomial(int fd, cmo_distributed_polynomial* c)

{

send_cmo(fd, (cmo *)c->li);

cell* cp = c->head;

return 0;

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

}

send_int32(fd, len);

send_cmo(fd, c->ringdef);

static int send_cmo_null(int fd, cmo_null* c)

while(cp->next != NULL) {

{

send_cmo(fd, cp->cmo);

cp = cp->next;

}

return 0;

}

static int send_cmo_string(int fd, cmo_string* m)

static int send_cmo_monomial32(int fd, cmo_monomial32* c)

{

int len = strlen(m->s);

int i;

send_int32(fd, len);

int len = c->length;

if (len > 0) {

send_int32(fd, len);

write(fd, m->s, len);

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

}

send_int32(fd, c->exps[i]);

return 0;

}

send_cmo(fd, c->coef);

return 0;

}

static int send_cmo_zz(int fd, cmo_zz* c)

{

send_mpz(fd, c->mpz);

return 0;

}

static int send_cmo_error2(int fd, cmo_error2* c)

{

send_cmo(fd, c->ob);

return 0;

}

/* CMOを送る. OX_tag は送信済*/

int send_cmo(int fd, cmo* c)

{

Line 773 int send_cmo(int fd, cmo* c)

Line 1059 int send_cmo(int fd, cmo* c)

send_int32(fd, tag);

switch(tag) {

case CMO_NULL:

case CMO_ZERO:

case CMO_DMS_GENERIC:

send_cmo_null(fd, c); /* 空の関数 */

break;

case CMO_INT32:

Line 782 int send_cmo(int fd, cmo* c)

Line 1070 int send_cmo(int fd, cmo* c)

send_cmo_string(fd, (cmo_string *)c);

break;

case CMO_MATHCAP:

case CMO_ERROR2:

case CMO_RING_BY_NAME:

case CMO_INDETERMINATE:

send_cmo_mathcap(fd, (cmo_mathcap *)c);

break;

case CMO_LIST:

send_cmo_list(fd, (cmo_list *)c);

break;

case CMO_MONOMIAL32:

send_cmo_monomial32(fd, (cmo_monomial32 *)c);

break;

case CMO_ZZ:

send_cmo_zz(fd, (cmo_zz *)c);

break;

case CMO_ERROR2:

case CMO_DISTRIBUTED_POLYNOMIAL:

send_cmo_error(fd, (cmo_error *)c);

send_cmo_distributed_polynomial(fd, (cmo_distributed_polynomial *)c);

break;

default:

}

/* CMO_ZZ の例外の実装が不十分?? */

static int send_mpz(int fd, mpz_ptr mpz)

{

int i;

Line 825 ox_command* new_ox_command(int sm_code)

Line 1118 ox_command* new_ox_command(int sm_code)

return m;

}

char* dump_ox_data(char* array, ox_data* m)

{

array = dump_integer(array, OX_DATA);

array = dump_integer(array, -1);

return dump_cmo(array, m->cmo);

}

char* dump_ox_command(char* array, ox_command* m)

{

array = dump_integer(array, OX_COMMAND);

array = dump_integer(array, -1);

return dump_integer(array, m->command);

}

#define MAX_TYPES 8

static int known_types[] = {

-1, /* gate keeper */

Line 851 static int known_types[] = {

Line 1130 static int known_types[] = {

CMO_ERROR2,

};

#define VER_STR "(CMO_LIST, 2, (CMO_LIST, (CMO_INT32, %d), (CMO_STRING, \"%s\")), (CMO_LIST, 7, (CMO_INT32, 1), (CMO_INT32, 2), (CMO_INT32, 4), (CMO_INT32, 5), (CMO_INT32, 17), (CMO_INT32, 20), (CMO_INT32, 2130706434)))\n"

#define ID_TEMP "(CMO_MATHCAP, (CMO_LIST, (CMO_LIST, (CMO_INT32, %d), (CMO_STRING, \"%s\"), (CMO_STRING, \"%s\"), (CMO_STRING, \"%s\")), (CMO_LIST, (CMO_INT32, 1), (CMO_INT32, 2), (CMO_INT32, 4), (CMO_INT32, 5), (CMO_INT32, 17), (CMO_INT32, 20), (CMO_INT32, 2130706434))))\n"

cmo* make_mathcap_object2(int version, char* id_string)

cmo* make_mathcap_object2(int ver, char* ver_s, char* sysname)

{

cmo_list *li;

cmo *cap;

char buff[4096];

char buff[8192];

setgetc(mygetc);

sprintf(buff, VER_STR, version, id_string);

sprintf(buff, ID_TEMP, ver, sysname, ver_s, getenv("HOSTTYPE"));

setmode_mygetc(buff, 4096);

setmode_mygetc(buff, 8192);

li = parse();

cap = parse();

resetgetc();

return (cmo *)new_cmo_mathcap(li);

return cap;

}

cmo* make_mathcap_object(int version, char* id_string)

Line 887 cmo* make_mathcap_object(int version, char* id_string)

Line 1166 cmo* make_mathcap_object(int version, char* id_string)

append_cmo_list(li, (cmo *)li_ver);

append_cmo_list(li, (cmo *)li_cmo);

return (cmo *)new_cmo_mathcap(li);

return (cmo *)new_cmo_mathcap((cmo *)li);

}

static int funcs(int cmo_type)

Line 906 void setCmotypeDisable(int type)

Line 1185 void setCmotypeDisable(int type)

int i = funcs(type);

known_types[i] = -1;

}

#if 0

cmo* (*received_funcs[])(int fd) = {

NULL, /* gate keeper */

Line 915 cmo* (*received_funcs[])(int fd) = {

Line 1195 cmo* (*received_funcs[])(int fd) = {

receive_cmo_mathcap,

receive_cmo_list,

receive_cmo_zz,

receive_cmo_error

receive_cmo_error2

};

cmo* receive_cmo2(int fd)

Line 926 cmo* receive_cmo2(int fd)

Line 1206 cmo* receive_cmo2(int fd)

return foo(fd);

}

#endif

/* ファイルディスクリプタ fd の通信路での integer の byte order を決定する */

/* 実際には order (0,1,or 0xFF)をみてはいない */

int decideByteOrder(int fd_read, int fd_write, int order)

int decideByteOrderClient(oxfd fd, int order)

{

char zero = '\0';

char zero = OX_BYTE_NETWORK_BYTE_ORDER;

char dest;

write(fd_write, &zero, 1);

read(fd, &dest, sizeof(char));

read(fd_read, &dest, 1);

write(fd, &zero, sizeof(char));

return 0;

}

/* Server 側ではこちらを用いる */

int decideByteOrder2(int fd_read, int fd_write, int order)

/* いまの実装は dup されていることが前提になっている */

int decideByteOrderServer(oxfd fd, int order)

{

char zero = '\0';

char zero = OX_BYTE_NETWORK_BYTE_ORDER;

char dest;

read(fd_read, &dest, 1);

write(fd, &zero, sizeof(char));

write(fd_write, &zero, 1);

read(fd, &dest, sizeof(char));

return 0;

}

/* cmo と string の変換関数群 */

/* cmo と string (ここではC言語のstring) の変換関数群 */

char *convert_zz_to_string(cmo_zz *c)

cmo_zz *new_cmo_zz_set_string(char *s)

{

cmo_zz* c = new_cmo_zz_noinit();

mpz_init_set_str(c->mpz, s, 10);

return c;

}

char *CONVERT_ZZ_TO_CSTRING(cmo_zz *c)

{

return mpz_get_str(NULL, 10, c->mpz);

}

char *CONVERT_CMO_TO_CSTRING(cmo *m)

char *convert_cmo_to_string(cmo *m)

{

switch(m->tag) {

case CMO_ZZ:

return CONVERT_ZZ_TO_CSTRING((cmo_zz *)m);

return convert_zz_to_string((cmo_zz *)m);

case CMO_INT32:

return CONVERT_INT_TO_CSTRING(((cmo_int32 *)m)->i);

return convert_int_to_string(((cmo_int32 *)m)->i);

case CMO_STRING:

return ((cmo_string *)m)->s;

case CMO_NULL:

return CONVERT_NULL_TO_CSTRING();

return convert_null_to_string();

default:

fprintf(stderr, "sorry, not implemented CMO\n");

/* まだ実装していません. */

Line 980 char *CONVERT_CMO_TO_CSTRING(cmo *m)

Line 1254 char *CONVERT_CMO_TO_CSTRING(cmo *m)

}

char *CONVERT_NULL_TO_CSTRING()

char *convert_null_to_string()

{

static char* null_string = "";

return null_string;

}

char *CONVERT_INT_TO_CSTRING(int integer)

char *convert_int_to_string(int integer)

{

char buff[1024];

char *s;

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