vishapoberon/compiler
1
0
Fork 0
mirror of https://github.com/vishapoberon/compiler.git synced 2026-04-05 23:22:25 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

ulm library compiled by fixing integer, longint, shortint and set sizes. -- noch

Browse source
This commit is contained in:
norayr 2016-11-30 19:39:26 +04:00
parent c549f5847b
commit 0e1c5fe498
39 changed files with 733 additions and 723 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/library/ulm/ulmAssertions.Mod
View file

@ -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;

12
src/library/ulm/ulmAsymmetricCiphers.Mod
View file

@ -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);

16
src/library/ulm/ulmBlockCiphers.Mod
View file

@ -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);

10
src/library/ulm/ulmCipherOps.Mod
View file

@ -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;

8
src/library/ulm/ulmCiphers.Mod
View file

@ -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;

8
src/library/ulm/ulmClocks.Mod
View file

@ -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

12
src/library/ulm/ulmConclusions.Mod
View file

@ -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

44
src/library/ulm/ulmConditions.Mod
View file

@ -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;

50
src/library/ulm/ulmConstStrings.Mod
View file

@ -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;

30
src/library/ulm/ulmEvents.Mod
View file

@ -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);*)

38
src/library/ulm/ulmIO.Mod
View file

@ -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

18
src/library/ulm/ulmIntOperations.Mod
View file

@ -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

56
src/library/ulm/ulmMC68881.Mod
View file

@ -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;

58
src/library/ulm/ulmNetIO.Mod
View file

@ -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

10
src/library/ulm/ulmOperations.Mod
View file

@ -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);

28
src/library/ulm/ulmPersistentObjects.Mod
View file

@ -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);

44
src/library/ulm/ulmPlotters.Mod
View file

@ -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);

292
src/library/ulm/ulmPrint.Mod
View file

@ -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.

4
src/library/ulm/ulmPriorities.Mod
View file

@ -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);

6
src/library/ulm/ulmProcess.Mod
View file

@ -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

40
src/library/ulm/ulmRandomGenerators.Mod
View file

@ -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;

52
src/library/ulm/ulmReals.Mod
View file

@ -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;

20
src/library/ulm/ulmScales.Mod
View file

@ -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

34
src/library/ulm/ulmServices.Mod
View file

@ -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) &

53
src/library/ulm/ulmSets.Mod
View file

@ -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;

12
src/library/ulm/ulmStreamDisciplines.Mod
View file

@ -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

28
src/library/ulm/ulmStreams.Mod
View file

@ -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

26
src/library/ulm/ulmStrings.Mod
View file

@ -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

74
src/library/ulm/ulmSysConversions.Mod
View file

@ -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;

18
src/library/ulm/ulmSysErrors.Mod
View file

@ -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";

44
src/library/ulm/ulmSysIO.Mod
View file

@ -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

52
src/library/ulm/ulmSysStat.Mod
View file

@ -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 <errno.h>';
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();

12
src/library/ulm/ulmSysTypes.Mod
View file

@ -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.

123
src/library/ulm/ulmTCrypt.Mod
View file

