[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.1 and 1.3

version 1.1, 2000/10/10 05:23:20 version 1.3, 2000/11/18 05:49:18
Line 1 
Line 1 
 /* -*- mode: C; coding: euc-japan -*- */  /* -*- mode: C; coding: euc-japan -*- */
 /* $OpenXM$ */  /* $OpenXM: OpenXM/src/ox_toolkit/mathcap.c,v 1.2 2000/10/12 15:40:41 ohara Exp $ */
   
 /* This module includes functions for handling mathcap databases. */  /* This module includes functions for handling mathcap databases. */
   
 #include <stdlib.h>  #include <stdlib.h>
 #include "ox_toolkit.h"  #include "ox_toolkit.h"
   
   /* 送信許可されている cmo, sm のリストを得る */
   #define smdb_get_allow_all(x)   mcdb_get_allow_all((x)->sm_db)
   #define cmodb_get_allow_all(x)  mcdb_get_allow_all((x)->cmo_db)
   
   /* 全ての種類の cmo の送信を許可/不許可にする */
   #define cmodb_deny_all(x)   mcdb_ctl_all((x), MATHCAP_FLAG_DENY)
   #define cmodb_allow_all(x)  mcdb_ctl_all((x), MATHCAP_FLAG_ALLOW)
   
 typedef struct {  typedef struct {
     int tag;      int tag;
     int flag;      int flag;
 } mc_cell;  } mcdb;
   
 static int mathcap_cmo_isallow_tag(int tag);  typedef struct {
 static mc_cell *mathcap_cmo_lookup(int tag);      mcdb *cmo_db;
 static int mathcap_cmo_isallow_cmo_list(cmo_list *ob);      mcdb *sm_db;
 static int mathcap_cmo_isallow_cmo_monomial32(cmo_monomial32 *ob);  } mathcap;
 static int mathcap_cmo_isallow_cmo_mathcap(cmo_mathcap *ob);  
 static char *new_string(char *s);  static char *new_string(char *s);
 static void mathcap_cmo_update(cmo_list* types);  
 static cmo_list *get_messagetypes(cmo_list *ob, int type);  
 static cmo_list *cmo_mathcap_get_cmotypes(cmo_mathcap *mc);  static cmo_list *cmo_mathcap_get_cmotypes(cmo_mathcap *mc);
 static cmo_list *get_messagetypes(cmo_list *ob, int type);  static cmo_list *get_messagetypes(cmo_list *ob, int type);
 static cmo_list *cmo_mathcap_get_cmotypes(cmo_mathcap *mc);  static cmo_list *mcdb_get_allow_all(mcdb *db);
   static cmo_list *sysinfo_get_all();
   static int cmodb_isallow_cmo(mcdb *cmo_db, cmo *ob);
   static int cmodb_isallow_cmo_list(mcdb *cmo_db, cmo_list *ob);
   static int cmodb_isallow_cmo_mathcap(mcdb *cmo_db, cmo_mathcap *ob);
   static int cmodb_isallow_cmo_monomial32(mcdb *cmo_db, cmo_monomial32 *ob);
   static int cmodb_isallow_tag(mcdb *cmo_db, int tag);
   static mcdb *mcdb_lookup(mcdb *db, int tag);
   static mcdb *new_mcdb(int *src);
   static void cmodb_allow(mcdb *cmo_db, int tag);
   static void cmodb_deny(mcdb *cmo_db, int tag);
   static void cmodb_update(mcdb *cmo_db, cmo_list* types);
   static void mcdb_ctl(mcdb *db, int tag, int flag);
   static void mcdb_ctl_all(mcdb *db, int flag);
   static void mcdb_init(mcdb *m, int key);
   void sysinfo_set(int version, char *version_string, char *sysname);
   
 static mc_cell mathcap_cmo[] = {  static int cmodb_d[] = {
     {CMO_NULL,       MATHCAP_FLAG_ALLOW},      CMO_NULL,
     {CMO_INT32,      MATHCAP_FLAG_ALLOW},      CMO_INT32,
     {CMO_DATUM,      MATHCAP_FLAG_ALLOW},      CMO_DATUM,
     {CMO_STRING,     MATHCAP_FLAG_ALLOW},      CMO_STRING,
     {CMO_MATHCAP,    MATHCAP_FLAG_ALLOW},      CMO_MATHCAP,
     {CMO_LIST,       MATHCAP_FLAG_ALLOW},      CMO_LIST,
     {CMO_MONOMIAL32, MATHCAP_FLAG_ALLOW},      CMO_MONOMIAL32,
     {CMO_ZZ,         MATHCAP_FLAG_ALLOW},      CMO_ZZ,
     {CMO_ZERO,       MATHCAP_FLAG_ALLOW},      CMO_ZERO,
     {CMO_DMS_GENERIC, MATHCAP_FLAG_ALLOW},      CMO_DMS_GENERIC,
     {CMO_RING_BY_NAME, MATHCAP_FLAG_ALLOW},      CMO_RING_BY_NAME,
     {CMO_INDETERMINATE, MATHCAP_FLAG_ALLOW},      CMO_INDETERMINATE,
     {CMO_DISTRIBUTED_POLYNOMIAL, MATHCAP_FLAG_ALLOW},      CMO_DISTRIBUTED_POLYNOMIAL,
     {CMO_ERROR2,     MATHCAP_FLAG_ALLOW},      CMO_ERROR2,
     {0,              MATHCAP_FLAG_DENY}      0,
 };  };
   
 static int mathcap_sm[] = {  static int smdb_d[] = {
     SM_popCMO,      SM_popCMO,
     SM_popString,      SM_popString,
     SM_mathcap,      SM_mathcap,
Line 52  static int mathcap_sm[] = {
Line 73  static int mathcap_sm[] = {
     SM_shutdown,      SM_shutdown,
     SM_control_kill,      SM_control_kill,
     SM_control_reset_connection,      SM_control_reset_connection,
     0      0,
 };  };
   
 static struct {  __inline__
     int  version;  static void mcdb_init(mcdb *m, int key)
     char *version_string;  {
     char *sysname;      m->tag  = key;
     char *hosttype;      m->flag = MATHCAP_FLAG_ALLOW;
 } mathcap_sysinfo = {0, "NO VERSION", "NONAME", "UNKNOWN"};  }
   
 /* 次の tag をもつ cmo の送信が許可されているかを調べる */  static mcdb *new_mcdb(int *src)
 static int mathcap_cmo_isallow_tag(int tag)  
 {  {
     mc_cell *e = mathcap_cmo;      mcdb *new;
     while (e->tag != 0 && e->tag != tag) {      int len=0;
         e++;      int i;
       while (src[len++] != 0) {
     }      }
     return e->flag;      new = malloc(sizeof(mcdb)*len);
       for(i=0; i<len; i++) {
           mcdb_init(new+i, src[i]);
       }
       return new;
 }  }
   
   mathcap *new_mathcap_d()
   {
       mathcap *new = malloc(sizeof(mathcap));
       new->cmo_db = new_mcdb(cmodb_d);
       new->sm_db  = new_mcdb(smdb_d);
       return new;
   }
   
 /* 次の tag についてのキーを探す */  /* 次の tag についてのキーを探す */
 static mc_cell *mathcap_cmo_lookup(int tag)  static mcdb *mcdb_lookup(mcdb *db, int tag)
 {  {
     mc_cell *e = mathcap_cmo;      while (db->tag != 0) {
     while (e->tag != 0) {          if (db->tag == tag) {
         if (e->tag == tag) {              return db;
             return e;  
         }          }
         e++;          db++;
     }      }
     return NULL;      return NULL;
 }  }
   
 static int mathcap_cmo_isallow_cmo_list(cmo_list *ob)  /* tag に対する送信制御 */
   static void mcdb_ctl(mcdb *db, int tag, int flag)
 {  {
       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));
           }
           db++;
       }
       return list;
   }
   
   static struct {
       int  version;
       char *version_string;
       char *sysname;
       char *hosttype;
   } sysinfo = {0, "NO VERSION", "NONAME", "UNKNOWN"};
   
   /* 次の tag をもつ cmo の送信が許可されているかを調べる */
   static int cmodb_isallow_tag(mcdb *cmo_db, int tag)
   {
       while (cmo_db->tag != 0 && cmo_db->tag != tag) {
           cmo_db++;
       }
       return cmo_db->flag;
   }
   
   static int cmodb_isallow_cmo_list(mcdb *cmo_db, cmo_list *ob)
   {
     cell *el;      cell *el;
     if (mathcap_cmo_isallow_tag(ob->tag)) {      if (cmodb_isallow_tag(cmo_db, ob->tag)) {
         el = list_first(ob);          el = list_first(ob);
         while (!list_endof(ob, el)) {          while (!list_endof(ob, el)) {
             if (!mathcap_cmo_isallow_cmo(el->cmo)) {              if (!cmodb_isallow_cmo(cmo_db, el->cmo)) {
                 return MATHCAP_FLAG_DENY;                  return MATHCAP_FLAG_DENY;
             }              }
             el = list_next(el);              el = list_next(el);
Line 101  static int mathcap_cmo_isallow_cmo_list(cmo_list *ob)
Line 180  static int mathcap_cmo_isallow_cmo_list(cmo_list *ob)
     return MATHCAP_FLAG_DENY;      return MATHCAP_FLAG_DENY;
 }  }
   
 static int mathcap_cmo_isallow_cmo_monomial32(cmo_monomial32 *ob)  __inline__
   static int cmodb_isallow_cmo_monomial32(mcdb *cmo_db, cmo_monomial32 *ob)
 {  {
     return mathcap_cmo_isallow_tag(ob->tag)      return cmodb_isallow_tag(cmo_db, ob->tag)
         && mathcap_cmo_isallow_cmo(ob->coef);          && cmodb_isallow_cmo(cmo_db, ob->coef);
 }  }
   
 static int mathcap_cmo_isallow_cmo_mathcap(cmo_mathcap *ob)  __inline__
   static int cmodb_isallow_cmo_mathcap(mcdb *cmo_db, cmo_mathcap *ob)
 {  {
     return mathcap_cmo_isallow_tag(ob->tag)      return cmodb_isallow_tag(cmo_db, ob->tag)
         && mathcap_cmo_isallow_cmo(ob->ob);          && cmodb_isallow_cmo(cmo_db, ob->ob);
 }  }
   
 /* 次の cmo の送信が許可されているかを調べる */  /* 次の cmo の送信が許可されているかを調べる */
 int mathcap_cmo_isallow_cmo(cmo *ob)  static int cmodb_isallow_cmo(mcdb *cmo_db, cmo *ob)
 {  {
     int tag = ob->tag;      int tag = ob->tag;
     switch(tag) {      switch(tag) {
     case CMO_LIST:      case CMO_LIST:
     case CMO_DISTRIBUTED_POLYNOMIAL:      case CMO_DISTRIBUTED_POLYNOMIAL:
         return mathcap_cmo_isallow_cmo_list((cmo_list *)ob);          return cmodb_isallow_cmo_list(cmo_db, (cmo_list *)ob);
     case CMO_MATHCAP:      case CMO_MATHCAP:
     case CMO_ERROR2:      case CMO_ERROR2:
     case CMO_RING_BY_NAME:      case CMO_RING_BY_NAME:
     case CMO_INDETERMINATE:      case CMO_INDETERMINATE:
         return mathcap_cmo_isallow_cmo_mathcap((cmo_mathcap *)ob);          return cmodb_isallow_cmo_mathcap(cmo_db, (cmo_mathcap *)ob);
     case CMO_MONOMIAL32:      case CMO_MONOMIAL32:
         return mathcap_cmo_isallow_cmo_monomial32((cmo_monomial32 *)ob);          return cmodb_isallow_cmo_monomial32(cmo_db, (cmo_monomial32 *)ob);
     default:      default:
         return mathcap_cmo_isallow_tag(tag);          return cmodb_isallow_tag(cmo_db, tag);
     }      }
 }  }
   
 /* 次の tag をもつ cmo の送信を許可する */  /* 次の tag をもつ cmo の送信を許可する */
 void mathcap_cmo_allow(int tag)  __inline__
   static void cmodb_allow(mcdb *cmo_db, int tag)
 {  {
     mc_cell *e = mathcap_cmo_lookup(tag);      mcdb_ctl(cmo_db, tag, MATHCAP_FLAG_ALLOW);
     if (e != NULL) {  
         e->flag = MATHCAP_FLAG_ALLOW;  
     }  
 }  }
   
 /* 次の tag をもつ cmo の送信を不許可にする */  /* 次の tag をもつ cmo の送信を不許可にする */
 void mathcap_cmo_deny(int tag)  __inline__
   static void cmodb_deny(mcdb *cmo_db, int tag)
 {  {
     mc_cell *e = mathcap_cmo_lookup(tag);      mcdb_ctl(cmo_db, tag, MATHCAP_FLAG_DENY);
     if (e != NULL) {  
         e->flag = MATHCAP_FLAG_DENY;  
     }  
 }  }
   
 /* 全ての種類の cmo の送信を不許可にする */  
 void mathcap_cmo_deny_all()  
 {  
     mc_cell *e = mathcap_cmo;  
     while (e->tag != 0) {  
         e->flag = MATHCAP_FLAG_DENY;  
         e++;  
     }  
 }  
   
 /* 全ての種類の cmo の送信を許可する */  
 void mathcap_cmo_allow_all()  
 {  
     mc_cell *e = mathcap_cmo;  
     while (e->tag != 0) {  
         e->flag = MATHCAP_FLAG_ALLOW;  
         e++;  
     }  
 }  
   
 /* 送信許可されている cmo のリストを得る */  
 cmo_list *mathcap_cmo_get_allow_all()  
 {  
     cmo_list *list = new_cmo_list();  
     mc_cell *e = mathcap_cmo;  
     while (e->tag != 0) {  
         if (e->flag != MATHCAP_FLAG_DENY) {  
             list_append(list, new_cmo_int32(e->tag));  
         }  
         e++;  
     }  
     return list;  
 }  
   
 /* 既知の sm コマンドのリストを得る */  
 cmo_list *mathcap_sm_get_all()  
 {  
     cmo_list *list = new_cmo_list();  
     int i;  
     for(i=0; mathcap_sm[i] != 0; i++) {  
         list_append(list, new_cmo_int32(mathcap_sm[i]));  
     }  
     return list;  
 }  
   
 /* システム情報を得る */  /* システム情報を得る */
 cmo_list *mathcap_sysinfo_get_all()  static cmo_list *sysinfo_get_all()
 {  {
     cmo_list *syslist = new_cmo_list();      cmo_list *syslist = new_cmo_list();
     cmo_int32 *ver    = new_cmo_int32(mathcap_sysinfo.version);      cmo_int32 *ver    = new_cmo_int32(sysinfo.version);
     cmo_string *vers  = new_cmo_string(mathcap_sysinfo.version_string);      cmo_string *vers  = new_cmo_string(sysinfo.version_string);
     cmo_string *host  = new_cmo_string(mathcap_sysinfo.hosttype);      cmo_string *host  = new_cmo_string(sysinfo.hosttype);
     cmo_string *sname = new_cmo_string(mathcap_sysinfo.sysname);      cmo_string *sname = new_cmo_string(sysinfo.sysname);
     return list_appendl(syslist, ver, sname, vers, host);      return list_appendl(syslist, ver, sname, vers, host, NULL);
 }  }
   
   __inline__
 static char *new_string(char *s)  static char *new_string(char *s)
 {  {
     char *t = malloc(sizeof(s)+1);      char *t = malloc(sizeof(s)+1);
Line 214  static char *new_string(char *s)
Line 247  static char *new_string(char *s)
     return t;      return t;
 }  }
   
 void mathcap_sysinfo_set(int version, char *version_string, char *sysname)  void sysinfo_set(int version, char *vstr, char *sysname)
 {  {
     char *host = getenv("HOSTTYPE");      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  = version;
   }
   
     mathcap_sysinfo.hosttype = (host != NULL)? new_string(host): "UNKNOWN";  void mathcap_global_init(int ver, char *vstr, char *sysname, int cmos[], int sms[])
     mathcap_sysinfo.sysname  = new_string(sysname);  {
     mathcap_sysinfo.version_string = new_string(version_string);          sysinfo_set(ver, vstr, sysname); /* global! */
     mathcap_sysinfo.version  = version;          if (cmos == NULL) {
                   cmos = cmodb_d;
           }
           if (sms == NULL) {
                   sms = smdb_d;
           }
           /* ... */
 }  }
   
 /* データベースから cmo_mathcap を生成する */  /* データベースから cmo_mathcap を生成する */
 cmo_mathcap* mathcap_get()  cmo_mathcap* mathcap_get(mathcap *this)
 {  {
     cmo_list *mc = new_cmo_list();      cmo_list *mc = new_cmo_list();
     cmo_list *l3 = 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_append(l3, list_appendl(new_cmo_list(),
     list_appendl(mc, (cmo *)mathcap_sysinfo_get_all(), (cmo *)mathcap_sm_get_all(), (cmo *)l3, NULL);                                   new_cmo_int32(OX_DATA),
                                    cmodb_get_allow_all(this), NULL));
       list_appendl(mc, (cmo *)sysinfo_get_all(),
                    (cmo *)smdb_get_allow_all(this), (cmo *)l3, NULL);
     return new_cmo_mathcap((cmo *)mc);      return new_cmo_mathcap((cmo *)mc);
 }  }
   
 static void mathcap_cmo_update(cmo_list* types)  static void cmodb_update(mcdb *cmo_db, cmo_list* types)
 {  {
     cell *el = list_first(types);      cell *el = list_first(types);
     cmo_int32 *ob;      cmo_int32 *ob;
     while(!list_endof(types, el)) {      while(!list_endof(types, el)) {
         ob = (cmo_int32 *)el->cmo;          ob = (cmo_int32 *)el->cmo;
         if (ob->tag == CMO_INT32) {          if (ob->tag == CMO_INT32) {
             mathcap_cmo_allow(ob->i);              cmodb_allow(cmo_db, ob->i);
         }          }
         el = list_next(el);          el = list_next(el);
     }      }
Line 250  static void mathcap_cmo_update(cmo_list* types)
Line 297  static void mathcap_cmo_update(cmo_list* types)
 /* cmo_mathcap が妥当な構造を持つかを調べる.  (未実装) */  /* cmo_mathcap が妥当な構造を持つかを調べる.  (未実装) */
 int cmo_mathcap_isvalid(cmo_mathcap *mc)  int cmo_mathcap_isvalid(cmo_mathcap *mc)
 {  {
           /* print_cmo(mc); */
     return 1;      return 1;
 }  }
   
Line 271  static cmo_list *get_messagetypes(cmo_list *ob, int ty
Line 319  static cmo_list *get_messagetypes(cmo_list *ob, int ty
   
 /* cmo_mathcap->ob = ( (...), (...), ( ( cmo_int32, (...) ), ...), ...) */  /* cmo_mathcap->ob = ( (...), (...), ( ( cmo_int32, (...) ), ...), ...) */
 /*                                              ^^^^^ Here!         */  /*                                              ^^^^^ Here!         */
   __inline__
 static cmo_list *cmo_mathcap_get_cmotypes(cmo_mathcap *mc)  static cmo_list *cmo_mathcap_get_cmotypes(cmo_mathcap *mc)
 {  {
     cmo_list *ob = (cmo_list *)list_nth((cmo_list *)mc->ob, 2);      cmo_list *ob = (cmo_list *)list_nth((cmo_list *)mc->ob, 2);
Line 278  static cmo_list *cmo_mathcap_get_cmotypes(cmo_mathcap 
Line 327  static cmo_list *cmo_mathcap_get_cmotypes(cmo_mathcap 
 }  }
   
 /* 受信した mathcap データを反映させる */  /* 受信した mathcap データを反映させる */
 void mathcap_update(cmo_mathcap *mc)  /* this == NULL のとき、はじめて mathcap* オブジェクトをせいせいする */
   mathcap *mathcap_update(mathcap *this, cmo_mathcap *mc)
 {  {
     cmo_list *types;      cmo_list *types;
     if (cmo_mathcap_isvalid(mc)) {      if (cmo_mathcap_isvalid(mc)) {
         types = cmo_mathcap_get_cmotypes(mc);          types = cmo_mathcap_get_cmotypes(mc);
         if (types != NULL) {          if (types != NULL) {
             mathcap_cmo_deny_all(); /* すべての cmo の送信を禁止 */              cmodb_deny_all(this->cmo_db); /* すべての cmo の送信を禁止 */
             mathcap_cmo_update(types);              cmodb_update(this->cmo_db, types);
         }          }
     }      }
           return this;
 }  }
   
 /* 互換性のため */  
 cmo* make_mathcap_object(int version, char *id_string)  
 {  
     mathcap_sysinfo_set(version, id_string, "ox_math");  
     return (cmo *)mathcap_get();  
 }  
   
Legend:
Removed from v.1.1  
changed lines
  Added in v.1.3
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>