Index: types/Type.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3front/src/types/Type.m3,v
retrieving revision 1.8
diff -u -r1.8 Type.m3
--- types/Type.m3	4 May 2008 11:03:49 -0000	1.8
+++ types/Type.m3	10 Jan 2010 11:23:16 -0000
@@ -539,13 +539,19 @@
 
 PROCEDURE IsAssignable (a, b: T): BOOLEAN =
   VAR i, e: T;  min_a, max_a, min_b, max_b, min, max: Target.Int;
+      baseA, baseB: T;
   BEGIN
     IF IsEqual (a, b, NIL) OR IsSubtype (b, a) THEN
       RETURN TRUE;
     ELSIF IsOrdinal (a) THEN
       (* ordinal types:  OK if there is a common supertype
-         and they have at least one member in common. *)
-      IF IsEqual (Base(a), Base(b), NIL)
+         and they have at least one member in common;
+         OK if assigning INTEGER to LONGINT or vice versa *)
+      baseA := Base (a);
+      baseB := Base (b);
+      IF (IsEqual (baseA, baseB, NIL)
+            OR (IsEqual (baseA, Int.T, NIL) AND IsEqual (baseB, LInt.T, NIL))
+            OR (IsEqual (baseB, Int.T, NIL) AND IsEqual (baseA, LInt.T, NIL)))
          AND GetBounds (a, min_a, max_a)
          AND GetBounds (b, min_b, max_b) THEN
         (* check for a non-empty intersection *)
Index: src/os/Common/File.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/os/Common/File.i3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 File.i3
--- src/os/Common/File.i3	24 Jan 2001 12:24:16 -0000	1.1.1.1
+++ src/os/Common/File.i3	10 Jan 2010 11:23:29 -0000
@@ -31,7 +31,7 @@
   Status = RECORD
     type: Type;
     modificationTime: Time.T;
-    size: CARDINAL
+    size: LONGINT
   END;
   Type = Atom.T;
 
Index: src/rw/AutoFlushWr.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/rw/AutoFlushWr.m3,v
retrieving revision 1.5
diff -u -r1.5 AutoFlushWr.m3
--- src/rw/AutoFlushWr.m3	31 Aug 2009 09:58:08 -0000	1.5
+++ src/rw/AutoFlushWr.m3	10 Jan 2010 11:23:29 -0000
@@ -107,7 +107,7 @@
     RETURN wr
   END Init;
 
-PROCEDURE Seek (wr: T; n: CARDINAL) RAISES {Failure, Alerted} =
+PROCEDURE Seek (wr: T; n: LONGINT) RAISES {Failure, Alerted} =
   VAR wasEmpty := FALSE;
   BEGIN
     WrClass.Lock(wr.child);
@@ -153,7 +153,7 @@
     END;
   END Flush;
 
-PROCEDURE Length (wr: T): CARDINAL RAISES {Failure, Alerted} =
+PROCEDURE Length (wr: T): LONGINT RAISES {Failure, Alerted} =
   VAR res: CARDINAL;
   BEGIN
     WrClass.Lock(wr.child);
Index: src/rw/FileRd.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/rw/FileRd.m3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 FileRd.m3
--- src/rw/FileRd.m3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ src/rw/FileRd.m3	10 Jan 2010 11:23:29 -0000
@@ -64,7 +64,7 @@
 
 EXCEPTION Error; <*FATAL Error*>
 
-PROCEDURE Seek (rd: T; pos: CARDINAL; dontBlock: BOOLEAN): RdClass.SeekResult
+PROCEDURE Seek (rd: T; pos: LONGINT; dontBlock: BOOLEAN): RdClass.SeekResult
   RAISES {Rd.Failure} =
   VAR n: INTEGER; BEGIN
     TRY
@@ -88,7 +88,7 @@
     END;
     IF n < 0 THEN RETURN RdClass.SeekResult.WouldBlock END;
     IF n = 0 THEN RETURN RdClass.SeekResult.Eof END;
-    INC(rd.hi, n);
+    INC(rd.hi, VAL(n, LONGINT));
     RETURN RdClass.SeekResult.Ready
   END Seek;
 
@@ -99,10 +99,10 @@
     TRY
       WHILE toRead # 0 DO
         IF rd.cur # rd.hi THEN
-          VAR n := MIN(toRead, rd.hi-rd.cur); BEGIN
+          VAR n := MIN(toRead, ORD(rd.hi-rd.cur)); BEGIN
             SUBARRAY(a, NUMBER(a) - toRead, n) := 
-              SUBARRAY(rd.buff^, rd.cur-rd.lo, n);
-            INC(rd.cur, n);
+              SUBARRAY(rd.buff^, ORD(rd.cur-rd.lo), n);
+            INC(rd.cur, VAL(n, LONGINT));
             DEC(toRead, n)
           END
         ELSE