@ -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<exp2;
the absolute value can be 1 or 2 : 2 if the sums of the
vectors differ, 1 otherwise; this distinction isn't used, but
it could be useful for later versions *)
VAR
i : SHORTINT;
e1, e2: INTEGER; diff: BOOLEAN; cmp: SHORTINT;
sum1, sum2 : INTEGER;
i : Types.Int8;
e1, e2: Types.Int32; diff: BOOLEAN; cmp: Types.Int8;
sum1, sum2 : Types.Int32;
BEGIN
i := 0;
sum1 := 0; sum2 := 0; diff := FALSE; cmp := 0;
@ -431,19 +432,19 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
(* arrange a polynomial according to the order given by CmpExp *)
VAR
r : Polynom;
cnt : INTEGER;
cnt : Types.Int32;
PROCEDURE SortPolynom(left, right: INTEGER);
PROCEDURE SortPolynom(left, right: Types.Int32);
(* sort the global field PolFeld with the quicksort algorithm *)
VAR
mid : INTEGER;
mid : Types.Int32;
PROCEDURE Partition(l, r: INTEGER) : INTEGER;
PROCEDURE Partition(l, r: Types.Int32) : Types.Int32;
VAR
koeff : CCMElement;
exp : Exponent;
cmp : Exponent;
i, j : INTEGER;
i, j : Types.Int32;
BEGIN
cmp := PolFeld[(l+r) DIV 2].exp;
i := l-1;
@ -528,7 +529,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
term1, term2 : Polynom;
last : Polynom; (* the last term of the result *)
tmp : Polynom;
cmpres : SHORTINT;
cmpres : Types.Int8;
BEGIN
IF (p = NIL) & (q = NIL) THEN
r := NIL;
@ -606,7 +607,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
(* add two exponent vetors; addition is modulo M *)
PROCEDURE AddExp (exp1, exp2 : Exponent; VAR res: Exponent);
VAR
i : SHORTINT;
i : Types.Int8;
BEGIN
i := 0;
WHILE i<MaxVar DO
@ -681,7 +682,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
(* inverts a regular polynomial; if p is illegal (NIL) or singular the
result is NIL *)
VAR
exp : SHORTINT;
exp : Types.Int8;
tmp : Polynom;
BEGIN
IF (p = NIL) OR ~RegulaerPolynom(p) THEN
@ -706,7 +707,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
(* evaluate p; a precomputed list of all the powers of the argument can
be found in the global variable PreEvalArg *)
VAR
i : SHORTINT;
i : Types.Int8;
pow, prod : CCMElement;
BEGIN
res := NullCCM;
@ -730,7 +731,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
PROCEDURE CreateExp (VAR exp: Exponent);
(* creates a random vector of exponents *)
VAR
i : SHORTINT;
i : Types.Int8;
BEGIN
i := 0;
WHILE i<MaxVar DO
@ -742,7 +743,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
PROCEDURE CreateExpList (VAR explist : ListExp);
(* create a list of MaxNrExp different exponents *)
VAR
i : SHORTINT;
i : Types.Int8;
BEGIN
i := 0;
WHILE i < MaxNrExp DO
@ -751,7 +752,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
END;
END CreateExpList;
PROCEDURE CreatePolynom (VAR p: Polynom; terms: SHORTINT; mode: SHORTINT;
PROCEDURE CreatePolynom (VAR p: Polynom; terms: Types.Int8; mode: Types.Int8;
UseList: BOOLEAN; explist: ListExp);
(* creates a random polynomial depending on mode (can be reg,
sing or random);
@ -760,8 +761,8 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
created entirely randomly but will be chosen form a list of
precomputed exponents *)
VAR
regkoeffs, i : SHORTINT;
expindex : SHORTINT;
regkoeffs, i : Types.Int8;
expindex : Types.Int8;
proot, tmp : Polynom;
doubleexp : BOOLEAN;
@ -851,11 +852,11 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
AddPolynom(mul1, mul2, res);
END DetMatrix;
PROCEDURE ChangeCol (mat: MatPolynom; vek: VektorPolynom; col: INTEGER;
PROCEDURE ChangeCol (mat: MatPolynom; vek: VektorPolynom; col: Types.Int32;
VAR res: MatPolynom);
(* replaces the column #col in mat with vek *)
VAR
dx, dy : INTEGER;
dx, dy : Types.Int32;
BEGIN
dx := 0;
WHILE dx < Dim DO
@ -875,7 +876,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
PROCEDURE ChooseInitialMatrix(VAR mat: MatPolynom);
(* choose an initial matrix for the recursion *)
VAR
dx, dy : SHORTINT;
dx, dy : Types.Int8;
BEGIN
(* the starting matrix consists only of regular components *)
dy := 0;
@ -911,7 +912,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
PROCEDURE MulMatrix (mat: MatCCM; col: VektorCCM; VAR res: VektorCCM);
(* multiplies the matrix mat with the vector col *)
VAR
x, y : SHORTINT;
x, y : Types.Int8;
addres, mulres : CCMElement;
BEGIN
x := 0;
@ -945,9 +946,9 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
(* create random but suiting maps phi, psi and eta for a pair of
public and private keys *)
VAR
r, d, idx : SHORTINT;
regindex, singindex : SHORTINT;
dx, dy : SHORTINT;
r, d, idx : Types.Int8;
regindex, singindex : Types.Int8;
dx, dy : Types.Int8;
A : ChainPolynom;
E : ARRAY Rounds OF MatPolynom;
num : ChainPolynom;
@ -1070,7 +1071,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
PROCEDURE PreComputeArgs(arg: TCryptInput);
(* used for preevaluation of a polynomial argument *)
VAR
k, i, kk, ii : INTEGER;
k, i, kk, ii : Types.Int32;
tmp : CCMElement;
BEGIN
i := 0;
@ -1111,7 +1112,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
argument arg *)
VAR
res : TCryptTmp;
r, d : SHORTINT;
r, d : Types.Int8;
BEGIN
NEW(res);
PreComputeArgs(arg);
@ -1136,7 +1137,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
num, denom, inv : CCMElement;
vek : VektorCCM;
A : ChainCCM;
r, d : SHORTINT;
r, d : Types.Int8;
BEGIN
(* first correct the input with the correlating inverts *)
MulCCM(arg.denominator[0], data.korrDenom[0], denom);
@ -1178,7 +1179,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
PROCEDURE EvaluateEta (arg: TCryptInput; data: Eta) : TCryptRes;
(* evaluate the public function eta (composition of phi and psi) *)
VAR
l, d : SHORTINT;
l, d : Types.Int8;
res : TCryptRes;
BEGIN
NEW(res);
@ -1204,10 +1205,10 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
END Eof;
PROCEDURE Encrypt (msg: Streams.Stream; key: Ciphers.Cipher;
length: INTEGER; s: Streams.Stream) : BOOLEAN;
length: Types.Int32; s: Streams.Stream) : BOOLEAN;
(* interface procedure for Ciphers.Encrypt *)
VAR
i, j : SHORTINT;
i, j : Types.Int8;
ccmarg : TCryptInput;
ccmres : TCryptTmp;
wholeStream : BOOLEAN;
@ -1260,10 +1261,10 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
END Encrypt;
PROCEDURE Decrypt (msg: Streams.Stream; key: Ciphers.Cipher;
length: INTEGER; s: Streams.Stream) : BOOLEAN;
length: Types.Int32; s: Streams.Stream) : BOOLEAN;
(* interface procedure for Ciphers.Decrypt *)
VAR
i, j : SHORTINT;
i, j : Types.Int8;
inNum, inDenom, out : ARRAY (M DIV 8) OF SYS.BYTE;
ccmarg : TCryptTmp;
ccmres : TCryptRes;
@ -1313,10 +1314,10 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
END Decrypt;
PROCEDURE ComposedEncrypt (msg: Streams.Stream; key: Ciphers.Cipher;
length: INTEGER; s: Streams.Stream) : BOOLEAN;
length: Types.Int32; s: Streams.Stream) : BOOLEAN;
(* interface procedure for AsymmetricCiphers.ComposedEncrypt *)
VAR
i, j : SHORTINT;
i, j : Types.Int8;
ccmarg : TCryptInput;
ccmres : TCryptRes;
in, out : ARRAY (M DIV 8) OF SYS.BYTE;
@ -1365,7 +1366,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
VAR
ccm : CCMElement;
bytes : ARRAY M DIV 8 OF SYS.BYTE;
i : INTEGER;
i : Types.Int32;
BEGIN
i := 0;
WHILE i < MaxVar DO
@ -1445,7 +1446,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
CONST
index = M DIV 8;
VAR
nrOfTerms, i : INTEGER;
nrOfTerms, i : Types.Int32;
bytes : ARRAY index OF SYS.BYTE;
BEGIN
nrOfTerms := LengthPolynom(p);
@ -1474,7 +1475,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
CONST
index = M DIV 8;
VAR
nrOfTerms, i : INTEGER;
nrOfTerms, i : Types.Int32;
pol : Polynom;
bytes : ARRAY index OF SYS.BYTE;
BEGIN
@ -1506,7 +1507,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
PROCEDURE PhiWrite (s: Streams.Stream; data: Phi) : BOOLEAN;
(* writes the data structure for the public function phi onto a stream *)
VAR
r, d, k : INTEGER;
r, d, k : Types.Int32;
BEGIN
r := 0;
WHILE r < Rounds DO
@ -1528,7 +1529,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
PROCEDURE PhiRead (s: Streams.Stream; VAR data: Phi) : BOOLEAN;
(* reads the data structure for the public function phi from a stream *)
VAR
r, d, k : INTEGER;
r, d, k : Types.Int32;
BEGIN
NEW(data);
r := 0;
@ -1553,7 +1554,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
CONST
index = M DIV 8;
VAR
dx, dy, r, d : INTEGER;
dx, dy, r, d : Types.Int32;
bytes : ARRAY index OF SYS.BYTE;
BEGIN
dy := 0;
@ -1589,7 +1590,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
CONST
index = M DIV 8;
VAR
dy, dx, r, d : INTEGER;
dy, dx, r, d : Types.Int32;
bytes : ARRAY index OF SYS.BYTE;
BEGIN
dy := 0;
@ -1623,7 +1624,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
PROCEDURE EtaWrite (s: Streams.Stream; data: Eta) : BOOLEAN;
(* writes the data structure for the public function eta onto a stream *)
VAR
l, d : INTEGER;
l, d : Types.Int32;
BEGIN
l := 0;
WHILE l < LastRounds DO
@ -1642,7 +1643,7 @@ MODULE ulmTCrypt; (* Michael Szczuka *)
PROCEDURE EtaRead (s: Streams.Stream; VAR data: Eta) : BOOLEAN;
(* reads the data structure for the public function eta from a stream *)
VAR
l, d : INTEGER;
l, d : Types.Int32;
BEGIN
NEW(data);
l := 0;

