===================================================================
RCS file: /home/cvs/OpenXM/src/kan96xx/Kan/kanExport0.c,v
retrieving revision 1.1.1.1
retrieving revision 1.39
diff -u -p -r1.1.1.1 -r1.39
--- OpenXM/src/kan96xx/Kan/kanExport0.c	1999/10/08 02:12:01	1.1.1.1
+++ OpenXM/src/kan96xx/Kan/kanExport0.c	2004/09/20 02:26:56	1.39
@@ -1,3 +1,4 @@
+/* $OpenXM: OpenXM/src/kan96xx/Kan/kanExport0.c,v 1.38 2004/09/20 02:11:22 takayama Exp $  */
 #include <stdio.h>
 #include "datatype.h"
 #include "stackm.h"
@@ -18,10 +19,11 @@ int SerialCurrent = -1;  /* Current Serial number of t
 
 int ReverseOutputOrder = 1;  
 int WarningNoVectorVariable = 1;
+extern int QuoteMode;
 
 /** :arithmetic **/
 struct object KooAdd(ob1,ob2)
-struct object ob1,ob2;
+     struct object ob1,ob2;
 {
   extern struct ring *CurrentRingp;
   struct object rob = NullObject;
@@ -141,14 +143,18 @@ struct object ob1,ob2;
     
 
   default:
-    warningKan("KooAdd() has not supported yet these objects.\n");
+    if (QuoteMode) {
+      rob = addTree(ob1,ob2);
+    }else{
+      warningKan("KooAdd() has not supported yet these objects.\n");
+    }
     break;
   }
   return(rob);
 }
 
 struct object KooSub(ob1,ob2)
-struct object ob1,ob2;
+     struct object ob1,ob2;
 {
   struct object rob = NullObject;
   POLY r;
@@ -269,14 +275,18 @@ struct object ob1,ob2;
     break;
 
   default:
-    warningKan("KooSub() has not supported yet these objects.\n");
+    if (QuoteMode) {
+      rob = minusTree(ob1,ob2);
+    }else{
+      warningKan("KooSub() has not supported yet these objects.\n");
+    }
     break;
   }
   return(rob);
 }
 
 struct object KooMult(ob1,ob2)
-struct object ob1,ob2;
+     struct object ob1,ob2;
 {
   struct object rob = NullObject;
   POLY r;
@@ -411,7 +421,11 @@ struct object ob1,ob2;
     break;
 
   default:
-    warningKan("KooMult() has not supported yet these objects.\n");
+    if (QuoteMode) {
+      rob = timesTree(ob1,ob2);
+    }else{
+      warningKan("KooMult() has not supported yet these objects.\n");
+    }
     break;
   }
   return(rob);
@@ -420,7 +434,7 @@ struct object ob1,ob2;
 
 
 struct object KoNegate(obj)
-struct object obj;
+     struct object obj;
 {
   struct object rob = NullObject;
   extern struct ring SmallRing;
@@ -450,14 +464,18 @@ struct object obj;
     break;
 
   default:
-    warningKan("KoNegate() has not supported yet these objects.\n");
+    if (QuoteMode) {
+      rob = unaryminusTree(obj);
+    }else{
+      warningKan("KoNegate() has not supported yet these objects.\n");
+    }
     break;
   }
   return(rob);
 }
     
 struct object KoInverse(obj)
