OpenXM/src/kan96xx/Kan/kanExport0.c - diff

Return to kanExport0.c CVS log

Up to [local] / OpenXM / src / kan96xx / Kan

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

-version 1.32, 2004/09/09 11:42:22
+version 1.42, 2005/06/09 05:46:57
 Line 1
 Line 1
 Line 1
- /* $OpenXM: OpenXM/src/kan96xx/Kan/kanExport0.c,v 1.31 2004/09/09 03:14:46 takayama Exp $  */
+ /* $OpenXM: OpenXM/src/kan96xx/Kan/kanExport0.c,v 1.41 2004/11/15 08:27:27 takayama Exp $  */
  #include <stdio.h>
  #include "datatype.h"
  #include "stackm.h"
 Line 687  KooEqualQ(obj1,obj2)
 Line 687  KooEqualQ(obj1,obj2)
 Line 687  KooEqualQ(obj1,obj2)
  {
    struct object ob;
    int i;
+   extern int Verbose;
    if (obj1.tag != obj2.tag) {
      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);
    }
    switch(obj1.tag) {
-Line 1033  struct object KdataConversion(obj,key)
+Line 1041  struct object KdataConversion(obj,key)
 Line 1033  struct object KdataConversion(obj,key)
 Line 1041  struct object KdataConversion(obj,key)
      }else if (strcmp(key,"null") == 0) {
        rob = NullObject;
        return(rob);
+     }else if (strcmp(key,"byteArray") == 0) {
+       rob = newByteArray(getoaSize(obj),obj);
+       return(rob);
      }else {
            { /* Automatically maps the elements. */
                  int n,i;
-Line 1210  struct object KdataConversion(obj,key)
+Line 1221  struct object KdataConversion(obj,key)
 Line 1210  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");
      }
      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:
      warningKan("Sorry. This type of data conversion has not supported yet.\n");
    }
-Line 1503  int KsetUpRing(ob1,ob2,ob3,ob4,ob5)
+Line 1522  int KsetUpRing(ob1,ob2,ob3,ob4,ob5)
 Line 1503  int KsetUpRing(ob1,ob2,ob3,ob4,ob5)
 Line 1522  int KsetUpRing(ob1,ob2,ob3,ob4,ob5)
          ob4 = Order matrix
          ob5 = [(keyword) value (keyword) value ....]
       */
- #define RP_LIMIT 500
+ #define RP_LIMIT 5000
  {
    int i;
    struct object ob;
-Line 1646  int KsetUpRing(ob1,ob2,ob3,ob4,ob5)
+Line 1665  int KsetUpRing(ob1,ob2,ob3,ob4,ob5)
 Line 1646  int KsetUpRing(ob1,ob2,ob3,ob4,ob5)
 Line 1665  int KsetUpRing(ob1,ob2,ob3,ob4,ob5)
    newRingp->degreeShiftSize = 0;
    newRingp->degreeShiftN = 0;
    newRingp->degreeShift = NULL;
+   newRingp->partialEcart = 0;
+   newRingp->partialEcartGlobalVarX = NULL;
    if (ob5.tag != Sarray || (getoaSize(ob5) % 2) != 0) {
      errorKan1("%s\n","[(keyword) value (keyword) value ....] should be given.");
-Line 1726  int KsetUpRing(ob1,ob2,ob3,ob4,ob5)
+Line 1747  int KsetUpRing(ob1,ob2,ob3,ob4,ob5)
 Line 1726  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");
          /* Warning: grading is changed to module1v!! */
        } else {
-Line 2992  struct object Kjoin(struct object ob1, struct object o
+Line 3043  struct object Kjoin(struct object ob1, struct object o
 Line 2992  struct object Kjoin(struct object ob1, struct object o
 Line 3043  struct object Kjoin(struct object ob1, struct object o
    }
  }
+ 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)
-Line 3005  errorKan1(str,message)
+Line 3247  errorKan1(str,message)
 Line 3005  errorKan1(str,message)
 Line 3247  errorKan1(str,message)
    extern char *GotoLabel;
    extern int GotoP;
    extern int ErrorMessageMode;
+   extern int RestrictedMode, RestrictedMode_saved;
    char tmpc[1024];
+   RestrictedMode = RestrictedMode_saved;
    cancelAlarm();
    if (ErrorMessageMode == 1 || ErrorMessageMode == 2) {
      sprintf(tmpc,"\nERROR(kanExport[0|1].c): ");

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>