6
src/library/ulm/ulmTimers.Mod
View file

@ -38,7 +38,7 @@
MODULE ulmTimers;
IMPORT Clocks := ulmClocks, Disciplines := ulmDisciplines, Events := ulmEvents, Objects := ulmObjects, Op := ulmOperations, Priorities := ulmPriorities,
SYS := ulmSYSTEM, RelatedEvents := ulmRelatedEvents, Scales := ulmScales, Times := ulmTimes;
SYS := ulmSYSTEM, RelatedEvents := ulmRelatedEvents, Scales := ulmScales, Times := ulmTimes, Types := ulmTypes;
TYPE
Queue = POINTER TO QueueRec;
@ -88,7 +88,7 @@ MODULE ulmTimers;
ErrorEventRec* =
RECORD
(Events.EventRec)
errorcode*: SHORTINT;
errorcode*: Types.Int8;
END;
VAR
errormsg*: ARRAY errorcodes OF Events.Message;
@ -102,7 +102,7 @@ MODULE ulmTimers;
Events.Define(error); Events.SetPriority(error, Priorities.liberrors);
END InitErrorHandling;
PROCEDURE Error(errors: RelatedEvents.Object; code: SHORTINT);
PROCEDURE Error(errors: RelatedEvents.Object; code: Types.Int8);
VAR
event: ErrorEvent;
BEGIN

