=================================================================== RCS file: /home/cvs/OpenXM/src/ox_toolkit/mathcap.c,v retrieving revision 1.2 retrieving revision 1.12.2.1 diff -u -p -r1.2 -r1.12.2.1 --- OpenXM/src/ox_toolkit/mathcap.c 2000/10/12 15:40:41 1.2 +++ OpenXM/src/ox_toolkit/mathcap.c 2005/10/12 03:49:17 1.12.2.1 @@ -1,336 +1,193 @@ /* -*- mode: C; coding: euc-japan -*- */ -/* $OpenXM: OpenXM/src/ox_toolkit/mathcap.c,v 1.1 2000/10/10 05:23:20 ohara Exp $ */ +/* $OpenXM: OpenXM/src/ox_toolkit/mathcap.c,v 1.12 2005/07/26 12:52:05 ohara Exp $ */ /* This module includes functions for handling mathcap databases. */ +/* This version will be in the new-mathcap-branch. */ +#include #include +#include #include "ox_toolkit.h" -typedef struct { - int tag; - int flag; -} mcdb; +#define MATHCAP_1ST_FORMAT "(CMO_LIST (CMO_INT32 %d) (CMO_STRING \"%s\") (CMO_STRING \"%s\") (CMO_STRING \"%s\"))" -static mcdb *mcdb_lookup(mcdb *db, int tag); -static void mcdb_ctl(mcdb *db, int tag, int flag); -static void mcdb_ctl_all(mcdb *db, int flag); -static cmo_list *mcdb_get_allow_all(mcdb *db); +static int default_cmd[] = { + SM_popCMO, + SM_popString, + SM_mathcap, + SM_pops, + SM_executeStringByLocalParser, + SM_executeFunction, + SM_control_kill, + SM_control_reset_connection, + 0 }; +static int default_cmo[] = { + CMO_NULL, + CMO_INT32, + CMO_STRING, + CMO_MATHCAP, + CMO_LIST, + CMO_MONOMIAL32, + CMO_ZZ, + CMO_QQ, + CMO_ZERO, + CMO_DMS_GENERIC, + CMO_RING_BY_NAME, + CMO_RECURSIVE_POLYNOMIAL, + CMO_DISTRIBUTED_POLYNOMIAL, + CMO_POLYNOMIAL_IN_ONE_VARIABLE, + CMO_64BIT_MACHINE_DOUBLE, + CMO_IEEE_DOUBLE_FLOAT, + CMO_INDETERMINATE, + CMO_TREE, + CMO_LAMBDA, + CMO_ERROR2, + 0 }; +static int default_oxtag[] = { OX_DATA, 0 }; -static char *new_string(char *s); -static cmo_list *cmo_mathcap_get_cmotypes(cmo_mathcap *mc); -static cmo_list *get_messagetypes(cmo_list *ob, int type); -static cmo_list *mathcap_sm_get_all(); -static cmo_list *mathcap_sysinfo_get_all(); -static int mathcap_cmo_isallow_cmo_list(cmo_list *ob); -static int mathcap_cmo_isallow_cmo_mathcap(cmo_mathcap *ob); -static int mathcap_cmo_isallow_cmo_monomial32(cmo_monomial32 *ob); -static int mathcap_cmo_isallow_tag(int tag); -static void mathcap_cmo_allow(int tag); -static void mathcap_cmo_allow_all(); -static void mathcap_cmo_deny(int tag); -static void mathcap_cmo_deny_all(); -static void mathcap_cmo_update(cmo_list* types); +static struct { + int ox_version; + char *sysname; + char *version; + char *hosttype; +} sysinfo = {OX_PROTOCOL_VERSION, "ox_toolkit", OX_TOOLKIT_VERSION, "generic"}; -static mcdb mathcap_cmo[] = { - {CMO_NULL, MATHCAP_FLAG_ALLOW}, - {CMO_INT32, MATHCAP_FLAG_ALLOW}, - {CMO_DATUM, MATHCAP_FLAG_ALLOW}, - {CMO_STRING, MATHCAP_FLAG_ALLOW}, - {CMO_MATHCAP, MATHCAP_FLAG_ALLOW}, - {CMO_LIST, MATHCAP_FLAG_ALLOW}, - {CMO_MONOMIAL32, MATHCAP_FLAG_ALLOW}, - {CMO_ZZ, MATHCAP_FLAG_ALLOW}, - {CMO_ZERO, MATHCAP_FLAG_ALLOW}, - {CMO_DMS_GENERIC, MATHCAP_FLAG_ALLOW}, - {CMO_RING_BY_NAME, MATHCAP_FLAG_ALLOW}, - {CMO_INDETERMINATE, MATHCAP_FLAG_ALLOW}, - {CMO_DISTRIBUTED_POLYNOMIAL, MATHCAP_FLAG_ALLOW}, - {CMO_ERROR2, MATHCAP_FLAG_ALLOW}, - {0, MATHCAP_FLAG_DENY} -}; +mathcap default_mathcap = {default_cmd, default_cmo}; -static mcdb mathcap_sm[] = { - {SM_popCMO, MATHCAP_FLAG_ALLOW}, - {SM_popString, MATHCAP_FLAG_ALLOW}, - {SM_mathcap, MATHCAP_FLAG_ALLOW}, - {SM_pops, MATHCAP_FLAG_ALLOW}, - {SM_executeStringByLocalParser, MATHCAP_FLAG_ALLOW}, - {SM_executeFunction, MATHCAP_FLAG_ALLOW}, - {SM_setMathCap, MATHCAP_FLAG_ALLOW}, - {SM_shutdown, MATHCAP_FLAG_ALLOW}, - {SM_control_kill, MATHCAP_FLAG_ALLOW}, - {SM_control_reset_connection, MATHCAP_FLAG_ALLOW}, - {0, MATHCAP_FLAG_DENY} -}; +static int ilen(int a[]); +static int *icopy(int s[]); +static int *icopyn(int s[], int n); +static int cmo_int32_to_int(cmo_int32* m); +static int *imerge(int *base, int *diff); +static mathcap *mathcap_merge_io(mathcap *this, mathcap *diff); -typedef struct { - mcdb *cmo_db; - mcdb *sm_db; -} mathcap; - -mathcap default_mathcap = {mathcap_cmo, mathcap_sm}; - -mcdb *new_mcdb(mcdb *src) +mathcap *new_mathcap() { - mcdb *new; - int len=0; - while ((src+(len++))->tag != 0) { - } - new = malloc(sizeof(mcdb)*len); - memcpy(new, src, sizeof(mcdb)*len); - return new; + mathcap *mcap = MALLOC(sizeof(mathcap)); + mcap->cmo = icopy(default_cmo); + mcap->cmd = icopy(default_cmd); + return mcap; } -mathcap *new_mathcap() +mathcap *new_mathcap_set(int *cmd, int *cmo) { - mathcap *new = malloc(sizeof(mathcap)); - new->cmo_db = new_mcdb(mathcap_cmo); - new->sm_db = new_mcdb(mathcap_sm); - return new; + mathcap *mcap = MALLOC(sizeof(mathcap)); + mcap->cmd = (cmd)? cmd: icopy(default_cmd); + mcap->cmo = (cmo)? cmo: icopy(default_cmo); + return mcap; } -/* 次の tag についてのキーを探す */ -static mcdb *mcdb_lookup(mcdb *db, int tag) +cmo_list *cmo_mathcap_1st() { - while (db->tag != 0) { - if (db->tag == tag) { - return db; - } - db++; + char buffer[BUFSIZ]; + static char format[] = MATHCAP_1ST_FORMAT; + int len = sizeof(format) + 32 + + strlen(sysinfo.sysname) + + strlen(sysinfo.version) + + strlen(sysinfo.hosttype); + if (len < BUFSIZ) { + sprintf(buffer, format, sysinfo.ox_version, sysinfo.sysname, + sysinfo.version, sysinfo.hosttype); + return (cmo_list *)ox_parse_lisp(buffer); } return NULL; } -/* tag に対する送信制御 */ -static void mcdb_ctl(mcdb *db, int tag, int flag) +/* 0: terminator of array of integer. */ +static int ilen(int a[]) { - mcdb *e = mcdb_lookup(db, tag); - if (e != NULL) { - e->flag = flag; - } -} - -/* 全データに対する送信制御 */ -static void mcdb_ctl_all(mcdb *db, int flag) -{ - while (db->tag != 0) { - db->flag = flag; - db++; - } -} - -/* 送信許可されている tag のリストを得る */ -static cmo_list *mcdb_get_allow_all(mcdb *db) -{ - cmo_list *list = new_cmo_list(); - while (db->tag != 0) { - if (db->flag == MATHCAP_FLAG_ALLOW) { - list_append(list, (cmo *)new_cmo_int32(db->tag)); + int i=0; + if (a != NULL) { + for( ; a[i] !=0; i++) { } - db++; } - return list; + return i; } -static struct { - int version; - char *version_string; - char *sysname; - char *hosttype; -} mathcap_sysinfo = {0, "NO VERSION", "NONAME", "UNKNOWN"}; - -/* 次の tag をもつ cmo の送信が許可されているかを調べる */ -static int mathcap_cmo_isallow_tag(int tag) +static int *icopy(int s[]) { - mcdb *e = mathcap_cmo; - while (e->tag != 0 && e->tag != tag) { - e++; - } - return e->flag; + int n = sizeof(int)*(ilen(s)+1); + int *d = MALLOC(n); + memcpy(d,s,n); + return d; } -static int mathcap_cmo_isallow_cmo_list(cmo_list *ob) +static int *icopyn(int s[], int n) { - cell *el; - if (mathcap_cmo_isallow_tag(ob->tag)) { - el = list_first(ob); - while (!list_endof(ob, el)) { - if (!mathcap_cmo_isallow_cmo(el->cmo)) { - return MATHCAP_FLAG_DENY; - } - el = list_next(el); - } - return MATHCAP_FLAG_ALLOW; - } - return MATHCAP_FLAG_DENY; + int *d = MALLOC((n = sizeof(int)*(n+1))); + memcpy(d,s,n); + return d; } -__inline__ -static int mathcap_cmo_isallow_cmo_monomial32(cmo_monomial32 *ob) +cmo_mathcap *new_cmo_mathcap_by_mathcap(mathcap *mcap) { - return mathcap_cmo_isallow_tag(ob->tag) - && mathcap_cmo_isallow_cmo(ob->coef); + cmo_list *cap1, *cap2, *cap3, *cap4; + cap1 = cmo_mathcap_1st(); + cap2 = new_cmo_list_map(mcap->cmd, ilen(mcap->cmd), new_cmo_int32); + cap3 = new_cmo_list_map(default_oxtag, + ilen(default_oxtag), + new_cmo_int32); + cap4 = new_cmo_list_map(mcap->cmo, ilen(mcap->cmo), new_cmo_int32); + /* new_cmo_mathcap([cap1, cap2, [cap3, cap4]]) */ + return new_cmo_mathcap( + (cmo *)list_appendl(NULL, cap1, cap2, list_appendl(NULL, cap3, cap4, NULL))); } -__inline__ -static int mathcap_cmo_isallow_cmo_mathcap(cmo_mathcap *ob) +static int cmo_int32_to_int(cmo_int32* m) { - return mathcap_cmo_isallow_tag(ob->tag) - && mathcap_cmo_isallow_cmo(ob->ob); + return m->i; } -/* 次の cmo の送信が許可されているかを調べる */ -int mathcap_cmo_isallow_cmo(cmo *ob) +mathcap *new_mathcap_by_cmo_mathcap(cmo_mathcap *cap) { - int tag = ob->tag; - switch(tag) { - case CMO_LIST: - case CMO_DISTRIBUTED_POLYNOMIAL: - return mathcap_cmo_isallow_cmo_list((cmo_list *)ob); - case CMO_MATHCAP: - case CMO_ERROR2: - case CMO_RING_BY_NAME: - case CMO_INDETERMINATE: - return mathcap_cmo_isallow_cmo_mathcap((cmo_mathcap *)ob); - case CMO_MONOMIAL32: - return mathcap_cmo_isallow_cmo_monomial32((cmo_monomial32 *)ob); - default: - return mathcap_cmo_isallow_tag(tag); - } + int *cmd = list_to_array_map(list_nth(cap->ob, 1), cmo_int32_to_int); + int *cmo = list_to_array_map(list_nth(list_nth(cap->ob, 2), 1), + cmo_int32_to_int); + return new_mathcap_set(cmd, cmo); } -/* 次の tag をもつ cmo の送信を許可する */ -__inline__ -static void mathcap_cmo_allow(int tag) +/* if base is unsorted. */ +static int *imerge(int *base, int *diff) { - mcdb_ctl(mathcap_cmo, tag, MATHCAP_FLAG_ALLOW); -} - -/* 次の tag をもつ cmo の送信を不許可にする */ -__inline__ -static void mathcap_cmo_deny(int tag) -{ - mcdb_ctl(mathcap_cmo, tag, MATHCAP_FLAG_DENY); -} - -/* 全ての種類の cmo の送信を不許可にする */ -__inline__ -static void mathcap_cmo_deny_all() -{ - mcdb_ctl_all(mathcap_cmo, MATHCAP_FLAG_DENY); -} - -/* 全ての種類の cmo の送信を許可する */ -__inline__ -static void mathcap_cmo_allow_all() -{ - mcdb_ctl_all(mathcap_cmo, MATHCAP_FLAG_ALLOW); -} - -/* 送信許可されている cmo のリストを得る */ -cmo_list *mathcap_cmo_get_allow_all() -{ - return mcdb_get_allow_all(mathcap_cmo); -} - -/* 既知の sm コマンドのリストを得る */ -__inline__ -static cmo_list *mathcap_sm_get_all() -{ - return mcdb_get_allow_all(mathcap_sm); -} - -/* システム情報を得る */ -static cmo_list *mathcap_sysinfo_get_all() -{ - cmo_list *syslist = new_cmo_list(); - cmo_int32 *ver = new_cmo_int32(mathcap_sysinfo.version); - cmo_string *vers = new_cmo_string(mathcap_sysinfo.version_string); - cmo_string *host = new_cmo_string(mathcap_sysinfo.hosttype); - cmo_string *sname = new_cmo_string(mathcap_sysinfo.sysname); - return list_appendl(syslist, ver, sname, vers, host); -} - -static char *new_string(char *s) -{ - char *t = malloc(sizeof(s)+1); - strcpy(t, s); - return t; -} - -void mathcap_sysinfo_set(int version, char *version_string, char *sysname) -{ - char *host = getenv("HOSTTYPE"); - - mathcap_sysinfo.hosttype = (host != NULL)? new_string(host): "UNKNOWN"; - mathcap_sysinfo.sysname = new_string(sysname); - mathcap_sysinfo.version_string = new_string(version_string); - mathcap_sysinfo.version = version; -} - -/* データベースから cmo_mathcap を生成する */ -cmo_mathcap* mathcap_get() -{ - cmo_list *mc = new_cmo_list(); - cmo_list *l3 = new_cmo_list(); - list_append(l3, list_appendl(new_cmo_list(), new_cmo_int32(OX_DATA), mathcap_cmo_get_allow_all(), NULL)); - list_appendl(mc, (cmo *)mathcap_sysinfo_get_all(), (cmo *)mathcap_sm_get_all(), (cmo *)l3, NULL); - return new_cmo_mathcap((cmo *)mc); -} - -static void mathcap_cmo_update(cmo_list* types) -{ - cell *el = list_first(types); - cmo_int32 *ob; - while(!list_endof(types, el)) { - ob = (cmo_int32 *)el->cmo; - if (ob->tag == CMO_INT32) { - mathcap_cmo_allow(ob->i); + int i,j,k; + int n = ilen(base); + int m = ilen(diff); + int *t = ALLOCA(sizeof(int)*(n+1)); + int *ret; + for(i=0,j=0; icmo, diff->cmo); + FREE(this->cmo); + this->cmo = tmp; + return this; } -/* ( ..., ( type, (...) ), (cmo_int32, (...) ), ... ) */ -/* ^^^^^ Here! */ -static cmo_list *get_messagetypes(cmo_list *ob, int type) +/* for compatibility */ +void mathcap_init(char *version, char *sysname) { - cmo_list *c; - cell *el; - - for (el = list_first(ob); !list_endof(ob, el); el = list_next(el)) { - c = (cmo_list *)el->cmo; - if (((cmo_int32 *)list_nth(c, 0))->i == type) { - return (cmo_list *)list_nth(c, 1); - } - } - return NULL; + sysinfo.hosttype = getenv("HOSTTYPE"); + sysinfo.version = version; + sysinfo.sysname = sysname; } - -/* cmo_mathcap->ob = ( (...), (...), ( ( cmo_int32, (...) ), ...), ...) */ -/* ^^^^^ Here! */ -__inline__ -static cmo_list *cmo_mathcap_get_cmotypes(cmo_mathcap *mc) +cmo_mathcap* mathcap_get(mathcap *this) { - cmo_list *ob = (cmo_list *)list_nth((cmo_list *)mc->ob, 2); - return get_messagetypes(ob, OX_DATA); + return new_cmo_mathcap_by_mathcap(this); } - -/* 受信した mathcap データを反映させる */ -void mathcap_update(cmo_mathcap *mc) +mathcap *mathcap_update(mathcap *this, cmo_mathcap *m) { - cmo_list *types; - if (cmo_mathcap_isvalid(mc)) { - types = cmo_mathcap_get_cmotypes(mc); - if (types != NULL) { - mathcap_cmo_deny_all(); /* すべての cmo の送信を禁止 */ - mathcap_cmo_update(types); - } - } + return mathcap_merge_io(this, new_mathcap_by_cmo_mathcap(m)); }