Index: m3-comm/events/src/EventHandle.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-comm/events/src/EventHandle.i3,v
retrieving revision 1.2
diff -u -r1.2 EventHandle.i3
--- m3-comm/events/src/EventHandle.i3	2 Dec 2001 00:20:37 -0000	1.2
+++ m3-comm/events/src/EventHandle.i3	8 Jan 2010 11:08:07 -0000
@@ -93,7 +93,7 @@
 
 TYPE 
   Public = Thread.Mutex OBJECT 
-    cur: CARDINAL;
+    cur: LONGINT;
     event: Event.T; 
     wr: EventWr.T 
   END;
Index: m3-comm/events/src/EventPort.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-comm/events/src/EventPort.m3,v
retrieving revision 1.2
diff -u -r1.2 EventPort.m3
--- m3-comm/events/src/EventPort.m3	2 Dec 2001 00:20:37 -0000	1.2
+++ m3-comm/events/src/EventPort.m3	8 Jan 2010 11:08:08 -0000
@@ -492,7 +492,7 @@
             DebugMsg(
               self.ep, "RdConnectionClosure received event "
                        & Fmt.Int(ev.hdr.rep.id) & "/" & Fmt.Int(ev.prot)
-                       & "/" & Fmt.Int(Rd.Length(self.conn.rd))
+                       & "/" & Fmt.LongInt(Rd.Length(self.conn.rd))
                        & " and added to work queue.");
           END;
         END;
Index: m3-comm/events/src/EventRd.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-comm/events/src/EventRd.m3,v
retrieving revision 1.2
diff -u -r1.2 EventRd.m3
--- m3-comm/events/src/EventRd.m3	2 Dec 2001 00:20:37 -0000	1.2
+++ m3-comm/events/src/EventRd.m3	8 Jan 2010 11:08:08 -0000
@@ -173,8 +173,8 @@
     RETURN wr;
   END ToWr;
 
-PROCEDURE GotoBuffer (rd: T;  n: INTEGER) =
-  VAR buf := n DIV BufferSize;
+PROCEDURE GotoBuffer (rd: T;  n: LONGINT) =
+  VAR buf := ORD(n DIV BufferSize);
   BEGIN
     <* ASSERT buf <= LAST (rd.buffers^) *>
     rd.cur_buf := buf;
@@ -185,12 +185,12 @@
 
 PROCEDURE New(t: EventWr.T): T = BEGIN RETURN NEW(T).init(t); END New;
 
-PROCEDURE Length (rd: T): INTEGER RAISES {} =
+PROCEDURE Length (rd: T): LONGINT RAISES {} =
   BEGIN
     RETURN rd.max_len;
   END Length;
 
-PROCEDURE Seek (rd: T; pos: CARDINAL;
+PROCEDURE Seek (rd: T; pos: LONGINT;
                <*UNUSED*> dontBlock: BOOLEAN): RdClass.SeekResult =
   BEGIN
     (* IO.Put(Fmt.F("EventRd.Seek(%s) => max=%s\n", Fmt.Unsigned(pos, 10),
@@ -205,7 +205,7 @@
       IF (pos < rd.lo) OR (rd.hi <= pos) THEN GotoBuffer (rd, pos) END;
       rd.cur := pos;
       (* IO.Put(Fmt.F("EventRd.Seek(%s) => set cur=%s and return Ready\n",
-                   Fmt.Unsigned(pos, 10), Fmt.Int(rd.cur))); *)
+                   Fmt.LongUnsigned(pos, 10), Fmt.LongInt(rd.cur))); *)
       RETURN RdClass.SeekResult.Ready; 
     END;
   END Seek;
@@ -214,7 +214,7 @@
   RAISES {Rd.Failure, Thread.Alerted} =
   VAR
     wr: EventWr.T := ToWr(erd);
-    num : INTEGER;
+    num : LONGINT;
     <*FATAL Wr.Failure *>
   BEGIN
     IF wr = NIL THEN
Index: m3-comm/events/src/EventStubLib.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-comm/events/src/EventStubLib.m3,v
retrieving revision 1.2
diff -u -r1.2 EventStubLib.m3
--- m3-comm/events/src/EventStubLib.m3	2 Dec 2001 00:20:37 -0000	1.2
+++ m3-comm/events/src/EventStubLib.m3	8 Jan 2010 11:08:08 -0000
@@ -222,9 +222,9 @@
 PROCEDURE ToProc (rd  : Rd.T;
                   proc: PROCEDURE (READONLY a: ARRAY OF CHAR) 
                           RAISES {Wr.Failure, Thread.Alerted};
-                  length: CARDINAL := LAST(CARDINAL)): CARDINAL
+                  length: LONGINT := LAST(LONGINT)): LONGINT
   RAISES {Wr.Failure, Rd.Failure, Thread.Alerted} =
-  VAR i := 0;
+  VAR i := 0L;
   BEGIN
     (*RdClass.Lock(rd);*)
     EVAL rd.seek(0, FALSE);                   (* reset so we read it all! *)
@@ -232,7 +232,7 @@
       LOOP
         WITH len = MIN(length - i, 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), ORD(len)));
             INC(i, len);
             INC(rd.cur, len);
           END;
@@ -253,7 +253,7 @@
       h: UNTRACED REF MsgHeader;
       from := LOOPHOLE(ADR(ev.from), UNTRACED REF ARRAY [0..65535] OF CHAR);
       ts := LOOPHOLE(ADR(ev.ts), UNTRACED REF ARRAY [0..65535] OF CHAR);
-      count: INTEGER := 0;
+      count := 0L;
 
     PROCEDURE PutString (READONLY a: ARRAY OF CHAR)
       RAISES {Wr.Failure, Thread.Alerted} =
@@ -263,7 +263,7 @@
 
   BEGIN
     LOCK wr DO
-      h := LOOPHOLE(ADR(wr.buff[wr.st + wr.cur - wr.lo]),
+      h := LOOPHOLE(ADR(wr.buff[wr.st + ORD(wr.cur - wr.lo)]),
                     UNTRACED REF MsgHeader);
 
       IF wr.hi - wr.cur < BYTESIZE(MsgHeader) THEN
@@ -308,7 +308,7 @@
         END;
       END;
     ELSE
-      WITH hdr = LOOPHOLE(ADR(rd.buff[rd.st+rd.cur-rd.lo]), 
+      WITH hdr = LOOPHOLE(ADR(rd.buff[rd.st + ORD(rd.cur - rd.lo)]),
                       UNTRACED REF MsgHeader) DO
         ev.hdr := hdr^;
         INC(rd.cur, BYTESIZE(MsgHeader));
@@ -571,7 +571,7 @@
     END;
     IF rd.cur = rd.hi THEN EVAL rd.seek(rd.cur, FALSE); END;
     IF rd.hi - rd.cur < nb THEN RaiseUnmarshalFailure(); END;
-    res := ADR(rd.buff[rd.st + rd.cur - rd.lo]);
+    res := ADR(rd.buff[rd.st + ORD(rd.cur - rd.lo)]);
     RETURN res;
   END AlignRd;
 
@@ -629,7 +629,7 @@
      *) 
     IF diff # 0 THEN INC(wr.cur, align-diff); END;
     IF wr.cur = wr.hi THEN wr.seek(wr.cur); END;
-    res := ADR(wr.buff[wr.st + wr.cur - wr.lo]);
+    res := ADR(wr.buff[wr.st + ORD(wr.cur - wr.lo)]);
     RETURN res;
   END AlignWr;
 
Index: m3-comm/events/src/EventWr.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-comm/events/src/EventWr.m3,v
retrieving revision 1.2
diff -u -r1.2 EventWr.m3
--- m3-comm/events/src/EventWr.m3	2 Dec 2001 00:20:38 -0000	1.2
+++ m3-comm/events/src/EventWr.m3	8 Jan 2010 11:08:08 -0000
@@ -135,16 +135,16 @@
 
 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);
@@ -158,8 +158,8 @@
     Seek(wr, wr.cur);
   END Flush;
 
-PROCEDURE GotoBuffer (wr: T;  n: INTEGER) =
-  VAR buf := n DIV BufferSize;
+PROCEDURE GotoBuffer (wr: T;  n: LONGINT) =
+  VAR buf := ORD(n DIV BufferSize);
   BEGIN
     WHILE (buf > LAST (wr.buffers^)) DO ExpandBufferPool (wr) END;
     WHILE (wr.n_buffers <= buf) DO
@@ -198,7 +198,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 := NEW (REF ARRAY OF CHAR, len);
Index: m3-comm/netobj/src/netobjrt/StubLib.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-comm/netobj/src/netobjrt/StubLib.m3,v
retrieving revision 1.1.1.2
diff -u -r1.1.1.2 StubLib.m3
--- m3-comm/netobj/src/netobjrt/StubLib.m3	14 Jan 2001 13:20:05 -0000	1.1.1.2
+++ m3-comm/netobj/src/netobjrt/StubLib.m3	8 Jan 2010 11:08:08 -0000
@@ -93,10 +93,10 @@
           dispatcher: Dispatcher;
           obj: NetObj.T;
           rd := c.rd;
