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 7 Jan 2010 11:17:48 -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 7 Jan 2010 11:17:48 -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 7 Jan 2010 11:17:48 -0000 @@ -146,7 +146,7 @@ END; rd.st := 0; - rd.cur := 0; + rd.cur := 0L; rd.closed := FALSE; rd.seekable := TRUE; rd.intermittent := FALSE; @@ -179,33 +179,33 @@ <* ASSERT buf <= LAST (rd.buffers^) *> rd.cur_buf := buf; rd.buff := rd.buffers [buf]; - rd.lo := buf * BufferSize; - rd.hi := MIN(rd.lo + BufferSize, rd.max_len); + rd.lo := VAL(buf * BufferSize, LONGINT); + rd.hi := VAL(MIN(ORD(rd.lo) + BufferSize, rd.max_len), LONGINT); END GotoBuffer; 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; + RETURN VAL(rd.max_len, LONGINT); 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), Fmt.Int(rd.max_len))); *) - IF pos >= rd.max_len THEN - rd.cur := rd.max_len; - GotoBuffer(rd, rd.cur); + IF ORD(pos) >= rd.max_len THEN + rd.cur := VAL(rd.max_len, LONGINT); + GotoBuffer(rd, rd.max_len); (* IO.Put(Fmt.F("EventRd.Seek(%s) => set cur=%s and return Eof\n", Fmt.Int(pos), Fmt.Int(rd.cur))); *) RETURN RdClass.SeekResult.Eof; ELSE - IF (pos < rd.lo) OR (rd.hi <= pos) THEN GotoBuffer (rd, pos) END; + IF (pos < rd.lo) OR (rd.hi <= pos) THEN GotoBuffer (rd, ORD(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 7 Jan 2010 11:17:48 -0000 @@ -177,7 +177,7 @@ END; END; ph.event := ev; - ph.cur := 0; + ph.cur := 0L; ph.wr := NIL; RETURN ph; END NewHandle; @@ -222,17 +222,17 @@ 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! *) + EVAL rd.seek(0L, FALSE); (* reset so we read it all! *) TRY 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)); + IF len > 0L THEN + 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,15 +263,15 @@ 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 + IF wr.hi - wr.cur < VAL(BYTESIZE(MsgHeader), LONGINT) THEN RAISE Wr.Failure(AtomList.List1( Atom.FromText("not enough buffer space"))); END; h^ := ev.hdr; - INC(wr.cur, BYTESIZE(MsgHeader)); + INC(wr.cur, VAL(BYTESIZE(MsgHeader), LONGINT)); wr.putString(SUBARRAY(from^, 0, NUMBER(ev.from.byte))); wr.putString(SUBARRAY(ts^, 0, NUMBER(ev.ts.r))); @@ -299,7 +299,7 @@ VAR ev := Event.New(); hi, lo: Word32; BEGIN - IF rd.hi - rd.cur < BYTESIZE(MsgHeader) THEN + IF rd.hi - rd.cur < VAL(BYTESIZE(MsgHeader), LONGINT) THEN WITH hdrChar = LOOPHOLE(ADR(ev.hdr), UNTRACED REF ARRAY [0..65535] OF CHAR) DO IF rd.getSub(SUBARRAY(hdrChar^, 0, @@ -308,10 +308,10 @@ 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)); + INC(rd.cur, VAL(BYTESIZE(MsgHeader), LONGINT)); END; END; WITH from = LOOPHOLE(ADR(ev.from), @@ -483,14 +483,14 @@ AcquireRd(c); IF rep.intFmt = NativeRep.intFmt THEN i := LOOPHOLE(AlignRd(rd, BYTESIZE(INTEGER)), UNTRACED REF INTEGER)^; - INC(rd.cur, BYTESIZE(INTEGER)); + INC(rd.cur, VAL(BYTESIZE(INTEGER), LONGINT)); ELSE CASE rep.intFmt OF | IntFmt32Little, IntFmt32Big => VAR ii: Int32 := LOOPHOLE(AlignRd(rd, BYTESIZE(Int32)), UNTRACED REF Int32)^; BEGIN - INC(rd.cur, BYTESIZE(Int32)); + INC(rd.cur, VAL(BYTESIZE(Int32), LONGINT)); IF NOT NativeEndian(rep) THEN ii := Swap.Swap4(ii); END; i := ii; END; @@ -500,7 +500,7 @@ VAR ip := LOOPHOLE(AlignRd(rd, BYTESIZE(Int64)), UNTRACED REF Int64); BEGIN - INC(rd.cur, BYTESIZE(Int64)); + INC(rd.cur, VAL(BYTESIZE(Int64), LONGINT)); IF (ip[0] < 0 AND ip[1] # -1) OR (ip[0] >= 0 AND ip[1] # 0) THEN RaiseUnsupportedDataRep(); END; @@ -533,12 +533,12 @@ AcquireRd(c); IF rep.intFmt = NativeRep.intFmt THEN i := LOOPHOLE(AlignRd(rd, BYTESIZE(Int32)), UNTRACED REF Int32)^; - INC(rd.cur, BYTESIZE(Int32)); + INC(rd.cur, VAL(BYTESIZE(Int32), LONGINT)); ELSE CASE rep.intFmt OF | IntFmt32Little, IntFmt32Big, IntFmt64Little => i := LOOPHOLE(AlignRd(rd, BYTESIZE(Int32)), UNTRACED REF Int32)^; - INC(rd.cur, BYTESIZE(Int32)); + INC(rd.cur, VAL(BYTESIZE(Int32), LONGINT)); IF NOT NativeEndian(rep) THEN i := Swap.Swap4(i); END; ELSE RaiseUnsupportedDataRep(); @@ -552,9 +552,10 @@ END; END InInt32; -PROCEDURE AlignRd(rd: Rd.T; nb: CARDINAL) : ADDRESS +PROCEDURE AlignRd(rd: Rd.T; nb_small: CARDINAL) : ADDRESS RAISES {Event.Error, Rd.Failure, Thread.Alerted} = - VAR diff := rd.cur MOD nb; + VAR nb := VAL(nb_small, LONGINT); + diff: LONGINT := rd.cur MOD nb; res: ADDRESS; BEGIN (* @@ -563,7 +564,7 @@ * I think that the invariants are held for "EventRd.T", but I'm * not positive. Time will tell. *) - IF diff # 0 THEN + IF diff # 0L THEN VAR n := rd.cur + nb - diff; BEGIN IF n > rd.hi THEN RaiseUnmarshalFailure(); END; rd.cur := n; @@ -571,7 +572,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; @@ -592,7 +593,7 @@ VAR ip := LOOPHOLE(AlignWr(c.wr, BYTESIZE(INTEGER)), UNTRACED REF INTEGER); BEGIN ip^ := i; - INC(c.wr.cur, BYTESIZE(INTEGER)); + INC(c.wr.cur, VAL(BYTESIZE(INTEGER), LONGINT)); END OutInteger; PROCEDURE OutEventNumber(c: Handle; n: EventNumber.T) @@ -613,12 +614,13 @@ VAR ip := LOOPHOLE(AlignWr(c.wr, BYTESIZE(Int32)), UNTRACED REF Int32); BEGIN ip^ := i; - INC(c.wr.cur, BYTESIZE(Int32)); + INC(c.wr.cur, VAL(BYTESIZE(Int32), LONGINT)); END OutInt32; -PROCEDURE AlignWr(wr: Wr.T; align: CARDINAL) : ADDRESS +PROCEDURE AlignWr(wr: Wr.T; align_small: CARDINAL) : ADDRESS RAISES {Wr.Failure, Thread.Alerted} = - VAR diff := wr.cur MOD align; + VAR align := VAL(align_small, LONGINT); + diff: LONGINT := wr.cur MOD align; res: ADDRESS; BEGIN (* @@ -627,9 +629,9 @@ * I think that the invariants are held for "EventWr.T", but I'm * not positive. Time will tell. *) - IF diff # 0 THEN INC(wr.cur, align-diff); END; + IF diff # 0L 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 7 Jan 2010 11:17:48 -0000 @@ -121,12 +121,12 @@ END; END; wr.st := 0; - wr.cur := 0; + wr.cur := 0L; wr.max_len := 0; wr.closed := FALSE; wr.seekable := TRUE; wr.buffered := TRUE; - GotoBuffer(wr, wr.cur); + GotoBuffer(wr, 0); FINALLY WrClass.Unlock(wr); END; @@ -135,21 +135,21 @@ 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); - RETURN wr.max_len; + wr.max_len := MAX (wr.max_len, ORD(wr.cur)); + RETURN VAL(wr.max_len, LONGINT); END Length; -PROCEDURE Seek(wr: T; n: CARDINAL) RAISES {} = +PROCEDURE Seek(wr: T; n: LONGINT) RAISES {} = BEGIN (* capture the current length of the writer *) - wr.max_len := MAX (wr.max_len, wr.cur); + wr.max_len := MAX (wr.max_len, ORD(wr.cur)); (* make sure we don't seek beyond the end of the writer *) - n := MIN (n, wr.max_len); + n := MIN (n, VAL(wr.max_len, LONGINT)); - IF (n < wr.lo) OR (wr.hi <= n) THEN GotoBuffer (wr, n) END; + IF (n < wr.lo) OR (wr.hi <= n) THEN GotoBuffer (wr, ORD(n)) END; wr.cur := n; END Seek; @@ -171,8 +171,8 @@ END; wr.cur_buf := buf; wr.buff := wr.buffers [buf]; - wr.lo := buf * BufferSize; - wr.hi := wr.lo + BufferSize; + wr.lo := VAL(buf * BufferSize, LONGINT); + wr.hi := wr.lo + VAL(BufferSize, LONGINT); END GotoBuffer; PROCEDURE ExpandBufferPool (wr: T) = @@ -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); @@ -220,7 +220,7 @@ (* reset the length, pointers and buffers *) wr.max_len := 0; - wr.cur := 0; + wr.cur := 0L; GotoBuffer (wr, 0); FINALLY WrClass.Unlock(wr) 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 7 Jan 2010 11:17:49 -0000 @@ -93,14 +93,14 @@ 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; - INC(rd.cur, BYTESIZE(CallHeader)); + INC(rd.cur, VAL(BYTESIZE(CallHeader), LONGINT)); IF h.hdr.intFmt # NativeRep.intFmt THEN IF NOT NativeEndian(h.hdr) THEN h.prot := Swap.Swap4(h.prot); @@ -113,13 +113,13 @@ 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)); + INC(rd.cur, VAL(BYTESIZE(MsgHeader), LONGINT)); IF hh.hdr.private # ORD(Op.ResultAck) THEN RETURN FALSE; END; END; ELSE @@ -139,14 +139,14 @@ | NetObj.Error(ec) => TRY (* this test checks whether we have started marshalling results *) - IF c.wr.cur = 0 THEN + IF c.wr.cur = 0L 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; h.hdr.private := ORD(Op.CallFailed); - INC(wr.cur, BYTESIZE(MsgHeader)); + INC(wr.cur, VAL(BYTESIZE(MsgHeader), LONGINT)); END; OutRef(c, ec); END; @@ -169,11 +169,11 @@ 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)) *> - INC(wr.cur, BYTESIZE(CallHeader)); + <* ASSERT (wr.hi - wr.cur >= VAL(BYTESIZE(CallHeader), LONGINT)) *> + INC(wr.cur, VAL(BYTESIZE(CallHeader), LONGINT)); h.hdr := NativeRep; h.hdr.private := ORD(Op.MethodCall); h.prot := stubProt; @@ -189,11 +189,11 @@ 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)^; - INC(rd.cur, BYTESIZE(MsgHeader)); + h := LOOPHOLE(ADR(rd.buff[rd.st + ORD(rd.cur - rd.lo)]), UNTRACED REF MsgHeader)^; + INC(rd.cur, VAL(BYTESIZE(MsgHeader), LONGINT)); EXCEPT | Thread.Alerted => RAISE NetObj.Error(AtomList.List1(NetObj.Alerted)); END; @@ -219,12 +219,12 @@ 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; h.hdr.private := ORD(Op.ResultAck); - INC(wr.cur, BYTESIZE(MsgHeader)); + INC(wr.cur, VAL(BYTESIZE(MsgHeader), LONGINT)); wr.nextMsg(); END; END; @@ -235,12 +235,12 @@ 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; h.hdr.private := ORD(Op.Return); - INC(wr.cur, BYTESIZE(MsgHeader)); + INC(wr.cur, VAL(BYTESIZE(MsgHeader), LONGINT)); END StartResult; PROCEDURE InChars(c: Conn; rep: DataRep; VAR arr: ARRAY OF CHAR) @@ -342,13 +342,13 @@ BEGIN IF rep.intFmt = NativeRep.intFmt THEN i := LOOPHOLE(AlignRd(c.rd, BYTESIZE(INTEGER)), UNTRACED REF INTEGER)^; - INC(c.rd.cur, BYTESIZE(INTEGER)); + INC(c.rd.cur, VAL(BYTESIZE(INTEGER), LONGINT)); ELSE CASE rep.intFmt OF | IntFmt32Little, IntFmt32Big => VAR ii: Int32 := LOOPHOLE(AlignRd(c.rd, BYTESIZE(Int32)), UNTRACED REF Int32)^; BEGIN - INC(c.rd.cur, BYTESIZE(Int32)); + INC(c.rd.cur, VAL(BYTESIZE(Int32), LONGINT)); IF NOT NativeEndian(rep) THEN ii := Swap.Swap4(ii); END; i := ii; END; @@ -358,7 +358,7 @@ VAR ip := LOOPHOLE(AlignRd(c.rd, BYTESIZE(Int64)), UNTRACED REF Int64); BEGIN - INC(c.rd.cur, BYTESIZE(Int64)); + INC(c.rd.cur, VAL(BYTESIZE(Int64), LONGINT)); IF NativeEndian(rep) THEN i := ip[0]; ELSE @@ -387,12 +387,12 @@ BEGIN IF rep.intFmt = NativeRep.intFmt THEN i := LOOPHOLE(AlignRd(c.rd, BYTESIZE(Int32)), UNTRACED REF Int32)^; - INC(c.rd.cur, BYTESIZE(Int32)); + INC(c.rd.cur, VAL(BYTESIZE(Int32), LONGINT)); ELSE CASE rep.intFmt OF | IntFmt32Little, IntFmt32Big, IntFmt64Little => i := LOOPHOLE(AlignRd(c.rd, BYTESIZE(Int32)), UNTRACED REF Int32)^; - INC(c.rd.cur, BYTESIZE(Int32)); + INC(c.rd.cur, VAL(BYTESIZE(Int32), LONGINT)); IF NOT NativeEndian(rep) THEN i := Swap.Swap4(i); END; ELSE RaiseError(NetObj.UnsupportedDataRep); @@ -402,13 +402,14 @@ RETURN i; END InInt32; -PROCEDURE AlignRd(rd: Rd.T; nb: CARDINAL) : ADDRESS +PROCEDURE AlignRd(rd: Rd.T; nb_small: CARDINAL) : ADDRESS RAISES {NetObj.Error, Rd.Failure, Thread.Alerted} = - VAR diff := rd.cur MOD nb; + VAR nb := VAL(nb_small, LONGINT); + diff: LONGINT := rd.cur MOD nb; res: ADDRESS; BEGIN (* here we rely on the alignment invariants of MsgRd.T *) - IF diff # 0 THEN + IF diff # 0L THEN VAR n := rd.cur + nb - diff; BEGIN IF n > rd.hi THEN RaiseUnmarshalFailure(); END; rd.cur := n; @@ -416,7 +417,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; @@ -431,8 +432,8 @@ RAISES {Wr.Failure, Thread.Alerted} = VAR ip := LOOPHOLE(AlignWr(c.wr, BYTESIZE(INTEGER)), UNTRACED REF INTEGER); BEGIN - ip^ := i; - INC(c.wr.cur, BYTESIZE(INTEGER)); + ip^ := ORD(i); + INC(c.wr.cur, VAL(BYTESIZE(INTEGER), LONGINT)); END OutInteger; PROCEDURE OutInt32(c: Conn; i: Int32) @@ -440,18 +441,19 @@ VAR ip := LOOPHOLE(AlignWr(c.wr, BYTESIZE(Int32)), UNTRACED REF Int32); BEGIN ip^ := i; - INC(c.wr.cur, BYTESIZE(Int32)); + INC(c.wr.cur, VAL(BYTESIZE(Int32), LONGINT)); END OutInt32; -PROCEDURE AlignWr(wr: Wr.T; align: CARDINAL) : ADDRESS +PROCEDURE AlignWr(wr: Wr.T; align_small: CARDINAL) : ADDRESS RAISES {Wr.Failure, Thread.Alerted} = - VAR diff := wr.cur MOD align; + VAR align := VAL(align_small, LONGINT); + diff: LONGINT := wr.cur MOD align; res: ADDRESS; BEGIN (* here we rely on the alignment invariants of MsgWr.T *) - IF diff # 0 THEN INC(wr.cur, align-diff); END; + IF diff # 0L 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; @@ -614,7 +616,7 @@ PROCEDURE OutCardinal(c: Conn; card: CARDINAL) RAISES {Wr.Failure, Thread.Alerted} = BEGIN - OutInteger(c, card); + OutInteger(c, VAL(card, INTEGER)); END OutCardinal; PROCEDURE InReal(c: Conn; rep: DataRep): REAL @@ -942,13 +944,13 @@ pwrep := LOOPHOLE(AlignWr(wr, Align64), UNTRACED REF WireRep.T); BEGIN - IF wr.hi - wr.cur >= BYTESIZE(WireRep.T) THEN + IF wr.hi - wr.cur >= VAL(BYTESIZE(WireRep.T), LONGINT) THEN IF o = NIL THEN pwrep^ := WireRep.NullT; ELSE pwrep^ := NetObjRT.InsertAndPin(o); END; - INC(wr.cur, BYTESIZE(WireRep.T)); + INC(wr.cur, VAL(BYTESIZE(WireRep.T), LONGINT)); ELSE IF o = NIL THEN OutBytes(c, WireRep.NullT.byte); @@ -978,8 +980,8 @@ pwrep := LOOPHOLE(AlignRd(rd, Align64), UNTRACED REF WireRep.T); BEGIN - IF rd.hi - rd.cur >= BYTESIZE(WireRep.T) THEN - INC(rd.cur, BYTESIZE(WireRep.T)); + IF ORD(rd.hi - rd.cur) >= BYTESIZE(WireRep.T) THEN + INC(rd.cur, VAL(BYTESIZE(WireRep.T), LONGINT)); IF pwrep^ = WireRep.NullT THEN RETURN NIL END; o := NetObjRT.Find(pwrep^, c.loc); ELSE 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 7 Jan 2010 11:17:49 -0000 @@ -66,14 +66,14 @@ RAISES {NetObj.Error, Rd.Failure, Wr.Failure, Thread.Alerted} = VAR rd: Rd.T; - pos: CARDINAL; + pos: INTEGER; BEGIN rd := v.claimRd(); IF rd = NIL THEN RAISE NetObj.Error(AtomList.List1(NetObj.MissingObject)); END; StubLib.StartResult(c); - pos := Rd.Index(rd); + pos := ORD(Rd.Index(rd)); StubLib.OutInteger(c, pos); c.wr.nextMsg(); SendOp(c, Op.StreamData); @@ -109,7 +109,7 @@ RAISES {NetObj.Error, Rd.Failure, Wr.Failure, Thread.Alerted} = VAR wr: Wr.T; - pos: CARDINAL; + pos: INTEGER; BEGIN (* wr might be lost here if an error is encountered during outbound marshalling. This will be fixed by object cleanup. *) @@ -118,7 +118,7 @@ RAISE NetObj.Error(AtomList.List1(NetObj.MissingObject)); END; StubLib.StartResult(c); - pos := Wr.Index(wr); + pos := ORD(Wr.Index(wr)); StubLib.OutInteger(c, pos); REPEAT c.wr.nextMsg(); @@ -144,7 +144,7 @@ PROCEDURE SurrogateClaimRd(v: T) : Rd.T RAISES {NetObj.Error, Thread.Alerted} = VAR steal := FALSE; c: StubLib.Conn; - pos: CARDINAL; + pos: INTEGER; rd: SurrogateRd; rep: StubLib.DataRep; BEGIN @@ -163,10 +163,10 @@ c := c, v := v, buff := c.rd.buff, - st := c.rd.st + (c.rd.cur - c.rd.lo), - lo := pos, - hi := pos + (c.rd.hi - c.rd.cur), - cur := pos, + st := c.rd.st + ORD(c.rd.cur - c.rd.lo), + lo := VAL(pos, LONGINT), + hi := VAL(pos + ORD(c.rd.hi - c.rd.cur), LONGINT), + cur := VAL(pos, LONGINT), intermittent := TRUE, seekable := FALSE, closed := FALSE); @@ -184,7 +184,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,10 +200,10 @@ v := v, buff := c.wr.buff, (* offset := pos - c.wr.cur, *) - st := c.wr.st + (c.wr.cur - c.wr.lo), - lo := pos, - hi := pos + (c.wr.hi - c.wr.cur), - cur := pos, + st := c.wr.st + ORD(c.wr.cur - c.wr.lo), + lo := VAL(pos, LONGINT), + hi := VAL(pos + ORD(c.wr.hi - c.wr.cur), LONGINT), + cur := VAL(pos, LONGINT), buffered := TRUE, seekable := FALSE, closed := FALSE); @@ -221,7 +221,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 +311,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 +351,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,8 +408,8 @@ VAR h: UNTRACED REF MsgHeader; wr := c.wr; BEGIN - h := LOOPHOLE(ADR(wr.buff[wr.st+wr.cur-wr.lo]), UNTRACED REF MsgHeader); - INC(wr.cur, BYTESIZE(MsgHeader)); + h := LOOPHOLE(ADR(wr.buff[wr.st + ORD(wr.cur - wr.lo)]), UNTRACED REF MsgHeader); + INC(wr.cur, VAL(BYTESIZE(MsgHeader), LONGINT)); h.hdr := StubLib.NativeRep; h.hdr.private := ORD(op); END SendOp; @@ -419,11 +419,11 @@ VAR h: UNTRACED REF MsgHeader; rd := c.rd; BEGIN - IF NOT rd.nextMsg() OR rd.hi - rd.cur < BYTESIZE(MsgHeader) THEN + IF NOT rd.nextMsg() OR rd.hi - rd.cur < VAL(BYTESIZE(MsgHeader), LONGINT) THEN RAISE Rd.Failure(AtomList.List1(StubLib.UnmarshalFailure)); END; - h := LOOPHOLE(ADR(rd.buff[rd.st+rd.cur-rd.lo]), UNTRACED REF MsgHeader); - INC(rd.cur, BYTESIZE(MsgHeader)); + h := LOOPHOLE(ADR(rd.buff[rd.st + ORD(rd.cur - rd.lo)]), UNTRACED REF MsgHeader); + INC(rd.cur, VAL(BYTESIZE(MsgHeader), LONGINT)); RETURN h.hdr; END RecvOp; @@ -460,7 +460,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 +482,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 7 Jan 2010 11:17:49 -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 = " & @@ -149,17 +149,17 @@ wr := NEW(WrT, buff := shared_buff, share := info); rd.st := 0; - rd.lo := 0; - rd.cur := 0; - rd.hi := 0; + rd.lo := 0L; + rd.cur := 0L; + rd.hi := 0L; rd.closed := FALSE; rd.seekable := FALSE; rd.intermittent := TRUE; wr.st := 0; - wr.lo := 0; - wr.cur := 0; - wr.hi := buff_size-1; + wr.lo := 0L; + wr.cur := 0L; + wr.hi := VAL(buff_size, LONGINT) - 1L; 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; @@ -182,7 +182,7 @@ (* cur_i is the position of rd.cur in the shared data buffer, which is the next character we want to read. *) - WITH cur_i = (rd.st + rd.cur - rd.lo) MOD rd.share.size DO + WITH cur_i = (rd.st + ORD(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 case we raise an Alert below and leave early. *) @@ -235,11 +235,11 @@ IF rd.share.first_i <= rd.share.next_i THEN (* move rd.hi to rd.share.next_i *) - INC(rd.hi, rd.share.next_i - cur_i); + INC(rd.hi, VAL(rd.share.next_i - cur_i, LONGINT)); ELSE (* available part of buffer wraps, so move rd.hi to one after the end. We will wrap next time. *) - INC(rd.hi, rd.share.size - cur_i); + INC(rd.hi, VAL(rd.share.size - cur_i, LONGINT)); END; END; (* RdChanged(rd.share.name, rd); *) @@ -251,9 +251,9 @@ RETURN RdClass.SeekResult.Ready; END RdSeek; -PROCEDURE RdLength (<*UNUSED*>rd: RdT): INTEGER = +PROCEDURE RdLength (<*UNUSED*>rd: RdT): LONGINT = BEGIN - RETURN -1; + RETURN -1L; END RdLength; PROCEDURE RdClose (rd: RdT) RAISES {} = @@ -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; @@ -285,7 +285,7 @@ (* cur_i is the position of wr.cur in the shared data buffer. Because of the flush() above, wr.cur = wr.lo, so cur_i = wr.st. We'll leave it as it is here, for now, though. *) - WITH cur_i = (wr.st + wr.cur - wr.lo) MOD wr.share.size DO + WITH cur_i = (wr.st + ORD(wr.cur - wr.lo)) MOD wr.share.size DO WHILE ((wr.share.next_i + 1) MOD wr.share.size) = wr.share.first_i DO (* IO.Put("WrSeek: Buffer is full. Wait with state:\n"); *) (* WrChanged(wr.share.name, wr);*) @@ -304,14 +304,14 @@ the end. Mark everything to the end as available, except perhaps our one dummy byte if first_i is 0. *) IF wr.share.first_i > 0 THEN - INC(wr.hi, wr.share.size - cur_i); + INC(wr.hi, VAL(wr.share.size - cur_i, LONGINT)); ELSE - INC(wr.hi, wr.share.size - cur_i - 1); + INC(wr.hi, VAL(wr.share.size - cur_i - 1, LONGINT)); END; ELSE (* mark everything from the beginning of the buffer to 1 before first_i as available *) - INC(wr.hi, wr.share.first_i - 1 - cur_i); + INC(wr.hi, VAL(wr.share.first_i - 1 - cur_i, LONGINT)); END; END; (* WrChanged(wr.share.name, wr); *) @@ -330,7 +330,7 @@ (* if there is anything to flush, let's flush! *) IF wr.cur > wr.lo THEN - WITH cur_i = (wr.st + wr.cur - wr.lo) MOD wr.share.size DO + WITH cur_i = (wr.st + ORD(wr.cur - wr.lo)) MOD wr.share.size DO IF wr.share.first_i = wr.share.next_i THEN (* IO.Put("WrFlush: Buffer was empty.\n"); *) (* The buffer was empty, so signal any blocked readers. *) @@ -370,7 +370,7 @@ BEGIN TYPECASE rd OF | RdT (r) => - LOCK rd DO DEC(r.cur, r.lo); DEC(r.hi, r.lo); r.lo := 0; END; + LOCK rd DO DEC(r.cur, r.lo); DEC(r.hi, r.lo); r.lo := 0L; END; ELSE (* Skip *) END; END ResetRdCounter; @@ -379,7 +379,7 @@ BEGIN TYPECASE wr OF | WrT (w) => - LOCK wr DO DEC(w.cur, w.lo); DEC(w.hi, w.lo); w.lo := 0; END; + LOCK wr DO DEC(w.cur, w.lo); DEC(w.hi, w.lo); w.lo := 0L; END; ELSE (* Skip *) END; END ResetWrCounter; 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 7 Jan 2010 11:17:49 -0000 @@ -177,9 +177,9 @@ RETURN NEW(RdT, rd := rd, buff := NEW(REF ARRAY OF CHAR, BufferSize), st := 0, - lo := 0, - hi := 0, - cur := 0, + lo := 0L, + hi := 0L, + cur := 0L, intermittent := TRUE, seekable := FALSE, closed := FALSE) @@ -191,16 +191,16 @@ RETURN NEW(WrT, wr := wr, buff := NEW(REF ARRAY OF CHAR, BufferSize), st := HeaderBytes, - lo := 0, - hi := BufferSize - HeaderBytes, - cur := 0, + lo := 0L, + hi := VAL(BufferSize - HeaderBytes, LONGINT), + cur := 0L, buffered := TRUE, seekable := FALSE, closed := FALSE) 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 @@ -244,9 +244,9 @@ (* Now "rd.st" is the buffer index where the data part of the now-current fragment begins. This could be beyond the end of the buffer. *) - rd.st := rd.st + (rd.lo MOD AlignBytes); + rd.st := rd.st + ORD(rd.lo MOD VAL(AlignBytes, LONGINT)); nb := MIN(rd.hdr.nb, MAX(rd.lim-rd.st, 0)); - INC(rd.hi, nb); + INC(rd.hi, VAL(nb, LONGINT)); DEC(rd.hdr.nb, nb); UNTIL nb # 0; (* loop necessary in case hdr is at end of buffer *) RETURN RdClass.SeekResult.Ready; @@ -295,12 +295,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; + RETURN rd.lo + VAL(rd.hdr.nb, LONGINT); ELSE - RETURN -1; + RETURN -1L; END; END Length; @@ -319,26 +319,26 @@ 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.cur := 0; - rd.lo := 0; - rd.hi := 0; + rd.st := Align(ORD(rd.hi - rd.lo) + rd.st); + rd.cur := 0L; + rd.lo := 0L; + rd.hi := 0L; rd.hdr := FragmentHeader{eom := 0, nb := 0}; EVAL RdSeek(rd, rd.cur, FALSE); RETURN TRUE; 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; PROCEDURE WrFlush(wr: WrT) RAISES {Wr.Failure, Thread.Alerted} = BEGIN IF wr.cur # wr.lo THEN PutFrag(wr, FALSE); END; - wr.st := HeaderBytes + (wr.cur MOD AlignBytes); + wr.st := HeaderBytes + ORD(wr.cur MOD VAL(AlignBytes, LONGINT)); wr.lo := wr.cur; - wr.hi := wr.lo + (NUMBER(wr.buff^) - wr.st); + wr.hi := wr.lo + VAL(NUMBER(wr.buff^) - wr.st, LONGINT); Wr.Flush(wr.wr); END WrFlush; @@ -352,13 +352,13 @@ BEGIN PutFrag(wr, TRUE); wr.st := HeaderBytes; - wr.cur := 0; - wr.lo := 0; - wr.hi := NUMBER(wr.buff^) - HeaderBytes; + wr.cur := 0L; + wr.lo := 0L; + wr.hi := VAL(NUMBER(wr.buff^) - HeaderBytes, LONGINT); 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 7 Jan 2010 11:17:49 -0000 @@ -73,9 +73,9 @@ self.wrs := NEW(RefanyTbl.Default).init(); END; self.st := 0; - self.lo := 0; - self.cur := 0; - self.hi := BuffSize; + self.lo := 0L; + self.cur := 0L; + self.hi := VAL(BuffSize, LONGINT); IF (self.buff = NIL) THEN self.buff := NEW(REF ARRAY OF CHAR, BuffSize); END; @@ -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; @@ -98,12 +98,12 @@ (* now, mark the buffer as available *) self.lo := n; self.cur := n; - self.hi := n + BuffSize; + self.hi := n + VAL(BuffSize, LONGINT); END Seek; (* 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)); @@ -123,8 +123,8 @@ END; END; END; - INC(self.cur, NUMBER(a)); - INC(self.hi, NUMBER(a)); + INC(self.cur, VAL(NUMBER(a), LONGINT)); + INC(self.hi, VAL(NUMBER(a), LONGINT)); self.lo := self.cur; END PutString; 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 7 Jan 2010 11:17:49 -0000 @@ -125,9 +125,9 @@ RETURN NEW(RdT, fd := fd, buff := NEW(REF ARRAY OF CHAR, BufferSize), st := 0, - lo := 0, - hi := 0, - cur := 0, + lo := 0L, + hi := 0L, + cur := 0L, intermittent := TRUE, seekable := FALSE, closed := FALSE) @@ -138,16 +138,16 @@ RETURN NEW(WrT, fd := fd, buff := NEW(REF ARRAY OF CHAR, BufferSize), st := HeaderBytes, - lo := 0, - hi := BufferSize - HeaderBytes, - cur := 0, + lo := 0L, + hi := VAL(BufferSize - HeaderBytes, LONGINT), + cur := 0L, buffered := TRUE, seekable := FALSE, closed := FALSE) 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; @@ -189,9 +189,9 @@ (* Now "rd.st" is the buffer index where the data part of the now-current fragment begins. This could be beyond the end of the buffer. *) - rd.st := rd.st + (rd.lo MOD AlignBytes); + rd.st := rd.st + ORD(rd.lo MOD VAL(AlignBytes, LONGINT)); nb := MIN(rd.hdr.nb, MAX(rd.lim-rd.st, 0)); - INC(rd.hi, nb); + INC(rd.hi, VAL(nb, LONGINT)); DEC(rd.hdr.nb, nb); UNTIL nb # 0; (* loop necessary in case hdr is at end of buffer *) RETURN RdClass.SeekResult.Ready; @@ -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; + RETURN rd.lo + VAL(rd.hdr.nb, LONGINT); ELSE - RETURN -1; + RETURN -1L; END; END Length; @@ -250,26 +250,26 @@ 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.cur := 0; - rd.lo := 0; - rd.hi := 0; + rd.st := Align(ORD(rd.hi - rd.lo) + rd.st); + rd.cur := 0L; + rd.lo := 0L; + rd.hi := 0L; rd.hdr := FragmentHeader{eom := 0, nb := 0}; EVAL RdSeek(rd, rd.cur, FALSE); RETURN TRUE; 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; PROCEDURE WrFlush(wr: WrT) RAISES {Wr.Failure, Thread.Alerted} = BEGIN IF wr.cur # wr.lo THEN PutFrag(wr, FALSE); END; - wr.st := HeaderBytes + (wr.cur MOD AlignBytes); + wr.st := HeaderBytes + ORD(wr.cur MOD VAL(AlignBytes, LONGINT)); wr.lo := wr.cur; - wr.hi := wr.lo + (NUMBER(wr.buff^) - wr.st); + wr.hi := wr.lo + VAL(NUMBER(wr.buff^) - wr.st, LONGINT); END WrFlush; PROCEDURE WrClose(wr: WrT) RAISES {Wr.Failure} = @@ -282,13 +282,13 @@ BEGIN PutFrag(wr, TRUE); wr.st := HeaderBytes; - wr.cur := 0; - wr.lo := 0; - wr.hi := NUMBER(wr.buff^) - HeaderBytes; + wr.cur := 0L; + wr.lo := 0L; + wr.hi := VAL(NUMBER(wr.buff^) - HeaderBytes, LONGINT); 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 7 Jan 2010 11:17:49 -0000 @@ -36,9 +36,9 @@ RETURN NEW(RdT, fd := fd, buff := NEW(REF ARRAY OF CHAR, BufferSize), st := 0, - lo := 0, - hi := 0, - cur := 0, + lo := 0L, + hi := 0L, + cur := 0L, intermittent := TRUE, seekable := FALSE, closed := FALSE); @@ -49,15 +49,15 @@ RETURN NEW(WrT, fd := fd, buff := NEW(REF ARRAY OF CHAR, BufferSize), st := 0, - lo := 0, - hi := 0, - cur := 0, + lo := 0L, + hi := 0L, + cur := 0L, buffered := TRUE, seekable := FALSE, 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 @@ -73,7 +73,7 @@ END; IF len > 0 THEN rd.lo := rd.cur; - rd.hi := rd.cur + len; + rd.hi := rd.cur + VAL(len, LONGINT); StreamRdClass.DontOverflow(rd); RETURN RdClass.SeekResult.Ready ELSE @@ -87,15 +87,15 @@ 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^); + wr.hi := wr.lo + VAL(NUMBER(wr.buff^), LONGINT); StreamWrClass.DontOverflow(wr); END WrFlush; 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 7 Jan 2010 11:17:50 -0000 @@ -33,7 +33,7 @@ IMPORT RdClass; CONST - Threshold = LAST(CARDINAL) DIV 2; + Threshold = LAST(LONGINT) DIV 2L; PROCEDURE ByteCount(srd: T): LONGREAL = BEGIN @@ -52,7 +52,7 @@ srd.offset := srd.offset + FLOAT(srd.lo, LONGREAL); DEC(srd.hi, srd.lo); DEC(srd.cur, srd.lo); - srd.lo := 0; + srd.lo := 0L; END; END DontOverflow; 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 7 Jan 2010 11:17:50 -0000 @@ -33,7 +33,7 @@ IMPORT WrClass; CONST - Threshold = LAST(CARDINAL) DIV 2; + Threshold = LAST(LONGINT) DIV 2L; PROCEDURE ByteCount(swr: T): LONGREAL = BEGIN @@ -52,7 +52,7 @@ swr.offset := swr.offset + FLOAT(swr.lo, LONGREAL); DEC(swr.hi, swr.lo); DEC(swr.cur, swr.lo); - swr.lo := 0; + swr.lo := 0L; END; END DontOverflow; 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 7 Jan 2010 11:17:50 -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 7 Jan 2010 11:17:50 -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 7 Jan 2010 11:17:50 -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 := 0L; lastSnapshot, lastLog: Time.T; pad: BOOLEAN; (* if TRUE, pad each update to a DiskPageSize boundary *) cl: Closure; @@ -261,8 +261,8 @@ END; OpenLogfile(t, TRUE); - t.logByteCnt := 0; - t.logEntries := 0; + t.logByteCnt := 0L; + t.logEntries := 0L; WriteVersionFile(t, TRUE); CommitToNewVersion(t); DeleteSnapshot(t, oldversion); @@ -293,8 +293,9 @@ END Recover; CONST - DiskPageSize = 512; - IntBytes = 4; (* writing only 32 bits of update length *) + DiskPageSize = 512L; + IntBytes = 4; (* writing only 32 bits of update length *) + IntBytesL = 4L; (* writing only 32 bits of update length *) ByteBits = BITSIZE(CHAR); PROCEDURE Update(t: T; update: REFANY; forceToDisk: BOOLEAN := TRUE ) @@ -302,7 +303,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,22 +316,22 @@ t.cl.logUpdate(t.logWriter, update); entryEnd := Wr.Index(t.logWriter); - updateLen := (entryEnd - entryStart) - IntBytes; + updateLen := ORD(entryEnd - entryStart - IntBytesL); IF forceToDisk THEN (* force update contents before updating length *) Wr.Flush(t.logWriter); OSSupport.Sync(t.logWriter); END; Wr.Seek(t.logWriter, entryStart); - FOR i := 0 TO IntBytes-1 DO (* Write real update len *) + FOR i := 0 TO IntBytes - 1 DO (* Write real update len *) Wr.PutChar(t.logWriter, VAL(Word.Extract(updateLen, i*ByteBits, ByteBits), CHAR)); END; 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 - WHILE (Wr.Index(t.logWriter) MOD DiskPageSize) # 0 DO + IF t.pad OR (entryEnd MOD DiskPageSize > DiskPageSize - IntBytesL) THEN + WHILE (Wr.Index(t.logWriter) MOD DiskPageSize) # 0L DO Wr.PutChar(t.logWriter, VAL(0, CHAR)); (* Fill to page boundary *) END; END; @@ -355,7 +356,7 @@ updateLen: Word.T; fname: TEXT; updateText: TEXT; - pos: CARDINAL; + pos: LONGINT; BEGIN IF t.version = 0 THEN RETURN state; END; TRY @@ -389,8 +390,8 @@ state := t.cl.readUpdate(TextRd.New(updateText), state); t.logByteCnt := Rd.Index(logReader); - pos := ((t.logByteCnt+DiskPageSize-1) DIV DiskPageSize) * DiskPageSize; - IF t.pad OR ((pos-t.logByteCnt) < IntBytes) THEN + pos := ((t.logByteCnt + DiskPageSize - 1L) DIV DiskPageSize) * DiskPageSize; + IF t.pad OR ((pos-t.logByteCnt) < IntBytesL) THEN Rd.Seek(logReader, pos); (* Seek to page boundary *) t.logByteCnt := pos; END; @@ -411,8 +412,8 @@ TRY Wr.Seek(t.logWriter, t.logByteCnt); OSSupport.Truncate(t.logWriter); - IF t.pad OR (t.logByteCnt MOD DiskPageSize > DiskPageSize-IntBytes) THEN - WHILE (Wr.Index(t.logWriter) MOD DiskPageSize) # 0 DO + IF t.pad OR (t.logByteCnt MOD DiskPageSize > DiskPageSize-IntBytesL) THEN + WHILE (Wr.Index(t.logWriter) MOD DiskPageSize) # 0L DO Wr.PutChar(t.logWriter, VAL(0, CHAR)); (* Fill to page boundary *) END; END; @@ -426,26 +427,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-db/stable/src/LogManager.m3 =================================================================== RCS file: /usr/cvs/cm3/m3-db/stable/src/LogManager.m3,v retrieving revision 1.1.1.2 diff -u -r1.1.1.2 LogManager.m3 --- m3-db/stable/src/LogManager.m3 24 Jan 2001 21:42:08 -0000 1.1.1.2 +++ m3-db/stable/src/LogManager.m3 7 Jan 2010 11:17:50 -0000 @@ -245,7 +245,7 @@ "no checkpointfile for log in " & nm))); END; log := lm.logfn(nm); - RETURN (NOT TestFile(log)) OR (FS.Status(log).size = 0); + RETURN (NOT TestFile(log)) OR (FS.Status(log).size = 0L); END EmptyLog; PROCEDURE Dispose (lm: Default; nm: Pathname.T) RAISES {OSError.E} = 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 7 Jan 2010 11:17:50 -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 7 Jan 2010 11:17:50 -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 7 Jan 2010 11:17:50 -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 7 Jan 2010 11:17:50 -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) + WITH result = Unix.lseek(h.fd, offset, ORD(origin)) DO + IF result < 0L THEN OSErrorPosix.Raise() END; + 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 7 Jan 2010 11:17:50 -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 7 Jan 2010 11:17:50 -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/os/WIN32/LazyConsole.m3 =================================================================== RCS file: /usr/cvs/cm3/m3-libs/libm3/src/os/WIN32/LazyConsole.m3,v retrieving revision 1.2 diff -u -r1.2 LazyConsole.m3 --- m3-libs/libm3/src/os/WIN32/LazyConsole.m3 12 Feb 2001 15:21:06 -0000 1.2 +++ m3-libs/libm3/src/os/WIN32/LazyConsole.m3 7 Jan 2010 11:17:50 -0000 @@ -50,7 +50,7 @@ BEGIN status.modificationTime := 0.0d0; status.type := Terminal.FileType; - status.size := 0; + status.size := 0L; RETURN status; END Status; 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 7 Jan 2010 11:17:51 -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 7 Jan 2010 11:17:51 -0000 @@ -51,11 +51,11 @@ | RegularFile.T(hRF) => rd.seekable := TRUE; rd.intermittent := FALSE; - rd.cur := hRF.seek(RegularFile.Origin.Current, 0); + rd.cur := hRF.seek(RegularFile.Origin.Current, 0L); ELSE rd.seekable := FALSE; rd.intermittent := TRUE; - rd.cur := 0 + rd.cur := 0L; 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 @@ -88,7 +88,7 @@ END; IF n < 0 THEN RETURN RdClass.SeekResult.WouldBlock END; IF n = 0 THEN RETURN RdClass.SeekResult.Eof END; - INC(rd.hi, n); + INC(rd.hi, VAL(n, LONGINT)); RETURN RdClass.SeekResult.Ready END Seek; @@ -99,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); - INC(rd.cur, n); - DEC(toRead, n) + SUBARRAY(rd.buff^, ORD(rd.cur-rd.lo), n); + INC(rd.cur, VAL(n, LONGINT)); + DEC(toRead, n); END ELSE rd.lo := rd.cur; @@ -113,13 +113,13 @@ n := rd.sourceH.read( SUBARRAY(LOOPHOLE(ADR(rd.buff[0]), ByteArrayPtr)^, 0, MIN (NUMBER(rd.buff^), BIG))); - INC(rd.hi, n) + INC(rd.hi, VAL(n, LONGINT)) ELSE n := rd.sourceH.read( SUBARRAY(LOOPHOLE(ADR(a[NUMBER(a)-toRead]), ByteArrayPtr)^, 0, MIN (toRead, BIG))); DEC(toRead, n); - INC(rd.cur, n); + INC(rd.cur, VAL(n, LONGINT)); rd.lo := rd.cur; rd.hi := rd.cur END; @@ -133,13 +133,13 @@ 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 RETURN rd.sourceH.status().size; ELSE - RETURN -1; + RETURN -1L; END EXCEPT | OSError.E(code) => RAISE Rd.Failure(code) 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 7 Jan 2010 11:17:51 -0000 @@ -22,7 +22,7 @@ PROCEDURE OpenAppend(p: Pathname.T): T RAISES {OSError.E} = VAR h: RegularFile.T := FS.OpenFile(p, truncate := FALSE); BEGIN - EVAL h.seek(RegularFile.Origin.End, 0); + EVAL h.seek(RegularFile.Origin.End, 0L); RETURN NEW(T).init(h) END OpenAppend; @@ -63,24 +63,24 @@ TYPECASE h OF | RegularFile.T (hRF) => (* seekable *) wr.seekable := TRUE; - wr.cur := hRF.seek(RegularFile.Origin.Current, 0); + wr.cur := hRF.seek(RegularFile.Origin.Current, 0L); wr.buffered := TRUE; ELSE wr.seekable := FALSE; - wr.cur := 0; + wr.cur := 0L; wr.buffered := buffered; END; wr.lo := wr.cur; - wr.hi := wr.cur + NUMBER(wr.buff^); + wr.hi := wr.cur + VAL(NUMBER(wr.buff^), LONGINT); RETURN wr END Init; EXCEPTION Error; <*FATAL Error*> -PROCEDURE Seek(wr: T; n: CARDINAL) RAISES {Wr.Failure} = +PROCEDURE Seek(wr: T; n: LONGINT) RAISES {Wr.Failure} = BEGIN IF NOT wr.seekable AND n # wr.hi THEN - RTIO.PutText("FileWr.Seek:wr.seekable=" & Fmt.Bool(wr.seekable) & ";n=" & Fmt.Int(n) & ";wr.hi=" & Fmt.Int(wr.hi) & "\n"); + 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; @@ -94,14 +94,14 @@ RegularFile.Origin.Beginning, n); wr.cur := n; wr.lo := n; - wr.hi := n + NUMBER(wr.buff^); + wr.hi := n + VAL(NUMBER(wr.buff^), LONGINT); END; EXCEPT | OSError.E(code) => RAISE Wr.Failure(code) END END Seek; -PROCEDURE Length(wr: T): CARDINAL RAISES {Wr.Failure} = +PROCEDURE Length(wr: T): LONGINT RAISES {Wr.Failure} = BEGIN TRY IF wr.seekable THEN @@ -124,7 +124,7 @@ END Flush; PROCEDURE EmptyBuffer(wr: T) RAISES {OSError.E} = - VAR buffered := wr.cur - wr.lo; start := 0; n: INTEGER; + VAR buffered := ORD(wr.cur - wr.lo); start := 0; n: INTEGER; BEGIN WHILE (buffered > 0) DO n := MIN (buffered, BIG); @@ -135,21 +135,21 @@ END; (* the file position is now wr.cur *) wr.lo := wr.cur; - wr.hi := wr.cur + NUMBER(wr.buff^); + wr.hi := wr.cur + VAL(NUMBER(wr.buff^), LONGINT); END EmptyBuffer; PROCEDURE PutString (wr: T; READONLY buf: ARRAY OF CHAR) RAISES {Wr.Failure} = VAR toWrite, start, n: INTEGER; BEGIN - IF NUMBER(buf) <= wr.hi - wr.cur THEN - SUBARRAY(wr.buff^, wr.cur - wr.lo, NUMBER(buf)) := buf; - INC(wr.cur, NUMBER(buf)); + IF NUMBER(buf) <= ORD(wr.hi - wr.cur) THEN + SUBARRAY(wr.buff^, ORD(wr.cur - wr.lo), NUMBER(buf)) := buf; + INC(wr.cur, VAL(NUMBER(buf), LONGINT)); ELSE Flush(wr); IF 2 * NUMBER(buf) < NUMBER(wr.buff^) THEN SUBARRAY(wr.buff^, 0, NUMBER(buf)) := buf; - INC(wr.cur, NUMBER(buf)); + INC(wr.cur, VAL(NUMBER(buf), LONGINT)); ELSE TRY toWrite := NUMBER (buf); @@ -161,9 +161,9 @@ DEC (toWrite, n); INC (start, n); END; - INC(wr.cur, NUMBER(buf)); + INC(wr.cur, VAL(NUMBER(buf), LONGINT)); wr.lo := wr.cur; - wr.hi := wr.cur + NUMBER(wr.buff^); + wr.hi := wr.cur + VAL(NUMBER(wr.buff^), LONGINT); EXCEPT | OSError.E (code) => RAISE Wr.Failure(code); END Index: 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 7 Jan 2010 11:17:51 -0000 @@ -22,9 +22,9 @@ PROCEDURE Init (rd: T): T = BEGIN rd.st := 0; - rd.lo := 0; - rd.cur := 0; - rd.hi := 0; + rd.lo := 0L; + rd.cur := 0L; + rd.hi := 0L; rd.buff := NIL; rd.closed := FALSE; rd.seekable := TRUE; @@ -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 = - BEGIN RETURN 0; END Length; +PROCEDURE Length(<*UNUSED*> rd: T): LONGINT = + BEGIN RETURN 0L; 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 7 Jan 2010 11:17:51 -0000 @@ -13,6 +13,7 @@ CONST BuffSize = 1024; + BuffSizeL = VAL(BuffSize, LONGINT); REVEAL T = Public BRANDED OBJECT @@ -25,9 +26,9 @@ PROCEDURE Init (wr: T): T = BEGIN wr.st := 0; - wr.lo := 0; - wr.cur := 0; - wr.hi := BuffSize; + wr.lo := 0L; + wr.cur := 0L; + wr.hi := BuffSizeL; IF (wr.buff = NIL) THEN wr.buff := NEW(REF ARRAY OF CHAR, BuffSize); END; @@ -37,16 +38,16 @@ RETURN wr; END Init; -PROCEDURE Seek (wr: T; n: CARDINAL) = +PROCEDURE Seek (wr: T; n: LONGINT) = BEGIN wr.lo := n; wr.cur := n; - wr.hi := n + BuffSize; + wr.hi := n + BuffSizeL; END Seek; PROCEDURE PutString (wr: T; READONLY a: ARRAY OF CHAR) = BEGIN - Seek(wr, wr.cur + NUMBER(a)); + Seek(wr, wr.cur + VAL(NUMBER(a), LONGINT)); END PutString; BEGIN Index: 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 7 Jan 2010 11:17:51 -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 7 Jan 2010 11:17:51 -0000 @@ -41,7 +41,7 @@ (* rd is locked *) VAR res: CHAR; BEGIN IF rd.cur = rd.hi THEN DoSeek(rd) END; - res := rd.buff[rd.st + (rd.cur - rd.lo)]; + res := rd.buff[rd.st + ORD(rd.cur - rd.lo)]; INC(rd.cur); RETURN res END FastGetChar; @@ -88,16 +88,16 @@ RETURN FALSE; END; END; - c1 := rd.buff[rd.st + (rd.cur - rd.lo)]; + c1 := rd.buff[rd.st + ORD(rd.cur - rd.lo)]; INC(rd.cur); IF rd.cur # rd.hi THEN - c2 := rd.buff[rd.st + (rd.cur - rd.lo)]; + c2 := rd.buff[rd.st + ORD(rd.cur - rd.lo)]; INC(rd.cur); ELSIF rd.seek(rd.cur, FALSE) = SeekResult.Eof THEN c2 := '\000'; ELSE - c2 := rd.buff[rd.st + (rd.cur - rd.lo)]; + c2 := rd.buff[rd.st + ORD(rd.cur - rd.lo)]; INC(rd.cur); END; @@ -149,11 +149,11 @@ IF rd.seek(rd.cur, FALSE) = SeekResult.Eof THEN EXIT END END; (* rd.lo <= rd.cur < rd.hi *) - VAR n := MIN(rd.hi - rd.cur, NUMBER(str) - i); BEGIN + VAR n := MIN(ORD(rd.hi - rd.cur), NUMBER(str) - i); BEGIN SUBARRAY(str, i, n) := - SUBARRAY(rd.buff^, rd.cur - rd.lo + rd.st, n); + SUBARRAY(rd.buff^, ORD(rd.cur - rd.lo) + rd.st, n); INC(i, n); - INC(rd.cur, n) + INC(rd.cur, VAL(n, LONGINT)) END END; RETURN i @@ -206,11 +206,11 @@ IF rd.closed THEN Die() END; IF rd.seek(rd.cur, TRUE) = SeekResult.Eof THEN RETURN 1 END END; - RETURN rd.hi - rd.cur; + RETURN ORD(rd.hi - rd.cur); END END CharsReady; -PROCEDURE Index(rd: T): CARDINAL = +PROCEDURE Index(rd: T): LONGINT = BEGIN LOCK rd DO IF rd.closed THEN Die() END; @@ -218,7 +218,7 @@ END END Index; -PROCEDURE Length(rd: T): INTEGER +PROCEDURE Length(rd: T): LONGINT RAISES {Failure, Alerted} = BEGIN LOCK rd DO @@ -227,7 +227,7 @@ END END Length; -PROCEDURE Seek(rd: T; n: CARDINAL) +PROCEDURE Seek(rd: T; n: LONGINT) RAISES {Failure, Alerted} = BEGIN LOCK rd DO @@ -275,17 +275,17 @@ END; (* rd is ready *) VAR - n := MIN (rd.hi, rd.cur + NUMBER (str) - i) - rd.lo + rd.st; - j := rd.cur - rd.lo + rd.st; + n := ORD(MIN (rd.hi, rd.cur + VAL(NUMBER (str) - i, LONGINT)) - rd.lo) + rd.st; + j := ORD(rd.cur - rd.lo) + rd.st; BEGIN WHILE (j # n) AND (rd.buff[j] # '\n') DO INC (j) END; VAR - rd_cur := rd.cur - rd.lo + rd.st; + rd_cur := ORD(rd.cur - rd.lo) + rd.st; k := j - rd_cur; BEGIN SUBARRAY (str, i, k) := SUBARRAY (rd.buff^, rd_cur, k); INC (i, k); - INC (rd.cur, k); + INC (rd.cur, VAL(k, LONGINT)); END; IF (j # n) THEN (* we found a newline *) @@ -320,16 +320,16 @@ LOCK rd DO IF rd.closed THEN Die () END; - IF (rd.lo <= rd.cur) AND (rd.hi - rd.cur >= length) THEN + IF (rd.lo <= rd.cur) AND (ORD(rd.hi - rd.cur) >= length) THEN (* the bytes we need are already in the buffer *) txt := Text.FromChars ( - SUBARRAY (rd.buff^, rd.cur - rd.lo + rd.st, length)); - INC (rd.cur, length); + SUBARRAY (rd.buff^, ORD(rd.cur - rd.lo) + rd.st, length)); + INC (rd.cur, VAL(length, LONGINT)); ELSIF (NOT rd.intermittent) THEN (* we know how long the reader is... *) VAR - len := MIN (length, rd.length () - rd.cur); + len := MIN (length, ORD(rd.length () - rd.cur)); txt8 := Text8.Create (len); BEGIN txt := txt8; @@ -429,21 +429,21 @@ END; END; (* rd is ready *) - n := rd.hi - rd.lo + rd.st; - j := rd.cur - rd.lo + rd.st; + n := ORD(rd.hi - rd.lo) + rd.st; + j := ORD(rd.cur - rd.lo) + rd.st; WHILE (j # n) AND rd.buff[j] # '\n' DO INC(j) END; - VAR rd_cur := rd.cur - rd.lo + rd.st; + VAR rd_cur := ORD(rd.cur - rd.lo) + rd.st; len := j - rd_cur; BEGIN IF len >= 1 AND j # n AND rd.buff[j-1] = '\r' THEN (* segment ends in \r\n *) txt := txt & Text.FromChars (SUBARRAY (rd.buff^, rd_cur, len-1)); - INC (rd.cur, len+1); + INC (rd.cur, VAL(len+1, LONGINT)); RETURN txt; ELSIF j # n THEN (* segment ends in \n *) txt := txt & Text.FromChars (SUBARRAY (rd.buff^, rd_cur, len)); - INC (rd.cur, len+1); + INC (rd.cur, VAL(len+1, LONGINT)); IF NOT Text.Empty(txt) AND Text.GetChar(txt, Text.Length(txt)-1) = '\r' THEN txt := Text.Sub(txt, 0, Text.Length(txt)-1) @@ -452,7 +452,7 @@ ELSE (* segment does not contain line break *) txt := txt & Text.FromChars (SUBARRAY (rd.buff^, rd_cur, len)); - INC (rd.cur, len); + INC (rd.cur, VAL(len, LONGINT)); END; END; END; (* LOOP *) @@ -526,7 +526,7 @@ Thread.Release (rd) END Unlock; -PROCEDURE LengthDefault (<*UNUSED*> rd: T): INTEGER = +PROCEDURE LengthDefault (<*UNUSED*> rd: T): LONGINT = BEGIN <*NOWARN*> Die() END LengthDefault; Index: 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 7 Jan 2010 11:17:51 -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 := 0L; (* 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 7 Jan 2010 11:17:51 -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 7 Jan 2010 11:17:51 -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,17 +32,17 @@ 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 LOOP 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)); + IF len > 0L THEN + proc(SUBARRAY(rd.buff^, rd.st + ORD(rd.cur - rd.lo), ORD(len))); INC(i, len); INC(rd.cur, len); END; @@ -61,17 +61,17 @@ 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 LOOP 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 + IF len > 0L THEN + WITH res = VAL(proc( + SUBARRAY(wr.buff^, wr.st + ORD(wr.cur - wr.lo), ORD(len))), LONGINT) 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 7 Jan 2010 11:17:51 -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 7 Jan 2010 11:17:51 -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,16 +78,16 @@ 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 + RETURN Rd.Index(rd) - 1L END END END 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 7 Jan 2010 11:17:51 -0000 @@ -28,9 +28,9 @@ END; Text.SetChars(rd.buff^, t); rd.st := 0; - rd.lo := 0; - rd.cur := 0; - rd.hi := len; + rd.lo := 0L; + rd.cur := 0L; + rd.hi := VAL(len, LONGINT); rd.closed := FALSE; rd.seekable := TRUE; rd.intermittent := FALSE; @@ -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 7 Jan 2010 11:17:51 -0000 @@ -44,12 +44,12 @@ TRY IF wr.buffers = NIL THEN wr.buffers := NEW(BufferList, 32); END; wr.st := 0; - wr.cur := 0; + wr.cur := 0L; wr.max_len := 0; wr.closed := FALSE; wr.seekable := TRUE; wr.buffered := TRUE; - GotoBuffer(wr, wr.cur); + GotoBuffer(wr, ORD(wr.cur)); FINALLY WrClass.Unlock(wr); END; @@ -58,21 +58,21 @@ 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); - RETURN wr.max_len; + wr.max_len := MAX (wr.max_len, ORD(wr.cur)); + RETURN VAL(wr.max_len, LONGINT); END Length; -PROCEDURE Seek(wr: T; n: CARDINAL) RAISES {} = +PROCEDURE Seek(wr: T; n: LONGINT) RAISES {} = BEGIN (* capture the current length of the writer *) - wr.max_len := MAX (wr.max_len, wr.cur); + wr.max_len := MAX (wr.max_len, ORD(wr.cur)); (* make sure we don't seek beyond the end of the writer *) - n := MIN (n, wr.max_len); + n := MIN (n, VAL(wr.max_len, LONGINT)); - IF (n < wr.lo) OR (wr.hi <= n) THEN GotoBuffer (wr, n) END; + IF (n < wr.lo) OR (wr.hi <= n) THEN GotoBuffer (wr, ORD(n)) END; wr.cur := n; END Seek; @@ -86,8 +86,8 @@ END; wr.cur_buf := buf; wr.buff := wr.buffers [buf]; - wr.lo := buf * BufferSize; - wr.hi := wr.lo + BufferSize; + wr.lo := VAL(buf * BufferSize, LONGINT); + wr.hi := wr.lo + VAL(BufferSize, LONGINT); END GotoBuffer; PROCEDURE ExpandBufferPool (wr: T) = @@ -111,7 +111,7 @@ WrClass.Lock(wr); TRY (* capture the current length of the writer *) - len := MAX (wr.max_len, wr.cur); + len := MAX (wr.max_len, ORD(wr.cur)); (* allocate the result and count the buffersp *) result := Text8.Create (len); @@ -133,7 +133,7 @@ (* reset the length, pointers and buffers *) wr.max_len := 0; - wr.cur := 0; + wr.cur := 0L; GotoBuffer (wr, 0); FINALLY WrClass.Unlock(wr) 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 7 Jan 2010 11:17:51 -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 7 Jan 2010 11:17:51 -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 7 Jan 2010 11:17:51 -0000 @@ -43,7 +43,7 @@ PROCEDURE FastPutChar (wr: T; ch: CHAR) RAISES {Failure, Alerted} = BEGIN IF wr.cur = wr.hi THEN DoSeek(wr) END; - wr.buff[wr.st + wr.cur - wr.lo] := ch; + wr.buff[wr.st + ORD(wr.cur - wr.lo)] := ch; INC(wr.cur); IF NOT wr.buffered THEN wr.flush(); END; END FastPutChar; @@ -70,10 +70,10 @@ c2 := VAL (Word.Extract (ORD (ch), 8, 8), CHAR); BEGIN IF wr.cur = wr.hi THEN DoSeek(wr) END; - wr.buff[wr.st + wr.cur - wr.lo] := c1; + wr.buff[wr.st + ORD(wr.cur - wr.lo)] := c1; INC(wr.cur); IF wr.cur = wr.hi THEN DoSeek(wr) END; - wr.buff[wr.st + wr.cur - wr.lo] := c2; + wr.buff[wr.st + ORD(wr.cur - wr.lo)] := c2; INC(wr.cur); END PutWC; @@ -174,14 +174,14 @@ l := NUMBER(a); BEGIN WHILE (l > 0) DO - VAR n := MIN(wr.hi - wr.cur, l); + VAR n := MIN(ORD(wr.hi - wr.cur), l); BEGIN IF n > 0 THEN - SUBARRAY(wr.buff^, wr.st + wr.cur - wr.lo, n) := + SUBARRAY(wr.buff^, wr.st + ORD(wr.cur - wr.lo), n) := SUBARRAY(a, start, n); INC(start, n); DEC(l, n); - INC(wr.cur, n); + INC(wr.cur, VAL(n, LONGINT)); END; END; IF l > 0 THEN wr.seek(wr.cur) END; @@ -225,13 +225,13 @@ END FastPutLongReal; -PROCEDURE FastSeek(wr: T; n: CARDINAL) RAISES {Failure, Alerted} = +PROCEDURE FastSeek(wr: T; n: LONGINT) RAISES {Failure, Alerted} = BEGIN IF wr.closed OR NOT wr.seekable THEN Die() END; wr.seek(n); END FastSeek; -PROCEDURE Seek(wr: T; n: CARDINAL) RAISES {Failure, Alerted} = +PROCEDURE Seek(wr: T; n: LONGINT) RAISES {Failure, Alerted} = BEGIN LOCK wr DO FastSeek(wr, n); @@ -251,7 +251,7 @@ END; END Flush; -PROCEDURE Index(wr: T): CARDINAL RAISES {} = +PROCEDURE Index(wr: T): LONGINT RAISES {} = BEGIN LOCK wr DO IF wr.closed THEN Die() END; @@ -259,13 +259,13 @@ END END Index; -PROCEDURE FastLength (wr: T): CARDINAL RAISES {Failure, Alerted} = +PROCEDURE FastLength (wr: T): LONGINT RAISES {Failure, Alerted} = BEGIN IF wr.closed THEN Die() END; RETURN wr.length (); END FastLength; -PROCEDURE Length (wr: T): CARDINAL RAISES {Failure, Alerted} = +PROCEDURE Length (wr: T): LONGINT RAISES {Failure, Alerted} = BEGIN LOCK wr DO RETURN FastLength(wr); @@ -324,7 +324,7 @@ BEGIN END FlushDefault; -PROCEDURE LengthDefault(wr: T): CARDINAL RAISES {} = +PROCEDURE LengthDefault(wr: T): LONGINT RAISES {} = BEGIN RETURN wr.cur; END LengthDefault; Index: 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 7 Jan 2010 11:17:51 -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 7 Jan 2010 11:17:51 -0000 @@ -294,18 +294,18 @@ VAR Reader := NEW (RefArrayReader, mu := NEW (MUTEX), - buff := NEW (REF ARRAY OF CHAR, MAXLEN), lo := 0, st := 0, + buff := NEW (REF ARRAY OF CHAR, MAXLEN), lo := 0L, st := 0, seekable := TRUE, intermittent := FALSE); PROCEDURE Init (rd: RefArrayReader): RefArrayReader = BEGIN - rd.cur := 0; - rd.hi := 0; + rd.cur := 0L; + rd.hi := 0L; rd.closed := FALSE; RETURN rd END Init; -PROCEDURE Seek (rd: RefArrayReader; pos: CARDINAL; +PROCEDURE Seek (rd: RefArrayReader; pos: LONGINT; <* UNUSED *> dontBlock: BOOLEAN): RdClass.SeekResult = BEGIN @@ -317,7 +317,7 @@ END END Seek; -PROCEDURE Length (rd: RefArrayReader): INTEGER = +PROCEDURE Length (rd: RefArrayReader): LONGINT = BEGIN RETURN rd.hi END Length; @@ -329,10 +329,10 @@ PROCEDURE PutChar (rd: RefArrayReader; ch: CHAR) RAISES {ReadError} = BEGIN - IF rd.hi >= MAXLEN THEN + IF rd.hi >= VAL(MAXLEN, LONGINT) THEN RAISE ReadError("Sx: Text literal or numeric too long") END; - rd.buff[rd.hi] := ch; + rd.buff[ORD(rd.hi)] := ch; INC(rd.hi); END PutChar; @@ -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 7 Jan 2010 11:17:53 -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 7 Jan 2010 11:17:53 -0000 @@ -30,20 +30,21 @@ RETURN self; END Init; -CONST Threshold = LAST(CARDINAL) DIV 4; +CONST Threshold = LAST(LONGINT) DIV 4L; 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 - w := RdCopy.ToWriter(self.rd, self.wr, MIN(NUMBER(self.buf^), n)); + IF n > 0 THEN + w := RdCopy.ToWriter(self.rd, self.wr, VAL(MIN(NUMBER(self.buf^), n), LONGINT)); Wr.Flush(self.wr); END; @@ -52,7 +53,7 @@ self.offset := self.offset + FLOAT(self.rd.lo, LONGREAL); DEC(self.rd.hi, self.rd.lo); DEC(self.rd.cur, self.rd.lo); - self.rd.lo := 0; + self.rd.lo := 0L; END; RdClass.Unlock(self.rd); Index: m3-libs/sysutils/src/System.m3 =================================================================== RCS file: /usr/cvs/cm3/m3-libs/sysutils/src/System.m3,v retrieving revision 1.5 diff -u -r1.5 System.m3 --- m3-libs/sysutils/src/System.m3 9 Apr 2008 13:11:46 -0000 1.5 +++ m3-libs/sysutils/src/System.m3 7 Jan 2010 11:17:53 -0000 @@ -230,7 +230,7 @@ TRY stdout := FS.OpenFile(pn, truncate := FALSE, create := FS.CreateOption.Ok); - EVAL stdout.seek(RegularFile.Origin.End, 0); + EVAL stdout.seek(RegularFile.Origin.End, 0L); EXCEPT OSError.E(list) => RAISE ExecuteError("open failed on " & pn & ": " & AtomListToText(list)); @@ -269,7 +269,7 @@ TRY stderr := FS.OpenFile(pn, truncate := FALSE, create := FS.CreateOption.Ok); - EVAL stderr.seek(RegularFile.Origin.End, 0); + EVAL stderr.seek(RegularFile.Origin.End, 0L); EXCEPT OSError.E(list) => RAISE ExecuteError("open failed on " & pn & ": " & AtomListToText(list)); @@ -309,7 +309,7 @@ TRY stdout := FS.OpenFile(pn, truncate := FALSE, create := FS.CreateOption.Ok); - EVAL stdout.seek(RegularFile.Origin.End, 0); + EVAL stdout.seek(RegularFile.Origin.End, 0L); EXCEPT OSError.E(list) => RAISE ExecuteError("open failed on " & pn & ": " & AtomListToText(list)); Index: m3-sys/cm3/src/Utils.m3 =================================================================== RCS file: /usr/cvs/cm3/m3-sys/cm3/src/Utils.m3,v retrieving revision 1.6 diff -u -r1.6 Utils.m3 --- m3-sys/cm3/src/Utils.m3 3 Jul 2009 05:53:05 -0000 1.6 +++ m3-sys/cm3/src/Utils.m3 7 Jan 2010 11:17:54 -0000 @@ -122,7 +122,7 @@ BEGIN IF (rd = NIL) THEN RETURN END; TRY - EVAL f.seek (RegularFile.Origin.Beginning, 0); + EVAL f.seek (RegularFile.Origin.Beginning, 0L); EXCEPT OSError.E (args) => Msg.FatalError (args, "unable to rewind input file: ", name); 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 7 Jan 2010 11:17:54 -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 7 Jan 2010 11:17:54 -0000 @@ -32,9 +32,9 @@ (* generic Wr fields *) IF (wr.buff = NIL) THEN wr.buff := NEW (REF ARRAY OF CHAR, 1); END; wr.st := 0; - wr.cur := 0; - wr.lo := 0; - wr.hi := 1; + wr.cur := 0L; + wr.lo := 0L; + wr.hi := 1L; wr.closed := FALSE; wr.seekable := FALSE; wr.buffered := FALSE; @@ -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 7 Jan 2010 11:17:55 -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 "); @@ -815,7 +815,7 @@ fmt.putText ("("); IF (a > 0) THEN fmt.align (3, tryOneLine := TRUE); - Rd.Seek (rd, d); + Rd.Seek (rd, VAL(d, LONGINT)); EmitTypeExpr (rd, line, a, 'S', expanded, fmt); fmt.end (); END; @@ -829,7 +829,7 @@ fmt.break (); fmt.begin (2); fmt.putText (" RAISES {"); - Rd.Seek (rd, d); + Rd.Seek (rd, VAL(d, LONGINT)); EmitTypeExpr (rd, line, a, 'T', expanded, fmt); fmt.putText ("}"); fmt.end (); @@ -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 *) @@ -894,7 +894,7 @@ IF (c > 0) THEN fmt.unitedBreak (); fmt.align (3, tryOneLine := NOT topLevel); - Rd.Seek (rd, f); + Rd.Seek (rd, VAL(f, LONGINT)); EmitTypeExpr (rd, line, c, 'L', expanded, fmt); fmt.end (); END; @@ -902,7 +902,7 @@ fmt.unitedBreak (-2); fmt.putText ("METHODS "); fmt.unitedBreak (0); - Rd.Seek (rd, f); + Rd.Seek (rd, VAL(f, LONGINT)); EmitTypeExpr (rd, line, d, 'W', expanded, fmt); END; IF (e > 0) THEN @@ -910,7 +910,7 @@ fmt.putText ("OVERRIDES "); fmt.unitedBreak (0); fmt.align (3, tryOneLine := NOT topLevel); - Rd.Seek (rd, f); + Rd.Seek (rd, VAL(f, LONGINT)); EmitTypeExpr (rd, line, e, 'X', expanded, fmt); fmt.end (); END; @@ -1210,7 +1210,7 @@ IF (rd = NIL) THEN RETURN NIL; END; TRY - Rd.Seek (rd, info.info_offset); + Rd.Seek (rd, VAL(info.info_offset, LONGINT)); EXCEPT Rd.Failure (ec) => Choke ("Unable to seek in", info.info_file, ec); OS.CloseRd (rd); 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 7 Jan 2010 11:17:55 -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/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 7 Jan 2010 11:17:55 -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 7 Jan 2010 11:17:55 -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 @@ -91,7 +91,7 @@ size := Word.And (size + 1, Word.Not (1)); (* round up to an even size *) IF (index > 2) THEN (* skip this file *) - Rd.Seek (rd, here + size); + Rd.Seek (rd, VAL(here + size, LONGINT)); ELSIF (index = 0) AND NameMatch (hdr.Name, "/") THEN exports1 := NEW (Buffer, size); Read (rd, exports1^); @@ -103,7 +103,7 @@ Read (rd, longnames^); ELSE (* skip this file *) - Rd.Seek (rd, here + size); + Rd.Seek (rd, VAL(here + size, LONGINT)); END; END DumpMember; 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 7 Jan 2010 11:18:01 -0000 @@ -43,9 +43,9 @@ (* 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); - IF (t.buflen # status.size) THEN RETURN NIL; END; + 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 # ORD(status.size)) THEN RETURN NIL; END; t.buffer [t.buflen] := EOFChar; EXCEPT OSError.E => RETURN NIL; END; 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 7 Jan 2010 11:18:01 -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 7 Jan 2010 11:18:01 -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 7 Jan 2010 11:18:01 -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 7 Jan 2010 11:18:02 -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 7 Jan 2010 11:18:02 -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 7 Jan 2010 11:18:02 -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 7 Jan 2010 11:18:02 -0000 @@ -156,7 +156,7 @@ VAR name: TEXT; ext: M3Extension.T; BEGIN - Rd.Seek(f.rd, fileLoc.index); + Rd.Seek(f.rd, VAL(fileLoc.index, LONGINT)); LOOP TRY IF RdExtras.Skip(f.rd) = '@' THEN EXIT END; @@ -187,7 +187,7 @@ IF RdExtras.Skip(rd, ASCII.Spaces, unget := FALSE) = '@' THEN VAR dirName := RdExtras.GetText(rd, unget := FALSE); - index := Rd.Index(rd); + index := ORD(Rd.Index(rd)); elem := M3PathElem.FromText(dirName, dirName, TRUE); BEGIN refList := RefList.AppendD(refList, RefList.List1( 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 7 Jan 2010 11:18:02 -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 7 Jan 2010 11:18:02 -0000 @@ -36,9 +36,9 @@ s.rd := rd; s.wr := wr; s.path := path; - here := Rd.Index (rd); + here := ORD(Rd.Index (rd)); s.ins := M3MarkUp.Get (rd, path); - Rd.Seek (rd, here); + Rd.Seek (rd, VAL(here, LONGINT)); Trans (s); END Annotate; 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 7 Jan 2010 11:18:02 -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 7 Jan 2010 11:18:02 -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) - 1L); 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 7 Jan 2010 11:18:03 -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 7 Jan 2010 11:18:03 -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 @@ -149,23 +149,23 @@ OR Text.Equal (name, t.helpfindnext) THEN IF Text.Equal (name, t.helpfindnext) OR Text.Equal (name, t.helpfindtext) THEN - Rd.Seek (t.rd, x.r) + Rd.Seek (t.rd, VAL(x.r, LONGINT)) ELSE - Rd.Seek (t.rd, 0) + Rd.Seek (t.rd, 0L) 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); + Rd.Seek (t.revRd, VAL(t.length - x.l, LONGINT)); 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/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 7 Jan 2010 11:18:03 -0000 @@ -71,13 +71,13 @@ t.seekable := TRUE; t.intermittent := FALSE; t.st := 0; - t.cur := 0; - t.lo := 0; - t.hi := 0; + t.cur := 0L; + t.lo := 0L; + t.hi := 0L; 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,20 +95,20 @@ 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 + 1L)); + VText.MoveInterval(t.future, ORD(n + 1L), LAST(INTEGER)); VBT.Mark(t.vbt); t.cur := n; t.lo := n; - t.hi := n + 1; + t.hi := n + 1L; t.buff[0] := Rd.GetChar(t.rd); EXCEPT Rd.EndOfFile => RETURN RdClass.SeekResult.Eof 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 7 Jan 2010 11:18:03 -0000 @@ -121,18 +121,18 @@ LOCK mu DO EVAL rd.init (t, index); EVAL rrd.init (t, index, reverse := TRUE); - left := FindChar (rrd, SET OF CHAR {'\n'}, index, -1); - Rd.Seek (rd, left); - leftMargin := FindChar (rd, SET OF CHAR {'\n'} + NonBlankRun, left); - Rd.Seek (rd, leftMargin); - rightEnd := FindChar (rd, SET OF CHAR {'\n'}, leftMargin); + left := ORD(FindChar (rrd, SET OF CHAR {'\n'}, index, -1)); + Rd.Seek (rd, VAL(left, LONGINT)); + leftMargin := ORD(FindChar (rd, SET OF CHAR {'\n'} + NonBlankRun, left)); + Rd.Seek (rd, VAL(leftMargin, LONGINT)); + rightEnd := ORD(FindChar (rd, SET OF CHAR {'\n'}, leftMargin)); right := rightEnd; IF right < len THEN INC (right) END; IF rightEnd = leftMargin THEN rightMargin := rightEnd ELSE - Rd.Seek (rrd, len - rightEnd); (* don't forget to reverse the - index. *) + Rd.Seek (rrd, VAL(len - rightEnd, LONGINT)); (* don't forget to reverse the + index. *) rightMargin := FindChar (rrd, NonBlankRun, rightEnd, -1) END END 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 7 Jan 2010 11:18:03 -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 7 Jan 2010 11:18:04 -0000 @@ -107,11 +107,11 @@ BEGIN v := TextEditVBT.T.init (v, scrollable); v.inputReady := NEW (Thread.Condition); - v.rd := NEW (Reader, v := v, lo := 0, cur := 0, hi := 0, st := 0, + v.rd := NEW (Reader, v := v, lo := 0L, cur := 0L, hi := 0L, st := 0, buff := NEW (REF ARRAY OF CHAR, TerminalReaderBuffSize), closed := FALSE, seekable := FALSE, intermittent := TRUE); v.wr := - NEW (Writer, v := v, lo := 0, cur := 0, hi := TerminalWriterBuffSize, + NEW (Writer, v := v, lo := 0L, cur := 0L, hi := VAL(TerminalWriterBuffSize, LONGINT), st := 0, buff := NEW (REF ARRAY OF CHAR, TerminalWriterBuffSize), closed := FALSE, seekable := FALSE, buffered := TRUE); v.lastReader := NIL; @@ -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, @@ -143,12 +143,12 @@ INC (tp.typeinStart, nchars); (* moved this line to be inside the LOCK -RCC *) END; wr.lo := wr.cur; - wr.hi := wr.lo + NUMBER (wr.buff^); + wr.hi := wr.lo + VAL(NUMBER (wr.buff^), LONGINT); IF normP THEN TextPort.Normalize (tp) ELSE VBT.Mark (tp) END; 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 @@ -181,7 +181,7 @@ Text.SetChars (rd.buff^, txt); INC (v.outputEnd, n); rd.lo := rd.cur; - rd.hi := rd.lo + n; (* NOT v.outputEnd! *) + rd.hi := rd.lo + VAL(n, LONGINT); (* NOT v.outputEnd! *) RETURN RdClass.SeekResult.Ready END (* WITH n *) END (* LOCK *) Index: m3-ui/vbtkit/src/mtext/MText.m3 =================================================================== RCS file: /usr/cvs/cm3/m3-ui/vbtkit/src/mtext/MText.m3,v retrieving revision 1.2 diff -u -r1.2 MText.m3 --- m3-ui/vbtkit/src/mtext/MText.m3 17 Mar 2008 03:46:55 -0000 1.2 +++ m3-ui/vbtkit/src/mtext/MText.m3 7 Jan 2010 11:18:04 -0000 @@ -168,8 +168,8 @@ BEGIN LOCK m.lock DO Check (begin, end, m.length); - start := MIN (start, Rd.Length (rd)); - numChars := MIN (numChars, Rd.Length (rd) - start); + start := MIN (start, ORD(Rd.Length (rd))); + numChars := MIN (numChars, ORD(Rd.Length (rd)) - start); MTextDs.Locate (m, begin, beginN, beginI); MTextDs.Locate (m, end, endN, endI); DeleteNodes (beginN, beginI, endN, endI, end - begin); @@ -265,7 +265,7 @@ | NodeType.text => RETURN Text.GetChar(node.text, nodeI); | NodeType.buf => RETURN node.buffer[nodeI]; | NodeType.file => - Rd.Seek(node.file, nodeI + node.start); + Rd.Seek(node.file, VAL(nodeI + node.start, LONGINT)); RETURN Rd.GetChar(node.file); ELSE <* ASSERT FALSE *> END Index: m3-ui/vbtkit/src/mtext/MTextDebug.m3 =================================================================== RCS file: /usr/cvs/cm3/m3-ui/vbtkit/src/mtext/MTextDebug.m3,v retrieving revision 1.2 diff -u -r1.2 MTextDebug.m3 --- m3-ui/vbtkit/src/mtext/MTextDebug.m3 17 Mar 2008 03:46:55 -0000 1.2 +++ m3-ui/vbtkit/src/mtext/MTextDebug.m3 7 Jan 2010 11:18:04 -0000 @@ -95,7 +95,7 @@ wr, "[f" & Fmt.Int(Id (node)) & ",start=" & Fmt.Int(node.start) & " len=" & Fmt.Int(node.length) & " index=" & Fmt.Int(index) & "]<"); - Rd.Seek(node.file, node.start); + Rd.Seek(node.file, VAL(node.start, LONGINT)); IF node.length < 20 THEN Wr.PutText(wr, Rd.GetText(node.file, node.length) & ">\n") ELSE Index: m3-ui/vbtkit/src/mtext/MTextDs.m3 =================================================================== RCS file: /usr/cvs/cm3/m3-ui/vbtkit/src/mtext/MTextDs.m3,v retrieving revision 1.2 diff -u -r1.2 MTextDs.m3 --- m3-ui/vbtkit/src/mtext/MTextDs.m3 17 Mar 2008 03:46:55 -0000 1.2 +++ m3-ui/vbtkit/src/mtext/MTextDs.m3 7 Jan 2010 11:18:04 -0000 @@ -440,7 +440,7 @@ ELSE size := end - start END; - Rd.Seek (node.file, start); + Rd.Seek (node.file, VAL(start, LONGINT)); textnode.text := Rd.GetText (node.file, size); IF all OR end >= start + node.length THEN ReplaceLeaf (node, textnode) 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 7 Jan 2010 11:18:04 -0000 @@ -61,42 +61,42 @@ rd.seekable := TRUE; rd.intermittent := FALSE; rd.st := 0; - rd.lo := 0; - rd.hi := 0; + rd.lo := 0L; + rd.hi := 0L; IF rd.chars = NIL THEN rd.chars := NEW (REF ARRAY OF CHAR, BufferSize) END; rd.buff := rd.chars; IF reverse THEN IF rd.len = 0 THEN - rd.cur := 0 + rd.cur := 0L ELSIF start < rd.first THEN - rd.cur := rd.len + rd.cur := VAL(rd.len, LONGINT) ELSIF start > rd.last THEN - rd.cur := 0 + rd.cur := 0L ELSE - rd.cur := rd.last + 1 - start + rd.cur := VAL(rd.last + 1 - start, LONGINT) END ELSE IF rd.len = 0 THEN - rd.cur := 0 + rd.cur := 0L ELSIF start < rd.first THEN - rd.cur := 0 + rd.cur := 0L ELSIF start > rd.last THEN - rd.cur := rd.len + rd.cur := VAL(rd.len, LONGINT) ELSE - rd.cur := start - rd.first + rd.cur := VAL(start - rd.first, LONGINT) END END; Rd.Seek (rd, rd.cur); 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 - rd.cur := rd.len; + IF n >= VAL(rd.len, LONGINT) THEN + rd.cur := VAL(rd.len, LONGINT); rd.lo := rd.cur; rd.hi := rd.cur; RETURN RdClass.SeekResult.Eof @@ -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); @@ -124,7 +124,7 @@ SUBARRAY (rd.buff^, 0, count) := SUBARRAY (beginN.buffer^, beginI, count); | NodeType.file => - Rd.Seek (beginN.file, beginI + beginN.start); + Rd.Seek (beginN.file, VAL(beginI + beginN.start, LONGINT)); i := 0; TRY WHILE i < count DO @@ -139,11 +139,11 @@ END; rd.cur := n; rd.lo := n; - rd.hi := rd.lo + count; + rd.hi := rd.lo + VAL(count, LONGINT); 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,14 +159,14 @@ END; END RevCopyText; BEGIN - MTextDs.Locate (rd.m, rd.last + 1 - n, beginN, beginI); - count := MIN (MIN (beginI, BufferSize), rd.len - n); + MTextDs.Locate (rd.m, rd.last + 1 - ORD(n), beginN, beginI); + count := MIN (MIN (beginI, BufferSize), rd.len - ORD(n)); first := beginI - count; CASE beginN.type OF | NodeType.text => RevCopyText (beginN.text); | NodeType.file => - Rd.Seek (beginN.file, beginN.start + first); + Rd.Seek (beginN.file, VAL(beginN.start + first, LONGINT)); i := 0; TRY WHILE i < count DO @@ -182,18 +182,15 @@ END; rd.cur := n; rd.lo := n; - rd.hi := rd.lo + count; + rd.hi := rd.lo + VAL(count, LONGINT); RETURN RdClass.SeekResult.Ready END RevSeek; -PROCEDURE Length (rd: T): INTEGER = +PROCEDURE Length (rd: T): LONGINT = BEGIN - RETURN rd.len + RETURN VAL(rd.len, LONGINT) END Length; BEGIN END MTextRd. - - - Index: m3-ui/vbtkit/src/vtext/VTPounce.m3 =================================================================== RCS file: /usr/cvs/cm3/m3-ui/vbtkit/src/vtext/VTPounce.m3,v retrieving revision 1.2 diff -u -r1.2 VTPounce.m3 --- m3-ui/vbtkit/src/vtext/VTPounce.m3 17 Mar 2008 03:46:59 -0000 1.2 +++ m3-ui/vbtkit/src/vtext/VTPounce.m3 7 Jan 2010 11:18:04 -0000 @@ -136,7 +136,7 @@ END; (* read forward *) <* ASSERT iR <= view.vt.length *> - Rd.Seek (view.vt.rd, iR); + Rd.Seek (view.vt.rd, VAL(iR, LONGINT)); (* read forward until we find a different character *) WHILE (iR < view.vt.length) AND (wordCodes [Rd.GetChar (view.vt.rd)] = code) DO @@ -167,7 +167,7 @@ (* read forward *) iR := MAX (iR - 2, iL); <* ASSERT iR <= view.vt.length *> - Rd.Seek (view.vt.rd, iR); + Rd.Seek (view.vt.rd, VAL(iR, LONGINT)); (* read until we see two new-lines *) LOOP IF iR = view.vt.length THEN EXIT END; 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 7 Jan 2010 11:18:04 -0000 @@ -18,14 +18,14 @@ EVAL vt.rd.init (vt.mtext, index); vt.rdDirty := FALSE; ELSE - Rd.Seek (vt.rd, index); + Rd.Seek (vt.rd, VAL(index, LONGINT)); END; END InitReaderIx; 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-ui/vbtkit/src/vtext/VTReal.m3 =================================================================== RCS file: /usr/cvs/cm3/m3-ui/vbtkit/src/vtext/VTReal.m3,v retrieving revision 1.2 diff -u -r1.2 VTReal.m3 --- m3-ui/vbtkit/src/vtext/VTReal.m3 17 Mar 2008 03:46:59 -0000 1.2 +++ m3-ui/vbtkit/src/vtext/VTReal.m3 7 Jan 2010 11:18:04 -0000 @@ -517,7 +517,7 @@ z_70.realLine.width := 0; h := z_69.rect.text.west; IF rdSet THEN - IF rdIndex # from THEN Rd.Seek (z_69.vt.rd, from); END; + IF rdIndex # from THEN Rd.Seek (z_69.vt.rd, VAL(from, LONGINT)); END; ELSE VTRd.InitReaderIx (z_69.vt, from); rdIndex := from; @@ -546,7 +546,7 @@ at := until; END; h := z_69.rect.text.west; - Rd.Seek (z_69.vt.rd, from); + Rd.Seek (z_69.vt.rd, VAL(from, LONGINT)); at := from; END; WHILE at < to DO @@ -575,7 +575,7 @@ END; IF NOT sf.paintOpaque THEN h := z_69.rect.text.west; - Rd.Seek (z_69.vt.rd, from); + Rd.Seek (z_69.vt.rd, VAL(from, LONGINT)); at := from; WHILE at < to DO intervalOptions := Index: m3-www/http/src/AppBackup.m3 =================================================================== RCS file: /usr/cvs/cm3/m3-www/http/src/AppBackup.m3,v retrieving revision 1.2 diff -u -r1.2 AppBackup.m3 --- m3-www/http/src/AppBackup.m3 3 May 2005 22:21:23 -0000 1.2 +++ m3-www/http/src/AppBackup.m3 7 Jan 2010 11:18:04 -0000 @@ -139,7 +139,7 @@ TRY rd := NEW(FileRd.T).init(file); - IF Rd.Length(rd) > 0 THEN t.read(rd, initial); END; + IF Rd.Length(rd) > 0L THEN t.read(rd, initial); END; t.changed := FALSE; FINALLY UnlockFile(file, t); 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 7 Jan 2010 11:18:04 -0000 @@ -292,7 +292,7 @@ VAR field, prev: Field := NIL; name, value: TEXT; - cur : INTEGER; + cur : LONGINT; ch : CHAR; BEGIN TRY @@ -1289,14 +1289,14 @@ 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 3L) - 1L DO c0 := UnsafeRd.FastGetChar(rd); c1 := UnsafeRd.FastGetChar(rd); c2 := UnsafeRd.FastGetChar(rd); AddEncoding(res, c0, c1, c2) END; - IF Rd.Length(rd) MOD 3 # 0 THEN + IF Rd.Length(rd) MOD 3L # 0L THEN c0 := ChNull; c1 := ChNull; c2 := ChNull; @@ -1426,7 +1426,7 @@ field.value), App.LogStatus.Error); END; END; - EVAL RdCopy.FromProc(wr, FromProc, length); <* NOWARN *> + EVAL RdCopy.FromProc(wr, FromProc, VAL(length, LONGINT)); <* NOWARN *> EXCEPT | Wr.Failure, Thread.Alerted, CopyError => log.log("HTTP.WriteBody: Error reading chunks from src", @@ -1500,7 +1500,7 @@ field.value), App.LogStatus.Error); END; END; - EVAL RdCopy.ToProc(rd, ToProc, length); <* NOWARN *> + EVAL RdCopy.ToProc(rd, ToProc, VAL(length, LONGINT)); <* NOWARN *> EXCEPT | Rd.Failure, Thread.Alerted, CopyError => log.log("HTTP.ReadBody: Error reading body", App.LogStatus.Error); Index: m3-www/http/src/HTTPProxy.m3 =================================================================== RCS file: /usr/cvs/cm3/m3-www/http/src/HTTPProxy.m3,v retrieving revision 1.2 diff -u -r1.2 HTTPProxy.m3 --- m3-www/http/src/HTTPProxy.m3 3 May 2005 22:21:23 -0000 1.2 +++ m3-www/http/src/HTTPProxy.m3 7 Jan 2010 11:18:04 -0000 @@ -117,12 +117,12 @@ IF self.logReply THEN twr := TextWr.New(); - EVAL RdCopy.ToWriter(rd, twr, length); + EVAL RdCopy.ToWriter(rd, twr, VAL(length, LONGINT)); rep := TextWr.ToText(twr); log.log(rep, App.LogStatus.Verbose); Wr.PutText(wr, rep); ELSE - EVAL RdCopy.ToWriter(rd, wr, length); + EVAL RdCopy.ToWriter(rd, wr, VAL(length, LONGINT)); END; EXCEPT Rd.Failure, Thread.Alerted, Wr.Failure =>