-struct object obj;
+     struct object obj;
 {
   struct object rob = NullObject;
   extern struct coeff *UniversalOne;
@@ -493,7 +511,7 @@ struct object obj;
     
 
 static int isVector(ob)
-struct object ob;
+     struct object ob;
 {
   int i,n;
   n = getoaSize(ob);
@@ -504,8 +522,8 @@ struct object ob;
 }
 
 static int isMatrix(ob,m,n)
-struct object ob;
-int m,n;
+     struct object ob;
+     int m,n;
 {
   int i,j;
   for (i=0; i<m; i++) {
@@ -520,8 +538,8 @@ int m,n;
 
 
 struct object KaoMult(aa,bb)
-struct object aa,bb;
-/* aa and bb is assumed to be array. */
+     struct object aa,bb;
+     /* aa and bb is assumed to be array. */
 {
   int m,n,m2,n2; 
   int i,j,k;
@@ -548,12 +566,12 @@ struct object aa,bb;
     if (r1 != 0) {
       ob1 = getoa(aa,0);
       if (ob1.tag == Spoly) {
-	rob.tag = Spoly; rob.lc.poly = ZERO;
+        rob.tag = Spoly; rob.lc.poly = ZERO;
       }else if (ob1.tag == Sinteger) {
-	rob.tag = Sinteger; rob.lc.ival = 0;
+        rob.tag = Sinteger; rob.lc.ival = 0;
       }else {
-	rob.tag = SuniversalNumber;
-	rob.lc.universalNumber = intToCoeff(0,&SmallRing);
+        rob.tag = SuniversalNumber;
+        rob.lc.universalNumber = intToCoeff(0,&SmallRing);
       }
     }else{
       rob.tag = Spoly; rob.lc.poly = ZERO;
@@ -563,7 +581,7 @@ struct object aa,bb;
     }
     return(rob);
   } else if (r1 == 0 && r2 ) { /* matrix X vector ---> vector */
-                               /* (m n) (m2=n) */
+    /* (m n) (m2=n) */
     n = getoaSize(getoa(aa,0));
     if (isMatrix(aa,m,n) == 0) {
       errorKan1("%s\n","KaoMult(matrix,vector). The left object is not matrix.");
@@ -599,15 +617,15 @@ struct object aa,bb;
     }
     for (i=0; i<m; i++) {
       for (j=0; j<n2; j++) {
-	ofik = getoa(getoa(aa,i),0);
-	ogkj = getoa(getoa(bb,0),j);
-	otmp = KooMult( ofik, ogkj);
-	for (k=1; k<n; k++) {
-	  ofik = getoa(getoa(aa,i),k);
-	  ogkj = getoa(getoa(bb,k),j);
-	  otmp = KooAdd(otmp, KooMult( ofik, ogkj));
-	}
-	getoa(getoa(rob,i),j) = otmp;
+        ofik = getoa(getoa(aa,i),0);
+        ogkj = getoa(getoa(bb,0),j);
+        otmp = KooMult( ofik, ogkj);
+        for (k=1; k<n; k++) {
+          ofik = getoa(getoa(aa,i),k);
+          ogkj = getoa(getoa(bb,k),j);
+          otmp = KooAdd(otmp, KooMult( ofik, ogkj));
+        }
+        getoa(getoa(rob,i),j) = otmp;
       }
     }
     return(rob);
@@ -624,9 +642,9 @@ struct object aa,bb;
     for (j=0; j<n2; j++) {
       tmp = ZERO;
       for (k=0; k<n; k++) {
-	fik = KopPOLY(getoa(getoa(aa,i),k));
-	gkj = KopPOLY(getoa(getoa(bb,k),j));
-	tmp = ppAdd(tmp, ppMult( fik, gkj));
+        fik = KopPOLY(getoa(getoa(aa,i),k));
+        gkj = KopPOLY(getoa(getoa(bb,k),j));
+        tmp = ppAdd(tmp, ppMult( fik, gkj));
       }
       getoa(getoa(rob,i),j) = KpoPOLY(tmp);
     }
@@ -635,7 +653,7 @@ struct object aa,bb;
 }
 
 struct object KooDiv(ob1,ob2)
-struct object ob1,ob2;
+     struct object ob1,ob2;
 {
   struct object rob = NullObject;
   switch (Lookup[ob1.tag][ob2.tag]) {
@@ -646,13 +664,17 @@ struct object ob1,ob2;
     rob.tag = SuniversalNumber;
     rob.lc.universalNumber = newUniversalNumber(0);
     universalNumberDiv(rob.lc.universalNumber,ob1.lc.universalNumber,
-		       ob2.lc.universalNumber);
+                       ob2.lc.universalNumber);
     return(rob);
     break;
 
 
   default:
-    warningKan("KooDiv() has not supported yet these objects.\n");
+    if (QuoteMode) {
+      rob = divideTree(ob1,ob2);
+    }else{
+      warningKan("KooDiv() has not supported yet these objects.\n");
+    }
     break;
   }
   return(rob);
@@ -660,73 +682,81 @@ struct object ob1,ob2;
 
 /* :relation */
 KooEqualQ(obj1,obj2)
-struct object obj1;
-struct object obj2;
+     struct object obj1;
+     struct object 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) {
-    case 0:
-      return(1); /* case of NullObject */
-      break;
-    case Sinteger:
-      if (obj1.lc.ival == obj2.lc.ival) return(1);
-      else return(0);
-      break;
-    case Sstring:
-    case Sdollar:
-      if (strcmp(obj1.lc.str, obj2.lc.str)==0) return(1);
-      else return(0);
-      break;
-    case Spoly:
-      ob = KooSub(obj1,obj2);
-      if (KopPOLY(ob) == ZERO) return(1);
-      else return(0);
-    case Sarray:
-      if (getoaSize(obj1) != getoaSize(obj2)) return(0);
-      for (i=0; i< getoaSize(obj1); i++) {
-	if (KooEqualQ(getoa(obj1,i),getoa(obj2,i))) { ; }
-	else { return(0); }
-      }
-      return(1);
-    case Slist:
-      if (KooEqualQ(*(obj1.lc.op),*(obj2.lc.op))) {
-	if (isNullList(obj1.rc.op)) {
-	  if (isNullList(obj2.rc.op)) return(1);
-	  else return(0);
-	}else{
-	  if (isNullList(obj2.rc.op)) return(0);
-	  return(KooEqualQ(*(obj1.rc.op),*(obj2.rc.op)));
-	}
+  case 0:
+    return(1); /* case of NullObject */
+    break;
+  case Sinteger:
+    if (obj1.lc.ival == obj2.lc.ival) return(1);
+    else return(0);
+    break;
+  case Sstring:
+  case Sdollar:
+    if (strcmp(obj1.lc.str, obj2.lc.str)==0) return(1);
+    else return(0);
+    break;
+  case Spoly:
+    ob = KooSub(obj1,obj2);
+    if (KopPOLY(ob) == ZERO) return(1);
+    else return(0);
+  case Sarray:
+    if (getoaSize(obj1) != getoaSize(obj2)) return(0);
+    for (i=0; i< getoaSize(obj1); i++) {
+      if (KooEqualQ(getoa(obj1,i),getoa(obj2,i))) { ; }
+      else { return(0); }
+    }
+    return(1);
+  case Slist:
+    if (KooEqualQ(*(obj1.lc.op),*(obj2.lc.op))) {
+      if (isNullList(obj1.rc.op)) {
+        if (isNullList(obj2.rc.op)) return(1);
+        else return(0);
       }else{
-	return(0);
+        if (isNullList(obj2.rc.op)) return(0);
+        return(KooEqualQ(*(obj1.rc.op),*(obj2.rc.op)));
       }
-      break;
-    case SuniversalNumber:
-      return(coeffEqual(obj1.lc.universalNumber,obj2.lc.universalNumber));
-      break;
-    case Sring:
-      return(KopRingp(obj1) == KopRingp(obj2));
-      break;
-    case Sclass:
-      return(KclassEqualQ(obj1,obj2));
-      break;
-    case Sdouble:
-      return(KopDouble(obj1) == KopDouble(obj2));
-      break;
-    default:
-      errorKan1("%s\n","KooEqualQ() has not supported these objects yet.");
-      break;
+    }else{
+      return(0);
     }
+    break;
+  case SuniversalNumber:
+    return(coeffEqual(obj1.lc.universalNumber,obj2.lc.universalNumber));
+    break;
+  case Sring:
+    return(KopRingp(obj1) == KopRingp(obj2));
+    break;
+  case Sclass:
+    return(KclassEqualQ(obj1,obj2));
+    break;
+  case Sdouble:
+    return(KopDouble(obj1) == KopDouble(obj2));
+    break;
+  default:
+    errorKan1("%s\n","KooEqualQ() has not supported these objects yet.");
+    break;
+  }
 }
       
 
 struct object KoIsPositive(ob1)
-struct object ob1;
+     struct object ob1;
 {
   struct object rob = NullObject;
   switch (ob1.tag) {
@@ -741,8 +771,8 @@ struct object ob1;
 }
 
 struct object KooGreater(obj1,obj2)
-struct object obj1;
-struct object obj2;
+     struct object obj1;
+     struct object obj2;
 {
   struct object ob;
   int tt;
@@ -750,40 +780,55 @@ struct object obj2;
     errorKan1("%s\n","You cannot compare different kinds of objects.");
   }
   switch(obj1.tag) {
-    case 0:
-      return(KpoInteger(1)); /* case of NullObject */
-      break;
-    case Sinteger:
-      if (obj1.lc.ival > obj2.lc.ival) return(KpoInteger(1));
-      else return(KpoInteger(0));
-      break;
-    case Sstring:
-    case Sdollar:
-      if (strcmp(obj1.lc.str, obj2.lc.str)>0) return(KpoInteger(1));
-      else return(KpoInteger(0));
-      break;
-    case Spoly:
-      if ((*mmLarger)(obj1.lc.poly,obj2.lc.poly) == 1) return(KpoInteger(1));
-      else return(KpoInteger(0));
-      break;
-    case SuniversalNumber:
-      tt = coeffGreater(obj1.lc.universalNumber,obj2.lc.universalNumber);
-      if (tt > 0) return(KpoInteger(1));
-      else return(KpoInteger(0));
-      break;
-    case Sdouble:
-      if ( KopDouble(obj1) > KopDouble(obj2) ) return(KpoInteger(1));
-      else return(KpoInteger(0));
-      break;
-    default:
-      errorKan1("%s\n","KooGreater() has not supported these objects yet.");
-      break;
+  case 0:
+    return(KpoInteger(1)); /* case of NullObject */
+    break;
+  case Sinteger:
+    if (obj1.lc.ival > obj2.lc.ival) return(KpoInteger(1));
+    else return(KpoInteger(0));
+    break;
+  case Sstring:
+  case Sdollar:
+    if (strcmp(obj1.lc.str, obj2.lc.str)>0) return(KpoInteger(1));
+    else return(KpoInteger(0));
+    break;
+  case Spoly:
+    if ((*mmLarger)(obj1.lc.poly,obj2.lc.poly) == 1) return(KpoInteger(1));
+    else return(KpoInteger(0));
+    break;
+  case SuniversalNumber:
+    tt = coeffGreater(obj1.lc.universalNumber,obj2.lc.universalNumber);
+    if (tt > 0) return(KpoInteger(1));
+    else return(KpoInteger(0));
+    break;
+  case Sdouble:
+    if ( KopDouble(obj1) > KopDouble(obj2) ) return(KpoInteger(1));
+    else return(KpoInteger(0));
+    break;
+  case Sarray:
+  {
+    int i,m1,m2;
+    struct object rr;
+    m1 = getoaSize(obj1); m2 = getoaSize(obj2);
+    for (i=0; i< (m1>m2?m2:m1); i++) {
+      rr=KooGreater(getoa(obj1,i),getoa(obj2,i));
+      if (KopInteger(rr) == 1) return rr;
+      rr=KooGreater(getoa(obj2,i),getoa(obj1,i));
+      if (KopInteger(rr) == 1) return KpoInteger(0);
     }
+    if (m1 > m2) return KpoInteger(1);
+    else return KpoInteger(0);
+  }
+  break;
+  default:
+    errorKan1("%s\n","KooGreater() has not supported these objects yet.");
+    break;
+  }
 }
       
 struct object KooLess(obj1,obj2)
-struct object obj1;
-struct object obj2;
+     struct object obj1;
+     struct object obj2;
 {
   struct object ob;
   int tt;
@@ -791,42 +836,57 @@ struct object obj2;
     errorKan1("%s\n","You cannot compare different kinds of objects.");
   }
   switch(obj1.tag) {
-    case 0:
-      return(KpoInteger(1)); /* case of NullObject */
-      break;
-    case Sinteger:
-      if (obj1.lc.ival < obj2.lc.ival) return(KpoInteger(1));
-      else return(KpoInteger(0));
-      break;
-    case Sstring:
-    case Sdollar:
-      if (strcmp(obj1.lc.str, obj2.lc.str)<0) return(KpoInteger(1));
-      else return(KpoInteger(0));
-      break;
-    case Spoly:
-      if ((*mmLarger)(obj2.lc.poly,obj1.lc.poly) == 1) return(KpoInteger(1));
-      else return(KpoInteger(0));
-      break;
-    case SuniversalNumber:
-      tt = coeffGreater(obj1.lc.universalNumber,obj2.lc.universalNumber);
-      if (tt < 0) return(KpoInteger(1));
-      else return(KpoInteger(0));
-      break;
-    case Sdouble:
-      if ( KopDouble(obj1) < KopDouble(obj2) ) return(KpoInteger(1));
-      else return(KpoInteger(0));
-      break;
-    default:
-      errorKan1("%s\n","KooLess() has not supported these objects yet.");
-      break;
+  case 0:
+    return(KpoInteger(1)); /* case of NullObject */
+    break;
+  case Sinteger:
+    if (obj1.lc.ival < obj2.lc.ival) return(KpoInteger(1));
+    else return(KpoInteger(0));
+    break;
+  case Sstring:
+  case Sdollar:
+    if (strcmp(obj1.lc.str, obj2.lc.str)<0) return(KpoInteger(1));
+    else return(KpoInteger(0));
+    break;
+  case Spoly:
+    if ((*mmLarger)(obj2.lc.poly,obj1.lc.poly) == 1) return(KpoInteger(1));
+    else return(KpoInteger(0));
+    break;
+  case SuniversalNumber:
+    tt = coeffGreater(obj1.lc.universalNumber,obj2.lc.universalNumber);
+    if (tt < 0) return(KpoInteger(1));
+    else return(KpoInteger(0));
+    break;
+  case Sdouble:
+    if ( KopDouble(obj1) < KopDouble(obj2) ) return(KpoInteger(1));
+    else return(KpoInteger(0));
+    break;
+  case Sarray:
+  {
+    int i,m1,m2;
+    struct object rr;
+    m1 = getoaSize(obj1); m2 = getoaSize(obj2);
+    for (i=0; i< (m1>m2?m2:m1); i++) {
+      rr=KooLess(getoa(obj1,i),getoa(obj2,i));
+      if (KopInteger(rr) == 1) return rr;
+      rr=KooLess(getoa(obj2,i),getoa(obj1,i));
+      if (KopInteger(rr) == 1) return KpoInteger(0);
     }
+    if (m1 < m2) return KpoInteger(1);
+    else return KpoInteger(0);
+  }
+  break;
+  default:
+    errorKan1("%s\n","KooLess() has not supported these objects yet.");
+    break;
+  }
 }
       
 /* :conversion */
 
 struct object KdataConversion(obj,key)
-struct object obj;
-char *key;
+     struct object obj;
+     char *key;
 {
   char tmps[128]; /* Assume that double is not more than 128 digits */
   char intstr[100]; /* Assume that int is not more than 100 digits */
@@ -837,6 +897,8 @@ char *key;
   struct object rob1,rob2;
   char *s;
   int i;
+  double f;
+  double f2;
   /* reports the data type */
   if (key[0] == 't' || key[0] =='e') {
     if (strcmp(key,"type?")==0) {
@@ -844,9 +906,9 @@ char *key;
       return(rob);
     }else if (strcmp(key,"type??")==0) {
       if (obj.tag != Sclass) {
-	rob = KpoInteger(obj.tag);
+        rob = KpoInteger(obj.tag);
       }else {
-	rob = KpoInteger(ectag(obj));
+        rob = KpoInteger(ectag(obj));
       }
       return(rob);
     }else if (strcmp(key,"error")==0) {
@@ -865,6 +927,10 @@ char *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");
     }
@@ -890,8 +956,7 @@ char *key;
       strcpy(rob.lc.str,intstr);
       return(rob);
     }else if (strcmp(key,"universalNumber")==0) {
-      rob.tag = SuniversalNumber;
-      rob.lc.universalNumber = intToCoeff(obj.lc.ival,&SmallRing);
+      rob = KintToUniversalNumber(obj.lc.ival);
       return(rob);
     }else if (strcmp(key,"double") == 0) {
       rob = KpoDouble((double) (obj.lc.ival));
@@ -911,7 +976,7 @@ char *key;
       rob.tag = Sstring;
       s = (char *) sGC_malloc(sizeof(char)*(strlen(obj.lc.str)+3));
       if (s == (char *) NULL)   {
-	errorKan1("%s\n","No memory.");
+        errorKan1("%s\n","No memory.");
       }
       s[0] = '/';
       strcpy(&(s[1]),obj.lc.str);
@@ -927,15 +992,30 @@ char *key;
     }else if (strcmp(key,"array")==0) {
       rob = newObjectArray(strlen(obj.lc.str));
       for (i=0; i<strlen(obj.lc.str); i++) {
-	putoa(rob,i,KpoInteger((obj.lc.str)[i]));
+        putoa(rob,i,KpoInteger((obj.lc.str)[i]));
       }
       return(rob);
     }else if (strcmp(key,"universalNumber") == 0) {
       rob.tag = SuniversalNumber;
       rob.lc.universalNumber = stringToUniversalNumber(obj.lc.str,&flag);
       if (flag == -1) errorKan1("KdataConversion(): %s",
-				  "It's not number.\n");
+                                "It's not number.\n");
       return(rob);
+    }else if (strcmp(key,"double") == 0) {
+      /* Check the format.  2.3432 e2 is not allowed. It should be 2.3232e2.*/
+      flag = 0;
+      for (i=0; (obj.lc.str)[i] != '\0'; i++) {
+        if ((obj.lc.str)[i] > ' ' && flag == 0) flag=1;
+        else if ((obj.lc.str)[i] <= ' ' && flag == 1) flag = 2;
+        else if ((obj.lc.str)[i] > ' ' && flag == 2) flag=3;
+      }
+      if (flag == 3) errorKan1("KdataConversion(): %s","The data for the double contains blanck(s)");
+      /* Read the double. */
+      if (sscanf(obj.lc.str,"%lf",&f) <= 0) {
+        errorKan1("KdataConversion(): %s","It cannot be translated to double.");
+      }
+      rob = KpoDouble(f);
+      return(rob);
     }else if (strcmp(key,"null") == 0) {
       rob = NullObject;
       return(rob);
@@ -947,7 +1027,7 @@ char *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));
@@ -961,17 +1041,29 @@ char *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 {
-      warningKan("Sorry. This type of data conversion has not supported yet.\n");
+	  { /* Automatically maps the elements. */
+		int n,i;
+		n = getoaSize(obj);
+		rob = newObjectArray(n);
+		for (i=0; i<n; i++) {
+		  putoa(rob,i,KdataConversion(getoa(obj,i),key));
+		}
+		return(rob);
+	  }
     }
     break;
   case Spoly:
