cleanups & removed dummy parameters which are no longer needed

git-svn-id: https://svn.inf.ethz.ch/svn/lecturers/a2/trunk@7324 8c9fc860-2736-0410-a75d-ab315db34111

source/Generic.Linux.I386.Unix.Mod

@@ -11,7 +11,7 @@ IMPORT S := SYSTEM, Glue, Trace;
 
 
 CONST
-	Version* = "LinuxG32";
+	Version* = "Linux";
 
   	libcname* = "libc.so.6";
 	libX11name* = "libX11.so.6";
@@ -143,19 +143,18 @@ TYPE
 	Thread_t* = ADDRESS;
 	Mutex_t* = ADDRESS;
 	MutexType = ARRAY 8 OF ADDRESS;
+	MutexAttributeType = ARRAY 1 OF WORD;
 
 	Condition_t* = ADDRESS;
 	ConditionType = ARRAY 12 OF WORD;
 
 	Sigset_t= ARRAY 32 OF ADDRESS;
-	SignalHandler = PROCEDURE ( sig: LONGINT; scp, ucp, dum: ADDRESS );
-
-	MutexAttributeType = ARRAY 1 OF WORD;
+	SignalHandler = PROCEDURE ( sig: LONGINT; scp, ucp: ADDRESS );
 	
-	pid_t *= LONGINT;
-	path_t *= ARRAY OF CHAR;
-	arg_t *= ARRAY OF CHAR;
-	argv_t *= ARRAY OF arg_t;
+	pid_t*		= LONGINT;
+	path_t*	= ARRAY OF CHAR;
+	arg_t*		= ARRAY OF CHAR;
+	argv_t*	= ARRAY OF arg_t;
 
 
 CONST
@@ -398,12 +397,9 @@ VAR
 
 	sigstack-: ARRAY 32*4096 OF CHAR;
 
-	ptrace: PROCEDURE {C} (request: WORD; pid: Thread_t; adr, data: ADDRESS): WORD;
-	getcontext-: PROCEDURE {C} (context: ADDRESS): WORD;
 
 	sysconf: PROCEDURE {C} (name: LONGINT):WORD;
 
-
 	pthread_mutex_init: PROCEDURE {C} (mutex: ADDRESS; mutexattr: ADDRESS): WORD;
 	pthread_mutex_destroy: PROCEDURE {C} (mutex: ADDRESS): WORD;
 	pthread_mutex_lock: PROCEDURE {C} (mutex: ADDRESS): WORD;
@@ -529,21 +525,21 @@ VAR
 
 	PROCEDURE getnprocs* (): LONGINT;
 	BEGIN
-		RETURN sysconf(0x54); (*0x53 for number of processors configured, 0x54 for number of processors online *)
+		RETURN sysconf( 0x54 ); (*0x53 for number of processors configured, 0x54 for number of processors online *)
 	END getnprocs;
 
 
-	PROCEDURE MtxInit*(dummy: LONGINT): Mutex_t;
+	PROCEDURE NewMtx*( ): Mutex_t;
 	VAR
 		mtx: Mutex_t;
 	BEGIN
