===================================================================
RCS file: /home/cvs/OpenXM/src/kan96xx/Kan/kanExport0.c,v
retrieving revision 1.4
retrieving revision 1.23
diff -u -p -r1.4 -r1.23
--- OpenXM/src/kan96xx/Kan/kanExport0.c	2000/07/17 02:58:45	1.4
+++ OpenXM/src/kan96xx/Kan/kanExport0.c	2004/07/30 11:21:55	1.23
@@ -1,4 +1,4 @@
-/* $OpenXM: OpenXM/src/kan96xx/Kan/kanExport0.c,v 1.3 2000/06/08 08:35:02 takayama Exp $  */
+/* $OpenXM: OpenXM/src/kan96xx/Kan/kanExport0.c,v 1.22 2004/05/13 04:38:28 takayama Exp $  */
 #include <stdio.h>
 #include "datatype.h"
 #include "stackm.h"
@@ -19,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;
@@ -142,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;
@@ -270,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;
@@ -412,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);
@@ -421,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;
@@ -451,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;
@@ -494,7 +511,7 @@ struct object obj;
     
 
 static int isVector(ob)
-struct object ob;
+     struct object ob;
 {
   int i,n;
   n = getoaSize(ob);
@@ -505,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++) {
@@ -521,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;
@@ -549,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;
@@ -564,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.");
@@ -600,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);
@@ -625,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);
     }
@@ -636,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]) {
@@ -647,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);
@@ -661,8 +682,8 @@ 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;
@@ -671,63 +692,63 @@ struct object obj2;
     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) {
@@ -742,8 +763,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;
@@ -751,40 +772,40 @@ 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;
+  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;
@@ -792,42 +813,42 @@ 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;
+  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 */
@@ -847,9 +868,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) {
@@ -914,7 +935,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);
@@ -930,27 +951,27 @@ 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 ((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.");
+        errorKan1("KdataConversion(): %s","It cannot be translated to double.");
       }
       rob = KpoDouble(f);
       return(rob);
@@ -980,16 +1001,25 @@ char *key;
       rob = NullObject;
       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;
@@ -1001,25 +1031,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;
@@ -1054,7 +1084,7 @@ char *key;
     }
     break;
   case SuniversalNumber:
-    if (strcmp(key,"universalNumber")==0) {
+    if ((strcmp(key,"universalNumber")==0) || (strcmp(key,"numerator")==0)) {
       return(rob);
     }else if (strcmp(key,"integer")==0) {
       rob = KpoInteger(coeffToInt(obj.lc.universalNumber));
@@ -1136,6 +1166,9 @@ 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");
     }
@@ -1149,7 +1182,7 @@ char *key;
 /* 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;
@@ -1157,7 +1190,7 @@ int k;
   return(obj);
 }
 struct object KpoString(s)
-char *s;
+     char *s;
 {
   struct object obj;
   obj.tag = Sdollar;
@@ -1165,7 +1198,7 @@ char *s;
   return(obj);
 }
 struct object KpoPOLY(f)
-POLY f;
+     POLY f;
 {
   struct object obj;
   obj.tag = Spoly;
@@ -1173,7 +1206,7 @@ POLY f;
   return(obj);
 }
 struct object KpoArrayOfPOLY(ap)
-struct arrayOfPOLY *ap ;
+     struct arrayOfPOLY *ap ;
 {
   struct object obj;
   obj.tag = SarrayOfPOLY;
@@ -1182,7 +1215,7 @@ struct arrayOfPOLY *ap ;
 }
 
 struct object KpoMatrixOfPOLY(mp)
-struct matrixOfPOLY *mp ;
+     struct matrixOfPOLY *mp ;
 {
   struct object obj;
   obj.tag = SmatrixOfPOLY;
@@ -1191,7 +1224,7 @@ struct matrixOfPOLY *mp ;
 }
 
 struct object KpoRingp(ringp)
-struct ring *ringp;
+     struct ring *ringp;
 {
   struct object obj;
   obj.tag = Sring;
@@ -1199,9 +1232,17 @@ struct ring *ringp;
   return(obj);
 }
 
+struct object KpoUniversalNumber(u)
+     struct coeff *u;
+{
+  struct object obj;
+  obj.tag = SuniversalNumber;
+  obj.lc.universalNumber = u;
+  return(obj);
+}
 /*** conversion 2. Data conversions on arrays and matrices. ****/
 struct object arrayOfPOLYToArray(aa)
-struct arrayOfPOLY *aa;
+     struct arrayOfPOLY *aa;
 {
   POLY *a;
   int size;
@@ -1220,7 +1261,7 @@ struct arrayOfPOLY *aa;
 }
 
 struct object matrixOfPOLYToArray(pmat)
-struct matrixOfPOLY *pmat;
+     struct matrixOfPOLY *pmat;
 {
   struct object r;
   struct object tmp;
@@ -1241,7 +1282,7 @@ struct matrixOfPOLY *pmat;
 }
 
 struct arrayOfPOLY *arrayToArrayOfPOLY(oa)
-struct object oa;
+     struct object oa;
 {
   POLY *a;
   int size;
@@ -1250,13 +1291,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));
@@ -1266,7 +1307,7 @@ struct object oa;
 }
 
 struct matrixOfPOLY *arrayToMatrixOfPOLY(oa)
