[BACK]Return to kanExport0.c CVS log [TXT][DIR] Up to [local] / OpenXM / src / kan96xx / Kan

Diff for /OpenXM/src/kan96xx/Kan/kanExport0.c between version 1.31 and 1.42

version 1.31, 2004/09/09 03:14:46 version 1.42, 2005/06/09 05:46:57
Line 1 
Line 1 
 /* $OpenXM: OpenXM/src/kan96xx/Kan/kanExport0.c,v 1.30 2004/09/04 11:25:58 takayama Exp $  */  /* $OpenXM: OpenXM/src/kan96xx/Kan/kanExport0.c,v 1.41 2004/11/15 08:27:27 takayama Exp $  */
 #include <stdio.h>  #include <stdio.h>
 #include "datatype.h"  #include "datatype.h"
 #include "stackm.h"  #include "stackm.h"
Line 687  KooEqualQ(obj1,obj2)
Line 687  KooEqualQ(obj1,obj2)
 {  {
   struct object ob;    struct object ob;
   int i;    int i;
     extern int Verbose;
   if (obj1.tag != obj2.tag) {    if (obj1.tag != obj2.tag) {
     warningKan("KooEqualQ(ob1,ob2): the datatypes of ob1 and ob2  are not same. Returns false (0).\n");      warningKan("KooEqualQ(ob1,ob2): the datatypes of ob1 and ob2  are not same. Returns false (0).\n");
           if (Verbose & 0x10) {
             fprintf(stderr,"obj1(tag:%d)=",obj1.tag);
             printObject(obj1,0,stderr);
             fprintf(stderr,", obj2(tag:%d)=",obj2.tag);
             printObject(obj2,0,stderr);
             fprintf(stderr,"\n"); fflush(stderr);
           }
     return(0);      return(0);
   }    }
   switch(obj1.tag) {    switch(obj1.tag) {
Line 919  struct object KdataConversion(obj,key)
Line 927  struct object KdataConversion(obj,key)
       return(rob);        return(rob);
     }else if (strcmp(key,"poly") == 0) {      }else if (strcmp(key,"poly") == 0) {
       rob = KpoPOLY(ZERO);        rob = KpoPOLY(ZERO);
         return rob;
       }else if (strcmp(key,"array") == 0) {
         rob = newObjectArray(0);
         return rob;
     }else{      }else{
       warningKan("Sorry. The data conversion from null to this data type has not supported yet.\n");        warningKan("Sorry. The data conversion from null to this data type has not supported yet.\n");
     }      }
Line 1015  struct object KdataConversion(obj,key)
Line 1027  struct object KdataConversion(obj,key)
     if (strcmp(key,"array") == 0) {      if (strcmp(key,"array") == 0) {
       return(rob);        return(rob);
     }else if (strcmp(key,"list") == 0) {      }else if (strcmp(key,"list") == 0) {
       rob = *( arrayToList(obj) );        rob = KarrayToList(obj);
       return(rob);        return(rob);
     }else if (strcmp(key,"arrayOfPOLY")==0) {      }else if (strcmp(key,"arrayOfPOLY")==0) {
       rob = KpoArrayOfPOLY(arrayToArrayOfPOLY(obj));        rob = KpoArrayOfPOLY(arrayToArrayOfPOLY(obj));
Line 1029  struct object KdataConversion(obj,key)
Line 1041  struct object KdataConversion(obj,key)
     }else if (strcmp(key,"null") == 0) {      }else if (strcmp(key,"null") == 0) {
       rob = NullObject;        rob = NullObject;
       return(rob);        return(rob);
       }else if (strcmp(key,"byteArray") == 0) {
         rob = newByteArray(getoaSize(obj),obj);
         return(rob);
     }else {      }else {
           { /* Automatically maps the elements. */            { /* Automatically maps the elements. */
                 int n,i;                  int n,i;
Line 1108  struct object KdataConversion(obj,key)
Line 1123  struct object KdataConversion(obj,key)
     break;      break;
   case Slist:    case Slist:
     if (strcmp(key,"array") == 0) {      if (strcmp(key,"array") == 0) {
       rob = listToArray(&obj);        rob = KlistToArray(obj);
       return(rob);        return(rob);
     }      }
     break;      break;
Line 1206  struct object KdataConversion(obj,key)
Line 1221  struct object KdataConversion(obj,key)
       warningKan("Sorryl This type of data conversion of ringp has not supported yet.\n");        warningKan("Sorryl This type of data conversion of ringp has not supported yet.\n");
     }      }
     break;      break;
     case SbyteArray:
       if (strcmp(key,"array") == 0) {
         rob = byteArrayToArray(obj);
         return(rob);
       } else {
         warningKan("Sorryl This type of data conversion of ringp has not supported yet.\n");
       }
       break;
   default:    default:
     warningKan("Sorry. This type of data conversion has not supported yet.\n");      warningKan("Sorry. This type of data conversion has not supported yet.\n");
   }    }
Line 1499  int KsetUpRing(ob1,ob2,ob3,ob4,ob5)
Line 1522  int KsetUpRing(ob1,ob2,ob3,ob4,ob5)
         ob4 = Order matrix          ob4 = Order matrix
         ob5 = [(keyword) value (keyword) value ....]          ob5 = [(keyword) value (keyword) value ....]
      */       */
 #define RP_LIMIT 500  #define RP_LIMIT 5000
 {  {
   int i;    int i;
   struct object ob;    struct object ob;
Line 1642  int KsetUpRing(ob1,ob2,ob3,ob4,ob5)
Line 1665  int KsetUpRing(ob1,ob2,ob3,ob4,ob5)
   newRingp->degreeShiftSize = 0;    newRingp->degreeShiftSize = 0;
   newRingp->degreeShiftN = 0;    newRingp->degreeShiftN = 0;
   newRingp->degreeShift = NULL;    newRingp->degreeShift = NULL;
     newRingp->partialEcart = 0;
     newRingp->partialEcartGlobalVarX = NULL;
   
   if (ob5.tag != Sarray || (getoaSize(ob5) % 2) != 0) {    if (ob5.tag != Sarray || (getoaSize(ob5) % 2) != 0) {
     errorKan1("%s\n","[(keyword) value (keyword) value ....] should be given.");      errorKan1("%s\n","[(keyword) value (keyword) value ....] should be given.");
Line 1722  int KsetUpRing(ob1,ob2,ob3,ob4,ob5)
Line 1747  int KsetUpRing(ob1,ob2,ob3,ob4,ob5)
             }              }
           }            }
         }          }
         } else if (strcmp(KopString(getoa(ob5,i)),"partialEcartGlobalVarX") == 0) {
           if (getoa(ob5,i+1).tag != Sarray) {
             errorKan1("%s\n","An array of array should be given. (partialEcart)");
           }
           {
             struct object odv;
             struct object ovv;
             int k,j,nn;
             char *vname;
             odv=getoa(ob5,i+1);
             nn = getoaSize(odv);
             newRingp->partialEcart = nn;
             newRingp->partialEcartGlobalVarX = (int *) sGC_malloc(sizeof(int)*nn+1);
             if (newRingp->partialEcartGlobalVarX == NULL) errorKan1("%s\n","No more memory.");
             for (j=0; j<nn; j++)
               (newRingp->partialEcartGlobalVarX)[j] = -1;
             for (j=0; j<nn; j++) {
               ovv = getoa(odv,j);
               if (ovv.tag != Sdollar) errorKan1("%s\n","partialEcartGlobalVarX: string is expected.");
               vname = KopString(ovv);
               for (k=0; k<n; k++) {
                 if (strcmp(vname,xvars[k]) == 0) {
                   (newRingp->partialEcartGlobalVarX)[j] = k; break;
                 }else{
                   if (k == n-1) errorKan1("%s\n","partialEcartGlobalVarX: no such variable.");
                 }
               }
             }
           }
   
         switch_function("grade","module1v");          switch_function("grade","module1v");
         /* Warning: grading is changed to module1v!! */          /* Warning: grading is changed to module1v!! */
       } else {        } else {
Line 2958  struct object Krest(struct object ob) {
Line 3013  struct object Krest(struct object ob) {
       putoa(rob,i-1,getoa(ob,i));        putoa(rob,i-1,getoa(ob,i));
     }      }
     return rob;      return rob;
   }else if (ob.tag == Slist) {    }else if ((ob.tag == Slist) || (ob.tag == Snull)) {
     errorKan1("%s\n","Krest: it has not yet been implemented.");      return Kcdr(ob);
   }else{    }else{
     errorKan1("%s\n","Krest(ob): ob must be an array or a list.");      errorKan1("%s\n","Krest(ob): ob must be an array or a list.");
   }    }