-		mtx := malloc(SIZEOF(MutexType));
+		mtx := malloc( SIZEOF(MutexType) );
 		ASSERT(mtx # 0);
 		ASSERT(pthread_mutex_init(mtx, NIL) = 0);
 		RETURN mtx;
-	END MtxInit;
+	END NewMtx;
 
-	PROCEDURE RecursiveMtxInit*(dummy: LONGINT): Mutex_t;
+	PROCEDURE NewRecursiveMtx*( ): Mutex_t;
 	VAR
 		mtx: Mutex_t;
 		attr: MutexAttributeType;
@@ -551,14 +547,14 @@ VAR
 	CONST
 		Recursive = 1;
 	BEGIN
-		mtx := malloc(SIZEOF(MutexType));
+		mtx := malloc( SIZEOF(MutexType) );
 		res := pthread_mutexattr_init(ADDRESS OF attr);
 		res := pthread_mutexattr_settype(ADDRESS OF attr, Recursive);
 
 		ASSERT(mtx # 0);
 		ASSERT(pthread_mutex_init(mtx, ADDRESS OF attr) = 0);
 		RETURN mtx;
-	END RecursiveMtxInit;
+	END NewRecursiveMtx;
 
 
 
@@ -577,43 +573,43 @@ VAR
 		ASSERT(pthread_mutex_unlock(mtx) = 0);
 	END MtxUnlock;
 
-	PROCEDURE ConInit* (dummy: LONGINT): Condition_t;
+	PROCEDURE NewCond* ( ): Condition_t;
 	VAR cond: Condition_t;
 	BEGIN
-		cond := malloc(SIZEOF(ConditionType));
+		cond := malloc( SIZEOF(ConditionType) );
 		ASSERT(cond # 0);
 		ASSERT(pthread_cond_init(cond, NIL)=0);
 		RETURN cond;
-	END ConInit;
+	END NewCond;
 
-	PROCEDURE ConDestroy*(con: Condition_t);
+	PROCEDURE CondDestroy*(con: Condition_t);
 	BEGIN
 		ASSERT(pthread_cond_destroy(con) = 0);
-	END ConDestroy;
+	END CondDestroy;
 
-	PROCEDURE ConWait*(con: Condition_t; mtx: Mutex_t);
+	PROCEDURE CondWait*(con: Condition_t; mtx: Mutex_t);
 	BEGIN
 		ASSERT(pthread_cond_wait(con, mtx) = 0);
-	END ConWait;
+	END CondWait;
 
-	PROCEDURE ConSignal*(cond: Condition_t);
+	PROCEDURE CondSignal*(cond: Condition_t);
 	BEGIN
 		ASSERT(pthread_cond_signal(cond) = 0);
-	END ConSignal;
+	END CondSignal;
 
-	PROCEDURE ThrThis*(dummy: LONGINT): Thread_t;
+	PROCEDURE ThrThis*(): Thread_t;
 	BEGIN
-		RETURN pthread_self();
+		RETURN pthread_self( );
 	END ThrThis;
 
-	PROCEDURE ThrYield*(dummy: LONGINT);
+	PROCEDURE ThrYield*( );
 	BEGIN
 		ThrSleep(1);
 	END ThrYield;
 
-	PROCEDURE ThrExit*(dummy: LONGINT);
+	PROCEDURE ThrExit*( );
 	BEGIN
-		pthread_exit(0);
+		pthread_exit( 0 );
 	END ThrExit;
 
 	PROCEDURE ThrSetPriority*(thr: Thread_t; prio: LONGINT);
@@ -621,11 +617,11 @@ VAR
 		param: Sched_param;
 		policy: LONGINT;
 	BEGIN
-	    IF pthread_getschedparam( thr, ADDRESS OF policy, ADDRESS OF param ) # 0 THEN END;
-	    param.sched_priority := prio;
-	    IF pthread_setschedparam( thr, SCHED_OTHER, ADDRESS OF param ) # 0 THEN
-	    	Perror("pthread_setschedparam");
-	    END
+		IF pthread_getschedparam( thr, ADDRESS OF policy, ADDRESS OF param ) # 0 THEN END;
+		param.sched_priority := prio;
+		IF pthread_setschedparam( thr, SCHED_OTHER, ADDRESS OF param ) # 0 THEN
+			Perror("pthread_setschedparam");
+		END
 	END ThrSetPriority;
 
 	PROCEDURE ThrGetPriority*(thr: Thread_t):LONGINT;
@@ -650,36 +646,33 @@ VAR
 	PROCEDURE {C} Starter(proc: PROCEDURE): ADDRESS;
 	VAR
 		me: Thread_t;
-
 		old, new: Sigset_t;
-
 		param: Sched_param;
 		res: LONGINT;
-
 	BEGIN
 		me := pthread_self();
 		SetSigaltstack();
 
-	    IF sigfillset( ADDRESS OF new ) < 0 THEN
-	    	Perror("sigfillset");
-	    END;
-	    sigdelset( ADDRESS OF new, SIGILL );
-	    sigdelset( ADDRESS OF new, SIGTRAP );
-	    sigdelset( ADDRESS OF new, SIGFPE );
-	    sigdelset( ADDRESS OF new, SIGBUS );
-	    sigdelset( ADDRESS OF new, SIGSEGV );
-	    sigdelset( ADDRESS OF new, SIGTERM );
-	    sigdelset( ADDRESS OF new, T_SIGSUSPEND );
-
-	    res := pthread_sigmask( SIG_SETMASK, ADDRESS OF new, ADDRESS OF old );
-	    res := pthread_setcancelstate( PTHREAD_CANCEL_ENABLE, NIL );
-	    res := pthread_setcanceltype( PTHREAD_CANCEL_ASYNCHRONOUS, NIL );
-	    param.sched_priority := 0;
-	    res := pthread_setschedparam( me, SCHED_OTHER, ADDRESS OF param );
-	    proc();
-
-	    pthread_exit( NIL );
-	    RETURN NIL;
+		IF sigfillset( ADDRESS OF new ) < 0 THEN
+			Perror("sigfillset");
+		END;
+		sigdelset( ADDRESS OF new, SIGILL );
+		sigdelset( ADDRESS OF new, SIGTRAP );
+		sigdelset( ADDRESS OF new, SIGFPE );
+		sigdelset( ADDRESS OF new, SIGBUS );
+		sigdelset( ADDRESS OF new, SIGSEGV );
+		sigdelset( ADDRESS OF new, SIGTERM );
+		sigdelset( ADDRESS OF new, T_SIGSUSPEND );
+
+		res := pthread_sigmask( SIG_SETMASK, ADDRESS OF new, ADDRESS OF old );
+		res := pthread_setcancelstate( PTHREAD_CANCEL_ENABLE, NIL );
+		res := pthread_setcanceltype( PTHREAD_CANCEL_ASYNCHRONOUS, NIL );
+		param.sched_priority := 0;
+		res := pthread_setschedparam( me, SCHED_OTHER, ADDRESS OF param );
+		proc();
+
+		pthread_exit( NIL );
+		RETURN NIL;
 	END Starter;
 
 	PROCEDURE ThrStart*(p: PROCEDURE; stackSize: SIZE): Thread_t;
@@ -704,8 +697,8 @@ VAR
 	VAR
 		sltime,rem: RECORD
 			tv_sec: WORD;        (* seconds *)
-            tv_nsec: WORD;       (* nanoseconds *)
-         END;
+			tv_nsec: WORD;       (* nanoseconds *)
+     	END;
 	BEGIN
 		sltime.tv_sec := ms DIV 1000;
 		sltime.tv_nsec := 1000000*(ms MOD 1000);
@@ -777,8 +770,6 @@ VAR
 	VAR
 		param: Sched_param;
 	BEGIN
-	    (*struct sched_param param;*)
-
 		ASSERT(pthread_mutex_init( ADDRESS OF suspend_mutex, NIL ) = 0);
 		mainthread := pthread_self();
 		high := sched_get_priority_max(SCHED_OTHER);
@@ -924,9 +915,9 @@ VAR
 	PROCEDURE {C} SigHandler  ( sig: LONGINT; scp: ADDRESS; ucp: ADDRESS); (* reversed arguments !! *)
 	BEGIN
 		IF trap # NIL THEN
-			trap(sig, scp, ucp, 0);
+			trap( sig, scp, ucp );
 		ELSE
-			TRACE(sig, scp, ucp)
+			TRACE( sig, scp, ucp )
 		END;
 	END SigHandler;
 
@@ -1037,8 +1028,6 @@ VAR
 
 		Dlsym( libc, "exit",		ADDRESSOF(exit) );
 
-		Dlsym( libc, "ptrace", ADDRESSOF(ptrace) );
-		Dlsym( libc, "getcontext", ADDRESSOF(getcontext) );
 		Dlsym( libc, "sysconf", ADDRESSOF(sysconf) );
 
 		Dlsym( libc, "pthread_mutex_init", ADDRESSOF(pthread_mutex_init) );

source/Generic.Solaris.I386.Glue.Mod

@@ -9,7 +9,6 @@ CONST
 (*	base* = 08050000H;		for true elf core *)
 	base* = 08070000H;	(*  used by A2Loader,  see 'A2Loader.elf  -h' *)
 	debug* = {};
-	NL = 0AX;
 VAR
 	last-: RECORD END; (* empty variable linked to end of kernel *)
 	
@@ -19,12 +18,8 @@ VAR
 	dlsym-	: PROCEDURE {C} ( handle: ADDRESS; name: ADDRESS ): ADDRESS;
 	dlopen-	: PROCEDURE {C} ( pathname: ADDRESS; mode: LONGINT ): ADDRESS;
 	dlclose-	: PROCEDURE {C} ( handle: ADDRESS );
-	write		: PROCEDURE {C} ( fd: LONGINT; buf: ADDRESS; n: SIZE ): LONGINT;
-	exit-		: PROCEDURE {C} ( status: LONGINT );
 
 	stackBottom-	: ADDRESS;	(* of main thread *)
-
-	libc: ADDRESS;
 	
 	argc-: WORD; 
 	argv-: ADDRESS;
@@ -171,7 +166,7 @@ VAR
 
 	PROCEDURE {INITIAL, NOPAF} EntryPoint;		(* header needed by A2Loader *)
 	CODE
-		DB 'Solaris32G.core', 0
+		DB 'Oberon32G.core', 0, 0
 		DD 0
 		DD 0
 		DD 0
@@ -179,17 +174,36 @@ VAR
 		DD base
 		DD @Init0
 		DD @dlopen
+		DD @dlclose
 		DD @dlsym
 		DD @argc
 		DD @argv
+		DD @environ
 	END EntryPoint;		
 	
+	PROCEDURE {NOPAF} putc*( file: ADDRESS; c: CHAR );
+	CODE
+		PUSH ECX
+		MOV EAX, 4
+		MOV EBX, [ESP + 12]
+		LEA ECX, [ESP+8]	
+		MOV EDX, 1
+		INT 80H
+		POP ECX
+		JNE fail
+		MOV EAX, [ESP + 4]
+		RET
+		fail:
+		MOV EAX, -1
+		RET
+	END putc;
+	
  	PROCEDURE Char ( c: CHAR );
-	VAR r: LONGINT;
 	BEGIN
-		r := write( 1, ADDRESSOF( c ), 1 );
+		putc( 1, c )
 	END Char;
 
+
  	PROCEDURE Dlsym*( handle: ADDRESS; CONST name: ARRAY OF CHAR; adr: ADDRESS );
 	VAR val: ADDRESS;
 	BEGIN
@@ -210,17 +224,16 @@ VAR
 		
 		stackBottom := ADDRESSOF( i ) + 2*SIZEOF( ADDRESS );
 
-	(*	Dlsym( 0, "dlopen" , ADDRESSOF ( dlopen ) );	*)
+	(*	Dlsym( 0, "dlopen" , ADDRESSOF ( dlopen ) );	
 		libdl := dlopen( ADDRESSOF( "/lib/libdl.so.1" ), 2 );
-		Dlsym( libdl, "dlclose", ADDRESSOF ( dlclose ) );
+		Dlsym( libdl, "dlclose", ADDRESSOF ( dlclose ) );  
 		libc := dlopen( ADDRESSOF( "/lib/libc.so.1" ), 2 );	
 		Dlsym( libc, "write", ADDRESSOF ( write ) );
-		Dlsym( libc, "exit", ADDRESSOF ( exit ) );
+		Dlsym( libc, "exit", ADDRESSOF ( exit ) );	*)
 	END Init;
 	
 	PROCEDURE {INITIAL, NOPAF} Init0;
 	BEGIN
-	(*? same layout in Solaris ?? *)
 	(*	(*initial stack layout:
 			argc at esp
 			argv at esp+4

source/Generic.Solaris.I386.Unix.Mod

@@ -19,9 +19,7 @@ CONST
 	Version* = "Solaris";
 
 	libcname* = "libc.so.1";
-	libmname* = "libm.so.1";
 	libX11name* = "libX11.so.4";
-	libXextname* = "libXext.so.0";
 	libpthreadname = "libpthread.so.1";
 
 	LittleEndian* = TRUE;   (** byte order of basic types *)
@@ -328,7 +326,7 @@ TYPE
 			END;
 
 	Sigset = ARRAY 4 OF SET;
-	SignalHandler = PROCEDURE ( sig: LONGINT; scp, ucp, dum: ADDRESS ); 
+	SignalHandler = PROCEDURE ( sig: LONGINT; scp, ucp: ADDRESS ); 
 
 	Stack* = RECORD
 				sp*	: ADDRESS;
@@ -581,7 +579,7 @@ VAR
 			suspendHandler( ucp );
 			handler_done := TRUE;
 		ELSIF trap # NIL THEN 
-			trap( sig, scp, ucp, 0 );
+			trap( sig, scp, ucp );
 		ELSE
 			Trace.String( "Unix.SigHandler: sig = " ); Trace.Int( sig, 0 ); Trace.Ln;  exit( -1 );
 		END;
@@ -746,17 +744,17 @@ VAR
 		END;  
 	END ThrKill;
 	
-	PROCEDURE ThrThis*( dummy: LONGINT ): Thread_t;
+	PROCEDURE ThrThis*( ): Thread_t;
 	BEGIN
-		RETURN pthread_self();
+		RETURN pthread_self( );
 	END ThrThis;
 
-	PROCEDURE ThrYield*( dummy: LONGINT );
+	PROCEDURE ThrYield*( );
 	BEGIN
 		ThrSleep( 1 );
 	END ThrYield;
 
-	PROCEDURE ThrExit*( dummy: LONGINT );
+	PROCEDURE ThrExit*( );
 	BEGIN
 		pthread_exit( 0 );
 	END ThrExit;
@@ -783,7 +781,7 @@ VAR
 	END ThrGetPriority;
 	
 	
-	PROCEDURE MtxInit*( dummy: LONGINT ): Mutex_t;
+	PROCEDURE NewMtx*( ): Mutex_t;
 	VAR 
 		mtx: Mutex_t;
 	BEGIN
@@ -791,9 +789,9 @@ VAR
 		ASSERT(mtx # 0);
 		ASSERT(pthread_mutex_init(mtx, NIL) = 0);
 		RETURN mtx;
-	END MtxInit;
+	END NewMtx;
 
-	PROCEDURE RecursiveMtxInit*(dummy: LONGINT): Mutex_t;
+	PROCEDURE NewRecursiveMtx*( ): Mutex_t;
 	VAR 
 		mtx: Mutex_t;
 		attr: MutexAttributeDesc;
@@ -808,7 +806,7 @@ VAR
 		ASSERT( mtx # 0 );
 		ASSERT( pthread_mutex_init( mtx, ADDRESSOF( attr ) ) = 0);
 		RETURN mtx;
-	END RecursiveMtxInit;
+	END NewRecursiveMtx;
 	
 	PROCEDURE MtxDestroy*( mtx: Mutex_t );
 	BEGIN
@@ -826,29 +824,29 @@ VAR
 	END MtxUnlock;
 	
 	
-	PROCEDURE ConInit* ( dummy: LONGINT ): Condition_t;
+	PROCEDURE NewCond* ( ): Condition_t;
 	VAR cond: Condition_t;
 	BEGIN
 		cond := malloc( SIZEOF( ConditionDesc ) );
 		ASSERT( cond # 0 );
 		ASSERT( pthread_cond_init( cond, NIL ) = 0 );
 		RETURN cond;
-	END ConInit;
+	END NewCond;
 	
-	PROCEDURE ConDestroy*( con: Condition_t );
+	PROCEDURE CondDestroy*( con: Condition_t );
 	BEGIN
 		ASSERT( pthread_cond_destroy( con ) = 0 );
-	END ConDestroy;
+	END CondDestroy;
 
-	PROCEDURE ConWait*( con: Condition_t; mtx: Mutex_t );
+	PROCEDURE CondWait*( con: Condition_t; mtx: Mutex_t );
 	BEGIN
 		ASSERT( pthread_cond_wait( con, mtx ) = 0 );
-	END ConWait;
+	END CondWait;
 
-	PROCEDURE ConSignal*( cond: Condition_t );
+	PROCEDURE CondSignal*( cond: Condition_t );
 	BEGIN
 		ASSERT( pthread_cond_signal( cond ) = 0 );
-	END ConSignal;
+	END CondSignal;
 	
 	
 	(*-------------------------------------------------------------------------------------------------------------*)

source/Generic.Unix.I386.Machine.Mod

@@ -5,7 +5,7 @@ IMPORT S := SYSTEM, Trace, Unix, Glue;
 CONST
 	DefaultConfig = "Color 0  StackSize 128";
 	
-	Version = " A2 ";
+	Version = "A2 Generic, ";
 
 	DefaultObjectFileExtension* = ".Obj";
 	
@@ -34,9 +34,7 @@ CONST
 	Processors* = 6;	(*!  Interprocessor interrupts,  not used in UnixAos *)
 	KernelLog* = 7;		(* Atomic output *)
 	X11* = 8;				(* XWindows I/O *)
-	Trap* = 9;
-	GC = 10;
-	MaxLocks* = 11;   (* { <= 32 } *)
+	MaxLocks* = 9;   (* { <= 32 } *)
 	
 	MaxCPU* = 4;
 	IsCooperative* = FALSE;
@@ -80,9 +78,7 @@ VAR
 	SSE42Support-	: BOOLEAN;
 	SSE5Support-	: BOOLEAN;
 	AVXSupport-		: BOOLEAN;
-	
-	GCacquired- : BOOLEAN;
-	
+		
 	ticks-: LONGINT;	(** timer ticks. Use Kernel.GetTicks() to read, don't write *)
 	
 	prioLow-, prioHigh-: LONGINT;	(* permitted thread priorities *)
@@ -99,23 +95,7 @@ VAR
 	
 	config: ARRAY 2048 OF CHAR;	(* config strings *)
 	
-	(*
-	Unix.ThrInitialize	: PROCEDURE {REALTIME, C} ( VAR low, high: LONGINT ): BOOLEAN;
-	
-	Unix.MtxInit			: PROCEDURE {REALTIME, C} ( dummy: LONGINT ): Unix.Mutex_t;
-	Unix.MtxDestroy	: PROCEDURE {REALTIME, C} ( mtx: Unix.Mutex_t );
-	Unix.MtxLock		: PROCEDURE {REALTIME, C} ( mtx: Unix.Mutex_t );
-	Unix.MtxUnlock	: PROCEDURE {REALTIME, C} ( mtx: Unix.Mutex_t );
-	
-	conInit			: PROCEDURE {REALTIME, C}  ( dummy: LONGINT ): Unix.Condition_t;
-	conDestroy	: PROCEDURE {REALTIME, C}  ( cond: Unix.Condition_t );
-	conWait		: PROCEDURE {REALTIME, C}  ( cond: Unix.Condition_t;  mtx: Unix.Mutex_t );
-	conSignal		: PROCEDURE {REALTIME, C}  ( cond: Unix.Condition_t );
-	
-	thrSleep		: PROCEDURE {REALTIME, C} ( ms: LONGINT );
-	thrThis			: PROCEDURE {REALTIME, C} ( dummy: LONGINT ): Unix.Thread_t;
-	*)
-	
+
 	logfile: LONGINT;
 	traceHeap: BOOLEAN;
 
@@ -548,10 +528,7 @@ END GetTimer;
 				UNTIL ch <= ' '
 			END
 		END;
-		IF name = "ObjectFileExtension" THEN val := ".GofU"
-		ELSE
-		val[0] := 0X
-		END;
+		IF name = "ObjectFileExtension" THEN  val := ".GofU" ELSE  val[0] := 0X  END;
 	END GetConfig;
 
 
@@ -718,7 +695,7 @@ END GetTimer;
 	VAR i: LONGINT;  a: ADDRESS;
 	BEGIN 
 		i := 0;  
-		WHILE i < MaxLocks DO  	mtx[i] := Unix.MtxInit(0);  INC( i )  END;   
+		WHILE i < MaxLocks DO  mtx[i] := Unix.NewMtx( );  INC( i )  END;   
 	END InitLocks;  
 
 	PROCEDURE CleanupLocks*;  
@@ -740,22 +717,6 @@ END GetTimer;
 		Unix.MtxUnlock( mtx[level] );
 	END Release;  
 	
-	PROCEDURE  AcquireGC*( ): BOOLEAN;  
-	VAR res: BOOLEAN;
-	BEGIN 
-		Unix.MtxLock( mtx[GC] );
-		IF ~GCacquired THEN  GCacquired := TRUE;  res := TRUE  ELSE  res := FALSE  END;
-		Unix.MtxUnlock( mtx[GC] );
-		RETURN  res
-	END AcquireGC;  
-
-	(** Release a spin-lock. *)
-	PROCEDURE  ReleaseGC*;   
-	BEGIN 
-		Unix.MtxLock( mtx[GC] );
-		GCacquired := FALSE;
-		Unix.MtxUnlock( mtx[GC] )
-	END ReleaseGC;  
 	
 	PROCEDURE Shutdown*( reboot: BOOLEAN );
 	VAR ignore: LONGINT;
@@ -809,9 +770,6 @@ END GetTimer;
 		memBlkSize := memDescSize + size + StaticBlockSize; 		(* add StaticBlockSize to account for alignments different from multiples of StaticBlockSize *)
 		IF memBlkSize < MemBlockSize THEN memBlkSize := MemBlockSize END; 	(* MemBlockSize implicitly multiple of StaticBlockSize *)
 
-		(*initVal := 8*1024*1024;
-		TRACE(initVal, adr);
-		*)
 		IF Unix.posix_memalign( adr, Unix.PageSize, memBlkSize ) # 0 THEN
 			Unix.Perror( "Machine.ExpandHeap: posix_memalign" );
 			beginBlockAdr := 0;
@@ -822,12 +780,7 @@ END GetTimer;
 			END;
 			IF TraceMemBlocks THEN TRACE(adr, memBlkSize) END;
 		END;
-		(*
-		adr := Kernel32.VirtualAlloc(initVal, memBlkSize, {Kernel32.MEMCommit, Kernel32.MEMReserve}, {Kernel32.PageExecuteReadWrite});
-		IF adr = NilVal THEN (* allocation failed *)
-			adr := Kernel32.VirtualAlloc(NilVal, memBlkSize, {Kernel32.MEMCommit}, {Kernel32.PageExecuteReadWrite});
-		END;
-		*)
+
 		IF TraceMemBlocks THEN
 			Trace.String("first heap block intVal "); Trace.Int(initVal,1); Trace.Ln;
 			Trace.String("first heap block memBlkSize "); Trace.Int(memBlkSize,1); Trace.Ln;
@@ -869,25 +822,6 @@ END GetTimer;
 		memoryBlock := memBlock;
 	END InitHeap;
 
-	(*
-	PROCEDURE InitHeap;
-	VAR heapAdr, firstBlock: ADDRESS; size: SIZE;  
-	BEGIN
-		Unix.Dlsym( 0, "heapAdr", ADDRESSOF( heapAdr ) );  
-		Unix.Dlsym( 0, "heapSize", ADDRESSOF( size ) );  
-		firstBlock := heapAdr + ((-heapAdr - AddrSize) MOD BlockSize);
-		size := heapAdr + size - BlockSize - firstBlock;  DEC( size, size MOD BlockSize + BlockSize );
-
-		firstMemBlock.next := NIL;
-		firstMemBlock.startAdr := heapAdr;
-		firstMemBlock.beginBlockAdr :=  firstBlock;
-		firstMemBlock.endBlockAdr := firstBlock + size;  
-		firstMemBlock.size := size;
-	
-		memBlockHead := S.VAL( MemoryBlock, ADDRESSOF( firstMemBlock ) );
-		memBlockTail := memBlockHead;
-	END InitHeap;
-	*)
 
 	PROCEDURE InitConfig;
 	VAR a: ADDRESS;  i: LONGINT;  c: CHAR;

source/Generic.Unix.Objects.Mod

@@ -282,9 +282,8 @@ TYPE
 				
 				
 		PROCEDURE & Initialize( obj: ProtectedObject;  bodyProc: Body;  prio: LONGINT; fl: SET; stacksize: LONGINT);
-		VAR  thr: Unix.Thread_t;
 		BEGIN
-			SELF.obj := obj;  condition := NIL;  continue := Unix.ConInit(0);
+			SELF.obj := obj;  condition := NIL;  continue := Unix.NewCond( );
 			flags := fl;
 			priority := prio;
 			nextProcess := NIL;
@@ -293,14 +292,14 @@ TYPE
 				ASSERT( bodyProc # NIL );
 				body := bodyProc;  
 				Unix.MtxLock( startProcess );
-				thr := Unix.ThrStart( BodyStarter, stacksize );
-				Unix.ConWait( childrunning, startProcess );
+				threadId := Unix.ThrStart( BodyStarter, stacksize );
+				Unix.CondWait( childrunning, startProcess );
 				Unix.MtxUnlock( startProcess );
 				RegisterFinalizer( SELF, FinalizeProcess );
 			ELSE 
 				(* first process *)
 				stackBottom := Glue.stackBottom;  
-				threadId := Unix.ThrThis(0);
+				threadId := Unix.ThrThis( );
 				id := 0;  nextPID := 1;
 				root := SELF;
 				mode := Running;
@@ -309,17 +308,17 @@ TYPE
 				
 	END Process;
 
+
 	GCStatusExt = OBJECT (Heaps.GCStatus)
 	
-	(* called from Heaps.InvokeGC, i.e. this is a hidden upcall. However, it is necessary to take the Machine.Objects lock here since writing
-		    the set of variables here must not be interrupted, i.e. atomic writing of the set of variables is absolutely necessary.  They system may hang
-		    if the lock is not taken. *)
+		(*	called from Heaps.InvokeGC, i.e. this is a hidden upcall. However, it is necessary to take the Machine.Objects 
+			lock here since writing the set of variables here must not be interrupted, i.e. atomic writing of the set of variables
+			is absolutely necessary.  They system may hang if the lock is not taken. *)
 		PROCEDURE SetgcOngoing( value: BOOLEAN );	
 		VAR cur: Process;
 		BEGIN (* serialize writers *)
 			cur := CurrentProcess();
 			IF value THEN
-			(*	IF Machine.AcquireGC( ) THEN	*)
 				Machine.Acquire( Machine.Objects );	
 				Machine.Acquire( Machine.Heaps );
 				cur.context.r_sp := Machine.CurrentSP();
@@ -327,13 +326,12 @@ TYPE
 				cur.context.r_pc := ADDRESS OF GCLoop;
 					
 				SuspendActivities;
-				
-				Heaps.CollectGarbage( Modules.root );				
+				Heaps.CollectGarbage( Modules.root );
+					
 				Machine.Release( Machine.Heaps );
 				Machine.Release( Machine.Objects );
 				ResumeActivities;
 				finalizerCaller.Activate;
-			(*	END	*)
 			END;	
 		END SetgcOngoing;
 	
@@ -346,7 +344,6 @@ TYPE
 	BEGIN
 		Unix.MtxLock( startProcess );
 			p := newProcess;  newProcess := NIL;
-			p.threadId := Unix.ThrThis(0);  
 			p.id := nextPID;  INC( nextPID );
 			p.stackBottom := Machine.CurrentBP( );
 			S.GET( p.stackBottom, prevBP );
@@ -354,7 +351,7 @@ TYPE
 			Unix.MtxLock( processList );
 				p.nextProcess := root;  root := p;
 			Unix.MtxUnlock( processList );
-			Unix.ConSignal( childrunning );
+			Unix.CondSignal( childrunning );
 		Unix.MtxUnlock( startProcess );
 
 		p.SetPriority( p.priority );
@@ -384,7 +381,7 @@ TYPE
 		Unix.MtxLock(lockMutex);
 		IF hdr.lock = NIL THEN
 			hdr.lock := lock;
-			lock.mtx := Unix.MtxInit( 0 );  lock.enter := Unix.ConInit( 0 );  hdr.lockedBy := NIL; 
+			lock.mtx := Unix.NewMtx( );  lock.enter := Unix.NewCond( );  hdr.lockedBy := NIL; 
 		END;
 		Unix.MtxUnlock(lockMutex);
 	END InitProtHeader;
@@ -420,7 +417,7 @@ TYPE
 		WHILE hdr.lockedBy # NIL DO
 			(* wait until threads with complied AWAIT conditions have left the monitor *)
 			p.mode := AwaitingLock;
-			Unix.ConWait( lock.enter, lock.mtx );
+			Unix.CondWait( lock.enter, lock.mtx );
 		END;
 		p.mode := Running;  hdr.lockedBy := p;  p.waitingOn := NIL
 	END Lock;
@@ -440,11 +437,11 @@ TYPE
 		
 		Put( hdr.awaitingCond, p );
 		hdr.lockedBy := c;
-		IF c # NIL THEN  Unix.ConSignal( c.continue )  ELSE  Unix.ConSignal( lock.enter )  END;
+		IF c # NIL THEN  Unix.CondSignal( c.continue )  ELSE  Unix.CondSignal( lock.enter )  END;
 
 		p.context.r_sp := Machine.CurrentSP( );
 		p.context.r_bp := Machine.CurrentBP( );
-		Unix.ConWait( p.continue, lock.mtx );   
+		Unix.CondWait( p.continue, lock.mtx );   
 		
 		p.mode := Running;  hdr.lockedBy := p;  p.waitingOn := NIL
 	END Await;
@@ -457,7 +454,7 @@ TYPE
 		IF hdr.awaitingCond.head # NIL THEN  c := FindCondition( hdr.awaitingCond )  END;
 		
 		hdr.lockedBy := c;
-		IF c # NIL THEN  Unix.ConSignal( c.continue )  ELSE  Unix.ConSignal( lock.enter )  END;
+		IF c # NIL THEN  Unix.CondSignal( c.continue )  ELSE  Unix.CondSignal( lock.enter )  END;
 		Unix.MtxUnlock( lock.mtx );
 	END Unlock;
 	
@@ -522,14 +519,14 @@ TYPE
 
 	PROCEDURE Yield*;	(* Relinquish control. *)
 	BEGIN
-		Unix.ThrYield(0);
+		Unix.ThrYield( );
 	END Yield;
 	
 	(* Return current process. (DEPRECATED, use ActiveObject) *)
 	PROCEDURE CurrentProcess*( ): Process;	
 	VAR me: Unix.Thread_t;  p: Process;
 	BEGIN
-		me := Unix.ThrThis(0);
+		me := Unix.ThrThis( );
 		Unix.MtxLock( processList );
 		p := root;
 		WHILE (p # NIL) & (p.threadId # me) DO  p := p.nextProcess  END;
@@ -540,7 +537,7 @@ TYPE
 	PROCEDURE CurrentProcess0( ): Process;	
 	VAR me: Unix.Thread_t;  p: Process;
 	BEGIN
-		me := Unix.ThrThis(0);
+		me := Unix.ThrThis( );
 		p := root;
 		WHILE (p # NIL) & (p.threadId # me) DO  p := p.nextProcess  END;
 		RETURN p
@@ -610,7 +607,7 @@ TYPE
 		Unix.MtxUnlock( processList );
 		IF (p # NIL) & (p.obj = obj) THEN
 			p.mode := Terminated;
-			Unix.ConDestroy( p.continue );  p.continue := 0;
+			Unix.CondDestroy( p.continue );  p.continue := 0;
 			FinalizeProtObject( obj );
 			p.Cancel
 		END;
@@ -632,7 +629,7 @@ TYPE
 	BEGIN
 		p := obj(Process);
 		IF p.continue # 0 THEN
-			Unix.ConDestroy( p.continue );  p.continue := 0
+			Unix.CondDestroy( p.continue );  p.continue := 0
 		END
 	END FinalizeProcess;
 	
@@ -649,7 +646,7 @@ TYPE
 				IF prev = NIL THEN  root := p.nextProcess  ELSE  prev.nextProcess := p.nextProcess  END;
 			END;
 		Unix.MtxUnlock( processList );
-		Unix.ThrExit(0);
+		Unix.ThrExit( );
 	END Exit;
 
 	PROCEDURE ExitTrap*;
@@ -814,7 +811,7 @@ TYPE
 	
 	PROCEDURE StartTimerActivity;
 	BEGIN
-		timerListMutex := Unix.MtxInit(0);  timers := NIL;  
+		timerListMutex := Unix.NewMtx( );  timers := NIL;  
 		NEW( timerActivity );
 	END StartTimerActivity;
 
@@ -846,9 +843,9 @@ TYPE
 	BEGIN
 		Unix.suspendHandler := GetContext;
 		
-		createProcess := Unix.MtxInit( 0 );  processList := Unix.MtxInit( 0 );
-		startProcess := Unix.MtxInit(0);  childrunning := Unix.ConInit(0); 
-		lockMutex := Unix.MtxInit(0);
+		createProcess := Unix.NewMtx( );  processList := Unix.NewMtx( );
+		startProcess := Unix.NewMtx( );  childrunning := Unix.NewCond( ); 
+		lockMutex := Unix.NewMtx( );
 											
 		GetStacksize;  
 		Convert;
@@ -881,7 +878,7 @@ VAR main: MainThread;
 	BEGIN
 		NEW( main );
 		main.Await( );
-		Unix.exit(0);
+		Unix.exit( 0 );
 	END MainThreadSleep;
 	
 	PROCEDURE {FINAL} Final;

source/Generic.Unix.Traps.Mod

@@ -263,7 +263,7 @@ VAR
 	END SearchExceptionHandler;
 
 
-	PROCEDURE SignalHandler( signal: LONGINT;  scp, ucp, dummy: ADDRESS );
+	PROCEDURE SignalHandler( signal: LONGINT;  scp, ucp: ADDRESS );
 		(* 'dummy' for 16 byte stack alignment, MacOS! *)
 	BEGIN
 		IF ~(signal IN  {1, 2, 14, 15}) (* SIGHUP, SIGINT, SIGALRM, SIGTERM *) THEN
@@ -274,7 +274,7 @@ VAR
 
 
 BEGIN
-	trapMutex := Unix.RecursiveMtxInit(0);
+	trapMutex := Unix.NewRecursiveMtx( );
 	trace := FALSE;  
 	Unix.InstallSignalHandler( SignalHandler );
 	unix := StdIO.env