===================================================================
RCS file: /home/cvs/OpenXM/src/kan96xx/Kan/kanExport0.c,v
retrieving revision 1.29
retrieving revision 1.42
diff -u -p -r1.29 -r1.42
--- OpenXM/src/kan96xx/Kan/kanExport0.c	2004/08/31 05:30:20	1.29
+++ OpenXM/src/kan96xx/Kan/kanExport0.c	2005/06/09 05:46:57	1.42
@@ -1,4 +1,4 @@
-/* $OpenXM: OpenXM/src/kan96xx/Kan/kanExport0.c,v 1.28 2004/08/31 04:45:42 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"
@@ -687,8 +687,16 @@ 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) {
@@ -919,6 +927,10 @@ struct object KdataConversion(obj,key)
       return(rob);
     }else if (strcmp(key,"poly") == 0) {
       rob = KpoPOLY(ZERO);
+      return rob;
+    }else if (strcmp(key,"array") == 0) {
+      rob = newObjectArray(0);
+      return rob;
     }else{
       warningKan("Sorry. The data conversion from null to this data type has not supported yet.\n");
     }
@@ -1015,7 +1027,7 @@ struct object KdataConversion(obj,key)
     if (strcmp(key,"array") == 0) {
       return(rob);
     }else if (strcmp(key,"list") == 0) {
-      rob = *( arrayToList(obj) );
+      rob = KarrayToList(obj);
       return(rob);
     }else if (strcmp(key,"arrayOfPOLY")==0) {
       rob = KpoArrayOfPOLY(arrayToArrayOfPOLY(obj));
@@ -1029,6 +1041,9 @@ 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;
@@ -1108,7 +1123,7 @@ struct object KdataConversion(obj,key)
     break;
   case Slist:
     if (strcmp(key,"array") == 0) {
-      rob = listToArray(&obj);
+      rob = KlistToArray(obj);
       return(rob);
     }
     break;
@@ -1206,6 +1221,14 @@ 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");
   }
@@ -1499,7 +1522,7 @@ 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;
@@ -1642,6 +1665,8 @@ 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.");
@@ -1722,6 +1747,36 @@ 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 {
@@ -2946,11 +3001,243 @@ struct object KdefaultPolyRing(struct object ob) {
 }
   
   
+struct object Krest(struct object ob) {
+  struct object rob;
+  struct object *op;
+  int n,i;
+  if (ob.tag == Sarray) {
+    n = getoaSize(ob);
+    if (n == 0) return ob;
+    rob = newObjectArray(n-1);
+    for (i=1; i<n; i++) {
+      putoa(rob,i-1,getoa(ob,i));
+    }
+    return rob;
+  }else if ((ob.tag == Slist) || (ob.tag == Snull)) {
+    return Kcdr(ob);
+  }else{
+    errorKan1("%s\n","Krest(ob): ob must be an array or a list.");
+  }
+}
+struct object Kjoin(struct object ob1, struct object ob2) {
+  struct object rob;
+  int n1,n2,i;
+  if ((ob1.tag == Sarray) &&  (ob2.tag == Sarray)) {
+    n1 = getoaSize(ob1); n2 = getoaSize(ob2);
+    rob = newObjectArray(n1+n2);
+    for (i=0; i<n1; i++) {
+      putoa(rob,i,getoa(ob1,i));
+    }
+    for (i=n1; i<n1+n2; i++) {
+      putoa(rob,i,getoa(ob2,i-n1));
+    }
+    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{
+    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)
@@ -2960,7 +3247,9 @@ 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): ");
@@ -2972,6 +3261,7 @@ errorKan1(str,message)
   if (ErrorMessageMode != 1) {
     fprintf(stderr,"\nERROR(kanExport[0|1].c): ");
     fprintf(stderr,str,message);
+    (void) traceShowStack(); traceClearStack();
   }
   /* fprintf(stderr,"Hello "); */
   if (GotoP) {