=================================================================== RCS file: /home/cvs/OpenXM/src/ox_toolkit/mathcap.c,v retrieving revision 1.2 retrieving revision 1.17 diff -u -p -r1.2 -r1.17 --- OpenXM/src/ox_toolkit/mathcap.c 2000/10/12 15:40:41 1.2 +++ OpenXM/src/ox_toolkit/mathcap.c 2016/08/23 02:24:19 1.17 @@ -1,161 +1,192 @@ /* -*- 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.16 2016/06/29 05:07:23 ohara Exp $ */ /* This module includes functions for handling mathcap databases. */ #include +#include #include "ox_toolkit.h" -typedef struct { - int tag; - int flag; -} mcdb; +#define MATHCAP_FLAG_DENY 0 +#define MATHCAP_FLAG_ALLOW 1 -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 void table_init(table *m, int key); +static table *new_table(int *src); +static table *table_lookup(table *tbl, int tag); +static void table_ctl(table *tbl, int tag, int flag); +static void table_ctl_all(table *tbl, int flag); +static cmo_list *table_get_all(table *tbl); +static void table_allow(table *tbl, int tag); +static void table_deny(table *tbl, int tag); +static void table_update(table *cmotbl, cmo_list* types); +static int table_allowQ_tag(table *tbl, int tag); +static int table_allowQ_cmo_list(table *cmotbl, cmo_list *ob); +static int table_allowQ_cmo_monomial32(table *cmotbl, cmo_monomial32 *ob); +static int table_allowQ_cmo_mathcap(table *cmotbl, cmo_mathcap *ob); +static int table_allowQ_cmo(table *cmotbl, cmo *ob); +static cmo_list *sysinfo_get(); static char *new_string(char *s); -static cmo_list *cmo_mathcap_get_cmotypes(cmo_mathcap *mc); +static int *new_int_array(int *array); 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 cmo_list *cmo_mathcap_get_cmotypes(cmo_mathcap *mc); -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} +static int cmotbl_a[] = { + CMO_NULL, + CMO_INT32, + CMO_DATUM, + CMO_STRING, + CMO_MATHCAP, + CMO_LIST, + CMO_MONOMIAL32, + CMO_ZZ, + CMO_QQ, + CMO_BIGFLOAT32, + CMO_COMPLEX, + CMO_IEEE_DOUBLE_FLOAT, + CMO_ZERO, + CMO_DMS_GENERIC, + CMO_RING_BY_NAME, + CMO_INDETERMINATE, + CMO_DISTRIBUTED_POLYNOMIAL, + CMO_RECURSIVE_POLYNOMIAL, + CMO_POLYNOMIAL_IN_ONE_VARIABLE, + CMO_ERROR2, + 0, }; -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 smtbl_a[] = { + SM_popCMO, + SM_popString, + SM_mathcap, + SM_pops, + SM_executeStringByLocalParser, + SM_executeFunction, + SM_setMathCap, + SM_shutdown, + SM_control_kill, + SM_control_reset_connection, + SM_control_spawn_server, + SM_control_terminate_server, + 0, }; -typedef struct { - mcdb *cmo_db; - mcdb *sm_db; -} mathcap; +static struct { + int version; + char *version_string; + char *sysname; + char *hosttype; + int *cmo_tags; + int *sm_cmds; + char **opts; +} sysinfo = {0, "NO VERSION", "NONAME", "UNKNOWN", cmotbl_a, smtbl_a, NULL}; -mathcap default_mathcap = {mathcap_cmo, mathcap_sm}; - -mcdb *new_mcdb(mcdb *src) +__inline__ +static void table_init(table *m, int key) { - mcdb *new; - int len=0; - while ((src+(len++))->tag != 0) { - } - new = malloc(sizeof(mcdb)*len); - memcpy(new, src, sizeof(mcdb)*len); - return new; + m->tag = key; + m->flag = MATHCAP_FLAG_ALLOW; } -mathcap *new_mathcap() +static table *new_table(int *src) { - mathcap *new = malloc(sizeof(mathcap)); - new->cmo_db = new_mcdb(mathcap_cmo); - new->sm_db = new_mcdb(mathcap_sm); - return new; + table *new; + int len=0; + int i; + while (src[len++] != 0) { + } + new = MALLOC(sizeof(table)*len); + for(i=0; itag != 0) { - if (db->tag == tag) { - return db; + while (tbl->tag != 0) { + if (tbl->tag == tag) { + return tbl; } - db++; + tbl++; } return NULL; } -/* tag に対する送信制御 */ -static void mcdb_ctl(mcdb *db, int tag, int flag) +/* controller about a cmo identified by the tag */ +static void table_ctl(table *tbl, int tag, int flag) { - mcdb *e = mcdb_lookup(db, tag); + table *e = table_lookup(tbl, tag); if (e != NULL) { e->flag = flag; } } -/* 全データに対する送信制御 */ -static void mcdb_ctl_all(mcdb *db, int flag) +/* controller about all CMObjects */ +static void table_ctl_all(table *tbl, int flag) { - while (db->tag != 0) { - db->flag = flag; - db++; + while (tbl->tag != 0) { + tbl->flag = flag; + tbl++; } } -/* 送信許可されている tag のリストを得る */ -static cmo_list *mcdb_get_allow_all(mcdb *db) +/* getting the list of tags of all allowed objects */ +static cmo_list *table_get_all(table *tbl) { 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)); + while (tbl->tag != 0) { + if (tbl->flag == MATHCAP_FLAG_ALLOW) { + list_append(list, (cmo *)new_cmo_int32(tbl->tag)); } - db++; + tbl++; } return list; } -static struct { - int version; - char *version_string; - char *sysname; - char *hosttype; -} mathcap_sysinfo = {0, "NO VERSION", "NONAME", "UNKNOWN"}; +/* giving a permssion to send objects identified by the tag. */ +__inline__ +static void table_allow(table *tbl, int tag) +{ + table_ctl(tbl, tag, MATHCAP_FLAG_ALLOW); +} -/* 次の tag をもつ cmo の送信が許可されているかを調べる */ -static int mathcap_cmo_isallow_tag(int tag) +/* taking a permssion to send objects identified by the tag. */ +__inline__ +static void table_deny(table *tbl, int tag) { - mcdb *e = mathcap_cmo; - while (e->tag != 0 && e->tag != tag) { - e++; + table_ctl(tbl, tag, MATHCAP_FLAG_DENY); +} + +static void table_update(table *cmotbl, 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) { + table_allow(cmotbl, ob->i); + } + el = list_next(el); } - return e->flag; } -static int mathcap_cmo_isallow_cmo_list(cmo_list *ob) +/* getting a permission to send objects identified by the tag. */ +static int table_allowQ_tag(table *tbl, int tag) { + while (tbl->tag != 0 && tbl->tag != tag) { + tbl++; + } + return tbl->flag; +} + +static int table_allowQ_cmo_list(table *cmotbl, cmo_list *ob) +{ cell *el; - if (mathcap_cmo_isallow_tag(ob->tag)) { + if (table_allowQ_tag(cmotbl, ob->tag)) { el = list_first(ob); while (!list_endof(ob, el)) { - if (!mathcap_cmo_isallow_cmo(el->cmo)) { + if (!table_allowQ_cmo(cmotbl, el->cmo)) { return MATHCAP_FLAG_DENY; } el = list_next(el); @@ -166,137 +197,141 @@ static int mathcap_cmo_isallow_cmo_list(cmo_list *ob) } __inline__ -static int mathcap_cmo_isallow_cmo_monomial32(cmo_monomial32 *ob) +static int table_allowQ_cmo_monomial32(table *cmotbl, cmo_monomial32 *ob) { - return mathcap_cmo_isallow_tag(ob->tag) - && mathcap_cmo_isallow_cmo(ob->coef); + return table_allowQ_tag(cmotbl, ob->tag) + && table_allowQ_cmo(cmotbl, ob->coef); } __inline__ -static int mathcap_cmo_isallow_cmo_mathcap(cmo_mathcap *ob) +static int table_allowQ_cmo_mathcap(table *cmotbl, cmo_mathcap *ob) { - return mathcap_cmo_isallow_tag(ob->tag) - && mathcap_cmo_isallow_cmo(ob->ob); + return table_allowQ_tag(cmotbl, ob->tag) + && table_allowQ_cmo(cmotbl, ob->ob); } -/* 次の cmo の送信が許可されているかを調べる */ -int mathcap_cmo_isallow_cmo(cmo *ob) +/* getting a permission to send the following object. */ +static int table_allowQ_cmo(table *cmotbl, cmo *ob) { int tag = ob->tag; switch(tag) { case CMO_LIST: case CMO_DISTRIBUTED_POLYNOMIAL: - return mathcap_cmo_isallow_cmo_list((cmo_list *)ob); + return table_allowQ_cmo_list(cmotbl, (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); + return table_allowQ_cmo_mathcap(cmotbl, (cmo_mathcap *)ob); case CMO_MONOMIAL32: - return mathcap_cmo_isallow_cmo_monomial32((cmo_monomial32 *)ob); + return table_allowQ_cmo_monomial32(cmotbl, (cmo_monomial32 *)ob); default: - return mathcap_cmo_isallow_tag(tag); + return table_allowQ_tag(cmotbl, tag); } } -/* 次の tag をもつ cmo の送信を許可する */ -__inline__ -static void mathcap_cmo_allow(int tag) +/* getting the System Information */ +static cmo_list *sysinfo_get() { - mcdb_ctl(mathcap_cmo, tag, MATHCAP_FLAG_ALLOW); + cmo_list *syslist = new_cmo_list(); + cmo_int32 *ver = new_cmo_int32(sysinfo.version); + cmo_string *vers = new_cmo_string(sysinfo.version_string); + cmo_string *host = new_cmo_string(sysinfo.hosttype); + cmo_string *sname = new_cmo_string(sysinfo.sysname); + return list_appendl(syslist, ver, sname, vers, host, NULL); } -/* 次の tag をもつ cmo の送信を不許可にする */ -__inline__ -static void mathcap_cmo_deny(int tag) +static char *new_string(char *s) { - mcdb_ctl(mathcap_cmo, tag, MATHCAP_FLAG_DENY); + char *t = MALLOC(strlen(s)+1); + strcpy(t, s); + return t; } -/* 全ての種類の cmo の送信を不許可にする */ -__inline__ -static void mathcap_cmo_deny_all() +static int *new_int_array(int *array) { - mcdb_ctl_all(mathcap_cmo, MATHCAP_FLAG_DENY); + int *new_array; + int length = 0; + while(array[length++] != 0) + ; + new_array = MALLOC(sizeof(int)*length); + return memcpy(new_array, array, sizeof(int)*length); } -/* 全ての種類の cmo の送信を許可する */ -__inline__ -static void mathcap_cmo_allow_all() +void mathcap_init(int ver, char *vstr, char *sysname, int cmos[], int sms[]) { - mcdb_ctl_all(mathcap_cmo, MATHCAP_FLAG_ALLOW); + mathcap_init2(ver, vstr, sysname, cmos, sms, NULL); } -/* 送信許可されている cmo のリストを得る */ -cmo_list *mathcap_cmo_get_allow_all() +/* src must be terminated by NULL */ +static char **clone_str_list(char **src) { - return mcdb_get_allow_all(mathcap_cmo); + int i,len; + char **new = NULL; + if(!src) { + for(len=0; src[len]!=NULL; len++) { + } + new = (char **)MALLOC(sizeof(char *)*(len+1)); + new[len] = NULL; + for(i=0; icmotbl = new_table(sysinfo.cmo_tags); + new->smtbl = new_table(sysinfo.sm_cmds); + new->opts = clone_str_list(sysinfo.opts); + return new; } -static char *new_string(char *s) +/* generating a cmo_mathcap by a local database. */ +cmo_mathcap* mathcap_get(mathcap *this) { - 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); -} + cmo_list *si = sysinfo_get(); + cmo_list *sm= table_get_all(this->smtbl); + cmo_list *opts; + int i; -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); + list_append(l3, (cmo *)list_appendl(new_cmo_list(), + new_cmo_int32(OX_DATA), + table_get_all(this->cmotbl), NULL)); + if(this->opts) { + opts = new_cmo_list(); + for(i=0; this->opts[i]!=NULL; i++) { + list_append(opts, (cmo *)new_cmo_string(this->opts[i])); } - el = list_next(el); + list_appendl(mc, (cmo *)si, (cmo *)sm, (cmo *)l3, (cmo *)opts, NULL); + }else { + list_appendl(mc, (cmo *)si, (cmo *)sm, (cmo *)l3, NULL); } + return new_cmo_mathcap((cmo *)mc); } -/* cmo_mathcap が妥当な構造を持つかを調べる. (未実装) */ -int cmo_mathcap_isvalid(cmo_mathcap *mc) -{ - return 1; -} - /* ( ..., ( type, (...) ), (cmo_int32, (...) ), ... ) */ /* ^^^^^ Here! */ static cmo_list *get_messagetypes(cmo_list *ob, int type) @@ -322,15 +357,21 @@ static cmo_list *cmo_mathcap_get_cmotypes(cmo_mathcap return get_messagetypes(ob, OX_DATA); } -/* 受信した mathcap データを反映させる */ -void mathcap_update(cmo_mathcap *mc) +/* The mathcap_update integrates received cmo_mathcap into the mathcap + database. If this == NULL, then an instance of mathcap is generated. */ +mathcap *mathcap_update(mathcap *this, cmo_mathcap *mc) { 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); - } + types = cmo_mathcap_get_cmotypes(mc); + if (types != NULL) { + table_ctl_all(this->cmotbl, MATHCAP_FLAG_DENY); + table_update(this->cmotbl, types); } + + return this; +} + +int mathcap_allowQ_cmo(mathcap *this, cmo *ob) +{ + return table_allowQ_cmo(this->cmotbl, ob); }