@@ -113,13 +113,13 @@
               n := rd.sourceH.read(
                     SUBARRAY(LOOPHOLE(ADR(rd.buff[0]), ByteArrayPtr)^, 
                               0, MIN (NUMBER(rd.buff^), BIG)));
-              INC(rd.hi, n)
+              INC(rd.hi, VAL(n, LONGINT));
             ELSE
               n := rd.sourceH.read(
                     SUBARRAY(LOOPHOLE(ADR(a[NUMBER(a)-toRead]), ByteArrayPtr)^,
                               0, MIN (toRead, BIG)));
               DEC(toRead, n);
-              INC(rd.cur, n);
+              INC(rd.cur, VAL(n, LONGINT));
               rd.lo := rd.cur;
               rd.hi := rd.cur
             END;
@@ -133,7 +133,7 @@
     RETURN NUMBER(a) - toRead;
   END GetSub;
 
-PROCEDURE Length(rd: T): INTEGER RAISES {Rd.Failure} =
+PROCEDURE Length(rd: T): LONGINT RAISES {Rd.Failure} =
   BEGIN
     TRY
       IF rd.seekable THEN
Index: src/rw/FileWr.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/rw/FileWr.m3,v
retrieving revision 1.2
diff -u -r1.2 FileWr.m3
--- src/rw/FileWr.m3	31 Aug 2009 09:01:00 -0000	1.2
+++ src/rw/FileWr.m3	10 Jan 2010 11:23:29 -0000
@@ -71,13 +71,13 @@
       wr.buffered := buffered;
     END;
     wr.lo := wr.cur;
-    wr.hi := wr.cur + NUMBER(wr.buff^);
+    wr.hi := wr.cur + VAL(NUMBER(wr.buff^), LONGINT);
     RETURN wr
   END Init;
 
 EXCEPTION Error; <*FATAL Error*>
 
-PROCEDURE Seek(wr: T; n: CARDINAL) RAISES {Wr.Failure} =
+PROCEDURE Seek(wr: T; n: LONGINT) RAISES {Wr.Failure} =
   BEGIN
     IF NOT wr.seekable AND n # wr.hi THEN
         RTIO.PutText("FileWr.Seek:wr.seekable=" & Fmt.Bool(wr.seekable) & ";n=" & Fmt.Int(n) & ";wr.hi=" & Fmt.Int(wr.hi) & "\n");
@@ -94,14 +94,14 @@
                      RegularFile.Origin.Beginning, n);
         wr.cur := n;
         wr.lo := n;
-        wr.hi := n + NUMBER(wr.buff^);
+        wr.hi := n + VAL(NUMBER(wr.buff^), LONGINT);
       END;
     EXCEPT
     | OSError.E(code) =>  RAISE Wr.Failure(code)
     END
   END Seek;
 
-PROCEDURE Length(wr: T): CARDINAL RAISES {Wr.Failure} =
+PROCEDURE Length(wr: T): LONGINT RAISES {Wr.Failure} =
   BEGIN
     TRY
       IF wr.seekable THEN
@@ -124,7 +124,7 @@
   END Flush;
 
 PROCEDURE EmptyBuffer(wr: T) RAISES {OSError.E} =
-  VAR buffered := wr.cur - wr.lo;  start := 0;  n: INTEGER;
+  VAR buffered := ORD(wr.cur - wr.lo);  start := 0;  n: INTEGER;
   BEGIN
     WHILE (buffered > 0) DO
       n := MIN (buffered, BIG);
@@ -135,21 +135,21 @@
     END;
     (* the file position is now wr.cur *)
     wr.lo := wr.cur;
-    wr.hi := wr.cur + NUMBER(wr.buff^);
+    wr.hi := wr.cur + VAL(NUMBER(wr.buff^), LONGINT);
   END EmptyBuffer;
 
 PROCEDURE PutString (wr: T; READONLY buf: ARRAY OF CHAR)
   RAISES {Wr.Failure} =
   VAR toWrite, start, n: INTEGER;
   BEGIN
-    IF NUMBER(buf) <= wr.hi - wr.cur THEN
+    IF NUMBER(buf) <= ORD(wr.hi - wr.cur) THEN
       SUBARRAY(wr.buff^, wr.cur - wr.lo, NUMBER(buf)) := buf;
-      INC(wr.cur, NUMBER(buf));
+      INC(wr.cur, VAL(NUMBER(buf), LONGINT));
     ELSE
       Flush(wr);
       IF 2 * NUMBER(buf) < NUMBER(wr.buff^) THEN
         SUBARRAY(wr.buff^, 0, NUMBER(buf)) := buf;
-        INC(wr.cur, NUMBER(buf));
+        INC(wr.cur, VAL(NUMBER(buf), LONGINT));
       ELSE
         TRY
           toWrite := NUMBER (buf);