-    if (strcmp(key,"poly")==0) {
+    if ((strcmp(key,"poly")==0) || (strcmp(key,"numerator")==0)) {
+      rob = obj;
       return(rob);
     }else if (strcmp(key,"integer")==0) {
       if (obj.lc.poly == ZERO) return(KpoInteger(0));
       else {
-	return(KpoInteger(coeffToInt(obj.lc.poly->coeffp)));
+        return(KpoInteger(coeffToInt(obj.lc.poly->coeffp)));
       }
     }else if (strcmp(key,"string")==0 || strcmp(key,"dollar")==0) {
       rob.tag = Sdollar;
@@ -983,25 +1075,25 @@ char *key;
       return(KringMap(obj));
     }else if (strcmp(key,"universalNumber")==0) {
       if (obj.lc.poly == ZERO) {
-	rob.tag = SuniversalNumber;
-	rob.lc.universalNumber = newUniversalNumber(0);
+        rob.tag = SuniversalNumber;
+        rob.lc.universalNumber = newUniversalNumber(0);
       } else {
-	if (obj.lc.poly->coeffp->tag == MP_INTEGER) {
-	  rob.tag = SuniversalNumber;
-	  rob.lc.universalNumber = newUniversalNumber2(obj.lc.poly->coeffp->val.bigp);
-	}else {
-	  rob = NullObject;
-	  warningKan("Coefficient is not MP_INT.");
-	}
+        if (obj.lc.poly->coeffp->tag == MP_INTEGER) {
+          rob.tag = SuniversalNumber;
+          rob.lc.universalNumber = newUniversalNumber2(obj.lc.poly->coeffp->val.bigp);
+        }else {
+          rob = NullObject;
+          warningKan("Coefficient is not MP_INT.");
+        }
       }
       return(rob);
     }else if (strcmp(key,"ring")==0) {
       if (obj.lc.poly ISZERO) {
-	warningKan("Zero polynomial does not have the ring structure field.\n");
+        warningKan("Zero polynomial does not have the ring structure field.\n");
       }else{
-	rob.tag = Sring;
-	rob.lc.ringp = (obj.lc.poly)->m->ringp;
-	return(rob);
+        rob.tag = Sring;
+        rob.lc.ringp = (obj.lc.poly)->m->ringp;
+        return(rob);
       }
     }else if (strcmp(key,"null") == 0) {
       rob = NullObject;
@@ -1031,12 +1123,13 @@ char *key;
     break;
   case Slist:
     if (strcmp(key,"array") == 0) {
-      rob = listToArray(&obj);
+      rob = KlistToArray(obj);
       return(rob);
     }
     break;
   case SuniversalNumber:
-    if (strcmp(key,"universalNumber")==0) {
+    if ((strcmp(key,"universalNumber")==0) || (strcmp(key,"numerator")==0)) {
+      rob = obj;
       return(rob);
     }else if (strcmp(key,"integer")==0) {
       rob = KpoInteger(coeffToInt(obj.lc.universalNumber));
@@ -1054,6 +1147,9 @@ char *key;
     }else if (strcmp(key,"double") == 0) {
       rob = KpoDouble( toDouble0(obj) );
       return(rob);
+    }else if (strcmp(key,"denominator") == 0) {
+      rob = KintToUniversalNumber(1);
+      return(rob);
     }else{
       warningKan("Sorry. This type of data conversion of universalNumber has not supported yet.\n");
     }
@@ -1118,20 +1214,48 @@ char *key;
     if (strcmp(key,"orderMatrix")==0) {
       rob = oGetOrderMatrix(KopRingp(obj));
       return(rob);
+    }else if (strcmp(key,"oxRingStructure")==0) {
+      rob = oRingToOXringStructure(KopRingp(obj));
+      return(rob);
     }else{
       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");
   }
   return(NullObject);
 }
-    
+
+/* cf. macro to_int32 */
+struct object Kto_int32(struct object ob) {
+  int n,i;
+  struct object otmp;
+  struct object rob;
+  if (ob.tag == SuniversalNumber) return KdataConversion(ob,"integer");
+  if (ob.tag == Sarray) {
+	n = getoaSize(ob);
+	rob = newObjectArray(n);
+	for (i=0; i<n; i++) {
+	  otmp = Kto_int32(getoa(ob,i));
+	  putoa(rob,i,otmp);
+	}
+	return rob;
+  }
+  return ob;
+}    
 /* conversion functions between primitive data and objects.
    If it's not time critical, it is recommended to use these functions */
 struct object KpoInteger(k)
-int k;
+     int k;
 {
   struct object obj;
   obj.tag = Sinteger;
@@ -1139,7 +1263,7 @@ int k;
   return(obj);
 }
 struct object KpoString(s)
-char *s;
+     char *s;
 {
   struct object obj;
   obj.tag = Sdollar;
@@ -1147,7 +1271,7 @@ char *s;
   return(obj);
 }
 struct object KpoPOLY(f)
-POLY f;
+     POLY f;
 {
   struct object obj;
   obj.tag = Spoly;
@@ -1155,7 +1279,7 @@ POLY f;
   return(obj);
 }
 struct object KpoArrayOfPOLY(ap)
-struct arrayOfPOLY *ap ;
+     struct arrayOfPOLY *ap ;
 {
   struct object obj;
   obj.tag = SarrayOfPOLY;
@@ -1164,7 +1288,7 @@ struct arrayOfPOLY *ap ;
 }
 
 struct object KpoMatrixOfPOLY(mp)
-struct matrixOfPOLY *mp ;
+     struct matrixOfPOLY *mp ;
 {
   struct object obj;
   obj.tag = SmatrixOfPOLY;
@@ -1173,7 +1297,7 @@ struct matrixOfPOLY *mp ;
 }
 
 struct object KpoRingp(ringp)
-struct ring *ringp;
+     struct ring *ringp;
 {
   struct object obj;
   obj.tag = Sring;
@@ -1181,9 +1305,27 @@ struct ring *ringp;
   return(obj);
 }
 
+struct object KpoUniversalNumber(u)
+     struct coeff *u;
+{
+  struct object obj;
+  obj.tag = SuniversalNumber;
+  obj.lc.universalNumber = u;
+  return(obj);
+}
+struct object KintToUniversalNumber(n)
+	 int n;
+{
+  struct object rob;
+  extern struct ring SmallRing;
+  rob.tag = SuniversalNumber;
+  rob.lc.universalNumber = intToCoeff(n,&SmallRing);
+  return(rob);
+}
+
 /*** conversion 2. Data conversions on arrays and matrices. ****/
 struct object arrayOfPOLYToArray(aa)
-struct arrayOfPOLY *aa;
+     struct arrayOfPOLY *aa;
 {
   POLY *a;
   int size;
@@ -1202,7 +1344,7 @@ struct arrayOfPOLY *aa;
 }
 
 struct object matrixOfPOLYToArray(pmat)
-struct matrixOfPOLY *pmat;
+     struct matrixOfPOLY *pmat;
 {
   struct object r;
   struct object tmp;
@@ -1223,7 +1365,7 @@ struct matrixOfPOLY *pmat;
 }
 
 struct arrayOfPOLY *arrayToArrayOfPOLY(oa)
-struct object oa;
+     struct object oa;
 {
   POLY *a;
   int size;
@@ -1232,13 +1374,13 @@ struct object oa;
   struct arrayOfPOLY *ap;
   
   if (oa.tag != Sarray) errorKan1("KarrayToArrayOfPOLY(): %s",
-				  "Argument is not array\n");
+                                  "Argument is not array\n");
   size = getoaSize(oa);
   a = (POLY *)sGC_malloc(sizeof(POLY)*size);
   for (i=0; i<size; i++) {
     tmp = getoa(oa,i);
     if (tmp.tag != Spoly) errorKan1("KarrayToArrayOfPOLY():%s ",
-				    "element must be polynomial.\n");
+                                    "element must be polynomial.\n");
     a[i] = tmp.lc.poly;
   }
   ap = (struct arrayOfPOLY *)sGC_malloc(sizeof(struct arrayOfPOLY));
@@ -1248,7 +1390,7 @@ struct object oa;
 }
 
 struct matrixOfPOLY *arrayToMatrixOfPOLY(oa)
