Annotation of OpenXM/src/ox_toolkit/mathcap.c, Revision 1.8
1.1 ohara 1: /* -*- mode: C; coding: euc-japan -*- */
1.8 ! ohara 2: /* $OpenXM: OpenXM/src/ox_toolkit/mathcap.c,v 1.7 2000/12/03 16:15:03 ohara Exp $ */
1.1 ohara 3:
4: /* This module includes functions for handling mathcap databases. */
5:
6: #include <stdlib.h>
1.5 ohara 7: #include <string.h>
1.1 ohara 8: #include "ox_toolkit.h"
9:
1.5 ohara 10: #define MATHCAP_FLAG_DENY 0
11: #define MATHCAP_FLAG_ALLOW 1
1.3 ohara 12:
1.5 ohara 13: static void table_init(table *m, int key);
14: static table *new_table(int *src);
15: static table *table_lookup(table *tbl, int tag);
16: static void table_ctl(table *tbl, int tag, int flag);
17: static void table_ctl_all(table *tbl, int flag);
18: static cmo_list *table_get_all(table *tbl);
19: static void table_allow(table *tbl, int tag);
20: static void table_deny(table *tbl, int tag);
21: static void table_update(table *cmotbl, cmo_list* types);
22: static int table_allowQ_tag(table *tbl, int tag);
23: static int table_allowQ_cmo_list(table *cmotbl, cmo_list *ob);
24: static int table_allowQ_cmo_monomial32(table *cmotbl, cmo_monomial32 *ob);
25: static int table_allowQ_cmo_mathcap(table *cmotbl, cmo_mathcap *ob);
26: static int table_allowQ_cmo(table *cmotbl, cmo *ob);
27: static cmo_list *sysinfo_get();
1.3 ohara 28: static char *new_string(char *s);
1.5 ohara 29: static int *new_int_array(int *array);
30: static cmo_list *get_messagetypes(cmo_list *ob, int type);
1.3 ohara 31: static cmo_list *cmo_mathcap_get_cmotypes(cmo_mathcap *mc);
1.2 ohara 32:
1.5 ohara 33: static int cmotbl_a[] = {
1.3 ohara 34: CMO_NULL,
35: CMO_INT32,
36: CMO_DATUM,
37: CMO_STRING,
38: CMO_MATHCAP,
39: CMO_LIST,
40: CMO_MONOMIAL32,
41: CMO_ZZ,
42: CMO_ZERO,
43: CMO_DMS_GENERIC,
44: CMO_RING_BY_NAME,
45: CMO_INDETERMINATE,
46: CMO_DISTRIBUTED_POLYNOMIAL,
47: CMO_ERROR2,
48: 0,
1.1 ohara 49: };
50:
1.5 ohara 51: static int smtbl_a[] = {
1.3 ohara 52: SM_popCMO,
53: SM_popString,
54: SM_mathcap,
55: SM_pops,
56: SM_executeStringByLocalParser,
57: SM_executeFunction,
58: SM_setMathCap,
59: SM_shutdown,
60: SM_control_kill,
61: SM_control_reset_connection,
1.5 ohara 62: SM_control_spawn_server,
63: SM_control_terminate_server,
1.3 ohara 64: 0,
1.1 ohara 65: };
66:
1.5 ohara 67: static struct {
68: int version;
69: char *version_string;
70: char *sysname;
71: char *hosttype;
72: int *cmo_tags;
73: int *sm_cmds;
74: } sysinfo = {0, "NO VERSION", "NONAME", "UNKNOWN", cmotbl_a, smtbl_a};
75:
1.3 ohara 76: __inline__
1.5 ohara 77: static void table_init(table *m, int key)
1.3 ohara 78: {
79: m->tag = key;
80: m->flag = MATHCAP_FLAG_ALLOW;
81: }
1.2 ohara 82:
1.5 ohara 83: static table *new_table(int *src)
1.2 ohara 84: {
1.5 ohara 85: table *new;
1.3 ohara 86: int len=0;
87: int i;
88: while (src[len++] != 0) {
89: }
1.5 ohara 90: new = malloc(sizeof(table)*len);
1.3 ohara 91: for(i=0; i<len; i++) {
1.5 ohara 92: table_init(new+i, src[i]);
1.3 ohara 93: }
94: return new;
1.2 ohara 95: }
96:
1.7 ohara 97: /* looking for an item of the tag */
1.5 ohara 98: static table *table_lookup(table *tbl, int tag)
1.2 ohara 99: {
1.5 ohara 100: while (tbl->tag != 0) {
101: if (tbl->tag == tag) {
102: return tbl;
1.2 ohara 103: }
1.5 ohara 104: tbl++;
1.2 ohara 105: }
106: return NULL;
107: }
108:
1.7 ohara 109: /* controller about a cmo identified by the tag */
1.5 ohara 110: static void table_ctl(table *tbl, int tag, int flag)
1.2 ohara 111: {
1.5 ohara 112: table *e = table_lookup(tbl, tag);
1.2 ohara 113: if (e != NULL) {
114: e->flag = flag;
115: }
116: }
117:
1.7 ohara 118: /* controller about all CMObjects */
1.5 ohara 119: static void table_ctl_all(table *tbl, int flag)
1.2 ohara 120: {
1.5 ohara 121: while (tbl->tag != 0) {
122: tbl->flag = flag;
123: tbl++;
1.2 ohara 124: }
125: }
126:
1.7 ohara 127: /* getting the list of tags of all allowed objects */
1.5 ohara 128: static cmo_list *table_get_all(table *tbl)
1.2 ohara 129: {
130: cmo_list *list = new_cmo_list();
1.5 ohara 131: while (tbl->tag != 0) {
132: if (tbl->flag == MATHCAP_FLAG_ALLOW) {
133: list_append(list, (cmo *)new_cmo_int32(tbl->tag));
1.2 ohara 134: }
1.5 ohara 135: tbl++;
1.2 ohara 136: }
137: return list;
138: }
139:
1.7 ohara 140: /* giving a permssion to send objects identified by the tag. */
1.5 ohara 141: __inline__
142: static void table_allow(table *tbl, int tag)
143: {
144: table_ctl(tbl, tag, MATHCAP_FLAG_ALLOW);
145: }
146:
1.7 ohara 147: /* taking a permssion to send objects identified by the tag. */
1.5 ohara 148: __inline__
149: static void table_deny(table *tbl, int tag)
150: {
151: table_ctl(tbl, tag, MATHCAP_FLAG_DENY);
152: }
153:
154: static void table_update(table *cmotbl, cmo_list* types)
155: {
156: cell *el = list_first(types);
157: cmo_int32 *ob;
158: while(!list_endof(types, el)) {
159: ob = (cmo_int32 *)el->cmo;
160: if (ob->tag == CMO_INT32) {
161: table_allow(cmotbl, ob->i);
162: }
163: el = list_next(el);
164: }
165: }
1.1 ohara 166:
1.7 ohara 167: /* getting a permission to send objects identified by the tag. */
1.5 ohara 168: static int table_allowQ_tag(table *tbl, int tag)
1.1 ohara 169: {
1.5 ohara 170: while (tbl->tag != 0 && tbl->tag != tag) {
171: tbl++;
1.1 ohara 172: }
1.5 ohara 173: return tbl->flag;
1.1 ohara 174: }
175:
1.5 ohara 176: static int table_allowQ_cmo_list(table *cmotbl, cmo_list *ob)
1.1 ohara 177: {
178: cell *el;
1.5 ohara 179: if (table_allowQ_tag(cmotbl, ob->tag)) {
1.1 ohara 180: el = list_first(ob);
181: while (!list_endof(ob, el)) {
1.5 ohara 182: if (!table_allowQ_cmo(cmotbl, el->cmo)) {
1.1 ohara 183: return MATHCAP_FLAG_DENY;
184: }
185: el = list_next(el);
186: }
187: return MATHCAP_FLAG_ALLOW;
188: }
189: return MATHCAP_FLAG_DENY;
190: }
191:
1.2 ohara 192: __inline__
1.5 ohara 193: static int table_allowQ_cmo_monomial32(table *cmotbl, cmo_monomial32 *ob)
1.1 ohara 194: {
1.5 ohara 195: return table_allowQ_tag(cmotbl, ob->tag)
196: && table_allowQ_cmo(cmotbl, ob->coef);
1.1 ohara 197: }
198:
1.2 ohara 199: __inline__
1.5 ohara 200: static int table_allowQ_cmo_mathcap(table *cmotbl, cmo_mathcap *ob)
1.1 ohara 201: {
1.5 ohara 202: return table_allowQ_tag(cmotbl, ob->tag)
203: && table_allowQ_cmo(cmotbl, ob->ob);
1.1 ohara 204: }
205:
1.7 ohara 206: /* getting a permission to send the following object. */
1.5 ohara 207: static int table_allowQ_cmo(table *cmotbl, cmo *ob)
1.1 ohara 208: {
209: int tag = ob->tag;
210: switch(tag) {
211: case CMO_LIST:
212: case CMO_DISTRIBUTED_POLYNOMIAL:
1.5 ohara 213: return table_allowQ_cmo_list(cmotbl, (cmo_list *)ob);
1.1 ohara 214: case CMO_MATHCAP:
215: case CMO_ERROR2:
216: case CMO_RING_BY_NAME:
217: case CMO_INDETERMINATE:
1.5 ohara 218: return table_allowQ_cmo_mathcap(cmotbl, (cmo_mathcap *)ob);
1.1 ohara 219: case CMO_MONOMIAL32:
1.5 ohara 220: return table_allowQ_cmo_monomial32(cmotbl, (cmo_monomial32 *)ob);
1.1 ohara 221: default:
1.5 ohara 222: return table_allowQ_tag(cmotbl, tag);
1.1 ohara 223: }
224: }
225:
1.7 ohara 226: /* getting the System Information */
1.5 ohara 227: static cmo_list *sysinfo_get()
1.1 ohara 228: {
229: cmo_list *syslist = new_cmo_list();
1.3 ohara 230: cmo_int32 *ver = new_cmo_int32(sysinfo.version);
231: cmo_string *vers = new_cmo_string(sysinfo.version_string);
232: cmo_string *host = new_cmo_string(sysinfo.hosttype);
233: cmo_string *sname = new_cmo_string(sysinfo.sysname);
234: return list_appendl(syslist, ver, sname, vers, host, NULL);
1.1 ohara 235: }
236:
237: static char *new_string(char *s)
238: {
1.8 ! ohara 239: char *t = malloc(strlen(s)+1);
1.1 ohara 240: strcpy(t, s);
241: return t;
242: }
243:
1.5 ohara 244: static int *new_int_array(int *array)
245: {
246: int *new_array;
247: int length = 0;
248: while(array[length++] != 0)
249: ;
250: new_array = malloc(sizeof(int)*length);
251: return memcpy(new_array, array, sizeof(int)*length);
252: }
253:
254: void mathcap_init(int ver, char *vstr, char *sysname, int cmos[], int sms[])
1.1 ohara 255: {
256: char *host = getenv("HOSTTYPE");
1.3 ohara 257: sysinfo.hosttype = (host != NULL)? new_string(host): "UNKNOWN";
258: sysinfo.sysname = new_string(sysname);
259: sysinfo.version_string = new_string(vstr);
1.5 ohara 260: sysinfo.version = ver;
261: if (cmos != NULL) {
262: sysinfo.cmo_tags = new_int_array(cmos);
263: }
264: if (sms != NULL) {
265: sysinfo.sm_cmds = new_int_array(sms);
266: }
1.3 ohara 267: }
1.1 ohara 268:
1.5 ohara 269: mathcap *new_mathcap()
1.3 ohara 270: {
1.5 ohara 271: mathcap *new = malloc(sizeof(mathcap));
272: new->cmotbl = new_table(sysinfo.cmo_tags);
273: new->smtbl = new_table(sysinfo.sm_cmds);
274: return new;
1.1 ohara 275: }
276:
1.7 ohara 277: /* generating a cmo_mathcap by a local database. */
1.3 ohara 278: cmo_mathcap* mathcap_get(mathcap *this)
1.1 ohara 279: {
280: cmo_list *mc = new_cmo_list();
281: cmo_list *l3 = new_cmo_list();
1.3 ohara 282: list_append(l3, list_appendl(new_cmo_list(),
283: new_cmo_int32(OX_DATA),
1.5 ohara 284: table_get_all(this->cmotbl), NULL));
285: list_appendl(mc, (cmo *)sysinfo_get(),
286: (cmo *)table_get_all(this->smtbl), (cmo *)l3, NULL);
1.1 ohara 287: return new_cmo_mathcap((cmo *)mc);
288: }
289:
290: /* ( ..., ( type, (...) ), (cmo_int32, (...) ), ... ) */
291: /* ^^^^^ Here! */
292: static cmo_list *get_messagetypes(cmo_list *ob, int type)
293: {
294: cmo_list *c;
295: cell *el;
296:
297: for (el = list_first(ob); !list_endof(ob, el); el = list_next(el)) {
298: c = (cmo_list *)el->cmo;
299: if (((cmo_int32 *)list_nth(c, 0))->i == type) {
300: return (cmo_list *)list_nth(c, 1);
301: }
302: }
303: return NULL;
304: }
305:
306: /* cmo_mathcap->ob = ( (...), (...), ( ( cmo_int32, (...) ), ...), ...) */
307: /* ^^^^^ Here! */
1.2 ohara 308: __inline__
1.1 ohara 309: static cmo_list *cmo_mathcap_get_cmotypes(cmo_mathcap *mc)
310: {
311: cmo_list *ob = (cmo_list *)list_nth((cmo_list *)mc->ob, 2);
312: return get_messagetypes(ob, OX_DATA);
313: }
314:
1.7 ohara 315: /* The mathcap_update integrates received cmo_mathcap into the mathcap
316: database. If this == NULL, then an instance of mathcap is generated. */
1.3 ohara 317: mathcap *mathcap_update(mathcap *this, cmo_mathcap *mc)
1.1 ohara 318: {
319: cmo_list *types;
1.5 ohara 320: types = cmo_mathcap_get_cmotypes(mc);
321: if (types != NULL) {
322: table_ctl_all(this->cmotbl, MATHCAP_FLAG_DENY);
323: table_update(this->cmotbl, types);
1.1 ohara 324: }
1.5 ohara 325:
326: return this;
327: }
328:
329: int mathcap_allowQ_cmo(mathcap *this, cmo *ob)
330: {
331: return table_allowQ_cmo(this->cmotbl, ob);
1.1 ohara 332: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mathcap.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM / src / ox_toolkit