@@ -161,9 +161,9 @@
             DEC (toWrite, n);
             INC (start, n);
           END;
-          INC(wr.cur, NUMBER(buf));
+          INC(wr.cur, VAL(NUMBER(buf), LONGINT));
           wr.lo := wr.cur;
-          wr.hi := wr.cur + NUMBER(wr.buff^);
+          wr.hi := wr.cur + VAL(NUMBER(wr.buff^), LONGINT);
         EXCEPT
         | OSError.E (code) => RAISE Wr.Failure(code);
         END
Index: src/rw/NullRd.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/rw/NullRd.m3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 NullRd.m3
--- src/rw/NullRd.m3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ src/rw/NullRd.m3	10 Jan 2010 11:23:29 -0000
@@ -32,14 +32,14 @@
     RETURN rd;
   END Init;
 
-PROCEDURE Seek (<*UNUSED*> rd: T; <*UNUSED*> pos: CARDINAL;
+PROCEDURE Seek (<*UNUSED*> rd: T; <*UNUSED*> pos: LONGINT;
                                   <*UNUSED*> dontBlock: BOOLEAN):
   RdClass.SeekResult =
   BEGIN
     RETURN (RdClass.SeekResult.Eof);
   END Seek;
 
-PROCEDURE Length(<*UNUSED*> rd: T): INTEGER =
+PROCEDURE Length(<*UNUSED*> rd: T): LONGINT =
   BEGIN RETURN 0; END Length;
 
 BEGIN
Index: src/rw/NullWr.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/rw/NullWr.m3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 NullWr.m3
--- src/rw/NullWr.m3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ src/rw/NullWr.m3	10 Jan 2010 11:23:29 -0000
@@ -37,16 +37,16 @@
     RETURN wr;
   END Init;
 
-PROCEDURE Seek (wr: T; n: CARDINAL) =
+PROCEDURE Seek (wr: T; n: LONGINT) =
   BEGIN
     wr.lo := n;
     wr.cur := n;
-    wr.hi := n + BuffSize;
+    wr.hi := n + VAL(BuffSize, LONGINT);
   END Seek;
 
 PROCEDURE PutString (wr: T; READONLY a: ARRAY OF CHAR) =
   BEGIN
-    Seek(wr, wr.cur + NUMBER(a));
+    Seek(wr, wr.cur + VAL(NUMBER(a), LONGINT));
   END PutString;
 
 BEGIN
Index: src/rw/Rd.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/rw/Rd.i3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 Rd.i3
--- src/rw/Rd.i3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ src/rw/Rd.i3	10 Jan 2010 11:23:29 -0000
@@ -299,7 +299,7 @@
    A line break is either {\tt \char'42\char'134n\char'42} or {\tt
    \char'42\char'134r\char'134n\char'42}. *)
 
-PROCEDURE Seek(rd: T; n: CARDINAL) RAISES {Failure, Alerted};
+PROCEDURE Seek(rd: T; n: LONGINT) RAISES {Failure, Alerted};
 (* This is equivalent to: *)
 (*
 | IF closed(rd) OR NOT seekable(rd) THEN
@@ -315,14 +315,14 @@
    closed.  This leaves "rd" closed even if it raises an exception,
    and is a no-op if "rd" is closed. *)
 
-PROCEDURE Index(rd: T): CARDINAL RAISES {};
+PROCEDURE Index(rd: T): LONGINT RAISES {};
 (* This is equivalent to: *)
 (*
 | IF closed(rd) THEN `Cause checked runtime error` END;
 | RETURN cur(rd)
 *)
 