-struct object oa;
+     struct object oa;
 {
   POLY *a;
   int m;
@@ -1258,21 +1400,21 @@ struct object oa;
 
   struct object tmp,tmp2;
   if (oa.tag != Sarray) errorKan1("KarrayToMatrixOfPOLY(): %s",
-				  "Argument is not array\n");
+                                  "Argument is not array\n");
   m = getoaSize(oa);
   tmp = getoa(oa,0);
   if (tmp.tag != Sarray) errorKan1("arrayToMatrixOfPOLY():%s ",
-				  "Argument is not array\n");
+                                   "Argument is not array\n");
   n = getoaSize(tmp);
   a = (POLY *)sGC_malloc(sizeof(POLY)*(m*n));
   for (i=0; i<m; i++) {
     tmp = getoa(oa,i);
     if (tmp.tag != Sarray) errorKan1("arrayToMatrixOfPOLY(): %s",
-				     "element must be array.\n");
+                                     "element must be array.\n");
     for (j=0; j<n; j++) {
       tmp2 = getoa(tmp,j);
       if (tmp2.tag != Spoly) errorKan1("arrayToMatrixOfPOLY(): %s",
-				       "element must be a polynomial.\n");
+                                       "element must be a polynomial.\n");
       a[ind(i,j)] = tmp2.lc.poly;
       /* we use the macro ind here.  Be careful of using m and n. */
     }
@@ -1287,10 +1429,10 @@ struct object oa;
 
 /* :ring    :kan */
 int objArrayToOrderMatrix(oA,order,n,oasize)
-struct object oA;
-int order[];
-int n;
-int oasize;
+     struct object oA;
+     int order[];
+     int n;
+     int oasize;
 {
   int size;
   int k,j;
@@ -1324,7 +1466,7 @@ int oasize;
 }
 
 int KsetOrderByObjArray(oA)
-struct object oA;
+     struct object oA;
 {
   int *order;
   int n,c,l, oasize;
@@ -1352,13 +1494,13 @@ struct object oA;
 }
 
 static int checkRelations(c,l,m,n,cc,ll,mm,nn)
