===================================================================
RCS file: /home/cvs/OpenXM/src/ox_math/Attic/ox.c,v
retrieving revision 1.1.1.1
retrieving revision 1.15
diff -u -p -r1.1.1.1 -r1.15
--- OpenXM/src/ox_math/Attic/ox.c	1999/10/29 08:06:41	1.1.1.1
+++ OpenXM/src/ox_math/Attic/ox.c	1999/11/18 21:57:56	1.15
@@ -1,6 +1,5 @@
 /* -*- mode: C; coding: euc-japan -*- */
-/* $OpenXM$ */
-/* $Id: ox.c,v 1.1.1.1 1999/10/29 08:06:41 ohara Exp $ */
+/* $OpenXM: OpenXM/src/ox_math/ox.c,v 1.14 1999/11/12 12:55:47 ohara Exp $ */
 
 /*
 関数の名前付け規約(その2):
@@ -32,6 +31,8 @@ YYY_cmo_XXX 関数が処理する.  cmo の内部に cmo_ZZZ への
 #include <errno.h>
 #include <fcntl.h>
 #include <gmp.h>
+#include <unistd.h>
+#include <sys/file.h>
 
 #include "mysocket.h"
 #include "ox.h"
@@ -43,49 +44,63 @@ 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 char*        dump_cmo_list(char* array, cmo_list* m);
-static char*        dump_cmo_mathcap(char* array, cmo_mathcap* m);
-static char*        dump_cmo_null(char* array, cmo_null* m);
-static char*        dump_cmo_string(char* array, cmo_string* m);
-static char*        dump_cmo_zz(char* array, cmo_zz* c);
-static char*        dump_integer(char* array, int x);
-static char*        dump_mpz(char* array, mpz_ptr mpz);
+static int          dump_cmo_int32(cmo_int32* m);
+static int          dump_cmo_list(cmo_list* m);
+static int          dump_cmo_mathcap(cmo_mathcap* m);
+static int          dump_cmo_null(cmo_null* m);
+static int          dump_cmo_string(cmo_string* m);
+static int          dump_cmo_monomial32(cmo_monomial32* c);
+static int          dump_cmo_zz(cmo_zz* c);
+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 cmo_error*   receive_cmo_error(int fd);
-static cmo_int32*   receive_cmo_int32(int fd);
-static cmo_list*    receive_cmo_list(int fd);
-static cmo_mathcap* receive_cmo_mathcap(int fd);
-static cmo_null*    receive_cmo_null(int fd);
-static cmo_string*  receive_cmo_string(int fd);
-static cmo_zz*      receive_cmo_zz(int fd);
-static void         receive_mpz(int fd, mpz_ptr mpz);
+static int          login_with_otp(int fd, char* passwd);
+static char         *create_otp();
 
-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);
+/* CMO_xxx の値順にならべること(デバッグのため) */
+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_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* make_error_object(int err_code, cmo *ob)
 {
     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));
+    append_cmo_list(li, ob);
     /* 他の情報を加えるならココ */
-    return new_cmo_error(li);
+    return new_cmo_error2((cmo *)li);
 }
 
 /* add at Mon Sep  7 15:51:28 JST 1998 */