-PROCEDURE Length(rd: T): INTEGER RAISES {Failure, Alerted};
+PROCEDURE Length(rd: T): LONGINT RAISES {Failure, Alerted};
 (* This is equivalent to: *)
 (*
 | IF closed(rd) THEN
Index: src/rw/Rd.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/rw/Rd.m3,v
retrieving revision 1.2
diff -u -r1.2 Rd.m3
--- src/rw/Rd.m3	31 Aug 2009 08:47:43 -0000	1.2
+++ src/rw/Rd.m3	10 Jan 2010 11:23:29 -0000
@@ -41,7 +41,7 @@
   (* rd is locked *)
   VAR res: CHAR; BEGIN
     IF rd.cur = rd.hi THEN DoSeek(rd) END;
-    res := rd.buff[rd.st + (rd.cur - rd.lo)];
+    res := rd.buff[rd.st + ORD(rd.cur - rd.lo)];
     INC(rd.cur);
     RETURN res
   END FastGetChar;
@@ -88,16 +88,16 @@
         RETURN FALSE;
       END;
     END;
-    c1 := rd.buff[rd.st + (rd.cur - rd.lo)];
+    c1 := rd.buff[rd.st + ORD(rd.cur - rd.lo)];
     INC(rd.cur);
 
     IF rd.cur # rd.hi THEN
-      c2 := rd.buff[rd.st + (rd.cur - rd.lo)];
+      c2 := rd.buff[rd.st + ORD(rd.cur - rd.lo)];
       INC(rd.cur);
     ELSIF rd.seek(rd.cur, FALSE) = SeekResult.Eof THEN
       c2 := '\000';
     ELSE
-      c2 := rd.buff[rd.st + (rd.cur - rd.lo)];
+      c2 := rd.buff[rd.st + ORD(rd.cur - rd.lo)];
       INC(rd.cur);
     END;
 
@@ -149,11 +149,11 @@
         IF rd.seek(rd.cur, FALSE) = SeekResult.Eof THEN EXIT END
       END;
       (* rd.lo <= rd.cur < rd.hi *)
-      VAR n := MIN(rd.hi - rd.cur, NUMBER(str) - i); BEGIN
+      VAR n := MIN(ORD(rd.hi - rd.cur), NUMBER(str) - i); BEGIN
         SUBARRAY(str, i, n) :=
-          SUBARRAY(rd.buff^, rd.cur - rd.lo + rd.st, n);
+          SUBARRAY(rd.buff^, ORD(rd.cur - rd.lo) + rd.st, n);
         INC(i, n);
-        INC(rd.cur, n)
+        INC(rd.cur, VAL(n, LONGINT))
       END
     END;
     RETURN i
@@ -206,11 +206,11 @@
         IF rd.closed THEN Die() END;
         IF rd.seek(rd.cur, TRUE) = SeekResult.Eof THEN RETURN 1 END
       END;
-      RETURN rd.hi - rd.cur;
+      RETURN ORD(rd.hi - rd.cur);
     END
   END CharsReady;
 
-PROCEDURE Index(rd: T): CARDINAL =
+PROCEDURE Index(rd: T): LONGINT =
   BEGIN
     LOCK rd DO
       IF rd.closed THEN Die() END;
@@ -218,7 +218,7 @@
     END
   END Index;
 
-PROCEDURE Length(rd: T): INTEGER
+PROCEDURE Length(rd: T): LONGINT
   RAISES {Failure, Alerted} =
   BEGIN
     LOCK rd DO
@@ -227,7 +227,7 @@
     END
   END Length;
 
-PROCEDURE Seek(rd: T; n: CARDINAL)
+PROCEDURE Seek(rd: T; n: LONGINT)
   RAISES {Failure, Alerted} =
   BEGIN
     LOCK rd DO
@@ -275,17 +275,17 @@
         END;
         (* rd is ready *)
         VAR
-          n := MIN (rd.hi, rd.cur + NUMBER (str) - i) - rd.lo + rd.st;
-          j := rd.cur - rd.lo + rd.st;
+          n := ORD(MIN (rd.hi, rd.cur + VAL(NUMBER (str) - i, LONGINT)) - rd.lo + VAL(rd.st, LONGINT));
+          j := ORD(rd.cur - rd.lo) + rd.st;
         BEGIN
           WHILE (j # n) AND (rd.buff[j] # '\n') DO INC (j) END;
           VAR
-            rd_cur := rd.cur - rd.lo + rd.st;
+            rd_cur := ORD(rd.cur - rd.lo) + rd.st;
             k := j - rd_cur;
           BEGIN
             SUBARRAY (str, i, k) := SUBARRAY (rd.buff^, rd_cur, k);
             INC (i, k);
-            INC (rd.cur, k);
+            INC (rd.cur, VAL(k, LONGINT));
           END;
           IF (j # n) THEN
             (* we found a newline *)
@@ -320,16 +320,16 @@
     LOCK rd DO
       IF rd.closed THEN Die () END;
 
-      IF (rd.lo <= rd.cur) AND (rd.hi - rd.cur >= length) THEN
+      IF (rd.lo <= rd.cur) AND (ORD(rd.hi - rd.cur) >= length) THEN
         (* the bytes we need are already in the buffer *)
         txt := Text.FromChars (
-                 SUBARRAY (rd.buff^, rd.cur - rd.lo + rd.st, length));
-        INC (rd.cur, length);
+                 SUBARRAY (rd.buff^, ORD(rd.cur - rd.lo) + rd.st, length));
+        INC (rd.cur, VAL(length, LONGINT));
 
       ELSIF (NOT rd.intermittent) THEN
         (* we know how long the reader is... *)
         VAR
-          len := MIN (length, rd.length () - rd.cur);
+          len := MIN (length, ORD(rd.length () - rd.cur));
           txt8 := Text8.Create (len);
         BEGIN
           txt := txt8;
@@ -429,21 +429,21 @@
           END;
         END;
         (* rd is ready *)
-        n := rd.hi - rd.lo + rd.st;
-        j := rd.cur - rd.lo + rd.st;
+        n := ORD(rd.hi - rd.lo) + rd.st;
+        j := ORD(rd.cur - rd.lo) + rd.st;
         WHILE (j # n) AND rd.buff[j] # '\n' DO INC(j) END;
-        VAR rd_cur := rd.cur - rd.lo + rd.st;
+        VAR rd_cur := ORD(rd.cur - rd.lo) + rd.st;
             len := j - rd_cur;
          BEGIN
           IF len >= 1 AND j # n  AND rd.buff[j-1] = '\r' THEN
             (* segment ends in \r\n *)
             txt := txt & Text.FromChars (SUBARRAY (rd.buff^, rd_cur, len-1));
-            INC (rd.cur, len+1);
+            INC (rd.cur, VAL(len+1, LONGINT));
             RETURN txt;
           ELSIF j # n THEN
             (* segment ends in \n *)
             txt := txt & Text.FromChars (SUBARRAY (rd.buff^, rd_cur, len));
-            INC (rd.cur, len+1);
+            INC (rd.cur, VAL(len+1, LONGINT));
             IF NOT Text.Empty(txt) AND
                  Text.GetChar(txt, Text.Length(txt)-1) = '\r' THEN
               txt := Text.Sub(txt, 0, Text.Length(txt)-1)
@@ -452,7 +452,7 @@
           ELSE
             (* segment does not contain line break *)
             txt := txt & Text.FromChars (SUBARRAY (rd.buff^, rd_cur, len));
-            INC (rd.cur, len);
+            INC (rd.cur, VAL(len, LONGINT));
           END;
         END;
       END; (* LOOP *)
@@ -526,7 +526,7 @@
     Thread.Release (rd)
   END Unlock;
 
-PROCEDURE LengthDefault (<*UNUSED*> rd: T): INTEGER =
+PROCEDURE LengthDefault (<*UNUSED*> rd: T): LONGINT =
   BEGIN
     <*NOWARN*> Die()
   END LengthDefault;
Index: src/rw/RdClass.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/rw/RdClass.i3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 RdClass.i3
--- src/rw/RdClass.i3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ src/rw/RdClass.i3	10 Jan 2010 11:23:29 -0000
@@ -32,16 +32,16 @@
     Private BRANDED OBJECT
       buff         : REF ARRAY OF CHAR;
       st           : CARDINAL;           (* index into buff *)
-      lo, hi, cur  : CARDINAL            := 0; (* indexes into src(rd) *)
+      lo, hi, cur  : LONGINT := 0;       (* indexes into src(rd) *)
       closed: BOOLEAN := TRUE;   (* init method of the subtype should set
                                     this to FALSE *)
       seekable, intermittent: BOOLEAN;
     METHODS
-      seek   (n: CARDINAL; dontBlock: BOOLEAN): SeekResult
+      seek   (n: LONGINT; dontBlock: BOOLEAN): SeekResult
                          RAISES {Failure, Alerted};
       getSub (VAR a: ARRAY OF CHAR): CARDINAL
                          RAISES {Failure, Alerted} := GetSubDefault;
-      length (): INTEGER RAISES {Failure, Alerted} := LengthDefault;
+      length (): LONGINT RAISES {Failure, Alerted} := LengthDefault;
       close  () RAISES {Failure, Alerted}          := CloseDefault;
     END;
 
@@ -160,7 +160,7 @@
    achieve greater efficiency; for example, by copying directly
    from the source of the reader into "str". *)
 
-PROCEDURE LengthDefault(rd: Rd.T): INTEGER RAISES {Failure, Alerted};
+PROCEDURE LengthDefault(rd: Rd.T): LONGINT RAISES {Failure, Alerted};
 (* The procedure LengthDefault causes a checked runtime error; this
 represents an error in the (non-intermittent) class implementation. *)
 
Index: src/rw/RdCopy.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/rw/RdCopy.m3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 RdCopy.m3
--- src/rw/RdCopy.m3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ src/rw/RdCopy.m3	10 Jan 2010 11:23:29 -0000
@@ -40,11 +40,11 @@
     TRY
       LOOP
         IF Thread.TestAlert() THEN RAISE Thread.Alerted END; (* mhb: 7/7/95 *)
-        WITH len = MIN(length - i, rd.hi - rd.cur) DO
+        WITH len = MIN(length - i, ORD(rd.hi - rd.cur)) DO
           IF len > 0 THEN
-            proc(SUBARRAY(rd.buff^, rd.st + rd.cur - rd.lo, len));
+            proc(SUBARRAY(rd.buff^, rd.st + ORD(rd.cur - rd.lo), len));
             INC(i, len);
-            INC(rd.cur, len);
+            INC(rd.cur, VAL(len, LONGINT));
           END;
         END;
         IF i = length OR rd.seek(rd.cur, FALSE) = RdClass.SeekResult.Eof THEN
@@ -68,12 +68,12 @@
     WrClass.Lock(wr);
     TRY
       LOOP
-        WITH len = MIN(length - i, wr.hi - wr.cur) DO
+        WITH len = MIN(length - i, ORD(wr.hi - wr.cur)) DO
           IF len > 0 THEN
             WITH res = proc(
-                         SUBARRAY(wr.buff^, wr.st + wr.cur - wr.lo, len)) DO
+                         SUBARRAY(wr.buff^, wr.st + ORD(wr.cur - wr.lo), len)) DO
               INC(i, res);
-              INC(wr.cur, res);
+              INC(wr.cur, VAL(res, LONGINT));
               IF res # len THEN EXIT; END;
             END;
           END;
Index: src/rw/RdUtils.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/rw/RdUtils.m3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 RdUtils.m3
--- src/rw/RdUtils.m3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ src/rw/RdUtils.m3	10 Jan 2010 11:23:29 -0000
@@ -84,7 +84,7 @@
       IF Rd.EOF(rd) THEN RETURN -1; END;
       WITH c = Rd.GetChar(rd) DO
         IF c = pattern OR (canonicalize # NIL AND canonicalize(c) = uc) THEN
-          RETURN Rd.Index(rd) - 1
+          RETURN Rd.Index(rd) - 1L
         END
       END
     END
Index: src/rw/TextRd.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/rw/TextRd.m3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 TextRd.m3
--- src/rw/TextRd.m3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ src/rw/TextRd.m3	10 Jan 2010 11:23:29 -0000
@@ -39,7 +39,7 @@
 
 PROCEDURE New(t: TEXT): T = BEGIN RETURN NEW(T).init(t); END New;
 
-PROCEDURE Seek (rd: T; pos: CARDINAL;
+PROCEDURE Seek (rd: T; pos: LONGINT;
                <*UNUSED*> dontBlock: BOOLEAN): RdClass.SeekResult =
   BEGIN
     IF pos >= rd.hi THEN
@@ -50,7 +50,7 @@
       RETURN RdClass.SeekResult.Ready; END;
   END Seek;
 
-PROCEDURE Length (rd: T): INTEGER =
+PROCEDURE Length (rd: T): LONGINT =
   BEGIN
     RETURN rd.hi;
   END Length;
Index: src/rw/TextWr.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/rw/TextWr.m3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 TextWr.m3
--- src/rw/TextWr.m3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ src/rw/TextWr.m3	10 Jan 2010 11:23:29 -0000
@@ -58,19 +58,19 @@
 
 PROCEDURE New(): T = BEGIN RETURN NEW(T).init(); END New;
 
-PROCEDURE Length (wr: T): CARDINAL RAISES {} =
+PROCEDURE Length (wr: T): LONGINT RAISES {} =
   BEGIN
-    wr.max_len := MAX (wr.max_len, wr.cur);
+    wr.max_len := MAX (wr.max_len, ORD(wr.cur));
     RETURN wr.max_len;
   END Length;
 
-PROCEDURE Seek(wr: T; n: CARDINAL) RAISES {} =
+PROCEDURE Seek(wr: T; n: LONGINT) RAISES {} =
   BEGIN
     (* capture the current length of the writer *)
-    wr.max_len := MAX (wr.max_len, wr.cur);
+    wr.max_len := MAX (wr.max_len, ORD(wr.cur));
 
     (* make sure we don't seek beyond the end of the writer *)
-    n := MIN (n, wr.max_len);
+    n := VAL (MIN (ORD(n), wr.max_len), LONGINT);
 
     IF (n < wr.lo) OR (wr.hi <= n) THEN GotoBuffer (wr, n) END;
     wr.cur := n;
@@ -87,7 +87,7 @@
     wr.cur_buf := buf;
     wr.buff    := wr.buffers [buf];
     wr.lo      := buf * BufferSize;
-    wr.hi      := wr.lo + BufferSize;
+    wr.hi      := wr.lo + VAL(BufferSize, LONGINT);
   END GotoBuffer;
 
 PROCEDURE ExpandBufferPool (wr: T) =
@@ -111,7 +111,7 @@
     WrClass.Lock(wr);
     TRY
       (* capture the current length of the writer *)
-      len := MAX (wr.max_len, wr.cur);
+      len := MAX (wr.max_len, ORD(wr.cur));
 
       (* allocate the result and count the buffersp *)
       result := Text8.Create (len);
Index: src/rw/UnsafeWr.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/rw/UnsafeWr.i3,v
retrieving revision 1.2
diff -u -r1.2 UnsafeWr.i3
--- src/rw/UnsafeWr.i3	31 Aug 2009 09:58:08 -0000	1.2
+++ src/rw/UnsafeWr.i3	10 Jan 2010 11:23:29 -0000
@@ -107,13 +107,13 @@
 PROCEDURE FastClose (wr: Wr.T) RAISES {Failure, Alerted};
 (* Like Wr.Close *)
 
-PROCEDURE FastSeek(wr: Wr.T; n: CARDINAL) RAISES {Failure, Alerted};
+PROCEDURE FastSeek(wr: Wr.T; n: LONGINT) RAISES {Failure, Alerted};
 (* Like Wr.Seek *)
 
 PROCEDURE FastFlush(wr: Wr.T) RAISES {Failure, Alerted};
 (* Like Wr.Flush *)
 
-PROCEDURE FastLength(wr: Wr.T): CARDINAL RAISES {Failure, Alerted};
+PROCEDURE FastLength(wr: Wr.T): LONGINT RAISES {Failure, Alerted};
 (* Like Wr.Length *)
 
 END UnsafeWr.
Index: src/rw/Wr.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/rw/Wr.i3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 Wr.i3
--- src/rw/Wr.i3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ src/rw/Wr.i3	10 Jan 2010 11:23:29 -0000
@@ -176,7 +176,7 @@
 | IF NOT buffered(wr) THEN Flush(wr) END
 *)
 
-PROCEDURE Seek(wr: T; n: CARDINAL) RAISES {Failure, Alerted};
+PROCEDURE Seek(wr: T; n: LONGINT) RAISES {Failure, Alerted};
 (* Set the current position of "wr" to "n".  This is an error if "wr"
    is closed. More precisely, this is equivalent to: *)
 (*
@@ -199,8 +199,8 @@
    even if it raises an exception, and is a no-op if "wr" is closed.
    *)
 
-PROCEDURE Length(wr: T): CARDINAL RAISES {Failure, Alerted};
-PROCEDURE Index(wr: T): CARDINAL RAISES {};
+PROCEDURE Length(wr: T): LONGINT RAISES {Failure, Alerted};
+PROCEDURE Index(wr: T): LONGINT RAISES {};
 PROCEDURE Seekable(wr: T): BOOLEAN RAISES {};
 PROCEDURE Closed(wr: T): BOOLEAN RAISES {};
 PROCEDURE Buffered(wr: T): BOOLEAN RAISES {};
Index: src/rw/Wr.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/rw/Wr.m3,v
retrieving revision 1.4
diff -u -r1.4 Wr.m3
--- src/rw/Wr.m3	31 Aug 2009 09:58:08 -0000	1.4
+++ src/rw/Wr.m3	10 Jan 2010 11:23:29 -0000
@@ -43,7 +43,7 @@
 PROCEDURE FastPutChar (wr: T; ch: CHAR) RAISES {Failure, Alerted} =
   BEGIN
     IF wr.cur = wr.hi THEN DoSeek(wr) END;
-    wr.buff[wr.st + wr.cur - wr.lo] := ch;
+    wr.buff[wr.st + ORD(wr.cur - wr.lo)] := ch;
     INC(wr.cur);
     IF NOT wr.buffered THEN wr.flush(); END;
   END FastPutChar;
@@ -70,10 +70,10 @@
     c2 := VAL (Word.Extract (ORD (ch), 8, 8), CHAR);
   BEGIN
     IF wr.cur = wr.hi THEN DoSeek(wr) END;
-    wr.buff[wr.st + wr.cur - wr.lo] := c1;
+    wr.buff[wr.st + ORD(wr.cur - wr.lo)] := c1;
     INC(wr.cur);
     IF wr.cur = wr.hi THEN DoSeek(wr) END;
-    wr.buff[wr.st + wr.cur - wr.lo] := c2;
+    wr.buff[wr.st + ORD(wr.cur - wr.lo)] := c2;
     INC(wr.cur);
   END PutWC;
 
@@ -174,14 +174,14 @@
     l               := NUMBER(a);
   BEGIN
     WHILE (l > 0) DO
-      VAR n := MIN(wr.hi - wr.cur, l);
+      VAR n := MIN(ORD(wr.hi - wr.cur), l);
       BEGIN
         IF n > 0 THEN
-          SUBARRAY(wr.buff^, wr.st + wr.cur - wr.lo, n) :=
+          SUBARRAY(wr.buff^, wr.st + ORD(wr.cur - wr.lo), n) :=
                      SUBARRAY(a, start, n);
           INC(start, n);
           DEC(l, n);
-          INC(wr.cur, n);
+          INC(wr.cur, VAL(n, LONGINT));
         END;
       END;
       IF l > 0 THEN wr.seek(wr.cur) END;
@@ -225,13 +225,13 @@
   END FastPutLongReal;
 
    
-PROCEDURE FastSeek(wr: T; n: CARDINAL) RAISES {Failure, Alerted} =
+PROCEDURE FastSeek(wr: T; n: LONGINT) RAISES {Failure, Alerted} =
   BEGIN
     IF wr.closed OR NOT wr.seekable THEN Die() END;
     wr.seek(n);
   END FastSeek;
    
-PROCEDURE Seek(wr: T; n: CARDINAL) RAISES {Failure, Alerted} =
+PROCEDURE Seek(wr: T; n: LONGINT) RAISES {Failure, Alerted} =
   BEGIN
     LOCK wr DO
       FastSeek(wr, n);
@@ -251,7 +251,7 @@
     END;
   END Flush;
 
-PROCEDURE Index(wr: T): CARDINAL RAISES {} =
+PROCEDURE Index(wr: T): LONGINT RAISES {} =
   BEGIN 
     LOCK wr DO 
       IF wr.closed THEN Die() END;
@@ -259,13 +259,13 @@
     END
   END Index;
 
-PROCEDURE FastLength (wr: T): CARDINAL RAISES {Failure, Alerted} =
+PROCEDURE FastLength (wr: T): LONGINT RAISES {Failure, Alerted} =
   BEGIN
     IF wr.closed THEN Die() END;
     RETURN wr.length ();
   END FastLength;
 
-PROCEDURE Length (wr: T): CARDINAL RAISES {Failure, Alerted} =
+PROCEDURE Length (wr: T): LONGINT RAISES {Failure, Alerted} =
   BEGIN
     LOCK wr DO
       RETURN FastLength(wr);
@@ -324,7 +324,7 @@
   BEGIN
   END FlushDefault;
 
-PROCEDURE LengthDefault(wr: T): CARDINAL RAISES {} =
+PROCEDURE LengthDefault(wr: T): LONGINT RAISES {} =
   BEGIN
     RETURN wr.cur;
   END LengthDefault;
Index: src/rw/WrClass.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/rw/WrClass.i3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 WrClass.i3
--- src/rw/WrClass.i3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ src/rw/WrClass.i3	10 Jan 2010 11:23:30 -0000
@@ -82,15 +82,15 @@
   Wr.T = Private BRANDED OBJECT
            buff       : REF ARRAY OF CHAR;
            st         : CARDINAL;           (* index into buff *)
-           lo, hi, cur: CARDINAL            := 0; (* indexes into c(wr) *)
+           lo, hi, cur: LONGINT := 0;       (* indexes into c(wr) *)
            closed := TRUE;       (* Subtype's init method should set this
                                     to FALSE *)
            seekable, buffered: BOOLEAN
          METHODS
-           seek      (n: CARDINAL) RAISES {Failure, Alerted};
+           seek      (n: LONGINT) RAISES {Failure, Alerted};
            putString (READONLY a: ARRAY OF CHAR) RAISES {Failure, Alerted}
                                                          := PutStringDefault;
-           length (): CARDINAL RAISES {Failure, Alerted} := LengthDefault;
+           length (): LONGINT RAISES {Failure, Alerted}  := LengthDefault;
            flush  () RAISES {Failure, Alerted}           := FlushDefault;
            close  () RAISES {Failure, Alerted}           := CloseDefault
          END;
@@ -225,7 +225,7 @@
 PROCEDURE PutStringDefault(wr: Wr.T; READONLY a: ARRAY OF CHAR)
     RAISES {Failure, Alerted};
 
-PROCEDURE LengthDefault(wr: Wr.T): CARDINAL RAISES {};
+PROCEDURE LengthDefault(wr: Wr.T): LONGINT RAISES {};
 
 PROCEDURE CloseDefault(wr: Wr.T) RAISES {};
 
Index: src/sx/Sx.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/sx/Sx.m3,v
retrieving revision 1.1.1.2
diff -u -r1.1.1.2 Sx.m3
--- src/sx/Sx.m3	24 Jan 2001 16:48:02 -0000	1.1.1.2
+++ src/sx/Sx.m3	10 Jan 2010 11:23:30 -0000
@@ -305,7 +305,7 @@
     RETURN rd
   END Init;
 
-PROCEDURE Seek (rd: RefArrayReader; pos: CARDINAL;
+PROCEDURE Seek (rd: RefArrayReader; pos: LONGINT;
                 <* UNUSED *> dontBlock: BOOLEAN):
   RdClass.SeekResult =
   BEGIN
@@ -317,7 +317,7 @@
     END
   END Seek;
 
-PROCEDURE Length (rd: RefArrayReader): INTEGER =
+PROCEDURE Length (rd: RefArrayReader): LONGINT =
   BEGIN
     RETURN rd.hi
   END Length;
@@ -329,10 +329,10 @@
 PROCEDURE PutChar (rd: RefArrayReader; ch: CHAR)
   RAISES {ReadError} =
   BEGIN
-    IF rd.hi >= MAXLEN THEN
+    IF rd.hi >= VAL(MAXLEN, LONGINT) THEN
       RAISE ReadError("Sx: Text literal or numeric too long")
     END;
-    rd.buff[rd.hi] := ch;
+    rd.buff[ORD(rd.hi)] := ch;
     INC(rd.hi);
   END PutChar;