14
src/library/ulm/ulmTimes.Mod
View file

@ -38,7 +38,7 @@
MODULE ulmTimes;
IMPORT NetIO := ulmNetIO, Objects := ulmObjects, Operations := ulmOperations, PersistentObjects := ulmPersistentObjects, Scales := ulmScales,
Services := ulmServices, Streams := ulmStreams;
Services := ulmServices, Streams := ulmStreams, Types := ulmTypes;
CONST
relative* = Scales.relative;
@ -86,7 +86,7 @@ MODULE ulmTimes;
UnitRec =
RECORD
(Scales.UnitRec)
index: SHORTINT; (* epochUnit..usecUnit *)
index: Types.Int8; (* epochUnit..usecUnit *)
END;
VAR
@ -94,7 +94,7 @@ MODULE ulmTimes;
family*: Scales.Family; (* family of time scales *)
if: Scales.Interface;
PROCEDURE Create*(VAR time: Time; type: SHORTINT);
PROCEDURE Create*(VAR time: Time; type: Types.Int8);
(* type = absolute or relative *)
VAR
m: Scales.Measure;
@ -157,7 +157,7 @@ MODULE ulmTimes;
END;
END SetValue;
PROCEDURE CreateAndSet*(VAR time: Time; type: SHORTINT;
PROCEDURE CreateAndSet*(VAR time: Time; type: Types.Int8;
epoch, second, usec: Scales.Value);
VAR
timeval: TimeValueRec;
@ -285,9 +285,9 @@ MODULE ulmTimes;
END; END;
END Op;
PROCEDURE Compare(op1, op2: Scales.Measure) : INTEGER;
PROCEDURE Compare(op1, op2: Scales.Measure) : Types.Int32;
PROCEDURE ReturnVal(val1, val2: Scales.Value) : INTEGER;
PROCEDURE ReturnVal(val1, val2: Scales.Value) : Types.Int32;
BEGIN
IF val1 < val2 THEN
RETURN -1
@ -370,7 +370,7 @@ MODULE ulmTimes;
VAR
poif: PersistentObjects.Interface;
PROCEDURE InitUnit(unitIndex: SHORTINT; name: Scales.UnitName);
PROCEDURE InitUnit(unitIndex: Types.Int8; name: Scales.UnitName);
VAR
unit: Unit;
BEGIN

62
src/library/ulm/ulmTypes.Mod
View file

@ -24,7 +24,7 @@
SetInt type used in msb constant
Revision 1.4 2000/12/13 09:51:57 borchert
constants and types for the relationship of INTEGER and SET added
constants and types for the relationship of Types.Int32 and Types.Set added
Revision 1.3 1998/09/25 15:23:09 borchert
Real32..Real128 added
@ -40,7 +40,7 @@
----------------------------------------------------------------------------
*)
MODULE Types;
MODULE ulmTypes;
(* compiler-dependent type definitions;
this version works for Ulm's Oberon Compilers on
@ -63,62 +63,68 @@ MODULE Types;
Int32* = SYS.INT32;
Real32* = LONGREAL;
Real64* = LONGREAL;
Set* = SYS.SET32;
CONST
bigEndian* = 0; (* SPARC, M68K etc *)
littleEndian* = 1; (* Intel 80x86, VAX etc *)
byteorder* = littleEndian; (* machine-dependent constant *)
TYPE
ByteOrder* = SHORTINT; (* bigEndian or littleEndian *)
ByteOrder* = SYS.INT8; (* bigEndian or littleEndian *)
(* following constants and type definitions try to make
conversions from INTEGER to SET and vice versa more portable
to allow for bit operations on INTEGER values
conversions from Types.Int32 to Types.Set and vice versa more portable
to allow for bit operations on Types.Int32 values
*)
TYPE
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 *)
SetInt* = SYS.INT32; (* Types.Int32 type that corresponds to Types.Set *)
VAR
msb*: SYS.SET32;
msbIsMax*, msbIs0*: SYS.INT8;
msbindex*, lsbindex*, nofbits*: SYS.INT32;
PROCEDURE ToInt8*(int: LONGINT) : Int8;
PROCEDURE ToInt8*(int: Int32) : Int8;
BEGIN
RETURN SHORT(SHORT(int))
END ToInt8;
PROCEDURE ToInt16*(int: LONGINT) : Int16;
PROCEDURE ToInt16*(int: Int32) : Int16;
BEGIN
RETURN SYS.VAL(Int16, int)
END ToInt16;
PROCEDURE ToInt32*(int: LONGINT) : Int32;
PROCEDURE ToInt32*(int: Int32) : Int32;
BEGIN
RETURN int
END ToInt32;
PROCEDURE ToReal32*(real: LONGREAL) : Real32;
PROCEDURE ToReal32*(real: Real64) : Real32;
BEGIN
RETURN SHORT(real)
END ToReal32;
PROCEDURE ToReal64*(real: LONGREAL) : Real64;
PROCEDURE ToReal64*(real: Real64) : Real64;
BEGIN
RETURN SHORT(real)
END ToReal64;
BEGIN
msb := SYS.VAL(SYS.SET32, MIN(SetInt));
(* most significant bit, converted to a Types.Set *)
(* we expect msbIsMax XOR msbIs0 to be 1;
this is checked for by an assertion
*)
msbIsMax := SYS.VAL(SYS.INT8, (msb = {MAX(Set)}));
(* is 1, if msb equals {MAX(Set)} *)
msbIs0 := SYS.VAL(SYS.INT8, (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 Types.
END ulmTypes.

38
src/library/ulm/ulmWrite.Mod
View file

@ -33,31 +33,31 @@
MODULE ulmWrite;
IMPORT ASCII := ulmASCII, Print := ulmPrint, StreamDisciplines := ulmStreamDisciplines, Streams := ulmStreams, SYSTEM, SYS := ulmSYSTEM;
IMPORT ASCII := ulmASCII, Print := ulmPrint, StreamDisciplines := ulmStreamDisciplines, Streams := ulmStreams, SYSTEM, SYS := ulmSYSTEM, Types := ulmTypes;
(*
TYPE barr = ARRAY SIZE(LONGINT) OF SYSTEM.BYTE; (* need this because voc does not convert implicitly LONGINT to ARRAY OF BYTE; -- noch *)
TYPE barr = ARRAY SIZE(Types.Int32) OF SYSTEM.BYTE; (* need this because voc does not convert implicitly Types.Int32 to ARRAY OF BYTE; -- noch *)
pbarr = POINTER TO barr;
TYPE lrarr = ARRAY SIZE(LONGREAL) OF SYSTEM.BYTE; (* need this because voc does not convert implicitly LONGINT to ARRAY OF BYTE; -- noch *)
TYPE lrarr = ARRAY SIZE(Types.Real64) OF SYSTEM.BYTE; (* need this because voc does not convert implicitly Types.Int32 to ARRAY OF BYTE; -- noch *)
plrarr = POINTER TO barr;
PROCEDURE LongToByteArr ( l : LONGINT; VAR bar : barr); (* noch *)
PROCEDURE LongToByteArr ( l : Types.Int32; VAR bar : barr); (* noch *)
VAR b : SYSTEM.BYTE;
p : pbarr;
i : LONGINT;
i : Types.Int32;
BEGIN
p := SYSTEM.VAL(pbarr, SYSTEM.ADR(l));
FOR i := 0 TO SIZE(LONGINT) -1 DO
FOR i := 0 TO SIZE(Types.Int32) -1 DO
b := p^[i]; bar[i] := b;
END
END LongToByteArr;
PROCEDURE LRealToByteArr ( l : LONGREAL; VAR lar : lrarr); (* noch *)
PROCEDURE LRealToByteArr ( l : Types.Real64; VAR lar : lrarr); (* noch *)
VAR b : SYSTEM.BYTE;
p : plrarr;
i : LONGINT;
i : Types.Int32;
BEGIN
p := SYSTEM.VAL(plrarr, SYSTEM.ADR(l));
FOR i := 0 TO SIZE(LONGREAL) -1 DO
FOR i := 0 TO SIZE(Types.Real64) -1 DO
b := p^[i]; lar[i] := b;
END
END LRealToByteArr;
@ -65,7 +65,7 @@ MODULE ulmWrite;
*)
PROCEDURE IntS*(s: Streams.Stream; int: LONGINT; width: LONGINT);
PROCEDURE IntS*(s: Streams.Stream; int: Types.Int32; width: Types.Int32);
VAR b, b0 : SYS.bytearray;
BEGIN
SYS.LongToByteArr(int, b);
@ -73,7 +73,7 @@ MODULE ulmWrite;
Print.S2(s, "%*d", b0, b);
END IntS;
PROCEDURE RealS*(s: Streams.Stream; real: LONGREAL; width: LONGINT);
PROCEDURE RealS*(s: Streams.Stream; real: Types.Real64; width: Types.Int32);
VAR b : SYS.bytearray; lr : SYS.longrealarray;
BEGIN
SYS.LRealToByteArr(real, lr);
@ -93,11 +93,11 @@ MODULE ulmWrite;
PROCEDURE LineS*(s: Streams.Stream; str: ARRAY OF CHAR);
VAR
count: LONGINT;
count: Types.Int32;
nlOK: BOOLEAN;
cnt: LONGINT;
cnt: Types.Int32;
lineterm: StreamDisciplines.LineTerminator;
len: INTEGER; i: INTEGER;
len: Types.Int32; i: Types.Int32;
BEGIN
cnt := 0;
WHILE (cnt < LEN(str)) & (str[cnt] # 0X) DO
@ -141,7 +141,7 @@ MODULE ulmWrite;
PROCEDURE LnS*(s: Streams.Stream);
VAR
lineterm: StreamDisciplines.LineTerminator;
len: INTEGER;
len: Types.Int32;
BEGIN
StreamDisciplines.GetLineTerm(s, lineterm);
IF lineterm[1] = 0X THEN
@ -157,7 +157,7 @@ MODULE ulmWrite;
PROCEDURE StringS*(s: Streams.Stream; str: ARRAY OF CHAR);
VAR
cnt: LONGINT;
cnt: Types.Int32;
BEGIN
cnt := 0;
WHILE (cnt < LEN(str)) & (str[cnt] # 0X) DO
@ -168,7 +168,7 @@ MODULE ulmWrite;
PROCEDURE IndentS*(s: Streams.Stream);
VAR
indentwidth: INTEGER;
indentwidth: Types.Int32;
BEGIN
StreamDisciplines.GetIndentationWidth(s, indentwidth);
WHILE (indentwidth > 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);

2
src/tools/make/oberon.mk
View file

@ -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