-int c,l,m,n,cc,ll,mm,nn;
+     int c,l,m,n,cc,ll,mm,nn;
 {
   if (!(1<=c && c<=l && l<=m && m<=n)) return(1);
   if (!(cc<=ll && ll<=mm && mm<=nn && nn <= n)) return(1);
   if (!(cc<c || ll < l || mm < m || nn < n)) {
     if (WarningNoVectorVariable) {
-      warningKan("Ring definition: there is no variable to represent vectors.\n");
+      warningKanNoStrictMode("Ring definition: there is no variable to represent vectors.\n");
     }
   }
   if (!(cc<=c && ll <= l && mm <= m && nn <= n)) return(1);
@@ -1373,13 +1515,13 @@ struct object KgetOrderMatrixOfCurrentRing() 
 
   
 int KsetUpRing(ob1,ob2,ob3,ob4,ob5)
-struct object ob1,ob2,ob3,ob4,ob5;
-/* ob1 = [x(0), ..., x(n-1)];
-   ob2 = [D(0), ..., D(n-1)];
-   ob3 = [p,c,l,m,n,cc,ll,mm,nn,next];
-   ob4 = Order matrix
-   ob5 = [(keyword) value (keyword) value ....]
-*/
+     struct object ob1,ob2,ob3,ob4,ob5;
+     /* ob1 = [x(0), ..., x(n-1)];
+        ob2 = [D(0), ..., D(n-1)];
+        ob3 = [p,c,l,m,n,cc,ll,mm,nn,next];
+        ob4 = Order matrix
+        ob5 = [(keyword) value (keyword) value ....]
+     */
 #define RP_LIMIT 500
 {
   int i;
@@ -1477,7 +1619,8 @@ struct object ob1,ob2,ob3,ob4,ob5;
       outputVars[i] = i;
     }
   }
-  
+
+  ob4 = Kto_int32(ob4); /* order matrix */
   oasize = getoaSize(ob4);
   order = (int *)sGC_malloc(sizeof(int)*((2*n)*oasize+1));
   if (order == (int *)NULL) errorKan1("%s\n","No memory.");
@@ -1518,6 +1661,12 @@ struct object ob1,ob2,ob3,ob4,ob5;
   newRingp->schreyer = 0;
   newRingp->gbListTower = NULL;
   newRingp->outputOrder = outputVars;
