[BACK]Return to mathcap.c CVS log [TXT][DIR] Up to [local] / OpenXM / src / ox_toolkit

Diff for /OpenXM/src/ox_toolkit/mathcap.c between version 1.8 and 1.12

version 1.8, 2003/05/19 06:57:38 version 1.12, 2005/07/26 12:52:05
Line 1 
Line 1 
 /* -*- mode: C; coding: euc-japan -*- */  /* -*- mode: C; coding: euc-japan -*- */
 /* $OpenXM: OpenXM/src/ox_toolkit/mathcap.c,v 1.7 2000/12/03 16:15:03 ohara Exp $ */  /* $OpenXM: OpenXM/src/ox_toolkit/mathcap.c,v 1.11 2005/03/04 06:29:46 ohara Exp $ */
   
 /* This module includes functions for handling mathcap databases. */  /* This module includes functions for handling mathcap databases. */
   
   #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
 #include "ox_toolkit.h"  #include "ox_toolkit.h"
   
 #define MATHCAP_FLAG_DENY   0  #define MATHCAP_1ST_FORMAT "(CMO_LIST (CMO_INT32 %d) (CMO_STRING \"%s\") (CMO_STRING \"%s\") (CMO_STRING \"%s\"))"
 #define MATHCAP_FLAG_ALLOW  1  
   
 static void table_init(table *m, int key);  static int default_cmd[] = {
 static table *new_table(int *src);      SM_popCMO,
 static table *table_lookup(table *tbl, int tag);      SM_popString,
 static void table_ctl(table *tbl, int tag, int flag);      SM_mathcap,
 static void table_ctl_all(table *tbl, int flag);      SM_pops,
 static cmo_list *table_get_all(table *tbl);      SM_executeStringByLocalParser,
 static void table_allow(table *tbl, int tag);      SM_executeFunction,
 static void table_deny(table *tbl, int tag);      SM_control_kill,
 static void table_update(table *cmotbl, cmo_list* types);      SM_control_reset_connection,
 static int table_allowQ_tag(table *tbl, int tag);      0 };
 static int table_allowQ_cmo_list(table *cmotbl, cmo_list *ob);  static int default_cmo[] = {
 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 int *new_int_array(int *array);  
 static cmo_list *get_messagetypes(cmo_list *ob, int type);  
 static cmo_list *cmo_mathcap_get_cmotypes(cmo_mathcap *mc);  
   
 static int cmotbl_a[] = {  
     CMO_NULL,      CMO_NULL,
     CMO_INT32,      CMO_INT32,
     CMO_DATUM,  
     CMO_STRING,      CMO_STRING,
     CMO_MATHCAP,      CMO_MATHCAP,
     CMO_LIST,      CMO_LIST,
     CMO_MONOMIAL32,      CMO_MONOMIAL32,
     CMO_ZZ,      CMO_ZZ,
       CMO_QQ,
     CMO_ZERO,      CMO_ZERO,
     CMO_DMS_GENERIC,      CMO_DMS_GENERIC,
     CMO_RING_BY_NAME,      CMO_RING_BY_NAME,
     CMO_INDETERMINATE,      CMO_RECURSIVE_POLYNOMIAL,
     CMO_DISTRIBUTED_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,      CMO_ERROR2,
     0,      0 };
 };  static int default_oxtag[] = { OX_DATA, 0 };
   
 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,  
 };  
   
 static struct {  static struct {
     int  version;      int  ox_version;
     char *version_string;  
     char *sysname;      char *sysname;
       char *version;
     char *hosttype;      char *hosttype;
     int  *cmo_tags;  } sysinfo = {OX_PROTOCOL_VERSION, "ox_toolkit", OX_TOOLKIT_VERSION, "generic"};
     int  *sm_cmds;  
 } sysinfo = {0, "NO VERSION", "NONAME", "UNKNOWN", cmotbl_a, smtbl_a};  
   
 __inline__  mathcap default_mathcap = {default_cmd, default_cmo};
 static void table_init(table *m, int key)  
   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);
   
   mathcap *new_mathcap()
 {  {
     m->tag  = key;      mathcap *mcap = MALLOC(sizeof(mathcap));
     m->flag = MATHCAP_FLAG_ALLOW;      mcap->cmo = icopy(default_cmo);
       mcap->cmd = icopy(default_cmd);
       return mcap;
 }  }
   
 static table *new_table(int *src)  mathcap *new_mathcap_set(int *cmd, int *cmo)
 {  {
     table *new;      mathcap *mcap  = MALLOC(sizeof(mathcap));
     int len=0;          mcap->cmd = (cmd)? cmd: icopy(default_cmd);
     int i;          mcap->cmo = (cmo)? cmo: icopy(default_cmo);
     while (src[len++] != 0) {      return mcap;
     }  
     new = malloc(sizeof(table)*len);  
     for(i=0; i<len; i++) {  
         table_init(new+i, src[i]);  
     }  
     return new;  
 }  }
   
 /* looking for an item of the tag */  cmo_list *cmo_mathcap_1st()
 static table *table_lookup(table *tbl, int tag)  
 {  {
     while (tbl->tag != 0) {      char buffer[BUFSIZ];
         if (tbl->tag == tag) {      static char format[] = MATHCAP_1ST_FORMAT;
             return tbl;      int len = sizeof(format) + 32
         }                  + strlen(sysinfo.sysname)
         tbl++;                  + 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;      return NULL;
 }  }
   
 /* controller about a cmo identified by the tag */  /* 0: terminator of array of integer. */
 static void table_ctl(table *tbl, int tag, int flag)  static int ilen(int a[])
 {  {
     table *e = table_lookup(tbl, tag);      int i=0;
     if (e != NULL) {      if (a != NULL) {
         e->flag = flag;          for( ; a[i] !=0; i++) {
           }
     }      }
       return i;
 }  }
   
 /* controller about all CMObjects */  static int *icopy(int s[])
 static void table_ctl_all(table *tbl, int flag)  
 {  {
     while (tbl->tag != 0) {      int n = sizeof(int)*(ilen(s)+1);
         tbl->flag = flag;      int *d = MALLOC(n);
         tbl++;      memcpy(d,s,n);
     }      return d;
 }  }
   
 /* getting the list of tags of all allowed objects */  static int *icopyn(int s[], int n)
 static cmo_list *table_get_all(table *tbl)  
 {  {
     cmo_list *list = new_cmo_list();      int *d = MALLOC((n = sizeof(int)*(n+1)));
     while (tbl->tag != 0) {      memcpy(d,s,n);
         if (tbl->flag == MATHCAP_FLAG_ALLOW) {      return d;
             list_append(list, (cmo *)new_cmo_int32(tbl->tag));  
         }  
         tbl++;  
     }  
     return list;  
 }  }
   
 /* giving a permssion to send objects identified by the tag. */  cmo_mathcap *new_cmo_mathcap_by_mathcap(mathcap *mcap)
 __inline__  
 static void table_allow(table *tbl, int tag)  
 {  {
     table_ctl(tbl, tag, MATHCAP_FLAG_ALLOW);      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)));
 }  }
   
 /* taking a permssion to send objects identified by the tag. */  static int cmo_int32_to_int(cmo_int32* m)
 __inline__  
 static void table_deny(table *tbl, int tag)  
 {  {
     table_ctl(tbl, tag, MATHCAP_FLAG_DENY);      return m->i;
 }  }
   
 static void table_update(table *cmotbl, cmo_list* types)  mathcap *new_mathcap_by_cmo_mathcap(cmo_mathcap *cap)
 {  {
     cell *el = list_first(types);      int *cmd = list_to_array_map(list_nth(cap->ob, 1), cmo_int32_to_int);
     cmo_int32 *ob;      int *cmo = list_to_array_map(list_nth(list_nth(cap->ob, 2), 1),
     while(!list_endof(types, el)) {                                   cmo_int32_to_int);
         ob = (cmo_int32 *)el->cmo;      return new_mathcap_set(cmd, cmo);
         if (ob->tag == CMO_INT32) {  
             table_allow(cmotbl, ob->i);  
         }  
         el = list_next(el);  
     }  
 }  }
   
 /* getting a permission to send objects identified by the tag. */  /* if base is unsorted. */
 static int table_allowQ_tag(table *tbl, int tag)  static int *imerge(int *base, int *diff)
 {  {
     while (tbl->tag != 0 && tbl->tag != tag) {      int i,j,k;
         tbl++;      int n = ilen(base);
     }      int m = ilen(diff);
     return tbl->flag;      int *t = ALLOCA(sizeof(int)*(n+1));
 }      int *ret;
       for(i=0,j=0; i<n; i++) {
 static int table_allowQ_cmo_list(table *cmotbl, cmo_list *ob)          for(k=0; k<m; k++) {
 {              if (base[i] == diff[k]) {
     cell *el;                  t[j++] = base[i];
     if (table_allowQ_tag(cmotbl, ob->tag)) {                  break;
         el = list_first(ob);  
         while (!list_endof(ob, el)) {  
             if (!table_allowQ_cmo(cmotbl, el->cmo)) {  
                 return MATHCAP_FLAG_DENY;  
             }              }
             el = list_next(el);  
         }          }
         return MATHCAP_FLAG_ALLOW;  
     }      }
     return MATHCAP_FLAG_DENY;      t[j] = 0;
       ret = icopyn(t,j);
       return ret;
 }  }
   
 __inline__  static mathcap *mathcap_merge_io(mathcap *this, mathcap *diff)
 static int table_allowQ_cmo_monomial32(table *cmotbl, cmo_monomial32 *ob)  
 {  {
     return table_allowQ_tag(cmotbl, ob->tag)      int *tmp;
         && table_allowQ_cmo(cmotbl, ob->coef);      tmp = imerge(this->cmo, diff->cmo);
       FREE(this->cmo);
       this->cmo = tmp;
       return this;
 }  }
   
 __inline__  /* for compatibility */
 static int table_allowQ_cmo_mathcap(table *cmotbl, cmo_mathcap *ob)  void mathcap_init(char *version, char *sysname)
 {  {
     return table_allowQ_tag(cmotbl, ob->tag)      sysinfo.hosttype = getenv("HOSTTYPE");
         && table_allowQ_cmo(cmotbl, ob->ob);      sysinfo.version  = version;
       sysinfo.sysname  = sysname;
 }  }
   
 /* 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 table_allowQ_cmo_list(cmotbl, (cmo_list *)ob);  
     case CMO_MATHCAP:  
     case CMO_ERROR2:  
     case CMO_RING_BY_NAME:  
     case CMO_INDETERMINATE:  
         return table_allowQ_cmo_mathcap(cmotbl, (cmo_mathcap *)ob);  
     case CMO_MONOMIAL32:  
         return table_allowQ_cmo_monomial32(cmotbl, (cmo_monomial32 *)ob);  
     default:  
         return table_allowQ_tag(cmotbl, tag);  
     }  
 }  
   
 /* getting the System Information */  
 static cmo_list *sysinfo_get()  
 {  
     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);  
 }  
   
 static char *new_string(char *s)  
 {  
     char *t = malloc(strlen(s)+1);  
     strcpy(t, s);  
     return t;  
 }  
   
 static int *new_int_array(int *array)  
 {  
     int *new_array;  
     int length = 0;  
     while(array[length++] != 0)  
         ;  
     new_array = malloc(sizeof(int)*length);  
     return memcpy(new_array, array, sizeof(int)*length);  
 }  
   
 void mathcap_init(int ver, char *vstr, char *sysname, int cmos[], int sms[])  
 {  
     char *host = getenv("HOSTTYPE");  
     sysinfo.hosttype = (host != NULL)? new_string(host): "UNKNOWN";  
     sysinfo.sysname  = new_string(sysname);  
     sysinfo.version_string = new_string(vstr);  
     sysinfo.version  = ver;  
     if (cmos != NULL) {  
         sysinfo.cmo_tags = new_int_array(cmos);  
     }  
     if (sms != NULL) {  
         sysinfo.sm_cmds = new_int_array(sms);  
     }  
 }  
   
 mathcap *new_mathcap()  
 {  
     mathcap *new = malloc(sizeof(mathcap));  
     new->cmotbl = new_table(sysinfo.cmo_tags);  
     new->smtbl  = new_table(sysinfo.sm_cmds);  
     return new;  
 }  
   
 /* generating a cmo_mathcap by a local database. */  
 cmo_mathcap* mathcap_get(mathcap *this)  cmo_mathcap* mathcap_get(mathcap *this)
 {  {
     cmo_list *mc = new_cmo_list();      return new_cmo_mathcap_by_mathcap(this);
     cmo_list *l3 = new_cmo_list();  
     list_append(l3, list_appendl(new_cmo_list(),  
                                  new_cmo_int32(OX_DATA),  
                                  table_get_all(this->cmotbl), NULL));  
     list_appendl(mc, (cmo *)sysinfo_get(),  
                  (cmo *)table_get_all(this->smtbl), (cmo *)l3, NULL);  
     return new_cmo_mathcap((cmo *)mc);  
 }  }
   mathcap *mathcap_update(mathcap *this, cmo_mathcap *m)
 /* ( ..., ( type, (...) ), (cmo_int32, (...) ), ... )  */  
 /*                ^^^^^ Here!                          */  
 static cmo_list *get_messagetypes(cmo_list *ob, int type)  
 {  {
     cmo_list  *c;      return mathcap_merge_io(this, new_mathcap_by_cmo_mathcap(m));
     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;  
 }  
   
 /* cmo_mathcap->ob = ( (...), (...), ( ( cmo_int32, (...) ), ...), ...) */  
 /*                                              ^^^^^ Here!         */  
 __inline__  
 static cmo_list *cmo_mathcap_get_cmotypes(cmo_mathcap *mc)  
 {  
     cmo_list *ob = (cmo_list *)list_nth((cmo_list *)mc->ob, 2);  
     return get_messagetypes(ob, OX_DATA);  
 }  
   
 /* 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;  
     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);  
 }  }
Legend:
Removed from v.1.8  
changed lines
  Added in v.1.12
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>