@@ -130,43 +145,46 @@ 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 **cp = &this->head;
-    while (*cp != NULL) {
-        cp = &((*cp)->next);
+cell* next_cell(cell* this)
+{
+    return this->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 = tailp(this);
-    *cp = new_cell(newcmo);
+    cell *cp = tail(this);
+    cp->cmo  = 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_error(li);
+    return new_cmo_null();
 }
 
 static cmo_int32* receive_cmo_int32(int fd)
@@ -175,49 +193,150 @@ 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);
-        append_cmo_list(c, newcmo);
+        ob = receive_cmo(fd);
+        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);
-    return new_cmo_mathcap(li);
+    int i;
+    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);
-    memset(s, '\0', len+1);
-    if (len > 0) {
-        read(fd, s, len);
+    c->ringdef = receive_cmo(fd);
+
+    while (len>0) {
+        ob = receive_cmo(fd);
+        append_cmo_list((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();
-    receive_mpz(fd, c->mpz);
-    return c;
+    cmo* ob = receive_cmo(fd);
+    return new_cmo_error2(ob);
 }
 
+/* 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;
@@ -237,12 +356,11 @@ 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));
-    c->tag = CMO_ERROR2;
-    c->li  = li;
-    return c;
+    cmo_null* m = malloc(sizeof(cmo_null));
+    m->tag = CMO_NULL;
+    return m;
 }
 
 cmo_int32* new_cmo_int32(int i)
@@ -254,38 +372,53 @@ 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));
-    c->tag    = CMO_LIST;
-    c->length = 0;
-    c->head   = NULL;
+    cmo_string* c = malloc(sizeof(cmo_string));
+    c->tag = CMO_STRING;
+    if (s != 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));
-    m->tag = CMO_NULL;
-    return m;
+    cmo_list* c = malloc(sizeof(cmo_list));
+    c->tag    = CMO_LIST;
+    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));
-    c->tag = CMO_STRING;
-    c->s   = s;
+    cmo_monomial32* c = malloc(sizeof(cmo_monomial32));
+    c->tag  = CMO_MONOMIAL32;
     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));
@@ -308,6 +441,13 @@ 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();
@@ -315,48 +455,54 @@ cmo_zz* new_cmo_zz_size(int size)
     return c;
 }
 
-/* receive_ox_tag() == OX_DATA の後に呼び出される */
-/* 関数ポインタを使った方がきれいに書けるような気がする.  */
-/* if (foo[tag] != NULL) foo[tag](fd); とか */
-
-cmo* receive_cmo(int fd)
+cmo_zero* new_cmo_zero()
 {
-    cmo* m;
-    int tag;
-    tag = receive_int32(fd);
+    cmo_zero* m = malloc(sizeof(cmo_zero));
+    m->tag = CMO_ZERO;
+    return m;
+}
 
-    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_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);
-    }
+cmo_dms_generic* new_cmo_dms_generic()
+{
+    cmo_dms_generic* m = malloc(sizeof(cmo_dms_generic));
+    m->tag = CMO_DMS_GENERIC;
     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);
@@ -366,7 +512,14 @@ void send_ox_command(int fd, int sm_command)
 int print_cmo(cmo* c)
 {
     int tag = c->tag;
-    fprintf(stderr, "local::tag = (%d): ", tag);
+
+    symbol* symp = lookup_by_tag(tag);
+    if (symp != NULL) {
+        fprintf(stderr, "(%s", symp->key);
+    }else {     
+        fprintf(stderr, "(%d", tag);
+    }
+
     switch(tag) {
     case CMO_LIST:
         print_cmo_list((cmo_list *)c);
@@ -375,13 +528,18 @@ int print_cmo(cmo* c)
         print_cmo_int32((cmo_int32 *)c);
         break;
     case CMO_MATHCAP:
+    case CMO_INDETERMINATE:
+    case CMO_RING_BY_NAME:
+    case CMO_ERROR2:
         print_cmo_mathcap((cmo_mathcap *)c);
         break;
     case CMO_STRING:
         print_cmo_string((cmo_string *)c);
         break;
     case CMO_NULL:
-        fprintf(stderr, "\n");
+    case CMO_ZERO:
+    case CMO_DMS_GENERIC:
+        fprintf(stderr, ")");
         break;
     default:
         fprintf(stderr, "print_cmo() does not know how to print.\n");
@@ -390,60 +548,49 @@ int print_cmo(cmo* c)
 
 int print_cmo_int32(cmo_int32* c)
 {
-    fprintf(stderr, "cmo_int32 = (%d)\n", c->i);
+    fprintf(stderr, ", %d)", c->i);
 }
 
 int print_cmo_list(cmo_list* li)
 {
     cell* cp = li->head;
-    fprintf(stderr, "length = (%d)\nlist:\n", li->length);
-    while(cp != NULL) {
+    while(cp->next != NULL) {
+		fprintf(stderr, ", ");
         print_cmo(cp->cmo);
         cp=cp->next;
     }
-    fprintf(stderr, "end of list\n");
+    fprintf(stderr, ")");
 }
 
 int print_cmo_mathcap(cmo_mathcap* c)
 {
-    fprintf(stderr, "\n");
-    print_cmo((cmo *)c->li);
+    fprintf(stderr, ", ");
+    print_cmo(c->ob);
+    fprintf(stderr, ")");
 }
 
 int print_cmo_string(cmo_string* c)
 {
-    fprintf(stderr, "cmo_string = (%s)\n", c->s);
+    fprintf(stderr, ", \"%s\")", 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
+#ifdef 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
 }
 
 void ox_executeStringByLocalParser(ox_file_t sv, char* s)
 {
-    /* 文字列ををスタックにプッシュ. */
-    send_ox_cmo(sv->stream, (cmo *)new_cmo_string(s));
-
-    /* サーバに実行させる. */
-    send_ox_command(sv->stream, SM_executeStringByLocalParser);
+    if (s != NULL) {
+        /* 文字列ををスタックにプッシュ. */
+        send_ox_cmo(sv->stream, (cmo *)new_cmo_string(s));
+        /* サーバに実行させる. */
+        send_ox_command(sv->stream, SM_executeStringByLocalParser);
+    }
 }
 
 /* ox_mathcap() をコールする.  */
@@ -472,43 +619,149 @@ 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)
+{
+    int len   = strlen(passwd)+1;
+    char *buf = alloca(len);
+    int n     = read(fd, buf, len);
+    int ret   = strcmp(passwd, buf);
+
+#ifdef DEBUG
+    if (ret != 0) {
+        fprintf(stderr, "Socket#%d: Login incorrect.\n", fd);
+    }else {
+        fprintf(stderr, "Socket#%d: login!.\n", fd);
+    }
+    fprintf(stderr, "password = (%s), %d bytes.\n", passwd, len);
+    fprintf(stderr, "received = (%s), %d bytes.\n", buf, n);
+    fflush(stderr);
+#endif
+
+    return ret;
+}
+
+static int exists_ox(char *dir, char *prog)
+{
+    char *path = alloca(strlen(dir)+strlen(prog)+6);
+    sprintf(path, "%s/%s", dir, prog);
+    return access(path, X_OK|R_OK);
+}
+
+static char *search_ox(char *prog)
+{
+    char *env = getenv("OpenXM_HOME");
+    char *dir;
+    if (env != NULL) {
+        dir = malloc(strlen(env)+5);
+        sprintf(dir, "%s/bin", env);
+        if (exists_ox(dir, prog) == 0) {
+            return dir;
+        }
+        free(dir);
+    }
+    dir = "/usr/local/OpenXM/bin";
+    if (exists_ox(dir, prog) == 0) {
+        return dir;
+    }
+    dir = ".";
+    if (exists_ox(dir, prog) == 0) {
+        return dir;
+    }
+    return NULL;
+}
+
+static int mysocketAccept2(int fd, char *pass)
+{
+    fd = mysocketAccept(fd);
+    if(login_with_otp(fd, pass)==0) {
+        decideByteOrderClient(fd, 0);
+        return fd;
+    }
+    close(fd);
+    return -1;
+}
+
+/*
+   (-reverse 版の ox_start)
    ox_start は クライアントが呼び出すための関数である.
-   サーバでは使われない.  prog1 は コントロールサーバであり,
+   サーバでは使われない.  ctl_prog は コントロールサーバであり,
    -ox, -reverse, -data, -control, -pass, -host
-   というオプションを理解することを仮定する. prog2 は計算サーバである.
+   というオプションを理解することを仮定する. dat_prog は計算サーバである.
    接続時には, sv->control を先にオープンする.
 */
 
-ox_file_t ox_start(char* host, char* prog1, char* prog2)
+ox_file_t ox_start(char* host, char* ctl_prog, char* dat_prog)
 {
-    static char pass[] = "passwd";
+    char *pass;
     char ctl[16], dat[16];
     short portControl = 0; /* short であることに注意 */
     short portStream  = 0;
-    ox_file_t sv = malloc(sizeof(__ox_file_struct));
+    ox_file_t sv = NULL;
+    char *dir;
 
+    if ((dir = search_ox(ctl_prog)) == NULL) {
+        fprintf(stderr, "client:: %s not found.\n", ctl_prog);
+        return NULL;
+    }
+    sv = malloc(sizeof(__ox_file_struct));
     sv->control = mysocketListen(host, &portControl);
     sv->stream  = mysocketListen(host, &portStream);
+
     sprintf(ctl, "%d", portControl);
     sprintf(dat, "%d", portStream);
+    pass = create_otp();
 
     if (fork() == 0) {
         dup2(2, 1);
         dup2(open(DEFAULT_LOGFILE, O_RDWR|O_CREAT|O_TRUNC, 0644), 2);
-        execl(prog1, prog1, "-reverse", "-ox", prog2,
+        chdir(dir);
+        execl(ctl_prog, ctl_prog, "-reverse", "-ox", dat_prog,
               "-data", dat, "-control", ctl, "-pass", pass,
               "-host", host, NULL);
     }
 
-    sv->control = mysocketAccept(sv->control);
-    read_password(sv->control, pass);
-    decideByteOrder(sv->control, sv->control, 0);
+    if ((sv->control = mysocketAccept2(sv->control, pass)) == -1) {
+        close(sv->stream);
+        return NULL;
+    }
+    /* 10マイクロ秒, 時間稼ぎする. */
     usleep(10);
-    sv->stream  = mysocketAccept(sv->stream);
-    read_password(sv->stream, pass);
-    decideByteOrder(sv->stream, sv->stream, 0);
+    if((sv->stream  = mysocketAccept2(sv->stream, pass)) == -1) {
+        return NULL;
+    }
+    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;
 }
 
@@ -524,53 +777,65 @@ void ox_reset(ox_file_t sv)
     }
 
     send_ox_tag(sv->stream, OX_SYNC_BALL);
-#if DEBUG
+#ifdef DEBUG
     fprintf(stderr, "I have reset an Open XM server.\n");
 #endif
 }
 
-/* 以下は parse.c で必要とする関数たち */
-/* cmolen 関数は cmo の(送信時の)バイト長を返す */
-/* cmolen_XXX 関数は tag を除いたバイト長を返す */
+/* 以下は bconv.c で必要とする関数群である. */
 
+/* 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)
 {
@@ -578,6 +843,8 @@ 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:
@@ -586,102 +853,175 @@ 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:
-        size += cmolen_cmo_mathcap((cmo_mathcap *)c);
+    case CMO_DISTRIBUTED_POLYNOMIAL:
+        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) {
-        array = dump_cmo(array, cp->cmo);
+    while(cp->next != NULL) {
+        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);
-    array = dump_integer(array, len);
-    memcpy(array, m->s, len);
-    return array + len;
+    cell* cp = m->head;
+    int len = length_cmo_list((cmo_list *)m);
+    dump_integer(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);
-    case CMO_MATHCAP:
-        return dump_cmo_mathcap(array, (cmo_mathcap *)m);
+        dump_cmo_zz((cmo_zz *)m);
+        break;
+    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;
@@ -708,22 +1048,31 @@ 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)
@@ -732,39 +1081,51 @@ 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);
-    return 0;
-}
+    cell* cp = c->head;
+    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;
+    int len = c->length;
     send_int32(fd, len);
-    if (len > 0) {
-        write(fd, m->s, len);
+    for(i=0; i<len; i++) {
+        send_int32(fd, c->exps[i]);
     }
+    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)
 {
@@ -773,6 +1134,8 @@ 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:
@@ -782,22 +1145,27 @@ 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:
-        send_cmo_error(fd, (cmo_error *)c);
+    case CMO_DISTRIBUTED_POLYNOMIAL:
+        send_cmo_distributed_polynomial(fd, (cmo_distributed_polynomial *)c);
         break;
     default:
     }
 }
 
-/* CMO_ZZ の例外の実装が不十分?? */
 static int send_mpz(int fd, mpz_ptr mpz)
 {
     int i;
@@ -825,20 +1193,6 @@ 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 */
@@ -851,43 +1205,55 @@ 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_LIST, (CMO_INT32, %d), (CMO_STRING, \"%s\"), (CMO_STRING, \"%s\"), (CMO_STRING, \"%s\"))"
 
-cmo* make_mathcap_object2(int version, char* id_string)
+
+static cmo_list* make_list_of_id(int ver, char* ver_s, char* sysname)
 {
-    cmo_list *li;
-    char buff[4096];
+    cmo_list *cap;
+    char buff[512];
 
     setgetc(mygetc);
-    sprintf(buff, VER_STR, version, id_string);
-    setmode_mygetc(buff, 4096);
-    li = parse();
+    sprintf(buff, ID_TEMP, ver, sysname, ver_s, getenv("HOSTTYPE"));
+    setmode_mygetc(buff, 512);
+    cap = parse();
     resetgetc();
 
-    return (cmo *)new_cmo_mathcap(li);
+    return cap;
 }
 
-cmo* make_mathcap_object(int version, char* id_string)
+static cmo_list *make_list_of_tag(int type)
 {
-    cmo_list *li_ver, *li_cmo, *li;
-    
-    int i;
-    li_ver = new_cmo_list();
-    append_cmo_list(li_ver, (cmo *)new_cmo_int32(version));
-    append_cmo_list(li_ver, (cmo *)new_cmo_string(id_string));
-
-    li_cmo = new_cmo_list();
-    for(i=0; i<MAX_TYPES; i++) {
-        if (known_types[i] != -1) {
-            append_cmo_list(li_cmo, (cmo *)new_cmo_int32(known_types[i]));
+    cmo_list *li = new_cmo_list();
+    symbol *symp;
+    int i = 0;
+    while((symp = lookup(i++))->key != NULL) {
+        if (symp->type == type) {
+            append_cmo_list(li, (cmo *)new_cmo_int32(symp->tag));
         }
     }
+    return li;
+}
 
-    li = new_cmo_list();
-    append_cmo_list(li, (cmo *)li_ver);
-    append_cmo_list(li, (cmo *)li_cmo);
-    
-    return (cmo *)new_cmo_mathcap(li);
+cmo* make_mathcap_object(int version, char *id_string)
+{
+    char *sysname    = "ox_math";
+    cmo_list *li     = new_cmo_list();
+    cmo_list *li_1st = make_list_of_id(version, id_string, sysname);
+    cmo_list *li_2nd = make_list_of_tag(IS_SM);
+	cmo_list *li_3rd = new_cmo_list();
+    cmo_list *li_cmo = make_list_of_tag(IS_CMO);
+
+    cmo_list *li_ox  = new_cmo_list();
+	append_cmo_list(li_ox,  (cmo *)new_cmo_int32(OX_DATA));
+    append_cmo_list(li_3rd, (cmo *)li_ox);
+    append_cmo_list(li_3rd, (cmo *)li_cmo);
+
+    append_cmo_list(li, (cmo *)li_1st);
+    append_cmo_list(li, (cmo *)li_2nd);
+    append_cmo_list(li, (cmo *)li_3rd);
+
+    return (cmo *)new_cmo_mathcap((cmo *)li);
 }
 
 static int funcs(int cmo_type)
@@ -906,6 +1272,7 @@ void setCmotypeDisable(int type)
     int i = funcs(type);
     known_types[i] = -1;
 }
+
 #if 0
 cmo* (*received_funcs[])(int fd) = {
     NULL,  /* gate keeper */
@@ -915,7 +1282,7 @@ 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)
@@ -926,67 +1293,43 @@ cmo* receive_cmo2(int fd)
         return foo(fd);
     }
 }
-#endif 
+#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_read, &dest, 1);
+    read(fd, &dest, sizeof(char));
+    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_write, &zero, 1);
+    write(fd, &zero, sizeof(char));
+    read(fd, &dest, sizeof(char));
     return 0;
 }
 
-/* cmo と string の変換関数群 */
-
-cmo_zz *new_cmo_zz_set_string(char *s)
+/* cmo と string (ここではC言語のstring) の変換関数群 */
+char *convert_zz_to_string(cmo_zz *c)
 {
-    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_null_to_string()
 {
-    switch(m->tag) {
-    case CMO_ZZ:
-        return CONVERT_ZZ_TO_CSTRING((cmo_zz *)m);
-    case CMO_INT32:
-        return CONVERT_INT_TO_CSTRING(((cmo_int32 *)m)->i);
-    case CMO_STRING:
-        return ((cmo_string *)m)->s;
-    case CMO_NULL:
-        return CONVERT_NULL_TO_CSTRING();
-    default:
-        fprintf(stderr, "sorry, not implemented CMO\n");
-        /* まだ実装していません. */
-        return NULL;
-    }
-}
-
-char *CONVERT_NULL_TO_CSTRING()
-{
     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;
@@ -996,4 +1339,54 @@ char *CONVERT_INT_TO_CSTRING(int integer)
     strcpy(s, buff);
 
     return s;
+}
+
+char *convert_cmo_list_to_string(cmo_list *m)
+{
+	char *s;
+	int i;
+	int size = 0;
+	int len = length_cmo_list(m);
+	char **sp = malloc(len*sizeof(cmo *));
+
+    cell *cp = m->head;
+    for(i = 0; i < len; i++) {
+		sp[i] = convert_cmo_to_string(cp->cmo);
+		size += strlen(sp[i]) + 3;
+        cp = cp->next;
+    }
+	s = malloc(size+2);
+	strcpy(s, "[ ");
+	for(i = 0; i < len - 1; i++) {
+		strcat(s, sp[i]);
+		strcat(s, " , ");
+	}
+	strcat(s, sp[len-1]);
+	strcat(s, " ]");
+	free(sp);
+	return s;
+}
+
+char *convert_cmo_to_string(cmo *m)
+{
+    symbol *symp;
+    switch(m->tag) {
+    case CMO_ZZ:
+        return convert_zz_to_string((cmo_zz *)m);
+    case CMO_INT32:
+        return convert_int_to_string(((cmo_int32 *)m)->i);
+    case CMO_STRING:
+        return ((cmo_string *)m)->s;
+    case CMO_NULL:
+        return convert_null_to_string();
+    case CMO_LIST:
+        return convert_cmo_list_to_string((cmo_list *)m);
+    default:
+#ifdef DEBUG
+        symp = lookup_by_tag(m->tag);
+        fprintf(stderr, "I do not know how to convert %s to a string.\n", symp->key);
+#endif
+        /* まだ実装していません. */
+        return NULL;
+    }
 }