Annotation of OpenXM/src/ox_math/ox.c, Revision 1.1
1.1 ! ohara 1: /* -*- mode: C; coding: euc-japan -*- */
! 2: /* $OpenXM$ */
! 3: /* $Id: ox.c,v 1.5 1999/10/14 10:18:24 ohara Exp ohara $ */
! 4:
! 5: /*
! 6: 関数の名前付け規約(その2):
! 7: (1) receive_cmo 関数はCMOタグとデータ本体を受信する. この関数は CMOタグの
! 8: 値が事前に分からないときに使用する. 返り値として、cmo へのポインタを返す.
! 9: (2) receive_cmo_XXX 関数は, CMOタグを親の関数で受信してから呼び出される関
! 10: 数で、データ本体のみを受信し、cmo_XXX へのポインタを返す. しかも、
! 11: 関数内部で new_cmo_XXX 関数を呼び出す.
! 12: (3) send_cmo 関数はCMOタグとデータ本体を送信する.
! 13: (4) send_cmo_XXX 関数はCMOタグを親の関数で送信してから呼び出される関数で、
! 14: データ本体のみを送信する.
! 15:
! 16: ----
! 17: (5) receive_ox_XXX 関数は存在しない(作らない). receive_cmo を利用する.
! 18: (6) send_ox_XXX 関数は OX タグを含めて送信する.
! 19: (7) ox_XXX 関数は一連の送受信を含むより抽象的な操作を表現する.
! 20: ox_XXX 関数は、第一引数として、ox_file_t型の変数 sv をとる.
! 21:
! 22: (8) YYY_cmo 関数と YYY_cmo_XXX 関数の関係は次の通り:
! 23: まず YYY_cmo 関数で cmo のタグを処理し、タグを除いた残りの部分を
! 24: YYY_cmo_XXX 関数が処理する. cmo の内部に cmo_ZZZ へのポインタが
! 25: あるときには、その種類によらずに YYY_cmo 関数を呼び出す.
! 26: */
! 27:
! 28: #include <stdio.h>
! 29: #include <stdlib.h>
! 30: #include <string.h>
! 31: #include <unistd.h>
! 32: #include <errno.h>
! 33: #include <fcntl.h>
! 34: #include <gmp.h>
! 35:
! 36: #include "mysocket.h"
! 37: #include "ox.h"
! 38: #include "parse.h"
! 39:
! 40: static int cmolen_cmo_int32(cmo_int32* c);
! 41: static int cmolen_cmo_list(cmo_list* c);
! 42: static int cmolen_cmo_mathcap(cmo_mathcap* c);
! 43: static int cmolen_cmo_null(cmo_null* c);
! 44: static int cmolen_cmo_string(cmo_string* c);
! 45: static int cmolen_cmo_zz(cmo_zz* c);
! 46:
! 47: static char* dump_cmo_int32(char* array, cmo_int32* m);
! 48: static char* dump_cmo_list(char* array, cmo_list* m);
! 49: static char* dump_cmo_mathcap(char* array, cmo_mathcap* m);
! 50: static char* dump_cmo_null(char* array, cmo_null* m);
! 51: static char* dump_cmo_string(char* array, cmo_string* m);
! 52: static char* dump_cmo_zz(char* array, cmo_zz* c);
! 53: static char* dump_integer(char* array, int x);
! 54: static char* dump_mpz(char* array, mpz_ptr mpz);
! 55:
! 56: static int funcs(int cmo_type);
! 57:
! 58: static int read_password(int fd, char* passwd);
! 59: static cmo_error* receive_cmo_error(int fd);
! 60: static cmo_int32* receive_cmo_int32(int fd);
! 61: static cmo_list* receive_cmo_list(int fd);
! 62: static cmo_mathcap* receive_cmo_mathcap(int fd);
! 63: static cmo_null* receive_cmo_null(int fd);
! 64: static cmo_string* receive_cmo_string(int fd);
! 65: static cmo_zz* receive_cmo_zz(int fd);
! 66: static void receive_mpz(int fd, mpz_ptr mpz);
! 67:
! 68: static int send_cmo_error(int fd, cmo_error* c);
! 69: static int send_cmo_int32(int fd, cmo_int32* m);
! 70: static int send_cmo_list(int fd, cmo_list* c);
! 71: static int send_cmo_mathcap(int fd, cmo_mathcap* c);
! 72: static int send_cmo_null(int fd, cmo_null* c);
! 73: static int send_cmo_string(int fd, cmo_string* m);
! 74: static int send_cmo_zz(int fd, cmo_zz* c);
! 75: static int send_mpz(int fd, mpz_ptr mpz);
! 76:
! 77:
! 78: /* エラーハンドリングのため */
! 79: static int current_received_serial = 0;
! 80:
! 81: /* エラーを起こしたときはサーバは次のようにすればよい. */
! 82: cmo_error* gen_error_object(int err_code)
! 83: {
! 84: cmo_list* li = new_cmo_list();
! 85: append_cmo_list(li, (cmo *)new_cmo_int32(current_received_serial));
! 86: append_cmo_list(li, (cmo *)new_cmo_int32(err_code));
! 87: /* 他の情報を加えるならココ */
! 88: return new_cmo_error(li);
! 89: }
! 90:
! 91: /* add at Mon Sep 7 15:51:28 JST 1998 */
! 92: #define DEFAULT_SERIAL_NUMBER 0x0000ffff
! 93: #define receive_serial_number(x) (receive_int32(x))
! 94:
! 95: /* 新しいシリアル番号を得る */
! 96: int next_serial()
! 97: {
! 98: static int serial_number = DEFAULT_SERIAL_NUMBER;
! 99: return serial_number++;
! 100: }
! 101:
! 102: /* int32 型のオブジェクトを送信する. */
! 103: int send_int32(int fd, int int32)
! 104: {
! 105: int32 = htonl(int32);
! 106: return write(fd, &int32, sizeof(int));
! 107: }
! 108:
! 109: /* int32 型のオブジェクトを受信する. */
! 110: int receive_int32(int fd)
! 111: {
! 112: int tag;
! 113: read(fd, &tag, sizeof(int));
! 114: return ntohl(tag);
! 115: }
! 116:
! 117: /* (OX_tag, serial number) を受信する. */
! 118: int receive_ox_tag(int fd)
! 119: {
! 120: int serial;
! 121: int tag = receive_int32(fd);
! 122: current_received_serial = receive_serial_number(fd);
! 123: return tag;
! 124: }
! 125:
! 126: /* (OX_tag, serial number) を送信する. */
! 127: int send_ox_tag(int fd, int tag)
! 128: {
! 129: send_int32(fd, tag);
! 130: return send_int32(fd, next_serial());
! 131: }
! 132:
! 133:
! 134: /* CMO_LIST 関係の関数群 */
! 135: cell* new_cell(cmo* newcmo)
! 136: {
! 137: cell* h = malloc(sizeof(cell));
! 138: h->next = NULL;
! 139: h->cmo = newcmo;
! 140: return h;
! 141: }
! 142:
! 143: static cell* *tailp(cmo_list* this) {
! 144: cell **cp = &this->head;
! 145: while (*cp != NULL) {
! 146: cp = &((*cp)->next);
! 147: }
! 148: return cp;
! 149: }
! 150:
! 151: int length_cmo_list(cmo_list* this)
! 152: {
! 153: return this->length;
! 154: }
! 155:
! 156: int append_cmo_list(cmo_list* this, cmo* newcmo)
! 157: {
! 158: /* リストの最後尾のNULLを保持している変数へのポインタ */
! 159: cell **cp = tailp(this);
! 160: *cp = new_cell(newcmo);
! 161: this->length++;
! 162: return 0;
! 163: }
! 164:
! 165: /** receive_cmo_XXX 関数群 **/
! 166: static cmo_error* receive_cmo_error(int fd)
! 167: {
! 168: cmo_list* li = (cmo_list *)receive_cmo(fd);
! 169: return new_cmo_error(li);
! 170: }
! 171:
! 172: static cmo_int32* receive_cmo_int32(int fd)
! 173: {
! 174: int i = receive_int32(fd);
! 175: return new_cmo_int32(i);
! 176: }
! 177:
! 178: static cmo_list* receive_cmo_list(int fd)
! 179: {
! 180: cmo* newcmo;
! 181: cmo_list* c = new_cmo_list();
! 182: int len = receive_int32(fd);
! 183:
! 184: while (len>0) {
! 185: newcmo = receive_cmo(fd);
! 186: append_cmo_list(c, newcmo);
! 187: len--;
! 188: }
! 189: return c;
! 190: }
! 191:
! 192: static cmo_mathcap* receive_cmo_mathcap(int fd)
! 193: {
! 194: cmo_list* li = (cmo_list *)receive_cmo(fd);
! 195: return new_cmo_mathcap(li);
! 196: }
! 197:
! 198: static cmo_null* receive_cmo_null(int fd)
! 199: {
! 200: return new_cmo_null();
! 201: }
! 202:
! 203: static cmo_string* receive_cmo_string(int fd)
! 204: {
! 205: int len = receive_int32(fd);
! 206: char* s = malloc(len+1);
! 207: memset(s, '\0', len+1);
! 208: if (len > 0) {
! 209: read(fd, s, len);
! 210: }
! 211: return new_cmo_string(s);
! 212: }
! 213:
! 214: static cmo_zz* receive_cmo_zz(int fd)
! 215: {
! 216: cmo_zz* c = new_cmo_zz();
! 217: receive_mpz(fd, c->mpz);
! 218: return c;
! 219: }
! 220:
! 221: static void receive_mpz(int fd, mpz_ptr mpz)
! 222: {
! 223: int i;
! 224: int size = receive_int32(fd);
! 225: int len = abs(size);
! 226: resize_mpz(mpz, size);
! 227:
! 228: for(i=0; i<len; i++) {
! 229: mpz->_mp_d[i] = receive_int32(fd);
! 230: }
! 231: }
! 232:
! 233: void resize_mpz(mpz_ptr mpz, int size)
! 234: {
! 235: _mpz_realloc(mpz, abs(size));
! 236: mpz->_mp_size = size;
! 237: }
! 238:
! 239: /** new_cmo_XXX 関数群 **/
! 240: cmo_error* new_cmo_error(cmo_list* li)
! 241: {
! 242: cmo_error* c = malloc(sizeof(cmo_error));
! 243: c->tag = CMO_ERROR2;
! 244: c->li = li;
! 245: return c;
! 246: }
! 247:
! 248: cmo_int32* new_cmo_int32(int i)
! 249: {
! 250: cmo_int32* c;
! 251: c = malloc(sizeof(cmo_int32));
! 252: c->tag = CMO_INT32;
! 253: c->i = i;
! 254: return c;
! 255: }
! 256:
! 257: cmo_list* new_cmo_list()
! 258: {
! 259: cmo_list* c = malloc(sizeof(cmo_list));
! 260: c->tag = CMO_LIST;
! 261: c->length = 0;
! 262: c->head = NULL;
! 263: return c;
! 264: }
! 265:
! 266: cmo_mathcap* new_cmo_mathcap(cmo_list* li)
! 267: {
! 268: cmo_mathcap* c = malloc(sizeof(cmo_mathcap));
! 269: c->tag = CMO_MATHCAP;
! 270: c->li = li;
! 271: return c;
! 272: }
! 273:
! 274: cmo_null* new_cmo_null()
! 275: {
! 276: cmo* m = malloc(sizeof(cmo));
! 277: m->tag = CMO_NULL;
! 278: return m;
! 279: }
! 280:
! 281: cmo_string* new_cmo_string(char* s)
! 282: {
! 283: cmo_string* c = malloc(sizeof(cmo_string));
! 284: c->tag = CMO_STRING;
! 285: c->s = s;
! 286: return c;
! 287: }
! 288:
! 289: cmo_zz* new_cmo_zz()
! 290: {
! 291: cmo_zz* c = malloc(sizeof(cmo_zz));
! 292: c->tag = CMO_ZZ;
! 293: mpz_init(c->mpz);
! 294: return c;
! 295: }
! 296:
! 297: cmo_zz* new_cmo_zz_noinit()
! 298: {
! 299: cmo_zz* c = malloc(sizeof(cmo_zz));
! 300: c->tag = CMO_ZZ;
! 301: return c;
! 302: }
! 303:
! 304: cmo_zz* new_cmo_zz_set_si(int i)
! 305: {
! 306: cmo_zz* c = new_cmo_zz();
! 307: mpz_set_si(c->mpz, i);
! 308: return c;
! 309: }
! 310:
! 311: cmo_zz* new_cmo_zz_size(int size)
! 312: {
! 313: cmo_zz* c = new_cmo_zz();
! 314: resize_mpz(c->mpz, size);
! 315: return c;
! 316: }
! 317:
! 318: /* receive_ox_tag() == OX_DATA の後に呼び出される */
! 319: /* 関数ポインタを使った方がきれいに書けるような気がする. */
! 320: /* if (foo[tag] != NULL) foo[tag](fd); とか */
! 321:
! 322: cmo* receive_cmo(int fd)
! 323: {
! 324: cmo* m;
! 325: int tag;
! 326: tag = receive_int32(fd);
! 327:
! 328: switch(tag) {
! 329: case CMO_NULL:
! 330: m = receive_cmo_null(fd);
! 331: break;
! 332: case CMO_INT32:
! 333: m = (cmo *)receive_cmo_int32(fd);
! 334: break;
! 335: case CMO_STRING:
! 336: m = (cmo *)receive_cmo_string(fd);
! 337: break;
! 338: case CMO_ZZ:
! 339: m = (cmo *)receive_cmo_zz(fd);
! 340: break;
! 341: case CMO_LIST:
! 342: m = (cmo *)receive_cmo_list(fd);
! 343: break;
! 344: case CMO_MATHCAP:
! 345: m = (cmo *)receive_cmo_mathcap(fd);
! 346: break;
! 347: case CMO_ERROR2:
! 348: m = (cmo *)receive_cmo_error(fd);
! 349: break;
! 350: case CMO_DATUM:
! 351: case CMO_QQ:
! 352: case CMO_ZERO:
! 353: case CMO_DMS:
! 354: default:
! 355: fprintf(stderr, "unknown cmo-type: tag = (%d)\n", m->tag);
! 356: }
! 357: return m;
! 358: }
! 359:
! 360: void send_ox_command(int fd, int sm_command)
! 361: {
! 362: send_ox_tag(fd, OX_COMMAND);
! 363: send_int32(fd, sm_command);
! 364: }
! 365:
! 366: int print_cmo(cmo* c)
! 367: {
! 368: int tag = c->tag;
! 369: fprintf(stderr, "local::tag = (%d): ", tag);
! 370: switch(tag) {
! 371: case CMO_LIST:
! 372: print_cmo_list((cmo_list *)c);
! 373: break;
! 374: case CMO_INT32:
! 375: print_cmo_int32((cmo_int32 *)c);
! 376: break;
! 377: case CMO_MATHCAP:
! 378: print_cmo_mathcap((cmo_mathcap *)c);
! 379: break;
! 380: case CMO_STRING:
! 381: print_cmo_string((cmo_string *)c);
! 382: break;
! 383: case CMO_NULL:
! 384: fprintf(stderr, "\n");
! 385: break;
! 386: default:
! 387: fprintf(stderr, "print_cmo() does not know how to print.\n");
! 388: }
! 389: }
! 390:
! 391: int print_cmo_int32(cmo_int32* c)
! 392: {
! 393: fprintf(stderr, "cmo_int32 = (%d)\n", c->i);
! 394: }
! 395:
! 396: int print_cmo_list(cmo_list* li)
! 397: {
! 398: cell* cp = li->head;
! 399: fprintf(stderr, "length = (%d)\nlist:\n", li->length);
! 400: while(cp != NULL) {
! 401: print_cmo(cp->cmo);
! 402: cp=cp->next;
! 403: }
! 404: fprintf(stderr, "end of list\n");
! 405: }
! 406:
! 407: int print_cmo_mathcap(cmo_mathcap* c)
! 408: {
! 409: fprintf(stderr, "\n");
! 410: print_cmo((cmo *)c->li);
! 411: }
! 412:
! 413: int print_cmo_string(cmo_string* c)
! 414: {
! 415: fprintf(stderr, "cmo_string = (%s)\n", c->s);
! 416: }
! 417:
! 418: /* ox_start() から呼び出す */
! 419: static int read_password(int fd, char* passwd)
! 420: {
! 421: char buff[1024];
! 422: int n;
! 423: if ((n = read(fd, buff, 1024)) != strlen(passwd)) {
! 424: fprintf(stderr, "Socket#%d: Login incorrect.\n", fd);
! 425: fprintf(stderr, "password = (%s), received = (%s).\n", passwd, buff);
! 426: fprintf(stderr, " = (%d), received = (%d).\n", strlen(passwd), n);
! 427: }
! 428: fflush(stderr);
! 429: }
! 430:
! 431: void ox_close(ox_file_t sv)
! 432: {
! 433: send_ox_command(sv->control, SM_control_kill);
! 434: #if DEBUG
! 435: sleep(2); /* OpenXM server の終了を待つ. あまり意味はない. */
! 436: fprintf(stderr, "I have closed an Open XM server.\n");
! 437: #endif
! 438: }
! 439:
! 440: void ox_executeStringByLocalParser(ox_file_t sv, char* s)
! 441: {
! 442: /* 文字列ををスタックにプッシュ. */
! 443: send_ox_cmo(sv->stream, (cmo *)new_cmo_string(s));
! 444:
! 445: /* サーバに実行させる. */
! 446: send_ox_command(sv->stream, SM_executeStringByLocalParser);
! 447: }
! 448:
! 449: /* ox_mathcap() をコールする. */
! 450: cmo_mathcap* ox_mathcap(ox_file_t sv)
! 451: {
! 452: send_ox_command(sv->stream, SM_mathcap);
! 453: send_ox_command(sv->stream, SM_popCMO);
! 454: receive_ox_tag(sv->stream); /* OX_DATA */
! 455: return (cmo_mathcap *)receive_cmo(sv->stream);
! 456: }
! 457:
! 458: char* ox_popString(ox_file_t sv, int fd)
! 459: {
! 460: cmo_string* m = NULL;
! 461:
! 462: send_ox_command(fd, SM_popString);
! 463: receive_ox_tag(fd); /* OX_DATA */
! 464: m = (cmo_string *)receive_cmo(fd);
! 465: return m->s;
! 466: }
! 467:
! 468: cmo* ox_pop_cmo(ox_file_t sv, int fd)
! 469: {
! 470: send_ox_command(fd, SM_popCMO);
! 471: receive_ox_tag(fd); /* OX_DATA */
! 472: return receive_cmo(fd);
! 473: }
! 474:
! 475: /*
! 476: ox_start は クライアントが呼び出すための関数である.
! 477: サーバでは使われない. prog1 は コントロールサーバであり,
! 478: -ox, -reverse, -data, -control, -pass, -host
! 479: というオプションを理解することを仮定する. prog2 は計算サーバである.
! 480: 接続時には, sv->control を先にオープンする.
! 481: */
! 482:
! 483: ox_file_t ox_start(char* host, char* prog1, char* prog2)
! 484: {
! 485: static char pass[] = "passwd";
! 486: char ctl[16], dat[16];
! 487: short portControl = 0; /* short であることに注意 */
! 488: short portStream = 0;
! 489: ox_file_t sv = malloc(sizeof(__ox_file_struct));
! 490:
! 491: sv->control = mysocketListen(host, &portControl);
! 492: sv->stream = mysocketListen(host, &portStream);
! 493: sprintf(ctl, "%d", portControl);
! 494: sprintf(dat, "%d", portStream);
! 495:
! 496: if (fork() == 0) {
! 497: dup2(2, 1);
! 498: dup2(open(DEFAULT_LOGFILE, O_RDWR|O_CREAT|O_TRUNC, 0644), 2);
! 499: execl(prog1, prog1, "-reverse", "-ox", prog2,
! 500: "-data", dat, "-control", ctl, "-pass", pass,
! 501: "-host", host, NULL);
! 502: }
! 503:
! 504: sv->control = mysocketAccept(sv->control);
! 505: read_password(sv->control, pass);
! 506: decideByteOrder(sv->control, sv->control, 0);
! 507: usleep(10);
! 508: sv->stream = mysocketAccept(sv->stream);
! 509: read_password(sv->stream, pass);
! 510: decideByteOrder(sv->stream, sv->stream, 0);
! 511:
! 512: return sv;
! 513: }
! 514:
! 515: void ox_reset(ox_file_t sv)
! 516: {
! 517: send_ox_command(sv->control, SM_control_reset_connection);
! 518:
! 519: receive_ox_tag(sv->control); /* OX_DATA */
! 520: receive_cmo(sv->control); /* (CMO_INT32, 0) */
! 521:
! 522: while(receive_ox_tag(sv->stream) != OX_SYNC_BALL) {
! 523: receive_cmo(sv->stream); /* skipping a message. */
! 524: }
! 525:
! 526: send_ox_tag(sv->stream, OX_SYNC_BALL);
! 527: #if DEBUG
! 528: fprintf(stderr, "I have reset an Open XM server.\n");
! 529: #endif
! 530: }
! 531:
! 532: /* 以下は parse.c で必要とする関数たち */
! 533: /* cmolen 関数は cmo の(送信時の)バイト長を返す */
! 534: /* cmolen_XXX 関数は tag を除いたバイト長を返す */
! 535:
! 536: static int cmolen_cmo_int32(cmo_int32* c)
! 537: {
! 538: return sizeof(int);
! 539: }
! 540:
! 541: static int cmolen_cmo_list(cmo_list* c)
! 542: {
! 543: int size = sizeof(c->head);
! 544: cell* cp = c->head;
! 545:
! 546: while(cp != NULL) {
! 547: size += cmolen_cmo(cp->cmo);
! 548: cp = cp->next;
! 549: }
! 550: return size;
! 551: }
! 552:
! 553: static int cmolen_cmo_mathcap(cmo_mathcap* c)
! 554: {
! 555: return cmolen_cmo((cmo *)c->li);
! 556: }
! 557:
! 558: static int cmolen_cmo_null(cmo_null* c)
! 559: {
! 560: return 0;
! 561: }
! 562:
! 563: static int cmolen_cmo_string(cmo_string* c)
! 564: {
! 565: return sizeof(int)+strlen(c->s);
! 566: }
! 567:
! 568: static int cmolen_cmo_zz(cmo_zz* c)
! 569: {
! 570: int len = abs(c->mpz->_mp_size);
! 571: return sizeof(len) + len*sizeof(int);
! 572: }
! 573:
! 574: /* CMO がバイトエンコードされた場合のバイト列の長さを求める */
! 575: int cmolen_cmo(cmo* c)
! 576: {
! 577: int size = sizeof(int);
! 578:
! 579: switch(c->tag) {
! 580: case CMO_NULL:
! 581: size += cmolen_cmo_null(c);
! 582: break;
! 583: case CMO_INT32:
! 584: size += cmolen_cmo_int32((cmo_int32 *)c);
! 585: break;
! 586: case CMO_STRING:
! 587: size += cmolen_cmo_string((cmo_string *)c);
! 588: break;
! 589: case CMO_LIST:
! 590: size += cmolen_cmo_list((cmo_list *)c);
! 591: break;
! 592: case CMO_ZZ:
! 593: size += cmolen_cmo_zz((cmo_zz *)c);
! 594: break;
! 595: case CMO_MATHCAP:
! 596: size += cmolen_cmo_mathcap((cmo_mathcap *)c);
! 597: break;
! 598: default:
! 599: }
! 600: return size;
! 601: }
! 602:
! 603: static char* dump_cmo_int32(char* array, cmo_int32* m)
! 604: {
! 605: return dump_integer(array, m->i);
! 606: }
! 607:
! 608: static char* dump_cmo_list(char* array, cmo_list* m)
! 609: {
! 610: cell* cp = m->head;
! 611: int len = length_cmo_list(m);
! 612: array = dump_integer(array, len);
! 613:
! 614: while(cp != NULL) {
! 615: array = dump_cmo(array, cp->cmo);
! 616: cp = cp->next;
! 617: }
! 618: return array;
! 619: }
! 620:
! 621: static char* dump_cmo_mathcap(char* array, cmo_mathcap* c)
! 622: {
! 623: return dump_cmo(array, (cmo *)c->li);
! 624: }
! 625:
! 626: static char* dump_cmo_null(char* array, cmo_null* m)
! 627: {
! 628: return array;
! 629: }
! 630:
! 631: static char* dump_cmo_string(char* array, cmo_string* m)
! 632: {
! 633: int len = strlen(m->s);
! 634: array = dump_integer(array, len);
! 635: memcpy(array, m->s, len);
! 636: return array + len;
! 637: }
! 638:
! 639: static char* dump_cmo_zz(char* array, cmo_zz* c)
! 640: {
! 641: return dump_mpz(array, c->mpz);
! 642: }
! 643:
! 644: /* タグを書き出してから、各関数を呼び出す */
! 645: char* dump_cmo(char* array, cmo* m)
! 646: {
! 647: array = dump_integer(array, m->tag);
! 648: switch(m->tag) {
! 649: case CMO_NULL:
! 650: return dump_cmo_null(array, m);
! 651: case CMO_INT32:
! 652: return dump_cmo_int32(array, (cmo_int32 *)m);
! 653: case CMO_STRING:
! 654: return dump_cmo_string(array, (cmo_string *)m);
! 655: case CMO_LIST:
! 656: return dump_cmo_list(array, (cmo_list *)m);
! 657: case CMO_ZZ:
! 658: return dump_cmo_zz(array, (cmo_zz *)m);
! 659: case CMO_MATHCAP:
! 660: return dump_cmo_mathcap(array, (cmo_mathcap *)m);
! 661: default:
! 662: return NULL;
! 663: }
! 664: }
! 665:
! 666: static char* dump_integer(char* array, int x)
! 667: {
! 668: int nx = htonl(x);
! 669: memcpy(array, &nx, sizeof(int));
! 670: return array + sizeof(int);
! 671: }
! 672:
! 673: static char* dump_mpz(char* array, mpz_ptr mpz)
! 674: {
! 675: int i;
! 676: int len = abs(mpz->_mp_size);
! 677: array = dump_integer(array, mpz->_mp_size);
! 678: for(i=0; i<len; i++) {
! 679: array = dump_integer(array, mpz->_mp_d[i]);
! 680: }
! 681: return array;
! 682: }
! 683:
! 684:
! 685: int send_ox(ox_file_t s, ox *m)
! 686: {
! 687: int tag = m->tag;
! 688: int code;
! 689: if (tag == OX_DATA) {
! 690: send_ox_cmo(s->stream, ((ox_data *)m)->cmo);
! 691: }else if (tag == OX_COMMAND) {
! 692: code = ((ox_command *)m)->command;
! 693: if (code >= 1024) {
! 694: /* control command */
! 695: send_ox_command(s->control, code);
! 696: }else {
! 697: send_ox_command(s->stream, code);
! 698: }
! 699: }else {
! 700: /* CMO?? */
! 701: send_ox_cmo(s->stream, (cmo *)m);
! 702: }
! 703: }
! 704:
! 705: int send_ox_cmo(int fd, cmo* m)
! 706: {
! 707: send_ox_tag(fd, OX_DATA);
! 708: send_cmo(fd, m);
! 709: }
! 710:
! 711: int append_cell(cell* this, cell* cp);
! 712:
! 713: cell* next_cell(cell* this)
! 714: {
! 715: return this->next;
! 716: }
! 717:
! 718: static int send_cmo_error(int fd, cmo_error* c)
! 719: {
! 720: send_cmo(fd, (cmo *)c->li);
! 721: return 0;
! 722: }
! 723:
! 724: static int send_cmo_int32(int fd, cmo_int32* m)
! 725: {
! 726: send_int32(fd, m->i);
! 727: }
! 728:
! 729: static int send_cmo_list(int fd, cmo_list* c)
! 730: {
! 731: cell* cp = c->head;
! 732: int len = length_cmo_list(c);
! 733: send_int32(fd, len);
! 734:
! 735: while(cp != NULL) {
! 736: send_cmo(fd, cp->cmo);
! 737: cp = cp->next;
! 738: }
! 739: return 0;
! 740: }
! 741:
! 742: static int send_cmo_mathcap(int fd, cmo_mathcap* c)
! 743: {
! 744: send_cmo(fd, (cmo *)c->li);
! 745: return 0;
! 746: }
! 747:
! 748: static int send_cmo_null(int fd, cmo_null* c)
! 749: {
! 750: return 0;
! 751: }
! 752:
! 753: static int send_cmo_string(int fd, cmo_string* m)
! 754: {
! 755: int len = strlen(m->s);
! 756: send_int32(fd, len);
! 757: if (len > 0) {
! 758: write(fd, m->s, len);
! 759: }
! 760: return 0;
! 761: }
! 762:
! 763: static int send_cmo_zz(int fd, cmo_zz* c)
! 764: {
! 765: send_mpz(fd, c->mpz);
! 766: }
! 767:
! 768: /* CMOを送る. OX_tag は送信済*/
! 769: int send_cmo(int fd, cmo* c)
! 770: {
! 771: int tag = c->tag;
! 772:
! 773: send_int32(fd, tag);
! 774: switch(tag) {
! 775: case CMO_NULL:
! 776: send_cmo_null(fd, c); /* 空の関数 */
! 777: break;
! 778: case CMO_INT32:
! 779: send_cmo_int32(fd, (cmo_int32 *)c);
! 780: break;
! 781: case CMO_STRING:
! 782: send_cmo_string(fd, (cmo_string *)c);
! 783: break;
! 784: case CMO_MATHCAP:
! 785: send_cmo_mathcap(fd, (cmo_mathcap *)c);
! 786: break;
! 787: case CMO_LIST:
! 788: send_cmo_list(fd, (cmo_list *)c);
! 789: break;
! 790: case CMO_ZZ:
! 791: send_cmo_zz(fd, (cmo_zz *)c);
! 792: break;
! 793: case CMO_ERROR2:
! 794: send_cmo_error(fd, (cmo_error *)c);
! 795: break;
! 796: default:
! 797: }
! 798: }
! 799:
! 800: /* CMO_ZZ の例外の実装が不十分?? */
! 801: static int send_mpz(int fd, mpz_ptr mpz)
! 802: {
! 803: int i;
! 804: int len = abs(mpz->_mp_size);
! 805: send_int32(fd, mpz->_mp_size);
! 806: for(i=0; i<len; i++) {
! 807: send_int32(fd, mpz->_mp_d[i]);
! 808: }
! 809: return 0;
! 810: }
! 811:
! 812: ox_data* new_ox_data(cmo* c)
! 813: {
! 814: ox_data* m = malloc(sizeof(ox_data));
! 815: m->tag = OX_DATA;
! 816: m->cmo = c;
! 817: return m;
! 818: }
! 819:
! 820: ox_command* new_ox_command(int sm_code)
! 821: {
! 822: ox_command* m = malloc(sizeof(ox_command));
! 823: m->tag = OX_COMMAND;
! 824: m->command = sm_code;
! 825: return m;
! 826: }
! 827:
! 828: char* dump_ox_data(char* array, ox_data* m)
! 829: {
! 830: array = dump_integer(array, OX_DATA);
! 831: array = dump_integer(array, -1);
! 832: return dump_cmo(array, m->cmo);
! 833: }
! 834:
! 835: char* dump_ox_command(char* array, ox_command* m)
! 836: {
! 837: array = dump_integer(array, OX_COMMAND);
! 838: array = dump_integer(array, -1);
! 839: return dump_integer(array, m->command);
! 840: }
! 841:
! 842: #define MAX_TYPES 8
! 843: static int known_types[] = {
! 844: -1, /* gate keeper */
! 845: CMO_NULL,
! 846: CMO_INT32,
! 847: CMO_STRING,
! 848: CMO_MATHCAP,
! 849: CMO_LIST,
! 850: CMO_ZZ,
! 851: CMO_ERROR2,
! 852: };
! 853:
! 854: #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"
! 855:
! 856: cmo* make_mathcap_object2(int version, char* id_string)
! 857: {
! 858: cmo_list *li;
! 859: char buff[4096];
! 860:
! 861: setgetc(mygetc);
! 862: sprintf(buff, VER_STR, version, id_string);
! 863: setmode_mygetc(buff, 4096);
! 864: li = parse();
! 865: resetgetc();
! 866:
! 867: return (cmo *)new_cmo_mathcap(li);
! 868: }
! 869:
! 870: cmo* make_mathcap_object(int version, char* id_string)
! 871: {
! 872: cmo_list *li_ver, *li_cmo, *li;
! 873:
! 874: int i;
! 875: li_ver = new_cmo_list();
! 876: append_cmo_list(li_ver, (cmo *)new_cmo_int32(version));
! 877: append_cmo_list(li_ver, (cmo *)new_cmo_string(id_string));
! 878:
! 879: li_cmo = new_cmo_list();
! 880: for(i=0; i<MAX_TYPES; i++) {
! 881: if (known_types[i] != -1) {
! 882: append_cmo_list(li_cmo, (cmo *)new_cmo_int32(known_types[i]));
! 883: }
! 884: }
! 885:
! 886: li = new_cmo_list();
! 887: append_cmo_list(li, (cmo *)li_ver);
! 888: append_cmo_list(li, (cmo *)li_cmo);
! 889:
! 890: return (cmo *)new_cmo_mathcap(li);
! 891: }
! 892:
! 893: static int funcs(int cmo_type)
! 894: {
! 895: int i;
! 896: for(i=0; i<MAX_TYPES; i++) {
! 897: if (known_types[i] == cmo_type) {
! 898: return i;
! 899: }
! 900: }
! 901: return 0;
! 902: }
! 903:
! 904: void setCmotypeDisable(int type)
! 905: {
! 906: int i = funcs(type);
! 907: known_types[i] = -1;
! 908: }
! 909: #if 0
! 910: cmo* (*received_funcs[])(int fd) = {
! 911: NULL, /* gate keeper */
! 912: receive_cmo_null,
! 913: receive_cmo_int32,
! 914: receive_cmo_string,
! 915: receive_cmo_mathcap,
! 916: receive_cmo_list,
! 917: receive_cmo_zz,
! 918: receive_cmo_error
! 919: };
! 920:
! 921: cmo* receive_cmo2(int fd)
! 922: {
! 923: int tag;
! 924: cmo* (*foo)() = received_funcs[funcs(tag)];
! 925: if (foo != NULL) {
! 926: return foo(fd);
! 927: }
! 928: }
! 929: #endif
! 930: /* ファイルディスクリプタ fd の通信路での integer の byte order を決定する */
! 931: /* 実際には order (0,1,or 0xFF)をみてはいない */
! 932: int decideByteOrder(int fd_read, int fd_write, int order)
! 933: {
! 934: char zero = '\0';
! 935: char dest;
! 936: write(fd_write, &zero, 1);
! 937: read(fd_read, &dest, 1);
! 938: return 0;
! 939: }
! 940:
! 941: /* Server 側ではこちらを用いる */
! 942: int decideByteOrder2(int fd_read, int fd_write, int order)
! 943: {
! 944: char zero = '\0';
! 945: char dest;
! 946: read(fd_read, &dest, 1);
! 947: write(fd_write, &zero, 1);
! 948: return 0;
! 949: }
! 950:
! 951: /* cmo と string の変換関数群 */
! 952:
! 953: cmo_zz *new_cmo_zz_set_string(char *s)
! 954: {
! 955: cmo_zz* c = new_cmo_zz_noinit();
! 956: mpz_init_set_str(c->mpz, s, 10);
! 957: return c;
! 958: }
! 959:
! 960: char *CONVERT_ZZ_TO_CSTRING(cmo_zz *c)
! 961: {
! 962: return mpz_get_str(NULL, 10, c->mpz);
! 963: }
! 964:
! 965: char *CONVERT_CMO_TO_CSTRING(cmo *m)
! 966: {
! 967: switch(m->tag) {
! 968: case CMO_ZZ:
! 969: return CONVERT_ZZ_TO_CSTRING((cmo_zz *)m);
! 970: case CMO_INT32:
! 971: return CONVERT_INT_TO_CSTRING(((cmo_int32 *)m)->i);
! 972: case CMO_STRING:
! 973: return ((cmo_string *)m)->s;
! 974: case CMO_NULL:
! 975: return CONVERT_NULL_TO_CSTRING();
! 976: default:
! 977: fprintf(stderr, "sorry, not implemented CMO\n");
! 978: /* まだ実装していません. */
! 979: return NULL;
! 980: }
! 981: }
! 982:
! 983: char *CONVERT_NULL_TO_CSTRING()
! 984: {
! 985: static char* null_string = "";
! 986: return null_string;
! 987: }
! 988:
! 989: char *CONVERT_INT_TO_CSTRING(int integer)
! 990: {
! 991: char buff[1024];
! 992: char *s;
! 993:
! 994: sprintf(buff, "%d", integer);
! 995: s = malloc(strlen(buff)+1);
! 996: strcpy(s, buff);
! 997:
! 998: return s;
! 999: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ox.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM / src / ox_math