From 047d8b94e70cbf2d1ec86c53e06b10208c84a5a0 Mon Sep 17 00:00:00 2001 From: norayr Date: Tue, 29 Nov 2016 15:00:18 +0400 Subject: [PATCH 1/4] plongrealarray had to be pointer to longrealarray. -- noch --- src/library/ulm/ulmSYSTEM.Mod | 22 ++++++++++++---------- src/library/ulm/ulmTypes.Mod | 8 ++++---- 2 files changed, 16 insertions(+), 14 deletions(-) diff --git a/src/library/ulm/ulmSYSTEM.Mod b/src/library/ulm/ulmSYSTEM.Mod index ece334a7..3d00abab 100644 --- a/src/library/ulm/ulmSYSTEM.Mod +++ b/src/library/ulm/ulmSYSTEM.Mod @@ -8,7 +8,7 @@ TYPE pchar = POINTER TO ARRAY 1 OF CHAR; TYPE bytearray* = ARRAY SIZE(LONGINT) OF SYSTEM.BYTE; (* need this because voc does not convert implicitly LONGINT to ARRAY OF BYTE; -- noch *) pbytearray* = POINTER TO bytearray; TYPE longrealarray* = ARRAY SIZE(LONGREAL) OF SYSTEM.BYTE; (* need this because voc does not convert implicitly LONGINT to ARRAY OF BYTE; -- noch *) - plongrealarray* = POINTER TO bytearray; + plongrealarray* = POINTER TO longrealarray; PROCEDURE LongToByteArr* ( l : LONGINT; VAR bar : bytearray); (* noch *) VAR b : SYSTEM.BYTE; @@ -23,24 +23,26 @@ TYPE pchar = POINTER TO ARRAY 1 OF CHAR; PROCEDURE LRealToByteArr* ( l : LONGREAL; VAR lar : longrealarray); (* noch *) VAR b : SYSTEM.BYTE; + (*adr: SYSTEM.ADDRESS;*) p : plongrealarray; i : LONGINT; BEGIN p := SYSTEM.VAL(plongrealarray, SYSTEM.ADR(l)); FOR i := 0 TO SIZE(LONGREAL) -1 DO - b := p^[i]; lar[i] := b; + b := p^[i]; + lar[i] := b; END + (* + adr := SYSTEM.ADR(l); + i := 0; + REPEAT + SYSTEM.GET(adr + i, b); + lar[i] := b; + INC(i) + UNTIL i = SIZE(LONGREAL);*) END LRealToByteArr; -(* - PROCEDURE -Write(adr, n: LONGINT): LONGINT - "write(1/*stdout*/, adr, n)"; - - PROCEDURE -read(VAR ch: CHAR): LONGINT - "read(0/*stdin*/, ch, 1)"; -*) - PROCEDURE TAS*(VAR flag:BOOLEAN): BOOLEAN; (* added for compatibility with ulmSYSTEM module; noch *) VAR oldflag : BOOLEAN; BEGIN diff --git a/src/library/ulm/ulmTypes.Mod b/src/library/ulm/ulmTypes.Mod index 93bab9fc..0d09a4f5 100644 --- a/src/library/ulm/ulmTypes.Mod +++ b/src/library/ulm/ulmTypes.Mod @@ -55,13 +55,13 @@ MODULE ulmTypes; UntracedAddress* = POINTER[1] TO UntracedAddressDesc; (*SYS.UNTRACEDADDRESS;*) UntracedAddressDesc* = RECORD[1] END; - Count* = LONGINT; + Count* = SYS.INT32; Size* = Count; Byte* = SYS.BYTE; IntAddress* = LONGINT; - Int8* = SHORTINT; - Int16* = INTEGER; (* No real 16 bit integer type *) - Int32* = INTEGER; + Int8* = SYS.INT8; + Int16* = SYS.INT16; + Int32* = SYS.INT32; Real32* = REAL; Real64* = LONGREAL; From 247852e0b7c413cb93e7af370fe3275050f4f3a4 Mon Sep 17 00:00:00 2001 From: norayr Date: Tue, 29 Nov 2016 16:14:15 +0400 Subject: [PATCH 2/4] fixed overflow in LRealToByteArr; -- noch --- src/library/ulm/ulmSYSTEM.Mod | 24 ++++++++++-------------- 1 file changed, 10 insertions(+), 14 deletions(-) diff --git a/src/library/ulm/ulmSYSTEM.Mod b/src/library/ulm/ulmSYSTEM.Mod index 3d00abab..796a0d1b 100644 --- a/src/library/ulm/ulmSYSTEM.Mod +++ b/src/library/ulm/ulmSYSTEM.Mod @@ -12,34 +12,30 @@ TYPE pchar = POINTER TO ARRAY 1 OF CHAR; PROCEDURE LongToByteArr* ( l : LONGINT; VAR bar : bytearray); (* noch *) VAR b : SYSTEM.BYTE; - p : pbytearray; + adr : SYSTEM.ADDRESS; i : LONGINT; BEGIN - p := SYSTEM.VAL(pbytearray, SYSTEM.ADR(l)); - FOR i := 0 TO SIZE(LONGINT) -1 DO - b := p^[i]; bar[i] := b; - END + adr := SYSTEM.ADR(l); + i := 0; + REPEAT + SYSTEM.GET(adr + i, b); + lar[i] := b; + INC(i) + UNTIL i = SIZE(LONGINT) END LongToByteArr; PROCEDURE LRealToByteArr* ( l : LONGREAL; VAR lar : longrealarray); (* noch *) VAR b : SYSTEM.BYTE; - (*adr: SYSTEM.ADDRESS;*) - p : plongrealarray; + adr: SYSTEM.ADDRESS; i : LONGINT; BEGIN - p := SYSTEM.VAL(plongrealarray, SYSTEM.ADR(l)); - FOR i := 0 TO SIZE(LONGREAL) -1 DO - b := p^[i]; - lar[i] := b; - END - (* adr := SYSTEM.ADR(l); i := 0; REPEAT SYSTEM.GET(adr + i, b); lar[i] := b; INC(i) - UNTIL i = SIZE(LONGREAL);*) + UNTIL i = SIZE(LONGREAL); END LRealToByteArr; From c549f5847be7a73665e765f34dd2b250f19fafd9 Mon Sep 17 00:00:00 2001 From: norayr Date: Tue, 29 Nov 2016 16:45:18 +0400 Subject: [PATCH 3/4] fixed Longint to Byte Arr function; -- noch --- src/library/ulm/ulmPrint.Mod | 1294 ++++++++++++++++----------------- src/library/ulm/ulmSYSTEM.Mod | 3 +- src/library/ulm/ulmTypes.Mod | 74 +- 3 files changed, 682 insertions(+), 689 deletions(-) diff --git a/src/library/ulm/ulmPrint.Mod b/src/library/ulm/ulmPrint.Mod index 756a3813..42f5a7fe 100644 --- a/src/library/ulm/ulmPrint.Mod +++ b/src/library/ulm/ulmPrint.Mod @@ -35,7 +35,7 @@ ---------------------------------------------------------------------------- *) -MODULE ulmPrint; +MODULE Print; (* formatted printing; Print.F[0-9] prints to Streams.stdout @@ -57,13 +57,13 @@ MODULE ulmPrint; ErrorCode* = SHORTINT; ErrorEvent* = POINTER TO ErrorEventRec; ErrorEventRec* = - RECORD - (Events.EventRec) - errorcode*: ErrorCode; - format*: FormatString; - errpos*: LONGINT; - nargs*: INTEGER; - END; + RECORD + (Events.EventRec) + errorcode*: ErrorCode; + format*: FormatString; + errpos*: LONGINT; + nargs*: INTEGER; + END; VAR error*: Events.EventType; errormsg*: ARRAY errors OF Events.Message; @@ -77,887 +77,883 @@ MODULE ulmPrint; errormsg[tooFewArgs] := "too few arguments given"; errormsg[badFormat] := "syntax error in format string"; errormsg[badArgumentSize] := - "size of argument doesn't conform to the corresponding format element"; + "size of argument doesn't conform to the corresponding format element"; END InitErrorHandling; PROCEDURE Out(out: Streams.Stream; VAR fmt: ARRAY OF CHAR; nargs: INTEGER; - VAR p1,p2,p3,p4,p5,p6,p7,p8,p9: ARRAY OF SYS.BYTE; - errors: RelatedEvents.Object); + VAR p1,p2,p3,p4,p5,p6,p7,p8,p9: ARRAY OF BYTE; + errors: RelatedEvents.Object); CONST - maxargs = 9; (* maximal number of arguments *) - maxargsize = SIZE(LONGREAL); (* maximal arg size (except strings) *) - fmtcmd = "%"; - escape = "\"; + maxargs = 9; (* maximal number of arguments *) + maxargsize = SIZE(LONGREAL); (* maximal arg size (except strings) *) + fmtcmd = "%"; + escape = "\"; VAR - arglen: ARRAY maxargs OF LONGINT; - nextarg: INTEGER; - fmtindex: LONGINT; - fmtchar: CHAR; - hexcharval: LONGINT; + arglen: ARRAY maxargs OF LONGINT; + nextarg: INTEGER; + fmtindex: LONGINT; + fmtchar: CHAR; + hexcharval: LONGINT; PROCEDURE Error(errorcode: ErrorCode); - VAR - event: ErrorEvent; + VAR + event: ErrorEvent; BEGIN - NEW(event); - event.type := error; - event.message := errormsg[errorcode]; - event.errorcode := errorcode; - COPY(fmt, event.format); - event.errpos := fmtindex; - event.nargs := nargs; - RelatedEvents.Raise(errors, event); + NEW(event); + event.type := error; + event.message := errormsg[errorcode]; + event.errorcode := errorcode; + COPY(fmt, event.format); + event.errpos := fmtindex; + event.nargs := nargs; + RelatedEvents.Raise(errors, event); END Error; PROCEDURE Next() : BOOLEAN; BEGIN - IF fmtindex < LEN(fmt) THEN - fmtchar := fmt[fmtindex]; INC(fmtindex); - IF fmtchar = 0X THEN - fmtindex := LEN(fmt); - RETURN FALSE - ELSE - RETURN TRUE - END; - ELSE - RETURN FALSE - END; + IF fmtindex < LEN(fmt) THEN + fmtchar := fmt[fmtindex]; INC(fmtindex); + IF fmtchar = 0X THEN + fmtindex := LEN(fmt); + RETURN FALSE + ELSE + RETURN TRUE + END; + ELSE + RETURN FALSE + END; END Next; PROCEDURE Unget; BEGIN - IF (fmtindex > 0) & (fmtindex < LEN(fmt)) THEN - DEC(fmtindex); fmtchar := fmt[fmtindex]; - ELSE - fmtchar := 0X; - END; + IF (fmtindex > 0) & (fmtindex < LEN(fmt)) THEN + DEC(fmtindex); fmtchar := fmt[fmtindex]; + ELSE + fmtchar := 0X; + END; END Unget; - PROCEDURE Write(byte: SYS.BYTE); + PROCEDURE Write(byte: BYTE); BEGIN - IF Streams.WriteByte(out, byte) THEN - INC(out.count); - END; + IF Streams.WriteByte(out, byte) THEN + INC(out.count); + END; END Write; PROCEDURE WriteLn; - VAR - lineterm: StreamDisciplines.LineTerminator; - i: INTEGER; + VAR + lineterm: StreamDisciplines.LineTerminator; + i: INTEGER; BEGIN - StreamDisciplines.GetLineTerm(out, lineterm); - Write(lineterm[0]); - i := 1; - WHILE (i < LEN(lineterm)) & (lineterm[i] # 0X) DO - Write(lineterm[i]); INC(i); - END; + StreamDisciplines.GetLineTerm(out, lineterm); + Write(lineterm[0]); + i := 1; + WHILE (i < LEN(lineterm)) & (lineterm[i] # 0X) DO + Write(lineterm[i]); INC(i); + END; END WriteLn; PROCEDURE Int(VAR int: LONGINT; base: INTEGER) : BOOLEAN; - PROCEDURE ValidDigit(ch: CHAR) : BOOLEAN; - BEGIN - RETURN (ch >= "0") & (ch <= "9") OR - (base = 16) & (CAP(ch) >= "A") & (CAP(ch) <= "F") - END ValidDigit; + PROCEDURE ValidDigit(ch: CHAR) : BOOLEAN; + BEGIN + RETURN (ch >= "0") & (ch <= "9") OR + (base = 16) & (CAP(ch) >= "A") & (CAP(ch) <= "F") + END ValidDigit; BEGIN - int := 0; - REPEAT - int := int * base; - IF (fmtchar >= "0") & (fmtchar <= "9") THEN - INC(int, LONG(ORD(fmtchar) - ORD("0"))); - ELSIF (base = 16) & - (CAP(fmtchar) >= "A") & (CAP(fmtchar) <= "F") THEN - INC(int, LONG(10 + ORD(CAP(fmtchar)) - ORD("A"))); - ELSE - RETURN FALSE - END; - UNTIL ~Next() OR ~ValidDigit(fmtchar); - RETURN TRUE + int := 0; + REPEAT + int := int * base; + IF (fmtchar >= "0") & (fmtchar <= "9") THEN + INC(int, ORD(fmtchar) - ORD("0")); + ELSIF (base = 16) & + (CAP(fmtchar) >= "A") & (CAP(fmtchar) <= "F") THEN + INC(int, 10 + ORD(CAP(fmtchar)) - ORD("A")); + ELSE + RETURN FALSE + END; + UNTIL ~Next() OR ~ValidDigit(fmtchar); + RETURN TRUE END Int; PROCEDURE SetSize; - VAR - index: INTEGER; + VAR + index: INTEGER; BEGIN - index := 0; - WHILE index < nargs DO - CASE index OF - | 0: arglen[index] := LEN(p1); - | 1: arglen[index] := LEN(p2); - | 2: arglen[index] := LEN(p3); - | 3: arglen[index] := LEN(p4); - | 4: arglen[index] := LEN(p5); - | 5: arglen[index] := LEN(p6); - | 6: arglen[index] := LEN(p7); - | 7: arglen[index] := LEN(p8); - | 8: arglen[index] := LEN(p9); - ELSE - END; - INC(index); - END; + index := 0; + WHILE index < nargs DO + CASE index OF + | 0: arglen[index] := LEN(p1); + | 1: arglen[index] := LEN(p2); + | 2: arglen[index] := LEN(p3); + | 3: arglen[index] := LEN(p4); + | 4: arglen[index] := LEN(p5); + | 5: arglen[index] := LEN(p6); + | 6: arglen[index] := LEN(p7); + | 7: arglen[index] := LEN(p8); + | 8: arglen[index] := LEN(p9); + END; + INC(index); + END; END SetSize; - PROCEDURE Access(par: INTEGER; at: LONGINT) : SYS.BYTE; + PROCEDURE Access(par: INTEGER; at: LONGINT) : BYTE; BEGIN - CASE par OF - | 0: RETURN p1[at] - | 1: RETURN p2[at] - | 2: RETURN p3[at] - | 3: RETURN p4[at] - | 4: RETURN p5[at] - | 5: RETURN p6[at] - | 6: RETURN p7[at] - | 7: RETURN p8[at] - | 8: RETURN p9[at] - ELSE - END; + CASE par OF + | 0: RETURN p1[at] + | 1: RETURN p2[at] + | 2: RETURN p3[at] + | 3: RETURN p4[at] + | 4: RETURN p5[at] + | 5: RETURN p6[at] + | 6: RETURN p7[at] + | 7: RETURN p8[at] + | 8: RETURN p9[at] + END; END Access; - PROCEDURE Convert(from: INTEGER; VAR to: ARRAY OF SYS.BYTE); - VAR i: INTEGER; + PROCEDURE Convert(from: INTEGER; VAR to: ARRAY OF BYTE); + VAR i: INTEGER; BEGIN - i := 0; - WHILE i < arglen[from] DO - to[i] := Access(from, i); INC(i); - END; + i := 0; + WHILE i < arglen[from] DO + to[i] := Access(from, i); INC(i); + END; END Convert; PROCEDURE GetInt(index: INTEGER; VAR long: LONGINT) : BOOLEAN; - (* access index-th parameter (counted from 0); - fails if arglen[index] > SIZE(LONGINT) - *) - VAR - short: SHORTINT; - (*int16: SYS.INT16;*) - int: INTEGER; - + (* access index-th parameter (counted from 0); + fails if arglen[index] > SYS.SIZE(LONGINT) + *) + VAR + short: SHORTINT; + int16: SYS.INT16; + int: INTEGER; + BEGIN - IF arglen[index] = SIZE(SHORTINT) THEN - Convert(index, short); long := short; - (*ELSIF arglen[index] = SIZE(SYS.INT16) THEN - Convert(index, int16); long := int16;*) - ELSIF arglen[index] = SIZE(INTEGER) THEN - Convert(index, int); long := int; - ELSIF arglen[index] = SIZE(LONGINT) THEN - Convert(index, long); - ELSE - Error(badArgumentSize); - RETURN FALSE - END; - RETURN TRUE + IF arglen[index] = SIZE(SHORTINT) THEN + Convert(index, short); long := short; + ELSIF arglen[index] = SIZE(SYS.INT16) THEN + Convert(index, int16); long := int16; + ELSIF arglen[index] = SIZE(INTEGER) THEN + Convert(index, int); long := int; + ELSIF arglen[index] = SIZE(LONGINT) THEN + Convert(index, long); + ELSE + Error(badArgumentSize); + RETURN FALSE + END; + RETURN TRUE END GetInt; PROCEDURE Format() : BOOLEAN; - VAR - fillch: CHAR; (* filling character *) - insert: BOOLEAN; (* insert between sign and 1st digit *) - sign: BOOLEAN; (* sign even positive values *) - leftaligned: BOOLEAN; (* output left aligned *) - width, scale: LONGINT; + VAR + fillch: CHAR; (* filling character *) + insert: BOOLEAN; (* insert between sign and 1st digit *) + sign: BOOLEAN; (* sign even positive values *) + leftaligned: BOOLEAN; (* output left aligned *) + width, scale: LONGINT; - PROCEDURE NextArg(VAR index: INTEGER) : BOOLEAN; - BEGIN - IF nextarg < nargs THEN - index := nextarg; INC(nextarg); RETURN TRUE - ELSE - RETURN FALSE - END; - END NextArg; + PROCEDURE NextArg(VAR index: INTEGER) : BOOLEAN; + BEGIN + IF nextarg < nargs THEN + index := nextarg; INC(nextarg); RETURN TRUE + ELSE + RETURN FALSE + END; + END NextArg; - PROCEDURE Flags() : BOOLEAN; - BEGIN - fillch := " "; insert := FALSE; sign := FALSE; - leftaligned := FALSE; - REPEAT - CASE fmtchar OF - | "+": sign := TRUE; - | "0": fillch := "0"; insert := TRUE; - | "-": leftaligned := TRUE; - | "^": insert := TRUE; - | "\": IF ~Next() THEN RETURN FALSE END; fillch := fmtchar; - ELSE - RETURN TRUE - END; - UNTIL ~Next(); - Error(badFormat); - RETURN FALSE (* unexpected end *) - END Flags; + PROCEDURE Flags() : BOOLEAN; + BEGIN + fillch := " "; insert := FALSE; sign := FALSE; + leftaligned := FALSE; + REPEAT + CASE fmtchar OF + | "+": sign := TRUE; + | "0": fillch := "0"; insert := TRUE; + | "-": leftaligned := TRUE; + | "^": insert := TRUE; + | "\": IF ~Next() THEN RETURN FALSE END; fillch := fmtchar; + ELSE + RETURN TRUE + END; + UNTIL ~Next(); + Error(badFormat); + RETURN FALSE (* unexpected end *) + END Flags; - PROCEDURE FetchInt(VAR int: LONGINT) : BOOLEAN; - VAR - index: INTEGER; - BEGIN - RETURN (fmtchar = "*") & Next() & - NextArg(index) & GetInt(index, int) OR - Int(int, 10) & (int >= 0) - END FetchInt; + PROCEDURE FetchInt(VAR int: LONGINT) : BOOLEAN; + VAR + index: INTEGER; + BEGIN + RETURN (fmtchar = "*") & Next() & + NextArg(index) & GetInt(index, int) OR + Int(int, 10) & (int >= 0) + END FetchInt; - PROCEDURE Width() : BOOLEAN; - BEGIN - IF (fmtchar >= "0") & (fmtchar <= "9") OR (fmtchar = "*") THEN - IF FetchInt(width) THEN - RETURN TRUE - END; - Error(badFormat); RETURN FALSE - ELSE - width := 0; - RETURN TRUE - END; - END Width; + PROCEDURE Width() : BOOLEAN; + BEGIN + IF (fmtchar >= "0") & (fmtchar <= "9") OR (fmtchar = "*") THEN + IF FetchInt(width) THEN + RETURN TRUE + END; + Error(badFormat); RETURN FALSE + ELSE + width := 0; + RETURN TRUE + END; + END Width; - PROCEDURE Scale() : BOOLEAN; - BEGIN - IF fmtchar = "." THEN - IF Next() & FetchInt(scale) THEN - RETURN TRUE - ELSE - Error(badFormat); RETURN FALSE - END; - ELSE - scale := -1; RETURN TRUE - END; - END Scale; + PROCEDURE Scale() : BOOLEAN; + BEGIN + IF fmtchar = "." THEN + IF Next() & FetchInt(scale) THEN + RETURN TRUE + ELSE + Error(badFormat); RETURN FALSE + END; + ELSE + scale := -1; RETURN TRUE + END; + END Scale; - PROCEDURE Conversion() : BOOLEAN; + PROCEDURE Conversion() : BOOLEAN; - PROCEDURE Fill(cnt: LONGINT); - (* cnt: space used by normal output *) - VAR i: LONGINT; - BEGIN - IF cnt < width THEN - i := width - cnt; - WHILE i > 0 DO - Write(fillch); - DEC(i); - END; - END; - END Fill; + PROCEDURE Fill(cnt: LONGINT); + (* cnt: space used by normal output *) + VAR i: LONGINT; + BEGIN + IF cnt < width THEN + i := width - cnt; + WHILE i > 0 DO + Write(fillch); + DEC(i); + END; + END; + END Fill; - PROCEDURE FillLeft(cnt: LONGINT); - BEGIN - IF ~leftaligned THEN - Fill(cnt); - END; - END FillLeft; + PROCEDURE FillLeft(cnt: LONGINT); + BEGIN + IF ~leftaligned THEN + Fill(cnt); + END; + END FillLeft; - PROCEDURE FillRight(cnt: LONGINT); - BEGIN - IF leftaligned THEN - Fill(cnt); - END; - END FillRight; + PROCEDURE FillRight(cnt: LONGINT); + BEGIN + IF leftaligned THEN + Fill(cnt); + END; + END FillRight; - PROCEDURE WriteBool(true, false: ARRAY OF CHAR) : BOOLEAN; - VAR index: INTEGER; val: LONGINT; + PROCEDURE WriteBool(true, false: ARRAY OF CHAR) : BOOLEAN; + VAR index: INTEGER; val: LONGINT; - PROCEDURE WriteString(VAR s: ARRAY OF CHAR); - VAR i, len: INTEGER; - BEGIN - len := 0; - WHILE (len < LEN(s)) & (s[len] # 0X) DO - INC(len); - END; - FillLeft(len); - i := 0; - WHILE i < len DO - Write(s[i]); INC(i); - END; - FillRight(len); - END WriteString; + PROCEDURE WriteString(VAR s: ARRAY OF CHAR); + VAR i, len: INTEGER; + BEGIN + len := 0; + WHILE (len < LEN(s)) & (s[len] # 0X) DO + INC(len); + END; + FillLeft(len); + i := 0; + WHILE i < len DO + Write(s[i]); INC(i); + END; + FillRight(len); + END WriteString; - BEGIN - IF NextArg(index) & GetInt(index, val) THEN - IF val = 0 THEN - WriteString(false); RETURN TRUE - ELSIF val = 1 THEN - WriteString(true); RETURN TRUE - END; - END; - RETURN FALSE - END WriteBool; + BEGIN + IF NextArg(index) & GetInt(index, val) THEN + IF val = 0 THEN + WriteString(false); RETURN TRUE + ELSIF val = 1 THEN + WriteString(true); RETURN TRUE + END; + END; + RETURN FALSE + END WriteBool; - PROCEDURE WriteChar() : BOOLEAN; - VAR - val: LONGINT; - index: INTEGER; - BEGIN - IF NextArg(index) & GetInt(index, val) & - (val >= 0) & (val <= ORD(MAX(CHAR))) THEN - FillLeft(1); - Write(CHR(val)); - FillRight(1); - RETURN TRUE - END; - RETURN FALSE - END WriteChar; + PROCEDURE WriteChar() : BOOLEAN; + VAR + val: LONGINT; + index: INTEGER; + BEGIN + IF NextArg(index) & GetInt(index, val) & + (val >= 0) & (val <= ORD(MAX(CHAR))) THEN + FillLeft(1); + Write(CHR(val)); + FillRight(1); + RETURN TRUE + END; + RETURN FALSE + END WriteChar; - PROCEDURE WriteInt(base: INTEGER) : BOOLEAN; - VAR - index: INTEGER; - val: LONGINT; - neg: BOOLEAN; (* set by Convert *) - buf: ARRAY 12 OF CHAR; (* filled by Convert *) - i: INTEGER; - len: INTEGER; (* space needed for val *) - signcnt: INTEGER; (* =1 if sign printed; else 0 *) - signch: CHAR; + PROCEDURE WriteInt(base: INTEGER) : BOOLEAN; + VAR + index: INTEGER; + val: LONGINT; + neg: BOOLEAN; (* set by Convert *) + buf: ARRAY 12 OF CHAR; (* filled by Convert *) + i: INTEGER; + len: INTEGER; (* space needed for val *) + signcnt: INTEGER; (* =1 if sign printed; else 0 *) + signch: CHAR; - PROCEDURE Convert; - VAR - index: INTEGER; - digit: LONGINT; - BEGIN - neg := val < 0; - index := 0; - REPEAT - digit := val MOD base; - val := val DIV base; - IF neg & (digit > 0) THEN - digit := base - digit; - INC(val); - END; - IF digit < 10 THEN - buf[index] := CHR(ORD("0") + digit); - ELSE - buf[index] := CHR(ORD("A") + digit - 10); - END; - INC(index); - UNTIL val = 0; - len := index; - END Convert; + PROCEDURE Convert; + VAR + index: INTEGER; + digit: LONGINT; + BEGIN + neg := val < 0; + index := 0; + REPEAT + digit := val MOD base; + val := val DIV base; + IF neg & (digit > 0) THEN + digit := base - digit; + INC(val); + END; + IF digit < 10 THEN + buf[index] := CHR(ORD("0") + digit); + ELSE + buf[index] := CHR(ORD("A") + digit - 10); + END; + INC(index); + UNTIL val = 0; + len := index; + END Convert; - BEGIN (* WriteInt *) - IF NextArg(index) & GetInt(index, val) THEN - Convert; - IF sign OR neg THEN - signcnt := 1; - IF neg THEN - signch := "-"; - ELSE - signch := "+"; - END; - ELSE - signcnt := 0; - END; - IF insert & (signcnt = 1) THEN - Write(signch); - END; - FillLeft(len+signcnt); - IF ~insert & (signcnt = 1) THEN - Write(signch); - END; - i := len; - WHILE i > 0 DO - DEC(i); Write(buf[i]); - END; - FillRight(len+signcnt); - RETURN TRUE - END; - RETURN FALSE - END WriteInt; + BEGIN (* WriteInt *) + IF NextArg(index) & GetInt(index, val) THEN + Convert; + IF sign OR neg THEN + signcnt := 1; + IF neg THEN + signch := "-"; + ELSE + signch := "+"; + END; + ELSE + signcnt := 0; + END; + IF insert & (signcnt = 1) THEN + Write(signch); + END; + FillLeft(len+signcnt); + IF ~insert & (signcnt = 1) THEN + Write(signch); + END; + i := len; + WHILE i > 0 DO + DEC(i); Write(buf[i]); + END; + FillRight(len+signcnt); + RETURN TRUE + END; + RETURN FALSE + END WriteInt; - PROCEDURE WriteReal(format: CHAR) : BOOLEAN; - (* format either "f", "e", or "g" *) - CONST - defaultscale = 6; - VAR - index: INTEGER; - lr: LONGREAL; - r: REAL; - shortint: SHORTINT; int: INTEGER; longint: LONGINT; - (*int16: SYS.INT16;*) - long: BOOLEAN; - exponent: INTEGER; - mantissa: LONGREAL; - digits: ARRAY Reals.maxlongdignum OF CHAR; - neg: BOOLEAN; - ndigits: INTEGER; - decpt: INTEGER; + PROCEDURE WriteReal(format: CHAR) : BOOLEAN; + (* format either "f", "e", or "g" *) + CONST + defaultscale = 6; + VAR + index: INTEGER; + lr: LONGREAL; + r: REAL; + shortint: SHORTINT; int: INTEGER; longint: LONGINT; + int16: SYS.INT16; + long: BOOLEAN; + exponent: INTEGER; + mantissa: LONGREAL; + digits: ARRAY Reals.maxlongdignum OF CHAR; + neg: BOOLEAN; + ndigits: INTEGER; + decpt: INTEGER; - PROCEDURE Print(decpt: INTEGER; withexp: BOOLEAN; exp: INTEGER); - (* decpt: position of decimal point - = 0: just before the digits - > 0: after decpt digits - < 0: ABS(decpt) zeroes before digits needed - *) - VAR - needed: INTEGER; (* space needed *) - index: INTEGER; - count: LONGINT; + PROCEDURE Print(decpt: INTEGER; withexp: BOOLEAN; exp: INTEGER); + (* decpt: position of decimal point + = 0: just before the digits + > 0: after decpt digits + < 0: ABS(decpt) zeroes before digits needed + *) + VAR + needed: INTEGER; (* space needed *) + index: INTEGER; + count: LONGINT; - PROCEDURE WriteExp(exp: INTEGER); - CONST - base = 10; - VAR - power: INTEGER; - digit: INTEGER; - BEGIN - IF long THEN - Write("D"); - ELSE - Write("E"); - END; - IF exp < 0 THEN - Write("-"); exp := - exp; - ELSE - Write("+"); - END; - IF long THEN - power := 1000; - ELSE - power := 100; - END; - WHILE power > 0 DO - digit := (exp DIV power) MOD base; - Write(CHR(digit+ORD("0"))); - power := power DIV base; - END; - END WriteExp; + PROCEDURE WriteExp(exp: INTEGER); + CONST + base = 10; + VAR + power: INTEGER; + digit: INTEGER; + BEGIN + IF long THEN + Write("D"); + ELSE + Write("E"); + END; + IF exp < 0 THEN + Write("-"); exp := - exp; + ELSE + Write("+"); + END; + IF long THEN + power := 1000; + ELSE + power := 100; + END; + WHILE power > 0 DO + digit := (exp DIV power) MOD base; + Write(CHR(digit+ORD("0"))); + power := power DIV base; + END; + END WriteExp; - BEGIN (* Print *) - (* leading digits *) - IF decpt > 0 THEN - needed := decpt; - ELSE - needed := 1; - END; - IF neg OR sign THEN - INC(needed); - END; - IF withexp OR (scale # 0) THEN - INC(needed); (* decimal point *) - END; - IF withexp THEN - INC(needed, 2); (* E[+-] *) - IF long THEN - INC(needed, 4); - ELSE - INC(needed, 3); - END; - END; - INC(needed, SHORT(scale)); + BEGIN (* Print *) + (* leading digits *) + IF decpt > 0 THEN + needed := decpt; + ELSE + needed := 1; + END; + IF neg OR sign THEN + INC(needed); + END; + IF withexp OR (scale # 0) THEN + INC(needed); (* decimal point *) + END; + IF withexp THEN + INC(needed, 2); (* E[+-] *) + IF long THEN + INC(needed, 4); + ELSE + INC(needed, 3); + END; + END; + INC(needed, scale); - FillLeft(needed); - IF neg THEN - Write("-"); - ELSIF sign THEN - Write("+"); - END; - IF decpt <= 0 THEN - Write("0"); - ELSE - index := 0; - WHILE index < decpt DO - IF index < ndigits THEN - Write(digits[index]); - ELSE - Write("0"); - END; - INC(index); - END; - END; - IF withexp OR (scale > 0) THEN - Write("."); - END; - IF scale > 0 THEN - count := scale; - index := decpt; - WHILE (index < 0) & (count > 0) DO - Write("0"); INC(index); DEC(count); - END; - WHILE (index < ndigits) & (count > 0) DO - Write(digits[index]); INC(index); DEC(count); - END; - WHILE count > 0 DO - Write("0"); DEC(count); - END; - END; - IF withexp THEN - WriteExp(exp); - END; - FillRight(needed); - END Print; + FillLeft(needed); + IF neg THEN + Write("-"); + ELSIF sign THEN + Write("+"); + END; + IF decpt <= 0 THEN + Write("0"); + ELSE + index := 0; + WHILE index < decpt DO + IF index < ndigits THEN + Write(digits[index]); + ELSE + Write("0"); + END; + INC(index); + END; + END; + IF withexp OR (scale > 0) THEN + Write("."); + END; + IF scale > 0 THEN + count := scale; + index := decpt; + WHILE (index < 0) & (count > 0) DO + Write("0"); INC(index); DEC(count); + END; + WHILE (index < ndigits) & (count > 0) DO + Write(digits[index]); INC(index); DEC(count); + END; + WHILE count > 0 DO + Write("0"); DEC(count); + END; + END; + IF withexp THEN + WriteExp(exp); + END; + FillRight(needed); + END Print; - BEGIN (* WriteReal *) - IF NextArg(index) THEN - IF arglen[index] = SIZE(LONGREAL) THEN - long := TRUE; - Convert(index, lr); - ELSIF arglen[index] = SIZE(REAL) THEN - long := FALSE; - Convert(index, r); - lr := r; - ELSIF arglen[index] = SIZE(LONGINT) THEN - long := FALSE; - Convert(index, longint); - lr := longint; - ELSIF arglen[index] = SIZE(INTEGER) THEN - long := FALSE; - Convert(index, int); - lr := int; - (*ELSIF arglen[index] = SIZE(SYS.INT16) THEN - long := FALSE; - Convert(index, int16); - lr := int16;*) - ELSIF arglen[index] = SIZE(SHORTINT) THEN - long := FALSE; - Convert(index, shortint); - lr := shortint; - ELSE - Error(badArgumentSize); RETURN FALSE - END; - IF scale = -1 THEN - scale := defaultscale; - END; - (* check for NaNs and other invalid numbers *) - IF ~IEEE.Valid(lr) THEN - IF IEEE.NotANumber(lr) THEN - Write("N"); Write("a"); Write("N"); - RETURN TRUE - ELSE - IF lr < 0 THEN - Write("-"); - ELSE - Write("+"); - END; - Write("i"); Write("n"); Write("f"); - END; - RETURN TRUE - END; - (* real value in `lr' *) - Reals.ExpAndMan(lr, long, 10, exponent, mantissa); - CASE format OF - | "e": ndigits := SHORT(scale)+1; - | "f": ndigits := SHORT(scale)+exponent+1; - IF ndigits <= 0 THEN - ndigits := 1; - END; - | "g": ndigits := SHORT(scale); - ELSE - END; - Reals.Digits(mantissa, 10, digits, neg, - (* force = *) format # "g", ndigits); - decpt := 1; - CASE format OF - | "e": Print(decpt, (* withexp = *) TRUE, exponent); - | "f": INC(decpt, exponent); - Print(decpt, (* withexp = *) FALSE, 0); - | "g": IF (exponent < -4) OR (exponent > scale) THEN - scale := ndigits-1; - Print(decpt, (* withexp = *) TRUE, exponent); - ELSE - INC(decpt, exponent); - scale := ndigits-1; - DEC(scale, LONG(exponent)); - IF scale < 0 THEN - scale := 0; - END; - Print(decpt, (* withexp = *) FALSE, 0); - END; - ELSE - END; - RETURN TRUE - ELSE - RETURN FALSE - END; - END WriteReal; + BEGIN (* WriteReal *) + IF NextArg(index) THEN + IF arglen[index] = SIZE(LONGREAL) THEN + long := TRUE; + Convert(index, lr); + ELSIF arglen[index] = SIZE(REAL) THEN + long := FALSE; + Convert(index, r); + lr := r; + ELSIF arglen[index] = SIZE(LONGINT) THEN + long := FALSE; + Convert(index, longint); + lr := longint; + ELSIF arglen[index] = SIZE(INTEGER) THEN + long := FALSE; + Convert(index, int); + lr := int; + ELSIF arglen[index] = SIZE(SYS.INT16) THEN + long := FALSE; + Convert(index, int16); + lr := int16; + ELSIF arglen[index] = SIZE(SHORTINT) THEN + long := FALSE; + Convert(index, shortint); + lr := shortint; + ELSE + Error(badArgumentSize); RETURN FALSE + END; + IF scale = -1 THEN + scale := defaultscale; + END; + (* check for NaNs and other invalid numbers *) + IF ~IEEE.Valid(lr) THEN + IF IEEE.NotANumber(lr) THEN + Write("N"); Write("a"); Write("N"); + RETURN TRUE + ELSE + IF lr < 0 THEN + Write("-"); + ELSE + Write("+"); + END; + Write("i"); Write("n"); Write("f"); + END; + RETURN TRUE + END; + (* real value in `lr' *) + Reals.ExpAndMan(lr, long, 10, exponent, mantissa); + CASE format OF + | "e": ndigits := SHORT(scale)+1; + | "f": ndigits := SHORT(scale)+exponent+1; + IF ndigits <= 0 THEN + ndigits := 1; + END; + | "g": ndigits := SHORT(scale); + END; + Reals.Digits(mantissa, 10, digits, neg, + (* force = *) format # "g", ndigits); + decpt := 1; + CASE format OF + | "e": Print(decpt, (* withexp = *) TRUE, exponent); + | "f": INC(decpt, exponent); + Print(decpt, (* withexp = *) FALSE, 0); + | "g": IF (exponent < -4) OR (exponent > scale) THEN + scale := ndigits-1; + Print(decpt, (* withexp = *) TRUE, exponent); + ELSE + INC(decpt, exponent); + scale := ndigits-1; + DEC(scale, exponent); + IF scale < 0 THEN + scale := 0; + END; + Print(decpt, (* withexp = *) FALSE, 0); + END; + END; + RETURN TRUE + ELSE + RETURN FALSE + END; + END WriteReal; - PROCEDURE WriteString() : BOOLEAN; - VAR - index: INTEGER; - i: LONGINT; - byte: SYS.BYTE; - len: LONGINT; - BEGIN - IF NextArg(index) THEN - len := 0; - WHILE (len < arglen[index]) & - ((scale = -1) OR (len < scale)) & - ((*CHR*)SYS.VAL(CHAR, (Access(index, len))) # 0X) DO - INC(len); - END; - FillLeft(len); - i := 0; - WHILE i < len DO - byte := Access(index, i); - Write(byte); - INC(i); - END; - FillRight(len); - RETURN TRUE - END; - RETURN FALSE - END WriteString; + PROCEDURE WriteString() : BOOLEAN; + VAR + index: INTEGER; + i: LONGINT; + byte: BYTE; + len: LONGINT; + BEGIN + IF NextArg(index) THEN + len := 0; + WHILE (len < arglen[index]) & + ((scale = -1) OR (len < scale)) & + (CHR(Access(index, len)) # 0X) DO + INC(len); + END; + FillLeft(len); + i := 0; + WHILE i < len DO + byte := Access(index, i); + Write(byte); + INC(i); + END; + FillRight(len); + RETURN TRUE + END; + RETURN FALSE + END WriteString; - BEGIN (* Conversion *) - CASE fmtchar OF - | "b": RETURN WriteBool("TRUE", "FALSE") - | "c": RETURN WriteChar() - | "d": RETURN WriteInt(10) - | "e", - "f", - "g": RETURN WriteReal(fmtchar) - | "j": RETURN WriteBool("ja", "nein") - | "o": RETURN WriteInt(8) - | "s": RETURN WriteString() - | "x": RETURN WriteInt(16) - | "y": RETURN WriteBool("yes", "no") - ELSE - Error(badFormat); RETURN FALSE - END; - END Conversion; + BEGIN (* Conversion *) + CASE fmtchar OF + | "b": RETURN WriteBool("TRUE", "FALSE") + | "c": RETURN WriteChar() + | "d": RETURN WriteInt(10) + | "e", + "f", + "g": RETURN WriteReal(fmtchar) + | "j": RETURN WriteBool("ja", "nein") + | "o": RETURN WriteInt(8) + | "s": RETURN WriteString() + | "x": RETURN WriteInt(16) + | "y": RETURN WriteBool("yes", "no") + ELSE + Error(badFormat); RETURN FALSE + END; + END Conversion; BEGIN - IF ~Next() THEN RETURN FALSE END; - IF fmtchar = fmtcmd THEN Write(fmtcmd); RETURN TRUE END; - RETURN Flags() & Width() & Scale() & Conversion() + IF ~Next() THEN RETURN FALSE END; + IF fmtchar = fmtcmd THEN Write(fmtcmd); RETURN TRUE END; + RETURN Flags() & Width() & Scale() & Conversion() END Format; - + BEGIN out.count := 0; out.error := FALSE; SetSize; nextarg := 0; fmtindex := 0; WHILE Next() DO - IF fmtchar = fmtcmd THEN - IF ~Format() THEN - RETURN - END; - ELSIF (fmtchar = "\") & Next() THEN - CASE fmtchar OF - | "0".."9", "A".."F": - IF ~Int(hexcharval, 16) THEN - (* Error(s, BadFormat); *) RETURN - END; - Unget; - Write(CHR(hexcharval)); - | "b": Write(08X); (* back space *) - | "e": Write(1BX); (* escape *) - | "f": Write(0CX); (* form feed *) - | "n": WriteLn; - | "q": Write("'"); - | "Q": Write(22X); (* double quote: " *) - | "r": Write(0DX); (* carriage return *) - | "t": Write(09X); (* horizontal tab *) - | "&": Write(07X); (* bell *) - ELSE - Write(fmtchar); - END; - ELSE - Write(fmtchar); - END; + IF fmtchar = fmtcmd THEN + IF ~Format() THEN + RETURN + END; + ELSIF (fmtchar = "\") & Next() THEN + CASE fmtchar OF + | "0".."9", "A".."F": + IF ~Int(hexcharval, 16) THEN + (* Error(s, BadFormat); *) RETURN + END; + Unget; + Write(CHR(hexcharval)); + | "b": Write(08X); (* back space *) + | "e": Write(1BX); (* escape *) + | "f": Write(0CX); (* form feed *) + | "n": WriteLn; + | "q": Write("'"); + | "Q": Write(22X); (* double quote: " *) + | "r": Write(0DX); (* carriage return *) + | "t": Write(09X); (* horizontal tab *) + | "&": Write(07X); (* bell *) + ELSE + Write(fmtchar); + END; + ELSE + Write(fmtchar); + END; END; IF nextarg < nargs THEN - Error(tooManyArgs); + Error(tooManyArgs); ELSIF nextarg > nargs THEN - Error(tooFewArgs); + Error(tooFewArgs); END; END Out; (* === public part ============================================== *) - PROCEDURE F*(fmt: ARRAY OF CHAR); + PROCEDURE F(fmt: ARRAY OF CHAR); VAR x: INTEGER; BEGIN Out(Streams.stdout, fmt, 0, x,x,x,x,x,x,x,x,x, NIL); END F; - PROCEDURE F1*(fmt: ARRAY OF CHAR; p1: ARRAY OF SYS.BYTE); + PROCEDURE F1(fmt: ARRAY OF CHAR; p1: ARRAY OF BYTE); VAR x: INTEGER; BEGIN Out(Streams.stdout, fmt, 1, p1, x,x,x,x,x,x,x,x, NIL); END F1; - PROCEDURE F2*(fmt: ARRAY OF CHAR; p1, p2: ARRAY OF SYS.BYTE); + PROCEDURE F2(fmt: ARRAY OF CHAR; p1, p2: ARRAY OF BYTE); VAR x: INTEGER; BEGIN Out(Streams.stdout, fmt, 2, p1,p2, x,x,x,x,x,x,x, NIL); END F2; - PROCEDURE F3*(fmt: ARRAY OF CHAR; p1, p2, p3: ARRAY OF SYS.BYTE); + PROCEDURE F3(fmt: ARRAY OF CHAR; p1, p2, p3: ARRAY OF BYTE); VAR x: INTEGER; BEGIN Out(Streams.stdout, fmt, 3, p1,p2,p3, x,x,x,x,x,x, NIL); END F3; - PROCEDURE F4*(fmt: ARRAY OF CHAR; p1, p2, p3, p4: ARRAY OF SYS.BYTE); + PROCEDURE F4(fmt: ARRAY OF CHAR; p1, p2, p3, p4: ARRAY OF BYTE); VAR x: INTEGER; BEGIN Out(Streams.stdout, fmt, 4, p1,p2,p3,p4, x,x,x,x,x, NIL); END F4; - PROCEDURE F5*(fmt: ARRAY OF CHAR; p1, p2, p3, p4, p5: ARRAY OF SYS.BYTE); + PROCEDURE F5(fmt: ARRAY OF CHAR; p1, p2, p3, p4, p5: ARRAY OF BYTE); VAR x: INTEGER; BEGIN Out(Streams.stdout, fmt, 5, p1,p2,p3,p4,p5, x,x,x,x, NIL); END F5; - PROCEDURE F6*(fmt: ARRAY OF CHAR; p1, p2, p3, p4, p5, p6: ARRAY OF SYS.BYTE); + PROCEDURE F6(fmt: ARRAY OF CHAR; p1, p2, p3, p4, p5, p6: ARRAY OF BYTE); VAR x: INTEGER; BEGIN Out(Streams.stdout, fmt, 6, p1,p2,p3,p4,p5,p6, x,x,x, NIL); END F6; - PROCEDURE F7*(fmt: ARRAY OF CHAR; p1, p2, p3, p4, p5, p6, p7: ARRAY OF SYS.BYTE); + PROCEDURE F7(fmt: ARRAY OF CHAR; p1, p2, p3, p4, p5, p6, p7: ARRAY OF BYTE); VAR x: INTEGER; BEGIN Out(Streams.stdout, fmt, 7, p1,p2,p3,p4,p5,p6,p7, x,x, NIL); END F7; - PROCEDURE F8*(fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5, p6, p7, p8: ARRAY OF SYS.BYTE); + PROCEDURE F8(fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5, p6, p7, p8: ARRAY OF BYTE); VAR x: INTEGER; BEGIN Out(Streams.stdout, fmt, 8, p1,p2,p3,p4,p5,p6,p7,p8, x, NIL); END F8; - PROCEDURE F9*(fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5, p6, p7, p8, p9: ARRAY OF SYS.BYTE); + PROCEDURE F9(fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5, p6, p7, p8, p9: ARRAY OF BYTE); BEGIN Out(Streams.stdout, fmt, 9, p1,p2,p3,p4,p5,p6,p7,p8,p9, NIL); END F9; - PROCEDURE S*(out: Streams.Stream; fmt: ARRAY OF CHAR); + PROCEDURE S(out: Streams.Stream; fmt: ARRAY OF CHAR); VAR x: INTEGER; BEGIN Out(out, fmt, 0, x,x,x,x,x,x,x,x,x, NIL); END S; - PROCEDURE S1*(out: Streams.Stream; fmt: ARRAY OF CHAR; p1: ARRAY OF SYS.BYTE); + PROCEDURE S1(out: Streams.Stream; fmt: ARRAY OF CHAR; p1: ARRAY OF BYTE); VAR x: INTEGER; BEGIN Out(out, fmt, 1, p1, x,x,x,x,x,x,x,x, NIL); END S1; - PROCEDURE S2*(out: Streams.Stream; fmt: ARRAY OF CHAR; p1, p2: ARRAY OF SYS.BYTE); + PROCEDURE S2(out: Streams.Stream; fmt: ARRAY OF CHAR; p1, p2: ARRAY OF BYTE); VAR x: INTEGER; BEGIN Out(out, fmt, 2, p1,p2, x,x,x,x,x,x,x, NIL); END S2; - PROCEDURE S3*(out: Streams.Stream; fmt: ARRAY OF CHAR; p1, p2, p3: ARRAY OF SYS.BYTE); + PROCEDURE S3(out: Streams.Stream; fmt: ARRAY OF CHAR; p1, p2, p3: ARRAY OF BYTE); VAR x: INTEGER; BEGIN Out(out, fmt, 3, p1,p2,p3, x,x,x,x,x,x, NIL); END S3; - PROCEDURE S4*(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4: ARRAY OF SYS.BYTE); + PROCEDURE S4(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4: ARRAY OF BYTE); VAR x: INTEGER; BEGIN Out(out, fmt, 4, p1,p2,p3,p4, x,x,x,x,x, NIL); END S4; - PROCEDURE S5*(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5: ARRAY OF SYS.BYTE); + PROCEDURE S5(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5: ARRAY OF BYTE); VAR x: INTEGER; BEGIN Out(out, fmt, 5, p1,p2,p3,p4,p5, x,x,x,x, NIL); END S5; - PROCEDURE S6*(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5, p6: ARRAY OF SYS.BYTE); + PROCEDURE S6(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5, p6: ARRAY OF BYTE); VAR x: INTEGER; BEGIN Out(out, fmt, 6, p1,p2,p3,p4,p5,p6, x,x,x, NIL); END S6; - PROCEDURE S7*(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5, p6, p7: ARRAY OF SYS.BYTE); + PROCEDURE S7(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5, p6, p7: ARRAY OF BYTE); VAR x: INTEGER; BEGIN Out(out, fmt, 7, p1,p2,p3,p4,p5,p6,p7, x,x, NIL); END S7; - PROCEDURE S8*(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5, p6, p7, p8: ARRAY OF SYS.BYTE); + PROCEDURE S8(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5, p6, p7, p8: ARRAY OF BYTE); VAR x: INTEGER; BEGIN Out(out, fmt, 8, p1,p2,p3,p4,p5,p6,p7,p8, x, NIL); END S8; - PROCEDURE S9*(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5, p6, p7, p8, p9: ARRAY OF SYS.BYTE); + PROCEDURE S9(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5, p6, p7, p8, p9: ARRAY OF BYTE); BEGIN Out(out, fmt, 9, p1,p2,p3,p4,p5,p6,p7,p8,p9, NIL); END S9; - PROCEDURE SE*(out: Streams.Stream; fmt: ARRAY OF CHAR; - errors: RelatedEvents.Object); + PROCEDURE SE(out: Streams.Stream; fmt: ARRAY OF CHAR; + errors: RelatedEvents.Object); VAR x: INTEGER; BEGIN Out(out, fmt, 0, x,x,x,x,x,x,x,x,x, NIL); END SE; - PROCEDURE SE1*(out: Streams.Stream; fmt: ARRAY OF CHAR; p1: ARRAY OF SYS.BYTE; + PROCEDURE SE1(out: Streams.Stream; fmt: ARRAY OF CHAR; p1: ARRAY OF BYTE; errors: RelatedEvents.Object); VAR x: INTEGER; BEGIN Out(out, fmt, 1, p1, x,x,x,x,x,x,x,x, errors); END SE1; - PROCEDURE SE2*(out: Streams.Stream; fmt: ARRAY OF CHAR; p1, p2: ARRAY OF SYS.BYTE; + PROCEDURE SE2(out: Streams.Stream; fmt: ARRAY OF CHAR; p1, p2: ARRAY OF BYTE; errors: RelatedEvents.Object); VAR x: INTEGER; BEGIN Out(out, fmt, 2, p1,p2, x,x,x,x,x,x,x, errors); END SE2; - PROCEDURE SE3*(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3: ARRAY OF SYS.BYTE; + PROCEDURE SE3(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3: ARRAY OF BYTE; errors: RelatedEvents.Object); VAR x: INTEGER; BEGIN Out(out, fmt, 3, p1,p2,p3, x,x,x,x,x,x, errors); END SE3; - PROCEDURE SE4*(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4: ARRAY OF SYS.BYTE; + PROCEDURE SE4(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4: ARRAY OF BYTE; errors: RelatedEvents.Object); VAR x: INTEGER; BEGIN Out(out, fmt, 4, p1,p2,p3,p4, x,x,x,x,x, errors); END SE4; - PROCEDURE SE5*(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5: ARRAY OF SYS.BYTE; + PROCEDURE SE5(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5: ARRAY OF BYTE; errors: RelatedEvents.Object); VAR x: INTEGER; BEGIN Out(out, fmt, 5, p1,p2,p3,p4,p5, x,x,x,x, errors); END SE5; - PROCEDURE SE6*(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5, p6: ARRAY OF SYS.BYTE; + PROCEDURE SE6(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5, p6: ARRAY OF BYTE; errors: RelatedEvents.Object); VAR x: INTEGER; BEGIN Out(out, fmt, 6, p1,p2,p3,p4,p5,p6, x,x,x, errors); END SE6; - PROCEDURE SE7*(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5, p6, p7: ARRAY OF SYS.BYTE; + PROCEDURE SE7(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5, p6, p7: ARRAY OF BYTE; errors: RelatedEvents.Object); VAR x: INTEGER; BEGIN Out(out, fmt, 7, p1,p2,p3,p4,p5,p6,p7, x,x, errors); END SE7; - PROCEDURE SE8*(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5, p6, p7, p8: ARRAY OF SYS.BYTE; + PROCEDURE SE8(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5, p6, p7, p8: ARRAY OF BYTE; errors: RelatedEvents.Object); VAR x: INTEGER; BEGIN Out(out, fmt, 8, p1,p2,p3,p4,p5,p6,p7,p8, x, errors); END SE8; - PROCEDURE SE9*(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5, p6, p7, p8, p9: ARRAY OF SYS.BYTE; + PROCEDURE SE9(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5, p6, p7, p8, p9: ARRAY OF BYTE; errors: RelatedEvents.Object); BEGIN Out(out, fmt, 9, p1,p2,p3,p4,p5,p6,p7,p8,p9, errors); @@ -965,4 +961,4 @@ MODULE ulmPrint; BEGIN InitErrorHandling; -END ulmPrint. +END Print. diff --git a/src/library/ulm/ulmSYSTEM.Mod b/src/library/ulm/ulmSYSTEM.Mod index 796a0d1b..f4efb7d5 100644 --- a/src/library/ulm/ulmSYSTEM.Mod +++ b/src/library/ulm/ulmSYSTEM.Mod @@ -19,7 +19,7 @@ TYPE pchar = POINTER TO ARRAY 1 OF CHAR; i := 0; REPEAT SYSTEM.GET(adr + i, b); - lar[i] := b; + bar[i] := b; INC(i) UNTIL i = SIZE(LONGINT) END LongToByteArr; @@ -138,4 +138,5 @@ TYPE pchar = POINTER TO ARRAY 1 OF CHAR; BEGIN SYSTEM.MOVE(from, to, n); END WMOVE; + END ulmSYSTEM. diff --git a/src/library/ulm/ulmTypes.Mod b/src/library/ulm/ulmTypes.Mod index 0d09a4f5..755f7cee 100644 --- a/src/library/ulm/ulmTypes.Mod +++ b/src/library/ulm/ulmTypes.Mod @@ -40,7 +40,7 @@ ---------------------------------------------------------------------------- *) -MODULE ulmTypes; +MODULE Types; (* compiler-dependent type definitions; this version works for Ulm's Oberon Compilers on @@ -51,24 +51,23 @@ MODULE ulmTypes; TYPE Address* = SYS.ADDRESS; + UntracedAddress* = POINTER[1] TO UntracedAddressDesc; + UntracedAddressDesc* = RECORD[1] END; - UntracedAddress* = POINTER[1] TO UntracedAddressDesc; (*SYS.UNTRACEDADDRESS;*) - UntracedAddressDesc* = RECORD[1] END; - - Count* = SYS.INT32; - Size* = Count; - Byte* = SYS.BYTE; - IntAddress* = LONGINT; - Int8* = SYS.INT8; - Int16* = SYS.INT16; - Int32* = SYS.INT32; - Real32* = REAL; - Real64* = LONGREAL; + Count* = SYS.INT32; + Size* = Count; + Byte* = SYS.BYTE; + IntAddress* = SYS.INT32; + Int8* = SYS.INT8; + Int16* = SYS.INT16; + Int32* = SYS.INT32; + Real32* = LONGREAL; + Real64* = LONGREAL; CONST - bigEndian* = 0; (* SPARC, M68K etc *) + bigEndian* = 0; (* SPARC, M68K etc *) littleEndian* = 1; (* Intel 80x86, VAX etc *) - byteorder* = littleEndian; (* machine-dependent constant *) + byteorder* = littleEndian; (* machine-dependent constant *) TYPE ByteOrder* = SHORTINT; (* bigEndian or littleEndian *) @@ -77,14 +76,27 @@ MODULE ulmTypes; to allow for bit operations on INTEGER values *) TYPE - SetInt* = LONGINT; (* INTEGER type that corresponds to SET *) - VAR msb* : SET; - msbIsMax*, msbIs0*: SHORTINT; - msbindex*, lsbindex*, nofbits*: LONGINT; + SetInt* = INTEGER; (* INTEGER type that corresponds to SET *) + CONST + msb* = SYS.VAL(SET, MIN(SetInt)); + (* most significant bit, converted to a SET *) + (* we expect msbIsMax XOR msbIs0 to be 1; + this is checked for by an assertion + *) + msbIsMax* = SYS.VAL(SHORTINT, (msb = {MAX(SET)})); + (* is 1, if msb equals {MAX(SET)} *) + msbIs0* = SYS.VAL(SHORTINT, (msb = {0})); + (* is 0, if msb equals {0} *) + msbindex* = msbIsMax * MAX(SET); + (* set element that corresponds to the most-significant-bit *) + lsbindex* = MAX(SET) - msbindex; + (* set element that corresponds to the lowest-significant-bit *) + nofbits* = MAX(SET) + 1; + (* number of elements in SETs *) PROCEDURE ToInt8*(int: LONGINT) : Int8; BEGIN - RETURN SYS.VAL(SHORTINT, int) + RETURN SHORT(SHORT(int)) END ToInt8; PROCEDURE ToInt16*(int: LONGINT) : Int16; @@ -94,7 +106,7 @@ MODULE ulmTypes; PROCEDURE ToInt32*(int: LONGINT) : Int32; BEGIN - RETURN SYS.VAL(INTEGER, int) + RETURN int END ToInt32; PROCEDURE ToReal32*(real: LONGREAL) : Real32; @@ -104,25 +116,9 @@ MODULE ulmTypes; PROCEDURE ToReal64*(real: LONGREAL) : Real64; BEGIN - RETURN real + RETURN SHORT(real) END ToReal64; BEGIN - msb := SYS.VAL(SET, MIN(SetInt)); - (* most significant bit, converted to a SET *) - (* we expect msbIsMax XOR msbIs0 to be 1; - this is checked for by an assertion - *) - msbIsMax := SYS.VAL(SHORTINT, (msb = {MAX(SET)})); - (* is 1, if msb equals {MAX(SET)} *) - msbIs0 := SYS.VAL(SHORTINT, (msb = {0})); - (* is 0, if msb equals {0} *) - msbindex := msbIsMax * MAX(SET); - (* set element that corresponds to the most-significant-bit *) - lsbindex := MAX(SET) - msbindex; - (* set element that corresponds to the lowest-significant-bit *) - nofbits := MAX(SET) + 1; - (* number of elements in SETs *) - ASSERT((msbIs0 = 1) & (msbIsMax = 0) OR (msbIs0 = 0) & (msbIsMax = 1)); -END ulmTypes. +END Types. From 0e1c5fe498d8de3774e74f47f8e35472c8142c9c Mon Sep 17 00:00:00 2001 From: norayr Date: Wed, 30 Nov 2016 19:39:26 +0400 Subject: [PATCH 4/4] ulm library compiled by fixing integer, longint, shortint and set sizes. -- noch --- src/library/ulm/ulmAssertions.Mod | 2 +- src/library/ulm/ulmAsymmetricCiphers.Mod | 12 +- src/library/ulm/ulmBlockCiphers.Mod | 16 +- src/library/ulm/ulmCipherOps.Mod | 10 +- src/library/ulm/ulmCiphers.Mod | 8 +- src/library/ulm/ulmClocks.Mod | 8 +- src/library/ulm/ulmConclusions.Mod | 12 +- src/library/ulm/ulmConditions.Mod | 44 ++-- src/library/ulm/ulmConstStrings.Mod | 50 ++-- src/library/ulm/ulmEvents.Mod | 30 +-- src/library/ulm/ulmIO.Mod | 38 +-- src/library/ulm/ulmIntOperations.Mod | 18 +- src/library/ulm/ulmMC68881.Mod | 56 ++--- src/library/ulm/ulmNetIO.Mod | 58 ++--- src/library/ulm/ulmOperations.Mod | 10 +- src/library/ulm/ulmPersistentObjects.Mod | 28 +-- src/library/ulm/ulmPlotters.Mod | 44 ++-- src/library/ulm/ulmPrint.Mod | 292 ++++++++++++----------- src/library/ulm/ulmPriorities.Mod | 4 +- src/library/ulm/ulmProcess.Mod | 6 +- src/library/ulm/ulmRandomGenerators.Mod | 40 ++-- src/library/ulm/ulmReals.Mod | 52 ++-- src/library/ulm/ulmScales.Mod | 20 +- src/library/ulm/ulmServices.Mod | 34 +-- src/library/ulm/ulmSets.Mod | 53 ++-- src/library/ulm/ulmStreamDisciplines.Mod | 12 +- src/library/ulm/ulmStreams.Mod | 28 +-- src/library/ulm/ulmStrings.Mod | 26 +- src/library/ulm/ulmSysConversions.Mod | 74 +++--- src/library/ulm/ulmSysErrors.Mod | 18 +- src/library/ulm/ulmSysIO.Mod | 44 ++-- src/library/ulm/ulmSysStat.Mod | 52 ++-- src/library/ulm/ulmSysTypes.Mod | 12 +- src/library/ulm/ulmTCrypt.Mod | 123 +++++----- src/library/ulm/ulmTimers.Mod | 6 +- src/library/ulm/ulmTimes.Mod | 14 +- src/library/ulm/ulmTypes.Mod | 62 ++--- src/library/ulm/ulmWrite.Mod | 38 +-- src/tools/make/oberon.mk | 2 +- 39 files changed, 733 insertions(+), 723 deletions(-) diff --git a/src/library/ulm/ulmAssertions.Mod b/src/library/ulm/ulmAssertions.Mod index 0f6fe59e..dcceea08 100644 --- a/src/library/ulm/ulmAssertions.Mod +++ b/src/library/ulm/ulmAssertions.Mod @@ -35,7 +35,7 @@ MODULE ulmAssertions; (* general error handling of library routines *) - IMPORT Disciplines := ulmDisciplines, Events := ulmEvents, IO := ulmIO, Priorities := ulmPriorities, RelatedEvents := ulmRelatedEvents, Services := ulmServices; + IMPORT Disciplines := ulmDisciplines, Events := ulmEvents, IO := ulmIO, Priorities := ulmPriorities, RelatedEvents := ulmRelatedEvents, Services := ulmServices, Types := ulmTypes; TYPE Object = Disciplines.Object; diff --git a/src/library/ulm/ulmAsymmetricCiphers.Mod b/src/library/ulm/ulmAsymmetricCiphers.Mod index ba8dfdda..069972bd 100644 --- a/src/library/ulm/ulmAsymmetricCiphers.Mod +++ b/src/library/ulm/ulmAsymmetricCiphers.Mod @@ -30,13 +30,13 @@ MODULE ulmAsymmetricCiphers; (* Michael Szczuka *) (* abstraction for the use of public key ciphers *) - IMPORT BlockCiphers := ulmBlockCiphers, Ciphers := ulmCiphers, NetIO := ulmNetIO, PersistentObjects := ulmPersistentObjects, Services := ulmServices, Streams := ulmStreams; + IMPORT BlockCiphers := ulmBlockCiphers, Ciphers := ulmCiphers, NetIO := ulmNetIO, PersistentObjects := ulmPersistentObjects, Services := ulmServices, Streams := ulmStreams, Types := ulmTypes; CONST composed* = 0; isPrivateKey* = 1; TYPE - CapabilitySet* = SET; + CapabilitySet* = Types.Set; TYPE Cipher* = POINTER TO CipherRec; @@ -66,13 +66,13 @@ MODULE ulmAsymmetricCiphers; (* Michael Szczuka *) (* need to have this in case anyone wants to decrypt something with a public cipher ... *) PROCEDURE Identity(in: Streams.Stream; key: Ciphers.Cipher; - length: INTEGER; out: Streams.Stream) : BOOLEAN; + length: Types.Int32; out: Streams.Stream) : BOOLEAN; BEGIN RETURN Streams.Copy(in, out, length); END Identity; PROCEDURE Init* (key: Cipher; if: Interface; - cap: CapabilitySet; inLength, outLength: INTEGER); + cap: CapabilitySet; inLength, outLength: Types.Int32); BEGIN IF if.decrypt = NIL THEN (* decrypt is not defined, so we have only the public part of a cipher; @@ -122,7 +122,7 @@ MODULE ulmAsymmetricCiphers; (* Michael Szczuka *) END ComposedEncrypt; PROCEDURE ComposedEncryptPart* (in: Streams.Stream; key: Cipher; - length: INTEGER; + length: Types.Int32; out: Streams.Stream) : BOOLEAN; BEGIN RETURN key.asymIf.compencrypt(in, key, length, out); @@ -131,7 +131,7 @@ MODULE ulmAsymmetricCiphers; (* Michael Szczuka *) PROCEDURE ComposedEncryptBlock* (in: Streams.Stream; key: Cipher; out: Streams.Stream) : BOOLEAN; VAR - length : INTEGER; + length : Types.Int32; BEGIN length := BlockCiphers.GetInLength(key); RETURN key.asymIf.compencrypt(in, key, length, out); diff --git a/src/library/ulm/ulmBlockCiphers.Mod b/src/library/ulm/ulmBlockCiphers.Mod index 41e3355c..630b4c91 100644 --- a/src/library/ulm/ulmBlockCiphers.Mod +++ b/src/library/ulm/ulmBlockCiphers.Mod @@ -30,7 +30,7 @@ MODULE ulmBlockCiphers; (* Michael Szczuka *) (* abstraction for the use of block ciphers *) - IMPORT Ciphers := ulmCiphers, NetIO := ulmNetIO, PersistentObjects := ulmPersistentObjects, Services := ulmServices, Streams := ulmStreams; + IMPORT Ciphers := ulmCiphers, NetIO := ulmNetIO, PersistentObjects := ulmPersistentObjects, Services := ulmServices, Streams := ulmStreams, Types := ulmTypes; TYPE Cipher* = POINTER TO CipherRec; @@ -38,8 +38,8 @@ MODULE ulmBlockCiphers; (* Michael Szczuka *) CipherRec* = RECORD (Ciphers.CipherRec) (* private *) - inLength: INTEGER; - outLength: INTEGER; + inLength: Types.Int32; + outLength: Types.Int32; END; VAR @@ -47,7 +47,7 @@ MODULE ulmBlockCiphers; (* Michael Szczuka *) if : PersistentObjects.Interface; PROCEDURE Init* (key: Cipher; if: Ciphers.Interface; - inLength, outLength: INTEGER); + inLength, outLength: Types.Int32); (* init a block cipher with its special interface *) BEGIN Ciphers.Init(key, if); @@ -57,13 +57,13 @@ MODULE ulmBlockCiphers; (* Michael Szczuka *) key.outLength := outLength; END Init; - PROCEDURE GetInLength* (key: Cipher) : INTEGER; + PROCEDURE GetInLength* (key: Cipher) : Types.Int32; (* returns the input block length of a block cipher *) BEGIN RETURN key.inLength; END GetInLength; - PROCEDURE GetOutLength* (key: Cipher) : INTEGER; + PROCEDURE GetOutLength* (key: Cipher) : Types.Int32; (* returns the output block length of a block cipher *) BEGIN RETURN key.outLength; @@ -72,7 +72,7 @@ MODULE ulmBlockCiphers; (* Michael Szczuka *) PROCEDURE EncryptBlock* (in: Streams.Stream; key: Cipher; out: Streams.Stream) : BOOLEAN; VAR - length : INTEGER; + length : Types.Int32; BEGIN length := GetInLength(key); RETURN Ciphers.EncryptPart(in, key, length, out); @@ -81,7 +81,7 @@ MODULE ulmBlockCiphers; (* Michael Szczuka *) PROCEDURE DecryptBlock* (in: Streams.Stream; key: Cipher; out: Streams.Stream) : BOOLEAN; VAR - length : INTEGER; + length : Types.Int32; BEGIN length := GetOutLength(key); RETURN Ciphers.DecryptPart(in, key, length, out); diff --git a/src/library/ulm/ulmCipherOps.Mod b/src/library/ulm/ulmCipherOps.Mod index f2ef7602..39d951c2 100644 --- a/src/library/ulm/ulmCipherOps.Mod +++ b/src/library/ulm/ulmCipherOps.Mod @@ -30,18 +30,18 @@ MODULE ulmCipherOps; (* Michael Szczuka *) (* useful functions for stream ciphers *) - IMPORT Streams := ulmStreams, SYS := SYSTEM, Write := ulmWrite; + IMPORT Streams := ulmStreams, SYS := SYSTEM, Write := ulmWrite, Types := ulmTypes; PROCEDURE XorByte* (b1, b2: SYS.BYTE) : SYS.BYTE; (* adds two bytes bitwise modulo 2 *) BEGIN - (*RETURN SYS.VAL(SYS.BYTE, SYS.VAL(SET, LONG(b1)) / SYS.VAL(SET, LONG(b2)))*) - RETURN SYS.VAL(SYS.BYTE, SYS.VAL(SET, LONG(LONG(SYS.VAL(SHORTINT, b1)))) - / SYS.VAL(SET, LONG(LONG(SYS.VAL(SHORTINT, b2))))) + (*RETURN SYS.VAL(SYS.BYTE, SYS.VAL(Types.Set, LONG(b1)) / SYS.VAL(Types.Set, LONG(b2)))*) + RETURN SYS.VAL(SYS.BYTE, SYS.VAL(Types.Set, LONG(LONG(SYS.VAL(Types.Int8, b1)))) + / SYS.VAL(Types.Set, LONG(LONG(SYS.VAL(Types.Int8, b2))))) END XorByte; PROCEDURE XorStream* (in1, in2, out: Streams.Stream; - length: INTEGER) : BOOLEAN; + length: Types.Int32) : BOOLEAN; (* adds two streams bitwise modulo 2; restricted to length bytes *) VAR b1, b2, res : SYS.BYTE; diff --git a/src/library/ulm/ulmCiphers.Mod b/src/library/ulm/ulmCiphers.Mod index 95d66aa8..fbd97445 100644 --- a/src/library/ulm/ulmCiphers.Mod +++ b/src/library/ulm/ulmCiphers.Mod @@ -30,14 +30,14 @@ MODULE ulmCiphers; IMPORT Objects := ulmObjects, PersistentObjects := ulmPersistentObjects, PersistentDisciplines := ulmPersistentDisciplines, Services := ulmServices, - Streams := ulmStreams, Write := ulmWrite; + Streams := ulmStreams, Write := ulmWrite, Types := ulmTypes; TYPE Cipher* = POINTER TO CipherRec; TYPE CryptProc* = PROCEDURE (in: Streams.Stream; key: Cipher; - length: INTEGER; out: Streams.Stream) : BOOLEAN; + length: Types.Int32; out: Streams.Stream) : BOOLEAN; TYPE Interface* = POINTER TO InterfaceRec; @@ -77,13 +77,13 @@ BEGIN END Decrypt; PROCEDURE EncryptPart*(in: Streams.Stream; key: Cipher; - length: INTEGER; out: Streams.Stream) : BOOLEAN; + length: Types.Int32; out: Streams.Stream) : BOOLEAN; BEGIN RETURN key.if.encrypt(in, key, length, out); END EncryptPart; PROCEDURE DecryptPart*(in: Streams.Stream; key: Cipher; - length: INTEGER; out: Streams.Stream) : BOOLEAN; + length: Types.Int32; out: Streams.Stream) : BOOLEAN; BEGIN RETURN key.if.decrypt(in, key, length, out); END DecryptPart; diff --git a/src/library/ulm/ulmClocks.Mod b/src/library/ulm/ulmClocks.Mod index d0416cfb..6a72d661 100644 --- a/src/library/ulm/ulmClocks.Mod +++ b/src/library/ulm/ulmClocks.Mod @@ -37,7 +37,7 @@ MODULE ulmClocks; IMPORT Disciplines := ulmDisciplines, Events := ulmEvents, Objects := ulmObjects, Op := ulmOperations, Priorities := ulmPriorities, - RelatedEvents := ulmRelatedEvents, Services := ulmServices, Times := ulmTimes; + RelatedEvents := ulmRelatedEvents, Services := ulmServices, Times := ulmTimes, Types := ulmTypes; TYPE Clock* = POINTER TO ClockRec; @@ -45,7 +45,7 @@ MODULE ulmClocks; CONST settime* = 0; timer* = 1; passed* = 2; TYPE - CapabilitySet* = SET; (* OF [settime..passed] *) + CapabilitySet* = Types.Set; (* OF [settime..passed] *) TYPE GetTimeProc* = PROCEDURE (clock: Clock; VAR time: Times.Time); SetTimeProc* = PROCEDURE (clock: Clock; time: Times.Time); @@ -102,13 +102,13 @@ MODULE ulmClocks; ErrorEventRec* = RECORD (Events.EventRec) - errorcode*: SHORTINT; + errorcode*: Types.Int8; END; VAR errormsg*: ARRAY errorcodes OF Events.Message; error*: Events.EventType; - PROCEDURE Error(clock: Clock; code: SHORTINT); + PROCEDURE Error(clock: Clock; code: Types.Int8); VAR event: ErrorEvent; BEGIN diff --git a/src/library/ulm/ulmConclusions.Mod b/src/library/ulm/ulmConclusions.Mod index 2d0a6ade..7012b15c 100644 --- a/src/library/ulm/ulmConclusions.Mod +++ b/src/library/ulm/ulmConclusions.Mod @@ -39,22 +39,22 @@ MODULE ulmConclusions; *) IMPORT Errors := ulmErrors, Events := ulmEvents, Process := ulmProcess, RelatedEvents := ulmRelatedEvents, StreamDisciplines := ulmStreamDisciplines, - Streams := ulmStreams, Strings := ulmStrings, Write := ulmWrite; + Streams := ulmStreams, Strings := ulmStrings, Write := ulmWrite, Types := ulmTypes; VAR handlerSet*: Errors.HandlerSet; - errors*: INTEGER; (* number of errors *) - fatalcode*: INTEGER; (* exit code on fatal events *) + errors*: Types.Int32; (* number of errors *) + fatalcode*: Types.Int32; (* exit code on fatal events *) (* private variables *) cmdName: Process.Name; (* should be sufficient for a base name *) - cmdNameLen: INTEGER; (* Strings.Len(cmdName) *) + cmdNameLen: Types.Int32; (* Strings.Len(cmdName) *) (* private procedures *) PROCEDURE GeneralHandler(event: Events.Event; kind: Errors.Kind); VAR - width: INTEGER; + width: Types.Int32; BEGIN IF event # NIL THEN Write.IndentS(Streams.stderr); @@ -114,7 +114,7 @@ MODULE ulmConclusions; text: ARRAY OF CHAR); VAR queue: RelatedEvents.Queue; - width: INTEGER; + width: Types.Int32; PROCEDURE ReverseQueue(VAR queue: RelatedEvents.Queue); VAR diff --git a/src/library/ulm/ulmConditions.Mod b/src/library/ulm/ulmConditions.Mod index 2b983470..101d590c 100644 --- a/src/library/ulm/ulmConditions.Mod +++ b/src/library/ulm/ulmConditions.Mod @@ -60,12 +60,12 @@ MODULE ulmConditions; IMPORT Clocks := ulmClocks, Disciplines := ulmDisciplines, Events := ulmEvents, Objects := ulmObjects, Op := ulmOperations, - Priorities := ulmPriorities, Process := ulmProcess, RelatedEvents := ulmRelatedEvents, Scales := ulmScales, Timers := ulmTimers, Times := ulmTimes, SYSTEM; + Priorities := ulmPriorities, Process := ulmProcess, RelatedEvents := ulmRelatedEvents, Scales := ulmScales, Timers := ulmTimers, Times := ulmTimes, SYSTEM, Types := ulmTypes; CONST tags = 64; TYPE - Tag = INTEGER; (* 0..tags-1 *) + Tag = Types.Int32; (* 0..tags-1 *) (* tags are used for the hashs *) VAR nextTag: Tag; (* 0..tags-1, 0..tags-1, ... *) @@ -95,16 +95,16 @@ MODULE ulmConditions; ConditionSetRec* = RECORD (Objects.ObjectRec) - cardinality: INTEGER; + cardinality: Types.Int32; bucket: BucketTable; (* for the iterator *) - next: ConditionList; i: INTEGER; + next: ConditionList; i: Types.Int32; END; CONST select* = 0; timelimit* = 1; async* = 2; timecond* = 3; preconditions* = 4; TYPE - CapabilitySet* = SET; (* OF [select..preconditions] *) + CapabilitySet* = Types.Set; (* OF [select..preconditions] *) TYPE SelectProc* = PROCEDURE (domain: Domain; conditionSet: ConditionSet; time: Times.Time; @@ -159,7 +159,7 @@ MODULE ulmConditions; END; TYPE - GetTimeOfNextTryProc* = PROCEDURE (iteration: INTEGER; + GetTimeOfNextTryProc* = PROCEDURE (iteration: Types.Int32; VAR time: Times.Time); (* return a relative time measure *) VAR @@ -188,7 +188,7 @@ MODULE ulmConditions; getTimeOfNextTry := p; END SetGetTimeOfNextTryProc; - PROCEDURE GetTimeOfNextTry(iteration: INTEGER; VAR time: Times.Time); + PROCEDURE GetTimeOfNextTry(iteration: Types.Int32; VAR time: Times.Time); BEGIN Times.CreateAndSet(time, Times.relative, 0, 1, 0); iteration := iteration DIV 5; @@ -203,7 +203,7 @@ MODULE ulmConditions; PROCEDURE CreateSet*(VAR conditionSet: ConditionSet); VAR - i: INTEGER; + i: Types.Int32; cset: ConditionSet; BEGIN NEW(cset); @@ -226,7 +226,7 @@ MODULE ulmConditions; VAR listp: ConditionList; new: ConditionList; - i: INTEGER; + i: Types.Int32; BEGIN (* check if condition is already present in conditionSet *) i := condition.tag; @@ -245,7 +245,7 @@ MODULE ulmConditions; PROCEDURE Excl*(conditionSet: ConditionSet; condition: Condition); VAR prev, listp: ConditionList; - i: INTEGER; + i: Types.Int32; BEGIN i := condition.tag; listp := conditionSet.bucket[i]; prev := NIL; @@ -282,8 +282,8 @@ MODULE ulmConditions; VAR listp: ConditionList; newelem, newelems: ConditionList; - count: INTEGER; (* # of added elements in newelems *) - i: INTEGER; + count: Types.Int32; (* # of added elements in newelems *) + i: Types.Int32; BEGIN count := 0; i := 0; @@ -320,7 +320,7 @@ MODULE ulmConditions; CreateSet(result); Union(result, set1); Union(result, set2); END Union3; - PROCEDURE Card*(conditionSet: ConditionSet) : INTEGER; + PROCEDURE Card*(conditionSet: ConditionSet) : Types.Int32; BEGIN RETURN conditionSet.cardinality END Card; @@ -334,7 +334,7 @@ MODULE ulmConditions; PROCEDURE GetNextCondition*(conditionSet: ConditionSet; VAR condition: Condition) : BOOLEAN; VAR - i: INTEGER; + i: Types.Int32; BEGIN IF conditionSet.next = NIL THEN i := conditionSet.i; @@ -380,7 +380,7 @@ MODULE ulmConditions; VAR domain: Domain) : BOOLEAN; VAR dom: Domain; - i: INTEGER; + i: Types.Int32; listp: ConditionList; BEGIN dom := NIL; @@ -448,7 +448,7 @@ MODULE ulmConditions; VAR listp: ConditionList; - i: INTEGER; + i: Types.Int32; PROCEDURE CreateList(VAR list: List); BEGIN @@ -555,7 +555,7 @@ MODULE ulmConditions; PROCEDURE SetupAsyncEvents(list: List) : BOOLEAN; VAR elp: Element; - listp: ConditionList; i: INTEGER; + listp: ConditionList; i: Types.Int32; wakeupEvent: WakeupEvent; sendevent: SendEventProc; anythingTrue: BOOLEAN; @@ -603,7 +603,7 @@ MODULE ulmConditions; queue: RelatedEvents.Queue; (* queue of waitErrors *) busyLoop: BOOLEAN; (* TRUE if we have to resort to a busy loop *) wakeupEvent: Events.Event; (* iteration event for busy loops *) - loopCnt: INTEGER; (* number of iterations *) + loopCnt: Types.Int32; (* number of iterations *) nextTime: Times.Time; minTime: Times.Time; minTimeCond: Condition; @@ -679,7 +679,7 @@ MODULE ulmConditions; VAR setOfTrueConditions: ConditionSet; errors: RelatedEvents.Object) : BOOLEAN; VAR - listp: ConditionList; i: INTEGER; + listp: ConditionList; i: Types.Int32; condition: Condition; anythingTrue: BOOLEAN; BEGIN (* TestAndSelect *) @@ -728,7 +728,7 @@ MODULE ulmConditions; PROCEDURE TestAsyncList(list: List) : BOOLEAN; VAR element: Element; - listp: ConditionList; i: INTEGER; + listp: ConditionList; i: Types.Int32; condition: Condition; anythingFound: BOOLEAN; BEGIN @@ -872,7 +872,7 @@ MODULE ulmConditions; VAR setOfTrueConditions: ConditionSet; errors: RelatedEvents.Object); VAR - listp: ConditionList; i: INTEGER; + listp: ConditionList; i: Types.Int32; testSet: ConditionSet; preconds: ConditionSet; domain: Domain; @@ -881,7 +881,7 @@ MODULE ulmConditions; PROCEDURE PretestClosure(testSet, preconds: ConditionSet); VAR - listp: ConditionList; i: INTEGER; + listp: ConditionList; i: Types.Int32; domain: Domain; morePreconditions: ConditionSet; evenMorePreconditions: ConditionSet; diff --git a/src/library/ulm/ulmConstStrings.Mod b/src/library/ulm/ulmConstStrings.Mod index ae62e3b7..61f73a28 100644 --- a/src/library/ulm/ulmConstStrings.Mod +++ b/src/library/ulm/ulmConstStrings.Mod @@ -49,8 +49,7 @@ MODULE ulmConstStrings; (* WORM-device for strings *) - IMPORT Disciplines := ulmDisciplines, Events := ulmEvents, Objects := ulmObjects, Process := ulmProcess, Services := ulmServices, Streams := ulmStreams, Strings := ulmStrings, - Texts := ulmTexts, Types := ulmTypes; + IMPORT Disciplines := ulmDisciplines, Events := ulmEvents, Objects := ulmObjects, Process := ulmProcess, Services := ulmServices, Streams := ulmStreams, Strings := ulmStrings, Texts := ulmTexts, Types := ulmTypes; CONST tabsize = 1031; (* should be a prime number *) @@ -65,7 +64,7 @@ MODULE ulmConstStrings; BufferRec = RECORD buf: ARRAY bufsize OF CHAR; - free: INTEGER; (* buf[free..bufsize-1] is unused *) + free: Types.Int32; (* buf[free..bufsize-1] is unused *) next: Buffer; END; @@ -74,17 +73,17 @@ MODULE ulmConstStrings; RECORD (Disciplines.ObjectRec) (* read-only *) - len-: Streams.Count; (* length of string in bytes *) - hashval-: LONGINT; (* hash value *) + len*: Streams.Count; (* length of string in bytes *) + hashval*: Types.Int32; (* hash value *) (* private part *) domain: Domain; length: Streams.Count; (* private copy of length *) buf: Buffer; (* first buffer containing the string *) - offset: INTEGER; (* offset into buf *) + offset: Types.Int32; (* offset into buf *) next: String; (* list of strings with same hash value *) END; - TYPE + TYPE DomainRec* = RECORD (Disciplines.ObjectRec) @@ -108,7 +107,7 @@ MODULE ulmConstStrings; (Streams.StreamRec) string: String; buf: Buffer; (* current buffer *) - offset: INTEGER; (* index in current buffer *) + offset: Types.Int32; (* index in current buffer *) pos: Streams.Count; (* current position *) END; @@ -121,7 +120,7 @@ MODULE ulmConstStrings; (* === internal procedures =========================================== *) PROCEDURE HashVal(s: Streams.Stream; len: Streams.Count; - VAR hashval, orighashval: LONGINT); + VAR hashval, orighashval: Types.Int32); (* compute the hash value of the first `len' bytes of `s'; the hash value is returned in two variants: hashval: hash value MOD tabsize @@ -130,7 +129,7 @@ MODULE ulmConstStrings; CONST shift = 4; VAR - ordval: INTEGER; + ordval: Types.Int32; ch: CHAR; index: Streams.Count; @@ -159,7 +158,7 @@ MODULE ulmConstStrings; *) VAR ch: CHAR; - buf: Buffer; offset: INTEGER; + buf: Buffer; offset: Types.Int32; index: Streams.Count; BEGIN Streams.SetPos(s, 0); @@ -183,7 +182,7 @@ MODULE ulmConstStrings; END Equal; PROCEDURE Allocate(domain: Domain; len: Streams.Count; - VAR buf: Buffer; VAR offset: INTEGER); + VAR buf: Buffer; VAR offset: Types.Int32); (* allocate space for `len' bytes; `buf' and `offset' are returned, designating the begin of the allocated area; note that @@ -214,9 +213,9 @@ MODULE ulmConstStrings; offset := buf.free; WHILE len > 0 DO IF len <= bufsize - domain.tail.free THEN - INC(domain.tail.free, SHORT(len)); len := 0; + INC(domain.tail.free, len); len := 0; ELSE - DEC(len, bufsize - LONG(domain.tail.free)); + DEC(len, bufsize - domain.tail.free); domain.tail.free := bufsize; NewBuffer; END; @@ -224,7 +223,7 @@ MODULE ulmConstStrings; END Allocate; PROCEDURE CopyString(s: Streams.Stream; length: Streams.Count; - buf: Buffer; offset: INTEGER); + buf: Buffer; offset: Types.Int32); (* copy `length' bytes from `s' to `buf' at the given offset and its subsequent buffers *) @@ -254,7 +253,7 @@ MODULE ulmConstStrings; VAR string: String); (* common part of CloseD and CreateD *) VAR - orighashval, hashval: LONGINT; + orighashval, hashval: Types.Int32; str: String; BEGIN HashVal(s, length, hashval, orighashval); @@ -358,7 +357,7 @@ MODULE ulmConstStrings; s := rs; END Open; - PROCEDURE Compare*(string1, string2: String) : INTEGER; + PROCEDURE Compare*(string1, string2: String) : Types.Int32; (* returns < 0: if string1 < string2 = 0: if string1 = string2 (see note above) > 0: if string1 > string2 @@ -366,10 +365,10 @@ MODULE ulmConstStrings; VAR ch1, ch2: CHAR; buf1, buf2: Buffer; - offset1, offset2: INTEGER; + offset1, offset2: Types.Int32; len1, len2: Streams.Count; - PROCEDURE Next(VAR buf: Buffer; VAR offset: INTEGER; VAR ch: CHAR); + PROCEDURE Next(VAR buf: Buffer; VAR offset: Types.Int32; VAR ch: CHAR); BEGIN ch := buf.buf[offset]; INC(offset); @@ -409,7 +408,7 @@ MODULE ulmConstStrings; VAR len: Streams.Count; buf: Buffer; - offset: INTEGER; + offset: Types.Int32; count: Streams.Count; bytes: Streams.Count; BEGIN @@ -427,7 +426,7 @@ MODULE ulmConstStrings; INC(count, s.count); EXIT END; - INC(count, bytes); DEC(len, bytes); INC(offset, SHORT(bytes)); + INC(count, bytes); DEC(len, bytes); INC(offset, bytes); IF offset >= bufsize THEN buf := buf.next; offset := 0; @@ -441,7 +440,7 @@ MODULE ulmConstStrings; VAR len: Streams.Count; buf: Buffer; - offset: INTEGER; + offset: Types.Int32; index: Streams.Count; BEGIN len := string.length; @@ -480,7 +479,7 @@ MODULE ulmConstStrings; END; END ReadByte; - PROCEDURE ReadBuf(s: Streams.Stream; VAR buf: ARRAY OF Types.Byte(*BYTE*); + PROCEDURE ReadBuf(s: Streams.Stream; VAR buf: ARRAY OF Types.Byte; off, cnt: Streams.Count) : Streams.Count; VAR bytes, max: Streams.Count; @@ -520,7 +519,6 @@ MODULE ulmConstStrings; | Streams.fromStart: realpos := cnt; | Streams.fromPos: realpos := s.pos + cnt; | Streams.fromEnd: realpos := s.string.length + cnt; - ELSE END; IF (realpos < 0) OR (realpos > s.string.length) THEN RETURN FALSE @@ -531,10 +529,10 @@ MODULE ulmConstStrings; END; WHILE s.pos < realpos DO IF realpos - s.pos < bufsize - s.offset THEN - INC(s.offset, SHORT(realpos - s.pos)); + INC(s.offset, realpos - s.pos); s.pos := realpos; ELSE - INC(s.pos, LONG(bufsize - s.offset)); + INC(s.pos, bufsize - s.offset); s.offset := 0; s.buf := s.buf.next; END; diff --git a/src/library/ulm/ulmEvents.Mod b/src/library/ulm/ulmEvents.Mod index 52695762..07deb129 100644 --- a/src/library/ulm/ulmEvents.Mod +++ b/src/library/ulm/ulmEvents.Mod @@ -39,7 +39,7 @@ MODULE ulmEvents; - IMPORT Objects := ulmObjects, Priorities := ulmPriorities, Services := ulmServices, SYS := ulmSYSTEM; + IMPORT Objects := ulmObjects, Priorities := ulmPriorities, Services := ulmServices, SYS := ulmSYSTEM, Types := ulmTypes; TYPE EventType* = POINTER TO EventTypeRec; @@ -51,7 +51,7 @@ MODULE ulmEvents; funcs* = 2; (* call associated event handlers *) TYPE - Reaction* = INTEGER; (* one of default, ignore, or funcs *) + Reaction* = Types.Int32; (* one of default, ignore, or funcs *) Message* = ARRAY 80 OF CHAR; Event* = POINTER TO EventRec; EventRec* = @@ -69,7 +69,7 @@ MODULE ulmEvents; *) EventManager = PROCEDURE (type: EventType; reaction: Reaction); - Priority = INTEGER; (* must be non-negative *) + Priority = Types.Int32; (* must be non-negative *) (* every event with reaction `funcs' has a handler list; the list is in calling order which is reverse to @@ -104,7 +104,7 @@ MODULE ulmEvents; Queue = POINTER TO QueueRec; QueueRec = RECORD - priority: INTEGER; (* queue for this priority *) + priority: Types.Int32; (* queue for this priority *) head, tail: Event; next: Queue; (* queue with lower priority *) END; @@ -125,8 +125,8 @@ MODULE ulmEvents; (* private part *) currentPriority: Priority; priotab: ARRAY priotabsize OF Priority; - priotop: INTEGER; - overflow: INTEGER; (* of priority table *) + priotop: Types.Int32; + overflow: Types.Int32; (* of priority table *) END; CONST @@ -141,7 +141,7 @@ MODULE ulmEvents; ErrorEventRec* = RECORD (EventRec) - errorcode*: SHORTINT; + errorcode*: Types.Int8; END; VAR @@ -151,7 +151,7 @@ MODULE ulmEvents; VAR (* private part *) abort, log, queueHandler: EventHandler; - nestlevel: INTEGER; (* of Raise calls *) + nestlevel: Types.Int32; (* of Raise calls *) queue: Queue; lock: BOOLEAN; (* lock critical operations *) psys: PrioritySystem; (* current priority system *) @@ -173,7 +173,7 @@ MODULE ulmEvents; "negative priority given to Events.SetPriority"; END InitErrorHandling; - PROCEDURE Error(code: SHORTINT); + PROCEDURE Error(code: Types.Int8); VAR event: ErrorEvent; BEGIN NEW(event); event.type := error; @@ -301,10 +301,10 @@ MODULE ulmEvents; (* now QueueHandler will translate partly like BOOLEAN b; handler_EventHandler tmphandler; - LONGINT i, j; - i = (LONGINT)handler; + Types.Int32 i, j; + i = (Types.Int32)handler; tmphandler = handler_NilHandler; - j = (LONGINT)tmphandler; + j = (Types.Int32)tmphandler; b = i != j; *) (* changed because voc cannot compara handler and NilHandler -- noch *) @@ -316,12 +316,12 @@ MODULE ulmEvents; *) VAR b : BOOLEAN; (* noch *) tmphandler : EventHandler; - (*i,j : LONGINT;*) + (*i,j : Types.Int32;*) BEGIN - (*i := SYSTEM.VAL(LONGINT, handler);*) + (*i := SYSTEM.VAL(Types.Int32, handler);*) tmphandler := NilHandler; (*b := tmphandler = handler;*) - (*j := SYSTEM.VAL(LONGINT, tmphandler); + (*j := SYSTEM.VAL(Types.Int32, tmphandler); b := i # j;*) b := handler # tmphandler; (*ASSERT (handler # NilHandler);*) diff --git a/src/library/ulm/ulmIO.Mod b/src/library/ulm/ulmIO.Mod index 162aa127..31aedf8a 100644 --- a/src/library/ulm/ulmIO.Mod +++ b/src/library/ulm/ulmIO.Mod @@ -1,6 +1,6 @@ MODULE ulmIO; - IMPORT SYS := ulmSYSTEM, SYSTEM, Platform; + IMPORT SYS := ulmSYSTEM, SYSTEM, Platform, Types := ulmTypes; CONST nl = 0AX; @@ -11,7 +11,7 @@ MODULE ulmIO; dec = 1; hex = 2; TYPE - Basetype = SHORTINT; (* oct..hex *) + Basetype = Types.Int8; (* oct..hex *) (* basic IO *) @@ -22,7 +22,7 @@ MODULE ulmIO; (* ==================== conversions ================================= *) - PROCEDURE ConvertNumber(num, len: LONGINT; btyp: Basetype; neg: BOOLEAN; + PROCEDURE ConvertNumber(num, len: Types.Int32; btyp: Basetype; neg: BOOLEAN; VAR str: ARRAY OF CHAR); (* conversion of a number into a string of characters *) @@ -36,13 +36,13 @@ MODULE ulmIO; VAR (*digits : ARRAY NumberLen+1 OF CHAR;*) digits : POINTER TO ARRAY OF CHAR; - base : INTEGER; - cnt, ix : INTEGER; - maxlen : LONGINT; - dig : LONGINT; - NumberLen : SHORTINT; + base : Types.Int32; + cnt, ix : Types.Int32; + maxlen : Types.Int32; + dig : Types.Int32; + NumberLen : Types.Int8; BEGIN - IF SIZE(LONGINT) = 8 THEN + IF SIZE(Types.Int32) = 8 THEN NumberLen := 21 ELSE NumberLen := 11 (* default value, corresponds to 32 bit *) @@ -107,7 +107,7 @@ MODULE ulmIO; END; END ConvertNumber; - PROCEDURE ConvertInteger(num: LONGINT; len: INTEGER; VAR str: ARRAY OF + PROCEDURE ConvertInteger(num: Types.Int32; len: Types.Int32; VAR str: ARRAY OF CHAR); (* conversion of an integer decimal number to a string *) BEGIN @@ -119,8 +119,8 @@ MODULE ulmIO; (* PROCEDURE ReadChar(VAR ch: CHAR) : BOOLEAN; CONST read = 3; - (*VAR r0, r1: INTEGER;*) - VAR r0, r1: LONGINT; (* in ulm system INTEGER and LONGINT have the same 4 byte size; -- noch *) + (*VAR r0, r1: Types.Int32;*) + VAR r0, r1: Types.Int32; (* in ulm system Types.Int32 and Types.Int32 have the same 4 byte size; -- noch *) BEGIN RETURN SYS.UNIXCALL(read, r0, r1, 0, SYSTEM.ADR(ch), 1) & (r0 > 0) END ReadChar; @@ -128,7 +128,7 @@ MODULE ulmIO; PROCEDURE ReadChar(VAR ch: CHAR) : BOOLEAN; (* Read one byte, returning success flag *) - VAR error: Platform.ErrorCode; readcount: LONGINT; + VAR error: Platform.ErrorCode; readcount: Types.Int32; BEGIN error := Platform.ReadBuf(Platform.StdIn, ch, readcount); RETURN readcount > 0 @@ -137,8 +137,8 @@ MODULE ulmIO; (* PROCEDURE WriteChar(ch: CHAR) : BOOLEAN; CONST write = 4; - (*VAR r0, r1: INTEGER;*) - VAR r0, r1: LONGINT; (* same here *) + (*VAR r0, r1: Types.Int32;*) + VAR r0, r1: Types.Int32; (* same here *) BEGIN RETURN SYS.UNIXCALL(write, r0, r1, 1, SYSTEM.ADR(ch), 1) END WriteChar; @@ -186,7 +186,7 @@ MODULE ulmIO; END WriteLn; PROCEDURE WriteString*(s: ARRAY OF CHAR); - VAR i: INTEGER; + VAR i: Types.Int32; BEGIN i := 0; WHILE (i < LEN(s)) & (s[i] # 0X) DO @@ -201,14 +201,14 @@ MODULE ulmIO; Done := TRUE; END InitIO; - PROCEDURE WriteInt*(arg: LONGINT); + PROCEDURE WriteInt*(arg: Types.Int32); VAR field: ARRAY 23 OF CHAR; BEGIN (* the field size should be big enough to hold the long number. it was 12 to hold just 32 bit numbers, now it can hold 64 bit numbers; need to be more for 128bit numbers; -- noch *) ConvertInteger(arg, 1, field); WriteString(field); END WriteInt; - PROCEDURE ReadInt*(VAR arg: LONGINT); + PROCEDURE ReadInt*(VAR arg: Types.Int32); VAR ch: CHAR; minus: BOOLEAN; BEGIN @@ -236,7 +236,7 @@ MODULE ulmIO; PROCEDURE ReadLine*(VAR string: ARRAY OF CHAR); VAR - index: INTEGER; + index: Types.Int32; ch: CHAR; ok: BOOLEAN; BEGIN diff --git a/src/library/ulm/ulmIntOperations.Mod b/src/library/ulm/ulmIntOperations.Mod index 3f1799aa..739bb5a4 100644 --- a/src/library/ulm/ulmIntOperations.Mod +++ b/src/library/ulm/ulmIntOperations.Mod @@ -43,16 +43,16 @@ MODULE ulmIntOperations; (* Frank B.J. Fischer *) TYPE CapabilitySet* = Operations.CapabilitySet; - (* SET of [Operations.add..shift] *) + (* Types.Set of [Operations.add..shift] *) IsLargeEnoughForProc* = PROCEDURE (op: Operations.Operand; - n: LONGINT): BOOLEAN; + n: Types.Int32): BOOLEAN; UnsignedProc* = PROCEDURE (op: Operations.Operand): BOOLEAN; IntToOpProc* = PROCEDURE (int32: Types.Int32; VAR op: Operations.Operand); OpToIntProc* = PROCEDURE (op: Operations.Operand; VAR int32: Types.Int32); - Log2Proc* = PROCEDURE (op: Operations.Operand): LONGINT; + Log2Proc* = PROCEDURE (op: Operations.Operand): Types.Int32; OddProc* = PROCEDURE (op: Operations.Operand): BOOLEAN; ShiftProc* = PROCEDURE (op: Operations.Operand; - n: INTEGER): Operations.Operand; + n: Types.Int32): Operations.Operand; IntOperatorProc* = PROCEDURE(op: Operation; op1, op2, op3: Operations.Operand; VAR result: Operations.Operand); @@ -95,7 +95,7 @@ MODULE ulmIntOperations; (* Frank B.J. Fischer *) END Capabilities; - PROCEDURE IsLargeEnoughFor*(op: Operations.Operand; n: LONGINT): BOOLEAN; + PROCEDURE IsLargeEnoughFor*(op: Operations.Operand; n: Types.Int32): BOOLEAN; BEGIN WITH op: Operand DO RETURN op.if.isLargeEnoughFor(op, n) @@ -130,7 +130,7 @@ MODULE ulmIntOperations; (* Frank B.J. Fischer *) END OpToInt; - PROCEDURE Log2*(op: Operations.Operand): LONGINT; + PROCEDURE Log2*(op: Operations.Operand): Types.Int32; BEGIN WITH op: Operand DO RETURN op.if.log2(op) @@ -167,7 +167,7 @@ MODULE ulmIntOperations; (* Frank B.J. Fischer *) END Op; - PROCEDURE Shift*(op1: Operations.Operand; n: INTEGER): Operations.Operand; + PROCEDURE Shift*(op1: Operations.Operand; n: Types.Int32): Operations.Operand; BEGIN WITH op1: Operand DO ASSERT(shift IN op1.caps); @@ -176,14 +176,14 @@ MODULE ulmIntOperations; (* Frank B.J. Fischer *) END Shift; - PROCEDURE Shift2*(VAR op1: Operations.Operand; n: INTEGER); + PROCEDURE Shift2*(VAR op1: Operations.Operand; n: Types.Int32); BEGIN op1 := Shift(op1, n); END Shift2; PROCEDURE Shift3*(VAR result: Operations.Operand; op1: Operations.Operand; - n : INTEGER); + n : Types.Int32); VAR tmpresult: Operations.Operand; BEGIN diff --git a/src/library/ulm/ulmMC68881.Mod b/src/library/ulm/ulmMC68881.Mod index 4bcf69a0..fc3986d0 100644 --- a/src/library/ulm/ulmMC68881.Mod +++ b/src/library/ulm/ulmMC68881.Mod @@ -5,7 +5,7 @@ MODULE ulmMC68881; (* library interface to MC68881 instructions *) - IMPORT SYS := SYSTEM; + IMPORT SYS := SYSTEM, Types := ulmTypes; CONST available* = FALSE; (* TRUE if MC68881 present *) @@ -36,130 +36,130 @@ MODULE ulmMC68881; (* monadic operations *) - PROCEDURE FACOS*(x: LONGREAL) : LONGREAL; + PROCEDURE FACOS*(x: Types.Real64) : Types.Real64; BEGIN RETURN ABS(x) END FACOS; - PROCEDURE FASIN*(x: LONGREAL) : LONGREAL; + PROCEDURE FASIN*(x: Types.Real64) : Types.Real64; BEGIN RETURN ABS(x) END FASIN; - PROCEDURE FATAN*(x: LONGREAL) : LONGREAL; + PROCEDURE FATAN*(x: Types.Real64) : Types.Real64; BEGIN RETURN ABS(x) END FATAN; - PROCEDURE FATANH*(x: LONGREAL) : LONGREAL; + PROCEDURE FATANH*(x: Types.Real64) : Types.Real64; BEGIN RETURN ABS(x) END FATANH; - PROCEDURE FCOS*(x: LONGREAL) : LONGREAL; + PROCEDURE FCOS*(x: Types.Real64) : Types.Real64; BEGIN RETURN ABS(x) END FCOS; - PROCEDURE FCOSH*(x: LONGREAL) : LONGREAL; + PROCEDURE FCOSH*(x: Types.Real64) : Types.Real64; BEGIN RETURN ABS(x) END FCOSH; - PROCEDURE FETOX*(x: LONGREAL) : LONGREAL; + PROCEDURE FETOX*(x: Types.Real64) : Types.Real64; BEGIN RETURN ABS(x) END FETOX; - PROCEDURE FETOXM1*(x: LONGREAL) : LONGREAL; + PROCEDURE FETOXM1*(x: Types.Real64) : Types.Real64; BEGIN RETURN ABS(x) END FETOXM1; - PROCEDURE FGETEXP*(x: LONGREAL) : LONGREAL; + PROCEDURE FGETEXP*(x: Types.Real64) : Types.Real64; BEGIN RETURN ABS(x) END FGETEXP; - PROCEDURE FGETMAN*(x: LONGREAL) : LONGREAL; + PROCEDURE FGETMAN*(x: Types.Real64) : Types.Real64; BEGIN RETURN ABS(x) END FGETMAN; - PROCEDURE FLOG10*(x: LONGREAL) : LONGREAL; + PROCEDURE FLOG10*(x: Types.Real64) : Types.Real64; BEGIN RETURN ABS(x) END FLOG10; - PROCEDURE FLOG2*(x: LONGREAL) : LONGREAL; + PROCEDURE FLOG2*(x: Types.Real64) : Types.Real64; BEGIN RETURN ABS(x) END FLOG2; - PROCEDURE FLOGN*(x: LONGREAL) : LONGREAL; + PROCEDURE FLOGN*(x: Types.Real64) : Types.Real64; BEGIN RETURN ABS(x) END FLOGN; - PROCEDURE FLOGNP1*(x: LONGREAL) : LONGREAL; + PROCEDURE FLOGNP1*(x: Types.Real64) : Types.Real64; BEGIN RETURN ABS(x) END FLOGNP1; - PROCEDURE FSIN*(x: LONGREAL) : LONGREAL; + PROCEDURE FSIN*(x: Types.Real64) : Types.Real64; BEGIN RETURN ABS(x) END FSIN; - PROCEDURE FSINH*(x: LONGREAL) : LONGREAL; + PROCEDURE FSINH*(x: Types.Real64) : Types.Real64; BEGIN RETURN ABS(x) END FSINH; - PROCEDURE FSQRT*(x: LONGREAL) : LONGREAL; + PROCEDURE FSQRT*(x: Types.Real64) : Types.Real64; BEGIN RETURN ABS(x) END FSQRT; - PROCEDURE FTAN*(x: LONGREAL) : LONGREAL; + PROCEDURE FTAN*(x: Types.Real64) : Types.Real64; BEGIN RETURN ABS(x) END FTAN; - PROCEDURE FTANH*(x: LONGREAL) : LONGREAL; + PROCEDURE FTANH*(x: Types.Real64) : Types.Real64; BEGIN RETURN ABS(x) END FTANH; - PROCEDURE FTENTOX*(x: LONGREAL) : LONGREAL; + PROCEDURE FTENTOX*(x: Types.Real64) : Types.Real64; BEGIN RETURN ABS(x) END FTENTOX; - PROCEDURE FTWOTOX*(x: LONGREAL) : LONGREAL; + PROCEDURE FTWOTOX*(x: Types.Real64) : Types.Real64; BEGIN RETURN ABS(x) END FTWOTOX; - PROCEDURE GetExceptionEnable*(VAR exceptions: SET); + PROCEDURE GetExceptionEnable*(VAR exceptions: Types.Set); BEGIN exceptions := {}; END GetExceptionEnable; - PROCEDURE SetExceptionEnable*(exceptions: SET); + PROCEDURE SetExceptionEnable*(exceptions: Types.Set); BEGIN exceptions := {}; END SetExceptionEnable; - PROCEDURE GetRoundingMode*(VAR precision, mode: INTEGER); + PROCEDURE GetRoundingMode*(VAR precision, mode: Types.Int32); BEGIN precision := 1; mode := 2; END GetRoundingMode; - PROCEDURE SetRoundingMode*(precision, mode: INTEGER); + PROCEDURE SetRoundingMode*(precision, mode: Types.Int32); BEGIN precision := 1; mode := 2; @@ -170,12 +170,12 @@ MODULE ulmMC68881; float must consist of at least floatlen bytes *) - PROCEDURE RealToFloat*(real: LONGREAL; VAR float: ARRAY OF SYS.BYTE); + PROCEDURE RealToFloat*(real: Types.Real64; VAR float: ARRAY OF SYS.BYTE); BEGIN (*SYS.WMOVE(SYS.ADR(real), SYS.ADR(float), floatlen DIV 4);*) END RealToFloat; - PROCEDURE FloatToReal*(float: ARRAY OF SYS.BYTE; VAR real: LONGREAL); + PROCEDURE FloatToReal*(float: ARRAY OF SYS.BYTE; VAR real: Types.Real64); BEGIN (*SYS.WMOVE(SYS.ADR(float), SYS.ADR(real), floatlen DIV 4);*) END FloatToReal; diff --git a/src/library/ulm/ulmNetIO.Mod b/src/library/ulm/ulmNetIO.Mod index b9741f30..3db6887b 100644 --- a/src/library/ulm/ulmNetIO.Mod +++ b/src/library/ulm/ulmNetIO.Mod @@ -64,17 +64,17 @@ MODULE ulmNetIO; ReadBooleanProc* = PROCEDURE (s: Streams.Stream; VAR boolean: BOOLEAN) : BOOLEAN; ReadShortIntProc* = - PROCEDURE (s: Streams.Stream; VAR shortint: SHORTINT) : BOOLEAN; + PROCEDURE (s: Streams.Stream; VAR shortint: Types.Int8) : BOOLEAN; ReadIntegerProc* = - PROCEDURE (s: Streams.Stream; VAR integer: INTEGER) : BOOLEAN; + PROCEDURE (s: Streams.Stream; VAR integer: Types.Int32) : BOOLEAN; ReadLongIntProc* = - PROCEDURE (s: Streams.Stream; VAR longint: LONGINT) : BOOLEAN; + PROCEDURE (s: Streams.Stream; VAR longint: Types.Int32) : BOOLEAN; ReadRealProc* = - PROCEDURE (s: Streams.Stream; VAR real: REAL) : BOOLEAN; + PROCEDURE (s: Streams.Stream; VAR real: Types.Real32) : BOOLEAN; ReadLongRealProc* = - PROCEDURE (s: Streams.Stream; VAR longreal: LONGREAL) : BOOLEAN; + PROCEDURE (s: Streams.Stream; VAR longreal: Types.Real64) : BOOLEAN; ReadSetProc* = - PROCEDURE (s: Streams.Stream; VAR set: SET) : BOOLEAN; + PROCEDURE (s: Streams.Stream; VAR set: Types.Set) : BOOLEAN; ReadStringProc* = PROCEDURE (s: Streams.Stream; VAR string: ARRAY OF CHAR) : BOOLEAN; ReadConstStringProc* = @@ -88,17 +88,17 @@ MODULE ulmNetIO; WriteBooleanProc* = PROCEDURE (s: Streams.Stream; boolean: BOOLEAN) : BOOLEAN; WriteShortIntProc* = - PROCEDURE (s: Streams.Stream; shortint: SHORTINT) : BOOLEAN; + PROCEDURE (s: Streams.Stream; shortint: Types.Int8) : BOOLEAN; WriteIntegerProc* = - PROCEDURE (s: Streams.Stream; integer: INTEGER) : BOOLEAN; + PROCEDURE (s: Streams.Stream; integer: Types.Int32) : BOOLEAN; WriteLongIntProc* = - PROCEDURE (s: Streams.Stream; longint: LONGINT) : BOOLEAN; + PROCEDURE (s: Streams.Stream; longint: Types.Int32) : BOOLEAN; WriteRealProc* = - PROCEDURE (s: Streams.Stream; real: REAL) : BOOLEAN; + PROCEDURE (s: Streams.Stream; real: Types.Real32) : BOOLEAN; WriteLongRealProc* = - PROCEDURE (s: Streams.Stream; longreal: LONGREAL) : BOOLEAN; + PROCEDURE (s: Streams.Stream; longreal: Types.Real64) : BOOLEAN; WriteSetProc* = - PROCEDURE (s: Streams.Stream; set: SET) : BOOLEAN; + PROCEDURE (s: Streams.Stream; set: Types.Set) : BOOLEAN; WriteStringProc* = PROCEDURE (s: Streams.Stream; string: ARRAY OF CHAR) : BOOLEAN; WriteConstStringProc* = @@ -154,7 +154,7 @@ MODULE ulmNetIO; PROCEDURE Swap (VAR a : ARRAY OF SYS.BYTE); VAR - i,j : LONGINT; + i,j : Types.Int32; tmp : SYS.BYTE; BEGIN i := 0; j := LEN (a) - 1; @@ -166,8 +166,8 @@ MODULE ulmNetIO; PROCEDURE BitSwap (VAR a : ARRAY OF SYS.BYTE); VAR - i,old, bit : LONGINT; - new : LONGINT; + i,old, bit : Types.Int32; + new : Types.Int32; BEGIN i := 0; @@ -266,7 +266,7 @@ MODULE ulmNetIO; END; END ReadBoolean; - PROCEDURE ReadShortInt*(s: Streams.Stream; VAR shortint: SHORTINT) : BOOLEAN; + PROCEDURE ReadShortInt*(s: Streams.Stream; VAR shortint: Types.Int8) : BOOLEAN; VAR disc: Discipline; BEGIN @@ -277,7 +277,7 @@ MODULE ulmNetIO; END; END ReadShortInt; - PROCEDURE ReadInteger*(s: Streams.Stream; VAR integer: INTEGER) : BOOLEAN; + PROCEDURE ReadInteger*(s: Streams.Stream; VAR integer: Types.Int32) : BOOLEAN; VAR disc: Discipline; ret : BOOLEAN; @@ -293,7 +293,7 @@ MODULE ulmNetIO; END; END ReadInteger; - PROCEDURE ReadLongInt*(s: Streams.Stream; VAR longint: LONGINT) : BOOLEAN; + PROCEDURE ReadLongInt*(s: Streams.Stream; VAR longint: Types.Int32) : BOOLEAN; VAR disc: Discipline; ret : BOOLEAN; @@ -309,7 +309,7 @@ MODULE ulmNetIO; END; END ReadLongInt; - PROCEDURE ReadReal*(s: Streams.Stream; VAR real: REAL) : BOOLEAN; + PROCEDURE ReadReal*(s: Streams.Stream; VAR real: Types.Real32) : BOOLEAN; VAR disc: Discipline; BEGIN @@ -320,7 +320,7 @@ MODULE ulmNetIO; END; END ReadReal; - PROCEDURE ReadLongReal*(s: Streams.Stream; VAR longreal: LONGREAL) : BOOLEAN; + PROCEDURE ReadLongReal*(s: Streams.Stream; VAR longreal: Types.Real64) : BOOLEAN; VAR disc: Discipline; BEGIN @@ -331,7 +331,7 @@ MODULE ulmNetIO; END; END ReadLongReal; - PROCEDURE ReadSet*(s: Streams.Stream; VAR set: SET) : BOOLEAN; + PROCEDURE ReadSet*(s: Streams.Stream; VAR set: Types.Set) : BOOLEAN; VAR disc: Discipline; ret : BOOLEAN; @@ -350,7 +350,7 @@ MODULE ulmNetIO; PROCEDURE ReadString*(s: Streams.Stream; VAR string: ARRAY OF CHAR) : BOOLEAN; VAR disc: Discipline; - ch: CHAR; index: LONGINT; + ch: CHAR; index: Types.Int32; BEGIN IF Seek(s, discID, disc) THEN RETURN disc.if.readString(s, string) @@ -372,7 +372,7 @@ MODULE ulmNetIO; CONST bufsize = 512; VAR - length: LONGINT; + length: Types.Int32; buf: Streams.Stream; ch: CHAR; disc: Discipline; @@ -442,7 +442,7 @@ MODULE ulmNetIO; END; END WriteBoolean; - PROCEDURE WriteShortInt*(s: Streams.Stream; shortint: SHORTINT) : BOOLEAN; + PROCEDURE WriteShortInt*(s: Streams.Stream; shortint: Types.Int8) : BOOLEAN; VAR disc: Discipline; BEGIN @@ -453,7 +453,7 @@ MODULE ulmNetIO; END; END WriteShortInt; - PROCEDURE WriteInteger*(s: Streams.Stream; integer: INTEGER) : BOOLEAN; + PROCEDURE WriteInteger*(s: Streams.Stream; integer: Types.Int32) : BOOLEAN; VAR disc: Discipline; BEGIN @@ -467,7 +467,7 @@ MODULE ulmNetIO; END; END WriteInteger; - PROCEDURE WriteLongInt*(s: Streams.Stream; longint: LONGINT) : BOOLEAN; + PROCEDURE WriteLongInt*(s: Streams.Stream; longint: Types.Int32) : BOOLEAN; VAR disc: Discipline; BEGIN @@ -481,7 +481,7 @@ MODULE ulmNetIO; END; END WriteLongInt; - PROCEDURE WriteReal*(s: Streams.Stream; real: REAL) : BOOLEAN; + PROCEDURE WriteReal*(s: Streams.Stream; real: Types.Real32) : BOOLEAN; VAR disc: Discipline; BEGIN @@ -492,7 +492,7 @@ MODULE ulmNetIO; END; END WriteReal; - PROCEDURE WriteLongReal*(s: Streams.Stream; longreal: LONGREAL) : BOOLEAN; + PROCEDURE WriteLongReal*(s: Streams.Stream; longreal: Types.Real64) : BOOLEAN; VAR disc: Discipline; BEGIN @@ -503,7 +503,7 @@ MODULE ulmNetIO; END; END WriteLongReal; - PROCEDURE WriteSet*(s: Streams.Stream; set: SET) : BOOLEAN; + PROCEDURE WriteSet*(s: Streams.Stream; set: Types.Set) : BOOLEAN; VAR disc: Discipline; BEGIN diff --git a/src/library/ulm/ulmOperations.Mod b/src/library/ulm/ulmOperations.Mod index 617b9808..317b42d8 100644 --- a/src/library/ulm/ulmOperations.Mod +++ b/src/library/ulm/ulmOperations.Mod @@ -44,22 +44,22 @@ MODULE ulmOperations; (* generic support of arithmetic operations *) - IMPORT Events := ulmEvents, Objects := ulmObjects, PersistentDisciplines := ulmPersistentDisciplines, PersistentObjects := ulmPersistentObjects, Services := ulmServices; + IMPORT Events := ulmEvents, Objects := ulmObjects, PersistentDisciplines := ulmPersistentDisciplines, PersistentObjects := ulmPersistentObjects, Services := ulmServices, Types := ulmTypes; CONST add* = 0; sub* = 1; mul* = 2; div* = 3; cmp* = 4; TYPE - Operation* = SHORTINT; (* add..cmp *) + Operation* = Types.Int8; (* add..cmp *) Operand* = POINTER TO OperandRec; TYPE - CapabilitySet* = SET; (* SET OF [add..cmp] *) + CapabilitySet* = Types.Set; (* Types.Set OF [add..cmp] *) CreateProc* = PROCEDURE (VAR op: Operand); (* should call Operations.Init for op *) OperatorProc* = PROCEDURE (op: Operation; op1, op2: Operand; VAR result: Operand); AssignProc* = PROCEDURE (VAR target: Operand; source: Operand); - CompareProc* = PROCEDURE (op1, op2: Operand) : INTEGER; + CompareProc* = PROCEDURE (op1, op2: Operand) : Types.Int32; Interface* = POINTER TO InterfaceRec; InterfaceRec* = RECORD @@ -194,7 +194,7 @@ MODULE ulmOperations; Op(div, op1, op2, result); END Div3; - PROCEDURE Compare*(op1, op2: Operand) : INTEGER; + PROCEDURE Compare*(op1, op2: Operand) : Types.Int32; BEGIN ASSERT(op1.if = op2.if); ASSERT(cmp IN op1.caps); diff --git a/src/library/ulm/ulmPersistentObjects.Mod b/src/library/ulm/ulmPersistentObjects.Mod index c64b4fc0..b34b3645 100644 --- a/src/library/ulm/ulmPersistentObjects.Mod +++ b/src/library/ulm/ulmPersistentObjects.Mod @@ -72,7 +72,7 @@ MODULE ulmPersistentObjects; IMPORT ASCII := ulmASCII, ConstStrings := ulmConstStrings, Disciplines := ulmDisciplines, Errors := ulmErrors, Events := ulmEvents, Forwarders := ulmForwarders, IndirectDisciplines := ulmIndirectDisciplines, Loader := ulmLoader, NetIO := ulmNetIO, Objects := ulmObjects, Priorities := ulmPriorities, - RelatedEvents := ulmRelatedEvents, Services := ulmServices, StreamDisciplines := ulmStreamDisciplines, Streams := ulmStreams, Strings := ulmStrings, Texts := ulmTexts, SYS := SYSTEM; + RelatedEvents := ulmRelatedEvents, Services := ulmServices, StreamDisciplines := ulmStreamDisciplines, Streams := ulmStreams, Strings := ulmStrings, Texts := ulmTexts, SYS := SYSTEM, Types := ulmTypes; CONST maxNameLen = 128; (* max length of data type names *) @@ -123,8 +123,8 @@ MODULE ulmPersistentObjects; maxF = 13; (* maximal valid form code *) TYPE - Mode* = SHORTINT; - Form = SHORTINT; + Mode* = Types.Int8; + Form = Types.Int8; Object* = POINTER TO ObjectRec; Type = POINTER TO TypeRec; @@ -160,7 +160,7 @@ MODULE ulmPersistentObjects; TypeEntry = POINTER TO TypeEntryRec; TypeEntryRec = RECORD - code: LONGINT; + code: Types.Int32; type: Type; next: TypeEntry; END; @@ -185,7 +185,7 @@ MODULE ulmPersistentObjects; baseType: Type; (* the next non-abstract base type *) if: Interface; (* may be = NIL for abstract types *) ifs: InterfaceList; (* list of interfaces in reverse order *) - code: LONGINT; (* unique number *) + code: Types.Int32; (* unique number *) END; (* this list is used for storing the base type list of an object during @@ -201,7 +201,7 @@ MODULE ulmPersistentObjects; (* each error causes an event; the error number is stored in event.errorcode; the associated text can be taken from event.message *) - ErrorCode = SHORTINT; + ErrorCode = Types.Int8; Event = POINTER TO EventRec; EventRec* = RECORD @@ -230,7 +230,7 @@ MODULE ulmPersistentObjects; VAR id: Disciplines.Identifier; - nextTypeCode: LONGINT; (* for the generation of unique numbers *) + nextTypeCode: Types.Int32; (* for the generation of unique numbers *) potype: Services.Type; errormsg*: ARRAY errorcodes OF Events.Message; @@ -298,7 +298,7 @@ MODULE ulmPersistentObjects; PROCEDURE WriteLn(s: Streams.Stream) : BOOLEAN; VAR lineterm: StreamDisciplines.LineTerminator; - width: INTEGER; + width: Types.Int32; BEGIN StreamDisciplines.GetLineTerm(s, lineterm); IF ~WriteString(s, lineterm) THEN RETURN FALSE END; @@ -383,7 +383,7 @@ MODULE ulmPersistentObjects; (* encoding scheme: Object = Form Type Size ObjectInfo . - Form = SHORTINT; + Form = Types.Int8; Type = Code (* codeF *) | Code TypeName (* incrF *) | TypeName (* nameF *) | @@ -397,8 +397,8 @@ MODULE ulmPersistentObjects; PROCEDURE DecodeForm(form: Form; VAR nameGiven, codeGiven, hier, size: BOOLEAN); VAR - typeform: SHORTINT; - sizeform: SHORTINT; + typeform: Types.Int8; + sizeform: Types.Int8; BEGIN typeform := form MOD maskF; sizeform := form DIV maskF; nameGiven := typeform IN {incrF, nameF, hierF, incrhierF}; @@ -410,7 +410,7 @@ MODULE ulmPersistentObjects; PROCEDURE GetModule(name: ARRAY OF CHAR; VAR module: ARRAY OF CHAR); (* get the name of the module where 'name' was defined *) VAR - index: INTEGER; + index: Types.Int32; BEGIN index := 0; WHILE (name[index] # ".") & (name[index] # 0X) & @@ -471,7 +471,7 @@ MODULE ulmPersistentObjects; PROCEDURE ReadType(s: Streams.Stream; VAR type: Type; VAR sentinelFound, unknownTypeFound: BOOLEAN) : BOOLEAN; VAR - code: LONGINT; + code: Types.Int32; entry: TypeEntry; typeName: TypeName; btype: Type; @@ -755,7 +755,7 @@ MODULE ulmPersistentObjects; baseType: Services.Type; member: InterfaceList; bt: Type; - ifval: INTEGER; + ifval: Types.Int32; BEGIN (* check the parameters *) ASSERT(name[0] # 0X); diff --git a/src/library/ulm/ulmPlotters.Mod b/src/library/ulm/ulmPlotters.Mod index 59ee292d..58d1fda6 100644 --- a/src/library/ulm/ulmPlotters.Mod +++ b/src/library/ulm/ulmPlotters.Mod @@ -28,7 +28,7 @@ MODULE ulmPlotters; - IMPORT Events := ulmEvents, Objects := ulmObjects, Resources := ulmResources, Services := ulmServices, SYS := ulmSYSTEM; + IMPORT Events := ulmEvents, Objects := ulmObjects, Resources := ulmResources, Services := ulmServices, SYS := ulmSYSTEM, Types := ulmTypes; TYPE Plotter* = POINTER TO PlotterRec; @@ -41,7 +41,7 @@ MODULE ulmPlotters; longdashed* = 4; lineModes* = 5; TYPE - LineMode* = SHORTINT; (* solid ... *) + LineMode* = Types.Int8; (* solid ... *) CONST setspace* = 0; @@ -50,34 +50,34 @@ MODULE ulmPlotters; linemodes* = 3; linewidth* = 4; TYPE - CapabilitySet* = SET; (* OF setspace, erase ... *) + CapabilitySet* = Types.Set; (* OF setspace, erase ... *) TYPE Description* = POINTER TO DescriptionRec; DescriptionRec* = RECORD (Objects.ObjectRec) - xmin*, ymin, xmax, ymax: INTEGER; (* maximal supported range *) + xmin*, ymin, xmax, ymax: Types.Int32; (* maximal supported range *) END; TYPE GetSpaceProc* = PROCEDURE ( plotter: Plotter; - VAR xmin, ymin, xmax, ymax: INTEGER); + VAR xmin, ymin, xmax, ymax: Types.Int32); SetSpaceProc* = PROCEDURE ( plotter: Plotter; - xmin, ymin, xmax, ymax: INTEGER); + xmin, ymin, xmax, ymax: Types.Int32); EraseProc* = PROCEDURE (plotter: Plotter); - MoveProc* = PROCEDURE (plotter: Plotter; xto, yto: INTEGER); - LineProc* = PROCEDURE (plotter: Plotter; xfrom, yfrom, xto, yto: INTEGER); + MoveProc* = PROCEDURE (plotter: Plotter; xto, yto: Types.Int32); + LineProc* = PROCEDURE (plotter: Plotter; xfrom, yfrom, xto, yto: Types.Int32); ArcProc* = PROCEDURE ( plotter: Plotter; - xcenter, ycenter, xstart, ystart, xend, yend: INTEGER); + xcenter, ycenter, xstart, ystart, xend, yend: Types.Int32); CircleProc* = PROCEDURE ( - plotter: Plotter; xcenter, ycenter, radius: INTEGER); + plotter: Plotter; xcenter, ycenter, radius: Types.Int32); StringProc* = PROCEDURE (plotter: Plotter; str: ARRAY OF CHAR); SetLineModeProc* = PROCEDURE (plotter: Plotter; mode: LineMode); - SetLineWidthProc* = PROCEDURE (plotter: Plotter; width: INTEGER); + SetLineWidthProc* = PROCEDURE (plotter: Plotter; width: Types.Int32); CloseProc* = PROCEDURE (plotter: Plotter); TYPE Interface* = POINTER TO InterfaceRec; @@ -105,7 +105,7 @@ MODULE ulmPlotters; if: Interface; caps: CapabilitySet; desc: Description; - xmin, ymin, xmax, ymax: INTEGER; (* current range *) + xmin, ymin, xmax, ymax: Types.Int32; (* current range *) terminated: BOOLEAN; END; VAR @@ -162,7 +162,7 @@ MODULE ulmPlotters; PROCEDURE GetSpace*(plotter: Plotter; VAR xmin, ymin, - xmax, ymax: INTEGER); + xmax, ymax: Types.Int32); BEGIN xmin := plotter.xmin; xmax := plotter.xmax; @@ -172,7 +172,7 @@ MODULE ulmPlotters; PROCEDURE GetMaxSpace*(plotter: Plotter; VAR xmin, ymin, - xmax, ymax: INTEGER); + xmax, ymax: Types.Int32); BEGIN xmin := plotter.desc.xmin; xmax := plotter.desc.xmax; @@ -182,7 +182,7 @@ MODULE ulmPlotters; PROCEDURE SetSpace*(plotter: Plotter; xmin, ymin, - xmax, ymax: INTEGER); + xmax, ymax: Types.Int32); BEGIN ASSERT((xmin < xmax) & (ymin < ymax)); ASSERT((xmin >= plotter.desc.xmin) & @@ -203,33 +203,33 @@ MODULE ulmPlotters; plotter.if.erase(plotter); END Erase; - PROCEDURE Move*(plotter: Plotter; xto, yto: INTEGER); + PROCEDURE Move*(plotter: Plotter; xto, yto: Types.Int32); BEGIN plotter.if.move(plotter, xto, yto); END Move; - PROCEDURE Cont*(plotter: Plotter; xto, yto: INTEGER); + PROCEDURE Cont*(plotter: Plotter; xto, yto: Types.Int32); BEGIN plotter.if.cont(plotter, xto, yto); END Cont; - PROCEDURE Point*(plotter: Plotter; xpoint, ypoint: INTEGER); + PROCEDURE Point*(plotter: Plotter; xpoint, ypoint: Types.Int32); BEGIN plotter.if.point(plotter, xpoint, ypoint); END Point; - PROCEDURE Line*(plotter: Plotter; xfrom, yfrom, xto, yto: INTEGER); + PROCEDURE Line*(plotter: Plotter; xfrom, yfrom, xto, yto: Types.Int32); BEGIN plotter.if.line(plotter, xfrom, yfrom, xto, yto); END Line; PROCEDURE Arc*(plotter: Plotter; - xcenter, ycenter, xstart, ystart, xend, yend: INTEGER); + xcenter, ycenter, xstart, ystart, xend, yend: Types.Int32); BEGIN plotter.if.arc(plotter, xcenter, ycenter, xstart, ystart, xend, yend); END Arc; - PROCEDURE Circle*(plotter: Plotter; xcenter, ycenter, radius: INTEGER); + PROCEDURE Circle*(plotter: Plotter; xcenter, ycenter, radius: Types.Int32); BEGIN plotter.if.circle(plotter, xcenter, ycenter, radius); END Circle; @@ -246,7 +246,7 @@ MODULE ulmPlotters; plotter.if.setLineMode(plotter, mode); END SetLineMode; - PROCEDURE SetLineWidth*(plotter: Plotter; width: INTEGER); + PROCEDURE SetLineWidth*(plotter: Plotter; width: Types.Int32); BEGIN ASSERT((linewidth IN plotter.caps) & (width > 0)); plotter.if.setLineWidth(plotter, width); diff --git a/src/library/ulm/ulmPrint.Mod b/src/library/ulm/ulmPrint.Mod index 42f5a7fe..a2fb35e0 100644 --- a/src/library/ulm/ulmPrint.Mod +++ b/src/library/ulm/ulmPrint.Mod @@ -35,7 +35,7 @@ ---------------------------------------------------------------------------- *) -MODULE Print; +MODULE ulmPrint; (* formatted printing; Print.F[0-9] prints to Streams.stdout @@ -44,7 +44,7 @@ MODULE Print; *) IMPORT Events := ulmEvents, IEEE := ulmIEEE, Priorities := ulmPriorities, Reals := ulmReals, RelatedEvents := ulmRelatedEvents, StreamDisciplines := ulmStreamDisciplines, - Streams := ulmStreams, SYS := SYSTEM; + Streams := ulmStreams, SYS := SYSTEM, Types := ulmTypes; CONST tooManyArgs* = 0; (* too many arguments given *) @@ -54,15 +54,15 @@ MODULE Print; errors* = 4; TYPE FormatString* = ARRAY 128 OF CHAR; - ErrorCode* = SHORTINT; + ErrorCode* = Types.Int8; ErrorEvent* = POINTER TO ErrorEventRec; ErrorEventRec* = RECORD (Events.EventRec) errorcode*: ErrorCode; format*: FormatString; - errpos*: LONGINT; - nargs*: INTEGER; + errpos*: Types.Int32; + nargs*: Types.Int32; END; VAR error*: Events.EventType; @@ -80,20 +80,20 @@ MODULE Print; "size of argument doesn't conform to the corresponding format element"; END InitErrorHandling; - PROCEDURE Out(out: Streams.Stream; VAR fmt: ARRAY OF CHAR; nargs: INTEGER; - VAR p1,p2,p3,p4,p5,p6,p7,p8,p9: ARRAY OF BYTE; + PROCEDURE Out(out: Streams.Stream; VAR fmt: ARRAY OF CHAR; nargs: Types.Int32; + VAR p1,p2,p3,p4,p5,p6,p7,p8,p9: ARRAY OF SYS.BYTE; errors: RelatedEvents.Object); CONST maxargs = 9; (* maximal number of arguments *) - maxargsize = SIZE(LONGREAL); (* maximal arg size (except strings) *) + maxargsize = SIZE(Types.Real64); (* maximal arg size (except strings) *) fmtcmd = "%"; escape = "\"; VAR - arglen: ARRAY maxargs OF LONGINT; - nextarg: INTEGER; - fmtindex: LONGINT; + arglen: ARRAY maxargs OF Types.Int32; + nextarg: Types.Int32; + fmtindex: Types.Int32; fmtchar: CHAR; - hexcharval: LONGINT; + hexcharval: Types.Int32; PROCEDURE Error(errorcode: ErrorCode); VAR @@ -133,7 +133,7 @@ MODULE Print; END; END Unget; - PROCEDURE Write(byte: BYTE); + PROCEDURE Write(byte: SYS.BYTE); BEGIN IF Streams.WriteByte(out, byte) THEN INC(out.count); @@ -143,7 +143,7 @@ MODULE Print; PROCEDURE WriteLn; VAR lineterm: StreamDisciplines.LineTerminator; - i: INTEGER; + i: Types.Int32; BEGIN StreamDisciplines.GetLineTerm(out, lineterm); Write(lineterm[0]); @@ -153,7 +153,7 @@ MODULE Print; END; END WriteLn; - PROCEDURE Int(VAR int: LONGINT; base: INTEGER) : BOOLEAN; + PROCEDURE Int(VAR int: Types.Int32; base: Types.Int32) : BOOLEAN; PROCEDURE ValidDigit(ch: CHAR) : BOOLEAN; BEGIN @@ -179,7 +179,7 @@ MODULE Print; PROCEDURE SetSize; VAR - index: INTEGER; + index: Types.Int32; BEGIN index := 0; WHILE index < nargs DO @@ -193,12 +193,13 @@ MODULE Print; | 6: arglen[index] := LEN(p7); | 7: arglen[index] := LEN(p8); | 8: arglen[index] := LEN(p9); + ELSE END; INC(index); END; END SetSize; - PROCEDURE Access(par: INTEGER; at: LONGINT) : BYTE; + PROCEDURE Access(par: Types.Int32; at: Types.Int32) : SYS.BYTE; BEGIN CASE par OF | 0: RETURN p1[at] @@ -210,11 +211,12 @@ MODULE Print; | 6: RETURN p7[at] | 7: RETURN p8[at] | 8: RETURN p9[at] + ELSE END; END Access; - PROCEDURE Convert(from: INTEGER; VAR to: ARRAY OF BYTE); - VAR i: INTEGER; + PROCEDURE Convert(from: Types.Int32; VAR to: ARRAY OF SYS.BYTE); + VAR i: Types.Int32; BEGIN i := 0; WHILE i < arglen[from] DO @@ -222,23 +224,23 @@ MODULE Print; END; END Convert; - PROCEDURE GetInt(index: INTEGER; VAR long: LONGINT) : BOOLEAN; + PROCEDURE GetInt(index: Types.Int32; VAR long: Types.Int32) : BOOLEAN; (* access index-th parameter (counted from 0); - fails if arglen[index] > SYS.SIZE(LONGINT) + fails if arglen[index] > SYS.SIZE(Types.Int32) *) VAR - short: SHORTINT; + short: Types.Int8; int16: SYS.INT16; - int: INTEGER; + int: Types.Int32; BEGIN - IF arglen[index] = SIZE(SHORTINT) THEN + IF arglen[index] = SIZE(Types.Int8) THEN Convert(index, short); long := short; ELSIF arglen[index] = SIZE(SYS.INT16) THEN Convert(index, int16); long := int16; - ELSIF arglen[index] = SIZE(INTEGER) THEN + ELSIF arglen[index] = SIZE(Types.Int32) THEN Convert(index, int); long := int; - ELSIF arglen[index] = SIZE(LONGINT) THEN + ELSIF arglen[index] = SIZE(Types.Int32) THEN Convert(index, long); ELSE Error(badArgumentSize); @@ -254,9 +256,9 @@ MODULE Print; insert: BOOLEAN; (* insert between sign and 1st digit *) sign: BOOLEAN; (* sign even positive values *) leftaligned: BOOLEAN; (* output left aligned *) - width, scale: LONGINT; + width, scale: Types.Int32; - PROCEDURE NextArg(VAR index: INTEGER) : BOOLEAN; + PROCEDURE NextArg(VAR index: Types.Int32) : BOOLEAN; BEGIN IF nextarg < nargs THEN index := nextarg; INC(nextarg); RETURN TRUE @@ -284,9 +286,9 @@ MODULE Print; RETURN FALSE (* unexpected end *) END Flags; - PROCEDURE FetchInt(VAR int: LONGINT) : BOOLEAN; + PROCEDURE FetchInt(VAR int: Types.Int32) : BOOLEAN; VAR - index: INTEGER; + index: Types.Int32; BEGIN RETURN (fmtchar = "*") & Next() & NextArg(index) & GetInt(index, int) OR @@ -321,9 +323,9 @@ MODULE Print; PROCEDURE Conversion() : BOOLEAN; - PROCEDURE Fill(cnt: LONGINT); + PROCEDURE Fill(cnt: Types.Int32); (* cnt: space used by normal output *) - VAR i: LONGINT; + VAR i: Types.Int32; BEGIN IF cnt < width THEN i := width - cnt; @@ -334,14 +336,14 @@ MODULE Print; END; END Fill; - PROCEDURE FillLeft(cnt: LONGINT); + PROCEDURE FillLeft(cnt: Types.Int32); BEGIN IF ~leftaligned THEN Fill(cnt); END; END FillLeft; - PROCEDURE FillRight(cnt: LONGINT); + PROCEDURE FillRight(cnt: Types.Int32); BEGIN IF leftaligned THEN Fill(cnt); @@ -349,10 +351,10 @@ MODULE Print; END FillRight; PROCEDURE WriteBool(true, false: ARRAY OF CHAR) : BOOLEAN; - VAR index: INTEGER; val: LONGINT; + VAR index: Types.Int32; val: Types.Int32; PROCEDURE WriteString(VAR s: ARRAY OF CHAR); - VAR i, len: INTEGER; + VAR i, len: Types.Int32; BEGIN len := 0; WHILE (len < LEN(s)) & (s[len] # 0X) DO @@ -379,8 +381,8 @@ MODULE Print; PROCEDURE WriteChar() : BOOLEAN; VAR - val: LONGINT; - index: INTEGER; + val: Types.Int32; + index: Types.Int32; BEGIN IF NextArg(index) & GetInt(index, val) & (val >= 0) & (val <= ORD(MAX(CHAR))) THEN @@ -392,21 +394,21 @@ MODULE Print; RETURN FALSE END WriteChar; - PROCEDURE WriteInt(base: INTEGER) : BOOLEAN; + PROCEDURE WriteInt(base: Types.Int32) : BOOLEAN; VAR - index: INTEGER; - val: LONGINT; + index: Types.Int32; + val: Types.Int32; neg: BOOLEAN; (* set by Convert *) buf: ARRAY 12 OF CHAR; (* filled by Convert *) - i: INTEGER; - len: INTEGER; (* space needed for val *) - signcnt: INTEGER; (* =1 if sign printed; else 0 *) + i: Types.Int32; + len: Types.Int32; (* space needed for val *) + signcnt: Types.Int32; (* =1 if sign printed; else 0 *) signch: CHAR; PROCEDURE Convert; VAR - index: INTEGER; - digit: LONGINT; + index: Types.Int32; + digit: Types.Int32; BEGIN neg := val < 0; index := 0; @@ -462,36 +464,36 @@ MODULE Print; CONST defaultscale = 6; VAR - index: INTEGER; - lr: LONGREAL; - r: REAL; - shortint: SHORTINT; int: INTEGER; longint: LONGINT; + index: Types.Int32; + lr: Types.Real64; + r: Types.Real32; + shortint: Types.Int8; int: Types.Int32; longint: Types.Int32; int16: SYS.INT16; long: BOOLEAN; - exponent: INTEGER; - mantissa: LONGREAL; + exponent: Types.Int32; + mantissa: Types.Real64; digits: ARRAY Reals.maxlongdignum OF CHAR; neg: BOOLEAN; - ndigits: INTEGER; - decpt: INTEGER; + ndigits: Types.Int32; + decpt: Types.Int32; - PROCEDURE Print(decpt: INTEGER; withexp: BOOLEAN; exp: INTEGER); + PROCEDURE Print(decpt: Types.Int32; withexp: BOOLEAN; exp: Types.Int32); (* decpt: position of decimal point = 0: just before the digits > 0: after decpt digits < 0: ABS(decpt) zeroes before digits needed *) VAR - needed: INTEGER; (* space needed *) - index: INTEGER; - count: LONGINT; + needed: Types.Int32; (* space needed *) + index: Types.Int32; + count: Types.Int32; - PROCEDURE WriteExp(exp: INTEGER); + PROCEDURE WriteExp(exp: Types.Int32); CONST base = 10; VAR - power: INTEGER; - digit: INTEGER; + power: Types.Int32; + digit: Types.Int32; BEGIN IF long THEN Write("D"); @@ -581,18 +583,18 @@ MODULE Print; BEGIN (* WriteReal *) IF NextArg(index) THEN - IF arglen[index] = SIZE(LONGREAL) THEN + IF arglen[index] = SIZE(Types.Real64) THEN long := TRUE; Convert(index, lr); - ELSIF arglen[index] = SIZE(REAL) THEN + ELSIF arglen[index] = SIZE(Types.Real32) THEN long := FALSE; Convert(index, r); lr := r; - ELSIF arglen[index] = SIZE(LONGINT) THEN + ELSIF arglen[index] = SIZE(Types.Int32) THEN long := FALSE; Convert(index, longint); lr := longint; - ELSIF arglen[index] = SIZE(INTEGER) THEN + ELSIF arglen[index] = SIZE(Types.Int32) THEN long := FALSE; Convert(index, int); lr := int; @@ -600,7 +602,7 @@ MODULE Print; long := FALSE; Convert(index, int16); lr := int16; - ELSIF arglen[index] = SIZE(SHORTINT) THEN + ELSIF arglen[index] = SIZE(Types.Int8) THEN long := FALSE; Convert(index, shortint); lr := shortint; @@ -634,6 +636,7 @@ MODULE Print; ndigits := 1; END; | "g": ndigits := SHORT(scale); + ELSE END; Reals.Digits(mantissa, 10, digits, neg, (* force = *) format # "g", ndigits); @@ -654,6 +657,7 @@ MODULE Print; END; Print(decpt, (* withexp = *) FALSE, 0); END; + ELSE END; RETURN TRUE ELSE @@ -663,16 +667,16 @@ MODULE Print; PROCEDURE WriteString() : BOOLEAN; VAR - index: INTEGER; - i: LONGINT; - byte: BYTE; - len: LONGINT; + index: Types.Int32; + i: Types.Int32; + byte: SYS.BYTE; + len: Types.Int32; BEGIN IF NextArg(index) THEN len := 0; WHILE (len < arglen[index]) & ((scale = -1) OR (len < scale)) & - (CHR(Access(index, len)) # 0X) DO + ((*CHR*)SYS.VAL(CHAR, Access(index, len)) # 0X) DO INC(len); END; FillLeft(len); @@ -755,205 +759,205 @@ MODULE Print; (* === public part ============================================== *) - PROCEDURE F(fmt: ARRAY OF CHAR); - VAR x: INTEGER; + PROCEDURE F*(fmt: ARRAY OF CHAR); + VAR x: Types.Int32; BEGIN Out(Streams.stdout, fmt, 0, x,x,x,x,x,x,x,x,x, NIL); END F; - PROCEDURE F1(fmt: ARRAY OF CHAR; p1: ARRAY OF BYTE); - VAR x: INTEGER; + PROCEDURE F1*(fmt: ARRAY OF CHAR; p1: ARRAY OF SYS.BYTE); + VAR x: Types.Int32; BEGIN Out(Streams.stdout, fmt, 1, p1, x,x,x,x,x,x,x,x, NIL); END F1; - PROCEDURE F2(fmt: ARRAY OF CHAR; p1, p2: ARRAY OF BYTE); - VAR x: INTEGER; + PROCEDURE F2*(fmt: ARRAY OF CHAR; p1, p2: ARRAY OF SYS.BYTE); + VAR x: Types.Int32; BEGIN Out(Streams.stdout, fmt, 2, p1,p2, x,x,x,x,x,x,x, NIL); END F2; - PROCEDURE F3(fmt: ARRAY OF CHAR; p1, p2, p3: ARRAY OF BYTE); - VAR x: INTEGER; + PROCEDURE F3*(fmt: ARRAY OF CHAR; p1, p2, p3: ARRAY OF SYS.BYTE); + VAR x: Types.Int32; BEGIN Out(Streams.stdout, fmt, 3, p1,p2,p3, x,x,x,x,x,x, NIL); END F3; - PROCEDURE F4(fmt: ARRAY OF CHAR; p1, p2, p3, p4: ARRAY OF BYTE); - VAR x: INTEGER; + PROCEDURE F4*(fmt: ARRAY OF CHAR; p1, p2, p3, p4: ARRAY OF SYS.BYTE); + VAR x: Types.Int32; BEGIN Out(Streams.stdout, fmt, 4, p1,p2,p3,p4, x,x,x,x,x, NIL); END F4; - PROCEDURE F5(fmt: ARRAY OF CHAR; p1, p2, p3, p4, p5: ARRAY OF BYTE); - VAR x: INTEGER; + PROCEDURE F5*(fmt: ARRAY OF CHAR; p1, p2, p3, p4, p5: ARRAY OF SYS.BYTE); + VAR x: Types.Int32; BEGIN Out(Streams.stdout, fmt, 5, p1,p2,p3,p4,p5, x,x,x,x, NIL); END F5; - PROCEDURE F6(fmt: ARRAY OF CHAR; p1, p2, p3, p4, p5, p6: ARRAY OF BYTE); - VAR x: INTEGER; + PROCEDURE F6*(fmt: ARRAY OF CHAR; p1, p2, p3, p4, p5, p6: ARRAY OF SYS.BYTE); + VAR x: Types.Int32; BEGIN Out(Streams.stdout, fmt, 6, p1,p2,p3,p4,p5,p6, x,x,x, NIL); END F6; - PROCEDURE F7(fmt: ARRAY OF CHAR; p1, p2, p3, p4, p5, p6, p7: ARRAY OF BYTE); - VAR x: INTEGER; + PROCEDURE F7*(fmt: ARRAY OF CHAR; p1, p2, p3, p4, p5, p6, p7: ARRAY OF SYS.BYTE); + VAR x: Types.Int32; BEGIN Out(Streams.stdout, fmt, 7, p1,p2,p3,p4,p5,p6,p7, x,x, NIL); END F7; - PROCEDURE F8(fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5, p6, p7, p8: ARRAY OF BYTE); - VAR x: INTEGER; + PROCEDURE F8*(fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5, p6, p7, p8: ARRAY OF SYS.BYTE); + VAR x: Types.Int32; BEGIN Out(Streams.stdout, fmt, 8, p1,p2,p3,p4,p5,p6,p7,p8, x, NIL); END F8; - PROCEDURE F9(fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5, p6, p7, p8, p9: ARRAY OF BYTE); + PROCEDURE F9*(fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5, p6, p7, p8, p9: ARRAY OF SYS.BYTE); BEGIN Out(Streams.stdout, fmt, 9, p1,p2,p3,p4,p5,p6,p7,p8,p9, NIL); END F9; - PROCEDURE S(out: Streams.Stream; fmt: ARRAY OF CHAR); - VAR x: INTEGER; + PROCEDURE S*(out: Streams.Stream; fmt: ARRAY OF CHAR); + VAR x: Types.Int32; BEGIN Out(out, fmt, 0, x,x,x,x,x,x,x,x,x, NIL); END S; - PROCEDURE S1(out: Streams.Stream; fmt: ARRAY OF CHAR; p1: ARRAY OF BYTE); - VAR x: INTEGER; + PROCEDURE S1*(out: Streams.Stream; fmt: ARRAY OF CHAR; p1: ARRAY OF SYS.BYTE); + VAR x: Types.Int32; BEGIN Out(out, fmt, 1, p1, x,x,x,x,x,x,x,x, NIL); END S1; - PROCEDURE S2(out: Streams.Stream; fmt: ARRAY OF CHAR; p1, p2: ARRAY OF BYTE); - VAR x: INTEGER; + PROCEDURE S2*(out: Streams.Stream; fmt: ARRAY OF CHAR; p1, p2: ARRAY OF SYS.BYTE); + VAR x: Types.Int32; BEGIN Out(out, fmt, 2, p1,p2, x,x,x,x,x,x,x, NIL); END S2; - PROCEDURE S3(out: Streams.Stream; fmt: ARRAY OF CHAR; p1, p2, p3: ARRAY OF BYTE); - VAR x: INTEGER; + PROCEDURE S3*(out: Streams.Stream; fmt: ARRAY OF CHAR; p1, p2, p3: ARRAY OF SYS.BYTE); + VAR x: Types.Int32; BEGIN Out(out, fmt, 3, p1,p2,p3, x,x,x,x,x,x, NIL); END S3; - PROCEDURE S4(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4: ARRAY OF BYTE); - VAR x: INTEGER; + PROCEDURE S4*(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4: ARRAY OF SYS.BYTE); + VAR x: Types.Int32; BEGIN Out(out, fmt, 4, p1,p2,p3,p4, x,x,x,x,x, NIL); END S4; - PROCEDURE S5(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5: ARRAY OF BYTE); - VAR x: INTEGER; + PROCEDURE S5*(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5: ARRAY OF SYS.BYTE); + VAR x: Types.Int32; BEGIN Out(out, fmt, 5, p1,p2,p3,p4,p5, x,x,x,x, NIL); END S5; - PROCEDURE S6(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5, p6: ARRAY OF BYTE); - VAR x: INTEGER; + PROCEDURE S6*(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5, p6: ARRAY OF SYS.BYTE); + VAR x: Types.Int32; BEGIN Out(out, fmt, 6, p1,p2,p3,p4,p5,p6, x,x,x, NIL); END S6; - PROCEDURE S7(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5, p6, p7: ARRAY OF BYTE); - VAR x: INTEGER; + PROCEDURE S7*(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5, p6, p7: ARRAY OF SYS.BYTE); + VAR x: Types.Int32; BEGIN Out(out, fmt, 7, p1,p2,p3,p4,p5,p6,p7, x,x, NIL); END S7; - PROCEDURE S8(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5, p6, p7, p8: ARRAY OF BYTE); - VAR x: INTEGER; + PROCEDURE S8*(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5, p6, p7, p8: ARRAY OF SYS.BYTE); + VAR x: Types.Int32; BEGIN Out(out, fmt, 8, p1,p2,p3,p4,p5,p6,p7,p8, x, NIL); END S8; - PROCEDURE S9(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5, p6, p7, p8, p9: ARRAY OF BYTE); + PROCEDURE S9*(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5, p6, p7, p8, p9: ARRAY OF SYS.BYTE); BEGIN Out(out, fmt, 9, p1,p2,p3,p4,p5,p6,p7,p8,p9, NIL); END S9; - PROCEDURE SE(out: Streams.Stream; fmt: ARRAY OF CHAR; + PROCEDURE SE*(out: Streams.Stream; fmt: ARRAY OF CHAR; errors: RelatedEvents.Object); - VAR x: INTEGER; + VAR x: Types.Int32; BEGIN Out(out, fmt, 0, x,x,x,x,x,x,x,x,x, NIL); END SE; - PROCEDURE SE1(out: Streams.Stream; fmt: ARRAY OF CHAR; p1: ARRAY OF BYTE; + PROCEDURE SE1*(out: Streams.Stream; fmt: ARRAY OF CHAR; p1: ARRAY OF SYS.BYTE; errors: RelatedEvents.Object); - VAR x: INTEGER; + VAR x: Types.Int32; BEGIN Out(out, fmt, 1, p1, x,x,x,x,x,x,x,x, errors); END SE1; - PROCEDURE SE2(out: Streams.Stream; fmt: ARRAY OF CHAR; p1, p2: ARRAY OF BYTE; + PROCEDURE SE2*(out: Streams.Stream; fmt: ARRAY OF CHAR; p1, p2: ARRAY OF SYS.BYTE; errors: RelatedEvents.Object); - VAR x: INTEGER; + VAR x: Types.Int32; BEGIN Out(out, fmt, 2, p1,p2, x,x,x,x,x,x,x, errors); END SE2; - PROCEDURE SE3(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3: ARRAY OF BYTE; + PROCEDURE SE3*(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3: ARRAY OF SYS.BYTE; errors: RelatedEvents.Object); - VAR x: INTEGER; + VAR x: Types.Int32; BEGIN Out(out, fmt, 3, p1,p2,p3, x,x,x,x,x,x, errors); END SE3; - PROCEDURE SE4(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4: ARRAY OF BYTE; + PROCEDURE SE4*(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4: ARRAY OF SYS.BYTE; errors: RelatedEvents.Object); - VAR x: INTEGER; + VAR x: Types.Int32; BEGIN Out(out, fmt, 4, p1,p2,p3,p4, x,x,x,x,x, errors); END SE4; - PROCEDURE SE5(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5: ARRAY OF BYTE; + PROCEDURE SE5*(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5: ARRAY OF SYS.BYTE; errors: RelatedEvents.Object); - VAR x: INTEGER; + VAR x: Types.Int32; BEGIN Out(out, fmt, 5, p1,p2,p3,p4,p5, x,x,x,x, errors); END SE5; - PROCEDURE SE6(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5, p6: ARRAY OF BYTE; + PROCEDURE SE6*(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5, p6: ARRAY OF SYS.BYTE; errors: RelatedEvents.Object); - VAR x: INTEGER; + VAR x: Types.Int32; BEGIN Out(out, fmt, 6, p1,p2,p3,p4,p5,p6, x,x,x, errors); END SE6; - PROCEDURE SE7(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5, p6, p7: ARRAY OF BYTE; + PROCEDURE SE7*(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5, p6, p7: ARRAY OF SYS.BYTE; errors: RelatedEvents.Object); - VAR x: INTEGER; + VAR x: Types.Int32; BEGIN Out(out, fmt, 7, p1,p2,p3,p4,p5,p6,p7, x,x, errors); END SE7; - PROCEDURE SE8(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5, p6, p7, p8: ARRAY OF BYTE; + PROCEDURE SE8*(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5, p6, p7, p8: ARRAY OF SYS.BYTE; errors: RelatedEvents.Object); - VAR x: INTEGER; + VAR x: Types.Int32; BEGIN Out(out, fmt, 8, p1,p2,p3,p4,p5,p6,p7,p8, x, errors); END SE8; - PROCEDURE SE9(out: Streams.Stream; fmt: ARRAY OF CHAR; - p1, p2, p3, p4, p5, p6, p7, p8, p9: ARRAY OF BYTE; + PROCEDURE SE9*(out: Streams.Stream; fmt: ARRAY OF CHAR; + p1, p2, p3, p4, p5, p6, p7, p8, p9: ARRAY OF SYS.BYTE; errors: RelatedEvents.Object); BEGIN Out(out, fmt, 9, p1,p2,p3,p4,p5,p6,p7,p8,p9, errors); @@ -961,4 +965,4 @@ MODULE Print; BEGIN InitErrorHandling; -END Print. +END ulmPrint. diff --git a/src/library/ulm/ulmPriorities.Mod b/src/library/ulm/ulmPriorities.Mod index e171907a..a308df8f 100644 --- a/src/library/ulm/ulmPriorities.Mod +++ b/src/library/ulm/ulmPriorities.Mod @@ -49,7 +49,7 @@ MODULE ulmPriorities; - gap defines the minimum distance between two priority regions defined in this module *) - + IMPORT Types := ulmTypes; CONST region* = 10; gap* = 10; @@ -59,7 +59,7 @@ MODULE ulmPriorities; *) TYPE - Priority* = INTEGER; + Priority* = Types.Int32; VAR (* current priority at begin of execution (after init of Events); diff --git a/src/library/ulm/ulmProcess.Mod b/src/library/ulm/ulmProcess.Mod index 20bb5186..ce4ce70f 100644 --- a/src/library/ulm/ulmProcess.Mod +++ b/src/library/ulm/ulmProcess.Mod @@ -36,7 +36,7 @@ MODULE ulmProcess; - IMPORT Events := ulmEvents, Priorities := ulmPriorities; + IMPORT Events := ulmEvents, Priorities := ulmPriorities, Types := ulmTypes; (* user readable name of our process *) TYPE @@ -48,7 +48,7 @@ MODULE ulmProcess; (* exit codes *) TYPE - ExitCode* = INTEGER; + ExitCode* = Types.Int32; VAR indicateSuccess*: ExitCode; indicateFailure*: ExitCode; @@ -83,7 +83,7 @@ MODULE ulmProcess; (* private declarations *) VAR handlers: Interface; - nestlevel: INTEGER; + nestlevel: Types.Int32; PROCEDURE SetHandlers*(if: Interface); BEGIN diff --git a/src/library/ulm/ulmRandomGenerators.Mod b/src/library/ulm/ulmRandomGenerators.Mod index f1aa36de..baa0219e 100644 --- a/src/library/ulm/ulmRandomGenerators.Mod +++ b/src/library/ulm/ulmRandomGenerators.Mod @@ -74,7 +74,7 @@ MODULE ulmRandomGenerators; Sequence* = POINTER TO SequenceRec; Int32ValSProc* = PROCEDURE (sequence: Sequence): Types.Int32; - LongRealValSProc* = PROCEDURE (sequence: Sequence): LONGREAL; + LongRealValSProc* = PROCEDURE (sequence: Sequence): Types.Real64; RewindSequenceProc* = PROCEDURE (sequence: Sequence); RestartSequenceProc* = PROCEDURE (sequence, seed: Sequence); SetValSProc* = PROCEDURE (sequence: Sequence; value: Operations.Operand); @@ -83,7 +83,7 @@ MODULE ulmRandomGenerators; int32ValS* = 0; longRealValS* = 1; rewindSequence* = 2; restartSequence* = 3; TYPE - CapabilitySet* = SET; (* of [int32ValS..restartSequence] *) + CapabilitySet* = Types.Set; (* of [int32ValS..restartSequence] *) Interface* = POINTER TO InterfaceRec; InterfaceRec* = RECORD @@ -127,8 +127,8 @@ MODULE ulmRandomGenerators; DefaultSequenceRec = RECORD (SequenceRec) - seed1, seed2: LONGINT; - value1, value2: LONGINT; + seed1, seed2: Types.Int32; + value1, value2: Types.Int32; END; ServiceDiscipline = POINTER TO ServiceDisciplineRec; @@ -146,9 +146,9 @@ MODULE ulmRandomGenerators; (* ----- bug workaround ----- *) - PROCEDURE Entier(value: LONGREAL): LONGINT; + PROCEDURE Entier(value: Types.Real64): Types.Int32; VAR - result: LONGINT; + result: Types.Int32; BEGIN result := ENTIER(value); IF result > value THEN @@ -193,12 +193,12 @@ MODULE ulmRandomGenerators; sequence.if.restartSequence(sequence, seed); END RestartSequence; - PROCEDURE ^ LongRealValS*(sequence: Sequence): LONGREAL; + PROCEDURE ^ LongRealValS*(sequence: Sequence): Types.Real64; PROCEDURE Int32ValS*(sequence: Sequence): Types.Int32; (* get random 32-bit value from sequence *) VAR - real: LONGREAL; + real: Types.Real64; BEGIN IF int32ValS IN sequence.caps THEN RETURN sequence.if.int32ValS(sequence) @@ -214,7 +214,7 @@ MODULE ulmRandomGenerators; RETURN Int32ValS(std); END Int32Val; - PROCEDURE LongRealValS*(sequence: Sequence): LONGREAL; + PROCEDURE LongRealValS*(sequence: Sequence): Types.Real64; (* get a uniformly distributed longreal value in [0..1) *) BEGIN IF longRealValS IN sequence.caps THEN @@ -225,32 +225,32 @@ MODULE ulmRandomGenerators; END; END LongRealValS; - PROCEDURE LongRealVal*(): LONGREAL; + PROCEDURE LongRealVal*(): Types.Real64; (* get a uniformly distributed longreal value in [0..1) *) BEGIN RETURN LongRealValS(std) END LongRealVal; - PROCEDURE RealValS*(sequence: Sequence): REAL; + PROCEDURE RealValS*(sequence: Sequence): Types.Real32; (* get a uniformly distributed real value in [0..1) *) BEGIN RETURN SHORT(LongRealValS(sequence)) END RealValS; - PROCEDURE RealVal*(): REAL; + PROCEDURE RealVal*(): Types.Real32; (* get a uniformly distributed real value in [0..1) *) BEGIN RETURN SHORT(LongRealValS(std)) END RealVal; - PROCEDURE ValS*(sequence: Sequence; low, high: LONGINT): LONGINT; + PROCEDURE ValS*(sequence: Sequence; low, high: Types.Int32): Types.Int32; (* get a uniformly distributed integer in [low..high] *) BEGIN ASSERT(low <= high); RETURN Entier( low + LongRealValS(sequence) * (1. + high - low) ) END ValS; - PROCEDURE Val*(low, high: LONGINT): LONGINT; + PROCEDURE Val*(low, high: Types.Int32): Types.Int32; (* get a uniformly distributed integer in [low..high] *) BEGIN RETURN ValS(std, low, high) @@ -305,7 +305,7 @@ MODULE ulmRandomGenerators; (* ----- DefaultSequence ----- *) - PROCEDURE CongruentialStep(VAR value1, value2: LONGINT); + PROCEDURE CongruentialStep(VAR value1, value2: Types.Int32); BEGIN value1 := factor1 * (value1 MOD quotient1) - remainder1 * (value1 DIV quotient1); @@ -319,9 +319,9 @@ MODULE ulmRandomGenerators; END; END CongruentialStep; - PROCEDURE DefaultSequenceValue(sequence: Sequence): LONGREAL; + PROCEDURE DefaultSequenceValue(sequence: Sequence): Types.Real64; VAR - value: LONGINT; + value: Types.Int32; BEGIN WITH sequence: DefaultSequence DO CongruentialStep(sequence.value1, sequence.value2); @@ -357,12 +357,12 @@ MODULE ulmRandomGenerators; if: Interface; daytime: Times.Time; timeval: Times.TimeValueRec; - count: LONGINT; + count: Types.Int32; - PROCEDURE Hash(str: ARRAY OF CHAR): LONGINT; + PROCEDURE Hash(str: ARRAY OF CHAR): Types.Int32; VAR index, - val: LONGINT; + val: Types.Int32; BEGIN val := 27567352; index := 0; diff --git a/src/library/ulm/ulmReals.Mod b/src/library/ulm/ulmReals.Mod index f941c05a..a646512d 100644 --- a/src/library/ulm/ulmReals.Mod +++ b/src/library/ulm/ulmReals.Mod @@ -33,14 +33,14 @@ MODULE ulmReals; - IMPORT IEEE := ulmIEEE, MC68881 := ulmMC68881; + IMPORT IEEE := ulmIEEE, MC68881 := ulmMC68881, Types := ulmTypes; CONST - (* for REAL *) + (* for Types.Real32 *) maxexp* = 309; minexp* = -323; maxdignum* = 16; - (* for LONGREAL *) + (* for Types.Real64 *) (* maxlongexp = 4932; minlongexp = -4951; @@ -55,30 +55,30 @@ MODULE ulmReals; TYPE PowerRec = RECORD - p10: LONGREAL; - n: INTEGER; + p10: Types.Real64; + n: Types.Int32; END; VAR powtab: ARRAY powers OF PowerRec; - sigdigits: ARRAY maxbase+1 OF INTEGER; (* valid range: [2..maxbase] *) + sigdigits: ARRAY maxbase+1 OF Types.Int32; (* valid range: [2..maxbase] *) - PROCEDURE ExpAndMan*(r: LONGREAL; long: BOOLEAN; base: INTEGER; - VAR exponent: INTEGER; VAR mantissa: LONGREAL); + PROCEDURE ExpAndMan*(r: Types.Real64; long: BOOLEAN; base: Types.Int32; + VAR exponent: Types.Int32; VAR mantissa: Types.Real64); (* get exponent and mantissa from `r': (1.0 >= ABS(mantissa)) & (ABS(mantissa) < base) r = mantissa * base^exponent - long should be false if a REAL-value is passed to `r' + long should be false if a Types.Real32-value is passed to `r' valid values of base: 2, 8, 10, and 16 *) VAR neg: BOOLEAN; - index: INTEGER; - roundoff: LONGREAL; - i: INTEGER; - ndigits: INTEGER; + index: Types.Int32; + roundoff: Types.Real64; + i: Types.Int32; + ndigits: Types.Int32; BEGIN IF r = 0.0 THEN exponent := 0; mantissa := 0; RETURN @@ -164,10 +164,10 @@ MODULE ulmReals; END; END ExpAndMan; - PROCEDURE Power*(base: LONGREAL; exp: INTEGER) : LONGREAL; + PROCEDURE Power*(base: Types.Real64; exp: Types.Int32) : Types.Real64; (* efficient calculation of base^exp *) VAR - r, res: LONGREAL; + r, res: Types.Real64; neg: BOOLEAN; (* negative exponent? *) BEGIN IF MC68881.available & (base = 10) THEN @@ -197,10 +197,10 @@ MODULE ulmReals; END; END Power; - PROCEDURE Digits*(mantissa: LONGREAL; base: INTEGER; + PROCEDURE Digits*(mantissa: Types.Real64; base: Types.Int32; VAR buf: ARRAY OF CHAR; VAR neg: BOOLEAN; - force: BOOLEAN; VAR ndigits: INTEGER); + force: BOOLEAN; VAR ndigits: Types.Int32); (* PRE: mantissa holds the post-condition of ExpAndMan; valid values for base are 2, 8, 10, and 16 @@ -216,11 +216,11 @@ MODULE ulmReals; ndigits is unchanged *) VAR - index: INTEGER; (* of buf *) - i: INTEGER; roundoff: LONGREAL; - lastnz: INTEGER; (* last index with buf[index] # "0" *) + index: Types.Int32; (* of buf *) + i: Types.Int32; roundoff: Types.Real64; + lastnz: Types.Int32; (* last index with buf[index] # "0" *) ch: CHAR; - digit: LONGINT; + digit: Types.Int32; maxdig: CHAR; (* base-1 converted *) BEGIN @@ -269,14 +269,14 @@ MODULE ulmReals; buf[index] := 0X; ndigits := index; END Digits; - PROCEDURE Convert*(digits: ARRAY OF CHAR; base: INTEGER; neg: BOOLEAN; - VAR mantissa: LONGREAL); + PROCEDURE Convert*(digits: ARRAY OF CHAR; base: Types.Int32; neg: BOOLEAN; + VAR mantissa: Types.Real64); (* convert normalized `digits' (decimal point after 1st digit) into `mantissa' *) VAR - index: INTEGER; - factor: LONGREAL; + index: Types.Int32; + factor: Types.Real64; BEGIN IF digits = "0" THEN mantissa := 0; @@ -304,7 +304,7 @@ BEGIN powtab[4].p10 := 1.0D2; powtab[4].n := 2; powtab[5].p10 := 1.0D1; powtab[5].n := 1; - (* for LONGREAL *) + (* for Types.Real64 *) sigdigits[2] := 64; sigdigits[3] := 40; sigdigits[4] := 32; sigdigits[5] := 27; sigdigits[6] := 24; sigdigits[7] := 22; sigdigits[8] := 21; sigdigits[9] := 20; sigdigits[10] := 19; diff --git a/src/library/ulm/ulmScales.Mod b/src/library/ulm/ulmScales.Mod index 12cf5363..25af6eac 100644 --- a/src/library/ulm/ulmScales.Mod +++ b/src/library/ulm/ulmScales.Mod @@ -39,7 +39,7 @@ MODULE ulmScales; IMPORT Disciplines := ulmDisciplines, Events := ulmEvents, Objects := ulmObjects, Operations := ulmOperations, PersistentObjects := ulmPersistentObjects, - RelatedEvents := ulmRelatedEvents, Services := ulmServices, SYS := SYSTEM; + RelatedEvents := ulmRelatedEvents, Services := ulmServices, SYS := SYSTEM, Types := ulmTypes; TYPE Scale* = POINTER TO ScaleRec; @@ -88,25 +88,25 @@ MODULE ulmScales; RECORD (Operations.OperandRec) scale: Scale; - type: SHORTINT; (* absolute or relative? *) + type: Types.Int8; (* absolute or relative? *) END; VAR measureType: Services.Type; TYPE - Value* = LONGINT; + Value* = Types.Int32; CONST add* = Operations.add; sub* = Operations.sub; TYPE - Operation* = SHORTINT; (* add or sub *) + Operation* = Types.Int8; (* add or sub *) TYPE CreateProc* = PROCEDURE (scale: Scale; VAR measure: Measure; abs: BOOLEAN); GetValueProc* = PROCEDURE (measure: Measure; unit: Unit; VAR value: Value); SetValueProc* = PROCEDURE (measure: Measure; unit: Unit; value: Value); AssignProc* = PROCEDURE (target: Measure; source: Measure); OperatorProc* = PROCEDURE (op: Operation; op1, op2, result: Measure); - CompareProc* = PROCEDURE (op1, op2: Measure) : INTEGER; + CompareProc* = PROCEDURE (op1, op2: Measure) : Types.Int32; ConvertProc* = PROCEDURE (from, to: Measure); InterfaceRec* = @@ -183,7 +183,7 @@ MODULE ulmScales; scale.tail := listp; END InitUnit; - PROCEDURE CreateMeasure*(scale: Scale; VAR measure: Measure; type: SHORTINT); + PROCEDURE CreateMeasure*(scale: Scale; VAR measure: Measure; type: Types.Int8); BEGIN scale.if.create(scale, measure, type = absolute); Operations.Init(measure, opif, opcaps); @@ -295,7 +295,7 @@ MODULE ulmScales; RETURN measure.type = relative END IsRelative; - PROCEDURE MeasureType*(measure: Measure) : SHORTINT; + PROCEDURE MeasureType*(measure: Measure) : Types.Int8; BEGIN RETURN measure.type END MeasureType; @@ -372,10 +372,10 @@ MODULE ulmScales; PROCEDURE Op(op: Operations.Operation; op1, op2: Operations.Operand; VAR result: Operations.Operand); VAR - restype: SHORTINT; (* type of result -- set by CheckTypes *) + restype: Types.Int8; (* type of result -- set by CheckTypes *) m1, m2: Measure; - PROCEDURE CheckTypes(VAR restype: SHORTINT); + PROCEDURE CheckTypes(VAR restype: Types.Int8); (* check operands for correct typing; sets restype to the correct result type; *) @@ -419,7 +419,7 @@ MODULE ulmScales; END; END Op; - PROCEDURE Compare(op1, op2: Operations.Operand) : INTEGER; + PROCEDURE Compare(op1, op2: Operations.Operand) : Types.Int32; VAR m1, m2: Measure; BEGIN diff --git a/src/library/ulm/ulmServices.Mod b/src/library/ulm/ulmServices.Mod index 7ec557df..73b80aad 100644 --- a/src/library/ulm/ulmServices.Mod +++ b/src/library/ulm/ulmServices.Mod @@ -31,7 +31,7 @@ MODULE ulmServices; - IMPORT Disciplines := ulmDisciplines, Objects := ulmObjects; + IMPORT Disciplines := ulmDisciplines, Objects := ulmObjects, Types := ulmTypes; TYPE Type* = POINTER TO TypeRec; @@ -84,9 +84,9 @@ MODULE ulmServices; bufsize = 512; (* length of a name buffer in bytes *) tabsize = 1171; TYPE - BufferPosition = INTEGER; - Length = LONGINT; - HashValue = INTEGER; + BufferPosition = Types.Int32; + Length = Types.Int32; + HashValue = Types.Int32; Buffer = ARRAY bufsize OF CHAR; NameList = POINTER TO NameListRec; NameListRec = @@ -116,14 +116,14 @@ MODULE ulmServices; (* ==== name table management ======================================== *) - PROCEDURE Hash(name: ARRAY OF CHAR; length: LONGINT) : HashValue; + PROCEDURE Hash(name: ARRAY OF CHAR; length: Types.Int32) : HashValue; CONST shift = 4; VAR - index: LONGINT; - val: LONGINT; + index: Types.Int32; + val: Types.Int32; ch: CHAR; - ordval: INTEGER; + ordval: Types.Int32; BEGIN index := 0; val := length; WHILE index < length DO @@ -150,9 +150,9 @@ MODULE ulmServices; currentPos := 0; END CreateBuf; - PROCEDURE StringLength(string: ARRAY OF CHAR) : LONGINT; + PROCEDURE StringLength(string: ARRAY OF CHAR) : Types.Int32; VAR - index: LONGINT; + index: Types.Int32; BEGIN index := 0; WHILE (index < LEN(string)) & (string[index] # 0X) DO @@ -163,7 +163,7 @@ MODULE ulmServices; PROCEDURE InitName(name: Type; string: ARRAY OF CHAR); VAR - index, length: LONGINT; + index, length: Types.Int32; firstbuf, buf: NameList; startpos: BufferPosition; BEGIN @@ -195,9 +195,9 @@ MODULE ulmServices; PROCEDURE EqualName(name: Type; string: ARRAY OF CHAR) : BOOLEAN; (* precondition: both have the same length *) VAR - index: LONGINT; + index: Types.Int32; buf: NameList; - pos: INTEGER; + pos: Types.Int32; BEGIN buf := name.begin; pos := name.pos; index := 0; @@ -216,7 +216,7 @@ MODULE ulmServices; PROCEDURE SeekName(string: ARRAY OF CHAR; VAR name: Type) : BOOLEAN; VAR - length: LONGINT; + length: Types.Int32; hashval: HashValue; p: Type; BEGIN @@ -232,9 +232,9 @@ MODULE ulmServices; PROCEDURE ExtractName(name: Type; VAR string: ARRAY OF CHAR); VAR - index: LONGINT; + index: Types.Int32; buf: NameList; - pos: INTEGER; + pos: Types.Int32; BEGIN buf := name.begin; pos := name.pos; index := 0; @@ -331,7 +331,7 @@ MODULE ulmServices; PROCEDURE GetModule(name: ARRAY OF CHAR; VAR module: ARRAY OF CHAR); (* get the name of the module where 'name' was defined *) VAR - index: INTEGER; + index: Types.Int32; BEGIN index := 0; WHILE (name[index] # ".") & (name[index] # 0X) & diff --git a/src/library/ulm/ulmSets.Mod b/src/library/ulm/ulmSets.Mod index 7c75a3ff..a1dcd4df 100644 --- a/src/library/ulm/ulmSets.Mod +++ b/src/library/ulm/ulmSets.Mod @@ -35,15 +35,16 @@ *) MODULE ulmSets; +IMPORT Types := ulmTypes; CONST - setsize* = MAX(SET) + 1; + setsize* = MAX(Types.Set) + 1; TYPE - CharSet* = ARRAY (ORD(MAX(CHAR)) + 1) DIV setsize OF SET; + CharSet* = ARRAY (ORD(MAX(CHAR)) + 1) DIV setsize OF Types.Set; - PROCEDURE InitSet*(VAR set: ARRAY OF SET); - VAR i: LONGINT; + PROCEDURE InitSet*(VAR set: ARRAY OF Types.Set); + VAR i: Types.Int32; BEGIN i := 0; WHILE i < LEN(set) DO @@ -51,8 +52,8 @@ MODULE ulmSets; END; END InitSet; - PROCEDURE Complement*(VAR set: ARRAY OF SET); - VAR i: LONGINT; + PROCEDURE Complement*(VAR set: ARRAY OF Types.Set); + VAR i: Types.Int32; BEGIN i := 0; WHILE i < LEN(set) DO @@ -60,17 +61,17 @@ MODULE ulmSets; END; END Complement; - PROCEDURE In*(VAR set: ARRAY OF SET; i: LONGINT) : BOOLEAN; + PROCEDURE In*(VAR set: ARRAY OF Types.Set; i: Types.Int32) : BOOLEAN; BEGIN RETURN (i MOD setsize) IN set[i DIV setsize] END In; - PROCEDURE Incl*(VAR set: ARRAY OF SET; i: LONGINT); + PROCEDURE Incl*(VAR set: ARRAY OF Types.Set; i: Types.Int32); BEGIN INCL(set[i DIV setsize], i MOD setsize); END Incl; - PROCEDURE Excl*(VAR set: ARRAY OF SET; i: LONGINT); + PROCEDURE Excl*(VAR set: ARRAY OF Types.Set; i: Types.Int32); BEGIN EXCL(set[i DIV setsize], i MOD setsize); END Excl; @@ -90,9 +91,9 @@ MODULE ulmSets; EXCL(charset[ORD(ch) DIV setsize], ORD(ch) MOD setsize); END ExclChar; - PROCEDURE Intersection*(set1, set2: ARRAY OF SET; VAR result: ARRAY OF SET); + PROCEDURE Intersection*(set1, set2: ARRAY OF Types.Set; VAR result: ARRAY OF Types.Set); VAR - index: INTEGER; + index: Types.Int32; BEGIN ASSERT((LEN(result) = LEN(set1)) & (LEN(result) = LEN(set2))); index := 0; @@ -102,9 +103,9 @@ MODULE ulmSets; END; END Intersection; - PROCEDURE SymDifference*(set1, set2: ARRAY OF SET; VAR result: ARRAY OF SET); + PROCEDURE SymDifference*(set1, set2: ARRAY OF Types.Set; VAR result: ARRAY OF Types.Set); VAR - index: INTEGER; + index: Types.Int32; BEGIN ASSERT((LEN(result) = LEN(set1)) & (LEN(result) = LEN(set2))); index := 0; @@ -114,9 +115,9 @@ MODULE ulmSets; END; END SymDifference; - PROCEDURE Union*(set1, set2: ARRAY OF SET; VAR result: ARRAY OF SET); + PROCEDURE Union*(set1, set2: ARRAY OF Types.Set; VAR result: ARRAY OF Types.Set); VAR - index: INTEGER; + index: Types.Int32; BEGIN ASSERT((LEN(result) = LEN(set1)) & (LEN(result) = LEN(set2))); index := 0; @@ -126,9 +127,9 @@ MODULE ulmSets; END; END Union; - PROCEDURE Difference*(set1, set2: ARRAY OF SET; VAR result: ARRAY OF SET); + PROCEDURE Difference*(set1, set2: ARRAY OF Types.Set; VAR result: ARRAY OF Types.Set); VAR - index: INTEGER; + index: Types.Int32; BEGIN ASSERT((LEN(result) = LEN(set1)) & (LEN(result) = LEN(set2))); index := 0; @@ -138,9 +139,9 @@ MODULE ulmSets; END; END Difference; - PROCEDURE Equal*(set1, set2: ARRAY OF SET) : BOOLEAN; + PROCEDURE Equal*(set1, set2: ARRAY OF Types.Set) : BOOLEAN; VAR - index: INTEGER; + index: Types.Int32; BEGIN index := 0; WHILE (index < LEN(set1)) & (index < LEN(set2)) DO @@ -164,9 +165,9 @@ MODULE ulmSets; RETURN TRUE END Equal; - PROCEDURE Subset*(set1, set2: ARRAY OF SET) : BOOLEAN; + PROCEDURE Subset*(set1, set2: ARRAY OF Types.Set) : BOOLEAN; VAR - index: INTEGER; + index: Types.Int32; BEGIN index := 0; WHILE (index < LEN(set1)) & (index < LEN(set2)) DO @@ -184,17 +185,17 @@ MODULE ulmSets; RETURN TRUE END Subset; - PROCEDURE Card*(set: ARRAY OF SET) : INTEGER; + PROCEDURE Card*(set: ARRAY OF Types.Set) : Types.Int32; VAR - index: INTEGER; - i: INTEGER; - card: INTEGER; + index: Types.Int32; + i: Types.Int32; + card: Types.Int32; BEGIN card := 0; index := 0; WHILE index < LEN(set) DO i := 0; - WHILE i <= MAX(SET) DO + WHILE i <= MAX(Types.Set) DO IF i IN set[index] THEN INC(card); END; diff --git a/src/library/ulm/ulmStreamDisciplines.Mod b/src/library/ulm/ulmStreamDisciplines.Mod index 522f9cda..32f56bfe 100644 --- a/src/library/ulm/ulmStreamDisciplines.Mod +++ b/src/library/ulm/ulmStreamDisciplines.Mod @@ -35,7 +35,7 @@ MODULE ulmStreamDisciplines; (* definition of general-purpose disciplines for streams *) - IMPORT ASCII := ulmASCII, Disciplines := ulmIndirectDisciplines, Events := ulmEvents, Sets := ulmSets, Streams := ulmStreams, SYSTEM; + IMPORT ASCII := ulmASCII, Disciplines := ulmIndirectDisciplines, Events := ulmEvents, Sets := ulmSets, Streams := ulmStreams, SYSTEM, Types := ulmTypes; TYPE LineTerminator* = ARRAY 4 OF CHAR; @@ -51,7 +51,7 @@ MODULE ulmStreamDisciplines; fieldseps: Sets.CharSet; fieldsep: CHAR; (* one of them *) whitespace: Sets.CharSet; - indentwidth: INTEGER; + indentwidth: Types.Int32; END; VAR @@ -61,7 +61,7 @@ MODULE ulmStreamDisciplines; defaultFieldSep: CHAR; defaultLineTerm: LineTerminator; defaultWhiteSpace: Sets.CharSet; - defaultIndentWidth: INTEGER; + defaultIndentWidth: Types.Int32; PROCEDURE InitDiscipline(VAR disc: Disciplines.Discipline); VAR @@ -194,7 +194,7 @@ MODULE ulmStreamDisciplines; Disciplines.Add(s, disc); END SetWhiteSpace; - PROCEDURE SetIndentationWidth*(s: Streams.Stream; indentwidth: INTEGER); + PROCEDURE SetIndentationWidth*(s: Streams.Stream; indentwidth: Types.Int32); VAR disc: Disciplines.Discipline; BEGIN @@ -207,7 +207,7 @@ MODULE ulmStreamDisciplines; END; END SetIndentationWidth; - PROCEDURE GetIndentationWidth*(s: Streams.Stream; VAR indentwidth: INTEGER); + PROCEDURE GetIndentationWidth*(s: Streams.Stream; VAR indentwidth: Types.Int32); VAR disc: Disciplines.Discipline; BEGIN @@ -218,7 +218,7 @@ MODULE ulmStreamDisciplines; END; END GetIndentationWidth; - PROCEDURE IncrIndentationWidth*(s: Streams.Stream; incr: INTEGER); + PROCEDURE IncrIndentationWidth*(s: Streams.Stream; incr: Types.Int32); VAR disc: Disciplines.Discipline; BEGIN diff --git a/src/library/ulm/ulmStreams.Mod b/src/library/ulm/ulmStreams.Mod index bb55c3e6..37f25dfd 100644 --- a/src/library/ulm/ulmStreams.Mod +++ b/src/library/ulm/ulmStreams.Mod @@ -144,10 +144,10 @@ MODULE ulmStreams; Address* = Types.Address; Count* = Types.Count; Byte* = Types.Byte; - Whence* = SHORTINT; (* Whence = (fromStart, fromPos, fromEnd); *) - CapabilitySet* = SET; (* OF Capability; *) - BufMode* = SHORTINT; - ErrorCode* = SHORTINT; + Whence* = Types.Int8; (* Whence = (fromStart, fromPos, fromEnd); *) + CapabilitySet* = Types.Set; (* OF Capability; *) + BufMode* = Types.Int8; + ErrorCode* = Types.Int8; Stream* = POINTER TO StreamRec; Message* = RECORD (Objects.ObjectRec) END; @@ -185,8 +185,8 @@ MODULE ulmStreams; BufferPool = POINTER TO BufferPoolRec; BufferPoolRec = RECORD - maxbuf: INTEGER; (* maximal number of buffers to be used *) - nbuf: INTEGER; (* number of buffers in use *) + maxbuf: Types.Int32; (* maximal number of buffers to be used *) + nbuf: Types.Int32; (* number of buffers in use *) bucket: BucketTable; (* list of all buffers sorted after the last access time; tail points to the buffer most recently accessed @@ -230,7 +230,7 @@ MODULE ulmStreams; (Services.ObjectRec) (* following components are set after i/o-operations *) count*: Count; (* resulting count of last operation *) - errors*: INTEGER; (* incremented for each error; may be set to 0 *) + errors*: Types.Int32; (* incremented for each error; may be set to 0 *) error*: BOOLEAN; (* last operation successful? *) lasterror*: ErrorCode; (* error code of last error *) eof*: BOOLEAN; (* last read-operation with count=0 returned *) @@ -367,7 +367,7 @@ MODULE ulmStreams; PROCEDURE InitBufPool(s: Stream); VAR - index: INTEGER; + index: Types.Int32; BEGIN s.bufpool.maxbuf := 16; (* default size *) s.bufpool.nbuf := 0; (* currently, no buffers are allocated *) @@ -379,7 +379,7 @@ MODULE ulmStreams; END; END InitBufPool; - PROCEDURE HashValue(pos: Count) : INTEGER; + PROCEDURE HashValue(pos: Count) : Types.Int32; (* HashValue returns a hash value for pos *) BEGIN RETURN SHORT(pos DIV bufsize) MOD hashtabsize @@ -387,7 +387,7 @@ MODULE ulmStreams; PROCEDURE FindBuffer(s: Stream; pos: Count; VAR buf: Buffer) : BOOLEAN; VAR - index: INTEGER; + index: Types.Int32; bp: Buffer; BEGIN index := HashValue(pos); @@ -410,11 +410,11 @@ MODULE ulmStreams; buf: Buffer; pos: Count; (* buffer boundary for s.pos *) posindex: Count; (* buf[posindex] corresponds to s.pos *) - index: INTEGER; (* index into bucket table of the buffer pool *) + index: Types.Int32; (* index into bucket table of the buffer pool *) PROCEDURE InitBuf(buf: Buffer); VAR - index: INTEGER; (* of bucket table *) + index: Types.Int32; (* of bucket table *) BEGIN buf.ok := TRUE; buf.pos := pos; @@ -612,7 +612,7 @@ MODULE ulmStreams; in.tiedStream := out; END Tie; - PROCEDURE SetBufferPoolSize*(s: Stream; nbuf: INTEGER); + PROCEDURE SetBufferPoolSize*(s: Stream; nbuf: Types.Int32); BEGIN s.error := FALSE; IF SYS.TAS(s.lock) THEN @@ -624,7 +624,7 @@ MODULE ulmStreams; s.lock := FALSE; END SetBufferPoolSize; - PROCEDURE GetBufferPoolSize*(s: Stream; VAR nbuf: INTEGER); + PROCEDURE GetBufferPoolSize*(s: Stream; VAR nbuf: Types.Int32); BEGIN s.error := FALSE; CASE s.bufmode OF diff --git a/src/library/ulm/ulmStrings.Mod b/src/library/ulm/ulmStrings.Mod index 19b64395..56785bf9 100644 --- a/src/library/ulm/ulmStrings.Mod +++ b/src/library/ulm/ulmStrings.Mod @@ -64,7 +64,7 @@ MODULE ulmStrings; posOutside* = 3; (* trunc failure: position beyond trunc pos *) errorcodes* = 4; TYPE - ErrorCode* = SHORTINT; + ErrorCode* = Types.Int8; Event* = POINTER TO EventRec; EventRec* = RECORD @@ -91,13 +91,13 @@ MODULE ulmStrings; (* ======= string to stream operations =========================== *) PROCEDURE WritePart*(stream: Streams.Stream; string: ARRAY OF CHAR; - sourceIndex: LONGINT); + sourceIndex: Types.Int32); (* seek to position 0 of `stream' and copy string[sourceIndex..] to it; the file pointer of `stream' is left on position 0 *) VAR - index: LONGINT; + index: Types.Int32; BEGIN IF ~Streams.Seek(stream, 0, Streams.fromStart) OR ~Streams.Trunc(stream, 0) THEN @@ -122,12 +122,12 @@ MODULE ulmStrings; (* ======= stream to string operations =========================== *) - PROCEDURE ReadPart*(VAR string: ARRAY OF CHAR; destIndex: LONGINT; + PROCEDURE ReadPart*(VAR string: ARRAY OF CHAR; destIndex: Types.Int32; stream: Streams.Stream); (* like `Read' but fill string[destIndex..] *) VAR - len: LONGINT; - endIndex: LONGINT; + len: Types.Int32; + endIndex: Types.Int32; BEGIN len := LEN(string); IF Streams.Seek(stream, 0, Streams.fromStart) & (destIndex < len) THEN @@ -160,8 +160,8 @@ MODULE ulmStrings; PROCEDURE Copy*(VAR destination: ARRAY OF CHAR; source: ARRAY OF CHAR); VAR - index: LONGINT; - minlen: LONGINT; + index: Types.Int32; + minlen: Types.Int32; BEGIN minlen := LEN(destination); IF minlen > LEN(source) THEN @@ -180,8 +180,8 @@ MODULE ulmStrings; destination[index] := 0X; END Copy; - PROCEDURE PartCopy*(VAR destination: ARRAY OF CHAR; destIndex: LONGINT; - source: ARRAY OF CHAR; sourceIndex: LONGINT); + PROCEDURE PartCopy*(VAR destination: ARRAY OF CHAR; destIndex: Types.Int32; + source: ARRAY OF CHAR; sourceIndex: Types.Int32); (* copy source[sourceIndex..] to destination[destIndex..] *) BEGIN WHILE (destIndex+1 < LEN(destination)) & @@ -195,10 +195,10 @@ MODULE ulmStrings; END; END PartCopy; - PROCEDURE Len*(string: ARRAY OF CHAR) : LONGINT; + PROCEDURE Len*(string: ARRAY OF CHAR) : Types.Int32; (* returns the number of characters (without terminating 0X) *) VAR - len: LONGINT; + len: Types.Int32; BEGIN len := 0; WHILE (len < LEN(string)) & (string[len] # 0X) DO @@ -316,7 +316,7 @@ MODULE ulmStrings; PROCEDURE Flush(s: Streams.Stream) : BOOLEAN; VAR - len: LONGINT; + len: Types.Int32; ch: CHAR; BEGIN WITH s: Stream DO diff --git a/src/library/ulm/ulmSysConversions.Mod b/src/library/ulm/ulmSysConversions.Mod index 4da16095..babdab5d 100644 --- a/src/library/ulm/ulmSysConversions.Mod +++ b/src/library/ulm/ulmSysConversions.Mod @@ -38,7 +38,7 @@ MODULE ulmSysConversions; (* convert Oberon records to/from C structures *) IMPORT Events := ulmEvents, Objects := ulmObjects, Priorities := ulmPriorities, Streams := ulmStreams, Strings := ulmStrings, - SYS := SYSTEM, SysTypes := ulmSysTypes, Texts := ulmTexts; + SYS := SYSTEM, SysTypes := ulmSysTypes, Texts := ulmTexts, Types := ulmTypes; TYPE Address* = SysTypes.Address; @@ -66,10 +66,10 @@ MODULE ulmSysConversions; b: SYS.BYTE B: BOOLEAN c: CHAR - s: SHORTINT - i: INTEGER - l: LONGINT - S: SET + s: Types.Int8 + i: Types.Int32 + l: Types.Int32 + S: Types.Set C data types: @@ -90,10 +90,10 @@ MODULE ulmSysConversions; Rec = RECORD - a, b: INTEGER; + a, b: Types.Int32; c: CHAR; - s: SET; - f: ARRAY 3 OF INTEGER; + s: Types.Set; + f: ARRAY 3 OF Types.Int32; END; to @@ -118,7 +118,7 @@ MODULE ulmSysConversions; unsigned = 0; (* suppress sign extension *) boolean = 1; (* convert anything # 0 to 1 *) TYPE - Flags = SET; + Flags = Types.Set; Event* = POINTER TO EventRec; EventRec* = RECORD @@ -134,9 +134,9 @@ MODULE ulmSysConversions; (* 1: Oberon type 2: C type *) - type1, type2: CHAR; length: INTEGER; left: INTEGER; + type1, type2: CHAR; length: Types.Int32; left: Types.Int32; offset1, offset2: Address; - size1, size2: Address; elementsleft: INTEGER; flags: Flags; + size1, size2: Address; elementsleft: Types.Int32; flags: Flags; END; Format* = POINTER TO FormatRec; @@ -192,7 +192,7 @@ MODULE ulmSysConversions; RETURN (ch >= "0") & (ch <= "9") END IsDigit; - PROCEDURE ReadInt(cv: ConvStream; VAR i: INTEGER); + PROCEDURE ReadInt(cv: ConvStream; VAR i: Types.Int32); BEGIN i := 0; REPEAT @@ -219,10 +219,10 @@ MODULE ulmSysConversions; PROCEDURE ScanConv(cv: ConvStream; VAR type1, type2: CHAR; - VAR length: INTEGER) : BOOLEAN; + VAR length: Types.Int32) : BOOLEAN; VAR - i: INTEGER; - factor: INTEGER; + i: Types.Int32; + factor: Types.Int32; BEGIN IF cv.left > 0 THEN type1 := cv.type1; @@ -274,8 +274,8 @@ MODULE ulmSysConversions; PROCEDURE Align(VAR offset: Address; boundary: Address); BEGIN - IF SYS.VAL (INTEGER, offset) MOD SYS.VAL (INTEGER, boundary) # 0 THEN - offset := SYS.VAL (INTEGER, offset) + (SYS.VAL (INTEGER, boundary) - SYS.VAL (INTEGER, offset) MOD SYS.VAL (INTEGER, boundary)); + IF SYS.VAL (Types.Int32, offset) MOD SYS.VAL (Types.Int32, boundary) # 0 THEN + offset := SYS.VAL (Types.Int32, offset) + (SYS.VAL (Types.Int32, boundary) - SYS.VAL (Types.Int32, offset) MOD SYS.VAL (Types.Int32, boundary)); END; END Align; @@ -285,28 +285,28 @@ MODULE ulmSysConversions; VAR flags: Flags) : BOOLEAN; VAR type1, type2: CHAR; - length: INTEGER; + length: Types.Int32; align: BOOLEAN; - boundary: INTEGER; + boundary: Types.Int32; BEGIN IF cv.elementsleft > 0 THEN DEC(cv.elementsleft); (* Oberon type *) IF size1 > SIZE(SYS.BYTE) THEN - Align(cv.offset1, SIZE(INTEGER)); + Align(cv.offset1, SIZE(Types.Int32)); END; - offset1 := cv.offset1; cv.offset1 := SYS.VAL (INTEGER, cv.offset1) + size1; + offset1 := cv.offset1; cv.offset1 := SYS.VAL (Types.Int32, cv.offset1) + size1; size1 := cv.size1; size2 := cv.size2; flags := cv.flags; IF (size1 > 0) & (cv.elementsleft = 0) THEN - Align(cv.offset1, SIZE(INTEGER)); + Align(cv.offset1, SIZE(Types.Int32)); END; (* C type *) IF size2 > 1 THEN Align(cv.offset2, 2); END; - offset2 := cv.offset2; cv.offset2 := SYS.VAL (INTEGER, cv.offset2) + SYS.VAL (INTEGER, size2); + offset2 := cv.offset2; cv.offset2 := SYS.VAL (Types.Int32, cv.offset2) + SYS.VAL (Types.Int32, size2); RETURN TRUE END; @@ -318,21 +318,21 @@ MODULE ulmSysConversions; | "b": size1 := SIZE(SYS.BYTE); INCL(flags, unsigned); | "B": size1 := SIZE(BOOLEAN); INCL(flags, boolean); | "c": size1 := SIZE(CHAR); INCL(flags, unsigned); - | "s": size1 := SIZE(SHORTINT); - | "i": size1 := SIZE(INTEGER); - | "l": size1 := SIZE(LONGINT); - | "S": size1 := SIZE(SET); INCL(flags, unsigned); + | "s": size1 := SIZE(Types.Int8); + | "i": size1 := SIZE(Types.Int32); + | "l": size1 := SIZE(Types.Int32); + | "S": size1 := SIZE(Types.Set); INCL(flags, unsigned); | "-": size1 := 0; ELSE Error(cv, "bad Oberon type specifier"); RETURN FALSE END; IF size1 > 0 THEN IF length > 0 THEN - Align(cv.offset1, SIZE(INTEGER)); + Align(cv.offset1, SIZE(Types.Int32)); ELSIF size1 > SIZE(SYS.BYTE) THEN - Align(cv.offset1, SIZE(INTEGER)); + Align(cv.offset1, SIZE(Types.Int32)); END; END; - offset1 := cv.offset1; cv.offset1 := SYS.VAL (INTEGER, cv.offset1) + size1; + offset1 := cv.offset1; cv.offset1 := SYS.VAL (Types.Int32, cv.offset1) + size1; (* C type *) CASE type2 OF @@ -352,7 +352,7 @@ MODULE ulmSysConversions; IF size2 > 1 THEN Align(cv.offset2, size2); END; - offset2 := cv.offset2; cv.offset2 := SYS.VAL (INTEGER, cv.offset2) + SYS.VAL (INTEGER, size2); + offset2 := cv.offset2; cv.offset2 := SYS.VAL (Types.Int32, cv.offset2) + SYS.VAL (Types.Int32, size2); cv.size1 := size1; cv.size2 := size2; IF length > 0 THEN @@ -371,7 +371,7 @@ MODULE ulmSysConversions; Pointer = POINTER TO Bytes; VAR dest, source: Pointer; - dindex, sindex: INTEGER; + dindex, sindex: Types.Int32; nonzero: BOOLEAN; fill : CHAR; BEGIN @@ -383,7 +383,7 @@ MODULE ulmSysConversions; nonzero := FALSE; WHILE ssize > 0 DO nonzero := nonzero OR (source[sindex] # 0X); - INC(sindex); ssize := SYS.VAL (INTEGER, ssize) - 1; + INC(sindex); ssize := SYS.VAL (Types.Int32, ssize) - 1; END; IF dsize > 0 THEN IF nonzero THEN @@ -395,12 +395,12 @@ MODULE ulmSysConversions; END; WHILE dsize > 0 DO dest[dindex] := 0X; - dsize := SYS.VAL (INTEGER, dsize) - 1; INC(dindex); + dsize := SYS.VAL (Types.Int32, dsize) - 1; INC(dindex); END; ELSE WHILE (dsize > 0) & (ssize > 0) DO dest[dindex] := source[sindex]; - ssize := SYS.VAL (INTEGER, ssize) - 1; + ssize := SYS.VAL (Types.Int32, ssize) - 1; dsize := dsize - 1; INC(dindex); INC(sindex); END; @@ -415,7 +415,7 @@ MODULE ulmSysConversions; END; WHILE dsize > 0 DO dest[dindex] := fill; - dsize := SYS.VAL (INTEGER, dsize) - 1; INC(dindex); + dsize := SYS.VAL (Types.Int32, dsize) - 1; INC(dindex); END; END; END; @@ -475,7 +475,7 @@ MODULE ulmSysConversions; WHILE ReadConv(cv, offset1, offset2, size1, size2, flags) DO END; Close(cv); size := offset1 + size1; - Align(size, SIZE(INTEGER)); + Align(size, SIZE(Types.Int32)); RETURN size END OberonSize; diff --git a/src/library/ulm/ulmSysErrors.Mod b/src/library/ulm/ulmSysErrors.Mod index 0e81818d..ce535744 100644 --- a/src/library/ulm/ulmSysErrors.Mod +++ b/src/library/ulm/ulmSysErrors.Mod @@ -1,6 +1,6 @@ MODULE ulmSysErrors; - IMPORT Errors := ulmErrors, Events := ulmEvents, Priorities := ulmPriorities, RelatedEvents := ulmRelatedEvents, Streams := ulmStreams, Strings := ulmStrings, Sys := ulmSys; + IMPORT Errors := ulmErrors, Events := ulmEvents, Priorities := ulmPriorities, RelatedEvents := ulmRelatedEvents, Streams := ulmStreams, Strings := ulmStrings, Sys := ulmSys, Types := ulmTypes; CONST perm* = 1; @@ -138,8 +138,8 @@ MODULE ulmSysErrors; EventRec* = RECORD (Events.EventRec) - errno*: (*INTEGER*)LONGINT; - syscall*: (*INTEGER*)LONGINT; (* number of system call *) + errno*: (*Types.Int32*)Types.Int32; + syscall*: (*Types.Int32*)Types.Int32; (* number of system call *) text*: ARRAY textlen OF CHAR; END; @@ -150,7 +150,7 @@ MODULE ulmSysErrors; syserror*: ARRAY ncodes OF Events.EventType; PROCEDURE Raise*(errors: RelatedEvents.Object; - errno, syscall: (*INTEGER*)LONGINT; text: ARRAY OF CHAR); (* in ulm's system INTEGER and LONGINT have the same size *) + errno, syscall: (*Types.Int32*)Types.Int32; text: ARRAY OF CHAR); (* in ulm's system Types.Int32 and Types.Int32 have the same size *) (* raises the events syserrors and syserrors[syscall]; `text' contains additional information (e.g. filenames); further, the syserrors[syscall] event is passed to @@ -192,9 +192,9 @@ MODULE ulmSysErrors; IF ~Streams.WriteByte(s, ch) THEN END; END Write; - PROCEDURE WriteInt(intval: LONGINT); + PROCEDURE WriteInt(intval: Types.Int32); VAR - rest: LONGINT; + rest: Types.Int32; BEGIN rest := intval DIV 10; IF rest > 0 THEN @@ -231,7 +231,7 @@ MODULE ulmSysErrors; PROCEDURE InitEvents; VAR - errno: INTEGER; + errno: Types.Int32; BEGIN syserror[0] := NIL; errno := 1; @@ -447,11 +447,11 @@ BEGIN message[netdown] := "Network is down"; name[netunreach] := "ENETUNREACH"; message[netunreach] := "Network is unreachable"; - name[netreset] := "ENETRESET"; + name[netreset] := "ENETRETypes.Set"; message[netreset] := "Network dropped connection because of reset"; name[connaborted] := "ECONNABORTED"; message[connaborted] := "Software caused connection abort"; - name[connreset] := "ECONNRESET"; + name[connreset] := "ECONNRETypes.Set"; message[connreset] := "Connection reset by peer"; name[nobufs] := "ENOBUFS"; message[nobufs] := "No buffer space available"; diff --git a/src/library/ulm/ulmSysIO.Mod b/src/library/ulm/ulmSysIO.Mod index 2a22d29f..3274efda 100644 --- a/src/library/ulm/ulmSysIO.Mod +++ b/src/library/ulm/ulmSysIO.Mod @@ -33,7 +33,7 @@ MODULE ulmSysIO; IMPORT RelatedEvents := ulmRelatedEvents, Sys := ulmSys, SYS := SYSTEM, ulmSYSTEM, SysErrors := ulmSysErrors, SysTypes := ulmSysTypes, - Platform; + Platform, Types := ulmTypes; CONST (* file control options: arguments of Fcntl and Open *) @@ -79,11 +79,11 @@ MODULE ulmSysIO; File* = SysTypes.File; (* file descriptor *) Address* = SysTypes.Address; Count* = SysTypes.Count; - Protection* = LONGINT; - Whence* = LONGINT; + Protection* = Types.Int32; + Whence* = Types.Int32; PROCEDURE OpenCreat*(VAR fd: File; - filename: ARRAY OF CHAR; options: SET; + filename: ARRAY OF CHAR; options: Types.Set; protection: Protection; errors: RelatedEvents.Object; retry: BOOLEAN; VAR interrupted: BOOLEAN) : BOOLEAN; @@ -110,7 +110,7 @@ MODULE ulmSysIO; END OpenCreat; PROCEDURE Open*(VAR fd: File; - filename: ARRAY OF CHAR; options: SET; + filename: ARRAY OF CHAR; options: Types.Set; errors: RelatedEvents.Object; retry: BOOLEAN; VAR interrupted: BOOLEAN) : BOOLEAN; (* the filename must be 0X-terminated *) @@ -196,7 +196,7 @@ MODULE ulmSysIO; PROCEDURE Seek*(fd: File; offset: Count; whence: Whence; errors: RelatedEvents.Object) : BOOLEAN; VAR - error: Platform.ErrorCode; relativity: INTEGER; + error: Platform.ErrorCode; relativity: Types.Int16; BEGIN CASE whence OF |fromPos: relativity := Platform.SeekCur @@ -216,7 +216,7 @@ MODULE ulmSysIO; PROCEDURE Tell*(fd: File; VAR offset: Count; errors: RelatedEvents.Object) : BOOLEAN; VAR - d0, d1: LONGINT; + d0, d1: Types.Int32; BEGIN IF ulmSYSTEM.UNIXCALL(Sys.lseek, d0, d1, fd, 0, fromPos) THEN offset := d0; @@ -232,17 +232,17 @@ MODULE ulmSysIO; sizeofStructTermIO = 18; tcgeta = 00005405H; VAR - d0, d1: LONGINT; + d0, d1: Types.Int32; buf: ARRAY 32 OF SYS.BYTE; (* Should be more than sufficient *) BEGIN (* following system call fails for non-tty's *) RETURN ulmSYSTEM.UNIXCALL(Sys.ioctl, d0, d1, fd, tcgeta, SYS.ADR(buf)) END Isatty; - PROCEDURE Fcntl*(fd: File; request: INTEGER; VAR arg: LONGINT; + PROCEDURE Fcntl*(fd: File; request: Types.Int32; VAR arg: Types.Int32; errors: RelatedEvents.Object; retry: BOOLEAN; VAR interrupted: BOOLEAN) : BOOLEAN; VAR - d0, d1: LONGINT; + d0, d1: Types.Int32; BEGIN interrupted := FALSE; LOOP @@ -261,15 +261,15 @@ MODULE ulmSysIO; END; END Fcntl; - PROCEDURE FcntlSet*(fd: File; request: INTEGER; flags: SET; + PROCEDURE FcntlSet*(fd: File; request: Types.Int32; flags: Types.Set; errors: RelatedEvents.Object; retry: BOOLEAN; VAR interrupted: BOOLEAN) : BOOLEAN; VAR - d0, d1: LONGINT; + d0, d1: Types.Int32; BEGIN interrupted := FALSE; LOOP - IF ulmSYSTEM.UNIXCALL(Sys.fcntl, d0, d1, fd, request, SYS.VAL(LONGINT, flags)) THEN + IF ulmSYSTEM.UNIXCALL(Sys.fcntl, d0, d1, fd, request, SYS.VAL(Types.Int32, flags)) THEN RETURN TRUE ELSE IF d0 = SysErrors.intr THEN @@ -283,10 +283,10 @@ MODULE ulmSysIO; END; END FcntlSet; - PROCEDURE FcntlGet*(fd: File; request: INTEGER; VAR flags: SET; + PROCEDURE FcntlGet*(fd: File; request: Types.Int32; VAR flags: Types.Set; errors: RelatedEvents.Object) : BOOLEAN; VAR - d0, d1: LONGINT; + d0, d1: Types.Int32; BEGIN IF ulmSYSTEM.UNIXCALL(Sys.fcntl, d0, d1, fd, request, 0) THEN ulmSYSTEM.WMOVE(SYS.ADR(d0), SYS.ADR(flags), 1); @@ -300,8 +300,8 @@ MODULE ulmSysIO; PROCEDURE Dup*(fd: File; VAR newfd: File; errors: RelatedEvents.Object) : BOOLEAN; VAR - d0, d1: LONGINT; - a0, a1: LONGINT; + d0, d1: Types.Int32; + a0, a1: Types.Int32; BEGIN a0 := 0; a1 := 0; (* Initialised to disable compiler warning. *) IF ulmSYSTEM.UNIXCALL(Sys.dup, d0, d1, fd, a0, a1) THEN @@ -315,8 +315,8 @@ MODULE ulmSysIO; PROCEDURE Dup2*(fd, newfd: File; errors: RelatedEvents.Object) : BOOLEAN; VAR - d0, d1: LONGINT; - a0, a1: LONGINT; + d0, d1: Types.Int32; + a0, a1: Types.Int32; fd2: File; interrupted: BOOLEAN; BEGIN @@ -338,9 +338,9 @@ MODULE ulmSysIO; PROCEDURE Pipe*(VAR readfd, writefd: File; errors: RelatedEvents.Object) : BOOLEAN; VAR - d0, d1: LONGINT; - a0, a1: LONGINT; - fds : ARRAY 2 OF (*File*)INTEGER; (* it needs int pipefd[2], and int is 4 bytes long on x86_64 -- noch *) + d0, d1: Types.Int32; + a0, a1: Types.Int32; + fds : ARRAY 2 OF (*File*)Types.Int32; (* it needs int pipefd[2], and int is 4 bytes long on x86_64 -- noch *) BEGIN a0 := 0; a1 := 0; (* Initialised to disable compiler warning. *) IF ulmSYSTEM.UNIXCALL(Sys.pipe, d0, d1, SYS.ADR (fds), a0, a1) THEN diff --git a/src/library/ulm/ulmSysStat.Mod b/src/library/ulm/ulmSysStat.Mod index f9aaa507..addb33f2 100644 --- a/src/library/ulm/ulmSysStat.Mod +++ b/src/library/ulm/ulmSysStat.Mod @@ -40,7 +40,7 @@ MODULE ulmSysStat; (* examine inode: stat(2) and fstat(2) *) IMPORT RelatedEvents := ulmRelatedEvents, Sys := ulmSys, SYS := SYSTEM, uSYS := ulmSYSTEM, SysConversions := ulmSysConversions, SysErrors := ulmSysErrors, - SysTypes := ulmSysTypes; + SysTypes := ulmSysTypes, Types := ulmTypes; CONST (* file mode: @@ -96,17 +96,17 @@ MODULE ulmSysStat; device*: SysTypes.Device; (* ID of device containing a directory entry for this file *) inode*: SysTypes.Inode; (* inode number *) - mode*: SET; (* file mode; see mknod(2) *) - nlinks*: LONGINT; (* number of links *) - uid*: LONGINT; (* user id of the file's owner *) - gid*: LONGINT; (* group id of the file's group *) + mode*: Types.Set; (* file mode; see mknod(2) *) + nlinks*: Types.Int32; (* number of links *) + uid*: Types.Int32; (* user id of the file's owner *) + gid*: Types.Int32; (* group id of the file's group *) rdev*: SysTypes.Device; (* ID of device. this entry is defined only for character special or block special files *) size*: SysTypes.Offset; (* file size in bytes *) (* Blocks and blksize are not available on all platforms. - blksize*: LONGINT; (* preferred blocksize *) - blocks*: LONGINT; (* # of blocks allocated *) + blksize*: Types.Int32; (* preferred blocksize *) + blocks*: Types.Int32; (* # of blocks allocated *) *) atime*: SysTypes.Time; (* time of last access *) @@ -119,27 +119,27 @@ MODULE ulmSysStat; PROCEDURE -Aerrno '#include '; PROCEDURE -structstats "struct stat s"; - PROCEDURE -statdev(): LONGINT "(LONGINT)s.st_dev"; - PROCEDURE -statino(): LONGINT "(LONGINT)s.st_ino"; - PROCEDURE -statmode(): LONGINT "(LONGINT)s.st_mode"; - PROCEDURE -statnlink(): LONGINT "(LONGINT)s.st_nlink"; - PROCEDURE -statuid(): LONGINT "(LONGINT)s.st_uid"; - PROCEDURE -statgid(): LONGINT "(LONGINT)s.st_gid"; - PROCEDURE -statrdev(): LONGINT "(LONGINT)s.st_rdev"; - PROCEDURE -statsize(): LONGINT "(LONGINT)s.st_size"; - PROCEDURE -statatime(): LONGINT "(LONGINT)s.st_atime"; - PROCEDURE -statmtime(): LONGINT "(LONGINT)s.st_mtime"; - PROCEDURE -statctime(): LONGINT "(LONGINT)s.st_ctime"; + PROCEDURE -statdev(): Types.Int32 "(INT32)s.st_dev"; + PROCEDURE -statino(): Types.Int32 "(INT32)s.st_ino"; + PROCEDURE -statmode(): Types.Int32 "(INT32)s.st_mode"; + PROCEDURE -statnlink(): Types.Int32 "(INT32)s.st_nlink"; + PROCEDURE -statuid(): Types.Int32 "(INT32)s.st_uid"; + PROCEDURE -statgid(): Types.Int32 "(INT32)s.st_gid"; + PROCEDURE -statrdev(): Types.Int32 "(INT32)s.st_rdev"; + PROCEDURE -statsize(): Types.Int32 "(INT32)s.st_size"; + PROCEDURE -statatime(): Types.Int32 "(INT32)s.st_atime"; + PROCEDURE -statmtime(): Types.Int32 "(INT32)s.st_mtime"; + PROCEDURE -statctime(): Types.Int32 "(INT32)s.st_ctime"; (* Blocks and blksize are not available on all platforms. - PROCEDURE -statblksize(): LONGINT "(LONGINT)s.st_blksize"; - PROCEDURE -statblocks(): LONGINT "(LONGINT)s.st_blocks"; + PROCEDURE -statblksize(): Types.Int32 "(Types.Int32)s.st_blksize"; + PROCEDURE -statblocks(): Types.Int32 "(Types.Int32)s.st_blocks"; *) - PROCEDURE -fstat(fd: LONGINT): INTEGER "fstat(fd, &s)"; - PROCEDURE -stat (n: ARRAY OF CHAR): INTEGER "stat((char*)n, &s)"; + PROCEDURE -fstat(fd: Types.Int32): Types.Int32 "fstat(fd, &s)"; + PROCEDURE -stat (n: ARRAY OF CHAR): Types.Int32 "stat((char*)n, &s)"; - PROCEDURE -err(): INTEGER "errno"; + PROCEDURE -err(): Types.Int32 "errno"; PROCEDURE Stat*(path: ARRAY OF CHAR; VAR buf: StatRec; errors: RelatedEvents.Object): BOOLEAN; BEGIN @@ -147,7 +147,7 @@ MODULE ulmSysStat; IF stat(path) < 0 THEN SysErrors.Raise(errors, err(), Sys.newstat, path); RETURN FALSE END; buf.device := SYS.VAL(SysTypes.Device, statdev()); buf.inode := SYS.VAL(SysTypes.Inode, statino()); - buf.mode := SYS.VAL(SET, statmode()); + buf.mode := SYS.VAL(Types.Set, statmode()); buf.nlinks := statnlink(); buf.uid := statuid(); buf.gid := statgid(); @@ -166,10 +166,10 @@ MODULE ulmSysStat; PROCEDURE Fstat*(fd: SysTypes.File; VAR buf: StatRec; errors: RelatedEvents.Object): BOOLEAN; BEGIN structstats; - IF fstat(SYS.VAL(LONGINT, fd)) < 0 THEN SysErrors.Raise(errors, err(), Sys.newfstat, ""); RETURN FALSE END; + IF fstat(SYS.VAL(Types.Int32, fd)) < 0 THEN SysErrors.Raise(errors, err(), Sys.newfstat, ""); RETURN FALSE END; buf.device := SYS.VAL(SysTypes.Device, statdev()); buf.inode := SYS.VAL(SysTypes.Inode, statino()); - buf.mode := SYS.VAL(SET, statmode()); + buf.mode := SYS.VAL(Types.Set, statmode()); buf.nlinks := statnlink(); buf.uid := statuid(); buf.gid := statgid(); diff --git a/src/library/ulm/ulmSysTypes.Mod b/src/library/ulm/ulmSysTypes.Mod index 6d16ab4b..c757a5dc 100644 --- a/src/library/ulm/ulmSysTypes.Mod +++ b/src/library/ulm/ulmSysTypes.Mod @@ -40,12 +40,12 @@ MODULE ulmSysTypes; Byte* = Types.Byte; File* = Platform.FileHandle; - Offset* = LONGINT; - Device* = LONGINT; - Inode* = LONGINT; - Time* = LONGINT; + Offset* = Types.Int32; + Device* = Types.Int32; + Inode* = Types.Int32; + Time* = Types.Int32; - Word* = INTEGER; (* must have the size of C's int-type *) + Word* = Types.Int32; (* must have the size of C's int-type *) (* Note: linux supports wait4 but not waitid, i.e. these * constants aren't needed. *) @@ -64,7 +64,7 @@ MODULE ulmSysTypes; idAll = 7; (* all processes *) idLwpid = 8; (* an LWP identifier *) TYPE - IdType = INTEGER; (* idPid .. idLwpid *) + IdType = Types.Int32; (* idPid .. idLwpid *) *) END ulmSysTypes. diff --git a/src/library/ulm/ulmTCrypt.Mod b/src/library/ulm/ulmTCrypt.Mod index c35c7809..f31decda 100644 --- a/src/library/ulm/ulmTCrypt.Mod +++ b/src/library/ulm/ulmTCrypt.Mod @@ -36,7 +36,8 @@ MODULE ulmTCrypt; (* Michael Szczuka *) Events := ulmEvents, NetIO := ulmNetIO, PersistentObjects := ulmPersistentObjects, Random := ulmRandomGenerators, RelatedEvents := ulmRelatedEvents, Services := ulmServices, - Streams := ulmStreams, SYS := SYSTEM; + Streams := ulmStreams, SYS := SYSTEM, + Types := ulmTypes; CONST M = 16; (* size of an element of CC(M) [ring of Circular Convolution] *) @@ -59,8 +60,8 @@ MODULE ulmTCrypt; (* Michael Szczuka *) TYPE (* an element out of CC(M) *) - CCMElement = SET; - Exponent = ARRAY MaxVar OF SHORTINT; + CCMElement = Types.Set; + Exponent = ARRAY MaxVar OF Types.Int8; TYPE (* a polynomial with coefficients out of CC(M) *) @@ -161,7 +162,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *) ErrorEvent = POINTER TO ErrorEventRec; ErrorEventRec = RECORD (Events.EventRec) - errorcode : SHORTINT; + errorcode : Types.Int8; END; VAR @@ -176,7 +177,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *) PolFeld : ARRAY MaxTerms OF Polynom; (* used for sorting purposes *) PreEvalArg : ARRAY M OF TCryptInput; (* precomputed values to speed up evaluation of a polynomial *) - k : SHORTINT; (* simple counter during initialisation *) + k : Types.Int8; (* simple counter during initialisation *) error : Events.EventType; errormsg : ARRAY errorcodes OF Events.Message; @@ -191,7 +192,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *) errormsg[notRegular] := "element isn't regular"; END InitErrorHandling; - PROCEDURE Error(s: Streams.Stream; errorcode: SHORTINT); + PROCEDURE Error(s: Streams.Stream; errorcode: Types.Int8); VAR event: ErrorEvent; BEGIN @@ -208,7 +209,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *) (* tests x for regularity [a regular CCMElement contains an odd number of set bits]; returns TRUE when x is regular, FALSE otherwise *) VAR - res, i : SHORTINT; + res, i : Types.Int8; BEGIN i := 0; res := 0; @@ -225,7 +226,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *) (* compares x and y for equality; if x and y are equal TRUE is returned, FALSE otherwise *) VAR - i : SHORTINT; + i : Types.Int8; BEGIN i := 0; WHILE i < M DO @@ -240,7 +241,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *) PROCEDURE AddCCM (x, y: CCMElement; VAR z: CCMElement); (* add x and y in CC(M) *) VAR - i : SHORTINT; + i : Types.Int8; BEGIN z := NullCCM; i := 0; @@ -255,8 +256,8 @@ MODULE ulmTCrypt; (* Michael Szczuka *) PROCEDURE MulCCM (x, y: CCMElement; VAR z: CCMElement); (* multiply x and y in CC(M) *) VAR - i, j, diff : SHORTINT; - tmp : INTEGER; + i, j, diff : Types.Int8; + tmp : Types.Int32; BEGIN z := NullCCM; i := 0; @@ -283,7 +284,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *) UNTIL i>=M; END MulCCM; - PROCEDURE PowerCCM (x: CCMElement; exp: INTEGER; VAR z: CCMElement); + PROCEDURE PowerCCM (x: CCMElement; exp: Types.Int32; VAR z: CCMElement); (* raises x to the power exp in CC(M) *) VAR tmp : CCMElement; @@ -320,12 +321,12 @@ MODULE ulmTCrypt; (* Michael Szczuka *) UNTIL exp < 1; END PowerCCM; - PROCEDURE CreateCCM (VAR x: CCMElement; mode: SHORTINT); + PROCEDURE CreateCCM (VAR x: CCMElement; mode: Types.Int8); (* creates a random element out of CC(M) depending on mode which can be reg, sing or random; the result is in any case different from the zero *) VAR - i, SetBits: SHORTINT; + i, SetBits: Types.Int8; BEGIN x := NullCCM; REPEAT @@ -361,10 +362,10 @@ MODULE ulmTCrypt; (* Michael Szczuka *) (* ***** arithmetic functions for polynomials over CC(M) ***** *) - PROCEDURE LengthPolynom(p: Polynom) : INTEGER; + PROCEDURE LengthPolynom(p: Polynom) : Types.Int32; (* returns the number of terms which make up the polynomial p *) VAR - i : INTEGER; + i : Types.Int32; BEGIN i := 0; WHILE p # NIL DO @@ -378,7 +379,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *) (* tests the regularity of a polynomial [a polynomial is regular iff the # of regular coefficients is odd] *) VAR - regkoeffs : SHORTINT; + regkoeffs : Types.Int8; BEGIN regkoeffs := 0; WHILE p # NIL DO @@ -391,16 +392,16 @@ MODULE ulmTCrypt; (* Michael Szczuka *) RETURN (regkoeffs MOD 2) = 1; END RegulaerPolynom; - PROCEDURE CmpExp (exp1, exp2: Exponent) : SHORTINT; + PROCEDURE CmpExp (exp1, exp2: Exponent) : Types.Int8; (* compares two exponent vectors and returns 0 on equality, a positive value if exp1>exp2 and a negative value if exp1 0) & Streams.WriteByte(s, " ") DO @@ -180,12 +180,12 @@ MODULE ulmWrite; (* procedures writing to Streams.stdout *) - PROCEDURE Int*(int: LONGINT; width: LONGINT); + PROCEDURE Int*(int: Types.Int32; width: Types.Int32); BEGIN IntS(Streams.stdout, int, width); END Int; - PROCEDURE Real*(real: LONGREAL; width: LONGINT); + PROCEDURE Real*(real: Types.Real64; width: Types.Int32); (* write real in exponential format *) BEGIN RealS(Streams.stdout, real, width); diff --git a/src/tools/make/oberon.mk b/src/tools/make/oberon.mk index 796cb8d5..c852bd57 100644 --- a/src/tools/make/oberon.mk +++ b/src/tools/make/oberon.mk @@ -273,6 +273,7 @@ oocX11: ulm: @printf "\nMaking ulm library for -O$(MODEL)\n" + cd $(BUILDDIR)/$(MODEL); $(ROOTDIR)/$(OBECOMP) -Fs -O$(MODEL) ../../../src/library/ulm/ulmTypes.Mod cd $(BUILDDIR)/$(MODEL); $(ROOTDIR)/$(OBECOMP) -Fs -O$(MODEL) ../../../src/library/ulm/ulmObjects.Mod cd $(BUILDDIR)/$(MODEL); $(ROOTDIR)/$(OBECOMP) -Fs -O$(MODEL) ../../../src/library/ulm/ulmPriorities.Mod cd $(BUILDDIR)/$(MODEL); $(ROOTDIR)/$(OBECOMP) -Fs -O$(MODEL) ../../../src/library/ulm/ulmDisciplines.Mod @@ -284,7 +285,6 @@ ulm: cd $(BUILDDIR)/$(MODEL); $(ROOTDIR)/$(OBECOMP) -Fs -O$(MODEL) ../../../src/library/ulm/ulmResources.Mod cd $(BUILDDIR)/$(MODEL); $(ROOTDIR)/$(OBECOMP) -Fs -O$(MODEL) ../../../src/library/ulm/ulmForwarders.Mod cd $(BUILDDIR)/$(MODEL); $(ROOTDIR)/$(OBECOMP) -Fs -O$(MODEL) ../../../src/library/ulm/ulmRelatedEvents.Mod - cd $(BUILDDIR)/$(MODEL); $(ROOTDIR)/$(OBECOMP) -Fs -O$(MODEL) ../../../src/library/ulm/ulmTypes.Mod cd $(BUILDDIR)/$(MODEL); $(ROOTDIR)/$(OBECOMP) -Fs -O$(MODEL) ../../../src/library/ulm/ulmStreams.Mod cd $(BUILDDIR)/$(MODEL); $(ROOTDIR)/$(OBECOMP) -Fs -O$(MODEL) ../../../src/library/ulm/ulmStrings.Mod cd $(BUILDDIR)/$(MODEL); $(ROOTDIR)/$(OBECOMP) -Fs -O$(MODEL) ../../../src/library/ulm/ulmSysTypes.Mod