-struct object oa;
+     struct object oa;
 {
   POLY *a;
   int m;
@@ -1276,21 +1317,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. */
     }
@@ -1305,10 +1346,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;
@@ -1342,7 +1383,7 @@ int oasize;
 }
 
 int KsetOrderByObjArray(oA)
-struct object oA;
+     struct object oA;
 {
   int *order;
   int n,c,l, oasize;
@@ -1370,7 +1411,7 @@ 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);
@@ -1391,13 +1432,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;
@@ -1536,6 +1577,10 @@ 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;
 
   if (ob5.tag != Sarray || (getoaSize(ob5) % 2) != 0) {
     errorKan1("%s\n","[(keyword) value (keyword) value ....] should be given.");
@@ -1543,47 +1588,83 @@ 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));
+              }
+            }
+          }
+        }
+        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.");
@@ -1600,10 +1681,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. */
@@ -1671,13 +1752,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;
@@ -1697,7 +1778,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.");
     }
@@ -1719,8 +1800,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;
@@ -1737,7 +1818,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);
@@ -1777,8 +1861,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;
@@ -1794,8 +1878,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;
@@ -1811,7 +1895,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.");
@@ -1820,7 +1904,7 @@ struct object ob1,ob2;
 }
 
 struct object KringMap(obj)
-struct object obj;
+     struct object obj;
 {
   extern struct ring *CurrentRingp;
   extern struct ring *SyzRingp;
@@ -1844,7 +1928,7 @@ struct object obj;
 
 
 struct object Ksp(ob1,ob2)
-struct object ob1,ob2;
+     struct object ob1,ob2;
 {
   struct spValue sv;
   struct object rob,cob;
@@ -1853,7 +1937,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));
@@ -1864,7 +1948,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))));
@@ -1873,7 +1957,7 @@ struct object ob;
 
 /* :eval */
 struct object Keval(obj)
-struct object obj;
+     struct object obj;
 {
   char *key;
   int size;
@@ -1895,7 +1979,7 @@ struct object obj;
   
 /* :Utilities */
 char *KremoveSpace(str)
-char str[];
+     char str[];
 {
   int size;
   int start;
@@ -1920,7 +2004,7 @@ char str[];
 }
 
 struct object KtoRecords(ob)
-struct object ob;
+     struct object ob;
 {
   struct object obj;
   struct object tmp;
@@ -1953,16 +2037,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
 */
 {
@@ -2018,11 +2102,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];
@@ -2033,18 +2157,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;
@@ -2102,7 +2236,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);
@@ -2131,7 +2269,7 @@ struct object ob1,ob2;
 */
 
 int KisInvalidRational(op)
-objectp op;
+     objectp op;
 {
   extern struct coeff *UniversalZero;
   if (op->tag != SrationalFunction) return(0);
@@ -2158,6 +2296,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);
@@ -2237,6 +2376,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);
@@ -2271,6 +2417,37 @@ struct object KgbExtension(struct object obj)
     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.");
   }
@@ -2309,7 +2486,7 @@ struct object KmpzExtension(struct object obj)
     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);
@@ -2325,7 +2502,7 @@ struct object KmpzExtension(struct object obj)
     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);
@@ -2356,7 +2533,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);
@@ -2376,7 +2553,7 @@ 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);
@@ -2395,8 +2572,8 @@ 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);
@@ -2404,7 +2581,7 @@ struct object KmpzExtension(struct object obj)
     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);
@@ -2412,9 +2589,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();
@@ -2438,8 +2615,8 @@ struct object KmpzExtension(struct object obj)
       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);
@@ -2475,8 +2652,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;
@@ -2505,7 +2682,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);
@@ -2640,7 +2817,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);
@@ -2664,13 +2841,14 @@ struct object KdefaultPolyRing(struct object ob) {
 ******************************************************************/
 
 errorKan1(str,message)
-char *str;
-char *message;
+     char *str;
+     char *message;
 {
   extern char *GotoLabel;
   extern int GotoP;
   extern int ErrorMessageMode;
   char tmpc[1024];
+  cancelAlarm();
   if (ErrorMessageMode == 1 || ErrorMessageMode == 2) {
     sprintf(tmpc,"\nERROR(kanExport[0|1].c): ");
     if (strlen(message) < 900) {
@@ -2690,11 +2868,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;
@@ -2717,7 +2900,7 @@ char *str;
 }
 
 warningKanNoStrictMode(str)
-char *str; 
+     char *str; 
 {
   extern int Strict;
   int t;