+  newRingp->weightedHomogenization = 0;
+  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.");
@@ -1525,47 +1674,113 @@ struct object ob1,ob2,ob3,ob4,ob5;
   for (i=0; i < getoaSize(ob5); i += 2) {
     if (getoa(ob5,i).tag == Sdollar) {
       if (strcmp(KopString(getoa(ob5,i)),"mpMult") == 0) {
-	if (getoa(ob5,i+1).tag != Sdollar) {
-	  errorKan1("%s\n","A keyword should be given. (mpMult)");
-	}
-	fmp_mult_saved = F_mpMult;
-	mpMultName = KopString(getoa(ob5,i+1));
-	switch_function("mpMult",mpMultName);
-	/* Note that this cause a global effect. It will be done again. */
-	newRingp->multiplication = mpMult;
-	switch_function("mpMult",fmp_mult_saved);
+        if (getoa(ob5,i+1).tag != Sdollar) {
+          errorKan1("%s\n","A keyword should be given. (mpMult)");
+        }
+        fmp_mult_saved = F_mpMult;
+        mpMultName = KopString(getoa(ob5,i+1));
+        switch_function("mpMult",mpMultName);
+        /* Note that this cause a global effect. It will be done again. */
+        newRingp->multiplication = mpMult;
+        switch_function("mpMult",fmp_mult_saved);
       } else if (strcmp(KopString(getoa(ob5,i)),"coefficient ring") == 0) {
-	if (getoa(ob5,i+1).tag != Sring) {
-	  errorKan1("%s\n","The pointer to a ring should be given. (coefficient ring)");
-	}
-	nextRing = KopRingp(getoa(ob5,i+1));
-	newRingp->next = nextRing;
+        if (getoa(ob5,i+1).tag != Sring) {
+          errorKan1("%s\n","The pointer to a ring should be given. (coefficient ring)");
+        }
+        nextRing = KopRingp(getoa(ob5,i+1));
+        newRingp->next = nextRing;
       } else if (strcmp(KopString(getoa(ob5,i)),"valuation") == 0) {
-	errorKan1("%s\n","Not implemented. (valuation)");
+        errorKan1("%s\n","Not implemented. (valuation)");
       } else if (strcmp(KopString(getoa(ob5,i)),"characteristic") == 0) {
-	if (getoa(ob5,i+1).tag != Sinteger) {
-	  errorKan1("%s\n","A integer should be given. (characteristic)");
-	}
-	p = KopInteger(getoa(ob5,i+1));
-	newRingp->p = p;
+        if (getoa(ob5,i+1).tag != Sinteger) {
+          errorKan1("%s\n","A integer should be given. (characteristic)");
+        }
+        p = KopInteger(getoa(ob5,i+1));
+        newRingp->p = p;
       } else if (strcmp(KopString(getoa(ob5,i)),"schreyer") == 0) {
-	if (getoa(ob5,i+1).tag != Sinteger) {
-	  errorKan1("%s\n","A integer should be given. (schreyer)");
-	}
-	newRingp->schreyer = KopInteger(getoa(ob5,i+1));
+        if (getoa(ob5,i+1).tag != Sinteger) {
+          errorKan1("%s\n","A integer should be given. (schreyer)");
+        }
+        newRingp->schreyer = KopInteger(getoa(ob5,i+1));
       } else if (strcmp(KopString(getoa(ob5,i)),"gbListTower") == 0) {
-	if (getoa(ob5,i+1).tag != Slist) {
-	  errorKan1("%s\n","A list should be given (gbListTower).");
-	}
-	newRingp->gbListTower = newObject();
-	*((struct object *)(newRingp->gbListTower)) = getoa(ob5,i+1);
+        if (getoa(ob5,i+1).tag != Slist) {
+          errorKan1("%s\n","A list should be given (gbListTower).");
+        }
+        newRingp->gbListTower = newObject();
+        *((struct object *)(newRingp->gbListTower)) = getoa(ob5,i+1);
       } else if (strcmp(KopString(getoa(ob5,i)),"ringName") == 0) {
-	if (getoa(ob5,i+1).tag != Sdollar) {
-	  errorKan1("%s\n","A name should be given. (ringName)");
-	}
-	ringName = KopString(getoa(ob5,i+1));
+        if (getoa(ob5,i+1).tag != Sdollar) {
+          errorKan1("%s\n","A name should be given. (ringName)");
+        }
+        ringName = KopString(getoa(ob5,i+1));
+      } else if (strcmp(KopString(getoa(ob5,i)),"weightedHomogenization") == 0) {
+        if (getoa(ob5,i+1).tag != Sinteger) {
+          errorKan1("%s\n","A integer should be given. (weightedHomogenization)");
+        }
+        newRingp->weightedHomogenization = KopInteger(getoa(ob5,i+1));
+      } else if (strcmp(KopString(getoa(ob5,i)),"degreeShift") == 0) {
+        if (getoa(ob5,i+1).tag != Sarray) {
+          errorKan1("%s\n","An array of array should be given. (degreeShift)");
+        }
+        {
+          struct object ods;
+          struct object ods2;
+          int dssize,k,j,nn;
+          ods=getoa(ob5,i+1);
+          if ((getoaSize(ods) < 1) || (getoa(ods,0).tag != Sarray)) {
+            errorKan1("%s\n", "An array of array should be given. (degreeShift)");
+          }
+          nn = getoaSize(ods);
+          dssize = getoaSize(getoa(ods,0));
+          newRingp->degreeShiftSize = dssize;
+          newRingp->degreeShiftN = nn;
+          newRingp->degreeShift = (int *) sGC_malloc(sizeof(int)*(dssize*nn+1));
+          if (newRingp->degreeShift == NULL) errorKan1("%s\n","No more memory.");
+          for (j=0; j<nn; j++) {
+            ods2 = getoa(ods,j);
+            for (k=0; k<dssize; k++) {
+              if (getoa(ods2,k).tag == SuniversalNumber) {
+                (newRingp->degreeShift)[j*dssize+k] = coeffToInt(getoa(ods2,k).lc.universalNumber);
+              }else{
+                (newRingp->degreeShift)[j*dssize+k] = KopInteger(getoa(ods2,k));
+              }
+            }
+          }
+        }
+      } 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 {
-	errorKan1("%s\n","Unknown keyword to set_up_ring@");
+        errorKan1("%s\n","Unknown keyword to set_up_ring@");
       }
     }else{
       errorKan1("%s\n","A keyword enclosed by braces have to be given.");
@@ -1582,10 +1797,10 @@ struct object ob1,ob2,ob3,ob4,ob5;
       CurrentRingp = newRingp;
       /* Install it to the RingStack */
       if (rp <RP_LIMIT) {
-	rstack[rp] = CurrentRingp; rp++; /* Save the previous ringp */
+        rstack[rp] = CurrentRingp; rp++; /* Save the previous ringp */
       }else{
-	rp = 0;
-	errorKan1("%s\n","You have defined too many rings. Check the value of RP_LIMIT.");
+        rp = 0;
+        errorKan1("%s\n","You have defined too many rings. Check the value of RP_LIMIT.");
       }
     }else{
       /* This ring has been defined. */
@@ -1653,13 +1868,13 @@ struct object KsetVariableNames(struct object ob,struc
 
   
 void KshowRing(ringp)
-struct ring *ringp;
+     struct ring *ringp;
 {
   showRing(1,ringp);
 }
 
 struct object KswitchFunction(ob1,ob2)
-struct object ob1,ob2;
+     struct object ob1,ob2;
 {
   char *ans ;
   struct object rob;
@@ -1679,7 +1894,7 @@ struct object ob1,ob2;
   }
   if (AvoidTheSameRing) {
     if (strcmp(KopString(ob1),"mmLarger") == 0 &&
-	strcmp(KopString(ob2),"matrix") != 0) {
+        strcmp(KopString(ob2),"matrix") != 0) {
       fprintf(stderr,"mmLarger = %s",KopString(ob2));
       errorKan1("%s\n","mmLarger can set only to matrix under AvoidTheSameRing == 1.");
     }
@@ -1701,8 +1916,8 @@ void KprintSwitchStatus(void)
 }
 
 struct object KoReplace(of,rule)
-struct object of;
-struct object rule;
+     struct object of;
+     struct object rule;
 {
   struct object rob;
   POLY f;
@@ -1719,7 +1934,10 @@ struct object rule;
   }
   n = getoaSize(rule);
 
-  if (of.tag != Spoly) {
+  if (of.tag == Spoly) {
+  }else if (of.tag ==Sclass && ectag(of) == CLASSNAME_recursivePolynomial) {
+    return(KreplaceRecursivePolynomial(of,rule));
+  }else{
     errorKan1("%s\n"," KoReplace(): The first argument must be a polynomial.");
   }
   f = KopPOLY(of);
@@ -1759,8 +1977,8 @@ struct object rule;
 
 
 struct object Kparts(f,v)
-struct object f;
-struct object v;
+     struct object f;
+     struct object v;
 {
   POLY ff;
   POLY vv;
@@ -1776,8 +1994,8 @@ struct object v;
 }
 
 struct object Kparts2(f,v)
-struct object f;
-struct object v;
+     struct object f;
+     struct object v;
 {
   POLY ff;
   POLY vv;
@@ -1793,7 +2011,7 @@ struct object v;
 
 
 struct object Kdegree(ob1,ob2)
-struct object ob1,ob2;
+     struct object ob1,ob2;
 {
   if (ob1.tag != Spoly || ob2.tag != Spoly)
     errorKan1("%s\n","The arguments must be polynomials.");
@@ -1802,7 +2020,7 @@ struct object ob1,ob2;
 }
 
 struct object KringMap(obj)
-struct object obj;
+     struct object obj;
 {
   extern struct ring *CurrentRingp;
   extern struct ring *SyzRingp;
@@ -1826,7 +2044,7 @@ struct object obj;
 
 
 struct object Ksp(ob1,ob2)
-struct object ob1,ob2;
+     struct object ob1,ob2;
 {
   struct spValue sv;
   struct object rob,cob;
@@ -1835,7 +2053,7 @@ struct object ob1,ob2;
     errorKan1("%s\n","Ksp(): The arguments must be polynomials.");
   sv = (*sp)(ob1.lc.poly,ob2.lc.poly);
   f = ppAddv(ppMult(sv.a,KopPOLY(ob1)),
-	     ppMult(sv.b,KopPOLY(ob2)));
+             ppMult(sv.b,KopPOLY(ob2)));
   rob = newObjectArray(2);
   cob = newObjectArray(2);
   putoa(rob,1,KpoPOLY(f));
@@ -1846,7 +2064,7 @@ struct object ob1,ob2;
 }
   
 struct object Khead(ob)
-struct object ob;
+     struct object ob;
 {
   if (ob.tag != Spoly) errorKan1("%s\n","Khead(): The argument should be a polynomial.");
   return(KpoPOLY(head( KopPOLY(ob))));
@@ -1855,7 +2073,7 @@ struct object ob;
 
 /* :eval */
 struct object Keval(obj)
-struct object obj;
+     struct object obj;
 {
   char *key;
   int size;
@@ -1877,7 +2095,7 @@ struct object obj;
   
 /* :Utilities */
 char *KremoveSpace(str)
-char str[];
+     char str[];
 {
   int size;
   int start;
@@ -1902,7 +2120,7 @@ char str[];
 }
 
 struct object KtoRecords(ob)
-struct object ob;
+     struct object ob;
 {
   struct object obj;
   struct object tmp;
@@ -1935,16 +2153,16 @@ struct object ob;
 }
 
 int KtoArgvbyCurryBrace(str,argv,limit)
-char *str;
-char *argv[];
-int limit;
-/* This function returns argc */
-/* decompose into tokens by the separators
+     char *str;
+     char *argv[];
+     int limit;
+     /* This function returns argc */
+     /* decompose into tokens by the separators
    { }, [ ], and characters of which code is less than SPACE.
    Example.   { }  ---> nothing            (argc=0)
               {x}----> x                   (argc=1)
               {x,y} --> x   y              (argc=2)
-	      {ab, y, z } --> ab   y   z   (argc=3)
+          {ab, y, z } --> ab   y   z   (argc=3)
               [[ab],c,d]  --> [ab] c   d
 */
 {
@@ -2000,11 +2218,51 @@ int limit;
   return(argc);
 }
 
+struct object KstringToArgv(struct object ob) {
+  struct object rob;
+  char *s;
+  int n,wc,i,inblank;
+  char **argv;
+  if (ob.tag != Sdollar)
+    errorKan1("%s\n","KstringToArgv(): the argument must be a string.");
+  n = strlen(KopString(ob));
+  s = (char *) sGC_malloc(sizeof(char)*(n+2));
+  if (s == NULL) errorKan1("%s\n","KstringToArgv(): No memory.");
+  strcpy(s,KopString(ob));
+  inblank = 1;  wc = 0; 
+  for (i=0; i<n; i++) {
+    if (inblank && (s[i] > ' ')) {
+      wc++; inblank = 0;
+    }else if ((!inblank) && (s[i] <= ' ')) {
+      inblank = 1;
+    }
+  }
+  argv = (char **) sGC_malloc(sizeof(char *)*(wc+2));
+  argv[0] = NULL;
+  inblank = 1;  wc = 0; 
+  for (i=0; i<n; i++) {
+    if (inblank && (s[i] > ' ')) {
+      argv[wc] = &(s[i]); argv[wc+1]=NULL;
+      wc++; inblank = 0;
+    }else if ((inblank == 0) && (s[i] <= ' ')) {
+      inblank = 1; s[i] = 0;
+    }else if (inblank && (s[i] <= ' ')) {
+      s[i] = 0;
+    }
+  }
 
+  rob = newObjectArray(wc);
+  for (i=0; i<wc; i++) {
+    putoa(rob,i,KpoString(argv[i]));
+    /* printf("%s\n",argv[i]); */
+  }
+  return(rob);
+}
+
 static void checkDuplicateName(xvars,dvars,n)
-char *xvars[];
-char *dvars[];
-int n;
+     char *xvars[];
+     char *dvars[];
+     int n;
 {
   int i,j;
   char *names[N0*2];
@@ -2015,18 +2273,28 @@ int n;
   for (i=0; i<n; i++) {
     for (j=i+1; j<n; j++) {
       if (strcmp(names[i],names[j]) == 0) {
-	fprintf(stderr,"\n%d=%s, %d=%s\n",i,names[i],j,names[j]);
-	errorKan1("%s\n","Duplicate definition of the name above in SetUpRing().");
+        fprintf(stderr,"\n%d=%s, %d=%s\n",i,names[i],j,names[j]);
+        errorKan1("%s\n","Duplicate definition of the name above in SetUpRing().");
       }
     }
   }
 }
 
+struct object KooPower(struct object ob1,struct object ob2) {
+  struct object rob;
+  /* Bug. It has not yet been implemented. */
+  if (QuoteMode) {
+    rob = powerTree(ob1,ob2);
+  }else{
+    warningKan("KooDiv2() has not supported yet these objects.\n");
+  }
+  return(rob);
+}
 
 
 
 struct object KooDiv2(ob1,ob2)
-struct object ob1,ob2;
+     struct object ob1,ob2;
 {
   struct object rob = NullObject;
   POLY f;
@@ -2084,7 +2352,11 @@ struct object ob1,ob2;
     break;
 
   default:
-    warningKan("KooDiv2() has not supported yet these objects.\n");
+    if (QuoteMode) {
+      rob = divideTree(ob1,ob2);
+    }else{
+      warningKan("KooDiv2() has not supported yet these objects.\n");
+    }
     break;
   }
   return(rob);
@@ -2113,7 +2385,7 @@ struct object ob1,ob2;
 */
 
 int KisInvalidRational(op)
-objectp op;
+     objectp op;
 {
   extern struct coeff *UniversalZero;
   if (op->tag != SrationalFunction) return(0);
@@ -2140,6 +2412,7 @@ struct object KgbExtension(struct object obj)
   POLY f;
   int m,i;
   struct pairOfPOLY pf;
+  struct coeff *cont;
 
   if (obj.tag != Sarray) errorKan1("%s\n","KgbExtension(): The argument must be an array.");
   size = getoaSize(obj);
@@ -2219,6 +2492,13 @@ struct object KgbExtension(struct object obj)
       errorKan1("%s\n","The datatype of the argument mismatch: [(isConstant) polynomial] gbext");
     }
     return(KpoInteger(isConstant(KopPOLY(obj1))));
+  }else if (strcmp(key,"isConstantAll")==0) {
+    if (size != 2) errorKan1("%s\n","[(isConstantAll) poly ] gbext bool");
+    obj1 = getoa(obj,1);
+    if (obj1.tag != Spoly) {
+      errorKan1("%s\n","The datatype of the argument mismatch: [(isConstantAll) polynomial] gbext");
+    }
+    return(KpoInteger(isConstantAll(KopPOLY(obj1))));
   }else if (strcmp(key,"schreyerSkelton") == 0) {
     if (size != 2) errorKan1("%s\n","[(schreyerSkelton) array_of_poly ] gbext array");
     obj1 = getoa(obj,1);
@@ -2242,11 +2522,48 @@ struct object KgbExtension(struct object obj)
     obj1 = getoa(obj,1);
     if (obj1.tag != Sarray) errorKan1("%s\n","[(toes) array] gbext poly");
     return(KvectorToSchreyer_es(obj1));
+  }else if (strcmp(key,"toe_") == 0) {
+    if (size != 2) errorKan1("%s\n","[(toe_) array] gbext poly");
+    obj1 = getoa(obj,1);
+    if (obj1.tag == Spoly) return(obj1);
+    if (obj1.tag != Sarray) errorKan1("%s\n","[(toe_) array] gbext poly");
+    return(KpoPOLY(arrayToPOLY(obj1)));
   }else if (strcmp(key,"isOrdered") == 0) {
     if (size != 2) errorKan1("%s\n","[(isOrdered) poly] gbext poly");
     obj1 = getoa(obj,1);
     if (obj1.tag != Spoly) errorKan1("%s\n","[(isOrdered) poly] gbext poly");
     return(KisOrdered(obj1));
+  }else if (strcmp(key,"reduceContent")==0) {
+    if (size != 2) errorKan1("%s\n","[(reduceContent)  poly1 ] gbext.");
+    obj1 = getoa(obj,1);
+    if (obj1.tag != Spoly)
+      errorKan1("%s\n","[(reduceContent)  poly1 ] gbext.");
+    f1 = KopPOLY(obj1);
+    rob = newObjectArray(2);
+    f1 = reduceContentOfPoly(f1,&cont);
+    putoa(rob,0,KpoPOLY(f1));
+    if (f1 == POLYNULL) {
+      putoa(rob,1,KpoPOLY(f1));
+    }else{
+      putoa(rob,1,KpoPOLY(newCell(cont,newMonomial(f1->m->ringp))));
+    }
+  }else if (strcmp(key,"ord_ws_all")==0) {
+    if (size != 3) errorKan1("%s\n","[(ord_ws_all) fv wv] gbext");
+    obj1 = getoa(obj,1);
+    obj2 = getoa(obj,2);
+    rob  = KordWsAll(obj1,obj2);
+  }else if (strcmp(key,"exponents")==0) {
+    if (size == 3) {
+      obj1 = getoa(obj,1);
+      obj2 = getoa(obj,2);
+      rob  = KgetExponents(obj1,obj2);
+    }else if (size == 2) {
+      obj1 = getoa(obj,1);
+      obj2 = KpoInteger(2);
+      rob  = KgetExponents(obj1,obj2);
+    }else{
+      errorKan1("%s\n","[(exponents) f type] gbext");
+    }
   }else {
     errorKan1("%s\n","gbext : unknown tag.");
   }
@@ -2282,10 +2599,16 @@ struct object KmpzExtension(struct object obj)
     if (size != 3) errorKan1("%s\n","[(gcd)  universalNumber universalNumber] mpzext.");
     obj1 = getoa(obj,1);
     obj2 = getoa(obj,2);
+    if (obj1.tag != SuniversalNumber) {
+      obj1 = KdataConversion(obj1,"universalNumber");
+	}
+    if (obj2.tag != SuniversalNumber) {
+      obj2 = KdataConversion(obj2,"universalNumber");
+	}
     if (obj1.tag != SuniversalNumber || obj2.tag != SuniversalNumber)
       errorKan1("%s\n","[(gcd)  universalNumber universalNumber] mpzext.");
     if (! is_this_coeff_MP_INT(obj1.lc.universalNumber) ||
-	! is_this_coeff_MP_INT(obj2.lc.universalNumber)) {
+        ! is_this_coeff_MP_INT(obj2.lc.universalNumber)) {
       errorKan1("%s\n","[(gcd)  universalNumber universalNumber] mpzext.");
     }
     f = coeff_to_MP_INT(obj1.lc.universalNumber);
@@ -2298,10 +2621,16 @@ struct object KmpzExtension(struct object obj)
     if (size != 3) errorKan1("%s\n","[(tdiv_qr)  universalNumber universalNumber] mpzext.");
     obj1 = getoa(obj,1);
     obj2 = getoa(obj,2);
+    if (obj1.tag != SuniversalNumber) {
+      obj1 = KdataConversion(obj1,"universalNumber");
+	}
+    if (obj2.tag != SuniversalNumber) {
+      obj2 = KdataConversion(obj2,"universalNumber");
+	}
     if (obj1.tag != SuniversalNumber || obj2.tag != SuniversalNumber)
       errorKan1("%s\n","[(tdiv_qr)  universalNumber universalNumber] mpzext.");
     if (! is_this_coeff_MP_INT(obj1.lc.universalNumber) ||
-	! is_this_coeff_MP_INT(obj2.lc.universalNumber)) {
+        ! is_this_coeff_MP_INT(obj2.lc.universalNumber)) {
       errorKan1("%s\n","[(tdiv_qr)  universalNumber universalNumber] mpzext.");
     }
     f = coeff_to_MP_INT(obj1.lc.universalNumber);
@@ -2332,7 +2661,7 @@ struct object KmpzExtension(struct object obj)
       return(obj0);
     }
     if (! is_this_coeff_MP_INT(obj1.lc.universalNumber) ||
-	! is_this_coeff_MP_INT(obj2.lc.universalNumber)) {
+        ! is_this_coeff_MP_INT(obj2.lc.universalNumber)) {
       errorKan1("%s\n","[(cancel)  universalNumber/universalNumber] mpzext.");
     }
     f = coeff_to_MP_INT(obj1.lc.universalNumber);
@@ -2352,10 +2681,13 @@ struct object KmpzExtension(struct object obj)
     rob = KnewRationalFunction0(copyObjectp(&obj1),copyObjectp(&obj2));
     KisInvalidRational(&rob);
   }else if (strcmp(key,"sqrt")==0 ||
-	    strcmp(key,"com")==0) {
+            strcmp(key,"com")==0) {
     /*  One arg functions  */
     if (size != 2) errorKan1("%s\n","[key num] mpzext");
     obj1 = getoa(obj,1);
+    if (obj1.tag != SuniversalNumber) {
+      obj1 = KdataConversion(obj1,"universalNumber");
+	}
     if (obj1.tag != SuniversalNumber)
       errorKan1("%s\n","[key num] mpzext : num must be a universalNumber.");
     if (! is_this_coeff_MP_INT(obj1.lc.universalNumber))
@@ -2371,16 +2703,22 @@ struct object KmpzExtension(struct object obj)
     rob.tag = SuniversalNumber;
     rob.lc.universalNumber = mpintToCoeff(r1,SmallRingp);
   }else if (strcmp(key,"probab_prime_p")==0 ||
-	    strcmp(key,"and") == 0 ||
-	    strcmp(key,"ior")==0) {
+            strcmp(key,"and") == 0 ||
+            strcmp(key,"ior")==0) {
     /* Two args functions */
     if (size != 3) errorKan1("%s\n","[key  num1 num2] mpzext.");
     obj1 = getoa(obj,1);
     obj2 = getoa(obj,2);
+    if (obj1.tag != SuniversalNumber) {
+      obj1 = KdataConversion(obj1,"universalNumber");
+	}
+    if (obj2.tag != SuniversalNumber) {
+      obj2 = KdataConversion(obj2,"universalNumber");
+	}
     if (obj1.tag != SuniversalNumber || obj2.tag != SuniversalNumber)
       errorKan1("%s\n","[key num1 num2] mpzext.");
     if (! is_this_coeff_MP_INT(obj1.lc.universalNumber) ||
-	! is_this_coeff_MP_INT(obj2.lc.universalNumber)) {
+        ! is_this_coeff_MP_INT(obj2.lc.universalNumber)) {
       errorKan1("%s\n","[key  num1 num2] mpzext.");
     }
     f = coeff_to_MP_INT(obj1.lc.universalNumber);
@@ -2388,9 +2726,9 @@ struct object KmpzExtension(struct object obj)
     if (strcmp(key,"probab_prime_p")==0) {
       gi = (int) mpz_get_si(g);
       if (mpz_probab_prime_p(f,gi)) {
-	rob = KpoInteger(1);
+        rob = KpoInteger(1);
       }else {
-	rob = KpoInteger(0);
+        rob = KpoInteger(0);
       }
     }else if (strcmp(key,"and")==0) {
       r1 = newMP_INT();
@@ -2408,14 +2746,23 @@ struct object KmpzExtension(struct object obj)
     /* three args */
     if (size != 4) errorKan1("%s\n","[key num1 num2 num3] mpzext");
     obj1 = getoa(obj,1); obj2 = getoa(obj,2); obj3 = getoa(obj,3);
+    if (obj1.tag != SuniversalNumber) {
+      obj1 = KdataConversion(obj1,"universalNumber");
+	}
+    if (obj2.tag != SuniversalNumber) {
+      obj2 = KdataConversion(obj2,"universalNumber");
+	}
+    if (obj3.tag != SuniversalNumber) {
+      obj3 = KdataConversion(obj3,"universalNumber");
+	}
     if (obj1.tag != SuniversalNumber ||
         obj2.tag != SuniversalNumber ||
         obj3.tag != SuniversalNumber ) {
       errorKan1("%s\n","[key num1 num2 num3] mpzext : num1, num2 and num3 must be universalNumbers.");
     }
     if (! is_this_coeff_MP_INT(obj1.lc.universalNumber) ||
-	! is_this_coeff_MP_INT(obj2.lc.universalNumber) ||
-	! is_this_coeff_MP_INT(obj3.lc.universalNumber)) {
+        ! is_this_coeff_MP_INT(obj2.lc.universalNumber) ||
+        ! is_this_coeff_MP_INT(obj3.lc.universalNumber)) {
       errorKan1("%s\n","[key num1 num2 num3] mpzext : num1, num2 and num3 must be universalNumbers.");
     }
     f = coeff_to_MP_INT(obj1.lc.universalNumber);
@@ -2426,6 +2773,28 @@ struct object KmpzExtension(struct object obj)
     mpz_powm(r1,f,g,h);
     rob.tag = SuniversalNumber;
     rob.lc.universalNumber = mpintToCoeff(r1,SmallRingp);
+  } else if (strcmp(key,"lcm")==0) {
+    if (size != 3) errorKan1("%s\n","[(lcm)  universalNumber universalNumber] mpzext.");
+    obj1 = getoa(obj,1);
+    obj2 = getoa(obj,2);
+    if (obj1.tag != SuniversalNumber) {
+      obj1 = KdataConversion(obj1,"universalNumber");
+	}
+    if (obj2.tag != SuniversalNumber) {
+      obj2 = KdataConversion(obj2,"universalNumber");
+	}
+    if (obj1.tag != SuniversalNumber || obj2.tag != SuniversalNumber)
+      errorKan1("%s\n","[lcm num1 num2] mpzext.");
+    if (! is_this_coeff_MP_INT(obj1.lc.universalNumber) ||
+        ! is_this_coeff_MP_INT(obj2.lc.universalNumber)) {
+      errorKan1("%s\n","[(lcm)  universalNumber universalNumber] mpzext.");
+    }
+    f = coeff_to_MP_INT(obj1.lc.universalNumber);
+    g = coeff_to_MP_INT(obj2.lc.universalNumber);
+    r1 = newMP_INT();
+    mpz_lcm(r1,f,g);
+    rob.tag = SuniversalNumber;
+    rob.lc.universalNumber = mpintToCoeff(r1,SmallRingp); 
   }else {
     errorKan1("%s\n","mpzExtension(): Unknown tag.");
   }
@@ -2451,8 +2820,8 @@ struct object KnewContext(struct object superObj,char 
 }
 
 struct object KcreateClassIncetance(struct object ob1,
-				    struct object ob2,
-				    struct object ob3)
+                                    struct object ob2,
+                                    struct object ob3)
 {
   /* [class-tag super-obj] size [class-tag]  cclass */
   struct object ob4;
@@ -2481,7 +2850,7 @@ struct object KcreateClassIncetance(struct object ob1,
   ob5 = getoa(ob3,0);
   if (ectag(ob5) != CLASSNAME_CONTEXT)
     errorKan1("%s\n","cclass: The third argument must be [class-tag].");
-				    
+                    
   rob = newObjectArray(size);
   putoa(rob,0,ob5);
   if (getoaSize(ob1) < size) size2 = getoaSize(ob1);
@@ -2616,7 +2985,7 @@ struct object KdefaultPolyRing(struct object ob) {
     for (j=0; j<2*n; j++) {
       putoa(t1,j,KpoInteger(0));
       if (j == (2*n-i)) {
-	putoa(t1,j,KpoInteger(-1));
+        putoa(t1,j,KpoInteger(-1));
       }
     }
     putoa(ob4,i,t1);
@@ -2632,21 +3001,164 @@ 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 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;
+}
+
 /******************************************************************
      error handler
 ******************************************************************/
 
 errorKan1(str,message)
-char *str;
-char *message;
+     char *str;
+     char *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): ");
     if (strlen(message) < 900) {
@@ -2657,6 +3169,7 @@ char *message;
   if (ErrorMessageMode != 1) {
     fprintf(stderr,"\nERROR(kanExport[0|1].c): ");
     fprintf(stderr,str,message);
+    (void) traceShowStack(); traceClearStack();
   }
   /* fprintf(stderr,"Hello "); */
   if (GotoP) {
@@ -2666,11 +3179,16 @@ char *message;
   }
   stdOperandStack(); contextControl(CCRESTORE);
   /* fprintf(stderr,"Now. Long jump!\n"); */
+#if defined(__CYGWIN__)
+  siglongjmp(EnvOfStackMachine,1);
+#else
   longjmp(EnvOfStackMachine,1);
+#endif
 }
 
+
 warningKan(str)
-char *str;
+     char *str;
 {
   extern int WarningMessageMode;
   extern int Strict;
@@ -2689,6 +3207,18 @@ char *str;
   }
   /* if (Strict) errorKan1("%s\n"," "); */
   if (Strict) errorKan1("%s\n",str);
+  return(0);
+}
+
+warningKanNoStrictMode(str)
+     char *str; 
+{
+  extern int Strict;
+  int t;
+  t = Strict;
+  Strict = 0;
+  warningKan(str);
+  Strict = t;
   return(0);
 }