Line 2977  struct object Kjoin(struct object ob1, struct object o
Line 3032  struct object Kjoin(struct object ob1, struct object o
       putoa(rob,i,getoa(ob2,i-n1));        putoa(rob,i,getoa(ob2,i-n1));
     }      }
     return rob;      return rob;
     }else if ((ob1.tag == Slist) || (ob1.tag == Snull)) {
           if ((ob2.tag == Slist) || (ob2.tag == Snull)) {
             return KvJoin(ob1,ob2);
           }else{
             errorKan1("%s\n","Kjoin: both argument must be a list.");
           }
   }else{    }else{
     errorKan1("%s\n","Kjoin: arguments must be arrays.");      errorKan1("%s\n","Kjoin: arguments must be arrays.");
   }    }
 }  }
   
   struct object Kget(struct object ob1, struct object ob2) {
     struct object rob;
     struct object tob;
     int i,j,size,n;
     if (ob2.tag == Sinteger) {
       i =ob2.lc.ival;
     }else if (ob2.tag == SuniversalNumber) {
       i = KopInteger(KdataConversion(ob2,"integer"));
     }else if (ob2.tag == Sarray) {
       n = getoaSize(ob2);
       if (n == 0) return ob1;
       rob = ob1;
       for (i=0; i<n; i++) {
         rob=Kget(rob,getoa(ob2,i));
       }
       return rob;
     }
     if (ob1.tag == Sarray) {
       size = getoaSize(ob1);
       if ((0 <= i) && (i<size)) {
         return(getoa(ob1,i));
       }else{
         errorKan1("%s\n","Kget: Index is out of bound. (get)\n");
       }
     }else if (ob1.tag == Slist) {
       rob = NullObject;
       if (i < 0) errorKan1("%s\n","Kget: Index is negative. (get)");
       for (j=0; j<i; j++) {
         rob = Kcdr(ob1);
         if ((ob1.tag == Snull) && (rob.tag == Snull)) {
           errorKan1("%s\n","Kget: Index is out of bound. (get) cdr of null list.\n");
         }
         ob1 = rob;
       }
       return Kcar(ob1);
     } else if (ob1.tag == SbyteArray) {
       size = getByteArraySize(ob1);
       if ((0 <= i) && (i<size)) {
         return(KpoInteger(KopByteArray(ob1)[i]));
       }else{
         errorKan1("%s\n","Kget: Index is out of bound. (get)\n");
       }
     } else if (ob1.tag == Sdollar) {
       unsigned char *sss;
       sss = (unsigned char *) KopString(ob1);
       size = strlen(sss);
       if ((0 <= i) && (i<size)) {
         return(KpoInteger(sss[i]));
       }else{
         errorKan1("%s\n","Kget: Index is out of bound. (get)\n");
       }
   
     }else errorKan1("%s\n","Kget: argument must be an array or a list.");
   }
   
   /* Constructor of byteArray */
   struct object newByteArray(int size,struct object obj) {
     unsigned char *ba;
     unsigned char *ba2;
     struct object rob,tob;
     int i,n;
     ba = NULL;
     if (size > 0) {
       ba = (unsigned char *) sGC_malloc(size);
       if (ba == NULL) errorKan1("%s\n","No more memory.");
     }
     rob.tag = SbyteArray; rob.lc.bytes = ba; rob.rc.ival = size;
     if (obj.tag == SbyteArray) {
       n = getByteArraySize(obj);
       ba2 = KopByteArray(obj);
       for (i=0; i<(n<size?n:size); i++) {
         ba[i] = ba2[i];
       }
       for (i=n; i<size; i++) ba[i] = 0;
       return rob;
     }else if (obj.tag == Sarray) {
       n = getoaSize(obj);
       for (i=0; i<n; i++) {
         tob = getoa(obj,i);
         tob = Kto_int32(tob);
         if (tob.tag != Sinteger) errorKan1("%s\n","newByteArray: array is not an array of integer or universalNumber.");
         ba[i] = (unsigned char) KopInteger(tob);
       }
       for (i=n; i<size; i++) ba[i] = 0;
       return rob;
     }else{
       for (i=0; i<size; i++) ba[i] = 0;
       return rob;
     }
   }
   struct object newByteArrayFromStr(char *s,int size) {
     unsigned char *ba;
     struct object rob;
     int i;
     ba = NULL;
     if (size > 0) {
       ba = (unsigned char *) sGC_malloc(size);
       if (ba == NULL) errorKan1("%s\n","No more memory.");
     }
     rob.tag = SbyteArray; rob.lc.bytes = ba; rob.rc.ival = size;
     for (i=0; i<size; i++) {
           ba[i] = (char) s[i];
     }
     return(rob);
   }
   
   struct object byteArrayToArray(struct object obj) {
     int n,i; unsigned char *ba;
     struct object rob;
     if (obj.tag != SbyteArray) errorKan1("%s\n","byteArrayToArray: argument is not an byteArray.");
     n = getByteArraySize(obj);
     rob = newObjectArray(n);
     ba = KopByteArray(obj);
     for (i=0; i<n; i++) putoa(rob,i,KpoInteger((int) ba[i]));
     return rob;
   }
   
   struct object KgetAttributeList(struct object ob){
     struct object rob;
     if (ob.attr != NULL) rob = *(ob.attr);
     else rob = NullObject;
     return rob;
   }
   struct object  KputAttributeList(struct object ob,struct object attr) {
     ob.attr = newObject();
     *(ob.attr) = attr;
     return ob;
   }
   struct object KgetAttribute(struct object ob,struct object key) {
     struct object rob;
     struct object alist;
     int n,i;
     struct object tob;
     char *s;
     rob = NullObject;
     if (ob.attr == NULL) return rob;
     alist = *(ob.attr);
     if (alist.tag != Sarray) return rob;
     if (key.tag != Sdollar) return rob;
     s = KopString(key);
     n = getoaSize(alist);
     for (i = 0; i < n; i += 2) {
       tob = getoa(alist,i);
       if (tob.tag == Sdollar) {
         if (strcmp(KopString(tob),s) == 0) {
           if (i+1 < n) rob = getoa(alist,i+1);
           return rob;
         }
       }
     }
     return rob;
   }
   /*  ob (key) (value) putAttribute /ob set. They are not destructive. */
   struct object KputAttribute(struct object ob,struct object key,struct object value) {
     struct object rob;
     struct object alist;
     int n,i;
     char *s = "";
     struct object tob;
     rob = ob;
     if (ob.attr == NULL) {
       rob.attr = newObject();
       *(rob.attr) = newObjectArray(2);
       putoa((*(rob.attr)),0,key);
       putoa((*(rob.attr)),1,value);
       return rob;
     }
     alist = *(ob.attr);
     if (alist.tag != Sarray) return rob;
     if (key.tag != Sdollar) {
       s = KopString(key);
     }
     n = getoaSize(alist);
     for (i = 0; i < n; i += 2) {
       tob = getoa(alist,i);
       if (tob.tag == Sdollar) {
         if (strcmp(KopString(tob),s) == 0) {
           if (i+1 < n) putoa(alist,i+1,value);
           return rob;
         }
       }
     }
   
     rob.attr = newObject();
     *(rob.attr) = newObjectArray(n+2);
     for (i=0; i<n; i++) {
       putoa((*(rob.attr)),i,getoa((*(ob.attr)),i));
     }
     putoa((*(rob.attr)),n,key);
     putoa((*(rob.attr)),n+1,value);
     return rob;
   }
   
 /******************************************************************  /******************************************************************
      error handler       Error handler
 ******************************************************************/  ******************************************************************/
   
 errorKan1(str,message)  errorKan1(str,message)
Line 2995  errorKan1(str,message)
Line 3247  errorKan1(str,message)
   extern char *GotoLabel;    extern char *GotoLabel;
   extern int GotoP;    extern int GotoP;
   extern int ErrorMessageMode;    extern int ErrorMessageMode;
     extern int RestrictedMode, RestrictedMode_saved;
   char tmpc[1024];    char tmpc[1024];
     RestrictedMode = RestrictedMode_saved;
   cancelAlarm();    cancelAlarm();
   if (ErrorMessageMode == 1 || ErrorMessageMode == 2) {    if (ErrorMessageMode == 1 || ErrorMessageMode == 2) {
     sprintf(tmpc,"\nERROR(kanExport[0|1].c): ");      sprintf(tmpc,"\nERROR(kanExport[0|1].c): ");
Legend:
Removed from v.1.31  
changed lines
  Added in v.1.42
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>