Check properly for permutations whose degree would exceed the

internal limit. Document the limit.

lib/permutat.g

@@ -32,6 +32,11 @@
 ##  takes <M>4m</M> bytes of storage.
 ##  It can take even more because the internal list has sometimes room for
 ##  more than <M>d</M> images.
+##  <P/> On 32-bit systems, the limit on the degree of permutations is, for 
+##  technical reasons, <M>2^{{28}}-1</M>.
+##  On 64-bit systems, it is <M>2^{{32}}-1</M> because only a 32-bit integer 
+##  is used to represent each image internally. Error messages should be given
+##  if any command would require creating a permutation exceeding this limit. 
 ##  <P/>
 ##  The operation <Ref Func="RestrictedPerm"/> reduces the storage degree of
 ##  its result and therefore can be used to save memory if intermediate

src/exprs.c

@@ -969,6 +969,9 @@ Obj             EvalPermExpr (
                     "you can replace <expr> via 'return <expr>;'" );
             }
             c = INT_INTOBJ(val);
+	    if (c > MAX_DEG_PERM4)
+	      ErrorMayQuit( "Permutation literal exceeds maximum permutatuion degree -- %i vs %i",
+			    c, MAX_DEG_PERM4);
 
             /* if necessary resize the permutation                         */
             if ( SIZE_OBJ(perm)/sizeof(UInt4) < c ) {

src/intrprtr.c

@@ -2176,6 +2176,11 @@ void            IntrPermCycle (
                 (Int)TNAM_OBJ(val), 0L );
         }
         c = INT_INTOBJ(val);
+	if (c > MAX_DEG_PERM4)
+	  ErrorQuit( "Permutation literal exceeds maximum permutation degree -- %i vs %i",
+		     c, MAX_DEG_PERM4);
+
+
 
         /* if necessary resize the permutation                             */
         if ( SIZE_OBJ(perm)/sizeof(UInt4) < c ) {

src/permutat.c

@@ -73,6 +73,7 @@
 #include        "hpc/tls.h"
 
 #include        "trans.h"
+#include        <assert.h>
 
 /****************************************************************************
 **
@@ -97,6 +98,8 @@
 */
 
 
+
+
 /****************************************************************************
 **
 *F  IMAGE(<i>,<pt>,<dg>)  . . . . . .  image of <i> under <pt> of degree <dg>
@@ -147,6 +150,7 @@ Obj                     TmpPerm;
 #define  TmpPerm TLS(TmpPerm)
 
 static void UseTmpPerm( UInt size) {
+  assert(size <= MAX_DEG_PERM4);
   if (TmpPerm == (Obj)0)
     TmpPerm  = NewBag(T_PERM4, size);
   else if (SIZE_BAG(TmpPerm) < size)
@@ -2562,6 +2566,10 @@ Obj             FuncPermList (
 
         degPerm = LEN_LIST( list );
 
+	if (degPerm > MAX_DEG_PERM4)
+	  ErrorMayQuit("PermList: list length %i exceeds maximum permutation degree %i\n",
+		       degPerm, MAX_DEG_PERM4);
+
         /* make sure that the global buffer bag is large enough for checkin*/
 	UseTmpPerm(degPerm*sizeof(UInt4));
 
@@ -3722,6 +3730,9 @@ Obj             FuncSHIFTED_PERM (
   if (deg<0) deg=0; /* everything shift away */
 
   if (deg>65536) {
+    if (deg > MAX_DEG_PERM4)
+      ErrorMayQuit("SHIFTED_PERM: Shift would make permutation degree %i bigger than limit (%i)",
+		   deg, MAX_DEG_PERM4);
     to=4;
     new=NEW_PERM4(deg);
     ptTo2=ADDR_PERM2(new); /* please compiler */
@@ -4038,8 +4049,7 @@ Obj             FunSmallestImgTuplePerm (
     UInt                lmp;            /* largest moved point             */
     UInt                i, k;           /* loop variables                  */
 
-    res = 2UL << 30; /* ``infty''. 
-                        We have no permutations on over 2^28 points        */
+    res = MAX_DEG_PERM4; /* ``infty''. */
     /* handle small permutations                                           */
     if ( TNUM_OBJ(perm) == T_PERM2 ) {
 
@@ -4455,6 +4465,9 @@ Obj Array2Perm (
                     "you can replace <expr> via 'return <expr>;'" );
             }
             c = INT_INTOBJ(val);
+	    if (c > MAX_DEG_PERM4)
+	      ErrorMayQuit( "Permutation literal exceeds maximum permutatuion degree -- %i vs %i",
+			    c, MAX_DEG_PERM4);
 
             /* if necessary resize the permutation                         */
             if ( SIZE_OBJ(perm)/sizeof(UInt4) < c ) {

src/permutat.h

@@ -32,6 +32,13 @@
 
 #define IMAGE(i,pt,dg)  (((i) < (dg)) ? (pt)[(i)] : (i))
 
+#ifdef SYS_IS_64_BIT
+#define MAX_DEG_PERM4 ((1L<<32)-1)
+#else
+#define MAX_DEG_PERM4 ((1L<<28)-1)
+#endif
+
+
 /****************************************************************************
 **
 *V  IdentityPerm  . . . . . . . . . . . . . . . . . . .  identity permutation