-          h := LOOPHOLE(ADR(rd.buff[rd.st+rd.cur-rd.lo]),
+          h := LOOPHOLE(ADR(rd.buff[rd.st + ORD(rd.cur - rd.lo)]),
                                      UNTRACED REF CallHeader);
         BEGIN
-          IF rd.hi - rd.cur < BYTESIZE(CallHeader) OR
+          IF ORD(rd.hi - rd.cur) < BYTESIZE(CallHeader) OR
                      h.hdr.private # ORD(Op.MethodCall) THEN
                RaiseUnmarshalFailure();
           END;
@@ -113,10 +113,10 @@
             dispatcher(c, obj, h.hdr, h.prot);
             IF (c.objStack.pos # 0) THEN
               c.wr.nextMsg();
-              IF NOT rd.nextMsg() OR rd.hi - rd.cur < BYTESIZE(MsgHeader) THEN
+              IF NOT rd.nextMsg() OR ORD(rd.hi - rd.cur) < BYTESIZE(MsgHeader) THEN
                 RETURN FALSE;
               END;
-              VAR hh := LOOPHOLE(ADR(rd.buff[rd.st+rd.cur-rd.lo]),
+              VAR hh := LOOPHOLE(ADR(rd.buff[rd.st + ORD(rd.cur - rd.lo)]),
                                               UNTRACED REF MsgHeader)^;
               BEGIN
                 INC(rd.cur, BYTESIZE(MsgHeader));
@@ -141,7 +141,7 @@
             (* this test checks whether we have started marshalling results *)
             IF c.wr.cur = 0 THEN
               VAR wr := c.wr;
-                  h := LOOPHOLE(ADR(wr.buff[wr.st+wr.cur-wr.lo]),
+                  h := LOOPHOLE(ADR(wr.buff[wr.st + ORD(wr.cur - wr.lo)]),
                                              UNTRACED REF MsgHeader);
               BEGIN
                 h.hdr := NativeRep;
@@ -169,7 +169,7 @@
     c.inObj := FALSE;
     c.protocol := stubProt;
     VAR wr := c.wr;
-        h := LOOPHOLE(ADR(wr.buff[wr.st+wr.cur-wr.lo]),
+        h := LOOPHOLE(ADR(wr.buff[wr.st + ORD(wr.cur - wr.lo)]),
                                  UNTRACED REF CallHeader);
     BEGIN
       <* ASSERT (wr.hi - wr.cur >= BYTESIZE(CallHeader)) *>
@@ -189,10 +189,10 @@
   BEGIN
     c.wr.nextMsg();
     TRY
-      IF NOT rd.nextMsg() OR rd.hi - rd.cur < BYTESIZE(MsgHeader) THEN
+      IF NOT rd.nextMsg() OR ORD(rd.hi - rd.cur) < BYTESIZE(MsgHeader) THEN
         RaiseUnmarshalFailure();
       END;
-      h := LOOPHOLE(ADR(rd.buff[rd.st+rd.cur-rd.lo]), UNTRACED REF MsgHeader)^;
+      h := LOOPHOLE(ADR(rd.buff[rd.st + ORD(rd.cur - rd.lo)]), UNTRACED REF MsgHeader)^;
       INC(rd.cur, BYTESIZE(MsgHeader));
     EXCEPT
     | Thread.Alerted => RAISE NetObj.Error(AtomList.List1(NetObj.Alerted));
@@ -219,7 +219,7 @@
       END;
       IF reUse AND c.inObj (* OR NOT UnsafeRd.FastEOF(c.rd) *) THEN
         VAR wr := c.wr;
-            h := LOOPHOLE(ADR(wr.buff[wr.st+wr.cur-wr.lo]),
+            h := LOOPHOLE(ADR(wr.buff[wr.st + ORD(wr.cur - wr.lo)]),
                                        UNTRACED REF MsgHeader);
         BEGIN
           h.hdr := NativeRep;
@@ -235,7 +235,7 @@
   
 PROCEDURE StartResult(c: Conn) =
   VAR wr := c.wr;
-      h := LOOPHOLE(ADR(wr.buff[wr.st+wr.cur-wr.lo]),
+      h := LOOPHOLE(ADR(wr.buff[wr.st + ORD(wr.cur - wr.lo)]),
                                  UNTRACED REF MsgHeader);
   BEGIN
     h.hdr := NativeRep;
@@ -416,7 +416,7 @@
     END;
     IF rd.cur = rd.hi THEN EVAL rd.seek(rd.cur, FALSE); END;
     IF rd.hi - rd.cur < nb THEN RaiseUnmarshalFailure(); END;
-    res := ADR(rd.buff[rd.st + rd.cur - rd.lo]);
+    res := ADR(rd.buff[rd.st + ORD(rd.cur - rd.lo)]);
     RETURN res;
   END AlignRd;
 
@@ -451,7 +451,7 @@
     (* here we rely on the alignment invariants of MsgWr.T *)
     IF diff # 0 THEN INC(wr.cur, align-diff); END;
     IF wr.cur = wr.hi THEN wr.seek(wr.cur); END;
-    res := ADR(wr.buff[wr.st + wr.cur - wr.lo]);
+    res := ADR(wr.buff[wr.st + ORD(wr.cur - wr.lo)]);
     RETURN res;
   END AlignWr;
 
@@ -978,7 +978,7 @@
     pwrep := LOOPHOLE(AlignRd(rd, Align64),
                                UNTRACED REF WireRep.T);
   BEGIN
-    IF rd.hi - rd.cur >= BYTESIZE(WireRep.T) THEN
+    IF ORD(rd.hi - rd.cur) >= BYTESIZE(WireRep.T) THEN
       INC(rd.cur, BYTESIZE(WireRep.T));
       IF pwrep^ = WireRep.NullT THEN RETURN NIL END;
       o := NetObjRT.Find(pwrep^, c.loc);
Index: m3-comm/netobj/src/netobjrt/VoucherStubs.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-comm/netobj/src/netobjrt/VoucherStubs.m3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 VoucherStubs.m3
--- m3-comm/netobj/src/netobjrt/VoucherStubs.m3	13 Jan 2001 14:15:13 -0000	1.1.1.1
+++ m3-comm/netobj/src/netobjrt/VoucherStubs.m3	8 Jan 2010 11:08:09 -0000
@@ -66,15 +66,13 @@
     RAISES {NetObj.Error, Rd.Failure, Wr.Failure, Thread.Alerted} =
   VAR
     rd: Rd.T;
-    pos: CARDINAL;
   BEGIN
     rd := v.claimRd();
     IF rd = NIL THEN
       RAISE NetObj.Error(AtomList.List1(NetObj.MissingObject));
     END;
     StubLib.StartResult(c);
-    pos := Rd.Index(rd);
-    StubLib.OutInteger(c, pos);
+    StubLib.OutInteger(c, ORD(Rd.Index(rd)));
     c.wr.nextMsg();
     SendOp(c, Op.StreamData);
     TRY
@@ -109,7 +107,6 @@
     RAISES {NetObj.Error, Rd.Failure, Wr.Failure, Thread.Alerted} =
   VAR
     wr: Wr.T;
-    pos: CARDINAL;
   BEGIN
     (* wr might be lost here if an error is encountered during
        outbound marshalling.  This will be fixed by object cleanup. *)
@@ -118,8 +115,7 @@
       RAISE NetObj.Error(AtomList.List1(NetObj.MissingObject));
     END;
     StubLib.StartResult(c);
-    pos := Wr.Index(wr);
-    StubLib.OutInteger(c, pos);
+    StubLib.OutInteger(c, ORD(Wr.Index(wr)));
     REPEAT
       c.wr.nextMsg();
       TRY
@@ -163,7 +159,7 @@
           c := c,
           v := v,
           buff := c.rd.buff,
-          st := c.rd.st + (c.rd.cur - c.rd.lo),
+          st := c.rd.st + ORD(c.rd.cur - c.rd.lo),
           lo := pos,
           hi := pos + (c.rd.hi - c.rd.cur),
           cur := pos,
@@ -184,7 +180,7 @@
 PROCEDURE SurrogateClaimWr(v: T) : Wr.T RAISES {NetObj.Error, Thread.Alerted} =
   VAR steal := FALSE;
       c: StubLib.Conn;
-      pos: CARDINAL;
+      pos: INTEGER;
       wr: SurrogateWr;
       rep: StubLib.DataRep;
   BEGIN
@@ -200,7 +196,7 @@
           v := v,
           buff := c.wr.buff,
         (* offset := pos - c.wr.cur, *)
-          st := c.wr.st + (c.wr.cur - c.wr.lo),
+          st := c.wr.st + ORD(c.wr.cur - c.wr.lo),
           lo := pos,
           hi := pos + (c.wr.hi - c.wr.cur),
           cur := pos,
@@ -221,7 +217,7 @@
 
 (* surrogate reader methods *)
 
-PROCEDURE SRSeek(rd: SurrogateRd; pos: CARDINAL;
+PROCEDURE SRSeek(rd: SurrogateRd; pos: LONGINT;
                  dontBlock: BOOLEAN) : RdClass.SeekResult
                  RAISES {Rd.Failure, Thread.Alerted} =
   VAR mrd := rd.c.rd;
@@ -311,14 +307,14 @@
        the underlying connection.
   *)
   
-PROCEDURE SWSeek(wr: SurrogateWr; <*UNUSED*> n: CARDINAL)
+PROCEDURE SWSeek(wr: SurrogateWr; <*UNUSED*> n: LONGINT)
     RAISES {Wr.Failure, Thread.Alerted} =
   VAR mwr := wr.c.wr;
   BEGIN
     mwr.cur := mwr.hi;
     mwr.seek(mwr.cur);
     wr.buff := mwr.buff;
-    wr.st := mwr.st + (mwr.cur - mwr.lo);
+    wr.st := mwr.st + ORD(mwr.cur - mwr.lo);
     wr.lo := wr.cur;
     wr.hi := wr.cur + (mwr.hi - mwr.lo);
   END SWSeek;
@@ -351,7 +347,7 @@
     END;
     SendOp(wr.c, wr.dataOp);
     (* offset := wr.cur - c.wr.cur, *)
-    wr.st := mwr.st + (mwr.cur - mwr.lo);
+    wr.st := mwr.st + ORD(mwr.cur - mwr.lo);
     wr.lo := wr.cur;
     wr.hi := wr.cur + (mwr.hi - mwr.lo);
   END SWFlush;
@@ -408,7 +404,7 @@
   VAR h: UNTRACED REF MsgHeader;
       wr := c.wr;
   BEGIN
-    h := LOOPHOLE(ADR(wr.buff[wr.st+wr.cur-wr.lo]), UNTRACED REF MsgHeader);
+    h := LOOPHOLE(ADR(wr.buff[wr.st + ORD(wr.cur - wr.lo)]), UNTRACED REF MsgHeader);
     INC(wr.cur, BYTESIZE(MsgHeader));
     h.hdr := StubLib.NativeRep;
     h.hdr.private := ORD(op);
@@ -422,7 +418,7 @@
     IF NOT rd.nextMsg() OR rd.hi - rd.cur < BYTESIZE(MsgHeader) THEN
       RAISE Rd.Failure(AtomList.List1(StubLib.UnmarshalFailure));
     END;
-    h := LOOPHOLE(ADR(rd.buff[rd.st+rd.cur-rd.lo]), UNTRACED REF MsgHeader);
+    h := LOOPHOLE(ADR(rd.buff[rd.st + ORD(rd.cur - rd.lo)]), UNTRACED REF MsgHeader);
     INC(rd.cur, BYTESIZE(MsgHeader));
     RETURN h.hdr;
   END RecvOp;
@@ -460,7 +456,7 @@
       IF rd.closed THEN Die(); END;
       REPEAT
         IF rd.cur # rd.hi THEN
-          wr.putString(SUBARRAY(rd.buff^, (rd.cur-rd.lo)+rd.st, rd.hi-rd.cur));
+          wr.putString(SUBARRAY(rd.buff^, ORD(rd.cur - rd.lo) + rd.st, ORD(rd.hi - rd.cur)));
           rd.cur := rd.hi;
           dontBlock := rd.intermittent;
         ELSIF dontBlock THEN
@@ -482,7 +478,7 @@
     REPEAT
       IF rd.cur # rd.hi THEN
         Wr.PutString(wr,
-              SUBARRAY(rd.buff^, (rd.cur-rd.lo)+rd.st, rd.hi-rd.cur));
+              SUBARRAY(rd.buff^, ORD(rd.cur - rd.lo) + rd.st, ORD(rd.hi - rd.cur)));
         rd.cur := rd.hi;
       END;
     UNTIL (rd.seek(rd.cur, FALSE) = RdClass.SeekResult.Eof);
Index: m3-comm/rdwr/src/RdWrPipe.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-comm/rdwr/src/RdWrPipe.m3,v
retrieving revision 1.2
diff -u -r1.2 RdWrPipe.m3
--- m3-comm/rdwr/src/RdWrPipe.m3	2 Dec 2001 00:35:21 -0000	1.2
+++ m3-comm/rdwr/src/RdWrPipe.m3	8 Jan 2010 11:08:09 -0000
@@ -113,9 +113,9 @@
 PROCEDURE RdChanged(t: TEXT; rd: RdT) = 
   BEGIN
     IO.Put(t & "Rd("&rd.share.name&") changed: \n lo = " &
-      Fmt.Unsigned(rd.lo,10) & ", hi = " &
-      Fmt.Unsigned(rd.hi,10) & ", cur = " &
-      Fmt.Unsigned(rd.cur,10) & ", st = " &
+      Fmt.LongUnsigned(rd.lo,10) & ", hi = " &
+      Fmt.LongUnsigned(rd.hi,10) & ", cur = " &
+      Fmt.LongUnsigned(rd.cur,10) & ", st = " &
       Fmt.Unsigned(rd.st,10) & "\n share.first_i = " &
       Fmt.Unsigned(rd.share.first_i,10) & ", share.next_i = " &
       Fmt.Unsigned(rd.share.next_i,10) & ", share.size = " &
@@ -126,9 +126,9 @@
 PROCEDURE WrChanged(t: TEXT; wr: WrT) = 
   BEGIN
     IO.Put(t & "Wr("&wr.share.name&") changed: \n lo = " &
-      Fmt.Unsigned(wr.lo,10) & ", hi = " &
-      Fmt.Unsigned(wr.hi,10) & ", cur = " &
-      Fmt.Unsigned(wr.cur,10) & ", st = " &
+      Fmt.LongUnsigned(wr.lo,10) & ", hi = " &
+      Fmt.LongUnsigned(wr.hi,10) & ", cur = " &
+      Fmt.LongUnsigned(wr.cur,10) & ", st = " &
       Fmt.Unsigned(wr.st,10) & "\n share.first_i = " &
       Fmt.Unsigned(wr.share.first_i,10) & ", share.next_i = " &
       Fmt.Unsigned(wr.share.next_i,10) & ", share.size = " &
@@ -159,7 +159,7 @@
     wr.st := 0;
     wr.lo := 0;
     wr.cur := 0;
-    wr.hi := buff_size-1;
+    wr.hi := buff_size - 1;
     wr.closed := FALSE;
     wr.seekable := FALSE;
     wr.buffered := TRUE;
@@ -167,7 +167,7 @@
 
 EXCEPTION Error;                 <*FATAL Error*>
 
-PROCEDURE RdSeek (rd: RdT; pos: CARDINAL;
+PROCEDURE RdSeek (rd: RdT; pos: LONGINT;
                   dontBlock: BOOLEAN): 
   RdClass.SeekResult RAISES {Alerted} =
   VAR do_signal := FALSE;
@@ -181,7 +181,7 @@
       <*ASSERT rd.st = rd.share.first_i *>
 
       (* cur_i is the position of rd.cur in the shared data buffer,
-         which is the next character we want to read. *)
+         which is the next character we want to read. *)
       WITH cur_i = (rd.st + rd.cur - rd.lo) MOD rd.share.size DO
         (* Set rd.lo to rd.cur, since we are done with all of the current
            buffer contents.  Move rd.st to cur_i, to keep things in sync in
@@ -251,7 +251,7 @@
     RETURN RdClass.SeekResult.Ready;
   END RdSeek;
 
-PROCEDURE RdLength (<*UNUSED*>rd: RdT): INTEGER =
+PROCEDURE RdLength (<*UNUSED*>rd: RdT): LONGINT =
   BEGIN
     RETURN -1;
   END RdLength;
@@ -268,7 +268,7 @@
     END;
   END RdClose;
 
-PROCEDURE WrSeek (wr: WrT; pos: CARDINAL) RAISES {Wr.Failure, Alerted} =
+PROCEDURE WrSeek (wr: WrT; pos: LONGINT) RAISES {Wr.Failure, Alerted} =
   BEGIN
     (* This file is not seekable, so only handle the special case. *)
     IF pos # wr.hi OR pos # wr.cur THEN RAISE Error; END;
Index: m3-comm/rdwr/src/SimpleMsgRW.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-comm/rdwr/src/SimpleMsgRW.m3,v
retrieving revision 1.2
diff -u -r1.2 SimpleMsgRW.m3
--- m3-comm/rdwr/src/SimpleMsgRW.m3	2 Dec 2001 00:35:21 -0000	1.2
+++ m3-comm/rdwr/src/SimpleMsgRW.m3	8 Jan 2010 11:08:09 -0000
@@ -200,7 +200,7 @@
   END NewWr;
 
 
-PROCEDURE RdSeek(rd: RdT; <*UNUSED*> n: CARDINAL;
+PROCEDURE RdSeek(rd: RdT; <*UNUSED*> n: LONGINT;
                           dontBlock: BOOLEAN): RdClass.SeekResult
   RAISES {Rd.Failure, Thread.Alerted} =
   VAR
@@ -219,7 +219,7 @@
         (* fall out into common code below *)
       ELSE
         (* advance to next non-empty fragment *) 
-        rd.st := Align((rd.hi - rd.lo) + rd.st);
+        rd.st := Align(ORD(rd.hi - rd.lo) + rd.st);
         rd.lo := rd.hi;
         REPEAT
           IF rd.hdr.eom # 0 THEN 
@@ -295,7 +295,7 @@
     RETURN len;
   END ReadAligned;
 
-PROCEDURE Length(rd: RdT) : INTEGER =
+PROCEDURE Length(rd: RdT) : LONGINT =
   BEGIN
     IF rd.hdr.eom # 0 THEN
       RETURN rd.lo + rd.hdr.nb;
@@ -319,7 +319,7 @@
     WHILE rd.hdr.nb # 0 OR NOT rd.hdr.eom # 0 DO
       EVAL RdSeek(rd, rd.hi, FALSE);
     END;
-    rd.st := Align((rd.hi - rd.lo) + rd.st);
+    rd.st := Align(ORD(rd.hi - rd.lo) + rd.st);
     rd.cur := 0;
     rd.lo := 0;
     rd.hi := 0;
@@ -329,7 +329,7 @@
   END RdNextMsg;
   
 
-PROCEDURE WrSeek(wr: WrT; <*UNUSED*> n: CARDINAL)
+PROCEDURE WrSeek(wr: WrT; <*UNUSED*> n: LONGINT)
   RAISES {Wr.Failure, Thread.Alerted} =
   BEGIN WrFlush(wr) END WrSeek;
 
@@ -358,7 +358,7 @@
   END WrNextMsg;
   
 PROCEDURE PutFrag(wr: WrT; eom: BOOLEAN) RAISES {Wr.Failure, Thread.Alerted} =
-  VAR len := wr.cur - wr.lo;
+  VAR len := ORD(wr.cur - wr.lo);
   BEGIN
     WITH hdr = LOOPHOLE(ADR(wr.buff[0]), UNTRACED REF FragmentHeader) DO
       hdr^ := FragmentHeader{eom := ORD(eom), nb := len};
Index: m3-comm/rdwr/src/TeeWr.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-comm/rdwr/src/TeeWr.m3,v
retrieving revision 1.2
diff -u -r1.2 TeeWr.m3
--- m3-comm/rdwr/src/TeeWr.m3	2 Dec 2001 00:35:21 -0000	1.2
+++ m3-comm/rdwr/src/TeeWr.m3	8 Jan 2010 11:08:09 -0000
@@ -87,7 +87,7 @@
 
 EXCEPTION Error;                 <*FATAL Error*>
 
-PROCEDURE Seek (self: T; n: CARDINAL) RAISES {Failure, Alerted} =
+PROCEDURE Seek (self: T; n: LONGINT) RAISES {Failure, Alerted} =
   BEGIN
     (* This file is not seekable, so only handle the special case. *)
     IF n # self.hi OR n # self.cur THEN RAISE Error; END;
@@ -103,7 +103,7 @@
 
 (* write the current buffered amount to a writer *)
 PROCEDURE EmptyBuffer(self: T; wr: Wr.T) RAISES {Failure, Alerted} =
-  VAR n := self.cur - self.lo;
+  VAR n := ORD(self.cur - self.lo);
   BEGIN
     <*ASSERT self.st = 0*>
     wr.putString(SUBARRAY(self.buff^, 0, n)); 
Index: m3-comm/tcp/src/common/ConnMsgRW.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-comm/tcp/src/common/ConnMsgRW.m3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 ConnMsgRW.m3
--- m3-comm/tcp/src/common/ConnMsgRW.m3	13 Jan 2001 14:15:14 -0000	1.1.1.1
+++ m3-comm/tcp/src/common/ConnMsgRW.m3	8 Jan 2010 11:08:09 -0000
@@ -147,7 +147,7 @@
   END NewWr;
 
 
-PROCEDURE RdSeek(rd: RdT; <*UNUSED*> n: CARDINAL;
+PROCEDURE RdSeek(rd: RdT; <*UNUSED*> n: LONGINT;
                           dontBlock: BOOLEAN): RdClass.SeekResult
   RAISES {Rd.Failure, Thread.Alerted} =
   VAR
@@ -166,7 +166,7 @@
         (* fall out into common code below *)
       ELSE
         (* advance to next non-empty fragment *) 
-        rd.st := Align((rd.hi - rd.lo) + rd.st);
+        rd.st := Align(ORD(rd.hi - rd.lo) + rd.st);
         rd.lo := rd.hi;
         REPEAT
           IF rd.hdr.eom # 0 THEN RETURN RdClass.SeekResult.Eof; END;
@@ -226,12 +226,12 @@
     RETURN len;
   END ReadAligned;
 
-PROCEDURE Length(rd: RdT) : INTEGER =
+PROCEDURE Length(rd: RdT) : LONGINT =
   BEGIN
     IF rd.hdr.eom # 0 THEN
       RETURN rd.lo + rd.hdr.nb;
     ELSE
-      RETURN -1;
+      RETURN -1L
     END;
   END Length;
 
@@ -250,7 +250,7 @@
     WHILE rd.hdr.nb # 0 OR NOT rd.hdr.eom # 0 DO
       EVAL RdSeek(rd, rd.hi, FALSE);
     END;
-    rd.st := Align((rd.hi - rd.lo) + rd.st);
+    rd.st := Align(ORD(rd.hi - rd.lo) + rd.st);
     rd.cur := 0;
     rd.lo := 0;
     rd.hi := 0;
@@ -260,7 +260,7 @@
   END RdNextMsg;
   
 
-PROCEDURE WrSeek(wr: WrT; <*UNUSED*> n: CARDINAL)
+PROCEDURE WrSeek(wr: WrT; <*UNUSED*> n: LONGINT)
   RAISES {Wr.Failure, Thread.Alerted} =
   BEGIN WrFlush(wr) END WrSeek;
 
@@ -288,7 +288,7 @@
   END WrNextMsg;
   
 PROCEDURE PutFrag(wr: WrT; eom: BOOLEAN) RAISES {Wr.Failure, Thread.Alerted} =
-  VAR len := wr.cur - wr.lo;
+  VAR len := ORD(wr.cur - wr.lo);
   BEGIN
     WITH hdr = LOOPHOLE(ADR(wr.buff[0]), UNTRACED REF FragmentHeader) DO
       hdr^ := FragmentHeader{eom := ORD(eom), nb := len};
Index: m3-comm/tcp/src/common/ConnRW.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-comm/tcp/src/common/ConnRW.m3,v
retrieving revision 1.2
diff -u -r1.2 ConnRW.m3
--- m3-comm/tcp/src/common/ConnRW.m3	28 Jul 2003 14:12:14 -0000	1.2
+++ m3-comm/tcp/src/common/ConnRW.m3	8 Jan 2010 11:08:10 -0000
@@ -57,7 +57,7 @@
         closed := FALSE);
   END NewWr;
 
-PROCEDURE RdSeek(rd: RdT; <*UNUSED*> pos: CARDINAL;
+PROCEDURE RdSeek(rd: RdT; <*UNUSED*> pos: LONGINT;
                  dontBlock: BOOLEAN): RdClass.SeekResult
   RAISES {Rd.Failure, Thread.Alerted} =
   VAR 
@@ -87,13 +87,13 @@
     rd.fd.shutdownIn();
   END RdClose;
 
-PROCEDURE WrSeek(wr: WrT; <*UNUSED*> n: CARDINAL)
+PROCEDURE WrSeek(wr: WrT; <*UNUSED*> n: LONGINT)
   RAISES {Wr.Failure, Thread.Alerted} =
   BEGIN WrFlush(wr) END WrSeek;
 
 PROCEDURE WrFlush(wr: WrT) RAISES {Wr.Failure, Thread.Alerted} =
   BEGIN
-    wr.fd.put(SUBARRAY(wr.buff^, 0, wr.cur-wr.lo));
+    wr.fd.put(SUBARRAY(wr.buff^, 0, ORD(wr.cur - wr.lo)));
     wr.lo := wr.cur;
     wr.hi := wr.lo + NUMBER(wr.buff^);
     StreamWrClass.DontOverflow(wr);
Index: m3-comm/tcp/src/common/StreamRdClass.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-comm/tcp/src/common/StreamRdClass.m3,v
retrieving revision 1.1
diff -u -r1.1 StreamRdClass.m3
--- m3-comm/tcp/src/common/StreamRdClass.m3	28 Jul 2003 14:12:14 -0000	1.1
+++ m3-comm/tcp/src/common/StreamRdClass.m3	8 Jan 2010 11:08:10 -0000
@@ -33,7 +33,7 @@
 IMPORT RdClass;
 
 CONST
-  Threshold = LAST(CARDINAL) DIV 2;
+  Threshold = LAST(LONGINT) DIV 2L;
 
 PROCEDURE ByteCount(srd: T): LONGREAL =
   BEGIN
Index: m3-comm/tcp/src/common/StreamWrClass.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-comm/tcp/src/common/StreamWrClass.m3,v
retrieving revision 1.1
diff -u -r1.1 StreamWrClass.m3
--- m3-comm/tcp/src/common/StreamWrClass.m3	28 Jul 2003 14:12:14 -0000	1.1
+++ m3-comm/tcp/src/common/StreamWrClass.m3	8 Jan 2010 11:08:10 -0000
@@ -33,7 +33,7 @@
 IMPORT WrClass;
 
 CONST
-  Threshold = LAST(CARDINAL) DIV 2;
+  Threshold = LAST(LONGINT) DIV 2L;
 
 PROCEDURE ByteCount(swr: T): LONGREAL =
   BEGIN
Index: m3-db/smalldb/src/OSSupportWIN32.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-db/smalldb/src/OSSupportWIN32.m3,v
retrieving revision 1.2
diff -u -r1.2 OSSupportWIN32.m3
--- m3-db/smalldb/src/OSSupportWIN32.m3	1 Mar 2001 17:07:41 -0000	1.2
+++ m3-db/smalldb/src/OSSupportWIN32.m3	8 Jan 2010 11:08:10 -0000
@@ -3,7 +3,7 @@
 IMPORT OSError, OSErrorWin32, File, FileWr, FileWin32, WrClass, WinNT, 
        OSSupportWIN32IF, WinBase;
 
-CONST INVALID_SET_FILE_POINTER = -1; (* FIXME: is this correct? *)
+CONST INVALID_SET_FILE_POINTER = -1;
 
 REVEAL
   T = FileWr.T BRANDED OBJECT
@@ -30,7 +30,7 @@
   BEGIN
     WrClass.Lock(wr);
     TRY
-      IF WinBase.SetFilePointer(wr.handle, wr.cur, NIL,
+      IF WinBase.SetFilePointer(wr.handle, ORD(wr.cur), NIL,
                                 WinBase.FILE_BEGIN) = 
                                 INVALID_SET_FILE_POINTER THEN
         OSErrorWin32.Raise();
Index: m3-db/smalldb/src/SmallDB.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-db/smalldb/src/SmallDB.i3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 SmallDB.i3
--- m3-db/smalldb/src/SmallDB.i3	13 Jan 2001 14:17:33 -0000	1.1.1.1
+++ m3-db/smalldb/src/SmallDB.i3	8 Jan 2010 11:08:10 -0000
@@ -41,8 +41,8 @@
     update(value: REFANY; forceToDisk: BOOLEAN := TRUE) RAISES {OSError.E};
     snapshot(value: REFANY) RAISES {OSError.E};
     close() RAISES {OSError.E};
-    snapshotBytes() : CARDINAL;
-    logBytes() : CARDINAL;
+    snapshotBytes() : LONGINT;
+    logBytes() : LONGINT;
     status() : TEXT;
   END;
   
Index: m3-db/smalldb/src/SmallDB.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-db/smalldb/src/SmallDB.m3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 SmallDB.m3
--- m3-db/smalldb/src/SmallDB.m3	13 Jan 2001 14:17:33 -0000	1.1.1.1
+++ m3-db/smalldb/src/SmallDB.m3	8 Jan 2010 11:08:10 -0000
@@ -20,8 +20,8 @@
     logName: TEXT := NIL;
     logWriter: OSSupport.T := NIL; (* Writer to the current logfile *)
     (* statistics *)
-    snapshotByteCnt, logByteCnt: CARDINAL := 0;
-    logEntries: CARDINAL := 0;
+    snapshotByteCnt, logByteCnt: LONGINT := 0L;
+    logEntries: LONGINT := 0;
     lastSnapshot, lastLog: Time.T;
     pad: BOOLEAN; (* if TRUE, pad each update to a DiskPageSize boundary *)
     cl: Closure;
@@ -302,7 +302,7 @@
   (* Records this update in the log file for "t" *)
   VAR
     updateLen: Word.T;
-    entryStart, entryEnd: CARDINAL;
+    entryStart, entryEnd: LONGINT;
   BEGIN
     
     <* ASSERT t.logWriter # NIL *>
@@ -315,7 +315,7 @@
       t.cl.logUpdate(t.logWriter, update);
 
       entryEnd := Wr.Index(t.logWriter);
-      updateLen := (entryEnd - entryStart) - IntBytes;
+      updateLen := ORD(entryEnd - entryStart - IntBytes);
 
       IF forceToDisk THEN (* force update contents before updating length *)
         Wr.Flush(t.logWriter);
@@ -329,7 +329,7 @@
       Wr.Seek(t.logWriter, entryEnd);
 
       (* don't start an entry at the end of page *)
-      IF t.pad OR (entryEnd MOD DiskPageSize > DiskPageSize-IntBytes) THEN
+      IF t.pad OR (entryEnd MOD DiskPageSize > DiskPageSize - IntBytes) THEN
         WHILE (Wr.Index(t.logWriter) MOD DiskPageSize) # 0 DO
           Wr.PutChar(t.logWriter, VAL(0, CHAR)); (* Fill to page boundary *)
         END;
@@ -355,7 +355,7 @@
     updateLen: Word.T;
     fname: TEXT;
     updateText: TEXT;
-    pos: CARDINAL;
+    pos: LONGINT;
   BEGIN
     IF t.version = 0 THEN RETURN state; END;
     TRY
@@ -426,26 +426,26 @@
   (* Close a stable storage directory in an orderly manner *)
   BEGIN CloseLogfile(t); END Close;
 
-PROCEDURE SnapshotBytes(t: T): CARDINAL =
+PROCEDURE SnapshotBytes(t: T): LONGINT =
   BEGIN RETURN t.snapshotByteCnt; END SnapshotBytes;
 
-PROCEDURE LogBytes(t: T): CARDINAL = BEGIN RETURN t.logByteCnt; END LogBytes;
+PROCEDURE LogBytes(t: T): LONGINT = BEGIN RETURN t.logByteCnt; END LogBytes;
 
 PROCEDURE Status(t: T) : TEXT =
   VAR out: TEXT;
   BEGIN
     out := "   Stable storage status for directory \"" & t.dirname & "\"\n";
     out := out & "      Snapshot version " & Fmt.Int(t.version)
-              & ", size " & Fmt.Int(t.snapshotByteCnt) & " bytes.\n";
+              & ", size " & Fmt.LongInt(t.snapshotByteCnt) & " bytes.\n";
     IF t.lastSnapshot # 0.0D0 THEN
       out := out & "      Last snapshot was written at " &
          FmtTime.Long(t.lastSnapshot) & "\n";
     ELSE
       out := out & "      No snapshot has been made in this run.\n";
     END;
-    out := out & "      Log has " & Fmt.Int(t.logEntries)
+    out := out & "      Log has " & Fmt.LongInt(t.logEntries)
                & " entries, total size "
-               & Fmt.Int(t.logByteCnt) & " bytes.\n";
+               & Fmt.LongInt(t.logByteCnt) & " bytes.\n";
     IF t.lastLog # 0.0D0 THEN
       out := out & "      Last log entry was written at " &
          FmtTime.Long(t.lastLog) & "\n";
Index: m3-libs/libbuf/src/Buf.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libbuf/src/Buf.m3,v
retrieving revision 1.1
diff -u -r1.1 Buf.m3
--- m3-libs/libbuf/src/Buf.m3	6 Apr 2002 15:29:18 -0000	1.1
+++ m3-libs/libbuf/src/Buf.m3	8 Jan 2010 11:08:10 -0000
@@ -22,7 +22,7 @@
       THEN f := FS.OpenFileReadonly (path);
       ELSE f := src;
     END;
-    len := f.status().size;
+    len := ORD(f.status().size);
     t := NEW (T, len + pad);
 
     next := 0;
Index: m3-libs/libm3/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
--- m3-libs/libm3/src/os/Common/File.i3	24 Jan 2001 12:24:16 -0000	1.1.1.1
+++ m3-libs/libm3/src/os/Common/File.i3	8 Jan 2010 11:08:10 -0000
@@ -31,7 +31,7 @@
   Status = RECORD
     type: Type;
     modificationTime: Time.T;
-    size: CARDINAL
+    size: LONGINT
   END;
   Type = Atom.T;
 
Index: m3-libs/libm3/src/os/Common/RegularFile.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/os/Common/RegularFile.i3,v
retrieving revision 1.1.1.2
diff -u -r1.1.1.2 RegularFile.i3
--- m3-libs/libm3/src/os/Common/RegularFile.i3	24 Jan 2001 16:48:00 -0000	1.1.1.2
+++ m3-libs/libm3/src/os/Common/RegularFile.i3	8 Jan 2010 11:08:10 -0000
@@ -14,7 +14,7 @@
 TYPE
   T <: Public;
   Public = File.T OBJECT METHODS
-    seek(origin: Origin; offset: INTEGER): INTEGER
+    seek(origin: Origin; offset: LONGINT): LONGINT
       RAISES {OSError.E};
     flush() RAISES {OSError.E};
     lock(): BOOLEAN RAISES {OSError.E};
Index: m3-libs/libm3/src/os/POSIX/FilePosix.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/os/POSIX/FilePosix.m3,v
retrieving revision 1.16
diff -u -r1.16 FilePosix.m3
--- m3-libs/libm3/src/os/POSIX/FilePosix.m3	22 Jun 2009 12:29:31 -0000	1.16
+++ m3-libs/libm3/src/os/POSIX/FilePosix.m3	8 Jan 2010 11:08:10 -0000
@@ -145,12 +145,12 @@
   END RegularFileWrite;
 
 PROCEDURE RegularFileSeek(
-    h: RegularFile.T; origin: RegularFile.Origin; offset: INTEGER)
-  : INTEGER RAISES {OSError.E} =
+    h: RegularFile.T; origin: RegularFile.Origin; offset: LONGINT)
+  : LONGINT RAISES {OSError.E} =
   BEGIN
     WITH result = Unix.lseek(h.fd, VAL(offset, Utypes.off_t), ORD(origin)) DO
       IF result < VAL(0, Utypes.off_t) THEN OSErrorPosix.Raise() END;
-      RETURN ORD(result)
+      RETURN result;
     END
   END RegularFileSeek;
 
Index: m3-libs/libm3/src/os/WIN32/FSWin32.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/os/WIN32/FSWin32.m3,v
retrieving revision 1.5
diff -u -r1.5 FSWin32.m3
--- m3-libs/libm3/src/os/WIN32/FSWin32.m3	11 Feb 2008 09:40:29 -0000	1.5
+++ m3-libs/libm3/src/os/WIN32/FSWin32.m3	8 Jan 2010 11:08:10 -0000
@@ -432,7 +432,7 @@
 PROCEDURE BuildStatus (READONLY ffd  : WinBase.WIN32_FIND_DATA;
                      VAR(*OUT*) stat : File.Status) =
   BEGIN
-    stat.size := ffd.nFileSizeLow;
+    stat.size := VAL(ffd.nFileSizeLow, LONGINT);
     stat.modificationTime := TimeWin32.FromFileTime(ffd.ftLastWriteTime);
     IF Word.And(ffd.dwFileAttributes, WinNT.FILE_ATTRIBUTE_DIRECTORY) # 0
       THEN stat.type := DirectoryFileType;
Index: m3-libs/libm3/src/os/WIN32/FileWin32.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/os/WIN32/FileWin32.m3,v
retrieving revision 1.4
diff -u -r1.4 FileWin32.m3
--- m3-libs/libm3/src/os/WIN32/FileWin32.m3	12 Feb 2001 15:21:06 -0000	1.4
+++ m3-libs/libm3/src/os/WIN32/FileWin32.m3	8 Jan 2010 11:08:10 -0000
@@ -106,7 +106,7 @@
         END;
         status.type := RegularFile.FileType;
         status.modificationTime := TimeWin32.FromFileTime(ffd.ftLastWriteTime);
-        status.size := ffd.nFileSizeLow
+        status.size := VAL(ffd.nFileSizeLow, LONGINT);
     | WinBase.FILE_TYPE_CHAR => status.type := Terminal.FileType
     | WinBase.FILE_TYPE_PIPE => status.type := Pipe.FileType
     | WinBase.FILE_TYPE_UNKNOWN => 
@@ -216,12 +216,12 @@
   END RegularFileRead;
 
 PROCEDURE RegularFileSeek(
-    h: RegularFile.T; origin: RegularFile.Origin; offset: INTEGER)
-  : INTEGER RAISES {OSError.E} =
+    h: RegularFile.T; origin: RegularFile.Origin; offset: LONGINT)
+  : LONGINT RAISES {OSError.E} =
   BEGIN
-    WITH res = WinBase.SetFilePointer(h.handle, offset, NIL, ORD(origin)) DO
+    WITH res = WinBase.SetFilePointer(h.handle, ORD(offset), NIL, ORD(origin)) DO
       IF res < 0 THEN OSErrorWin32.Raise() END;
-      RETURN res
+      RETURN VAL(res, LONGINT);
     END
   END RegularFileSeek;
 
Index: m3-libs/libm3/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
--- m3-libs/libm3/src/rw/AutoFlushWr.m3	31 Aug 2009 09:58:08 -0000	1.5
+++ m3-libs/libm3/src/rw/AutoFlushWr.m3	8 Jan 2010 11:08:10 -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,8 +153,8 @@
     END;
   END Flush;
 
-PROCEDURE Length (wr: T): CARDINAL RAISES {Failure, Alerted} =
-  VAR res: CARDINAL;
+PROCEDURE Length (wr: T): LONGINT RAISES {Failure, Alerted} =
+  VAR res: LONGINT;
   BEGIN
     WrClass.Lock(wr.child);
     TRY
Index: m3-libs/libm3/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
--- m3-libs/libm3/src/rw/FileRd.m3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ m3-libs/libm3/src/rw/FileRd.m3	8 Jan 2010 11:08:11 -0000
@@ -55,7 +55,7 @@
     ELSE
       rd.seekable := FALSE;
       rd.intermittent := TRUE;
-      rd.cur := 0
+      rd.cur := 0;
     END;
     rd.lo := rd.cur;
     rd.hi := rd.cur;
@@ -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
@@ -99,11 +99,11 @@
     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);
+              SUBARRAY(rd.buff^, ORD(rd.cur-rd.lo), n);
             INC(rd.cur, n);
-            DEC(toRead, n)
+            DEC(toRead, n);
           END
         ELSE
           rd.lo := rd.cur;
@@ -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: m3-libs/libm3/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
--- m3-libs/libm3/src/rw/FileWr.m3	31 Aug 2009 09:01:00 -0000	1.2
+++ m3-libs/libm3/src/rw/FileWr.m3	8 Jan 2010 11:08:11 -0000
@@ -77,10 +77,10 @@
 
 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");
+        RTIO.PutText("FileWr.Seek:wr.seekable=" & Fmt.Bool(wr.seekable) & ";n=" & Fmt.LongInt(n) & ";wr.hi=" & Fmt.LongInt(wr.hi) & "\n");
         RTIO.Flush();
         RAISE Error
     END;
@@ -101,7 +101,7 @@
     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);
@@ -142,8 +142,8 @@
   RAISES {Wr.Failure} =
   VAR toWrite, start, n: INTEGER;
   BEGIN
-    IF NUMBER(buf) <= wr.hi - wr.cur THEN
-      SUBARRAY(wr.buff^, wr.cur - wr.lo, NUMBER(buf)) := buf;
+    IF NUMBER(buf) <= ORD(wr.hi - wr.cur) THEN
+      SUBARRAY(wr.buff^, ORD(wr.cur - wr.lo), NUMBER(buf)) := buf;
       INC(wr.cur, NUMBER(buf));
     ELSE
       Flush(wr);
Index: m3-libs/libm3/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
--- m3-libs/libm3/src/rw/NullRd.m3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ m3-libs/libm3/src/rw/NullRd.m3	8 Jan 2010 11:08:11 -0000
@@ -32,19 +32,15 @@
     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
 END NullRd.
-
-
-                
-  
Index: m3-libs/libm3/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
--- m3-libs/libm3/src/rw/NullWr.m3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ m3-libs/libm3/src/rw/NullWr.m3	8 Jan 2010 11:08:11 -0000
@@ -37,7 +37,7 @@
     RETURN wr;
   END Init;
 
-PROCEDURE Seek (wr: T; n: CARDINAL) =
+PROCEDURE Seek (wr: T; n: LONGINT) =
   BEGIN
     wr.lo := n;
     wr.cur := n;
Index: m3-libs/libm3/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
--- m3-libs/libm3/src/rw/Rd.i3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ m3-libs/libm3/src/rw/Rd.i3	8 Jan 2010 11:08:11 -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: m3-libs/libm3/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
--- m3-libs/libm3/src/rw/Rd.m3	31 Aug 2009 08:47:43 -0000	1.2
+++ m3-libs/libm3/src/rw/Rd.m3	8 Jan 2010 11:08:11 -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,9 +149,9 @@
         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)
       END
@@ -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,12 +275,12 @@
         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 + NUMBER (str) - i) - rd.lo) + rd.st;
+          j := ORD(rd.cur - rd.lo) + rd.st;
         BEGIN
-          WHILE (j # n) AND (rd.buff[j] # '\n') DO INC (j) END;
+          WHILE (j # n) AND (rd.buff[ORD(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);
@@ -323,13 +323,13 @@
       IF (rd.lo <= rd.cur) AND (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));
+                 SUBARRAY (rd.buff^, ORD(rd.cur - rd.lo) + rd.st, length));
         INC (rd.cur, length);
 
       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,10 +429,10 @@
           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
@@ -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: m3-libs/libm3/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
--- m3-libs/libm3/src/rw/RdClass.i3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ m3-libs/libm3/src/rw/RdClass.i3	8 Jan 2010 11:08:11 -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: m3-libs/libm3/src/rw/RdCopy.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/rw/RdCopy.i3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 RdCopy.i3
--- m3-libs/libm3/src/rw/RdCopy.i3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ m3-libs/libm3/src/rw/RdCopy.i3	8 Jan 2010 11:08:11 -0000
@@ -9,8 +9,8 @@
 
 IMPORT Rd, Wr, Thread;
 
-PROCEDURE ToWriter (rd: Rd.T; wr: Wr.T; length: CARDINAL := LAST(CARDINAL)):
-  CARDINAL RAISES {Rd.Failure, Wr.Failure, Thread.Alerted};
+PROCEDURE ToWriter (rd: Rd.T; wr: Wr.T; length: LONGINT := LAST(LONGINT)):
+  LONGINT RAISES {Rd.Failure, Wr.Failure, Thread.Alerted};
   (* Copies MIN(length, len(rd) - cur(rd)) bytes from rd to wr.  Returns
      the number of bytes copied.  Equivalent to:
 
@@ -26,7 +26,7 @@
 
 PROCEDURE ToProc (rd  : Rd.T;
                   proc: PROCEDURE (READONLY a: ARRAY OF CHAR) RAISES ANY;
-                  length: CARDINAL := LAST(CARDINAL)): CARDINAL
+                  length: LONGINT := LAST(LONGINT)): LONGINT
   RAISES ANY (* RAISES(proc) + {Rd.Failure, Thread.Alerted *);
   (* Passes MIN(length, len(rd) - cur(rd)) bytes from rd to proc.  Returns
      the number of bytes copied.  The length of the arrays passed to
@@ -35,7 +35,7 @@
 PROCEDURE FromProc (wr: Wr.T;
                     proc: PROCEDURE (VAR a: ARRAY OF CHAR): CARDINAL
                             RAISES ANY;
-                    length: CARDINAL := LAST(CARDINAL)): CARDINAL
+                    length: LONGINT := LAST(LONGINT)): LONGINT
   RAISES ANY (* RAISES(proc) + {Rd.Failure, Thread.Alerted *);
   (* Calls proc repeatedly to fill in up to length bytes in a buffer which are
      written to the writer.  If proc returns a value < NUMBER(a) then
Index: m3-libs/libm3/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
--- m3-libs/libm3/src/rw/RdCopy.m3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ m3-libs/libm3/src/rw/RdCopy.m3	8 Jan 2010 11:08:11 -0000
@@ -11,8 +11,8 @@
 
 IMPORT RdClass, WrClass, Rd, Wr, Thread;
 
-PROCEDURE ToWriter (rd: Rd.T; wr: Wr.T; length: CARDINAL := LAST(CARDINAL)):
-  CARDINAL RAISES {Rd.Failure, Wr.Failure, Thread.Alerted}<*NOWARN*> =
+PROCEDURE ToWriter (rd: Rd.T; wr: Wr.T; length: LONGINT := LAST(LONGINT)):
+  LONGINT RAISES {Rd.Failure, Wr.Failure, Thread.Alerted}<*NOWARN*> =
   (*
   PROCEDURE GetSub (VAR a: ARRAY OF CHAR): CARDINAL
     RAISES {Rd.Failure, Thread.Alerted} =
@@ -32,9 +32,9 @@
 
 PROCEDURE ToProc (rd  : Rd.T;
                   proc: PROCEDURE (READONLY a: ARRAY OF CHAR) RAISES ANY;
-                  length: CARDINAL := LAST(CARDINAL)): CARDINAL
+                  length: LONGINT := LAST(LONGINT)): LONGINT
   RAISES ANY (* RAISES(proc) + {Rd.Failure, Thread.Alerted *) =
-  VAR i := 0;
+  VAR i := 0L;
   BEGIN
     RdClass.Lock(rd);
     TRY
@@ -42,7 +42,7 @@
         IF Thread.TestAlert() THEN RAISE Thread.Alerted END; (* mhb: 7/7/95 *)
         WITH len = MIN(length - i, 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), ORD(len)));
             INC(i, len);
             INC(rd.cur, len);
           END;
@@ -61,9 +61,9 @@
 PROCEDURE FromProc (wr: Wr.T;
                     proc: PROCEDURE (VAR a: ARRAY OF CHAR): CARDINAL
                             RAISES ANY;
-                    length: CARDINAL := LAST(CARDINAL)): CARDINAL
+                    length: LONGINT := LAST(LONGINT)): LONGINT
   RAISES ANY (* RAISES(proc) + {Rd.Failure, Thread.Alerted *) =
-  VAR i := 0;
+  VAR i := 0L;
   BEGIN
     WrClass.Lock(wr);
     TRY
@@ -71,7 +71,7 @@
         WITH len = MIN(length - i, 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), ORD(len))) DO
               INC(i, res);
               INC(wr.cur, res);
               IF res # len THEN EXIT; END;
Index: m3-libs/libm3/src/rw/RdUtils.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/libm3/src/rw/RdUtils.i3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 RdUtils.i3
--- m3-libs/libm3/src/rw/RdUtils.i3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ m3-libs/libm3/src/rw/RdUtils.i3	8 Jan 2010 11:08:11 -0000
@@ -12,7 +12,7 @@
 IMPORT Rd, Thread, AtomList;
 
 PROCEDURE Find (rd: Rd.T; pattern: TEXT; canonicalize: Canonicalize := NIL):
-  [-1 .. LAST(CARDINAL)] RAISES {Rd.Failure, Thread.Alerted};
+  [-1L .. LAST(LONGINT)] RAISES {Rd.Failure, Thread.Alerted};
 (* Finds the first occurrence of pattern, reading forward from the current
    position of rd. If no match is found, Find returns -1 and leaves rd
    positioned at the end. If Rd.Failure, or Thread.Alerted is raised
@@ -31,13 +31,13 @@
 PROCEDURE FindString (         rd          : Rd.T;
                       READONLY pattern     : ARRAY OF CHAR;
                                canonicalize: Canonicalize    := NIL):
-  [-1 .. LAST(CARDINAL)] RAISES {Rd.Failure, Thread.Alerted};
+  [-1L .. LAST(LONGINT)] RAISES {Rd.Failure, Thread.Alerted};
 (* = Find(rd, Text.FromSub(pattern), canonicalize). *)
 
 PROCEDURE FindChar (rd          : Rd.T;
                     pattern     : CHAR;
                     canonicalize: Canonicalize := NIL):
-  [-1 .. LAST(CARDINAL)] RAISES {Rd.Failure, Thread.Alerted};
+  [-1L .. LAST(LONGINT)] RAISES {Rd.Failure, Thread.Alerted};
 (* = Find(rd, Text.FromChar(pattern), canonicalize). *)
 
 PROCEDURE FailureText (f: AtomList.T): TEXT;
Index: m3-libs/libm3/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
--- m3-libs/libm3/src/rw/RdUtils.m3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ m3-libs/libm3/src/rw/RdUtils.m3	8 Jan 2010 11:08:11 -0000
@@ -12,7 +12,7 @@
 IMPORT ASCII, Rd, Atom, Wr, Text, Text8, Text8Short(**, Text8Literal**);
 IMPORT Thread, TextWr, AtomList;
 
-TYPE FindResult = [-1 .. LAST(CARDINAL)];
+TYPE FindResult = [-1L .. LAST(LONGINT)];
 
 PROCEDURE Find (rd           : Rd.T;
                 pattern      : TEXT;
@@ -49,16 +49,19 @@
                       canonicalize : Canonicalize := NIL): FindResult
   RAISES {Rd.Failure, Thread.Alerted} =
   <*FATAL Rd.EndOfFile*>
-  VAR end := NUMBER(pattern);  i, restart: CARDINAL;  x, y: CHAR;
+  VAR end := NUMBER(pattern);
+      i: CARDINAL;
+      restart: LONGINT;
+      x, y: CHAR;
   BEGIN
     IF end = 0 THEN  RETURN Rd.Index(rd);  END;
     LOOP
-      IF FindChar(rd, pattern[0], canonicalize) = -1 THEN  RETURN -1;  END;
+      IF FindChar(rd, pattern[0], canonicalize) = -1L THEN  RETURN -1L;  END;
       restart := Rd.Index(rd);
       i := 1;
       LOOP
-        IF i = end    THEN  RETURN restart - 1;  END;
-        IF Rd.EOF(rd) THEN  RETURN -1;           END;
+        IF i = end    THEN  RETURN restart - 1L;  END;
+        IF Rd.EOF(rd) THEN  RETURN -1L;           END;
         x := Rd.GetChar(rd);
         y := pattern[i];
         IF x = y OR (canonicalize # NIL
@@ -75,13 +78,13 @@
 PROCEDURE FindChar (rd           : Rd.T;
                     pattern      : CHAR;
                     canonicalize: Canonicalize := NIL):
-  [-1 .. LAST(CARDINAL)] RAISES {Rd.Failure, Thread.Alerted} =
+  FindResult RAISES {Rd.Failure, Thread.Alerted} =
   VAR uc: CHAR;
    <*FATAL Rd.EndOfFile*>
   BEGIN
     IF canonicalize # NIL THEN uc := canonicalize(pattern); END;
     LOOP
-      IF Rd.EOF(rd) THEN RETURN -1; END;
+      IF Rd.EOF(rd) THEN RETURN -1L; END;
       WITH c = Rd.GetChar(rd) DO
         IF c = pattern OR (canonicalize # NIL AND canonicalize(c) = uc) THEN
           RETURN Rd.Index(rd) - 1
Index: m3-libs/libm3/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
--- m3-libs/libm3/src/rw/TextRd.m3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ m3-libs/libm3/src/rw/TextRd.m3	8 Jan 2010 11:08:11 -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: m3-libs/libm3/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
--- m3-libs/libm3/src/rw/TextWr.m3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ m3-libs/libm3/src/rw/TextWr.m3	8 Jan 2010 11:08:12 -0000
@@ -58,16 +58,16 @@
 
 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);
@@ -76,8 +76,8 @@
     wr.cur := n;
   END Seek;
 
-PROCEDURE GotoBuffer (wr: T;  n: INTEGER) =
-  VAR buf := n DIV BufferSize;
+PROCEDURE GotoBuffer (wr: T;  n: LONGINT) =
+  VAR buf := ORD(n DIV BufferSize);
   BEGIN
     WHILE (buf > LAST (wr.buffers^)) DO ExpandBufferPool (wr) END;
     WHILE (wr.n_buffers <= buf) DO
@@ -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: m3-libs/libm3/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
--- m3-libs/libm3/src/rw/UnsafeWr.i3	31 Aug 2009 09:58:08 -0000	1.2
+++ m3-libs/libm3/src/rw/UnsafeWr.i3	8 Jan 2010 11:08:12 -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: m3-libs/libm3/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
--- m3-libs/libm3/src/rw/Wr.i3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ m3-libs/libm3/src/rw/Wr.i3	8 Jan 2010 11:08:12 -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: m3-libs/libm3/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
--- m3-libs/libm3/src/rw/Wr.m3	31 Aug 2009 09:58:08 -0000	1.4
+++ m3-libs/libm3/src/rw/Wr.m3	8 Jan 2010 11:08:12 -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,10 +174,10 @@
     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);
@@ -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: m3-libs/libm3/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
--- m3-libs/libm3/src/rw/WrClass.i3	24 Jan 2001 16:48:02 -0000	1.1.1.1
+++ m3-libs/libm3/src/rw/WrClass.i3	8 Jan 2010 11:08:12 -0000
@@ -81,16 +81,16 @@
 REVEAL
   Wr.T = Private BRANDED OBJECT
            buff       : REF ARRAY OF CHAR;
-           st         : CARDINAL;           (* index into buff *)
-           lo, hi, cur: CARDINAL            := 0; (* indexes into c(wr) *)
+           st         : CARDINAL;       (* index into buff *)
+           lo, hi, cur: LONGINT := 0L;  (* 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: m3-libs/libm3/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
--- m3-libs/libm3/src/sx/Sx.m3	24 Jan 2001 16:48:02 -0000	1.1.1.2
+++ m3-libs/libm3/src/sx/Sx.m3	8 Jan 2010 11:08:12 -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;
@@ -332,7 +332,7 @@
     IF rd.hi >= MAXLEN 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;
 
@@ -407,7 +407,7 @@
       LOOP
         c := Rd.GetChar (rd);
         IF c = delim THEN
-          RETURN Text.FromChars (SUBARRAY (wr.buff^, 0, wr.hi))
+          RETURN Text.FromChars (SUBARRAY (wr.buff^, 0, ORD(wr.hi)))
         ELSIF c = SLASH THEN
           wr.putChar (ReadEscapeSequence (rd, delim))
         ELSIF ISO_Latin_printing (c) THEN
Index: m3-libs/slisp/src/SLisp.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/slisp/src/SLisp.m3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 SLisp.m3
--- m3-libs/slisp/src/SLisp.m3	24 Jan 2001 12:24:49 -0000	1.1.1.1
+++ m3-libs/slisp/src/SLisp.m3	8 Jan 2010 11:08:13 -0000
@@ -1088,9 +1088,9 @@
   (* Record the starting and ending positions of every list we read, so
      that we can highlight the list if there's an error. *)
   VAR
-    start := Rd.Index(rd) - 1;
+    start := ORD(Rd.Index(rd)) - 1;
     form  := Sx.ReadDelimitedList(rd, ')', s);
-    end   := Rd.Index(rd);
+    end   := ORD(Rd.Index(rd));
   BEGIN
     EVAL rm.table.put(start, NEW(Range, start := start, end := end, form := form));
     RETURN RefList.List1(form)
Index: m3-libs/sysutils/src/ConnectRdWr.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-libs/sysutils/src/ConnectRdWr.m3,v
retrieving revision 1.2
diff -u -r1.2 ConnectRdWr.m3
--- m3-libs/sysutils/src/ConnectRdWr.m3	4 Feb 2008 05:40:29 -0000	1.2
+++ m3-libs/sysutils/src/ConnectRdWr.m3	8 Jan 2010 11:08:13 -0000
@@ -35,14 +35,15 @@
 PROCEDURE Apply(self : T) : REFANY = 
   VAR
     lrr := NEW(REF LONGREAL);
-    n, w :  CARDINAL;
+    n: CARDINAL;
+    w: LONGINT;
   BEGIN
     lrr^ := self.offset;
     TRY
       TRY
         WHILE NOT Rd.EOF(self.rd) DO
           n := Rd.CharsReady(self.rd);
-          IF n > 0 THEN                
+          IF n > 0 THEN
             w := RdCopy.ToWriter(self.rd, self.wr, MIN(NUMBER(self.buf^), n));
             Wr.Flush(self.wr); 
           END;
Index: m3-obliq/obliqlibm3/src/ObLibM3.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-obliq/obliqlibm3/src/ObLibM3.m3,v
retrieving revision 1.1.1.2
diff -u -r1.1.1.2 ObLibM3.m3
--- m3-obliq/obliqlibm3/src/ObLibM3.m3	24 Jan 2001 21:52:38 -0000	1.1.1.2
+++ m3-obliq/obliqlibm3/src/ObLibM3.m3	8 Jan 2010 11:08:14 -0000
@@ -228,7 +228,7 @@
               ObValue.BadArgVal(1, "non-closed", self.name, opCode.name, loc);
               <*ASSERT FALSE*>
             END;
-            RETURN NEW(ObValue.ValInt, int:=Rd.Index(rd1), temp:=temp);
+            RETURN NEW(ObValue.ValInt, int:=ORD(Rd.Index(rd1)), temp:=temp);
         | RdCode.Length => 
             TYPECASE args[1] OF | ValRd(node) => rd1 := node.rd;
             ELSE 
@@ -244,7 +244,7 @@
                                 opCode.name,loc);
               <*ASSERT FALSE*>
             END;
-            RETURN NEW(ObValue.ValInt, int:=Rd.Length(rd1), temp:=temp);
+            RETURN NEW(ObValue.ValInt, int:=ORD(Rd.Length(rd1)), temp:=temp);
         | RdCode.Seek => 
             TYPECASE args[1] OF | ValRd(node) => rd1 := node.rd;
             ELSE 
@@ -471,14 +471,14 @@
             IF Wr.Closed(wr1) THEN
               ObValue.BadArgVal(1, "non-closed", self.name, opCode.name, loc);<*ASSERT FALSE*>
             END;
-            RETURN NEW(ObValue.ValInt, int:=Wr.Index(wr1), temp:=temp);
+            RETURN NEW(ObValue.ValInt, int:=ORD(Wr.Index(wr1)), temp:=temp);
         | WrCode.Length => 
             TYPECASE args[1] OF | ValWr(node) => wr1 := node.wr;
             ELSE ObValue.BadArgType(1, "wr", self.name, opCode.name, loc); <*ASSERT FALSE*>END;
             IF Wr.Closed(wr1) THEN
               ObValue.BadArgVal(1, "non-closed", self.name, opCode.name, loc);<*ASSERT FALSE*>
             END;
-            RETURN NEW(ObValue.ValInt, int:=Wr.Length(wr1), temp:=temp);
+            RETURN NEW(ObValue.ValInt, int:=ORD(Wr.Length(wr1)), temp:=temp);
         | WrCode.Seek => 
             TYPECASE args[1] OF | ValWr(node) => wr1 := node.wr;
             ELSE ObValue.BadArgType(1, "wr", self.name, opCode.name, loc); <*ASSERT FALSE*>END;
Index: m3-sys/cm3/src/WebFile.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/cm3/src/WebFile.m3,v
retrieving revision 1.2
diff -u -r1.2 WebFile.m3
--- m3-sys/cm3/src/WebFile.m3	6 Apr 2008 09:16:59 -0000	1.2
+++ m3-sys/cm3/src/WebFile.m3	8 Jan 2010 11:08:14 -0000
@@ -66,7 +66,7 @@
     rd  := Utils.OpenReader (InfoFile, fatal := FALSE);
     IF (rd = NIL) THEN RETURN NIL END;
     TRY
-      len := rd.status().size;
+      len := ORD(rd.status().size);
       IF (len > 0) THEN
         buf := NEW (CharList, len);
         xxx := M3File.Read (rd, buf^, len);
Index: m3-sys/cm3ide/src/misc/LineWr.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/cm3ide/src/misc/LineWr.m3,v
retrieving revision 1.1
diff -u -r1.1 LineWr.m3
--- m3-sys/cm3ide/src/misc/LineWr.m3	21 Jun 2008 04:31:31 -0000	1.1
+++ m3-sys/cm3ide/src/misc/LineWr.m3	8 Jan 2010 11:08:14 -0000
@@ -60,19 +60,19 @@
     END;
   END Clear;
 
-PROCEDURE Length (wr: T): CARDINAL RAISES {} =
+PROCEDURE Length (wr: T): LONGINT RAISES {} =
   BEGIN
     RETURN wr.cur;
   END Length;
 
-PROCEDURE Seek(wr: T; n: CARDINAL)
+PROCEDURE Seek(wr: T; n: LONGINT)
   RAISES {Wr.Failure, Thread.Alerted} =
   BEGIN
     <*ASSERT wr.cur = wr.hi *>
     AddChar (wr, wr.buff[0]);
     wr.cur := n;
     wr.lo  := n;
-    wr.hi  := n+1;
+    wr.hi  := n + 1L;
   END Seek;
 
 PROCEDURE Flush(wr: T)
Index: m3-sys/cm3ide/src/nodes/Type.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/cm3ide/src/nodes/Type.m3,v
retrieving revision 1.1
diff -u -r1.1 Type.m3
--- m3-sys/cm3ide/src/nodes/Type.m3	21 Jun 2008 04:31:52 -0000	1.1
+++ m3-sys/cm3ide/src/nodes/Type.m3	8 Jan 2010 11:08:14 -0000
@@ -807,7 +807,7 @@
              a := ReadInt (line, cur);  (* # formals *)
              b := ReadUID (line, cur);  (* return type *)
              c := ReadInt (line, cur);  (* # raises *)
-             d := Rd.Index (rd);
+             d := ORD(Rd.Index (rd));
              fmt.begin (2);
                IF (NOT sig_only) THEN
                  fmt.putText ("PROCEDURE ");
@@ -864,7 +864,7 @@
              e := ReadInt (line, cur); (* # overrides *)
              EVAL ReadInt (line, cur); (* total field size *)
              id := ReadBrand (line, cur);
-             f := Rd.Index (rd);
+             f := ORD(Rd.Index (rd));
 
              fmt.begin (2);
                IF (b # 0) THEN (* super type *)
Index: m3-sys/cm3ide/src/utils/Buf.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/cm3ide/src/utils/Buf.m3,v
retrieving revision 1.1
diff -u -r1.1 Buf.m3
--- m3-sys/cm3ide/src/utils/Buf.m3	21 Jun 2008 04:33:07 -0000	1.1
+++ m3-sys/cm3ide/src/utils/Buf.m3	8 Jan 2010 11:08:14 -0000
@@ -20,7 +20,7 @@
   BEGIN
     TRY
       f := FS.OpenFileReadonly (path);
-      len := f.status().size;
+      len := ORD(f.status().size);
       t := NEW (T, len + pad);
 
       next := 0;
Index: m3-sys/cminstall/src/config-no-install/NT386.common
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/cminstall/src/config-no-install/NT386.common,v
retrieving revision 1.13
diff -u -r1.13 NT386.common
--- m3-sys/cminstall/src/config-no-install/NT386.common	13 Dec 2009 16:39:15 -0000	1.13
+++ m3-sys/cminstall/src/config-no-install/NT386.common	8 Jan 2010 11:08:15 -0000
@@ -334,7 +334,7 @@
     if defined("pos")
        Listing = Path_GetBase (source) & ".lst"
     end
-    local readonly Command = ["cl.exe", escape(subst_chars(args, "\\", "/")), "-c", escape(source)]
+    local readonly Command = ["cl.exe", "-EHs", escape(subst_chars(args, "\\", "/")), "-c", "-Tp", escape(source)]
     local ret = try_exec("@" & Command, ">", Listing)
     if not equal (ret, 0)
         write (Command & CR)
Index: m3-sys/fix_nl/src/Main.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/fix_nl/src/Main.m3,v
retrieving revision 1.3
diff -u -r1.3 Main.m3
--- m3-sys/fix_nl/src/Main.m3	12 Feb 2001 15:25:03 -0000	1.3
+++ m3-sys/fix_nl/src/Main.m3	8 Jan 2010 11:08:15 -0000
@@ -81,11 +81,11 @@
       f := FS.OpenFileReadonly (path);
       TRY
         stat := f.status ();
-        IF (stat.size <= 0) THEN RETURN; END;
-        MakeRoom (stat.size);
-        in_len := f.read (SUBARRAY (inbuf^, 0, stat.size), mayBlock := TRUE);
-        IF (in_len # stat.size) THEN
-          Err ("unable to read: ", path, ": expected " & Fmt.Int (stat.size)
+        IF (stat.size <= 0L) THEN RETURN; END;
+        MakeRoom (ORD(stat.size));
+        in_len := f.read (SUBARRAY (inbuf^, 0, ORD(stat.size)), mayBlock := TRUE);
+        IF (in_len # ORD(stat.size)) THEN
+          Err ("unable to read: ", path, ": expected " & Fmt.Int (ORD(stat.size))
                & " bytes, but got " & Fmt.Int (in_len));
           RETURN;
         END;
Index: m3-sys/libdump/src/Main.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/libdump/src/Main.m3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 Main.m3
--- m3-sys/libdump/src/Main.m3	14 Jan 2001 13:40:21 -0000	1.1.1.1
+++ m3-sys/libdump/src/Main.m3	8 Jan 2010 11:08:15 -0000
@@ -60,7 +60,7 @@
   RAISES {Rd.Failure, Thread.Alerted, Wr.Failure} =
   VAR
     hdr: Header;
-    here := Rd.Index (rd);
+    here := ORD(Rd.Index (rd));
     nm_offs : INTEGER;
     size    : INTEGER;
   BEGIN
Index: m3-sys/m3front/src/builtinOps/Dec.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3front/src/builtinOps/Dec.m3,v
retrieving revision 1.9
diff -u -r1.9 Dec.m3
--- m3-sys/m3front/src/builtinOps/Dec.m3	25 Sep 2009 02:42:10 -0000	1.9
+++ m3-sys/m3front/src/builtinOps/Dec.m3	8 Jan 2010 11:08:17 -0000
@@ -44,8 +44,8 @@
     IF (NUMBER (ce.args^) > 1) THEN
       IF Type.IsSubtype (t, LInt.T) THEN
         t := Type.Base (Expr.TypeOf (ce.args[1]));
-        IF (t # LInt.T) THEN
-          Error.Txt (name, "second argument must be a LONGINT");
+        IF t # LInt.T AND t # Int.T THEN
+          Error.Txt (name, "second argument must be a INTEGER or LONGINT");
         END;
       ELSE
         t := Type.Base (Expr.TypeOf (ce.args[1]));
Index: m3-sys/m3front/src/builtinOps/Max.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3front/src/builtinOps/Max.m3,v
retrieving revision 1.3
diff -u -r1.3 Max.m3
--- m3-sys/m3front/src/builtinOps/Max.m3	18 Sep 2007 20:25:36 -0000	1.3
+++ m3-sys/m3front/src/builtinOps/Max.m3	8 Jan 2010 11:08:17 -0000
@@ -25,11 +25,14 @@
 
 PROCEDURE DoCheck (name: TEXT;  ce: CallExpr.T) =
   VAR ta, tb: Type.T;
+      resultType: Type.T := NIL;
   BEGIN
     ta := Type.Base (Expr.TypeOf (ce.args[0]));
     tb := Type.Base (Expr.TypeOf (ce.args[1]));
 
-    IF (NOT Type.IsEqual (ta, tb, NIL)) THEN
+    IF (ta = LInt.T AND tb = Int.T) OR (tb = LInt.T AND ta = Int.T) THEN
+      resultType := LInt.T;
+    ELSIF (NOT Type.IsEqual (ta, tb, NIL)) THEN
       Error.Txt (name, "incompatible argument types");
     ELSIF (ta = Int.T) OR (ta = LInt.T) OR (Type.IsOrdinal (ta)) THEN
       (* ok *)
@@ -39,7 +42,11 @@
       Error.Txt (name, "wrong argument types");
       ta := Int.T;
     END;
-    ce.type := ta;
+    IF resultType # NIL THEN
+      ce.type := resultType;
+    ELSE
+      ce.type := ta;
+    END;
   END DoCheck;
 
 PROCEDURE Compile (ce: CallExpr.T) =
Index: m3-sys/m3front/src/builtinOps/Min.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3front/src/builtinOps/Min.m3,v
retrieving revision 1.2
diff -u -r1.2 Min.m3
--- m3-sys/m3front/src/builtinOps/Min.m3	18 Sep 2007 20:25:36 -0000	1.2
+++ m3-sys/m3front/src/builtinOps/Min.m3	8 Jan 2010 11:08:17 -0000
@@ -9,13 +9,21 @@
 MODULE Min;
 
 IMPORT CG, CallExpr, Expr, Type, Procedure, Max;
-IMPORT IntegerExpr, EnumExpr, ReelExpr, Target, TInt;
+IMPORT IntegerExpr, EnumExpr, ReelExpr, Target, TInt, Int, LInt;
 
 VAR Z: CallExpr.MethodList;
 
 PROCEDURE Check (ce: CallExpr.T;  <*UNUSED*> VAR cs: Expr.CheckState) =
+  VAR ta, tb: Type.T;
   BEGIN
-    Max.DoCheck ("MIN", ce);
+    ta := Type.Base (Expr.TypeOf (ce.args[0]));
+    tb := Type.Base (Expr.TypeOf (ce.args[1]));
+
+    IF (ta = LInt.T AND tb = Int.T) OR (ta = Int.T AND tb = LInt.T) THEN
+      (*ce.type := ta;*)
+    ELSE
+      Max.DoCheck("MIN", ce);
+    END;
   END Check;
 
 PROCEDURE Compile (ce: CallExpr.T) =
Index: m3-sys/m3front/src/exprs/AddExpr.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3front/src/exprs/AddExpr.m3,v
retrieving revision 1.3
diff -u -r1.3 AddExpr.m3
--- m3-sys/m3front/src/exprs/AddExpr.m3	4 May 2008 11:03:45 -0000	1.3
+++ m3-sys/m3front/src/exprs/AddExpr.m3	8 Jan 2010 11:08:17 -0000
@@ -67,6 +67,7 @@
 
 PROCEDURE Check (p: P;  VAR cs: Expr.CheckState) =
   VAR ta, tb, range: Type.T;
+      resultType: Type.T := NIL;
   BEGIN
     Expr.TypeCheck (p.a, cs);
     Expr.TypeCheck (p.b, cs);
@@ -74,8 +75,9 @@
     tb := Type.Base (Expr.TypeOf (p.b));
     IF    (ta = Int.T)   AND (tb = Int.T)   THEN
       p.class := Class.cINT;
-    ELSIF (ta = LInt.T)  AND (tb = LInt.T) THEN
-      p.class := Class.cLINT
+    ELSIF (ta = LInt.T OR ta = Int.T) AND (tb = LInt.T OR tb = Int.T) THEN
+      p.class := Class.cLINT;
+      resultType := LInt.T;
     ELSIF (ta = Reel.T)  AND (tb = Reel.T)  THEN
       p.class := Class.cREAL;
     ELSIF (ta = LReel.T) AND (tb = LReel.T) THEN
@@ -96,7 +98,11 @@
     ELSE
       ta := Expr.BadOperands ("\'+\'", ta, tb);
     END;
-    p.type := ta;
+    IF resultType # NIL THEN
+      p.type := resultType;
+    ELSE
+      p.type := ta;
+    END;
   END Check;
 
 PROCEDURE Prep (p: P) =
Index: m3-sys/m3front/src/exprs/CompareExpr.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3front/src/exprs/CompareExpr.m3,v
retrieving revision 1.5
diff -u -r1.5 CompareExpr.m3
--- m3-sys/m3front/src/exprs/CompareExpr.m3	4 May 2008 11:03:45 -0000	1.5
+++ m3-sys/m3front/src/exprs/CompareExpr.m3	8 Jan 2010 11:08:17 -0000
@@ -89,7 +89,7 @@
     tb := Type.Base (Expr.TypeOf (p.b));
     p.class := cINT;
     IF    (ta = Int.T)   AND (tb = Int.T)    THEN  p.class := cINT;
-    ELSIF (ta = LInt.T)  AND (tb = LInt.T)   THEN  p.class := cLINT;
+    ELSIF (ta = LInt.T OR ta = Int.T) AND (tb = LInt.T OR tb = Int.T) THEN  p.class := cLINT;
     ELSIF (ta = Reel.T)  AND (tb = Reel.T)   THEN  p.class := cREAL;
     ELSIF (ta = LReel.T) AND (tb = LReel.T)  THEN  p.class := cLONG;
     ELSIF (ta = EReel.T) AND (tb = EReel.T)  THEN  p.class := cEXTND;
Index: m3-sys/m3front/src/exprs/DivExpr.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3front/src/exprs/DivExpr.m3,v
retrieving revision 1.5
diff -u -r1.5 DivExpr.m3
--- m3-sys/m3front/src/exprs/DivExpr.m3	4 May 2008 11:03:46 -0000	1.5
+++ m3-sys/m3front/src/exprs/DivExpr.m3	8 Jan 2010 11:08:17 -0000
@@ -60,7 +60,7 @@
     tb := Type.Base (Expr.TypeOf (p.b));
     IF (ta = Int.T) AND (tb = Int.T) THEN
       p.type := Int.T;
-    ELSIF (ta = LInt.T) AND (tb = LInt.T) THEN
+    ELSIF (ta = LInt.T OR ta = Int.T) AND (tb = LInt.T OR tb = Int.T) THEN
       p.type := LInt.T;
     ELSE
       p.type := Expr.BadOperands ("DIV", ta, tb);
Index: m3-sys/m3front/src/exprs/ModExpr.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3front/src/exprs/ModExpr.m3,v
retrieving revision 1.5
diff -u -r1.5 ModExpr.m3
--- m3-sys/m3front/src/exprs/ModExpr.m3	4 May 2008 11:03:46 -0000	1.5
+++ m3-sys/m3front/src/exprs/ModExpr.m3	8 Jan 2010 11:08:17 -0000
@@ -60,6 +60,7 @@
 
 PROCEDURE Check (p: P;  VAR cs: Expr.CheckState) =
   VAR ta, tb: Type.T;
+      resultType: Type.T := NIL;
   BEGIN
     Expr.TypeCheck (p.a, cs);
     Expr.TypeCheck (p.b, cs);
@@ -67,8 +68,18 @@
     tb := Type.Base (Expr.TypeOf (p.b));
     IF    (ta = Int.T)   AND (tb = Int.T)   THEN
       p.class := Class.cINT;
+
     ELSIF (ta = LInt.T)  AND (tb = LInt.T)  THEN
       p.class := Class.cLINT;
+
+    (* The result of MOD cannot be higher than either of its inputs.
+     * small divided by big is 0 remainder small
+     * big divided by small has a remainder of at most small
+     *)
+    ELSIF (ta = LInt.T OR ta = Int.T) AND (tb = LInt.T OR tb = Int.T) THEN
+      p.class := Class.cINT;
+      resultType := Int.T;
+
     ELSIF (ta = Reel.T)  AND (tb = Reel.T)  THEN
       p.class := Class.cREAL;
     ELSIF (ta = LReel.T) AND (tb = LReel.T) THEN
@@ -78,7 +89,11 @@
     ELSE p.class := Class.cERR;  ta := Int.T;
       ta := Expr.BadOperands ("MOD", ta, tb);
     END;
-    p.type := ta;
+    IF resultType # NIL THEN
+      p.type := resultType;
+    ELSE
+      p.type := ta;
+    END;
   END Check;
 
 PROCEDURE Prep (p: P) =
Index: m3-sys/m3front/src/exprs/MultiplyExpr.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3front/src/exprs/MultiplyExpr.m3,v
retrieving revision 1.3
diff -u -r1.3 MultiplyExpr.m3
--- m3-sys/m3front/src/exprs/MultiplyExpr.m3	4 May 2008 11:03:46 -0000	1.3
+++ m3-sys/m3front/src/exprs/MultiplyExpr.m3	8 Jan 2010 11:08:17 -0000
@@ -66,6 +66,7 @@
 
 PROCEDURE Check (p: P;  VAR cs: Expr.CheckState) =
   VAR ta, tb, range: Type.T;
+      resultType: Type.T := NIL;
   BEGIN
     Expr.TypeCheck (p.a, cs);
     Expr.TypeCheck (p.b, cs);
@@ -73,8 +74,9 @@
     tb := Type.Base (Expr.TypeOf (p.b));
     IF    (tb = Int.T)   AND (ta = Int.T)   THEN
       p.class := cINT;
-    ELSIF (tb = LInt.T)  AND (ta = LInt.T)  THEN
+    ELSIF (ta = LInt.T OR ta = Int.T) AND (tb = LInt.T OR tb = Int.T) THEN
       p.class := cLINT;
+      resultType := LInt.T;
     ELSIF (tb = Reel.T)  AND (ta = Reel.T)  THEN
       p.class := cREAL;
     ELSIF (tb = LReel.T) AND (ta = LReel.T) THEN
@@ -90,7 +92,11 @@
       ta := Expr.BadOperands ("\'*\'", ta, tb);
       p.class := cINT;
     END;
-    p.type := ta;
+    IF resultType # NIL THEN
+      p.type := resultType;
+    ELSE
+      p.type := ta;
+    END;
   END Check;
 
 PROCEDURE Prep (p: P) =
Index: m3-sys/m3front/src/exprs/SubtractExpr.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3front/src/exprs/SubtractExpr.m3,v
retrieving revision 1.4
diff -u -r1.4 SubtractExpr.m3
--- m3-sys/m3front/src/exprs/SubtractExpr.m3	4 May 2008 11:03:46 -0000	1.4
+++ m3-sys/m3front/src/exprs/SubtractExpr.m3	8 Jan 2010 11:08:17 -0000
@@ -73,6 +73,7 @@
 
 PROCEDURE Check (p: P;  VAR cs: Expr.CheckState) =
   VAR ta, tb, range: Type.T;
+      resultType: Type.T := NIL;
   BEGIN
     Expr.TypeCheck (p.a, cs);
     Expr.TypeCheck (p.b, cs);
@@ -80,8 +81,9 @@
     tb := Type.Base (Expr.TypeOf (p.b));
     IF    (ta = Int.T)   AND (tb = Int.T)   THEN
       p.class := Class.cINT;
-    ELSIF (ta = LInt.T)  AND (tb = LInt.T)  THEN
+    ELSIF (ta = LInt.T OR ta = Int.T) AND (tb = LInt.T OR tb = Int.T) THEN
       p.class := Class.cLINT;
+      resultType := LInt.T;
     ELSIF (ta = Reel.T)  AND (tb = Reel.T)  THEN
       p.class := Class.cREAL;
     ELSIF (ta = LReel.T) AND (tb = LReel.T) THEN
@@ -113,7 +115,11 @@
       ta := Expr.BadOperands ("\'-\'", ta, tb);
       p.class := Class.cINT;
     END;
-    p.type := ta;
+    IF resultType # NIL THEN
+      p.type := resultType;
+    ELSE
+      p.type := ta;
+    END;
   END Check;
 
 PROCEDURE Prep (p: P) =
Index: m3-sys/m3front/src/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
--- m3-sys/m3front/src/types/Type.m3	4 May 2008 11:03:49 -0000	1.8
+++ m3-sys/m3front/src/types/Type.m3	8 Jan 2010 11:08:17 -0000
@@ -543,6 +543,10 @@
     IF IsEqual (a, b, NIL) OR IsSubtype (b, a) THEN
       RETURN TRUE;
     ELSIF IsOrdinal (a) THEN
+      (* INTEGER and CARDINAL are assignable to LONGINT *)
+      IF a = LInt.T AND (b = Int.T OR b = Card.T) THEN
+        RETURN TRUE;
+      END;
       (* 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)
Index: m3-sys/m3quake/src/QScanner.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3quake/src/QScanner.m3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 QScanner.m3
--- m3-sys/m3quake/src/QScanner.m3	14 Jan 2001 13:40:39 -0000	1.1.1.1
+++ m3-sys/m3quake/src/QScanner.m3	8 Jan 2010 11:08:21 -0000
@@ -43,8 +43,8 @@
     (* slurp the source into memory *)
     TRY
       status := f.status ();
-      t.buffer := NEW (REF ARRAY OF CHAR, MAX (0, status.size) + 1);
-      t.buflen := M3File.Read (f, t.buffer^, status.size);
+      t.buffer := NEW (REF ARRAY OF CHAR, MAX (0, ORD(status.size)) + 1);
+      t.buflen := M3File.Read (f, t.buffer^, ORD(status.size));
       IF (t.buflen # status.size) THEN RETURN NIL; END;
       t.buffer [t.buflen] := EOFChar;
     EXCEPT OSError.E => RETURN NIL;
Index: m3-sys/m3scanner/src/M3Scanner.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3scanner/src/M3Scanner.m3,v
retrieving revision 1.2
diff -u -r1.2 M3Scanner.m3
--- m3-sys/m3scanner/src/M3Scanner.m3	8 Aug 2007 03:50:06 -0000	1.2
+++ m3-sys/m3scanner/src/M3Scanner.m3	8 Jan 2010 11:08:21 -0000
@@ -76,7 +76,7 @@
 
     (* read the source *)
     TRY
-      len0 := Rd.Length (source);
+      len0 := ORD(Rd.Length (source));
       t.buffer := NEW (Buf, MAX (0, len0) + 1);
       IF (len0 < 0) THEN Err (t, 0, "can't tell how much source there is") END;
       len1 := Rd.GetSub (source, t.buffer^);
Index: m3-sys/mklib/src/Main.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/mklib/src/Main.m3,v
retrieving revision 1.5
diff -u -r1.5 Main.m3
--- m3-sys/mklib/src/Main.m3	1 Jul 2009 11:10:55 -0000	1.5
+++ m3-sys/mklib/src/Main.m3	8 Jan 2010 11:08:21 -0000
@@ -283,7 +283,7 @@
       file   := FS.OpenFileReadonly (f.name);
       stat   := file.status ();
       f.time := stat.modificationTime;
-      f.size := stat.size;
+      f.size := ORD(stat.size);
       IF (stat.type # RegularFile.FileType) THEN
         Die ("\"", f.name, "\" is not a regular file.");
       END;
@@ -302,7 +302,7 @@
       f.tag := f.name & "/";
     ELSE
       IF (long_nms = NIL) THEN long_nms := TextWr.New (); END;
-      VAR offs := Wr.Index (long_nms); <*FATAL Wr.Failure, Thread.Alerted*> BEGIN
+      VAR offs := ORD(Wr.Index (long_nms)); <*FATAL Wr.Failure, Thread.Alerted*> BEGIN
         Wr.PutText (long_nms, f.name);
         Wr.PutChar (long_nms, '\000');
         f.tag := "/" & Fmt.Int (offs);
@@ -513,7 +513,7 @@
 
     IF (long_nms # NIL) THEN
       (* long filename table *)
-      INC (offs, Hdr + Wr.Index (long_nms));
+      INC (offs, Hdr + ORD(Wr.Index (long_nms)));
       IF (offs MOD 2 # 0) THEN INC (offs); END;
     END;
 
@@ -624,7 +624,7 @@
   VAR len, odd: INTEGER;
   BEGIN
     IF (long_nms = NIL) THEN RETURN; END;
-    len := Wr.Index (long_nms);
+    len := ORD(Wr.Index (long_nms));
     odd := len MOD 2;
     WriteHeader ("//", "0", lib_time, len);
     Wr.PutText (lib_wr, TextWr.ToText (long_nms));
Index: m3-tools/cmpdir/src/Main.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-tools/cmpdir/src/Main.m3,v
retrieving revision 1.2
diff -u -r1.2 Main.m3
--- m3-tools/cmpdir/src/Main.m3	12 Feb 2001 15:26:17 -0000	1.2
+++ m3-tools/cmpdir/src/Main.m3	8 Jan 2010 11:08:21 -0000
@@ -115,7 +115,7 @@
   BEGIN
     TRY
       f := FS.OpenFileReadonly (fn);
-      len := f.status().size;
+      len := ORD(f.status().size);
       IF len > NUMBER (buf^) THEN ExpandBuf (buf, len); END;
 
       next := 0;
Index: m3-tools/dirfp/src/Main.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-tools/dirfp/src/Main.m3,v
retrieving revision 1.2
diff -u -r1.2 Main.m3
--- m3-tools/dirfp/src/Main.m3	12 Feb 2001 15:26:25 -0000	1.2
+++ m3-tools/dirfp/src/Main.m3	8 Jan 2010 11:08:21 -0000
@@ -107,7 +107,7 @@
   BEGIN
     TRY
       f := FS.OpenFileReadonly (fn);
-      len := f.status().size;
+      len := ORD(f.status().size);
       IF len > NUMBER (buf^) THEN ExpandBuf (buf, len); END;
 
       next := 0;
Index: m3-tools/m3bundle/src/m3bundle.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-tools/m3bundle/src/m3bundle.m3,v
retrieving revision 1.2
diff -u -r1.2 m3bundle.m3
--- m3-tools/m3bundle/src/m3bundle.m3	9 Jul 2003 16:06:16 -0000	1.2
+++ m3-tools/m3bundle/src/m3bundle.m3	8 Jan 2010 11:08:21 -0000
@@ -45,7 +45,7 @@
       WITH z = elts[i] DO
         TRY
           rd := FileRd.Open (z.path);
-          z.length := Rd.Length (rd);
+          z.length := ORD(Rd.Length (rd));
           z.blocks := (z.length + MaxBlock - 1) DIV MaxBlock;
           z.base   := "E" & Fmt.Int (i);
           max_blocks := MAX (max_blocks, z.blocks);
Index: m3-tools/m3scan/src/M3Scanner.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-tools/m3scan/src/M3Scanner.m3,v
retrieving revision 1.3
diff -u -r1.3 M3Scanner.m3
--- m3-tools/m3scan/src/M3Scanner.m3	16 Jul 2009 19:56:45 -0000	1.3
+++ m3-tools/m3scan/src/M3Scanner.m3	8 Jan 2010 11:08:22 -0000
@@ -64,7 +64,7 @@
 
     (* read the source *)
     TRY
-      len0 := Rd.Length (source);
+      len0 := ORD(Rd.Length (source));
       t.buffer := NEW (Buf, MAX (0, len0) + 1);
       IF (len0 < 0) THEN Err (t, 0, "can't tell how much source there is") END;
       len1 := Rd.GetSub (source, t.buffer^);
Index: m3-tools/m3tk/src/files/Common/M3DirFindFile.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-tools/m3tk/src/files/Common/M3DirFindFile.m3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 M3DirFindFile.m3
--- m3-tools/m3tk/src/files/Common/M3DirFindFile.m3	13 Jan 2001 14:46:59 -0000	1.1.1.1
+++ m3-tools/m3tk/src/files/Common/M3DirFindFile.m3	8 Jan 2010 11:08:22 -0000
@@ -44,7 +44,7 @@
   END;
 
 TYPE
-  TFileLoc = REF RECORD index: CARDINAL; elem: M3PathElem.T END;
+  TFileLoc = REF RECORD index: LONGINT; elem: M3PathElem.T END;
  
 TYPE
   IndexToExts = ARRAY [ORD(FIRST(M3Extension.T))..ORD(LAST(M3Extension.T))]
Index: m3-tools/m3tohtml/src/DBRd.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-tools/m3tohtml/src/DBRd.m3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 DBRd.m3
--- m3-tools/m3tohtml/src/DBRd.m3	13 Jan 2001 14:47:03 -0000	1.1.1.1
+++ m3-tools/m3tohtml/src/DBRd.m3	8 Jan 2010 11:08:22 -0000
@@ -30,7 +30,7 @@
     t.cur := 0;
     TRY
       f     := FS.OpenFileReadonly (path);
-      sz    := f.status().size;
+      sz    := ORD(f.status().size);
       t.buf := NEW (REF ARRAY OF CHAR, MAX (1, sz));
       ptr   := ADR (t.buf[0]);
       t.len := f.read (SUBARRAY (ptr^, 0, NUMBER (t.buf^)), mayBlock := TRUE);
Index: m3-tools/m3tohtml/src/MarkUp.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-tools/m3tohtml/src/MarkUp.m3,v
retrieving revision 1.3
diff -u -r1.3 MarkUp.m3
--- m3-tools/m3tohtml/src/MarkUp.m3	9 Feb 2008 14:20:14 -0000	1.3
+++ m3-tools/m3tohtml/src/MarkUp.m3	8 Jan 2010 11:08:22 -0000
@@ -31,7 +31,8 @@
 
 PROCEDURE Annotate (rd: Rd.T;  wr: Wr.T;  path: TEXT)
   RAISES {Thread.Alerted, Wr.Failure, Rd.Failure} =
-  VAR s: State;  here: CARDINAL;
+  VAR s: State;
+      here: LONGINT;
   BEGIN
     s.rd   := rd;
     s.wr   := wr;
Index: m3-tools/rehearsecode/src/RehearseCode.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-tools/rehearsecode/src/RehearseCode.m3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 RehearseCode.m3
--- m3-tools/rehearsecode/src/RehearseCode.m3	13 Jan 2001 14:47:05 -0000	1.1.1.1
+++ m3-tools/rehearsecode/src/RehearseCode.m3	8 Jan 2010 11:08:22 -0000
@@ -54,7 +54,7 @@
            closed := FALSE, seekable := FALSE, buffered := FALSE);
   END NewWriter;
 
-PROCEDURE Seek (wr: Writer; <* UNUSED *> n: CARDINAL)
+PROCEDURE Seek (wr: Writer; <* UNUSED *> n: LONGINT)
   RAISES {Wr.Failure, Thread.Alerted} =
   BEGIN
     wr.flush ()
@@ -64,7 +64,7 @@
   BEGIN
     TextPort.PutText (
       wr.typescript.tp,
-      Text.FromChars (SUBARRAY (wr.buff^, 0, wr.cur - wr.lo)));
+      Text.FromChars (SUBARRAY (wr.buff^, 0, ORD(wr.cur - wr.lo))));
     wr.lo := wr.cur;
     wr.hi := wr.lo + NUMBER (wr.buff^);
     IF Thread.TestAlert () THEN RAISE Thread.Alerted END
Index: m3-ui/codeview/src/CodeView.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-ui/codeview/src/CodeView.m3,v
retrieving revision 1.2
diff -u -r1.2 CodeView.m3
--- m3-ui/codeview/src/CodeView.m3	17 Mar 2008 03:45:22 -0000	1.2
+++ m3-ui/codeview/src/CodeView.m3	8 Jan 2010 11:08:22 -0000
@@ -243,7 +243,7 @@
             pos := NEW (Position);
             tag := "0";
             id := 0;
-            pos.start := Wr.Index (procWr);
+            pos.start := ORD(Wr.Index (procWr));
             state := State.InStat;
           ELSE
             Wr.PutChar (tagWr, c);
@@ -252,7 +252,7 @@
           IF c = '@' THEN
             IF replaceTags THEN
               pos := NEW (Position);            (* JK, 11-JUN-96 *)
-              pos.start := Wr.Index (procWr);   (* JK, 11-JUN-96 *)
+              pos.start := ORD(Wr.Index (procWr)) ;(* JK, 11-JUN-96 *)
               Wr.PutChar (procWr, ' ');	        (* JK, 07-JUN-96 *)
             END;
             state := State.ProcAt;
@@ -305,11 +305,11 @@
                 errorWr,
                 Fmt.F (
                   "duplicate statement tag '@%s' at offsets %s and %s\n",
-                  tag, Fmt.Int (pos.start), Fmt.Int (Rd.Index (rd))));
+                  tag, Fmt.Int (pos.start), Fmt.LongInt (Rd.Index (rd))));
             END;
             IF NOT replaceTags THEN
               pos := NEW (Position);             (* JK, 11-JUN-96 *)
-              pos.start := Wr.Index (procWr);    (* JK, 11-JUN-96 *)
+              pos.start := ORD(Wr.Index (procWr)); (* JK, 11-JUN-96 *)
             END;
             state := State.InStat;
           END;
@@ -324,7 +324,7 @@
             Wr.PutChar (procWr, c);
             state := State.InStat;
           ELSE
-            pos.end := Wr.Index (procWr);
+            pos.end := ORD(Wr.Index (procWr));
             EVAL proc.offsets.put (id, pos);
             Wr.PutChar (procWr, c);
             state := State.InProc;
@@ -362,7 +362,7 @@
                       "unmatched procedure header (@%s) at end-of-file\n",
                       name));
     | State.StatAt =>
-        pos.end := Wr.Index (procWr);
+        pos.end := ORD(Wr.Index (procWr));
         EVAL proc.offsets.put (Lex.Int (TextRd.New (tag)), pos);
         Wr.PutText (errorWr,
                     Fmt.F (
Index: m3-ui/formsedit/src/FormsEditVBT.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-ui/formsedit/src/FormsEditVBT.m3,v
retrieving revision 1.2
diff -u -r1.2 FormsEditVBT.m3
--- m3-ui/formsedit/src/FormsEditVBT.m3	17 Mar 2008 03:45:24 -0000	1.2
+++ m3-ui/formsedit/src/FormsEditVBT.m3	8 Jan 2010 11:08:23 -0000
@@ -213,7 +213,7 @@
         IF NOT RefList.Member (frame.path, dir) THEN
           frame.path := RefList.Cons (dir, frame.path)
         END;
-        TextPort.SetText (ed.textport, Rd.GetText (rd, Rd.Length (rd)));
+        TextPort.SetText (ed.textport, Rd.GetText (rd, ORD(Rd.Length (rd))));
         TextPort.SetModified (ed.textport, FALSE);
         SetModified (ed, FALSE);
         Parse (frame);
@@ -1254,9 +1254,9 @@
   (* Record the starting and ending positions of every list we read, so that
      we can highlight the list if there's an error. *)
   VAR
-    start := Rd.Index (rd) - 1;
+    start := ORD(Rd.Index (rd) - 1);
     form  := Sx.ReadDelimitedList (rd, ')', s);
-    end   := Rd.Index (rd);
+    end   := ORD(Rd.Index (rd));
   BEGIN
     EVAL rm.ed.rangeTable.put (
            start, NEW (Range, start := start, end := end, form := form));
Index: m3-ui/formsvbt/src/FVRuntime.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-ui/formsvbt/src/FVRuntime.m3,v
retrieving revision 1.2
diff -u -r1.2 FVRuntime.m3
--- m3-ui/formsvbt/src/FVRuntime.m3	17 Mar 2008 03:45:24 -0000	1.2
+++ m3-ui/formsvbt/src/FVRuntime.m3	8 Jan 2010 11:08:23 -0000
@@ -1486,7 +1486,7 @@
         TRY t.rd := Rsrc.Open (text, fv.path) EXCEPT
         | Rsrc.NotFound => RAISE Error("No such resource: " & text)
         END;
-        TRY len := Rd.Length(t.rd) EXCEPT
+        TRY len := ORD(Rd.Length(t.rd)) EXCEPT
         | Rd.Failure (ref) => RAISE Error(RdUtils.FailureText(ref))
         | Thread.Alerted => (* ignore *)
         END;
Index: m3-ui/formsvbt/src/Manpage.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-ui/formsvbt/src/Manpage.m3,v
retrieving revision 1.2
diff -u -r1.2 Manpage.m3
--- m3-ui/formsvbt/src/Manpage.m3	17 Mar 2008 03:45:25 -0000	1.2
+++ m3-ui/formsvbt/src/Manpage.m3	8 Jan 2010 11:08:23 -0000
@@ -96,7 +96,7 @@
           (* Create forward- and reverse-readers for searching. *)
           t.rd := MTextRd.New (mtext);
           t.revRd := MTextRd.New (mtext, reverse := TRUE);
-          t.length := Rd.Length (rd)
+          t.length := ORD(Rd.Length (rd))
         END
       END
     EXCEPT
@@ -154,18 +154,18 @@
           Rd.Seek (t.rd, 0)
         END;
         IF t.caseSensitive THEN
-          pos := RdUtils.Find (t.rd, pattern)
+          pos := ORD(RdUtils.Find (t.rd, pattern))
         ELSE
-          pos := RdUtils.Find (t.rd, pattern, RdUtils.ToUpperCaseASCII)
+          pos := ORD(RdUtils.Find (t.rd, pattern, RdUtils.ToUpperCaseASCII))
         END;
         show (pos)
       ELSIF Text.Equal (name, t.helpfindprev) THEN
         Rd.Seek (t.revRd, t.length - x.l);
         IF t.caseSensitive THEN
-          pos := RdUtils.Find (t.revRd, TextReverse (pattern));
+          pos := ORD(RdUtils.Find (t.revRd, TextReverse (pattern)));
         ELSE
-          pos := RdUtils.Find (
-                   t.revRd, TextReverse (pattern), RdUtils.ToUpperCaseASCII)
+          pos := ORD(RdUtils.Find (
+                   t.revRd, TextReverse (pattern), RdUtils.ToUpperCaseASCII))
         END;
         show (t.length - pos - n)
       ELSIF t.helpcase # NIL AND Text.Equal (name, t.helpcase) THEN
Index: m3-ui/juno-2/juno-app/src/Editor.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-ui/juno-2/juno-app/src/Editor.m3,v
retrieving revision 1.2
diff -u -r1.2 Editor.m3
--- m3-ui/juno-2/juno-app/src/Editor.m3	17 Mar 2008 03:45:28 -0000	1.2
+++ m3-ui/juno-2/juno-app/src/Editor.m3	8 Jan 2010 11:08:24 -0000
@@ -189,17 +189,17 @@
     Wr.PutText(wr, "\n");
     CASE err.kind OF <* NOWARN *>
     | JunoLex.ErrorKind.UnclosedComment, JunoLex.ErrorKind.UnclosedText =>
-        start := Wr.Index(wr);
+        start := ORD(Wr.Index(wr));
         Wr.PutText(wr, err.initialChars);
         Wr.PutText(wr, Rd.GetText(rd, LAST(CARDINAL)));
-        finish := Wr.Index(wr)
+        finish := ORD(Wr.Index(wr))
     | JunoLex.ErrorKind.BadInitialChar, JunoLex.ErrorKind.BadEscapeChar,
         JunoLex.ErrorKind.BadReal =>
       Wr.PutText(wr, err.initialChars);
-      start := Wr.Index(wr);
+      start := ORD(Wr.Index(wr));
       finish := start + 1;
       Wr.PutText(wr, Rd.GetText(rd, LAST(CARDINAL)));
-      IF start = Wr.Index(wr) THEN Wr.PutChar(wr, ' ') END
+      IF start = ORD(Wr.Index(wr)) THEN Wr.PutChar(wr, ' ') END
     END
   END HandleLexErr;
 
@@ -284,9 +284,9 @@
   		  errmsg := errmsg & " (expected "
   		    & JunoToken.KindName[err.expected] & ")"
   		END;
-  		start := Wr.Index(wr);
+  		start := ORD(Wr.Index(wr));
   		Wr.PutText(wr, JunoToken.ToText(err.found));
-  		finish := Wr.Index(wr);
+  		finish := ORD(Wr.Index(wr));
   		Wr.PutChar(wr, ' ');
   		Wr.PutText(wr, err.additional);
   		Wr.PutText(wr, Rd.GetText(rd, LAST(CARDINAL)));
@@ -389,7 +389,7 @@
    fields of each tree in "f". *)
   VAR fmt := Formatter.New(wr, width); BEGIN
     WHILE f # NIL DO
-      f.start := Wr.Index(wr);
+      f.start := ORD(Wr.Index(wr));
       JunoUnparse.ToFmt(fmt, f.tree, indent := 0,
         prec := JunoConfig.realPrec, errast := errast);
       Formatter.NewLine(fmt, freshLine := FALSE);
@@ -400,7 +400,7 @@
         Formatter.NewLine(fmt, freshLine := FALSE)
       END;
       Formatter.Flush(fmt);
-      f.end := Wr.Index(wr);
+      f.end := ORD(Wr.Index(wr));
       f := f.next
     END;
     Formatter.Close(fmt)
Index: m3-ui/juno-2/juno-app/src/Source.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-ui/juno-2/juno-app/src/Source.m3,v
retrieving revision 1.2
diff -u -r1.2 Source.m3
--- m3-ui/juno-2/juno-app/src/Source.m3	17 Mar 2008 03:45:31 -0000	1.2
+++ m3-ui/juno-2/juno-app/src/Source.m3	8 Jan 2010 11:08:24 -0000
@@ -219,9 +219,9 @@
             JunoUnparse.Cmd(wr, res, tokens,
               width := Editor.Width(port), prec := JunoConfig.realPrec);
             Wr.PutChar(wr, '\n');
-            start := Wr.Index(wr);
+            start := ORD(Wr.Index(wr));
             Wr.PutText(wr, JunoToken.ToText(err.found));
-            finish := Wr.Index(wr);
+            finish := ORD(Wr.Index(wr));
             Wr.PutChar(wr, ' ');
             Wr.PutText(wr, err.additional);
             Wr.PutText(wr, Rd.GetText(rd, LAST(CARDINAL)));
Index: m3-ui/juno-2/juno-compiler/src/JunoLex.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-ui/juno-2/juno-compiler/src/JunoLex.m3,v
retrieving revision 1.2
diff -u -r1.2 JunoLex.m3
--- m3-ui/juno-2/juno-compiler/src/JunoLex.m3	17 Mar 2008 03:45:34 -0000	1.2
+++ m3-ui/juno-2/juno-compiler/src/JunoLex.m3	8 Jan 2010 11:08:24 -0000
@@ -87,7 +87,7 @@
   BEGIN
     (* skip whitespace *)
     WHILE s.c IN Lex.Blanks DO s.c := Rd.GetChar(s.rd) END;
-    s.lastPos := Rd.Index(s.rd) - 1;
+    s.lastPos := ORD(Rd.Index(s.rd) - 1);
 
     TRY
       CASE s.c OF
@@ -337,18 +337,18 @@
     RETURN res
   END ReadText;
 
-PROCEDURE PrefixChars(rd: Rd.T; start: CARDINAL): TEXT RAISES {Rd.Failure} =
+PROCEDURE PrefixChars(rd: Rd.T; start: LONGINT): TEXT RAISES {Rd.Failure} =
   <* FATAL Rd.EndOfFile *>
-  VAR curr := Rd.Index(rd); buf := NEW(REF ARRAY OF CHAR, curr - start); BEGIN
+  VAR curr := Rd.Index(rd); buf := NEW(REF ARRAY OF CHAR, ORD(curr - start)); BEGIN
     Rd.Seek(rd, start);
-    FOR i := 0 TO curr - start - 1 DO buf[i] := Rd.GetChar(rd) END;
+    FOR i := 0 TO ORD(curr - start - 1) DO buf[i] := Rd.GetChar(rd) END;
     RETURN Text.FromChars(buf^)
   END PrefixChars;
 
 PROCEDURE ReadReal(s: Stream): REAL RAISES {Error, Rd.Failure} =
 (* This procedure assumes that "s.rd" is positioned one character *past* the
    first character of the real number. *)
-  VAR res: REAL; start: CARDINAL; BEGIN
+  VAR res: REAL; start: LONGINT; BEGIN
     start := Rd.Index(s.rd) - 1;
     Rd.Seek(s.rd, start);
     TRY
Index: m3-ui/mgkit/src/MGRd.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-ui/mgkit/src/MGRd.m3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 MGRd.m3
--- m3-ui/mgkit/src/MGRd.m3	13 Jan 2001 15:01:31 -0000	1.1.1.1
+++ m3-ui/mgkit/src/MGRd.m3	8 Jan 2010 11:08:24 -0000
@@ -77,7 +77,7 @@
     RETURN t;
   END FromTextPort;
 
-PROCEDURE Length(t: T): INTEGER RAISES {Rd.Failure, Thread.Alerted} =
+PROCEDURE Length(t: T): LONGINT RAISES {Rd.Failure, Thread.Alerted} =
   BEGIN
     RETURN t.rd.length();
   END Length;
@@ -95,16 +95,16 @@
     VText.DeleteInterval(t.future);
   END Close;
 
-PROCEDURE Seek (t: T; n: CARDINAL;
+PROCEDURE Seek (t: T; n: LONGINT;
             <* UNUSED *> dontBlock: BOOLEAN): RdClass.SeekResult
   RAISES {Rd.Failure, Thread.Alerted} =
   <* FATAL VTDef.Error *>
   BEGIN
     TRY
       Rd.Seek(t.rd, n);
-      VText.MoveInterval(t.past, 0, n);
-      VText.MoveInterval(t.present, n, n + 1);
-      VText.MoveInterval(t.future, n + 1, LAST(INTEGER));
+      VText.MoveInterval(t.past, 0, ORD(n));
+      VText.MoveInterval(t.present, ORD(n), ORD(n + 1));
+      VText.MoveInterval(t.future, ORD(n + 1), LAST(INTEGER));
       VBT.Mark(t.vbt);
       t.cur := n;
       t.lo := n;
Index: m3-ui/vbtkit/src/etext/MTextUnit.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-ui/vbtkit/src/etext/MTextUnit.m3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 MTextUnit.m3
--- m3-ui/vbtkit/src/etext/MTextUnit.m3	13 Jan 2001 15:01:40 -0000	1.1.1.1
+++ m3-ui/vbtkit/src/etext/MTextUnit.m3	8 Jan 2010 11:08:24 -0000
@@ -121,11 +121,11 @@
     LOCK mu DO
       EVAL rd.init (t, index);
       EVAL rrd.init (t, index, reverse := TRUE);
-      left := FindChar (rrd, SET OF CHAR {'\n'}, index, -1);
+      left := ORD(FindChar (rrd, SET OF CHAR {'\n'}, index, -1));
       Rd.Seek (rd, left);
-      leftMargin := FindChar (rd, SET OF CHAR {'\n'} + NonBlankRun, left);
+      leftMargin := ORD(FindChar (rd, SET OF CHAR {'\n'} + NonBlankRun, left));
       Rd.Seek (rd, leftMargin);
-      rightEnd := FindChar (rd, SET OF CHAR {'\n'}, leftMargin);
+      rightEnd := ORD(FindChar (rd, SET OF CHAR {'\n'}, leftMargin));
       right := rightEnd;
       IF right < len THEN INC (right) END;
       IF rightEnd = leftMargin THEN
Index: m3-ui/vbtkit/src/etext/TextPortClass.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-ui/vbtkit/src/etext/TextPortClass.m3,v
retrieving revision 1.2
diff -u -r1.2 TextPortClass.m3
--- m3-ui/vbtkit/src/etext/TextPortClass.m3	17 Mar 2008 03:46:42 -0000	1.2
+++ m3-ui/vbtkit/src/etext/TextPortClass.m3	8 Jan 2010 11:08:24 -0000
@@ -361,14 +361,14 @@
           IF loc = Loc.First THEN start := 0 END;
           LOCK readerLock DO
             EVAL reader.init (v.vtext.mtext, start := start);
-            found := RdUtils.Find (reader, pattern, can);
+            found := ORD(RdUtils.Find (reader, pattern, can));
             IF found >= 0 THEN RETURN Extent {found, found + len} END
           END
       | Loc.Prev =>
           LOCK readerLock DO
             EVAL reader.init (v.vtext.mtext, start := start, rangeStart := 0,
                               rangeEnd := start, reverse := TRUE);
-            found := RdUtils.Find (reader, TextReverse (pattern), can);
+            found := ORD(RdUtils.Find (reader, TextReverse (pattern), can));
             IF found >= 0 THEN
               RETURN Extent {start - found - len, start - found}
             END                  (* IF *)
Index: m3-ui/vbtkit/src/etext/TypescriptVBT.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-ui/vbtkit/src/etext/TypescriptVBT.m3,v
retrieving revision 1.4
diff -u -r1.4 TypescriptVBT.m3
--- m3-ui/vbtkit/src/etext/TypescriptVBT.m3	17 Mar 2008 03:46:43 -0000	1.4
+++ m3-ui/vbtkit/src/etext/TypescriptVBT.m3	8 Jan 2010 11:08:24 -0000
@@ -124,7 +124,7 @@
 
 (***********************  Typescript-specific code  ***********************)
 
-PROCEDURE WSeek (wr: Writer; <* UNUSED *> n: CARDINAL)
+PROCEDURE WSeek (wr: Writer; <* UNUSED *> n: LONGINT)
   RAISES {Wr.Failure, Thread.Alerted} =
   BEGIN
     wr.flush ()
@@ -134,7 +134,7 @@
   VAR
     v      := wr.v; tp := v.tp;
     normP  := TextPort.IsVisible (v.tp, TextPort.Index (tp));
-    nchars := wr.cur - wr.lo;
+    nchars := ORD(wr.cur - wr.lo);
   BEGIN
     LOCK v.mu DO
       TextPort.Replace (tp, v.outputEnd, v.outputEnd,
@@ -148,7 +148,7 @@
     IF Thread.TestAlert () THEN RAISE Thread.Alerted END
   END WFlush;
 
-PROCEDURE RSeek (rd: Reader; <*UNUSED*> n: CARDINAL;
+PROCEDURE RSeek (rd: Reader; <*UNUSED*> n: LONGINT;
                  dontBlock: BOOLEAN): RdClass.SeekResult
   RAISES {Thread.Alerted} =
   VAR
Index: m3-ui/vbtkit/src/mtext/MTextRd.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-ui/vbtkit/src/mtext/MTextRd.m3,v
retrieving revision 1.2
diff -u -r1.2 MTextRd.m3
--- m3-ui/vbtkit/src/mtext/MTextRd.m3	17 Mar 2008 03:46:56 -0000	1.2
+++ m3-ui/vbtkit/src/mtext/MTextRd.m3	8 Jan 2010 11:08:25 -0000
@@ -92,7 +92,7 @@
     RETURN rd
   END Init;
 
-PROCEDURE Seek (rd: T; n: CARDINAL; dontBlock: BOOLEAN): RdClass.SeekResult
+PROCEDURE Seek (rd: T; n: LONGINT; dontBlock: BOOLEAN): RdClass.SeekResult
   RAISES {Rd.Failure, Thread.Alerted} =
   BEGIN
     IF n >= rd.len THEN
@@ -108,15 +108,15 @@
     END
   END Seek;
 
-PROCEDURE ForwardSeek (rd: T; n: CARDINAL; <* UNUSED *> dontBlock: BOOLEAN):
+PROCEDURE ForwardSeek (rd: T; n: LONGINT; <* UNUSED *> dontBlock: BOOLEAN):
   RdClass.SeekResult RAISES {Rd.Failure, Thread.Alerted} =
   VAR
     beginN          : Node;
     beginI, count, i: CARDINAL;
     result                     := RdClass.SeekResult.Ready;
   BEGIN
-    MTextDs.LocateB (rd.m, n + rd.first, beginN, beginI);
-    count := MIN (MIN (beginN.length - beginI, BufferSize), rd.len - n);
+    MTextDs.LocateB (rd.m, ORD(n) + rd.first, beginN, beginI);
+    count := MIN (MIN (beginN.length - beginI, BufferSize), rd.len - ORD(n));
     CASE beginN.type OF
     | NodeType.text =>
         Text.SetChars (SUBARRAY (rd.buff^, 0, count), beginN.text, beginI);
@@ -143,7 +143,7 @@
     RETURN result
   END ForwardSeek;
 
-PROCEDURE RevSeek (rd: T; n: CARDINAL; <* UNUSED *> dontBlock: BOOLEAN):
+PROCEDURE RevSeek (rd: T; n: LONGINT; <* UNUSED *> dontBlock: BOOLEAN):
   RdClass.SeekResult RAISES {Rd.Failure, Thread.Alerted} =
   VAR
     beginN                 : Node;
@@ -159,7 +159,7 @@
       END;
     END RevCopyText;
   BEGIN
-    MTextDs.Locate (rd.m, rd.last + 1 - n, beginN, beginI);
+    MTextDs.Locate (rd.m, rd.last + 1 - ORD(n), beginN, beginI);
     count := MIN (MIN (beginI, BufferSize), rd.len - n);
     first := beginI - count;
     CASE beginN.type OF
@@ -187,13 +187,10 @@
   END RevSeek;
 
 
-PROCEDURE Length (rd: T): INTEGER =
+PROCEDURE Length (rd: T): LONGINT =
   BEGIN
     RETURN rd.len
   END Length;
 
 BEGIN
 END MTextRd.
-
-
-
Index: m3-ui/vbtkit/src/vtext/VTRd.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-ui/vbtkit/src/vtext/VTRd.m3,v
retrieving revision 1.1.1.1
diff -u -r1.1.1.1 VTRd.m3
--- m3-ui/vbtkit/src/vtext/VTRd.m3	13 Jan 2001 15:01:44 -0000	1.1.1.1
+++ m3-ui/vbtkit/src/vtext/VTRd.m3	8 Jan 2010 11:08:25 -0000
@@ -25,7 +25,7 @@
 PROCEDURE Rev (vt: T) RAISES {Rd.Failure, Thread.Alerted} =
   BEGIN
     IF vt.rrd = NIL THEN vt.rrd := NEW (MTextRd.T) ELSE Rd.Close (vt.rrd) END;
-    EVAL vt.rrd.init (vt.mtext, Rd.Index (vt.rd), reverse := TRUE)
+    EVAL vt.rrd.init (vt.mtext, ORD(Rd.Index (vt.rd)), reverse := TRUE)
   END Rev;
 
 BEGIN END VTRd.
Index: m3-www/http/src/HTTP.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-www/http/src/HTTP.m3,v
retrieving revision 1.2
diff -u -r1.2 HTTP.m3
--- m3-www/http/src/HTTP.m3	3 May 2005 22:21:23 -0000	1.2
+++ m3-www/http/src/HTTP.m3	8 Jan 2010 11:08:25 -0000
@@ -292,7 +292,7 @@
   VAR
     field, prev: Field   := NIL;
     name, value: TEXT;
-    cur        : INTEGER;
+    cur        : LONGINT;
     ch         : CHAR;
   BEGIN
     TRY
@@ -1289,7 +1289,7 @@
   BEGIN
     TRY
       Wr.PutText(res, "Basic ");
-      FOR i := 0 TO (Rd.Length(rd) DIV 3) - 1 DO
+      FOR i := 0L TO (Rd.Length(rd) DIV 3) - 1L DO
         c0 := UnsafeRd.FastGetChar(rd);
           c1 := UnsafeRd.FastGetChar(rd);
           c2 := UnsafeRd.FastGetChar(rd);