64bit; mkSmallInteger
authorClaus Gittinger <cg@exept.de>
Fri, 08 Jul 2005 19:15:03 +0200
changeset 8913 b9498d27a554
parent 8912 3d1947a79cf3
child 8914 acac69ff65b0
64bit; mkSmallInteger
AbstractOperatingSystem.st
Array.st
Behavior.st
Block.st
ByteArray.st
CharacterArray.st
CharacterEncoderImplementations__JIS0208_to_EUC.st
CharacterEncoderImplementations__SJIS.st
CharacterWriteStream.st
CompiledCode.st
Context.st
Continuation.st
DirectoryStream.st
Encoder_JIS0208_to_EUC.st
Encoder_SJIS.st
ExecutableFunction.st
ExternalAddress.st
ExternalBytes.st
ExternalFunction.st
ExternalStream.st
FileStream.st
Float.st
FloatArray.st
Fraction.st
Integer.st
LargeInteger.st
LongFloat.st
MD5Stream.st
Method.st
Object.st
ObjectMemory.st
OpenVMSOperatingSystem.st
Process.st
ProcessorScheduler.st
ReadStream.st
ShortFloat.st
SmallInteger.st
Smalltalk.st
String.st
Symbol.st
UninterpretedBytes.st
UnixOperatingSystem.st
WeakArray.st
WriteStream.st
--- a/AbstractOperatingSystem.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/AbstractOperatingSystem.st	Fri Jul 08 19:15:03 2005 +0200
@@ -3986,167 +3986,167 @@
 
 #ifdef AF_INET
     else if ((aSymbolOrInteger == @symbol(AF_INET)) || (aSymbolOrInteger == @symbol(inet)))
-       domainCode = __MKSMALLINT(AF_INET);
+       domainCode = __mkSmallInteger(AF_INET);
 #endif
 #ifdef AF_INET6
     else if ((aSymbolOrInteger == @symbol(AF_INET6)) || (aSymbolOrInteger == @symbol(inet6)))
-       domainCode = __MKSMALLINT(AF_INET6);
+       domainCode = __mkSmallInteger(AF_INET6);
 #endif
 #ifdef AF_UNIX
     else if ((aSymbolOrInteger == @symbol(AF_UNIX)) || (aSymbolOrInteger == @symbol(unix)))
-       domainCode = __MKSMALLINT(AF_UNIX);
+       domainCode = __mkSmallInteger(AF_UNIX);
 #endif
 #ifdef AF_APPLETALK
     else if ((aSymbolOrInteger == @symbol(AF_APPLETALK)) || (aSymbolOrInteger == @symbol(appletalk)))
-       domainCode = __MKSMALLINT(AF_APPLETALK);
+       domainCode = __mkSmallInteger(AF_APPLETALK);
 #endif
 #ifdef AF_DECnet
     else if ((aSymbolOrInteger == @symbol(AF_DECnet)) || (aSymbolOrInteger == @symbol(decnet)))
-       domainCode = __MKSMALLINT(AF_DECnet);
+       domainCode = __mkSmallInteger(AF_DECnet);
 #endif
 #ifdef AF_NS
     else if ((aSymbolOrInteger == @symbol(AF_NS)) || (aSymbolOrInteger == @symbol(ns)))
-       domainCode = __MKSMALLINT(AF_NS);
+       domainCode = __mkSmallInteger(AF_NS);
 #endif
 #ifdef AF_X25
     else if ((aSymbolOrInteger == @symbol(AF_X25)) || (aSymbolOrInteger == @symbol(x25)))
-       domainCode = __MKSMALLINT(AF_X25);
+       domainCode = __mkSmallInteger(AF_X25);
 #endif
 #ifdef AF_SNA
     else if (aSymbolOrInteger == @symbol(AF_SNA))
-       domainCode = __MKSMALLINT(AF_SNA);
+       domainCode = __mkSmallInteger(AF_SNA);
 #endif
 #ifdef AF_RAW
     else if ((aSymbolOrInteger == @symbol(AF_RAW)) || (aSymbolOrInteger == @symbol(raw)))
-       domainCode = __MKSMALLINT(AF_RAW);
+       domainCode = __mkSmallInteger(AF_RAW);
 #endif
 #ifdef AF_ISO
     else if ((aSymbolOrInteger == @symbol(AF_ISO)) || (aSymbolOrInteger == @symbol(iso)))
-       domainCode = __MKSMALLINT(AF_ISO);
+       domainCode = __mkSmallInteger(AF_ISO);
 #endif
 #ifdef AF_ECMA
     else if (aSymbolOrInteger == @symbol(AF_ECMA))
-       domainCode = __MKSMALLINT(AF_ECMA);
+       domainCode = __mkSmallInteger(AF_ECMA);
 #endif
 #ifdef AF_NETBIOS
     else if ((aSymbolOrInteger == @symbol(AF_NETBIOS)) || (aSymbolOrInteger == @symbol(netbios)))
-       domainCode = __MKSMALLINT(AF_NETBIOS);
+       domainCode = __mkSmallInteger(AF_NETBIOS);
 #endif
 #ifdef AF_NETBEUI
     else if (aSymbolOrInteger == @symbol(AF_NETBEUI))
-       domainCode = __MKSMALLINT(AF_NETBEUI);
+       domainCode = __mkSmallInteger(AF_NETBEUI);
 #endif
 #ifdef AF_IPX
     else if (aSymbolOrInteger == @symbol(AF_IPX))
-       domainCode = __MKSMALLINT(AF_IPX);
+       domainCode = __mkSmallInteger(AF_IPX);
 #endif
 #ifdef AF_AX25
     else if (aSymbolOrInteger == @symbol(AF_AX25))
-       domainCode = __MKSMALLINT(AF_AX25);
+       domainCode = __mkSmallInteger(AF_AX25);
 #endif
 #ifdef AF_NETROM
     else if (aSymbolOrInteger == @symbol(AF_NETROM))
-       domainCode = __MKSMALLINT(AF_NETROM);
+       domainCode = __mkSmallInteger(AF_NETROM);
 #endif
 #ifdef AF_BRIDGE
     else if (aSymbolOrInteger == @symbol(AF_BRIDGE))
-       domainCode = __MKSMALLINT(AF_BRIDGE);
+       domainCode = __mkSmallInteger(AF_BRIDGE);
 #endif
 #ifdef AF_BSC
     else if (aSymbolOrInteger == @symbol(AF_BSC))
-       domainCode = __MKSMALLINT(AF_BSC);
+       domainCode = __mkSmallInteger(AF_BSC);
 #endif
 #ifdef AF_ROSE
     else if (aSymbolOrInteger == @symbol(AF_ROSE))
-       domainCode = __MKSMALLINT(AF_ROSE);
+       domainCode = __mkSmallInteger(AF_ROSE);
 #endif
 #ifdef AF_IRDA
     else if ((aSymbolOrInteger == @symbol(AF_IRDA)) || (aSymbolOrInteger == @symbol(irda)))
-       domainCode = __MKSMALLINT(AF_IRDA);
+       domainCode = __mkSmallInteger(AF_IRDA);
 #endif
 #ifdef AF_BAN
     else if (aSymbolOrInteger == @symbol(AF_BAN))
-       domainCode = __MKSMALLINT(AF_BAN);
+       domainCode = __mkSmallInteger(AF_BAN);
 #endif
 #ifdef AF_VOICEVIEW
     else if (aSymbolOrInteger == @symbol(AF_VOICEVIEW))
-       domainCode = __MKSMALLINT(AF_VOICEVIEW);
+       domainCode = __mkSmallInteger(AF_VOICEVIEW);
 #endif
 #ifdef AF_ATM
     else if (aSymbolOrInteger == @symbol(AF_ATM))
-       domainCode = __MKSMALLINT(AF_ATM);
+       domainCode = __mkSmallInteger(AF_ATM);
 #endif
 #ifdef AF_ATMPVC
     else if (aSymbolOrInteger == @symbol(AF_ATMPVC))
-       domainCode = __MKSMALLINT(AF_ATMPVC);
+       domainCode = __mkSmallInteger(AF_ATMPVC);
 #endif
 #ifdef AF_ATMSVC
     else if (aSymbolOrInteger == @symbol(AF_ATMSVC))
-       domainCode = __MKSMALLINT(AF_ATMSVC);
+       domainCode = __mkSmallInteger(AF_ATMSVC);
 #endif
 #ifdef AF_SECURITY
     else if (aSymbolOrInteger == @symbol(AF_SECURITY))
-       domainCode = __MKSMALLINT(AF_SECURITY);
+       domainCode = __mkSmallInteger(AF_SECURITY);
 #endif
 #ifdef AF_KEY
     else if (aSymbolOrInteger == @symbol(AF_KEY))
-       domainCode = __MKSMALLINT(AF_KEY);
+       domainCode = __mkSmallInteger(AF_KEY);
 #endif
 #ifdef AF_NETLINK
     else if (aSymbolOrInteger == @symbol(AF_NETLINK))
-       domainCode = __MKSMALLINT(AF_NETLINK);
+       domainCode = __mkSmallInteger(AF_NETLINK);
 #endif
 #ifdef AF_PACKET
     else if (aSymbolOrInteger == @symbol(AF_PACKET))
-       domainCode = __MKSMALLINT(AF_PACKET);
+       domainCode = __mkSmallInteger(AF_PACKET);
 #endif
 #ifdef AF_ASH
     else if (aSymbolOrInteger == @symbol(AF_ASH))
-       domainCode = __MKSMALLINT(AF_ASH);
+       domainCode = __mkSmallInteger(AF_ASH);
 #endif
 #ifdef AF_ECONET
     else if (aSymbolOrInteger == @symbol(AF_ECONET))
-       domainCode = __MKSMALLINT(AF_ECONET);
+       domainCode = __mkSmallInteger(AF_ECONET);
 #endif
 #ifdef AF_IMPLINK
     else if (aSymbolOrInteger == @symbol(AF_IMPLINK))
-       domainCode = __MKSMALLINT(AF_IMPLINK);
+       domainCode = __mkSmallInteger(AF_IMPLINK);
 #endif
 #ifdef AF_PUP
     else if (aSymbolOrInteger == @symbol(AF_PUP))
-       domainCode = __MKSMALLINT(AF_PUP);
+       domainCode = __mkSmallInteger(AF_PUP);
 #endif
 #ifdef AF_CHAOS
     else if (aSymbolOrInteger == @symbol(AF_CHAOS))
-       domainCode = __MKSMALLINT(AF_CHAOS);
+       domainCode = __mkSmallInteger(AF_CHAOS);
 #endif
 #ifdef AF_DLI
     else if (aSymbolOrInteger == @symbol(AF_DLI))
-       domainCode = __MKSMALLINT(AF_DLI);
+       domainCode = __mkSmallInteger(AF_DLI);
 #endif
 #ifdef AF_LAT
     else if (aSymbolOrInteger == @symbol(AF_LAT))
-       domainCode = __MKSMALLINT(AF_LAT);
+       domainCode = __mkSmallInteger(AF_LAT);
 #endif
 #ifdef AF_HYLINK
     else if (aSymbolOrInteger == @symbol(AF_HYLINK))
-       domainCode = __MKSMALLINT(AF_HYLINK);
+       domainCode = __mkSmallInteger(AF_HYLINK);
 #endif
 #ifdef AF_FIREFOX
     else if (aSymbolOrInteger == @symbol(AF_FIREFOX))
-       domainCode = __MKSMALLINT(AF_FIREFOX);
+       domainCode = __mkSmallInteger(AF_FIREFOX);
 #endif
 #ifdef AF_CLUSTER
     else if (aSymbolOrInteger == @symbol(AF_CLUSTER))
-       domainCode = __MKSMALLINT(AF_CLUSTER);
+       domainCode = __mkSmallInteger(AF_CLUSTER);
 #endif
 #ifdef AF_12844
     else if (aSymbolOrInteger == @symbol(AF_12844))
-       domainCode = __MKSMALLINT(AF_12844);
+       domainCode = __mkSmallInteger(AF_12844);
 #endif
 #ifdef AF_NETDES
     else if (aSymbolOrInteger == @symbol(AF_NETDES))
-       domainCode = __MKSMALLINT(AF_NETDES);
+       domainCode = __mkSmallInteger(AF_NETDES);
 #endif
 %}.
 
@@ -4410,39 +4410,39 @@
 
 #ifdef IPPROTO_IP
     else if ((aSymbolOrInteger == @symbol(IPPROTO_IP)) || (aSymbolOrInteger == @symbol(ip)))
-       protocolCode = __MKSMALLINT(IPPROTO_IP);
+       protocolCode = __mkSmallInteger(IPPROTO_IP);
 #endif
 #ifdef IPPROTO_ICMP
     else if ((aSymbolOrInteger == @symbol(IPPROTO_ICMP)) || (aSymbolOrInteger == @symbol(icmp)))
-       protocolCode = __MKSMALLINT(IPPROTO_ICMP);
+       protocolCode = __mkSmallInteger(IPPROTO_ICMP);
 #endif
 #ifdef IPPROTO_IGMP
     else if ((aSymbolOrInteger == @symbol(IPPROTO_IGMP)) || (aSymbolOrInteger == @symbol(igmp)))
-       protocolCode = __MKSMALLINT(IPPROTO_IGMP);
+       protocolCode = __mkSmallInteger(IPPROTO_IGMP);
 #endif
 #ifdef IPPROTO_GGP
     else if ((aSymbolOrInteger == @symbol(IPPROTO_GGP)) || (aSymbolOrInteger == @symbol(ggp)))
-       protocolCode = __MKSMALLINT(IPPROTO_GGP);
+       protocolCode = __mkSmallInteger(IPPROTO_GGP);
 #endif
 #ifdef IPPROTO_TCP
     else if ((aSymbolOrInteger == @symbol(IPPROTO_TCP)) || (aSymbolOrInteger == @symbol(tcp)))
-       protocolCode = __MKSMALLINT(IPPROTO_TCP);
+       protocolCode = __mkSmallInteger(IPPROTO_TCP);
 #endif
 #ifdef IPPROTO_UDP
     else if ((aSymbolOrInteger == @symbol(IPPROTO_UDP)) || (aSymbolOrInteger == @symbol(udp)))
-       protocolCode = __MKSMALLINT(IPPROTO_UDP);
+       protocolCode = __mkSmallInteger(IPPROTO_UDP);
 #endif
 #ifdef IPPROTO_IDP
     else if ((aSymbolOrInteger == @symbol(IPPROTO_IDP)) || (aSymbolOrInteger == @symbol(idp)))
-       protocolCode = __MKSMALLINT(IPPROTO_IDP);
+       protocolCode = __mkSmallInteger(IPPROTO_IDP);
 #endif
 #ifdef IPPROTO_ND
     else if ((aSymbolOrInteger == @symbol(IPPROTO_ND)) || (aSymbolOrInteger == @symbol(nd)))
-       protocolCode = __MKSMALLINT(IPPROTO_ND);
+       protocolCode = __mkSmallInteger(IPPROTO_ND);
 #endif
 #ifdef IPPROTO_RAW
     else if ((aSymbolOrInteger == @symbol(IPPROTO_RAW)) || (aSymbolOrInteger == @symbol(raw)))
-       protocolCode = __MKSMALLINT(IPPROTO_RAW);
+       protocolCode = __mkSmallInteger(IPPROTO_RAW);
 #endif
 %}.
 
@@ -4554,201 +4554,201 @@
 	switch (__intVal(domainCode)) {
 #ifdef AF_INET
 	    case AF_INET:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_in) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_in) );
 		break;
 #endif
 #ifdef AF_INET6
 	    case AF_INET6:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_in6) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_in6) );
 		break;
 #endif
 #ifdef AF_UNIX
 	    case AF_UNIX:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_un) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_un) );
 		break;
 #endif
 #ifdef AF_APPLETALK
 	    case AF_APPLETALK:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_at) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_at) );
 		break;
 #endif
 #ifdef AF_DECnet
 	    case AF_DECnet:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_dn) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_dn) );
 		break;
 #endif
 #ifdef AF_NS
 	    case AF_NS:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_ns) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_ns) );
 		break;
 #endif
 #ifdef AF_X25
 	    case AF_X25:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_x25) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_x25) );
 		break;
 #endif
 #ifdef AF_SNA
 	    case AF_SNA:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_sna) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_sna) );
 		break;
 #endif
 #ifdef AF_RAW
 	    case AF_RAW:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_raw) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_raw) );
 		break;
 #endif
 #ifdef AF_ISO
 	    case AF_ISO:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_iso) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_iso) );
 		break;
 #endif
 #ifdef AF_ECMA
 # if 0
 	    case AF_ECMA:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_ecma) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_ecma) );
 		break;
 # endif
 #endif
 #ifdef AF_NETBIOS
 	    case AF_NETBIOS:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_netbios) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_netbios) );
 		break;
 #endif
 #ifdef AF_NETBEUI
 	    case AF_NETBEUI:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_netbeui) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_netbeui) );
 		break;
 #endif
 #ifdef AF_IPX
 	    case AF_IPX:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_ipx) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_ipx) );
 		break;
 #endif
 #ifdef AF_AX25
 	    case AF_AX25:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_ax25) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_ax25) );
 		break;
 #endif
 #ifdef AF_NETROM
 	    case AF_NETROM:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_netrom) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_netrom) );
 		break;
 #endif
 #ifdef AF_BRIDGE
 	    case AF_BRIDGE:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_bridge) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_bridge) );
 		break;
 #endif
 #ifdef AF_BSC
 	    case AF_BSC:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_bsc) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_bsc) );
 		break;
 #endif
 #ifdef AF_ROSE
 	    case AF_ROSE:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_rose) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_rose) );
 		break;
 #endif
 #ifdef AF_IRDA
 	    case AF_IRDA:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_irda) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_irda) );
 		break;
 #endif
 #ifdef AF_BAN
 	    case AF_BAN:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_ban) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_ban) );
 		break;
 #endif
 #ifdef AF_VOICEVIEW
 	    case AF_VOICEVIEW:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_voiceview) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_voiceview) );
 		break;
 #endif
 #ifdef AF_ATM
 	    case AF_ATM:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_atm) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_atm) );
 		break;
 #endif
 #ifdef AF_ATMPVC
 	    case AF_ATMPVC:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_atmpvc) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_atmpvc) );
 		break;
 #endif
 #ifdef AF_ATMSVC
 	    case AF_ATMSVC:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_atmsvc) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_atmsvc) );
 		break;
 #endif
 #ifdef AF_NETLINK
 	    case AF_NETLINK:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_netlink) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_netlink) );
 		break;
 #endif
 #ifdef AF_PACKET
 	    case AF_PACKET:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_packet) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_packet) );
 		break;
 #endif
 #ifdef AF_ASH
 	    case AF_ASH:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_ash) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_ash) );
 		break;
 #endif
 #ifdef AF_ECONET
 	    case AF_ECONET:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_eco) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_eco) );
 		break;
 #endif
 #ifdef AF_IMPLINK
 	    case AF_IMPLINK:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_implink) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_implink) );
 		break;
 #endif
 #ifdef AF_PUP
 # if 0
 	    case AF_PUP:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_pup) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_pup) );
 		break;
 # endif
 #endif
 #ifdef AF_CHAOS
 	    case AF_CHAOS:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_chaos) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_chaos) );
 		break;
 #endif
 #ifdef AF_DLI
 	    case AF_DLI:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_dli) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_dli) );
 		break;
 #endif
 #ifdef AF_LAT
 	    case AF_LAT:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_lat) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_lat) );
 		break;
 #endif
 #ifdef AF_HYLINK
 	    case AF_HYLINK:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_hylink) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_hylink) );
 		break;
 #endif
 #ifdef AF_FIREFOX
 	    case AF_FIREFOX:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_firefox) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_firefox) );
 		break;
 #endif
 #ifdef AF_CLUSTER
 	    case AF_CLUSTER:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_cluster) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_cluster) );
 		break;
 #endif
 #ifdef AF_12844
 	    case AF_12844:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_12844) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_12844) );
 		break;
 #endif
 #ifdef AF_NETDES
 	    case AF_NETDES:
-		socketSize = __MKSMALLINT( sizeof(struct sockaddr_netdes) );
+		socketSize = __mkSmallInteger( sizeof(struct sockaddr_netdes) );
 		break;
 #endif
 	}
@@ -4777,27 +4777,27 @@
 
 #ifdef SOCK_STREAM
      else if ((aSymbolOrInteger == @symbol(stream)) || (aSymbolOrInteger == @symbol(SOCK_STREAM)))
-	typeCode = __MKSMALLINT(SOCK_STREAM);
+	typeCode = __mkSmallInteger(SOCK_STREAM);
 #endif
 #ifdef SOCK_DGRAM
      else if ((aSymbolOrInteger == @symbol(datagram)) || (aSymbolOrInteger == @symbol(SOCK_DGRAM)))
-	typeCode = __MKSMALLINT(SOCK_DGRAM);
+	typeCode = __mkSmallInteger(SOCK_DGRAM);
 #endif
 #ifdef SOCK_RAW
      else if ((aSymbolOrInteger == @symbol(raw)) || (aSymbolOrInteger == @symbol(SOCK_RAW)))
-	typeCode = __MKSMALLINT(SOCK_RAW);
+	typeCode = __mkSmallInteger(SOCK_RAW);
 #endif
 #ifdef SOCK_RDM
      else if ((aSymbolOrInteger == @symbol(rdm)) || (aSymbolOrInteger == @symbol(SOCK_RDM)))
-	typeCode = __MKSMALLINT(SOCK_RDM);
+	typeCode = __mkSmallInteger(SOCK_RDM);
 #endif
 #ifdef SOCK_SEQPACKET
      else if ((aSymbolOrInteger == @symbol(seqpacket)) || (aSymbolOrInteger == @symbol(SOCK_SEQPACKET)))
-	typeCode = __MKSMALLINT(SOCK_SEQPACKET);
+	typeCode = __mkSmallInteger(SOCK_SEQPACKET);
 #endif
 #ifdef SOCK_PACKET
      else if ((aSymbolOrInteger == @symbol(packet)) || (aSymbolOrInteger == @symbol(SOCK_PACKET)))
-	typeCode = __MKSMALLINT(SOCK_PACKET);
+	typeCode = __mkSmallInteger(SOCK_PACKET);
 #endif
 %}.
 
@@ -5144,7 +5144,7 @@
      timer wraps."
 
 %{  /* NOCONTEXT */
-    RETURN ( __MKSMALLINT(0x0FFFFFFF) );
+    RETURN ( __mkSmallInteger(0x0FFFFFFF) );
 %}
 !
 
@@ -5790,7 +5790,7 @@
 !AbstractOperatingSystem class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/AbstractOperatingSystem.st,v 1.145 2005-07-07 15:01:51 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/AbstractOperatingSystem.st,v 1.146 2005-07-08 17:15:00 cg Exp $'
 ! !
 
 AbstractOperatingSystem initialize!
--- a/Array.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/Array.st	Fri Jul 08 19:15:03 2005 +0200
@@ -549,7 +549,7 @@
     if (nIndex <= actualSize) {
 
 	if (__isBlockLike(aBlock)
-	 && (__BlockInstPtr(aBlock)->b_nargs == __MKSMALLINT(1))) {
+	 && (__BlockInstPtr(aBlock)->b_nargs == __mkSmallInteger(1))) {
 	    {
 		/*
 		 * the most common case: a static compiled block, with home on the stack ...
@@ -777,7 +777,7 @@
 	    n = indexHigh - index;
 
 	    if (__isBlockLike(__aBlock)
-	     && (__BlockInstPtr(__aBlock)->b_nargs == __MKSMALLINT(1))) {
+	     && (__BlockInstPtr(__aBlock)->b_nargs == __mkSmallInteger(1))) {
 		{
 		    /*
 		     * the most common case: a static compiled block, with home on the stack ...
@@ -1045,7 +1045,7 @@
 	    indexHigh--;
 
 	    if (__isBlockLike(aBlock)
-	     && (__BlockInstPtr(aBlock)->b_nargs == __MKSMALLINT(1))) {
+	     && (__BlockInstPtr(aBlock)->b_nargs == __mkSmallInteger(1))) {
 #               undef BLOCK_ARG
 #ifdef NEW_BLOCK_CALL
 #               define BLOCK_ARG        aBlock
@@ -1113,21 +1113,21 @@
 
 %{
     REGISTER OBJFUNC codeVal;
-    REGISTER int index;
+    REGISTER INT index;
     static struct inlineCache val2 = _ILC2;
     REGISTER OBJ rHome;
     int actualSize;
     OBJ myClass;
 
     myClass = __qClass(self);
-    if ((__ClassInstPtr(myClass)->c_ninstvars) == __MKSMALLINT(0)) {
+    if ((__ClassInstPtr(myClass)->c_ninstvars) == __mkSmallInteger(0)) {
 
 	actualSize = __BYTES2OBJS__(__qSize(self) - OHDR_SIZE);
 	index = 0;
 
 	if (index < actualSize) {
 	    if (__isBlockLike(aBlock)
-	     && (__BlockInstPtr(aBlock)->b_nargs == __MKSMALLINT(2))) {
+	     && (__BlockInstPtr(aBlock)->b_nargs == __mkSmallInteger(2))) {
 		{
 		    /*
 		     * the most common case: a static compiled block, with home on the stack ...
@@ -1158,7 +1158,7 @@
 				if (InterruptPending != nil) goto interruptX;
 		continueX:
 				index++;
-				(*codeVal)(BLOCK_ARG, __MKSMALLINT(index), el);
+				(*codeVal)(BLOCK_ARG, __mkSmallInteger(index), el);
 			    }
 			    RETURN (self);
 
@@ -1192,7 +1192,7 @@
 		    el = __InstPtr(self)->i_instvars[index];
 		    index++;
 		    if ((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil) {
-			(*codeVal)(BLOCK_ARG, __MKSMALLINT(index), el);
+			(*codeVal)(BLOCK_ARG, __mkSmallInteger(index), el);
 		    } else {
 			if (__BlockInstPtr(aBlock)->b_bytecodes != nil) {
 			    /*
@@ -1203,19 +1203,19 @@
 			    {
 				OBJ t[2];
 
-				t[0] = __MKSMALLINT(index);
+				t[0] = __mkSmallInteger(index);
 				t[1] = el;
 
 				__interpret(aBlock, 2, nil, IBLOCK_ARG, nil, nil, t);
 			    }
 #else
-			    __interpret(aBlock, 2, nil, IBLOCK_ARG, nil, nil, __MKSMALLINT(index), el);
+			    __interpret(aBlock, 2, nil, IBLOCK_ARG, nil, nil, __mkSmallInteger(index), el);
 #endif
 			} else {
 			    (*val2.ilc_func)(aBlock, 
 						@symbol(value:value:), 
 						nil, &val2, 
-						__MKSMALLINT(index),
+						__mkSmallInteger(index),
 						el);
 			}
 		    }
@@ -1240,7 +1240,7 @@
 		(*val2.ilc_func)(aBlock, 
 				    @symbol(value:value:), 
 				    nil, &val2, 
-				    __MKSMALLINT(index),
+				    __mkSmallInteger(index),
 				    el);
 	    }
 	    RETURN ( self );
@@ -1274,7 +1274,7 @@
 
 	if (nIndex <= actualSize) {
 	    if (__isBlockLike(aBlock)
-	     && (__BlockInstPtr(aBlock)->b_nargs == __MKSMALLINT(1))) {
+	     && (__BlockInstPtr(aBlock)->b_nargs == __mkSmallInteger(1))) {
 #               undef BLOCK_ARG
 #ifdef NEW_BLOCK_CALL
 #               define BLOCK_ARG        aBlock
@@ -1448,7 +1448,7 @@
     OBJ myClass;
     
     if (
-	(__ClassInstPtr((myClass = __qClass(self)))->c_ninstvars == __MKSMALLINT(0))
+	(__ClassInstPtr((myClass = __qClass(self)))->c_ninstvars == __mkSmallInteger(0))
      && __isNonNilObject(aCollection)
      && (((t = __qClass(aCollection)) == Array) || (t == myClass))
      && __bothSmallInteger(start, stop)
@@ -1732,7 +1732,7 @@
 %{  /* NOCONTEXT */
     REGISTER OBJ slf = self;
 
-    RETURN ( __MKSMALLINT(__arraySize(slf) - __intVal(__ClassInstPtr(__qClass(slf))->c_ninstvars) ));
+    RETURN ( __mkSmallInteger(__arraySize(slf) - __intVal(__ClassInstPtr(__qClass(slf))->c_ninstvars) ));
 %}
 !
 
@@ -1772,7 +1772,7 @@
 %{  /* NOCONTEXT */
     REGISTER OBJ slf = self;
 
-    RETURN ( __MKSMALLINT(__arraySize(slf) - __intVal(__ClassInstPtr(__qClass(slf))->c_ninstvars) ));
+    RETURN ( __mkSmallInteger(__arraySize(slf) - __intVal(__ClassInstPtr(__qClass(slf))->c_ninstvars) ));
 %}
 ! !
 
@@ -1789,11 +1789,11 @@
 
 %{  /* NOCONTEXT */
 
-    REGISTER int index;
+    REGISTER INT index;
     REGISTER OBJ o, el1, el2;
     REGISTER OBJ *op;
-    REGISTER unsigned int nIndex;
-    int altIndex = 0;
+    REGISTER unsigned INT nIndex;
+    INT altIndex = 0;
     int nInsts;
 
     index = 0;
@@ -1804,7 +1804,7 @@
     op = & (__InstPtr(self)->i_instvars[index]);
     while (index++ < nIndex) {
 	if ((o = *op++) == el1) {
-	    RETURN ( __MKSMALLINT(index - nInsts) );
+	    RETURN ( __mkSmallInteger(index - nInsts) );
 	}
 	if (o == el2) {
 	    if (altIndex == 0) {
@@ -1812,7 +1812,7 @@
 	    }
 	}
     }
-    RETURN ( __MKSMALLINT(altIndex) );
+    RETURN ( __mkSmallInteger(altIndex) );
 %}.
     ^ super identityIndexOf:anElement or:alternative
 
@@ -1834,10 +1834,10 @@
 
 %{  /* NOCONTEXT */
 
-    REGISTER int index;
+    REGISTER INT index;
     REGISTER OBJ el;
     REGISTER OBJ *op;
-    REGISTER unsigned int nIndex;
+    REGISTER unsigned INT nIndex;
     int nInsts;
 
     if (__isSmallInteger(start)) {
@@ -1856,7 +1856,7 @@
 		p = memsrch4(op, (INT)el, (nIndex - index));
 		if (p) {
 		    index += (p - op + 1);
-		    RETURN ( __MKSMALLINT(index) ); 
+		    RETURN ( __mkSmallInteger(index) ); 
 		}
 	    }
 #else
@@ -1898,21 +1898,21 @@
 		}
 		if (0) {
 		    found1:
-			RETURN ( __MKSMALLINT(index + 1 - nInsts) );
+			RETURN ( __mkSmallInteger(index + 1 - nInsts) );
 		    found2:
-			RETURN ( __MKSMALLINT(index + 2 - nInsts) );
+			RETURN ( __mkSmallInteger(index + 2 - nInsts) );
 		    found3:
-			RETURN ( __MKSMALLINT(index + 3 - nInsts) );
+			RETURN ( __mkSmallInteger(index + 3 - nInsts) );
 		    found4:
-			RETURN ( __MKSMALLINT(index + 4 - nInsts) );
+			RETURN ( __mkSmallInteger(index + 4 - nInsts) );
 		    found5:
-			RETURN ( __MKSMALLINT(index + 5 - nInsts) );
+			RETURN ( __mkSmallInteger(index + 5 - nInsts) );
 		    found6:
-			RETURN ( __MKSMALLINT(index + 6 - nInsts) );
+			RETURN ( __mkSmallInteger(index + 6 - nInsts) );
 		    found7:
-			RETURN ( __MKSMALLINT(index + 7 - nInsts) );
+			RETURN ( __mkSmallInteger(index + 7 - nInsts) );
 		    found8:
-			RETURN ( __MKSMALLINT(index + 8 - nInsts) );
+			RETURN ( __mkSmallInteger(index + 8 - nInsts) );
 		}
 	    }
 # endif /* UNROLLED_LOOPS */
@@ -1923,11 +1923,11 @@
 
 	    if (0) {
 		found0:
-		    RETURN ( __MKSMALLINT(index - nInsts) );
+		    RETURN ( __mkSmallInteger(index - nInsts) );
 	    }
 #endif /* no memsrch */
 	}
-	RETURN ( __MKSMALLINT(0) );
+	RETURN ( __mkSmallInteger(0) );
     }
 %}.
     ^ super identityIndexOf:anElement startingAt:start
@@ -1940,11 +1940,11 @@
 
 %{  /* NOCONTEXT */
 
-    REGISTER int index;
+    REGISTER INT index;
     REGISTER OBJ el;
     REGISTER OBJ *op;
     REGISTER unsigned int lastIndex;
-    unsigned int nIndex;
+    unsigned INT nIndex;
     int nInsts;
 
     if (__bothSmallInteger(start, stop)) {
@@ -1967,7 +1967,7 @@
 		p = memsrch4(op, (INT)el, (lastIndex - index));
 		if (p) {
 		    index += (p - op + 1);
-		    RETURN ( __MKSMALLINT(index) ); 
+		    RETURN ( __mkSmallInteger(index) ); 
 		}
 	    }
 #else
@@ -1991,21 +1991,21 @@
 
 		if (0) {
 	    found1:
-		    RETURN ( __MKSMALLINT(index + 1 - nInsts) );
+		    RETURN ( __mkSmallInteger(index + 1 - nInsts) );
 	    found2:
-		    RETURN ( __MKSMALLINT(index + 2 - nInsts) );
+		    RETURN ( __mkSmallInteger(index + 2 - nInsts) );
 	    found3:
-		    RETURN ( __MKSMALLINT(index + 3 - nInsts) );
+		    RETURN ( __mkSmallInteger(index + 3 - nInsts) );
 	    found4:
-		    RETURN ( __MKSMALLINT(index + 4 - nInsts) );
+		    RETURN ( __mkSmallInteger(index + 4 - nInsts) );
 	    found5:
-		    RETURN ( __MKSMALLINT(index + 5 - nInsts) );
+		    RETURN ( __mkSmallInteger(index + 5 - nInsts) );
 	    found6:
-		    RETURN ( __MKSMALLINT(index + 6 - nInsts) );
+		    RETURN ( __mkSmallInteger(index + 6 - nInsts) );
 	    found7:
-		    RETURN ( __MKSMALLINT(index + 7 - nInsts) );
+		    RETURN ( __mkSmallInteger(index + 7 - nInsts) );
 	    found8:
-		    RETURN ( __MKSMALLINT(index + 8 - nInsts) );
+		    RETURN ( __mkSmallInteger(index + 8 - nInsts) );
 		}
 	    }
 # endif /* UNROLL_LOOPS */
@@ -2016,11 +2016,11 @@
 
 	    if (0) {
 		found0:
-		    RETURN ( __MKSMALLINT(index - nInsts) );
+		    RETURN ( __mkSmallInteger(index - nInsts) );
 	    }
 #endif
 	}
-	RETURN ( __MKSMALLINT(0) );
+	RETURN ( __mkSmallInteger(0) );
     }
 %}.
     ^ super identityIndexOf:anElement startingAt:start endingAt:stop
@@ -2033,8 +2033,9 @@
 
     |element|
 %{
-    REGISTER int index;
-    unsigned int nIndex, nInsts;
+    REGISTER INT index;
+    unsigned INT nIndex;
+    unsigned int nInsts;
     static struct inlineCache eq = _ILC1;
     OBJ myClass, e;
 
@@ -2059,15 +2060,15 @@
 			element = __InstPtr(self)->i_instvars[index++];
 			if (__isNonNilObject(element)) {
 			    if (element == e) {
-				RETURN ( __MKSMALLINT(index - nInsts) );
+				RETURN ( __mkSmallInteger(index - nInsts) );
 			    }
 			    if (__qClass(element) == @global(String)) {
 				if (strcmp(__stringVal(e), __stringVal(element)) == 0) {
-				    RETURN ( __MKSMALLINT(index - nInsts) );
+				    RETURN ( __mkSmallInteger(index - nInsts) );
 				}
 			    } else {
 				if ((*eq.ilc_func)(e, @symbol(=), nil,&eq, element) == true) {
-				    RETURN ( __MKSMALLINT(index - nInsts) );
+				    RETURN ( __mkSmallInteger(index - nInsts) );
 				}
 				/*
 				 * send of #= could have lead to a GC - refetch e
@@ -2076,7 +2077,7 @@
 			    }
 			}
 		    }
-		    RETURN (__MKSMALLINT(0));
+		    RETURN (__mkSmallInteger(0));
 		}
 #endif
 		if (__isSmallInteger(e)) {
@@ -2084,14 +2085,14 @@
 		    while (index < nIndex) {
 			element = __InstPtr(self)->i_instvars[index++];
 			if (element == e) {
-			    RETURN ( __MKSMALLINT(index - nInsts) );
+			    RETURN ( __mkSmallInteger(index - nInsts) );
 			}
 			if (!__isSmallInteger(element)) {
 			    if ((*eq.ilc_func)(e,
 						@symbol(=), 
 						nil,&eq,
 						element) == true) {
-				RETURN ( __MKSMALLINT(index - nInsts) );
+				RETURN ( __mkSmallInteger(index - nInsts) );
 			    }
 			    /*
 			     * send of #= could have lead to a GC - refetch e
@@ -2099,7 +2100,7 @@
 			    e = anElement;
 			}
 		    }
-		    RETURN (__MKSMALLINT(0));
+		    RETURN (__mkSmallInteger(0));
 		}
 
 		while (index < nIndex) {
@@ -2112,7 +2113,7 @@
 					    @symbol(=), 
 					    nil,&eq,
 					    element) == true)) {
-			    RETURN ( __MKSMALLINT(index - nInsts) );
+			    RETURN ( __mkSmallInteger(index - nInsts) );
 			}
 		    }
 		}
@@ -2127,14 +2128,14 @@
 		    unsigned int i8;
 
 		    while ((i8 = index + 8) < nIndex) {
-			if (__InstPtr(slf)->i_instvars[index] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 1) ); }
-			if (__InstPtr(slf)->i_instvars[index+1] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 2) ); }
-			if (__InstPtr(slf)->i_instvars[index+2] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 3) ); }
-			if (__InstPtr(slf)->i_instvars[index+3] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 4) ); }
-			if (__InstPtr(slf)->i_instvars[index+4] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 5) ); }
-			if (__InstPtr(slf)->i_instvars[index+5] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 6) ); }
-			if (__InstPtr(slf)->i_instvars[index+6] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 7) ); }
-			if (__InstPtr(slf)->i_instvars[index+7] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 8) ); }
+			if (__InstPtr(slf)->i_instvars[index] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 1) ); }
+			if (__InstPtr(slf)->i_instvars[index+1] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 2) ); }
+			if (__InstPtr(slf)->i_instvars[index+2] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 3) ); }
+			if (__InstPtr(slf)->i_instvars[index+3] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 4) ); }
+			if (__InstPtr(slf)->i_instvars[index+4] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 5) ); }
+			if (__InstPtr(slf)->i_instvars[index+5] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 6) ); }
+			if (__InstPtr(slf)->i_instvars[index+6] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 7) ); }
+			if (__InstPtr(slf)->i_instvars[index+7] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 8) ); }
 			index = i8;
 		    }
 		}
@@ -2142,12 +2143,12 @@
 
 		while (index < nIndex) {
 		    if (__InstPtr(slf)->i_instvars[index++] == nil) {
-			RETURN ( __MKSMALLINT(index - nInsts) );
+			RETURN ( __mkSmallInteger(index - nInsts) );
 		    }
 		}
 	    }
 	}
-	RETURN (__MKSMALLINT(0));
+	RETURN (__mkSmallInteger(0));
     }
 %}.
     ^ super indexOf:anElement startingAt:start
@@ -2160,8 +2161,9 @@
 
     |element|
 %{
-    REGISTER int index;
-    unsigned int lastIndex, nIndex, nInsts;
+    REGISTER INT index;
+    unsigned INT lastIndex, nIndex;
+    unsigned int nInsts;
     static struct inlineCache eq = _ILC1;
     OBJ myClass, e;
 
@@ -2191,15 +2193,15 @@
 			element = __InstPtr(self)->i_instvars[index++];
 			if (__isNonNilObject(element)) {
 			    if (element == e) {
-				RETURN ( __MKSMALLINT(index - nInsts) );
+				RETURN ( __mkSmallInteger(index - nInsts) );
 			    }
 			    if (__qClass(element) == @global(String)) {
 				if (strcmp(__stringVal(e), __stringVal(element)) == 0) {
-				    RETURN ( __MKSMALLINT(index - nInsts) );
+				    RETURN ( __mkSmallInteger(index - nInsts) );
 				}
 			    } else {
 				if ((*eq.ilc_func)(e, @symbol(=), nil,&eq, element) == true) {
-				    RETURN ( __MKSMALLINT(index - nInsts) );
+				    RETURN ( __mkSmallInteger(index - nInsts) );
 				}
 				/*
 				 * send of #= could have lead to a GC - refetch e
@@ -2208,7 +2210,7 @@
 			    }
 			}
 		    }
-		    RETURN (__MKSMALLINT(0));
+		    RETURN (__mkSmallInteger(0));
 		}
 #endif
 		if (__isSmallInteger(e)) {
@@ -2216,14 +2218,14 @@
 		    while (index < lastIndex) {
 			element = __InstPtr(self)->i_instvars[index++];
 			if (element == e) {
-			    RETURN ( __MKSMALLINT(index - nInsts) );
+			    RETURN ( __mkSmallInteger(index - nInsts) );
 			}
 			if (!__isSmallInteger(element)) {
 			    if ((*eq.ilc_func)(e,
 						@symbol(=), 
 						nil,&eq,
 						element) == true) {
-				RETURN ( __MKSMALLINT(index - nInsts) );
+				RETURN ( __mkSmallInteger(index - nInsts) );
 			    }
 			    /*
 			     * send of #= could have lead to a GC - refetch e
@@ -2231,7 +2233,7 @@
 			    e = anElement;
 			}
 		    }
-		    RETURN (__MKSMALLINT(0));
+		    RETURN (__mkSmallInteger(0));
 		}
 
 		while (index < lastIndex) {
@@ -2243,7 +2245,7 @@
 					    @symbol(=), 
 					    nil,&eq,
 					    element) == true)) {
-			    RETURN ( __MKSMALLINT(index - nInsts) );
+			    RETURN ( __mkSmallInteger(index - nInsts) );
 			}
 		    }
 		}
@@ -2258,26 +2260,26 @@
 		    unsigned int i8;
 
 		    while ((i8 = index + 8) < lastIndex) {
-			if (__InstPtr(slf)->i_instvars[index] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 1) ); }
-			if (__InstPtr(slf)->i_instvars[index+1] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 2) ); }
-			if (__InstPtr(slf)->i_instvars[index+2] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 3) ); }
-			if (__InstPtr(slf)->i_instvars[index+3] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 4) ); }
-			if (__InstPtr(slf)->i_instvars[index+4] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 5) ); }
-			if (__InstPtr(slf)->i_instvars[index+5] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 6) ); }
-			if (__InstPtr(slf)->i_instvars[index+6] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 7) ); }
-			if (__InstPtr(slf)->i_instvars[index+7] == nil) { RETURN ( __MKSMALLINT(index - nInsts + 8) ); }
+			if (__InstPtr(slf)->i_instvars[index] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 1) ); }
+			if (__InstPtr(slf)->i_instvars[index+1] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 2) ); }
+			if (__InstPtr(slf)->i_instvars[index+2] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 3) ); }
+			if (__InstPtr(slf)->i_instvars[index+3] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 4) ); }
+			if (__InstPtr(slf)->i_instvars[index+4] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 5) ); }
+			if (__InstPtr(slf)->i_instvars[index+5] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 6) ); }
+			if (__InstPtr(slf)->i_instvars[index+6] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 7) ); }
+			if (__InstPtr(slf)->i_instvars[index+7] == nil) { RETURN ( __mkSmallInteger(index - nInsts + 8) ); }
 			index = i8;
 		    }
 		}
 #endif
 		while (index < lastIndex) {
 		    if (__InstPtr(slf)->i_instvars[index++] == nil) {
-			RETURN ( __MKSMALLINT(index - nInsts) );
+			RETURN ( __mkSmallInteger(index - nInsts) );
 		    }
 		}
 	    }
 	}
-	RETURN (__MKSMALLINT(0));
+	RETURN (__mkSmallInteger(0));
     }
 %}.
     ^ super indexOf:anElement startingAt:start endingAt:stop
@@ -2498,5 +2500,5 @@
 !Array class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/Array.st,v 1.137 2005-07-07 15:01:51 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/Array.st,v 1.138 2005-07-08 17:15:00 cg Exp $'
 ! !
--- a/Behavior.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/Behavior.st	Fri Jul 08 19:15:03 2005 +0200
@@ -323,7 +323,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(BEHAVIOR_INSTS) );
+    RETURN ( __mkSmallInteger(BEHAVIOR_INSTS) );
 %}
 
     "consistency check:
@@ -365,7 +365,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(BLOCK_INSTS) );
+    RETURN ( __mkSmallInteger(BLOCK_INSTS) );
 %}
 !
 
@@ -377,7 +377,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(BCONTEXT_INSTS) );
+    RETURN ( __mkSmallInteger(BCONTEXT_INSTS) );
 %}
 !
 
@@ -391,7 +391,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(BLOCKLIKE_INSTS) );
+    RETURN ( __mkSmallInteger(BLOCKLIKE_INSTS) );
 %}
 !
 
@@ -404,7 +404,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(BYTEARRAY) );
+    RETURN ( __mkSmallInteger(BYTEARRAY) );
 %}
     "
      Behavior flagBytes    
@@ -419,7 +419,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(CONTEXT_INSTS) );
+    RETURN ( __mkSmallInteger(CONTEXT_INSTS) );
 %}
 !
 
@@ -432,7 +432,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(DOUBLEARRAY) );
+    RETURN ( __mkSmallInteger(DOUBLEARRAY) );
 %}
     "
      Behavior flagDoubles    
@@ -451,7 +451,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(EXTERNALBYTES_INSTS) );
+    RETURN ( __mkSmallInteger(EXTERNALBYTES_INSTS) );
 %}
 !
 
@@ -463,7 +463,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(FLOAT_INSTS) );
+    RETURN ( __mkSmallInteger(FLOAT_INSTS) );
 %}
 !
 
@@ -476,7 +476,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(FLOATARRAY) );
+    RETURN ( __mkSmallInteger(FLOATARRAY) );
 %}
     "
      Behavior flagFloats    
@@ -493,37 +493,37 @@
 
 %{   /* NOCONTEXT */
     if (aSymbol == @symbol(float)) {
-        RETURN ( __MKSMALLINT(FLOATARRAY) );
+        RETURN ( __mkSmallInteger(FLOATARRAY) );
     }
     if (aSymbol == @symbol(double)) {
-        RETURN ( __MKSMALLINT(DOUBLEARRAY) );
+        RETURN ( __mkSmallInteger(DOUBLEARRAY) );
     }
     if (aSymbol == @symbol(long)) {
-        RETURN ( __MKSMALLINT(LONGARRAY) );
+        RETURN ( __mkSmallInteger(LONGARRAY) );
     }
     if (aSymbol == @symbol(longLong)) {
-        RETURN ( __MKSMALLINT(LONGLONGARRAY) );
+        RETURN ( __mkSmallInteger(LONGLONGARRAY) );
     }
     if (aSymbol == @symbol(word)) {
-        RETURN ( __MKSMALLINT(WORDARRAY) );
+        RETURN ( __mkSmallInteger(WORDARRAY) );
     }
     if (aSymbol == @symbol(signedWord)) {
-        RETURN ( __MKSMALLINT(SWORDARRAY) );
+        RETURN ( __mkSmallInteger(SWORDARRAY) );
     }
     if (aSymbol == @symbol(signedLong)) {
-        RETURN ( __MKSMALLINT(SLONGARRAY) );
+        RETURN ( __mkSmallInteger(SLONGARRAY) );
     }
     if (aSymbol == @symbol(signedLongLong)) {
-        RETURN ( __MKSMALLINT(SLONGLONGARRAY) );
+        RETURN ( __mkSmallInteger(SLONGLONGARRAY) );
     }
     if ((aSymbol == @symbol(byte)) || (aSymbol == @symbol(bytes))) {
-        RETURN ( __MKSMALLINT(BYTEARRAY) );
+        RETURN ( __mkSmallInteger(BYTEARRAY) );
     }
     if (aSymbol == @symbol(objects)) {
-        RETURN ( __MKSMALLINT(POINTERARRAY) );
+        RETURN ( __mkSmallInteger(POINTERARRAY) );
     }
     if (aSymbol == @symbol(weakObjects)) {
-        RETURN ( __MKSMALLINT(WKPOINTERARRAY) );
+        RETURN ( __mkSmallInteger(WKPOINTERARRAY) );
     }
 %}.
     ^ 0         "/ not indexed
@@ -537,7 +537,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(JCLASS_INSTS) );
+    RETURN ( __mkSmallInteger(JCLASS_INSTS) );
 %}
 !
 
@@ -549,7 +549,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(JMETHOD_INSTS) );
+    RETURN ( __mkSmallInteger(JMETHOD_INSTS) );
 %}
 !
 
@@ -562,7 +562,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(LONGLONGARRAY) );
+    RETURN ( __mkSmallInteger(LONGLONGARRAY) );
 %}
     "
      Behavior flagLongLongs    
@@ -578,7 +578,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(LONGARRAY) );
+    RETURN ( __mkSmallInteger(LONGARRAY) );
 %}
     "
      Behavior flagLongs    
@@ -593,7 +593,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(METAMETHOD_INSTS) );
+    RETURN ( __mkSmallInteger(METAMETHOD_INSTS) );
 %}
 !
 
@@ -605,7 +605,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(METHOD_INSTS) );
+    RETURN ( __mkSmallInteger(METHOD_INSTS) );
 %}
 !
 
@@ -617,7 +617,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(NONOBJECT_INSTS) );
+    RETURN ( __mkSmallInteger(NONOBJECT_INSTS) );
 %}
 !
 
@@ -638,7 +638,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(POINTERARRAY) );
+    RETURN ( __mkSmallInteger(POINTERARRAY) );
 %}
     "
      Behavior flagPointers    
@@ -662,7 +662,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(SLONGLONGARRAY) );
+    RETURN ( __mkSmallInteger(SLONGLONGARRAY) );
 %}
     "
      Behavior flagSignedLongLongs
@@ -678,7 +678,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(SLONGARRAY) );
+    RETURN ( __mkSmallInteger(SLONGARRAY) );
 %}
     "
      Behavior flagSignedLongs
@@ -694,7 +694,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(SWORDARRAY) );
+    RETURN ( __mkSmallInteger(SWORDARRAY) );
 %}
     "
      Behavior flagSignedWords
@@ -709,7 +709,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(SYMBOL_INSTS) );
+    RETURN ( __mkSmallInteger(SYMBOL_INSTS) );
 %}
 !
 
@@ -721,7 +721,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(WKPOINTERARRAY) );
+    RETURN ( __mkSmallInteger(WKPOINTERARRAY) );
 %}
 !
 
@@ -734,7 +734,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(WORDARRAY) );
+    RETURN ( __mkSmallInteger(WORDARRAY) );
 %}
     "
      Behavior flagWords    
@@ -747,7 +747,7 @@
 %{  /* NOCONTEXT */
     /* this is defined as a primitive to get defines from stc.h */
 
-    RETURN ( __MKSMALLINT(ARRAYMASK) );
+    RETURN ( __mkSmallInteger(ARRAYMASK) );
 %}
 ! !
 
@@ -3822,7 +3822,7 @@
 		break;
 	}
     }
-    RETURN (__MKSMALLINT(nBytes));
+    RETURN (__mkSmallInteger(nBytes));
 %}
 ! !
 
@@ -4397,5 +4397,5 @@
 !Behavior class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/Behavior.st,v 1.246 2005-07-08 15:20:07 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/Behavior.st,v 1.247 2005-07-08 17:15:00 cg Exp $'
 ! !
--- a/Block.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/Block.st	Fri Jul 08 19:15:03 2005 +0200
@@ -702,7 +702,7 @@
     REGISTER OBJFUNC thecode;
     OBJ home;
 
-    if (__INST(nargs) == __MKSMALLINT(0)) {
+    if (__INST(nargs) == __mkSmallInteger(0)) {
 #if defined(THIS_CONTEXT)
         if (__ISVALID_ILC_LNO(__pilc))
             __ContextInstPtr(__thisContext)->c_lineno = __ILC_LNO_AS_OBJ(__pilc);
@@ -747,7 +747,7 @@
     REGISTER OBJFUNC thecode;
     OBJ home;
 
-    if (__INST(nargs) == __MKSMALLINT(1)) {
+    if (__INST(nargs) == __mkSmallInteger(1)) {
 #if defined(THIS_CONTEXT)
         if (__ISVALID_ILC_LNO(__pilc))
             __ContextInstPtr(__thisContext)->c_lineno = __ILC_LNO_AS_OBJ(__pilc);
@@ -789,7 +789,7 @@
     REGISTER OBJFUNC thecode;
     OBJ home;
 
-    if (__INST(nargs) == __MKSMALLINT(2)) {
+    if (__INST(nargs) == __mkSmallInteger(2)) {
 #if defined(THIS_CONTEXT)
         if (__ISVALID_ILC_LNO(__pilc))
             __ContextInstPtr(__thisContext)->c_lineno = __ILC_LNO_AS_OBJ(__pilc);
@@ -829,7 +829,7 @@
     REGISTER OBJFUNC thecode;
     OBJ home;
 
-    if (__INST(nargs) == __MKSMALLINT(3)) {
+    if (__INST(nargs) == __mkSmallInteger(3)) {
 #if defined(THIS_CONTEXT)
         if (__ISVALID_ILC_LNO(__pilc))
             __ContextInstPtr(__thisContext)->c_lineno = __ILC_LNO_AS_OBJ(__pilc);
@@ -869,7 +869,7 @@
     REGISTER OBJFUNC thecode;
     OBJ home;
 
-    if (__INST(nargs) == __MKSMALLINT(4)) {
+    if (__INST(nargs) == __mkSmallInteger(4)) {
 #if defined(THIS_CONTEXT)
         if (__ISVALID_ILC_LNO(__pilc))
             __ContextInstPtr(__thisContext)->c_lineno = __ILC_LNO_AS_OBJ(__pilc);
@@ -909,7 +909,7 @@
     REGISTER OBJFUNC thecode;
     OBJ home;
 
-    if (__INST(nargs) == __MKSMALLINT(5)) {
+    if (__INST(nargs) == __mkSmallInteger(5)) {
 #if defined(THIS_CONTEXT)
         if (__ISVALID_ILC_LNO(__pilc))
             __ContextInstPtr(__thisContext)->c_lineno = __ILC_LNO_AS_OBJ(__pilc);
@@ -949,7 +949,7 @@
     REGISTER OBJFUNC thecode;
     OBJ home;
 
-    if (__INST(nargs) == __MKSMALLINT(6)) {
+    if (__INST(nargs) == __mkSmallInteger(6)) {
 #if defined(THIS_CONTEXT)
         if (__ISVALID_ILC_LNO(__pilc))
             __ContextInstPtr(__thisContext)->c_lineno = __ILC_LNO_AS_OBJ(__pilc);
@@ -989,7 +989,7 @@
     REGISTER OBJFUNC thecode;
     OBJ home;
 
-    if (__INST(nargs) == __MKSMALLINT(7)) {
+    if (__INST(nargs) == __mkSmallInteger(7)) {
 #if defined(THIS_CONTEXT)
         if (__ISVALID_ILC_LNO(__pilc))
             __ContextInstPtr(__thisContext)->c_lineno = __ILC_LNO_AS_OBJ(__pilc);
@@ -1029,7 +1029,7 @@
     REGISTER OBJFUNC thecode;
     OBJ home;
 
-    if (__INST(nargs) == __MKSMALLINT(8)) {
+    if (__INST(nargs) == __mkSmallInteger(8)) {
 #if defined(THIS_CONTEXT)
         if (__ISVALID_ILC_LNO(__pilc))
             __ContextInstPtr(__thisContext)->c_lineno = __ILC_LNO_AS_OBJ(__pilc);
@@ -1119,7 +1119,7 @@
     if (thecode != (OBJFUNC)nil) {
         /* the most common case (0 args) here (without a switch) */
 
-        if (nA == __MKSMALLINT(0)) {
+        if (nA == __mkSmallInteger(0)) {
             RETURN ( (*thecode)(home) );
         }
 
@@ -1127,79 +1127,79 @@
         switch ((INT)(nA)) {
             default:
                 goto error;
-            case (INT)__MKSMALLINT(15):
+            case (INT)__mkSmallInteger(15):
                 RETURN ( (*thecode)(home, ap[0], ap[1], ap[2], ap[3], ap[4], ap[5], ap[6], ap[7], ap[8], ap[9], ap[10], ap[11], ap[12], ap[13], ap[14]) );
-            case (INT)__MKSMALLINT(14):
+            case (INT)__mkSmallInteger(14):
                 RETURN ( (*thecode)(home, ap[0], ap[1], ap[2], ap[3], ap[4], ap[5], ap[6], ap[7], ap[8], ap[9], ap[10], ap[11], ap[12], ap[13]) );
-            case (INT)__MKSMALLINT(13):
+            case (INT)__mkSmallInteger(13):
                 RETURN ( (*thecode)(home, ap[0], ap[1], ap[2], ap[3], ap[4], ap[5], ap[6], ap[7], ap[8], ap[9], ap[10], ap[11], ap[12]) );
-            case (INT)__MKSMALLINT(12):
+            case (INT)__mkSmallInteger(12):
                 RETURN ( (*thecode)(home, ap[0], ap[1], ap[2], ap[3], ap[4], ap[5], ap[6], ap[7], ap[8], ap[9], ap[10], ap[11]) );
-            case (INT)__MKSMALLINT(11):
+            case (INT)__mkSmallInteger(11):
                 RETURN ( (*thecode)(home, ap[0], ap[1], ap[2], ap[3], ap[4], ap[5], ap[6], ap[7], ap[8], ap[9], ap[10]) );
-            case (INT)__MKSMALLINT(10):
+            case (INT)__mkSmallInteger(10):
                 RETURN ( (*thecode)(home, ap[0], ap[1], ap[2], ap[3], ap[4], ap[5], ap[6], ap[7], ap[8], ap[9]) );
-            case (INT)__MKSMALLINT(9):
+            case (INT)__mkSmallInteger(9):
                 RETURN ( (*thecode)(home, ap[0], ap[1], ap[2], ap[3], ap[4], ap[5], ap[6], ap[7], ap[8]) );
-            case (INT)__MKSMALLINT(8):
+            case (INT)__mkSmallInteger(8):
                 RETURN ( (*thecode)(home, ap[0], ap[1], ap[2], ap[3], ap[4], ap[5], ap[6], ap[7]) );
-            case (INT)__MKSMALLINT(7):
+            case (INT)__mkSmallInteger(7):
                 RETURN ( (*thecode)(home, ap[0], ap[1], ap[2], ap[3], ap[4], ap[5], ap[6]) );
-            case (INT)__MKSMALLINT(6):
+            case (INT)__mkSmallInteger(6):
                 RETURN ( (*thecode)(home, ap[0], ap[1], ap[2], ap[3], ap[4], ap[5]) );
-            case (INT)__MKSMALLINT(5):
+            case (INT)__mkSmallInteger(5):
                 RETURN ( (*thecode)(home, ap[0], ap[1], ap[2], ap[3], ap[4]) );
-            case (INT)__MKSMALLINT(4):
+            case (INT)__mkSmallInteger(4):
                 RETURN ( (*thecode)(home, ap[0], ap[1], ap[2], ap[3]) );
-            case (INT)__MKSMALLINT(3):
+            case (INT)__mkSmallInteger(3):
                 RETURN ( (*thecode)(home, ap[0], ap[1], ap[2]) );
-            case (INT)__MKSMALLINT(2):
+            case (INT)__mkSmallInteger(2):
                 RETURN ( (*thecode)(home, ap[0], ap[1]) );
-            case (INT)__MKSMALLINT(1):
+            case (INT)__mkSmallInteger(1):
                 RETURN ( (*thecode)(home, ap[0]) );
-            case (INT)__MKSMALLINT(0):
+            case (INT)__mkSmallInteger(0):
                 RETURN ( (*thecode)(home) );
                 break;
         }
     }
 #endif
 
-    if (nA != __MKSMALLINT(0)) {
+    if (nA != __mkSmallInteger(0)) {
         ap = __arrayVal(argArray);   /* nonNil after above test (size is known to be ok) */
         switch ((INT)nA) {
             default:
                 goto error;
-            case (INT)__MKSMALLINT(15):
+            case (INT)__mkSmallInteger(15):
                 a15 = ap[14];
-            case (INT)__MKSMALLINT(14):
+            case (INT)__mkSmallInteger(14):
                 a14 = ap[13];
-            case (INT)__MKSMALLINT(13):
+            case (INT)__mkSmallInteger(13):
                 a13 = ap[12];
-            case (INT)__MKSMALLINT(12):
+            case (INT)__mkSmallInteger(12):
                 a12 = ap[11];
-            case (INT)__MKSMALLINT(11):
+            case (INT)__mkSmallInteger(11):
                 a11 = ap[10];
-            case (INT)__MKSMALLINT(10):
+            case (INT)__mkSmallInteger(10):
                 a10 = ap[9];
-            case (INT)__MKSMALLINT(9):
+            case (INT)__mkSmallInteger(9):
                 a9 = ap[8];
-            case (INT)__MKSMALLINT(8):
+            case (INT)__mkSmallInteger(8):
                 a8 = ap[7];
-            case (INT)__MKSMALLINT(7):
+            case (INT)__mkSmallInteger(7):
                 a7 = ap[6];
-            case (INT)__MKSMALLINT(6):
+            case (INT)__mkSmallInteger(6):
                 a6 = ap[5];
-            case (INT)__MKSMALLINT(5):
+            case (INT)__mkSmallInteger(5):
                 a5 = ap[4];
-            case (INT)__MKSMALLINT(4):
+            case (INT)__mkSmallInteger(4):
                 a4 = ap[3];
-            case (INT)__MKSMALLINT(3):
+            case (INT)__mkSmallInteger(3):
                 a3 = ap[2];
-            case (INT)__MKSMALLINT(2):
+            case (INT)__mkSmallInteger(2):
                 a2 = ap[1];
-            case (INT)__MKSMALLINT(1):
+            case (INT)__mkSmallInteger(1):
                 a1 = ap[0];
-            case (INT)__MKSMALLINT(0):
+            case (INT)__mkSmallInteger(0):
                 break;
         }
     }
@@ -2203,7 +2203,7 @@
 !Block class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/Block.st,v 1.144 2005-02-01 12:39:03 stefan Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/Block.st,v 1.145 2005-07-08 17:15:00 cg Exp $'
 ! !
 
 Block initialize!
--- a/ByteArray.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/ByteArray.st	Fri Jul 08 19:15:03 2005 +0200
@@ -366,7 +366,7 @@
 	}
 	nIndex = __byteArraySize(slf);
 	if ((unsigned)indx < (unsigned)nIndex) {
-	    RETURN ( __MKSMALLINT(__ByteArrayInstPtr(slf)->ba_element[indx]) );
+	    RETURN ( __mkSmallInteger((__ByteArrayInstPtr(slf)->ba_element[indx])) );
 	}
     }
   fail: ;
@@ -441,7 +441,7 @@
 	}
 	nIndex = __byteArraySize(slf);
 	if ((unsigned)byte < (unsigned)nIndex) {
-	    RETURN ( __MKSMALLINT((__ByteArrayInstPtr(slf)->ba_element[byte] & (1 << indx)) != 0) );
+	    RETURN ( __mkSmallInteger(((__ByteArrayInstPtr(slf)->ba_element[byte] & (1 << indx)) != 0)) );
 	}
     }
 badIndex: ;
@@ -599,7 +599,7 @@
 	}
 	nIndex = __byteArraySize(slf);
 	if ((unsigned)indx < (unsigned)nIndex) {
-	    RETURN ( __MKSMALLINT(__ByteArrayInstPtr(slf)->ba_element[indx]) );
+	    RETURN ( __mkSmallInteger((__ByteArrayInstPtr(slf)->ba_element[indx])) );
 	}
     }
 badIndex: ;
@@ -835,7 +835,7 @@
 		    val.u_char[1] = byteP[1];
 		}
 #endif
-		RETURN ( __MKSMALLINT(val.u_ushort) );
+		RETURN ( __mkSmallInteger((val.u_ushort)) );
 	    }
 	}
     }
@@ -908,7 +908,7 @@
 		    }
 #endif
 		}
-		RETURN ( __MKSMALLINT(val) );
+		RETURN ( __mkSmallInteger(val) );
 	    }
 	}
     }
@@ -3112,7 +3112,7 @@
 		if (byte == 255) break;
 	    }
 	}
-	RETURN ( __MKSMALLINT(max) );
+	RETURN ( __mkSmallInteger(max) );
     }
 %}.
     ^ super max
@@ -3136,7 +3136,7 @@
     REGISTER unsigned char *cp;
     REGISTER int nByte;
     REGISTER int index;
-    int icounts[256];
+    INT icounts[256];
 
     if ((__qClass(self) == @global(ByteArray)) && __isArray(counts)) {
 	/*
@@ -3159,7 +3159,7 @@
 	 * make it real counts
 	 */
 	for (index=0; index<256; index++) {
-	    __ArrayInstPtr(counts)->a_element[index] = __MKSMALLINT(icounts[index]);
+	    __ArrayInstPtr(counts)->a_element[index] = __mkSmallInteger(icounts[index]);
 	}
 	RETURN ( counts );
     }
@@ -3259,7 +3259,8 @@
 %{  /* NOCONTEXT */
 
     REGISTER unsigned char *cp;
-    REGISTER int index, byteValue;
+    REGISTER INT index;
+    REGISTER int byteValue;
     REGISTER int len;
     OBJ cls;
 
@@ -3270,7 +3271,7 @@
 	    /*
 	     * searching for something which cannot be found
 	     */
-	    RETURN ( __MKSMALLINT(0) );
+	    RETURN ( __mkSmallInteger(0) );
 	}
 
 	if (__isSmallInteger(start)) {
@@ -3287,12 +3288,12 @@
 	    cp += index - 1;
 	    while (index <= len) {
 		if (*cp == byteValue) {
-		    RETURN ( __MKSMALLINT(index) );
+		    RETURN ( __mkSmallInteger(index) );
 		}
 		index++;
 		cp++;
 	    }
-	    RETURN ( __MKSMALLINT(0) );
+	    RETURN ( __mkSmallInteger(0) );
 	}
     }
 %}.
@@ -3337,5 +3338,5 @@
 !ByteArray class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/ByteArray.st,v 1.169 2005-07-08 14:00:04 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/ByteArray.st,v 1.170 2005-07-08 17:15:00 cg Exp $'
 ! !
--- a/CharacterArray.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/CharacterArray.st	Fri Jul 08 19:15:03 2005 +0200
@@ -1685,7 +1685,7 @@
      * This speeds up Set and Dictionary by a factor of 10!
      */
     val *= 31415821;
-    RETURN ( __MKSMALLINT(val & 0x3fffffff));
+    RETURN ( __mkSmallInteger(val & 0x3fffffff));
 %}
 
 !
@@ -4988,7 +4988,7 @@
 !CharacterArray class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/CharacterArray.st,v 1.319 2005-07-06 11:54:12 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/CharacterArray.st,v 1.320 2005-07-08 17:15:00 cg Exp $'
 ! !
 
 CharacterArray initialize!
--- a/CharacterEncoderImplementations__JIS0208_to_EUC.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/CharacterEncoderImplementations__JIS0208_to_EUC.st	Fri Jul 08 19:15:03 2005 +0200
@@ -212,8 +212,8 @@
                 _srcIdx++;
             }
     getOutOfHere:
-            srcIdx = __MKSMALLINT(_srcIdx);
-            dstIdx = __MKSMALLINT(_dstIdx);
+            srcIdx = __mkSmallInteger(_srcIdx);
+            dstIdx = __mkSmallInteger(_dstIdx);
         }
 %}.
 
@@ -332,5 +332,5 @@
 !JIS0208_to_EUC class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/CharacterEncoderImplementations__JIS0208_to_EUC.st,v 1.3 2004-03-12 09:15:13 ca Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/CharacterEncoderImplementations__JIS0208_to_EUC.st,v 1.4 2005-07-08 17:15:01 cg Exp $'
 ! !
--- a/CharacterEncoderImplementations__SJIS.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/CharacterEncoderImplementations__SJIS.st	Fri Jul 08 19:15:03 2005 +0200
@@ -148,8 +148,8 @@
             _dstIdx++;
         }
     getOutOfHere: ;
-        dstIdx = __MKSMALLINT(_dstIdx+1);
-        srcIdx = __MKSMALLINT(_srcIdx+1);
+        dstIdx = __mkSmallInteger(_dstIdx+1);
+        srcIdx = __mkSmallInteger(_srcIdx+1);
     }
 %}.
 
@@ -340,5 +340,5 @@
 !JIS0208_to_SJIS class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/CharacterEncoderImplementations__SJIS.st,v 1.8 2005-07-08 15:24:54 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/CharacterEncoderImplementations__SJIS.st,v 1.9 2005-07-08 17:15:01 cg Exp $'
 ! !
--- a/CharacterWriteStream.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/CharacterWriteStream.st	Fri Jul 08 19:15:03 2005 +0200
@@ -140,9 +140,9 @@
                 if (pos <= __stringSize(coll)) {
                     __StringInstPtr(coll)->s_element[pos-1] = ch;
                     if ((__readLimit >= 0) && (pos >= __readLimit)) {
-                        __INST(readLimit) = __MKSMALLINT(pos);
+                        __INST(readLimit) = __mkSmallInteger(pos);
                     }
-                    __INST(position) = __MKSMALLINT(__intVal(__INST(position)) + 1);
+                    __INST(position) = __mkSmallInteger(__intVal(__INST(position)) + 1);
                     RETURN ( aCharacter );
                 }
             } else if (cls == @global(Unicode16String)) {
@@ -152,18 +152,18 @@
                 if (pos <= __unicode16StringSize(coll)) {
                      __Unicode16StringInstPtr(coll)->s_element[pos-1] = ch;
                     if ((__readLimit >= 0) && (pos >= __readLimit)) {
-                        __INST(readLimit) = __MKSMALLINT(pos);
+                        __INST(readLimit) = __mkSmallInteger(pos);
                     }
-                    __INST(position) = __MKSMALLINT(__intVal(__INST(position)) + 1);
+                    __INST(position) = __mkSmallInteger(__intVal(__INST(position)) + 1);
                     RETURN ( aCharacter );
                 }
             } else if (cls == @global(Unicode32String)) {
                 if ((pos <= __unicode32StringSize(coll))) {
                      __Unicode32StringInstPtr(coll)->s_element[pos-1] = ch;
                     if ((__readLimit >= 0) && (pos >= __readLimit)) {
-                        __INST(readLimit) = __MKSMALLINT(pos);
+                        __INST(readLimit) = __mkSmallInteger(pos);
                     }
-                    __INST(position) = __MKSMALLINT(__intVal(__INST(position)) + 1);
+                    __INST(position) = __mkSmallInteger(__intVal(__INST(position)) + 1);
                     RETURN ( aCharacter );
                 }
             }
@@ -216,5 +216,5 @@
 !CharacterWriteStream class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/CharacterWriteStream.st,v 1.3 2004-04-21 14:12:07 stefan Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/CharacterWriteStream.st,v 1.4 2005-07-08 17:15:01 cg Exp $'
 ! !
--- a/CompiledCode.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/CompiledCode.st	Fri Jul 08 19:15:03 2005 +0200
@@ -131,7 +131,7 @@
      the next versions ..."
 
 %{  /* NOCONTEXT */
-    RETURN (__MKSMALLINT(MAX_METHOD_ARGS));
+    RETURN (__mkSmallInteger(MAX_METHOD_ARGS));
 %}
 !
 
@@ -140,7 +140,7 @@
 %{  /* NOCONTEXT */
     /* made this a primitive to get define in stc.h */
 
-    RETURN (__MKSMALLINT(F_NARGS));
+    RETURN (__mkSmallInteger(F_NARGS));
 %}.
 
     "
@@ -153,7 +153,7 @@
 %{  /* NOCONTEXT */
     /* made this a primitive to get define in stc.h */
 
-    RETURN (__MKSMALLINT(F_NARGSHIFT));
+    RETURN (__mkSmallInteger(F_NARGSHIFT));
 %}.
 
     "
@@ -166,7 +166,7 @@
 %{  /* NOCONTEXT */
     /* made this a primitive to get define in stc.h */
 
-    RETURN (__MKSMALLINT(F_NVARS));
+    RETURN (__mkSmallInteger(F_NVARS));
 %}.
 
     "
@@ -179,7 +179,7 @@
 %{  /* NOCONTEXT */
     /* made this a primitive to get define in stc.h */
 
-    RETURN (__MKSMALLINT(F_NVARSHIFT));
+    RETURN (__mkSmallInteger(F_NVARSHIFT));
 %}.
 
     "
@@ -1271,7 +1271,7 @@
     else
         newFlags &= ~F_CHECKED;
 
-    __INST(flags) = __MKSMALLINT(newFlags);
+    __INST(flags) = __mkSmallInteger(newFlags);
 %}
 !
 
@@ -1336,7 +1336,7 @@
     else
 	newFlags &= ~F_MARKBIT;
 
-    __INST(flags) = __MKSMALLINT(newFlags);
+    __INST(flags) = __mkSmallInteger(newFlags);
 %}
 ! !
 
@@ -1392,7 +1392,7 @@
 %{
     /* made this a primitive to get define in stc.h */
 #ifdef F_NARGS
-    __INST(flags) = __MKSMALLINT( (__intVal(__INST(flags)) & ~F_NARGS) | (__intVal(aNumber) << F_NARGSHIFT) );
+    __INST(flags) = __mkSmallInteger( (__intVal(__INST(flags)) & ~F_NARGS) | (__intVal(aNumber) << F_NARGSHIFT) );
 #endif
 %}
 
@@ -1411,7 +1411,7 @@
     /* made this a primitive to get define in stc.h */
     if (__isSmallInteger(aNumber)) {
         f = (f & ~F_NVARS) | (__intVal(aNumber) << F_NVARSHIFT);
-        __INST(flags) = __MKSMALLINT(f);
+        __INST(flags) = __mkSmallInteger(f);
     }
 %}
 
@@ -1425,10 +1425,10 @@
               This method may be removed without notice."
 
 %{  /* NOCONTEXT */
-    int n = (__intVal(__INST(flags)) & F_NSTACK) >> F_NSTACKSHIFT;
+    INT n = (__intVal(__INST(flags)) & F_NSTACK) >> F_NSTACKSHIFT;
 
     /* made this a primitive to get define in stc.h */
-    RETURN (__MKSMALLINT(n));
+    RETURN (__mkSmallInteger(n));
 %}
 
 !
@@ -1448,7 +1448,7 @@
     /* made this a primitive to get define in stc.h */
     if (__isSmallInteger(aNumber)) {
         f = (f & ~F_NSTACK) | (__intVal(aNumber) << F_NSTACKSHIFT);
-        __INST(flags) = __MKSMALLINT(f);
+        __INST(flags) = __mkSmallInteger(f);
     }
 %}
 
@@ -1462,7 +1462,7 @@
 %{  /* NOCONTEXT */
     /* made this a primitive to get define in stc.h */
 
-    RETURN (__MKSMALLINT((__intVal(__INST(flags)) & F_NARGS) >> F_NARGSHIFT));
+    RETURN (__mkSmallInteger((__intVal(__INST(flags)) & F_NARGS) >> F_NARGSHIFT));
 %}.
     "
      The old implementation simply counted the arguments from
@@ -1568,7 +1568,7 @@
 %{  /* NOCONTEXT */
     /* made this a primitive to get define in stc.h */
 
-    RETURN (__MKSMALLINT((__intVal(__INST(flags)) & F_NARGS) >> F_NARGSHIFT));
+    RETURN (__mkSmallInteger((__intVal(__INST(flags)) & F_NARGS) >> F_NARGSHIFT));
 %}.
     "
      The old implementation simply counted the arguments from
@@ -1592,7 +1592,7 @@
 %{  /* NOCONTEXT */
     /* made this a primitive to get define in stc.h */
 
-    RETURN (__MKSMALLINT((__intVal(__INST(flags)) & F_NVARS) >> F_NVARSHIFT));
+    RETURN (__mkSmallInteger((__intVal(__INST(flags)) & F_NVARS) >> F_NVARSHIFT));
 %}
 
 
@@ -1682,5 +1682,5 @@
 !CompiledCode class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/CompiledCode.st,v 1.100 2005-04-11 14:41:33 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/CompiledCode.st,v 1.101 2005-07-08 17:15:01 cg Exp $'
 ! !
--- a/Context.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/Context.st	Fri Jul 08 19:15:03 2005 +0200
@@ -310,7 +310,7 @@
 
 %{  /* NOCONTEXT */
 
-    RETURN ( __MKSMALLINT( (__intVal(__INST(flags)) >> __NARG_SHIFT) & __NARG_MASK) );
+    RETURN ( __mkSmallInteger( (__intVal(__INST(flags)) >> __NARG_SHIFT) & __NARG_MASK) );
 %}
 !
 
@@ -562,7 +562,7 @@
 
 %{  /* NOCONTEXT */
 
-    RETURN ( __MKSMALLINT( (__intVal(__INST(flags)) >> __NARG_SHIFT) & __NARG_MASK) );
+    RETURN ( __mkSmallInteger( (__intVal(__INST(flags)) >> __NARG_SHIFT) & __NARG_MASK) );
 %}
 !
 
@@ -581,7 +581,7 @@
 
 %{  /* NOCONTEXT */
 
-    RETURN ( __MKSMALLINT( (__intVal(__INST(flags)) >> __NVAR_SHIFT) & __NVAR_MASK) );
+    RETURN ( __mkSmallInteger( (__intVal(__INST(flags)) >> __NVAR_SHIFT) & __NVAR_MASK) );
 %}
 !
 
@@ -693,7 +693,7 @@
     flg = flg & ~(__NVAR_MASK << __NVAR_SHIFT);
     flg = flg | __intVal(nA) << __NARG_SHIFT;
     flg = flg | __intVal(nV) << __NVAR_SHIFT;
-    __INST(flags) = __MKSMALLINT(flg);
+    __INST(flags) = __mkSmallInteger(flg);
 %}
 !
 
@@ -2219,7 +2219,7 @@
 !Context class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/Context.st,v 1.131 2005-07-08 15:20:08 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/Context.st,v 1.132 2005-07-08 17:15:01 cg Exp $'
 ! !
 
 Context initialize!
--- a/Continuation.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/Continuation.st	Fri Jul 08 19:15:03 2005 +0200
@@ -97,7 +97,7 @@
 
     __cId = __continuationCreate(cont);
     if (__cId) {
-        id = __MKSMALLINT(__cId);
+        id = __mkSmallInteger(__cId);
     }
 %}.
     id isNil ifTrue:[
@@ -207,5 +207,5 @@
 !Continuation class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/Continuation.st,v 1.10 2005-04-18 09:18:55 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/Continuation.st,v 1.11 2005-07-08 17:15:01 cg Exp $'
 ! !
--- a/DirectoryStream.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/DirectoryStream.st	Fri Jul 08 19:15:03 2005 +0200
@@ -525,7 +525,7 @@
 	    nextEntry = __MKSTRING((char *)(dp->d_name));
 	} else {
 	    if (__threadErrno) {
-		__INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+		__INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 	    } else {
 		__INST(hitEOF) = true;
 	    }
@@ -626,7 +626,7 @@
 	    __END_INTERRUPTABLE__
 
 	    if (d == NULL) {
-		__INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+		__INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 	    } else {
 		dp = __MKEXTERNALADDRESS(d); __INST(dirPointer) = dp; __STORE(self, dp);
 		ok = true;
@@ -656,7 +656,7 @@
 		} while ((d < 0) && (__threadErrno == EINTR));
 
 		if (d == INVALID_HANDLE_VALUE) {
-		    __INST(lastErrorNumber) = __MKSMALLINT(GetLastError());
+		    __INST(lastErrorNumber) = __mkSmallInteger(GetLastError());
 		} else {
 		    dp = __MKEXTERNALADDRESS(d); __INST(dirPointer) = dp; __STORE(self, dp);
 		    entry = __MKSTRING( data.cFileName );
@@ -731,5 +731,5 @@
 !DirectoryStream class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/DirectoryStream.st,v 1.61 2005-07-07 15:01:51 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/DirectoryStream.st,v 1.62 2005-07-08 17:15:01 cg Exp $'
 ! !
--- a/Encoder_JIS0208_to_EUC.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/Encoder_JIS0208_to_EUC.st	Fri Jul 08 19:15:03 2005 +0200
@@ -212,8 +212,8 @@
                 _srcIdx++;
             }
     getOutOfHere:
-            srcIdx = __MKSMALLINT(_srcIdx);
-            dstIdx = __MKSMALLINT(_dstIdx);
+            srcIdx = __mkSmallInteger(_srcIdx);
+            dstIdx = __mkSmallInteger(_dstIdx);
         }
 %}.
 
@@ -332,5 +332,5 @@
 !JIS0208_to_EUC class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/Attic/Encoder_JIS0208_to_EUC.st,v 1.3 2004-03-12 09:15:13 ca Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/Attic/Encoder_JIS0208_to_EUC.st,v 1.4 2005-07-08 17:15:01 cg Exp $'
 ! !
--- a/Encoder_SJIS.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/Encoder_SJIS.st	Fri Jul 08 19:15:03 2005 +0200
@@ -148,8 +148,8 @@
             _dstIdx++;
         }
     getOutOfHere: ;
-        dstIdx = __MKSMALLINT(_dstIdx+1);
-        srcIdx = __MKSMALLINT(_srcIdx+1);
+        dstIdx = __mkSmallInteger(_dstIdx+1);
+        srcIdx = __mkSmallInteger(_srcIdx+1);
     }
 %}.
 
@@ -340,5 +340,5 @@
 !JIS0208_to_SJIS class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/Attic/Encoder_SJIS.st,v 1.8 2005-07-08 15:24:54 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/Attic/Encoder_SJIS.st,v 1.9 2005-07-08 17:15:01 cg Exp $'
 ! !
--- a/ExecutableFunction.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/ExecutableFunction.st	Fri Jul 08 19:15:03 2005 +0200
@@ -94,7 +94,7 @@
 #ifdef OLD
         addr = (unsigned INT)__INST(code_);
         if (addr <= _MAX_INT) {
-            RETURN ( __MKSMALLINT(addr) );
+            RETURN ( __mkSmallInteger(addr) );
         }
         RETURN ( __MKUINT(addr));
 #endif
@@ -407,5 +407,5 @@
 !ExecutableFunction class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/ExecutableFunction.st,v 1.51 2004-08-05 12:31:05 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/ExecutableFunction.st,v 1.52 2005-07-08 17:15:01 cg Exp $'
 ! !
--- a/ExternalAddress.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/ExternalAddress.st	Fri Jul 08 19:15:03 2005 +0200
@@ -215,7 +215,7 @@
 	}
 	addr >>= 1;
     }
-    RETURN (__MKSMALLINT(addr));
+    RETURN (__mkSmallInteger(addr));
 %}
 ! !
 
@@ -285,5 +285,5 @@
 !ExternalAddress class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/ExternalAddress.st,v 1.20 2004-09-27 08:55:45 stefan Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/ExternalAddress.st,v 1.21 2005-07-08 17:15:01 cg Exp $'
 ! !
--- a/ExternalBytes.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/ExternalBytes.st	Fri Jul 08 19:15:03 2005 +0200
@@ -28,7 +28,7 @@
 	struct mallocList *next;
 };
 static struct mallocList *mallocList = (struct mallocList *)0;
-static mallocCount = 0;
+static INT mallocCount = 0;
 
 static void
 removeFromMallocList(ptr)
@@ -564,7 +564,7 @@
 
 numberOfAllocatedChunks
 %{  /* NOCONTEXT */
-    RETURN ( __MKSMALLINT(mallocCount) );
+    RETURN ( __mkSmallInteger(mallocCount) );
 %}
     "
      self numberOfAllocatedChunks
@@ -586,7 +586,7 @@
     "return the number of bytes used by the machines native doubles"
 
 %{  /* NOCONTEXT */
-    RETURN (__MKSMALLINT( sizeof(double)));
+    RETURN (__mkSmallInteger( sizeof(double)));
 %}
     "
      ExternalBytes sizeofDouble
@@ -597,7 +597,7 @@
     "return the number of bytes used by the machines native floats"
 
 %{  /* NOCONTEXT */
-    RETURN (__MKSMALLINT( sizeof(float)));
+    RETURN (__mkSmallInteger( sizeof(float)));
 %}
     "
      ExternalBytes sizeofFloat
@@ -608,7 +608,7 @@
     "return the number of bytes used by the machines native integer"
 
 %{  /* NOCONTEXT */
-    RETURN (__MKSMALLINT( sizeof(int)));
+    RETURN (__mkSmallInteger( sizeof(int)));
 %}
     "
      ExternalBytes sizeofInt
@@ -619,7 +619,7 @@
     "return the number of bytes used by the machines native longs"
 
 %{  /* NOCONTEXT */
-    RETURN (__MKSMALLINT( sizeof(long)));
+    RETURN (__mkSmallInteger( sizeof(long)));
 %}
     "
      ExternalBytes sizeofLong
@@ -630,7 +630,7 @@
     "return the number of bytes used by the machines native pointer"
 
 %{  /* NOCONTEXT */
-    RETURN (__MKSMALLINT( sizeof(char *)));
+    RETURN (__mkSmallInteger( sizeof(char *)));
 %}
     "
      ExternalBytes sizeofPointer
@@ -641,7 +641,7 @@
     "return the number of bytes used by the machines native short"
 
 %{  /* NOCONTEXT */
-    RETURN (__MKSMALLINT( sizeof(short)));
+    RETURN (__mkSmallInteger( sizeof(short)));
 %}
     "
      ExternalBytes sizeofShort
@@ -655,12 +655,12 @@
 
 %{  /* NOCONTEXT */
 
-    int addr;
+    INT addr;
 
     if (__INST(address_) != nil) {
 	addr = (INT)__INST(address_);
 	if (addr <= _MAX_INT) {
-	    RETURN ( __MKSMALLINT(addr) );
+	    RETURN ( __mkSmallInteger(addr) );
 	}
 	RETURN ( __MKUINT(addr));
     }
@@ -685,7 +685,7 @@
 	    if (((sz = __INST(size)) == nil)
 	     || (__intVal(sz) >= idx)) {
 		cp = cp + idx - 1;
-		RETURN ( __MKSMALLINT(*cp) );
+		RETURN ( __mkSmallInteger((*cp)) );
 	    }
 	}
     }
@@ -1242,7 +1242,7 @@
 !ExternalBytes class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/ExternalBytes.st,v 1.58 2005-07-08 14:00:04 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/ExternalBytes.st,v 1.59 2005-07-08 17:15:01 cg Exp $'
 ! !
 
 ExternalBytes initialize!
--- a/ExternalFunction.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/ExternalFunction.st	Fri Jul 08 19:15:03 2005 +0200
@@ -377,7 +377,7 @@
 	nm = (char *)__stringVal(functionName);
 	for (i=0; i < __stxNCustomFunctions__; i++) {
 	   if (strcmp(__stxCustomFunctions__[i].name, nm) == 0) {
-		RETURN (__MKSMALLINT(i));
+		RETURN (__mkSmallInteger(i));
 	   }
 	}
     }
@@ -960,7 +960,7 @@
 !ExternalFunction class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/ExternalFunction.st,v 1.22 2004-09-24 14:49:24 stefan Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/ExternalFunction.st,v 1.23 2005-07-08 17:15:01 cg Exp $'
 ! !
 
 ExternalFunction initialize!
--- a/ExternalStream.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/ExternalStream.st	Fri Jul 08 19:15:03 2005 +0200
@@ -273,7 +273,7 @@
     if (isBuffered) {                                   \
 	ungetc((c), (f));                               \
     } else {                                            \
-      __INST(readAhead) = __MKSMALLINT((c));            \
+      __INST(readAhead) = __mkSmallInteger((c));            \
     }
 
 # define __READBYTE__(ret, f, buf, isBuffered)          \
@@ -719,13 +719,13 @@
 
 # ifdef NO_STDIO
 #  define __UNGETC__(c, f, isBuffered)                  \
-    __INST(readAhead) = __MKSMALLINT((c));
+    __INST(readAhead) = __mkSmallInteger((c));
 # else /* use STDIO */
 #  define __UNGETC__(c, f, isBuffered)                  \
     if (isBuffered) {                                   \
 	ungetc((c), (f));                               \
     } else {                                            \
-	__INST(readAhead) = __MKSMALLINT((c));          \
+	__INST(readAhead) = __mkSmallInteger((c));          \
     }
 # endif /* use STDIO */
 
@@ -2412,7 +2412,7 @@
 		    __INST(hitEOF) = true;
 		    break;
 		} else {
-		    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+		    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 		    goto err;
 		}
 	    }
@@ -2436,7 +2436,7 @@
 			__INST(hitEOF) = true;
 			break;
 		    }
-		    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+		    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 		    goto err;
 		}
 
@@ -2569,7 +2569,7 @@
 		RETURN ( self );
 	    }
 	}
-	__INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	__INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
     }
 %}.
     super nextPutLine:aString.
@@ -2617,7 +2617,7 @@
 	    for (;;) {
 		if (fgets(buffer, sizeof(buffer)-1, src) == NULL) {
 		    if (ferror(src)) {
-			readError = __MKSMALLINT(__threadErrno);
+			readError = __mkSmallInteger(__threadErrno);
 			__END_INTERRUPTABLE__
 			goto err;
 		    }
@@ -2625,7 +2625,7 @@
 		}
 		if (fputs(buffer, dst) == EOF) {
 		    if (ferror(dst)) {
-			__INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+			__INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 			__END_INTERRUPTABLE__
 			goto err;
 		    }
@@ -2733,7 +2733,7 @@
 
 	    if (cp == NULL) {
 		if (ferror(f)) {
-		    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+		    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 		    goto err;
 		} else {
 		    FSEEK(f, firstpos);
@@ -2961,10 +2961,10 @@
 	    __END_INTERRUPTABLE__
 
 	    if (ret >= 0) {
-		RETURN ( __MKSMALLINT(ret) );
+		RETURN ( __mkSmallInteger(ret) );
 	    }
 	    __INST(position) = nil; /* i.e. do not know */
-	    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 	}
     }
 # endif
@@ -3202,7 +3202,7 @@
 		} else {
 		    __INST(position) = nil; /* i.e. do not know */
 		}
-		RETURN (__MKSMALLINT(ret));
+		RETURN (__mkSmallInteger(ret));
 	    }
 #ifdef PRE_22_jan_2000
 	    if (ret == 0) {
@@ -3211,7 +3211,7 @@
 #endif
 	    {
 		__INST(position) = nil;
-		__INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+		__INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 	    }
 	}
     }
@@ -3257,14 +3257,14 @@
 	    } else {
 		__INST(position) = nil; /* i.e. do not know */
 	    }
-	    RETURN (__MKSMALLINT(byte));
+	    RETURN (__mkSmallInteger(byte));
 	}
 
 	if (ret == 0) {
 	    __INST(hitEOF) = true;
 	} else /* ret < 0 */ {
 	    __INST(position) = nil;
-	    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 	}
     }
 %}.
@@ -3374,13 +3374,13 @@
 		} else {
 		    __INST(position) = nil; /* i.e. do not know */
 		}
-		RETURN (__MKSMALLINT(ret));
+		RETURN (__mkSmallInteger(ret));
 	    }
 	    if (ret == 0) {
 		__INST(hitEOF) = true;
 	    } else /* ret < 0 */ {
 		__INST(position) = nil;
-		__INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+		__INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 	    }
 	}
     }
@@ -3463,10 +3463,10 @@
 #endif
 	    }
 #if __POINTER_SIZE__ == 8
-	    RETURN ( __MKSMALLINT(value));
+	    RETURN ( __mkSmallInteger(value));
 #else
 	    if ((value >= _MIN_INT) && (value <= _MAX_INT)) {
-		RETURN ( __MKSMALLINT(value));
+		RETURN ( __mkSmallInteger(value));
 	    }
 	    RETURN ( __MKLARGEINT(value) );
 #endif
@@ -3474,7 +3474,7 @@
 
 	if (ret < 0) {
 	    __INST(position) = nil;
-	    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 	} else /* ret == 0 */ {
 	    __INST(hitEOF) = true;
 	}
@@ -3537,12 +3537,12 @@
 		value = ((u.buffer[1] & 0xFF) << 8) | (u.buffer[0] & 0xFF);
 #endif
 	    }
-	    RETURN (__MKSMALLINT(value));
+	    RETURN (__mkSmallInteger(value));
 	}
 
 	if (ret < 0) {
 	    __INST(position) = nil; /* i.e. do not know */
-	    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 	} else /* ret == 0 */ {
 	    __INST(hitEOF) = true;
 	}
@@ -3614,10 +3614,10 @@
 	    }
 #if __POINTER_SIZE__ == 8
 	    value &= 0xFFFFFFFF;
-	    RETURN (__MKSMALLINT(value));
+	    RETURN (__mkSmallInteger(value));
 #else
 	    if (value <= _MAX_INT) {
-		RETURN (__MKSMALLINT(value));
+		RETURN (__mkSmallInteger(value));
 	    }
 	    RETURN (__MKULARGEINT(value) );
 #endif
@@ -3625,7 +3625,7 @@
 
 	if (ret < 0) {
 	    __INST(position) = nil; /* i.e. do not know */
-	    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 	} else /* ret == 0 */ {
 	    __INST(hitEOF) = true;
 	}
@@ -3688,12 +3688,12 @@
 		value = (u.buffer[1] << 8) | u.buffer[0];
 #endif
 	    }
-	    RETURN (__MKSMALLINT(value));
+	    RETURN (__mkSmallInteger(value));
 	}
 
 	if (ret < 0) {
 	    __INST(position) = nil; /* i.e. do not know */
-	    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 	} else /* ret == 0 */ {
 	    __INST(hitEOF) = true;
 	}
@@ -3757,7 +3757,7 @@
 	if (cnt < 0) {
 	    __INST(position) = nil; /* i.e. do not know */
 	}
-	__INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	__INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
     }
 %}.
     filePointer isNil ifTrue:[self errorNotOpen. ^ self].
@@ -3851,7 +3851,7 @@
 		} else {
 		    __INST(position) = nil; /* i.e. do not know */
 		}
-		RETURN ( __MKSMALLINT(cnt) );
+		RETURN ( __mkSmallInteger(cnt) );
 	    }
 	    if (
 #ifdef EWOULDBLOCK
@@ -3859,10 +3859,10 @@
 #endif
 		(__threadErrno == EAGAIN)
 	    ) {
-		RETURN ( __MKSMALLINT(0) );
+		RETURN ( __mkSmallInteger(0) );
 	    }
 	    __INST(position) = nil; /* i.e. do not know */
-	    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 	}
     }
 bad: ;
@@ -3950,7 +3950,7 @@
 	    RETURN ( self );
 	}
 	__INST(position) = nil; /* i.e. do not know */
-	__INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	__INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
     }
 badArg: ;
 %}.
@@ -4021,7 +4021,7 @@
 	    RETURN ( self );
 	}
 	__INST(position) = nil; /* i.e. do not know */
-	__INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	__INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
     }
 %}.
     lastErrorNumber notNil ifTrue:[self writeError. ^ self.].
@@ -4066,7 +4066,7 @@
      && (__qClass(openmode)== @global(String))) {
 	f = (FILEPOINTER) fdopen(__intVal(aFileDescriptor), (char *)__stringVal(openmode));
 	if (f == NULL) {
-	    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 	    __INST(position) = nil;
 	} else {
 	    if (@global(FileOpenTrace) == true) {
@@ -4122,7 +4122,7 @@
 	__END_INTERRUPTABLE__
 #endif /* UNIX */
 	if (f == NULL) {
-	    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 	} else {
 	    if (@global(FileOpenTrace) == true) {
 		fprintf(stderr, "fopen %s [ExternalStream] -> %x\n", __stringVal(aPath), f);
@@ -4315,14 +4315,14 @@
 		__INST(position) = nil; /* i.e. do not know */
 	    }
 	    if (__INST(binary) == true) {
-		RETURN ( __MKSMALLINT(ch) );
+		RETURN ( __mkSmallInteger(ch) );
 	    }
 	    RETURN ( __MKCHARACTER(ch) );
 	}
 
 	__INST(position) = nil;
 	if (ret < 0) {
-	    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 	} else /* ret == 0 */ {
 	    __INST(hitEOF) = true;
 	}
@@ -4408,12 +4408,12 @@
 	    __UNGETC__(c, f, _buffered);
 
 	    if (__INST(binary) == true) {
-		RETURN ( __MKSMALLINT(c) );
+		RETURN ( __mkSmallInteger(c) );
 	    }
 	    RETURN ( __MKCHARACTER(c) );
 	}
 	if (ret < 0) {
-	    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 	} else /* ret == 0 */ {
 	    __INST(hitEOF) = true;
 	}
@@ -4526,7 +4526,7 @@
 
 	if (ret <= 0) {
 	    if (ret < 0) {
-		__INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+		__INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 		goto err;
 	    }
 	    else if (ret == 0)
@@ -4760,7 +4760,7 @@
 	if (ret == 0)
 	    __INST(hitEOF) = true;
 	else /* ret < 0 */
-	    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
     }
     if (__isSmallInteger(__INST(position))) {
 	INT np = __intVal(__INST(position)) + nread;
@@ -4832,7 +4832,7 @@
 		__READBYTE__(ret, f, &c, _buffered);
 		if (ret <= 0) {
 		    if (ret < 0)
-			__INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+			__INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 		    else
 			__INST(hitEOF) = true;
 		    break;
@@ -4904,7 +4904,7 @@
 	    RETURN (false);
 	}
 	if (ret < 0) {
-	    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 	} else /* ret == 0 */
 	    __INST(hitEOF) = true;
 	}
@@ -4943,7 +4943,7 @@
 		break;
 	}
 	if (ret < 0) {
-	    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 	} else /* ret == 0 */ {
 	    __INST(hitEOF) = true;
 	}
@@ -4982,7 +4982,7 @@
 	    __READBYTE__(ret, f, &c, _buffered);
 	    if (ret <= 0) {
 		if (ret < 0) {
-		    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+		    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 		} else /* ret == 0 */ {
 		    __INST(hitEOF) = true;
 		}
@@ -5038,7 +5038,7 @@
 	    __READBYTE__(ret, f, &c, _buffered);
 	    if (ret <= 0) {
 		if (ret < 0) {
-		    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+		    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 		} else /* ret == 0 */ {
 		    __INST(hitEOF) = true;
 		}
@@ -5105,7 +5105,7 @@
 	    __READBYTE__(ret, f, &c, _buffered);
 	    if (ret <= 0) {
 		if (ret < 0) {
-		    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+		    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 		} else /* ret == 0 */ {
 		    __INST(hitEOF) = true;
 		}
@@ -5269,7 +5269,7 @@
 	}
 
 	/* ret < 0 */
-	__INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	__INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
     }
 %}.
     lastErrorNumber notNil ifTrue:[^ self readError].
@@ -5352,9 +5352,9 @@
 	    RETURN(nil)
 	}
 	if (ret < 0) {
-	    RETURN(__MKSMALLINT(__threadErrno));
+	    RETURN(__mkSmallInteger(__threadErrno));
 	} else /* ret == 0 */ {
-	    RETURN(__MKSMALLINT(0)); /* EOF */
+	    RETURN(__mkSmallInteger(0)); /* EOF */
 	}
     }
 %}.
@@ -5627,7 +5627,7 @@
 	    }
 	    RETURN ( self );
 	}
-	__INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	__INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
     }
 %}.
     lastErrorNumber notNil ifTrue:[self writeError. ^ self].
@@ -5722,7 +5722,7 @@
 			}
 			RETURN ( self );
 		    }
-		    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+		    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 		}
 	    }
 	} else {
@@ -5830,7 +5830,7 @@
 	    }
 	    RETURN (self);
 	}
-	__INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	__INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
     }
 out: ;
 %}.
@@ -5926,7 +5926,7 @@
 	    }
 	    RETURN (self);
 	}
-	__INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	__INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
     }
 out: ;
 %}.
@@ -5937,7 +5937,7 @@
 !ExternalStream class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/ExternalStream.st,v 1.291 2005-07-07 15:01:51 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/ExternalStream.st,v 1.292 2005-07-08 17:15:01 cg Exp $'
 ! !
 
 ExternalStream initialize!
--- a/FileStream.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/FileStream.st	Fri Jul 08 19:15:03 2005 +0200
@@ -693,7 +693,7 @@
 	    }
 	    RETURN ( rslt );
 	}
-	__INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	__INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
     }
 %}.
     lastErrorNumber notNil ifTrue:[^ self ioError].
@@ -711,7 +711,7 @@
     long ret;
     OBJ fp;
 
-    if ((__INST(canPosition) != false) || (newPos == __MKSMALLINT(0))) {
+    if ((__INST(canPosition) != false) || (newPos == __mkSmallInteger(0))) {
 	if ((fp = __INST(filePointer)) != nil) {
 
 #if defined(_LFS_LARGE_FILE) && !defined(WIN32)
@@ -725,23 +725,23 @@
 	    if (__isSmallInteger(newPos)) {
 		nP = __intVal(newPos);
 		if (nP < 0) {
-		    __INST(lastErrorNumber) = __MKSMALLINT(EINVAL);
+		    __INST(lastErrorNumber) = __mkSmallInteger(EINVAL);
 		    goto getOutOfHere;
 		}
 	    } else {
 		nP = __signedLongIntVal(newPos);
 		if (nP < 0) {
-		    __INST(lastErrorNumber) = __MKSMALLINT(EINVAL);
+		    __INST(lastErrorNumber) = __mkSmallInteger(EINVAL);
 		    goto getOutOfHere;
 		}
 		if (nP == 0) {
 		    if (sizeof(nP) == 8) {
 			if (__signedLong64IntVal(newPos, &nP) == 0 || nP < 0) {
-			    __INST(lastErrorNumber) = __MKSMALLINT(EINVAL);
+			    __INST(lastErrorNumber) = __mkSmallInteger(EINVAL);
 			    goto getOutOfHere;
 			}
 		    } else {
-			__INST(lastErrorNumber) = __MKSMALLINT(EINVAL);
+			__INST(lastErrorNumber) = __mkSmallInteger(EINVAL);
 			goto getOutOfHere;
 		    }
 		}
@@ -774,7 +774,7 @@
 		__INST(hitEOF) = false;
 		RETURN ( self );
 	    }
-	    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 	}
     }
     getOutOfHere: ;
@@ -837,7 +837,7 @@
 	if (ret >= 0) {
 	    RETURN ( self );
 	}
-	__INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	__INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
     }
 %}.
     lastErrorNumber notNil ifTrue:[^ self ioError].
@@ -1144,7 +1144,7 @@
 		goto retry;
 	    }
 	getOutOfHere: ;
-	    __INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	    __INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
 	    __INST(position) = nil;
 	} else {
 #ifdef __VMS__
@@ -1391,7 +1391,7 @@
 	    }
 	    RETURN(rslt);
 	}
-	__INST(lastErrorNumber) = __MKSMALLINT(__threadErrno);
+	__INST(lastErrorNumber) = __mkSmallInteger(__threadErrno);
     }
 #endif
 %}.
@@ -1441,7 +1441,7 @@
 !FileStream class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/FileStream.st,v 1.120 2005-07-07 15:01:52 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/FileStream.st,v 1.121 2005-07-08 17:15:01 cg Exp $'
 ! !
 
 FileStream initialize!
--- a/Float.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/Float.st	Fri Jul 08 19:15:03 2005 +0200
@@ -725,7 +725,7 @@
     double result, val;
 
     if (__isSmallInteger(aNumber)) {
-        if (aNumber != __MKSMALLINT(0)) {
+        if (aNumber != __mkSmallInteger(0)) {
             result = __floatVal(self) / ( (double)__intVal(aNumber)) ;
 retResult:
             __qMKFLOAT(newFloat, result);
@@ -865,7 +865,7 @@
 #endif
     {
         if ((dVal >= (double)_MIN_INT) && (dVal <= (double)_MAX_INT)) {
-            RETURN ( __MKSMALLINT( (INT)dVal) );
+            RETURN ( __mkSmallInteger( (INT)dVal) );
         }
     }
 %}.
@@ -1593,7 +1593,7 @@
         indx = __intVal(index) - 1;
         if (((unsigned)(indx)) < sizeof(double)) {
             cp = (unsigned char *)(& (__FloatInstPtr(self)->f_floatvalue));
-            RETURN ( __MKSMALLINT(cp[indx] & 0xFF) );
+            RETURN ( __mkSmallInteger(cp[indx] & 0xFF) );
         }
     }
 %}.
@@ -1664,7 +1664,7 @@
 
 %{  /* NOCONTEXT */
 
-    RETURN (__MKSMALLINT(sizeof(double)));
+    RETURN (__mkSmallInteger(sizeof(double)));
 %}.
 ! !
 
@@ -1682,12 +1682,12 @@
 
     double frexp();
     double frac;
-    INT exp;
+    int exp;
 
     __threadErrno = 0;
     frac = frexp(__floatVal(self), &exp);
     if (__threadErrno == 0) {
-	RETURN (__MKSMALLINT(exp));
+	RETURN (__mkSmallInteger(exp));
     }
 %}.
     ^ self primitiveFailed
@@ -1716,7 +1716,7 @@
 
     double frexp();
     double frac;
-    INT exp;
+    int exp;
 
     __threadErrno = 0;
     frac = frexp(__floatVal(self), &exp);
@@ -1868,7 +1868,7 @@
 
 %{  /* NOCONTEXT */
 
-    RETURN (__MKSMALLINT (sizeof(double) * 8));
+    RETURN (__mkSmallInteger (sizeof(double) * 8));
 %}
 
     "
@@ -2327,7 +2327,7 @@
      * ST-80 (and X3J20) returns integer.
      */
     if ((dVal >= (double)_MIN_INT) && (dVal <= (double)_MAX_INT)) {
-        RETURN ( __MKSMALLINT( (INT) dVal ) );
+        RETURN ( __mkSmallInteger( (INT) dVal ) );
     }
     __qMKFLOAT(val, dVal);
 %}.
@@ -2368,7 +2368,7 @@
      * ST-80 (and X3J20) returns integer.
      */
     if ((dVal >= (double)_MIN_INT) && (dVal <= (double)_MAX_INT)) {
-        RETURN ( __MKSMALLINT( (INT) dVal ) );
+        RETURN ( __mkSmallInteger( (INT) dVal ) );
     }
     __qMKFLOAT(val, dVal);
 %}.
@@ -2469,7 +2469,7 @@
      * ST-80 (and X3J20) returns integer.
      */
     if ((dVal >= (double)_MIN_INT) && (dVal <= (double)_MAX_INT)) {
-        RETURN ( __MKSMALLINT( (INT) dVal ) );
+        RETURN ( __mkSmallInteger( (INT) dVal ) );
     }
     __qMKFLOAT(val, dVal);
 %}.
@@ -2535,7 +2535,7 @@
      * ST-80 (and X3J20) returns integer.
      */
     if ((dVal >= (double)_MIN_INT) && (dVal <= (double)_MAX_INT)) {
-	RETURN ( __MKSMALLINT( (INT) dVal ) );
+	RETURN ( __mkSmallInteger( (INT) dVal ) );
     }
     __qMKFLOAT(val, dVal);
 %}.
@@ -2583,7 +2583,7 @@
 !Float class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/Float.st,v 1.156 2005-07-07 15:01:52 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/Float.st,v 1.157 2005-07-08 17:15:01 cg Exp $'
 ! !
 
 Float initialize!
--- a/FloatArray.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/FloatArray.st	Fri Jul 08 19:15:03 2005 +0200
@@ -130,9 +130,9 @@
      The argument must be another vector"
 
 %{
-    if ((__ClassInstPtr(__qClass(self))->c_ninstvars == __MKSMALLINT(0))
+    if ((__ClassInstPtr(__qClass(self))->c_ninstvars == __mkSmallInteger(0))
      && __isFloats(floatArray)
-     && (__ClassInstPtr(__qClass(floatArray))->c_ninstvars == __MKSMALLINT(0))) {
+     && (__ClassInstPtr(__qClass(floatArray))->c_ninstvars == __mkSmallInteger(0))) {
         int _sz1 = __floatArraySize(self);
         int _sz2 = __floatArraySize(floatArray);
         int i;
@@ -164,7 +164,7 @@
     "add the scalar argument into the receiver (destructive)."
 
 %{
-    if (__ClassInstPtr(__qClass(self))->c_ninstvars == __MKSMALLINT(0)) {
+    if (__ClassInstPtr(__qClass(self))->c_ninstvars == __mkSmallInteger(0)) {
         int _sz1 = __floatArraySize(self);
         int i;
         float *_p1 = __FloatArrayInstPtr(self)->f_element;
@@ -207,9 +207,9 @@
      The argument must be another vector"
 
 %{
-    if ((__ClassInstPtr(__qClass(self))->c_ninstvars == __MKSMALLINT(0))
+    if ((__ClassInstPtr(__qClass(self))->c_ninstvars == __mkSmallInteger(0))
      && __isFloats(floatArray)
-     && (__ClassInstPtr(__qClass(floatArray))->c_ninstvars == __MKSMALLINT(0))) {
+     && (__ClassInstPtr(__qClass(floatArray))->c_ninstvars == __mkSmallInteger(0))) {
         int _sz1 = __floatArraySize(self);
         int _sz2 = __floatArraySize(floatArray);
         int i;
@@ -241,7 +241,7 @@
     "multiply the scalar argument into the receiver (destructive)."
 
 %{
-    if (__ClassInstPtr(__qClass(self))->c_ninstvars == __MKSMALLINT(0)) {
+    if (__ClassInstPtr(__qClass(self))->c_ninstvars == __mkSmallInteger(0)) {
         int _sz1 = __floatArraySize(self);
         int i;
         float *_p1 = __FloatArrayInstPtr(self)->f_element;
@@ -288,7 +288,7 @@
 
     newArr := self class new:(self size).
 %{
-    if (__ClassInstPtr(__qClass(self))->c_ninstvars == __MKSMALLINT(0)) {
+    if (__ClassInstPtr(__qClass(self))->c_ninstvars == __mkSmallInteger(0)) {
         int _sz = __floatArraySize(self);
 
         bcopy(__FloatArrayInstPtr(self)->f_element,
@@ -313,7 +313,7 @@
     "return a partial copy of the receiver"
 
 %{
-    if (__ClassInstPtr(__qClass(self))->c_ninstvars == __MKSMALLINT(0)) {
+    if (__ClassInstPtr(__qClass(self))->c_ninstvars == __mkSmallInteger(0)) {
         if (__bothSmallInteger(start, stop)) {
             int __start = __intVal(start) - 1;
             int __stop = __intVal(stop) - 1 ;
@@ -353,9 +353,9 @@
 
 replaceFrom:start to:stop with:aCollection startingAt:replStart
 %{
-    if ((__ClassInstPtr(__qClass(self))->c_ninstvars == __MKSMALLINT(0))
+    if ((__ClassInstPtr(__qClass(self))->c_ninstvars == __mkSmallInteger(0))
      && __isFloats(aCollection)
-     && (__ClassInstPtr(__qClass(aCollection))->c_ninstvars == __MKSMALLINT(0))) {
+     && (__ClassInstPtr(__qClass(aCollection))->c_ninstvars == __mkSmallInteger(0))) {
         if (__bothSmallInteger(start, stop)
          && __isSmallInteger(replStart)) {
             int __start = __intVal(start) - 1;
@@ -451,7 +451,7 @@
     "return the largest element;
      redefined for speed"
 %{
-    if (__ClassInstPtr(__qClass(self))->c_ninstvars == __MKSMALLINT(0)) {
+    if (__ClassInstPtr(__qClass(self))->c_ninstvars == __mkSmallInteger(0)) {
         int _sz = __floatArraySize(self);
 
         if (_sz > 0) {
@@ -502,7 +502,7 @@
     "return the largest element;
      redefined for speed"
 %{
-    if (__ClassInstPtr(__qClass(self))->c_ninstvars == __MKSMALLINT(0)) {
+    if (__ClassInstPtr(__qClass(self))->c_ninstvars == __mkSmallInteger(0)) {
         int _sz = __floatArraySize(self);
 
         if (_sz > 0) {
@@ -556,7 +556,7 @@
     |min max|
 
 %{
-    if (__ClassInstPtr(__qClass(self))->c_ninstvars == __MKSMALLINT(0)) {
+    if (__ClassInstPtr(__qClass(self))->c_ninstvars == __mkSmallInteger(0)) {
         int _sz = __floatArraySize(self);
         if (_sz > 0) {
             int _i;
@@ -616,5 +616,5 @@
 !FloatArray class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/FloatArray.st,v 1.19 2003-04-22 09:39:26 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/FloatArray.st,v 1.20 2005-07-08 17:15:01 cg Exp $'
 ! !
--- a/Fraction.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/Fraction.st	Fri Jul 08 19:15:03 2005 +0200
@@ -89,7 +89,7 @@
     /* this check allows subclassing .. */
     if (self == Fraction) {
         if (__bothSmallInteger(num, den)) {
-            if (den != __MKSMALLINT(0)) {
+            if (den != __mkSmallInteger(0)) {
                 if (__CanDoQuickAlignedNew(sizeof(struct __Fraction))) {    /* OBJECT ALLOCATION */
                     OBJ newFraction;
                     int spc;
@@ -101,13 +101,13 @@
                     iDen = __intVal(den);
                     if (iDen != 0) {
                         if (iDen < 0) {
-                            __FractionInstPtr(newFraction)->f_numerator = __MKSMALLINT(- __intVal(num));
-                            __FractionInstPtr(newFraction)->f_denominator = __MKSMALLINT(- iDen);
+                            __FractionInstPtr(newFraction)->f_numerator = __mkSmallInteger(- __intVal(num));
+                            __FractionInstPtr(newFraction)->f_denominator = __mkSmallInteger(- iDen);
                         } else {
                             __FractionInstPtr(newFraction)->f_numerator = num;
                             __FractionInstPtr(newFraction)->f_denominator = den;
                         }
-                        if (num == __MKSMALLINT(1)) {
+                        if (num == __mkSmallInteger(1)) {
                             /* no need to reduce */
                             RETURN ( newFraction );
                         }
@@ -1098,7 +1098,7 @@
 !Fraction class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/Fraction.st,v 1.71 2004-11-10 10:40:41 penk Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/Fraction.st,v 1.72 2005-07-08 17:15:01 cg Exp $'
 ! !
 
 Fraction initialize!
--- a/Integer.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/Integer.st	Fri Jul 08 19:15:03 2005 +0200
@@ -117,7 +117,7 @@
         if ((unsigned)idx < __stringSize(aString)) {
             val = atoi(cp + idx);
             if (val <= _MAX_INT) {
-                RETURN(__MKSMALLINT(val));
+                RETURN(__mkSmallInteger(val));
             }
             RETURN (__MKUINT(val));
         }
@@ -3489,7 +3489,7 @@
 !Integer class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/Integer.st,v 1.174 2005-06-28 13:09:27 stefan Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/Integer.st,v 1.175 2005-07-08 17:15:01 cg Exp $'
 ! !
 
 Integer initialize!
--- a/LargeInteger.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/LargeInteger.st	Fri Jul 08 19:15:03 2005 +0200
@@ -713,7 +713,7 @@
 	    )
 #endif
 	    {
-		RETURN (__MKSMALLINT(_MIN_INT));
+		RETURN (__mkSmallInteger(_MIN_INT));
 	    }
 	}
 %}.
@@ -893,7 +893,7 @@
 	}
 #endif
 
-	RETURN ( __MKSMALLINT(v1 & v2) );
+	RETURN ( __mkSmallInteger(v1 & v2) );
     }
 %}.
     ^ super bitAnd:anInteger
@@ -1040,29 +1040,29 @@
 		if (c & 0x0F) {
 		    if (c & 0x03) {
 			if (c & 0x01) {
-			    RETURN ( __MKSMALLINT( bitIdx + 1) );
+			    RETURN ( __mkSmallInteger( bitIdx + 1) );
 			} else {
-			    RETURN ( __MKSMALLINT( bitIdx + 2) );
+			    RETURN ( __mkSmallInteger( bitIdx + 2) );
 			}
 		    } else {
 			if (c & 0x04) {
-			    RETURN ( __MKSMALLINT( bitIdx + 3) );
+			    RETURN ( __mkSmallInteger( bitIdx + 3) );
 			} else {
-			    RETURN ( __MKSMALLINT( bitIdx + 4) );
+			    RETURN ( __mkSmallInteger( bitIdx + 4) );
 			}
 		    }
 		} else {
 		    if (c & 0x30) {
 			if (c & 0x10) {
-			    RETURN ( __MKSMALLINT( bitIdx + 5) );
+			    RETURN ( __mkSmallInteger( bitIdx + 5) );
 			} else {
-			    RETURN ( __MKSMALLINT( bitIdx + 6) );
+			    RETURN ( __mkSmallInteger( bitIdx + 6) );
 			}
 		    } else {
 			if (c & 0x40) {
-			    RETURN ( __MKSMALLINT( bitIdx + 7) );
+			    RETURN ( __mkSmallInteger( bitIdx + 7) );
 			} else {
-			    RETURN ( __MKSMALLINT( bitIdx + 8) );
+			    RETURN ( __mkSmallInteger( bitIdx + 8) );
 			}
 		    }
 		}
@@ -1071,7 +1071,7 @@
 	    __sz--;
 	    __bP++;
 	}
-	idx0 = __MKSMALLINT( __bP - __bP0 + 1 );
+	idx0 = __mkSmallInteger( __bP - __bP0 + 1 );
     }
 #endif
 %}.
@@ -1270,8 +1270,8 @@
 %{  /* NOCONTEXT */
     OBJ t;
 
-    if (__INST(sign) == __MKSMALLINT(0)) {
-	RETURN (__MKSMALLINT(0));
+    if (__INST(sign) == __mkSmallInteger(0)) {
+	RETURN (__mkSmallInteger(0));
     }
 
     t = __INST(digitByteArray);
@@ -1297,10 +1297,10 @@
 		    _val = (_val + __digitBytes[2]) << 8;
 		    _val = (_val + __digitBytes[1]) << 8;
 		    _val += __digitBytes[0];
-		    if (__INST(sign) == __MKSMALLINT(-1))
+		    if (__INST(sign) == __mkSmallInteger(-1))
 			_val = -_val;
 		    if (__ISVALIDINTEGER(_val)) {
-			RETURN (__MKSMALLINT(_val));
+			RETURN (__mkSmallInteger(_val));
 		    }
 		}
 		break;
@@ -1312,9 +1312,9 @@
 		_val = (_val + __digitBytes[2]) << 8;
 		_val = (_val + __digitBytes[1]) << 8;
 		_val += __digitBytes[0];
-		if (__INST(sign) == __MKSMALLINT(-1))
+		if (__INST(sign) == __mkSmallInteger(-1))
 		    _val = -_val;
-		RETURN (__MKSMALLINT(_val));
+		RETURN (__mkSmallInteger(_val));
 	    case 6:
 		_val = (__digitBytes[5]<<8);
 		_val = (_val + __digitBytes[4]) << 8;
@@ -1322,77 +1322,77 @@
 		_val = (_val + __digitBytes[2]) << 8;
 		_val = (_val + __digitBytes[1]) << 8;
 		_val += __digitBytes[0];
-		if (__INST(sign) == __MKSMALLINT(-1))
+		if (__INST(sign) == __mkSmallInteger(-1))
 		    _val = -_val;
-		RETURN (__MKSMALLINT(_val));
+		RETURN (__mkSmallInteger(_val));
 	    case 5:
 		_val = (__digitBytes[4]<<8);
 		_val = (_val + __digitBytes[3]) << 8;
 		_val = (_val + __digitBytes[2]) << 8;
 		_val = (_val + __digitBytes[1]) << 8;
 		_val += __digitBytes[0];
-		if (__INST(sign) == __MKSMALLINT(-1))
+		if (__INST(sign) == __mkSmallInteger(-1))
 		    _val = -_val;
-		RETURN (__MKSMALLINT(_val));
+		RETURN (__mkSmallInteger(_val));
 	    case 4:
 		_val = (__digitBytes[3]<<8);
 		_val = (_val + __digitBytes[2]) << 8;
 		_val = (_val + __digitBytes[1]) << 8;
 		_val += __digitBytes[0];
-		if (__INST(sign) == __MKSMALLINT(-1))
+		if (__INST(sign) == __mkSmallInteger(-1))
 		    _val = -_val;
-		RETURN (__MKSMALLINT(_val));
+		RETURN (__mkSmallInteger(_val));
 	    case 3:
 		_val = (__digitBytes[2]<<8);
 		_val = (_val + __digitBytes[1]) << 8;
 		_val += __digitBytes[0];
-		if (__INST(sign) == __MKSMALLINT(-1))
+		if (__INST(sign) == __mkSmallInteger(-1))
 		    _val = -_val;
-		RETURN (__MKSMALLINT(_val));
+		RETURN (__mkSmallInteger(_val));
 	    case 2:
 		_val = (__digitBytes[1]<<8) + __digitBytes[0];
-		if (__INST(sign) == __MKSMALLINT(-1))
+		if (__INST(sign) == __mkSmallInteger(-1))
 		    _val = -_val;
-		RETURN (__MKSMALLINT(_val));
+		RETURN (__mkSmallInteger(_val));
 	    case 1:
 		_val = __digitBytes[0];
-		if (__INST(sign) == __MKSMALLINT(-1))
+		if (__INST(sign) == __mkSmallInteger(-1))
 		    _val = -_val;
-		RETURN (__MKSMALLINT(_val));
+		RETURN (__mkSmallInteger(_val));
 	    case 0:
-		RETURN (__MKSMALLINT(0));
+		RETURN (__mkSmallInteger(0));
 
 	}
 #else
 	if (_idx <= 4) {
 	    if (_idx <= 2) {
 		if (_idx == 0) {
-		    RETURN (__MKSMALLINT(0));
+		    RETURN (__mkSmallInteger(0));
 		}
 		if (_idx == 1) {
 		    _val = __digitBytes[0];
-		    if (__INST(sign) == __MKSMALLINT(-1))
+		    if (__INST(sign) == __mkSmallInteger(-1))
 			_val = -_val;
-		    RETURN (__MKSMALLINT(_val));
+		    RETURN (__mkSmallInteger(_val));
 		}
 		_val = (__digitBytes[1]<<8) + __digitBytes[0];
-		if (__INST(sign) == __MKSMALLINT(-1))
+		if (__INST(sign) == __mkSmallInteger(-1))
 		    _val = -_val;
-		RETURN (__MKSMALLINT(_val));
+		RETURN (__mkSmallInteger(_val));
 	    }
 	    if (_idx == 3) {
 		_val = (((__digitBytes[2]<<8) + __digitBytes[1])<<8) + __digitBytes[0];
-		if (__INST(sign) == __MKSMALLINT(-1))
+		if (__INST(sign) == __mkSmallInteger(-1))
 		    _val = -_val;
-		RETURN (__MKSMALLINT(_val));
+		RETURN (__mkSmallInteger(_val));
 	    }
 	    _val = __digitBytes[3];
 	    if (_val <= 0x40) {
 		_val = (((((_val<<8) + __digitBytes[2])<<8) + __digitBytes[1])<<8) + __digitBytes[0];
-		if (__INST(sign) == __MKSMALLINT(-1))
+		if (__INST(sign) == __mkSmallInteger(-1))
 		    _val = -_val;
 		if (__ISVALIDINTEGER(_val)) {
-		    RETURN (__MKSMALLINT(_val));
+		    RETURN (__mkSmallInteger(_val));
 		}
 	    }
 	}
@@ -1769,7 +1769,7 @@
 	}
 
 #if defined(__LSBFIRST__)
-# if defined (__GNUC__) && defined(__i386__)
+# if defined (__GNUC__) && defined(__i386__) && (__POINTER_SIZE__ == 4)
 	/*
 	 * can do it long-word-wise;
 	 * 32*32 -> 64 multiplication
@@ -1799,7 +1799,7 @@
 	    _l -= 4;
 	}
 # else /* not GNU-i386 */
-#  if defined (WIN32) && defined(__i386__)
+#  if defined (WIN32) && defined(__i386__) && (__POINTER_SIZE__ == 4)
 	/*
 	 * can do it long-word-wise;
 	 * 32*32 -> 64 multiplication
@@ -2262,7 +2262,7 @@
 	    resultBytes[index] = t / divisor;
 	    rest = t % divisor;
 	}
-	prevRest = __MKSMALLINT(rest);
+	prevRest = __mkSmallInteger(rest);
 
 	/*
 	 * no need to normalize ?
@@ -2420,7 +2420,7 @@
 	    __resultP[__index-1] = __diff;
 	    __index++;
 	}
-	lastDigit = __MKSMALLINT( __resultP[__index-1-1] );
+	lastDigit = __mkSmallInteger( __resultP[__index-1-1] );
 	ok = true;
     }
 %}.
@@ -2502,11 +2502,11 @@
 %{
 #if __POINTER_SIZE__ == 8
 	if (__intVal(aSmallInteger) & 0xFF00000000000000L) {
-	    rsltLen = __MKSMALLINT(__intVal(len) + 1);
+	    rsltLen = __mkSmallInteger(__intVal(len) + 1);
 	}
 #else
 	if (__intVal(aSmallInteger) & 0xFF000000) {
-	    rsltLen = __MKSMALLINT(__intVal(len) + 1);
+	    rsltLen = __mkSmallInteger(__intVal(len) + 1);
 	}
 #endif
 %}
@@ -2535,7 +2535,7 @@
 	}
 
 #if defined(__LSBFIRST__)
-# if defined(__i386__) && defined(__GNUC__)
+# if defined(__i386__) && defined(__GNUC__) && (__POINTER_SIZE__ == 4)
 #  if 0 /* NOTICE - the code below is 20% slower ... - why */
 	/*
 	 * add long-wise
@@ -2668,7 +2668,7 @@
 	}
 #  endif
 # else /* not i386-GNUC */
-#  if defined(__i386__) && defined(WIN32)
+#  if defined(__i386__) && defined(WIN32) && (__POINTER_SIZE__ == 4)
 	{
 	    unsigned char *__srcLast4;
 
@@ -3115,9 +3115,9 @@
 		}
 	    }
 	}
-	borrow = __MKSMALLINT(__borrow);
-	index = __MKSMALLINT(__index);
-	lastDigit = __MKSMALLINT(__resultDigits[__intVal(lResult)-1]);
+	borrow = __mkSmallInteger(__borrow);
+	index = __mkSmallInteger(__index);
+	lastDigit = __mkSmallInteger(__resultDigits[__intVal(lResult)-1]);
     }
 %}.
     ok == true ifFalse:[
@@ -3604,7 +3604,7 @@
 		    unsigned INT _sum = __unsignedLongIntVal(self) + __unsignedLongIntVal(aLargeInteger);
 #endif /* not LSB_FIRST */
 		    if (_sum <= _MAX_INT) {
-			_uint = __MKSMALLINT(_sum * __intVal(newSign));
+			_uint = __mkSmallInteger(_sum * __intVal(newSign));
 		    } else {
 			_uint = __MKULARGEINT(_sum);
 			__LargeIntegerInstPtr(_uint)->l_sign = newSign;
@@ -3719,7 +3719,7 @@
 	    }
 	}
 # else
-#  if defined(__i386__) && defined(__GNUC__)
+#  if defined(__i386__) && defined(__GNUC__) && (__POINTER_SIZE__ == 4)
 	{
 	    int _comLen3;
 
@@ -3788,7 +3788,7 @@
 	    }
 	}
 #  endif /* __i386__ && GNUC */
-#  if defined(__i386__) && defined(WIN32)
+#  if defined(__i386__) && defined(WIN32) && (__POINTER_SIZE__ == 4)
 	{
 	    int _comLen3;
 
@@ -4552,5 +4552,5 @@
 !LargeInteger class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/LargeInteger.st,v 1.182 2005-07-08 14:00:04 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/LargeInteger.st,v 1.183 2005-07-08 17:15:01 cg Exp $'
 ! !
--- a/LongFloat.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/LongFloat.st	Fri Jul 08 19:15:03 2005 +0200
@@ -484,13 +484,13 @@
     "
 %{
     if (sizeof(LONGFLOAT) == 10) { /* i386 - WIN32 */
-	RETURN (__MKSMALLINT(15));
+	RETURN (__mkSmallInteger(15));
     }
-    if (sizeof(LONGFLOAT) == 12) { /* i386 */
-	RETURN (__MKSMALLINT(15));
+    if (sizeof(LONGFLOAT) == 12) { /* i386-32bit */
+	RETURN (__mkSmallInteger(15));
     }
-    if (sizeof(LONGFLOAT) == 16) { /* sparc */
-	RETURN (__MKSMALLINT(15));
+    if (sizeof(LONGFLOAT) == 16) { /* sparc, i386-64bit */
+	RETURN (__mkSmallInteger(15));
     }
 %}.
     "systems without longFloat support use doubles instead"
@@ -512,13 +512,13 @@
     "
 %{
     if (sizeof(LONGFLOAT) == 10) { /* i386 - WIN32 */
-	RETURN (__MKSMALLINT(1));
+	RETURN (__mkSmallInteger(1));
     }
     if (sizeof(LONGFLOAT) == 12) { /* i386 */
-	RETURN (__MKSMALLINT(1));
+	RETURN (__mkSmallInteger(1));
     }
     if (sizeof(LONGFLOAT) == 16) { /* sparc */
-	RETURN (__MKSMALLINT(0));
+	RETURN (__mkSmallInteger(0));
     }
 %}.
     "systems without longFloat support use doubles instead"
@@ -543,13 +543,13 @@
     "
 %{
     if (sizeof(LONGFLOAT) == 10) { /* i386 - WIN32 */
-	RETURN (__MKSMALLINT(64));
+	RETURN (__mkSmallInteger(64));
     }
     if (sizeof(LONGFLOAT) == 12) { /* i386 */
-	RETURN (__MKSMALLINT(64));
+	RETURN (__mkSmallInteger(64));
     }
     if (sizeof(LONGFLOAT) == 16) { /* sparc */
-	RETURN (__MKSMALLINT(112));
+	RETURN (__mkSmallInteger(112));
     }
 %}.
     "systems without longFloat support use doubles instead"
@@ -677,7 +677,7 @@
     LONGFLOAT result, val;
 
     if (__isSmallInteger(aNumber)) {
-	if (aNumber != __MKSMALLINT(0)) {
+	if (aNumber != __mkSmallInteger(0)) {
 	    result = __longFloatVal(self) / (LONGFLOAT)(__intVal(aNumber));
 retResult:
 	    __qMKLFLOAT(newFloat, result);
@@ -826,7 +826,7 @@
     if (! isnanl(fVal))    
 #endif
     if ((fVal >= (LONGFLOAT)_MIN_INT) && (fVal <= (LONGFLOAT)_MAX_INT)) {
-	RETURN ( __MKSMALLINT( (INT)fVal) );
+	RETURN ( __mkSmallInteger( (INT)fVal) );
     }
 %}.
     ^ super asInteger
@@ -1533,7 +1533,7 @@
 	indx = __intVal(index) - 1;
 	if (((unsigned)(indx)) < sizeof(LONGFLOAT)) {
 	    cp = (unsigned char *)(& (__LongFloatInstPtr(self)->f_longfloatvalue));
-	    RETURN ( __MKSMALLINT(cp[indx] & 0xFF) );
+	    RETURN ( __mkSmallInteger(cp[indx] & 0xFF) );
 	}
     }
 %}.
@@ -1602,7 +1602,7 @@
 
 %{  /* NOCONTEXT */
 
-    RETURN (__MKSMALLINT(sizeof(LONGFLOAT)));
+    RETURN (__mkSmallInteger(sizeof(LONGFLOAT)));
 %}.
 ! !
 
@@ -1620,12 +1620,12 @@
 
 #if defined(LONG_frexp)
     LONGFLOAT LONG_frexp();
-    INT exp;
+    int exp;
 
     __threadErrno = 0;
     LONG_frexp( __longFloatVal(self), &exp);
     if (__threadErrno == 0) {
-	RETURN (__MKSMALLINT(exp));
+	RETURN (__mkSmallInteger(exp));
     }
 #endif
 %}.
@@ -1723,7 +1723,7 @@
 
 %{  /* NOCONTEXT */
 
-    RETURN (__MKSMALLINT (sizeof(LONGFLOAT) * 8));
+    RETURN (__mkSmallInteger (sizeof(LONGFLOAT) * 8));
 %}
 
     "
@@ -2258,7 +2258,7 @@
 
     lVal = LONG_ceil(__longFloatVal(self));
     if ((lVal >= (LONGFLOAT)_MIN_INT) && (lVal <= (LONGFLOAT)_MAX_INT)) {
-	RETURN ( __MKSMALLINT( (INT) lVal ) );
+	RETURN ( __mkSmallInteger( (INT) lVal ) );
     }
     __qMKLFLOAT(val, lVal);
 #endif
@@ -2310,7 +2310,7 @@
 
     lVal = LONG_floor(__longFloatVal(self));
     if ((lVal >= (LONGFLOAT)_MIN_INT) && (lVal <= (LONGFLOAT)_MAX_INT)) {
-	RETURN ( __MKSMALLINT( (INT) lVal ) );
+	RETURN ( __mkSmallInteger( (INT) lVal ) );
     }
     __qMKLFLOAT(val, lVal);
 #endif
@@ -2369,7 +2369,7 @@
      * ST-80 (and X3J20) returns integer.
      */
     if ((lVal >= (LONGFLOAT)_MIN_INT) && (lVal <= (LONGFLOAT)_MAX_INT)) {
-	RETURN ( __MKSMALLINT( (INT) lVal ) );
+	RETURN ( __mkSmallInteger( (INT) lVal ) );
     }
     __qMKLFLOAT(v, lVal);
     RETURN (v);
@@ -2431,7 +2431,7 @@
      * ST-80 (and X3J20) returns integer.
      */
     if ((lVal >= (LONGFLOAT)_MIN_INT) && (lVal <= (LONGFLOAT)_MAX_INT)) {
-	RETURN ( __MKSMALLINT( (INT) lVal ) );
+	RETURN ( __mkSmallInteger( (INT) lVal ) );
     }
     __qMKLFLOAT(val, lVal);
 #endif
@@ -2484,7 +2484,7 @@
 !LongFloat class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/LongFloat.st,v 1.50 2005-01-25 14:51:17 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/LongFloat.st,v 1.51 2005-07-08 17:15:01 cg Exp $'
 ! !
 
 LongFloat initialize!
--- a/MD5Stream.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/MD5Stream.st	Fri Jul 08 19:15:03 2005 +0200
@@ -179,7 +179,7 @@
     |ctxSize|
 
 %{
-    ctxSize = __MKSMALLINT(sizeof(MD5_CTX));
+    ctxSize = __mkSmallInteger(sizeof(MD5_CTX));
 %}.
     ContextSize := ctxSize.
     HashSize := 16.
@@ -439,7 +439,7 @@
 !MD5Stream class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/MD5Stream.st,v 1.4 2003-04-10 23:34:56 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/MD5Stream.st,v 1.5 2005-07-08 17:15:01 cg Exp $'
 ! !
 
 MD5Stream initialize!
--- a/Method.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/Method.st	Fri Jul 08 19:15:03 2005 +0200
@@ -747,7 +747,7 @@
         
 
     f = (f & ~M_PRIVACY) | p;
-    __INST(flags) = __MKSMALLINT(f);
+    __INST(flags) = __mkSmallInteger(f);
 #endif
 
 %}.
@@ -858,7 +858,7 @@
 	f |= F_RESTRICTED;
     else
 	f &= ~F_RESTRICTED;
-    __INST(flags) = __MKSMALLINT(f);
+    __INST(flags) = __mkSmallInteger(f);
     if (old & F_RESTRICTED)
 	RETURN(true);
 #endif
@@ -2015,7 +2015,7 @@
     INT f = __intVal(__INST(flags));
 
     f |= F_PRIMITIVE;
-    __INST(flags) = __MKSMALLINT(f);
+    __INST(flags) = __mkSmallInteger(f);
     __INST(code_) = aNumber;
     RETURN (self);
 #endif
@@ -2036,7 +2036,7 @@
     INT f = __intVal(__INST(flags));
 
     f |= F_RESOURCE;
-    __INST(flags) = __MKSMALLINT(f);
+    __INST(flags) = __mkSmallInteger(f);
 #endif
 %}
 ! !
@@ -2980,7 +2980,7 @@
 !Method class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/Method.st,v 1.285 2005-06-28 09:04:07 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/Method.st,v 1.286 2005-07-08 17:15:01 cg Exp $'
 ! !
 
 Method initialize!
--- a/Object.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/Object.st	Fri Jul 08 19:15:03 2005 +0200
@@ -732,7 +732,7 @@
                     unsigned char *cp;
 
                     cp = (unsigned char *)pFirst + indx;
-                    RETURN ( __MKSMALLINT( (INT)(*cp & 0xFF)) );
+                    RETURN ( __mkSmallInteger( (*cp & 0xFF)) );
                 }
                 break;
 
@@ -795,7 +795,7 @@
                     unsigned short *sp;
 
                     sp = (unsigned short *)(pFirst + (indx<<1));
-                    RETURN ( __MKSMALLINT( (INT)(*sp & 0xFFFF)) );
+                    RETURN ( __mkSmallInteger( (*sp & 0xFFFF)) );
                 }
                 break;
 
@@ -810,7 +810,7 @@
                     short *ssp;
 
                     ssp = (short *)(pFirst + (indx<<1));
-                    RETURN ( __MKSMALLINT( (INT)(*ssp) ));
+                    RETURN ( __mkSmallInteger( (*ssp) ));
                 }
                 break;
 
@@ -830,11 +830,11 @@
 #if __POINTER_SIZE__ == 8
                     {
                         unsigned  INT ull = (unsigned INT)ul;
-                        RETURN ( __MKSMALLINT(ull) );
+                        RETURN ( __mkSmallInteger(ull) );
                     }
 #else
                     if (ul <= _MAX_INT) {
-                        RETURN ( __MKSMALLINT(ul) );
+                        RETURN ( __mkSmallInteger(ul) );
                     }
                     RETURN ( __MKULARGEINT(ul) );
 #endif
@@ -857,11 +857,11 @@
 #if __POINTER_SIZE__ == 8
                     {
                         INT ll = (INT)l;
-                        RETURN ( __MKSMALLINT(ll) );
+                        RETURN ( __mkSmallInteger(ll) );
                     }
 #else
                     if (__ISVALIDINTEGER(l)) {
-                        RETURN ( __MKSMALLINT(l) );
+                        RETURN ( __mkSmallInteger(l) );
                     }
                     RETURN ( __MKLARGEINT(l) );
 #endif
@@ -890,7 +890,7 @@
                     slp = (INT *)(pFirst + (indx<<3));
                     ll = *slp;
                     if (__ISVALIDINTEGER(ll)) {
-                        RETURN ( __MKSMALLINT(ll) );
+                        RETURN ( __mkSmallInteger(ll) );
                     }
                     RETURN ( __MKLARGEINT(ll) );
 #else
@@ -924,7 +924,7 @@
                     ulp = (unsigned INT *)(pFirst + (indx<<3));
                     ul = *ulp;
                     if (ul <= _MAX_INT) {
-                        RETURN ( __MKSMALLINT(ul) );
+                        RETURN ( __mkSmallInteger(ul) );
                     }
                     RETURN ( __MKULARGEINT(ul) );
 #else
@@ -1108,7 +1108,7 @@
                     unsigned int32 *lp;
 
                     lp = (unsigned int32 *)(pFirst + (indx<<2));
-                    if (anObject == __MKSMALLINT(0)) {
+                    if (anObject == __mkSmallInteger(0)) {
                         *lp = 0;
                         RETURN ( anObject );
                     }
@@ -1139,7 +1139,7 @@
 
                     sllp = (__int64__ *)(pFirst + (indx<<3));
 
-                    if (anObject == __MKSMALLINT(0)) {
+                    if (anObject == __mkSmallInteger(0)) {
                         ll.lo = ll.hi = 0;
                         *sllp = ll;
                         RETURN ( anObject );
@@ -1165,7 +1165,7 @@
                     __uint64__ *llp;
 
                     llp = (__uint64__ *)(pFirst + (indx<<3));
-                    if (anObject == __MKSMALLINT(0)) {
+                    if (anObject == __mkSmallInteger(0)) {
                         ll.lo = ll.hi = 0;
                         *llp = ll;
                         RETURN ( anObject );
@@ -1260,7 +1260,7 @@
                 case __MASKSMALLINT(SLONGARRAY):
                 case __MASKSMALLINT(FLOATARRAY):
                     if ((unsigned)indx < (unsigned)nIndex) {
-                        RETURN ( __MKSMALLINT( (INT)(pFirst[indx])) );
+                        RETURN ( __mkSmallInteger( (INT)(pFirst[indx])) );
                     }
                     break;
 
@@ -1275,7 +1275,7 @@
                     }
 #endif
                     if ((unsigned)indx < (unsigned)nIndex) {
-                        RETURN ( __MKSMALLINT( (INT)(pFirst[indx])) );
+                        RETURN ( __mkSmallInteger( (INT)(pFirst[indx])) );
                     }
                     break;
             }
@@ -2153,7 +2153,7 @@
          * better distribution (i.e. bigger empty spaces) in hashed collection.
          */
         hash = __MAKE_HASH__(hash);
-        RETURN ( __MKSMALLINT(hash) );
+        RETURN ( __mkSmallInteger(hash) );
     }
 %}.
     ^ 0 "never reached, since redefined in UndefinedObject and SmallInteger"
@@ -2219,7 +2219,7 @@
             hash <<= 1;
         }
 
-        RETURN ( __MKSMALLINT(hash) );
+        RETURN ( __mkSmallInteger(hash) );
     }
 %}.
     "never reached, since UndefinedObject and SmallInteger are not hashed upon in binary storage"
@@ -5309,7 +5309,7 @@
             nargs = __intVal(numberOfArgs);
             argP = (OBJ *)(&a1);
             for (i=1; i <= nargs; i++) {
-                *argP++ = __AT_(argArray, __MKSMALLINT((INT)i));
+                *argP++ = __AT_(argArray, __mkSmallInteger(i));
             }
             argP = (OBJ *)(&a1);
         } else {
@@ -5791,7 +5791,7 @@
             nargs = __intVal(numberOfArgs);
             argP = (OBJ *)(&a1);
             for (i=1; i <= nargs; i++) {
-                *argP++ = __AT_(argArray, __MKSMALLINT((INT)i));
+                *argP++ = __AT_(argArray, __mkSmallInteger(i));
             }
             argP = (OBJ *)(&a1);
         } else {
@@ -7041,32 +7041,32 @@
         case __MASKSMALLINT(POINTERARRAY):
         case __MASKSMALLINT(WKPOINTERARRAY):
             nbytes -= nInstBytes;
-            RETURN ( __MKSMALLINT(__BYTES2OBJS__(nbytes)) );
+            RETURN ( __mkSmallInteger(__BYTES2OBJS__(nbytes)) );
 
         case __MASKSMALLINT(BYTEARRAY):
             nbytes -= nInstBytes;
-            RETURN ( __MKSMALLINT(nbytes / sizeof(char)) );
+            RETURN ( __mkSmallInteger(nbytes / sizeof(char)) );
 
         case __MASKSMALLINT(FLOATARRAY):
             nbytes -= nInstBytes;
-            RETURN ( __MKSMALLINT(nbytes / sizeof(float)) );
+            RETURN ( __mkSmallInteger(nbytes / sizeof(float)) );
 
         case __MASKSMALLINT(DOUBLEARRAY):
 #ifdef __NEED_DOUBLE_ALIGN
             nInstBytes = (nInstBytes-1+__DOUBLE_ALIGN) &~ (__DOUBLE_ALIGN-1);
 #endif
             nbytes -= nInstBytes;
-            RETURN ( __MKSMALLINT(nbytes / sizeof(double)) );
+            RETURN ( __mkSmallInteger(nbytes / sizeof(double)) );
 
         case __MASKSMALLINT(WORDARRAY):
         case __MASKSMALLINT(SWORDARRAY):
             nbytes -= nInstBytes;
-            RETURN ( __MKSMALLINT(nbytes>>1) ); /* notice the hardcoded 2 here - not sizeof(short) */
+            RETURN ( __mkSmallInteger(nbytes>>1) ); /* notice the hardcoded 2 here - not sizeof(short) */
 
         case __MASKSMALLINT(LONGARRAY):
         case __MASKSMALLINT(SLONGARRAY):
             nbytes -= nInstBytes;
-            RETURN ( __MKSMALLINT(nbytes>>2) ); /* notice the hardcoded 4 here - not sizeof(int) */
+            RETURN ( __mkSmallInteger(nbytes>>2) ); /* notice the hardcoded 4 here - not sizeof(int) */
 
         case __MASKSMALLINT(LONGLONGARRAY):
         case __MASKSMALLINT(SLONGLONGARRAY):
@@ -7074,7 +7074,7 @@
             nInstBytes = (nInstBytes-1+__LONGLONG_ALIGN) &~ (__LONGLONG_ALIGN-1);
 #endif
             nbytes -= nInstBytes;
-            RETURN ( __MKSMALLINT(nbytes>>3) ); /* notice the hardcoded 8 here - not sizeof(long long) */
+            RETURN ( __mkSmallInteger(nbytes>>3) ); /* notice the hardcoded 8 here - not sizeof(long long) */
     }
 %}.
     ^ 0
@@ -9239,7 +9239,7 @@
 !Object class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/Object.st,v 1.534 2005-07-08 15:03:44 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/Object.st,v 1.535 2005-07-08 17:15:02 cg Exp $'
 ! !
 
 Object initialize!
--- a/ObjectMemory.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/ObjectMemory.st	Fri Jul 08 19:15:03 2005 +0200
@@ -720,7 +720,7 @@
      takes"
 
 %{  /* NOCONTEXT */
-    RETURN(__MKSMALLINT(sizeof(OBJ)));
+    RETURN(__mkSmallInteger(sizeof(OBJ)));
 %}
 
     "
@@ -733,7 +733,7 @@
      i.e. the number of bytes in every objects header."
 
 %{  /* NOCONTEXT */
-    RETURN(__MKSMALLINT(OHDR_SIZE));
+    RETURN(__mkSmallInteger(OHDR_SIZE));
 %}
 
     "
@@ -1044,7 +1044,7 @@
      caches which are stored with the image"
 
 %{  /* NOCONTEXT */
-    RETURN ( __MKSMALLINT( __snapshotID() ));
+    RETURN ( __mkSmallInteger( __snapshotID() ));
 %}
     "
      ObjectMemory snapshotID     
@@ -1096,7 +1096,7 @@
         }
     }
     if ((unsigned INT)anObject <= _MAX_INT) {
-        RETURN ( __MKSMALLINT((INT)anObject) );
+        RETURN ( __mkSmallInteger((INT)anObject) );
     }
     RETURN ( __MKUINT((INT)anObject) );
 %}
@@ -1121,7 +1121,7 @@
     if (! __isNonNilObject(anObject)) {
         RETURN ( 0 );
     }
-    RETURN ( __MKSMALLINT( _GET_AGE(anObject) ) );
+    RETURN ( __mkSmallInteger( _GET_AGE(anObject) ) );
 %}
     "
     |p|
@@ -1590,7 +1590,7 @@
     if (! __isNonNilObject(anObject)) {
         RETURN ( nil );
     }
-    RETURN ( __MKSMALLINT( anObject->o_flags ) );
+    RETURN ( __mkSmallInteger( anObject->o_flags ) );
 %}
     "
 F_ISREMEMBERED  1       /* a new-space thing being refd by some oldSpace thing */
@@ -1783,7 +1783,7 @@
 
 %{  /* NOCONTEXT */
 
-    RETURN ( __isNonNilObject(anObject) ? __MKSMALLINT(__qSize(anObject)) : __MKSMALLINT(0) )
+    RETURN ( __isNonNilObject(anObject) ? __mkSmallInteger(__qSize(anObject)) : __mkSmallInteger(0) )
 %}
     "
      |hist big nw|
@@ -1815,7 +1815,7 @@
     if (! __isNonNilObject(anObject)) {
 	RETURN ( nil );
     }
-    RETURN ( __MKSMALLINT( __qSpace(anObject) ) );
+    RETURN ( __mkSmallInteger( __qSpace(anObject) ) );
 %}
 ! !
 
@@ -2751,7 +2751,7 @@
      extern int __fastMoreOldSpaceLimit();
 
      if (__isSmallInteger(aNumber)) {
-         RETURN ( __MKSMALLINT( __fastMoreOldSpaceLimit(__intVal(aNumber))));
+         RETURN ( __mkSmallInteger( __fastMoreOldSpaceLimit(__intVal(aNumber))));
      }
 %}.
      ^ 0
@@ -2936,7 +2936,7 @@
 %{  /* NOCONTEXT */
     extern unsigned __maxOldSpace();
 
-    RETURN (__MKSMALLINT( __maxOldSpace(-1) )); 
+    RETURN (__mkSmallInteger( __maxOldSpace(-1) )); 
 %}.
     ^ 0
     "
@@ -2959,7 +2959,7 @@
     extern unsigned __maxOldSpace();
 
     if (__isSmallInteger(amount)) {
-        RETURN (__MKSMALLINT( __maxOldSpace(__intVal(amount)) )); 
+        RETURN (__mkSmallInteger( __maxOldSpace(__intVal(amount)) )); 
     }
 %}.
     ^ 0
@@ -3069,7 +3069,7 @@
 %{  /* NOCONTEXT */
     extern unsigned __compressingGCLimit();
 
-    RETURN (__MKSMALLINT( __compressingGCLimit(-1) ));
+    RETURN (__mkSmallInteger( __compressingGCLimit(-1) ));
 %}.
     ^ 0
     "
@@ -3090,7 +3090,7 @@
     extern unsigned __compressingGCLimit();
 
     if (__isSmallInteger(amount)) {
-        RETURN (__MKSMALLINT( __compressingGCLimit(__intVal(amount)) ));
+        RETURN (__mkSmallInteger( __compressingGCLimit(__intVal(amount)) ));
     }
 %}.
     ^ 0
@@ -3109,7 +3109,7 @@
 %{  /* NOCONTEXT */
     extern unsigned __oldSpaceIncrement();
 
-    RETURN (__MKSMALLINT( __oldSpaceIncrement(-1) )); 
+    RETURN (__mkSmallInteger( __oldSpaceIncrement(-1) )); 
 %}.
     ^ 0
     "
@@ -3128,7 +3128,7 @@
     extern unsigned __oldSpaceIncrement();
 
     if (__isSmallInteger(amount)) {
-        RETURN (__MKSMALLINT( __oldSpaceIncrement(__intVal(amount)) )); 
+        RETURN (__mkSmallInteger( __oldSpaceIncrement(__intVal(amount)) )); 
     }
 %}.
     ^ 0
@@ -3465,7 +3465,7 @@
 				    __isSmallInteger(aNumber)
 				    ? __intVal(aNumber)
 				    : -1);
-    RETURN (__MKSMALLINT(prev));
+    RETURN (__mkSmallInteger(prev));
 %}.
 
     "
@@ -3517,7 +3517,7 @@
     prev = __codeSizeLimitForDynamicCompilation( __isSmallInteger(aNumber)
 				    ? __intVal(aNumber)
 				    : -1);
-    RETURN (__MKSMALLINT(prev));
+    RETURN (__mkSmallInteger(prev));
 %}.
 
     "
@@ -3536,7 +3536,7 @@
     int nBytes;
 
     nBytes = __compiledCodeCounter();
-    RETURN (__MKSMALLINT(nBytes));
+    RETURN (__mkSmallInteger(nBytes));
 %}
     "
      ObjectMemory compiledCodeCounter
@@ -3552,7 +3552,7 @@
     int nBytes;
 
     nBytes = __compiledCodeSpaceUsed();
-    RETURN (__MKSMALLINT(nBytes));
+    RETURN (__mkSmallInteger(nBytes));
 %}
     "
      ObjectMemory compiledCodeSpaceUsed
@@ -3607,7 +3607,7 @@
 
     limit = __dynamicCodeLimit();
     if (limit) {
-	RETURN (__MKSMALLINT(limit));
+	RETURN (__mkSmallInteger(limit));
     }
     RETURN (nil);
 %}
@@ -3630,7 +3630,7 @@
     prev = __insnSizeLimitForDynamicCompilation( __isSmallInteger(aNumber)
 				    ? __intVal(aNumber)
 				    : -1);
-    RETURN (__MKSMALLINT(prev));
+    RETURN (__mkSmallInteger(prev));
 %}.
 
     "
@@ -4072,7 +4072,7 @@
 %{  /* NOCONTEXT */
     extern unsigned __oldSpaceUsed(), __newSpaceUsed(), __freeListSpace();
 
-    RETURN ( __MKSMALLINT(__oldSpaceUsed() + __newSpaceUsed() - __freeListSpace()) );
+    RETURN ( __mkSmallInteger(__oldSpaceUsed() + __newSpaceUsed() - __freeListSpace()) );
 %}
     "
      ObjectMemory bytesUsed  
@@ -4104,7 +4104,7 @@
 %{  /* NOCONTEXT */
     extern unsigned __fixSpaceSize();
 
-    RETURN ( __MKSMALLINT(__fixSpaceSize()) );
+    RETURN ( __mkSmallInteger(__fixSpaceSize()) );
 %}
     "
      ObjectMemory fixSpaceSize
@@ -4117,7 +4117,7 @@
 %{  /* NOCONTEXT */
     extern unsigned __fixSpaceUsed();
 
-    RETURN ( __MKSMALLINT(__fixSpaceUsed()) );
+    RETURN ( __mkSmallInteger(__fixSpaceUsed()) );
 %}
     "
      ObjectMemory fixSpaceUsed
@@ -4131,7 +4131,7 @@
 %{  /* NOCONTEXT */
     extern unsigned __freeListSpace();
 
-    RETURN ( __MKSMALLINT(__freeListSpace()) );
+    RETURN ( __mkSmallInteger(__freeListSpace()) );
 %}
     "
      ObjectMemory freeListSpace
@@ -4145,7 +4145,7 @@
 %{  /* NOCONTEXT */
     extern unsigned __oldSpaceSize(), __oldSpaceUsed();
 
-    RETURN ( __MKSMALLINT(__oldSpaceSize() - __oldSpaceUsed()) );
+    RETURN ( __mkSmallInteger(__oldSpaceSize() - __oldSpaceUsed()) );
 %}
     "
      ObjectMemory freeSpace
@@ -4158,7 +4158,7 @@
 %{  /* NOCONTEXT */
     extern int __garbageCollectCount();
 
-    RETURN (__MKSMALLINT(__garbageCollectCount()));
+    RETURN (__mkSmallInteger(__garbageCollectCount()));
 %}
     "
      ObjectMemory garbageCollectCount 
@@ -4171,7 +4171,7 @@
 %{  /* NOCONTEXT */
     extern int __incrementalGCCount();
 
-    RETURN (__MKSMALLINT(__incrementalGCCount()));
+    RETURN (__mkSmallInteger(__incrementalGCCount()));
 %}
     "
      ObjectMemory incrementalGCCount
@@ -4192,7 +4192,7 @@
 %{  /* NOCONTEXT */
     extern int __incrGCphase();
 
-    RETURN (__MKSMALLINT(__incrGCphase()));
+    RETURN (__mkSmallInteger(__incrGCphase()));
 %}
 !
 
@@ -4225,7 +4225,7 @@
 %{  /* NOCONTEXT */
     extern int __newSpaceReclaimed();
 
-    RETURN ( __MKSMALLINT(__newSpaceReclaimed()) );
+    RETURN ( __mkSmallInteger(__newSpaceReclaimed()) );
 %}
     "percentage of reclaimed objects is returned by:
 
@@ -4255,7 +4255,7 @@
 %{  /* NOCONTEXT */
     extern int __lifoRememberedSetSize();
 
-    RETURN (__MKSMALLINT(__lifoRememberedSetSize()));
+    RETURN (__mkSmallInteger(__lifoRememberedSetSize()));
 %}
     "
      ObjectMemory lifoRememberedSetSize
@@ -4268,7 +4268,7 @@
 %{  /* NOCONTEXT */
     extern int __markAndSweepCount();
 
-    RETURN (__MKSMALLINT(__markAndSweepCount()));
+    RETURN (__mkSmallInteger(__markAndSweepCount()));
 %}
     "
      ObjectMemory markAndSweepCount 
@@ -4282,7 +4282,7 @@
      is used, which is currently 11 bits in size."
 
 %{  /* NOCONTEXT */
-    RETURN ( __MKSMALLINT( __MAX_HASH__ << __HASH_SHIFT__) );
+    RETURN ( __mkSmallInteger( __MAX_HASH__ << __HASH_SHIFT__) );
 %}
     "
      ObjectMemory maximumIdentityHashValue
@@ -4296,7 +4296,7 @@
 %{  /* NOCONTEXT */
     extern int __newSpaceReclaimedMin();
 
-    RETURN ( __MKSMALLINT(__newSpaceReclaimedMin()) );
+    RETURN ( __mkSmallInteger(__newSpaceReclaimedMin()) );
 %}
     "
      ObjectMemory minScavengeReclamation
@@ -4309,7 +4309,7 @@
 %{  /* NOCONTEXT */
     extern unsigned __newSpaceSize();
 
-    RETURN ( __MKSMALLINT(__newSpaceSize()) );
+    RETURN ( __mkSmallInteger(__newSpaceSize()) );
 %}
     "
      ObjectMemory newSpaceSize
@@ -4324,7 +4324,7 @@
 %{  /* NOCONTEXT */
     extern unsigned __newSpaceUsed();
 
-    RETURN ( __MKSMALLINT(__newSpaceUsed()) );
+    RETURN ( __mkSmallInteger(__newSpaceUsed()) );
 %}
     "
      ObjectMemory newSpaceUsed   
@@ -4351,7 +4351,7 @@
 %{  /* NOCONTEXT */
     extern int __weakListSize();
 
-    RETURN ( __MKSMALLINT(__weakListSize()) );
+    RETURN ( __mkSmallInteger(__weakListSize()) );
 %}
     "
      ObjectMemory numberOfWeakObjects
@@ -4367,7 +4367,7 @@
 %{  /* NOCONTEXT */
     extern unsigned __oldSpaceAllocatedSinceLastGC();
 
-    RETURN ( __MKSMALLINT(__oldSpaceAllocatedSinceLastGC()) );
+    RETURN ( __mkSmallInteger(__oldSpaceAllocatedSinceLastGC()) );
 %}
     "
      ObjectMemory oldSpaceAllocatedSinceLastGC   
@@ -4380,7 +4380,7 @@
 %{  /* NOCONTEXT */
     extern unsigned __oldSpaceSize();
 
-    RETURN ( __MKSMALLINT(__oldSpaceSize()) );
+    RETURN ( __mkSmallInteger(__oldSpaceSize()) );
 %}
     "
      ObjectMemory oldSpaceSize
@@ -4394,7 +4394,7 @@
 %{  /* NOCONTEXT */
     extern unsigned __oldSpaceUsed();
 
-    RETURN ( __MKSMALLINT(__oldSpaceUsed()) );
+    RETURN ( __mkSmallInteger(__oldSpaceUsed()) );
 %}
     "
      ObjectMemory oldSpaceUsed  
@@ -4408,7 +4408,7 @@
 %{  /* NOCONTEXT */
     extern int __rememberedSetSize();
 
-    RETURN (__MKSMALLINT(__rememberedSetSize()));
+    RETURN (__mkSmallInteger(__rememberedSetSize()));
 %}
     "
      ObjectMemory rememberedSetSize
@@ -4460,7 +4460,7 @@
 %{  /* NOCONTEXT */
     extern int __scavengeCount();
 
-    RETURN (__MKSMALLINT(__scavengeCount()));
+    RETURN (__mkSmallInteger(__scavengeCount()));
 %}
     "
      ObjectMemory scavengeCount 
@@ -4473,7 +4473,7 @@
 %{  /* NOCONTEXT */
     extern unsigned __symSpaceSize();
 
-    RETURN ( __MKSMALLINT(__symSpaceSize()) );
+    RETURN ( __mkSmallInteger(__symSpaceSize()) );
 %}
     "
      ObjectMemory symSpaceSize
@@ -4486,7 +4486,7 @@
 %{  /* NOCONTEXT */
     extern unsigned __symSpaceUsed();
 
-    RETURN ( __MKSMALLINT(__symSpaceUsed()) );
+    RETURN ( __mkSmallInteger(__symSpaceUsed()) );
 %}
     "
      ObjectMemory symSpaceUsed
@@ -4501,7 +4501,7 @@
 %{  /* NOCONTEXT */
     extern unsigned __tenureAge();
 
-    RETURN ( __MKSMALLINT(__tenureAge()) );
+    RETURN ( __mkSmallInteger(__tenureAge()) );
 %}
 !
 
@@ -5119,7 +5119,7 @@
 !ObjectMemory class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/ObjectMemory.st,v 1.221 2005-03-29 22:33:44 stefan Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/ObjectMemory.st,v 1.222 2005-07-08 17:15:02 cg Exp $'
 ! !
 
 ObjectMemory initialize!
--- a/OpenVMSOperatingSystem.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/OpenVMSOperatingSystem.st	Fri Jul 08 19:15:03 2005 +0200
@@ -747,9 +747,9 @@
 
 %{  /* NOCONTEXT */
 #ifdef SIGABRT
-    RETURN ( __MKSMALLINT(SIGABRT) );
+    RETURN ( __mkSmallInteger(SIGABRT) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -760,9 +760,9 @@
 
 %{  /* NOCONTEXT */
 #ifdef SIGALRM
-    RETURN ( __MKSMALLINT(SIGALRM) );
+    RETURN ( __mkSmallInteger(SIGALRM) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -773,9 +773,9 @@
 
 %{  /* NOCONTEXT */
 #ifdef SIGBREAK
-    RETURN ( __MKSMALLINT(SIGBREAK) );
+    RETURN ( __mkSmallInteger(SIGBREAK) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -786,9 +786,9 @@
 
 %{  /* NOCONTEXT */
 #ifdef SIGBUS
-    RETURN ( __MKSMALLINT(SIGBUS) );
+    RETURN ( __mkSmallInteger(SIGBUS) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -799,12 +799,12 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGCHLD)
-    RETURN ( __MKSMALLINT(SIGCHLD) );
+    RETURN ( __mkSmallInteger(SIGCHLD) );
 #else
 # if  defined(SIGCLD)
-    RETURN ( __MKSMALLINT(SIGCLD) );
+    RETURN ( __mkSmallInteger(SIGCLD) );
 # else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 # endif
 #endif
 %}
@@ -816,9 +816,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGCONT)
-    RETURN ( __MKSMALLINT(SIGCONT) );
+    RETURN ( __mkSmallInteger(SIGCONT) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -829,9 +829,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGDANGER)
-    RETURN ( __MKSMALLINT(SIGDANGER) );
+    RETURN ( __mkSmallInteger(SIGDANGER) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -842,9 +842,9 @@
 
 %{  /* NOCONTEXT */
 #ifdef SIGEMT
-    RETURN ( __MKSMALLINT(SIGEMT) );
+    RETURN ( __mkSmallInteger(SIGEMT) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -855,9 +855,9 @@
 
 %{  /* NOCONTEXT */
 #ifdef SIGFPE
-    RETURN ( __MKSMALLINT(SIGFPE) );
+    RETURN ( __mkSmallInteger(SIGFPE) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -868,9 +868,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGGRANT)
-    RETURN ( __MKSMALLINT(SIGGRANT) );
+    RETURN ( __mkSmallInteger(SIGGRANT) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -881,9 +881,9 @@
 
 %{  /* NOCONTEXT */
 #ifdef SIGHUP
-    RETURN ( __MKSMALLINT(SIGHUP) );
+    RETURN ( __mkSmallInteger(SIGHUP) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -894,9 +894,9 @@
 
 %{  /* NOCONTEXT */
 #ifdef SIGILL
-    RETURN ( __MKSMALLINT(SIGILL) );
+    RETURN ( __mkSmallInteger(SIGILL) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -907,9 +907,9 @@
 
 %{  /* NOCONTEXT */
 #ifdef SIGINT
-    RETURN ( __MKSMALLINT(SIGINT) );
+    RETURN ( __mkSmallInteger(SIGINT) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -920,9 +920,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGIO)
-    RETURN ( __MKSMALLINT(SIGIO) );
+    RETURN ( __mkSmallInteger(SIGIO) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -933,9 +933,9 @@
 
 %{  /* NOCONTEXT */
 #ifdef SIGIOT
-    RETURN ( __MKSMALLINT(SIGIOT) );
+    RETURN ( __mkSmallInteger(SIGIOT) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -946,9 +946,9 @@
 
 %{  /* NOCONTEXT */
 #ifdef SIGKILL
-    RETURN ( __MKSMALLINT(SIGKILL) );
+    RETURN ( __mkSmallInteger(SIGKILL) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -959,9 +959,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGLOST)
-    RETURN ( __MKSMALLINT(SIGLOST) );
+    RETURN ( __mkSmallInteger(SIGLOST) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -972,9 +972,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGMIGRATE)
-    RETURN ( __MKSMALLINT(SIGMIGRATE) );
+    RETURN ( __mkSmallInteger(SIGMIGRATE) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -985,9 +985,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGMSG)
-    RETURN ( __MKSMALLINT(SIGMSG) );
+    RETURN ( __mkSmallInteger(SIGMSG) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -998,9 +998,9 @@
 
 %{  /* NOCONTEXT */
 #ifdef SIGPIPE
-    RETURN ( __MKSMALLINT(SIGPIPE) );
+    RETURN ( __mkSmallInteger(SIGPIPE) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1011,9 +1011,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGPOLL)
-    RETURN ( __MKSMALLINT(SIGPOLL) );
+    RETURN ( __mkSmallInteger(SIGPOLL) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1024,9 +1024,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGPRE)
-    RETURN ( __MKSMALLINT(SIGPRE) );
+    RETURN ( __mkSmallInteger(SIGPRE) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1037,9 +1037,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGPROF)
-    RETURN ( __MKSMALLINT(SIGPROF) );
+    RETURN ( __mkSmallInteger(SIGPROF) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1050,9 +1050,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGPWR)
-    RETURN ( __MKSMALLINT(SIGPWR) );
+    RETURN ( __mkSmallInteger(SIGPWR) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1063,9 +1063,9 @@
 
 %{  /* NOCONTEXT */
 #ifdef SIGQUIT
-    RETURN ( __MKSMALLINT(SIGQUIT) );
+    RETURN ( __mkSmallInteger(SIGQUIT) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1076,9 +1076,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGRETRACT)
-    RETURN ( __MKSMALLINT(SIGRETRACT) );
+    RETURN ( __mkSmallInteger(SIGRETRACT) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1089,9 +1089,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGSAK)
-    RETURN ( __MKSMALLINT(SIGSAK) );
+    RETURN ( __mkSmallInteger(SIGSAK) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1102,9 +1102,9 @@
 
 %{  /* NOCONTEXT */
 #ifdef SIGSEGV
-    RETURN ( __MKSMALLINT(SIGSEGV) );
+    RETURN ( __mkSmallInteger(SIGSEGV) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1115,9 +1115,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGSOUND)
-    RETURN ( __MKSMALLINT(SIGSOUND) );
+    RETURN ( __mkSmallInteger(SIGSOUND) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1128,9 +1128,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGSTOP)
-    RETURN ( __MKSMALLINT(SIGSTOP) );
+    RETURN ( __mkSmallInteger(SIGSTOP) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1141,9 +1141,9 @@
 
 %{  /* NOCONTEXT */
 #ifdef SIGSYS
-    RETURN ( __MKSMALLINT(SIGSYS) );
+    RETURN ( __mkSmallInteger(SIGSYS) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1154,9 +1154,9 @@
 
 %{  /* NOCONTEXT */
 #ifdef SIGTERM
-    RETURN ( __MKSMALLINT(SIGTERM) );
+    RETURN ( __mkSmallInteger(SIGTERM) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1167,9 +1167,9 @@
 
 %{  /* NOCONTEXT */
 #ifdef SIGTRAP
-    RETURN ( __MKSMALLINT(SIGTRAP) );
+    RETURN ( __mkSmallInteger(SIGTRAP) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1180,9 +1180,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGTSTP)
-    RETURN ( __MKSMALLINT(SIGTSTP) );
+    RETURN ( __mkSmallInteger(SIGTSTP) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1193,9 +1193,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGTTIN)
-    RETURN ( __MKSMALLINT(SIGTTIN) );
+    RETURN ( __mkSmallInteger(SIGTTIN) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1206,9 +1206,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGTTOU)
-    RETURN ( __MKSMALLINT(SIGTTOU) );
+    RETURN ( __mkSmallInteger(SIGTTOU) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1219,9 +1219,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGURG)
-    RETURN ( __MKSMALLINT(SIGURG) );
+    RETURN ( __mkSmallInteger(SIGURG) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1232,9 +1232,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGUSR1)
-    RETURN ( __MKSMALLINT(SIGUSR1) );
+    RETURN ( __mkSmallInteger(SIGUSR1) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1245,9 +1245,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGUSR2)
-    RETURN ( __MKSMALLINT(SIGUSR2) );
+    RETURN ( __mkSmallInteger(SIGUSR2) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1258,9 +1258,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGVTALRM)
-    RETURN ( __MKSMALLINT(SIGVTALRM) );
+    RETURN ( __mkSmallInteger(SIGVTALRM) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1271,9 +1271,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGWINCH)
-    RETURN ( __MKSMALLINT(SIGWINCH) );
+    RETURN ( __mkSmallInteger(SIGWINCH) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1284,9 +1284,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGXCPU)
-    RETURN ( __MKSMALLINT(SIGXCPU) );
+    RETURN ( __mkSmallInteger(SIGXCPU) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 !
@@ -1297,9 +1297,9 @@
 
 %{  /* NOCONTEXT */
 #if defined(SIGXFSZ)
-    RETURN ( __MKSMALLINT(SIGXFSZ) );
+    RETURN ( __mkSmallInteger(SIGXFSZ) );
 #else
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 #endif
 %}
 ! !
@@ -1316,7 +1316,7 @@
 
 %{  /* NOCONTEXT */
 
-     RETURN ( __MKSMALLINT(errno) );
+     RETURN ( __mkSmallInteger(errno) );
 %}
      "
       OperatingSystem currentErrorNumber
@@ -1336,229 +1336,229 @@
      */
 #ifdef EPERM
     if (sym == @symbol(EPERM)) {
-	RETURN ( __MKSMALLINT(EPERM) );
+	RETURN ( __mkSmallInteger(EPERM) );
     }
 #endif
 
 #ifdef ENOENT
     if (sym == @symbol(ENOENT)) {
-	RETURN ( __MKSMALLINT(ENOENT) );
+	RETURN ( __mkSmallInteger(ENOENT) );
     }
 #endif
 
 #ifdef ESRCH
     if (sym == @symbol(ESRCH)) {
-	RETURN ( __MKSMALLINT(ESRCH) );
+	RETURN ( __mkSmallInteger(ESRCH) );
     }
 #endif
 
 #ifdef EINTR
     if (sym == @symbol(EINTR)) {
-	RETURN ( __MKSMALLINT(EINTR) );
+	RETURN ( __mkSmallInteger(EINTR) );
     }
 #endif
 
 #ifdef EIO
     if (sym == @symbol(EIO)) {
-	RETURN ( __MKSMALLINT(EIO) );
+	RETURN ( __mkSmallInteger(EIO) );
     }
 #endif
 
 #ifdef ENXIO
     if (sym == @symbol(ENXIO)) {
-	RETURN ( __MKSMALLINT(ENXIO) );
+	RETURN ( __mkSmallInteger(ENXIO) );
     }
 #endif
 
 #ifdef E2BIG
     if (sym == @symbol(E2BIG)) {
-	RETURN ( __MKSMALLINT(E2BIG) );
+	RETURN ( __mkSmallInteger(E2BIG) );
     }
 #endif
 
 #ifdef ENOEXEC
     if (sym == @symbol(ENOEXEC)) {
-	RETURN ( __MKSMALLINT(ENOEXEC) );
+	RETURN ( __mkSmallInteger(ENOEXEC) );
     }
 #endif
 
 #ifdef EBADF
     if (sym == @symbol(EBADF)) {
-	RETURN ( __MKSMALLINT(EBADF) );
+	RETURN ( __mkSmallInteger(EBADF) );
     }
 #endif
 
 #ifdef ECHILD
     if (sym == @symbol(ECHILD)) {
-	RETURN ( __MKSMALLINT(ECHILD) );
+	RETURN ( __mkSmallInteger(ECHILD) );
     }
 #endif
 
 #if defined(EAGAIN)
     if (sym == @symbol(EAGAIN)) {
-	RETURN ( __MKSMALLINT(EAGAIN) );
+	RETURN ( __mkSmallInteger(EAGAIN) );
     }
 #endif
 
 #ifdef ENOMEM
     if (sym == @symbol(ENOMEM)) {
-	RETURN ( __MKSMALLINT(ENOMEM) );
+	RETURN ( __mkSmallInteger(ENOMEM) );
     }
 #endif
 
 #ifdef EACCES
     if (sym == @symbol(EACCES)) {
-	RETURN ( __MKSMALLINT(EACCES) );
+	RETURN ( __mkSmallInteger(EACCES) );
     }
 #endif
 
 #ifdef EFAULT
     if (sym == @symbol(EFAULT)) {
-	RETURN ( __MKSMALLINT(EFAULT) );
+	RETURN ( __mkSmallInteger(EFAULT) );
     }
 #endif
 
 #ifdef EBUSY
     if (sym == @symbol(EBUSY)) {
-	RETURN ( __MKSMALLINT(EBUSY) );
+	RETURN ( __mkSmallInteger(EBUSY) );
     }
 #endif
 
 #ifdef EXDEV
     if (sym == @symbol(EXDEV)) {
-	RETURN ( __MKSMALLINT(EXDEV) );
+	RETURN ( __mkSmallInteger(EXDEV) );
     }
 #endif
 
 #ifdef ENODEV
     if (sym == @symbol(ENODEV)) {
-	RETURN ( __MKSMALLINT(ENODEV) );
+	RETURN ( __mkSmallInteger(ENODEV) );
     }
 #endif
 
 #ifdef ENOTDIR
     if (sym == @symbol(ENOTDIR)) {
-	RETURN ( __MKSMALLINT(ENOTDIR) );
+	RETURN ( __mkSmallInteger(ENOTDIR) );
     }
 #endif
 
 #ifdef EISDIR
     if (sym == @symbol(EISDIR)) {
-	RETURN ( __MKSMALLINT(EISDIR) );
+	RETURN ( __mkSmallInteger(EISDIR) );
     }
 #endif
 
 #ifdef EINVAL
     if (sym == @symbol(EINVAL)) {
-	RETURN ( __MKSMALLINT(EINVAL) );
+	RETURN ( __mkSmallInteger(EINVAL) );
     }
 #endif
 
 #ifdef ENFILE
     if (sym == @symbol(ENFILE)) {
-	RETURN ( __MKSMALLINT(ENFILE) );
+	RETURN ( __mkSmallInteger(ENFILE) );
     }
 #endif
 
 #ifdef EMFILE
     if (sym == @symbol(EMFILE)) {
-	RETURN ( __MKSMALLINT(EMFILE) );
+	RETURN ( __mkSmallInteger(EMFILE) );
     }
 #endif
 
 #ifdef ENOTTY
     if (sym == @symbol(ENOTTY)) {
-	RETURN ( __MKSMALLINT(ENOTTY) );
+	RETURN ( __mkSmallInteger(ENOTTY) );
     }
 #endif
 
 #ifdef EFBIG
     if (sym == @symbol(EFBIG)) {
-	RETURN ( __MKSMALLINT(EFBIG) );
+	RETURN ( __mkSmallInteger(EFBIG) );
     }
 #endif
 
 #ifdef ENOSPC
     if (sym == @symbol(ENOSPC)) {
-	RETURN ( __MKSMALLINT(ENOSPC) );
+	RETURN ( __mkSmallInteger(ENOSPC) );
     }
 #endif
 
 #ifdef ESPIPE
     if (sym == @symbol(ESPIPE)) {
-	RETURN ( __MKSMALLINT(ESPIPE) );
+	RETURN ( __mkSmallInteger(ESPIPE) );
     }
 #endif
 
 #ifdef EROFS
     if (sym == @symbol(EROFS)) {
-	RETURN ( __MKSMALLINT(EROFS) );
+	RETURN ( __mkSmallInteger(EROFS) );
     }
 #endif
 
 #ifdef EMLINK
     if (sym == @symbol(EMLINK)) {
-	RETURN ( __MKSMALLINT(EMLINK) );
+	RETURN ( __mkSmallInteger(EMLINK) );
     }
 #endif
 
 #ifdef EPIPE
     if (sym == @symbol(EPIPE)) {
-	RETURN ( __MKSMALLINT(EPIPE) );
+	RETURN ( __mkSmallInteger(EPIPE) );
     }
 #endif
 
 #ifdef EDOM
     if (sym == @symbol(EDOM)) {
-	RETURN ( __MKSMALLINT(EDOM) );
+	RETURN ( __mkSmallInteger(EDOM) );
     }
 #endif
 
 #ifdef ERANGE
     if (sym == @symbol(ERANGE)) {
-	RETURN ( __MKSMALLINT(ERANGE) );
+	RETURN ( __mkSmallInteger(ERANGE) );
     }
 #endif
 
 #ifdef EDEADLK
     if (sym == @symbol(EDEADLK)) {
-	RETURN ( __MKSMALLINT(EDEADLK) );
+	RETURN ( __mkSmallInteger(EDEADLK) );
     }
 #endif
 
 #ifdef ENAMETOOLONG
     if (sym == @symbol(ENAMETOOLONG)) {
-	RETURN ( __MKSMALLINT(ENAMETOOLONG) );
+	RETURN ( __mkSmallInteger(ENAMETOOLONG) );
     }
 #endif
 
 #ifdef ENOLCK
     if (sym == @symbol(ENOLCK)) {
-	RETURN ( __MKSMALLINT(ENOLCK) );
+	RETURN ( __mkSmallInteger(ENOLCK) );
     }
 #endif
 
 #ifdef ENOSYS
     if (sym == @symbol(ENOSYS)) {
-	RETURN ( __MKSMALLINT(ENOSYS) );
+	RETURN ( __mkSmallInteger(ENOSYS) );
     }
 #endif
 
 #ifdef ENOTEMPTY
     if (sym == @symbol(ENOTEMPTY)) {
-	RETURN ( __MKSMALLINT(ENOTEMPTY) );
+	RETURN ( __mkSmallInteger(ENOTEMPTY) );
     }
 #endif
 
 #ifdef EEXIST
     if (sym == @symbol(EEXIST)) {
-	RETURN ( __MKSMALLINT(EEXIST) );
+	RETURN ( __mkSmallInteger(EEXIST) );
     }
 #endif
 
 #ifdef EILSEQ
     if (sym == @symbol(EILSEQ)) {
-	RETURN ( __MKSMALLINT(EILSEQ) );
+	RETURN ( __mkSmallInteger(EILSEQ) );
     }
 #endif
 
@@ -1567,13 +1567,13 @@
      */
 #ifdef ENOTBLK
     if (sym == @symbol(ENOTBLK)) {
-	RETURN ( __MKSMALLINT(ENOTBLK) );
+	RETURN ( __mkSmallInteger(ENOTBLK) );
     }
 #endif
 
 #ifdef ETXTBSY
     if (sym == @symbol(ETXTBSY)) {
-	RETURN ( __MKSMALLINT(ETXTBSY) );
+	RETURN ( __mkSmallInteger(ETXTBSY) );
     }
 #endif
 
@@ -1582,19 +1582,19 @@
      */
 #ifdef EWOULDBLOCK
     if (sym == @symbol(EWOULDBLOCK)) {
-	RETURN ( __MKSMALLINT(EWOULDBLOCK) );
+	RETURN ( __mkSmallInteger(EWOULDBLOCK) );
     }
 #endif
 
 #ifdef ENOMSG
     if (sym == @symbol(ENOMSG)) {
-	RETURN ( __MKSMALLINT(ENOMSG) );
+	RETURN ( __mkSmallInteger(ENOMSG) );
     }
 #endif
 
 #ifdef ELOOP
     if (sym == @symbol(ELOOP)) {
-	RETURN ( __MKSMALLINT(ELOOP) );
+	RETURN ( __mkSmallInteger(ELOOP) );
     }
 #endif
 
@@ -1603,31 +1603,31 @@
      */
 #ifdef ETIME
     if (sym == @symbol(ETIME)) {
-	RETURN ( __MKSMALLINT(ETIME) );
+	RETURN ( __mkSmallInteger(ETIME) );
     }
 #endif
 
 #ifdef ENOSR
     if (sym == @symbol(ENOSR)) {
-	RETURN ( __MKSMALLINT(ENOSR) );
+	RETURN ( __mkSmallInteger(ENOSR) );
     }
 #endif
 
 #ifdef ENOSTR
     if (sym == @symbol(ENOSTR)) {
-	RETURN ( __MKSMALLINT(ENOSTR) );
+	RETURN ( __mkSmallInteger(ENOSTR) );
     }
 #endif
 
 #ifdef ECOMM
     if (sym == @symbol(ECOMM)) {
-	RETURN ( __MKSMALLINT(ECOMM) );
+	RETURN ( __mkSmallInteger(ECOMM) );
     }
 #endif
 
 #ifdef EPROTO
     if (sym == @symbol(EPROTO)) {
-	RETURN ( __MKSMALLINT(EPROTO) );
+	RETURN ( __mkSmallInteger(EPROTO) );
     }
 #endif
 
@@ -1636,13 +1636,13 @@
      */
 #ifdef ESTALE
     if (sym == @symbol(ESTALE)) {
-	RETURN ( __MKSMALLINT(ESTALE) );
+	RETURN ( __mkSmallInteger(ESTALE) );
     }
 #endif
 
 #ifdef EREMOTE
     if (sym == @symbol(EREMOTE)) {
-	RETURN ( __MKSMALLINT(EREMOTE) );
+	RETURN ( __mkSmallInteger(EREMOTE) );
     }
 #endif
 
@@ -1651,157 +1651,157 @@
      */
 #ifdef EINPROGRESS
     if (sym == @symbol(EINPROGRESS)) {
-	RETURN ( __MKSMALLINT(EINPROGRESS) );
+	RETURN ( __mkSmallInteger(EINPROGRESS) );
     }
 #endif
 
 #ifdef EALREADY
     if (sym == @symbol(EALREADY)) {
-	RETURN ( __MKSMALLINT(EALREADY) );
+	RETURN ( __mkSmallInteger(EALREADY) );
     }
 #endif
 
 #ifdef ENOTSOCK
     if (sym == @symbol(ENOTSOCK)) {
-	RETURN ( __MKSMALLINT(ENOTSOCK) );
+	RETURN ( __mkSmallInteger(ENOTSOCK) );
     }
 #endif
 
 #ifdef EDESTADDRREQ
     if (sym == @symbol(EDESTADDRREQ)) {
-	RETURN ( __MKSMALLINT(EDESTADDRREQ) );
+	RETURN ( __mkSmallInteger(EDESTADDRREQ) );
     }
 #endif
 
 #ifdef EMSGSIZE
     if (sym == @symbol(EMSGSIZE)) {
-	RETURN ( __MKSMALLINT(EMSGSIZE) );
+	RETURN ( __mkSmallInteger(EMSGSIZE) );
     }
 #endif
 
 #ifdef EPROTOTYPE
     if (sym == @symbol(EPROTOTYPE)) {
-	RETURN ( __MKSMALLINT(EPROTOTYPE) );
+	RETURN ( __mkSmallInteger(EPROTOTYPE) );
     }
 #endif
 
 #ifdef ENOPROTOOPT
     if (sym == @symbol(ENOPROTOOPT)) {
-	RETURN ( __MKSMALLINT(ENOPROTOOPT) );
+	RETURN ( __mkSmallInteger(ENOPROTOOPT) );
     }
 #endif
 
 #ifdef EPROTONOSUPPORT
     if (sym == @symbol(EPROTONOSUPPORT)) {
-	RETURN ( __MKSMALLINT(EPROTONOSUPPORT) );
+	RETURN ( __mkSmallInteger(EPROTONOSUPPORT) );
     }
 #endif
 
 #ifdef ESOCKTNOSUPPORT
     if (sym == @symbol(ESOCKTNOSUPPORT)) {
-	RETURN ( __MKSMALLINT(ESOCKTNOSUPPORT) );
+	RETURN ( __mkSmallInteger(ESOCKTNOSUPPORT) );
     }
 #endif
 
 #ifdef EOPNOTSUPP
     if (sym == @symbol(EOPNOTSUPP)) {
-	RETURN ( __MKSMALLINT(EOPNOTSUPP) );
+	RETURN ( __mkSmallInteger(EOPNOTSUPP) );
     }
 #endif
 
 #ifdef EPFNOSUPPORT
     if (sym == @symbol(EPFNOSUPPORT)) {
-	RETURN ( __MKSMALLINT(EPFNOSUPPORT) );
+	RETURN ( __mkSmallInteger(EPFNOSUPPORT) );
     }
 #endif
 
 #ifdef EAFNOSUPPORT
     if (sym == @symbol(EAFNOSUPPORT)) {
-	RETURN ( __MKSMALLINT(EAFNOSUPPORT) );
+	RETURN ( __mkSmallInteger(EAFNOSUPPORT) );
     }
 #endif
 
 #ifdef EADDRINUSE
     if (sym == @symbol(EADDRINUSE)) {
-	RETURN ( __MKSMALLINT(EADDRINUSE) );
+	RETURN ( __mkSmallInteger(EADDRINUSE) );
     }
 #endif
 
 #ifdef EADDRNOTAVAIL
     if (sym == @symbol(EADDRNOTAVAIL)) {
-	RETURN ( __MKSMALLINT(EADDRNOTAVAIL) );
+	RETURN ( __mkSmallInteger(EADDRNOTAVAIL) );
     }
 #endif
 
 #ifdef ETIMEDOUT
     if (sym == @symbol(ETIMEDOUT)) {
-	RETURN ( __MKSMALLINT(ETIMEDOUT) );
+	RETURN ( __mkSmallInteger(ETIMEDOUT) );
     }
 #endif
 
 #ifdef ECONNREFUSED
     if (sym == @symbol(ECONNREFUSED)) {
-	RETURN ( __MKSMALLINT(ECONNREFUSED) );
+	RETURN ( __mkSmallInteger(ECONNREFUSED) );
     }
 #endif
 
 #ifdef ENETDOWN
     if (sym == @symbol(ENETDOWN)) {
-	RETURN ( __MKSMALLINT(ENETDOWN) );
+	RETURN ( __mkSmallInteger(ENETDOWN) );
     }
 #endif
 
 #ifdef ENETUNREACH
     if (sym == @symbol(ENETUNREACH)) {
-	RETURN ( __MKSMALLINT(ENETUNREACH) );
+	RETURN ( __mkSmallInteger(ENETUNREACH) );
     }
 #endif
 
 #ifdef ENETRESET
     if (sym == @symbol(ENETRESET)) {
-	RETURN ( __MKSMALLINT(ENETRESET) );
+	RETURN ( __mkSmallInteger(ENETRESET) );
     }
 #endif
 
 #ifdef ECONNABORTED
     if (sym == @symbol(ECONNABORTED)) {
-	RETURN ( __MKSMALLINT(ECONNABORTED) );
+	RETURN ( __mkSmallInteger(ECONNABORTED) );
     }
 #endif
 
 #ifdef ECONNRESET
     if (sym == @symbol(ECONNRESET)) {
-	RETURN ( __MKSMALLINT(ECONNRESET) );
+	RETURN ( __mkSmallInteger(ECONNRESET) );
     }
 #endif
 
 #ifdef EISCONN
     if (sym == @symbol(EISCONN)) {
-	RETURN ( __MKSMALLINT(EISCONN) );
+	RETURN ( __mkSmallInteger(EISCONN) );
     }
 #endif
 
 #ifdef ENOTCONN
     if (sym == @symbol(ENOTCONN)) {
-	RETURN ( __MKSMALLINT(ENOTCONN) );
+	RETURN ( __mkSmallInteger(ENOTCONN) );
     }
 #endif
 
 #ifdef ESHUTDOWN
     if (sym == @symbol(ESHUTDOWN)) {
-	RETURN ( __MKSMALLINT(ESHUTDOWN) );
+	RETURN ( __mkSmallInteger(ESHUTDOWN) );
     }
 #endif
 
 #ifdef EHOSTDOWN
     if (sym == @symbol(EHOSTDOWN)) {
-	RETURN ( __MKSMALLINT(EHOSTDOWN) );
+	RETURN ( __mkSmallInteger(EHOSTDOWN) );
     }
 #endif
 
 #ifdef EHOSTUNREACH
     if (sym == @symbol(EHOSTUNREACH)) {
-	RETURN ( __MKSMALLINT(EHOSTUNREACH) );
+	RETURN ( __mkSmallInteger(EHOSTUNREACH) );
     }
 #endif
     /*
@@ -1809,7 +1809,7 @@
      */
 #ifdef EVMSERR
     if (sym == @symbol(EVMSERR)) {
-	RETURN ( __MKSMALLINT(EVMSERR) );
+	RETURN ( __mkSmallInteger(EVMSERR) );
     }
 #endif
 
@@ -2818,7 +2818,7 @@
 	    }
 #endif /* NO_WAITPID */
 	}
-	RETURN ( __MKSMALLINT(status));
+	RETURN ( __mkSmallInteger(status));
     }
 %}.
     self primitiveFailed
@@ -2967,7 +2967,7 @@
 
 	ret = mkdir(__stringVal(aPathName), 0755);
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN (false);
 	}
 	RETURN (true);
@@ -3053,7 +3053,7 @@
 	} while (ret < 0 && errno == EINTR);
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( false );
 	}
 	RETURN (true);
@@ -3088,7 +3088,7 @@
 	} while (ret < 0 && errno == EINTR);
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( false );
 	}
 	RETURN (true);
@@ -3117,7 +3117,7 @@
 	} while (ret < 0 && errno == EINTR);
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( false );
 	}
 	RETURN (true);
@@ -3151,7 +3151,7 @@
 	} while (ret < 0 && errno == EINTR);
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( false );
 	}
 	RETURN (true);
@@ -3167,14 +3167,14 @@
 	    fd = open((char *) __stringVal(aPathName), 2);
 	} while (fd < 0 && errno == EINTR);
 	if (fd < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( false );
 	}
 
 	ret = ftruncate(fd, __intVal(newSize));
 	close(fd);
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( false );
 	}
 	RETURN (true);
@@ -3210,31 +3210,31 @@
 #   endif
 
     if (aSymbol == @symbol(readUser)) {
-	RETURN ( __MKSMALLINT(S_IRUSR) );
+	RETURN ( __mkSmallInteger(S_IRUSR) );
     }
     if (aSymbol == @symbol(writeUser)) {
-	RETURN ( __MKSMALLINT(S_IWUSR) );
+	RETURN ( __mkSmallInteger(S_IWUSR) );
     }
     if (aSymbol == @symbol(executeUser)) {
-	RETURN ( __MKSMALLINT(S_IXUSR) );
+	RETURN ( __mkSmallInteger(S_IXUSR) );
     }
     if (aSymbol == @symbol(readGroup)) {
-	RETURN ( __MKSMALLINT(S_IRGRP) );
+	RETURN ( __mkSmallInteger(S_IRGRP) );
     }
     if (aSymbol == @symbol(writeGroup)) {
-	RETURN ( __MKSMALLINT(S_IWGRP) );
+	RETURN ( __mkSmallInteger(S_IWGRP) );
     }
     if (aSymbol == @symbol(executeGroup)) {
-	RETURN ( __MKSMALLINT(S_IXGRP) );
+	RETURN ( __mkSmallInteger(S_IXGRP) );
     }
     if (aSymbol == @symbol(readOthers)) {
-	RETURN ( __MKSMALLINT(S_IROTH) );
+	RETURN ( __mkSmallInteger(S_IROTH) );
     }
     if (aSymbol == @symbol(writeOthers)) {
-	RETURN ( __MKSMALLINT(S_IWOTH) );
+	RETURN ( __mkSmallInteger(S_IWOTH) );
     }
     if (aSymbol == @symbol(executeOthers)) {
-	RETURN ( __MKSMALLINT(S_IXOTH) );
+	RETURN ( __mkSmallInteger(S_IXOTH) );
     }
 %}.
     ^ self primitiveFailed
@@ -3271,10 +3271,10 @@
 	__END_INTERRUPTABLE__
 
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( nil );
 	}
-	RETURN ( __MKSMALLINT(buf.st_mode & 0777) );
+	RETURN ( __mkSmallInteger(buf.st_mode & 0777) );
     }
 %}.
    ^ self primitiveFailed
@@ -3300,7 +3300,7 @@
 	} while (ret < 0 && errno == EINTR);
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( false );
 	}
 	RETURN ( true );
@@ -3701,7 +3701,7 @@
 	__END_INTERRUPTABLE__
 
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( nil );
 	}
 	switch (buf.st_mode & S_IFMT) {
@@ -3788,10 +3788,10 @@
 		break;
 	}
 
-	recordFormatNumeric = __MKSMALLINT(buf.st_fab_rfm);
-	recordAttribs = __MKSMALLINT(buf.st_fab_rat);
-	fixedHeaderSize = __MKSMALLINT(buf.st_fab_fsz);
-	recordSize = __MKSMALLINT(buf.st_fab_mrs);
+	recordFormatNumeric = __mkSmallInteger(buf.st_fab_rfm);
+	recordAttribs = __mkSmallInteger(buf.st_fab_rat);
+	fixedHeaderSize = __mkSmallInteger(buf.st_fab_fsz);
+	recordSize = __mkSmallInteger(buf.st_fab_mrs);
 #  endif /* _POSIX_C_SOURCE */
 
 #  if __POINTER_SIZE__ == 8
@@ -3814,9 +3814,9 @@
 	id = __MKUINT(ino);
 # endif
 
-	mode = __MKSMALLINT(buf.st_mode & 0777);
-	uid = __MKSMALLINT(buf.st_uid);
-	gid = __MKSMALLINT(buf.st_gid);
+	mode = __mkSmallInteger(buf.st_mode & 0777);
+	uid = __mkSmallInteger(buf.st_uid);
+	gid = __mkSmallInteger(buf.st_gid);
 	size = __MKUINT(buf.st_size);
 	aOStime = __MKUINT(buf.st_atime);
 	mOStime = __MKUINT(buf.st_mtime);
@@ -3887,7 +3887,7 @@
 	} while ((ret < 0) && (errno == EINTR));
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( false );
 	}
 	RETURN ( ((buf.st_mode & S_IFMT) == S_IFDIR) ? true : false);
@@ -3917,7 +3917,7 @@
 	} while ((ret < 0) && (errno == EINTR));
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	}
 	RETURN ( ((ret == 0) ? true : false) );
     }
@@ -3942,7 +3942,7 @@
 	} while ((ret < 0) && (errno == EINTR));
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	}
 	RETURN ( ((ret == 0) ? true : false) );
     }
@@ -3979,7 +3979,7 @@
 	} while ((ret < 0) && (errno == EINTR));
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN (false);
 	}
 	RETURN ( ret ? false : true );
@@ -4005,7 +4005,7 @@
 	} while ((ret < 0) && (errno == EINTR));
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	}
 	RETURN ( ((ret == 0) ? true : false) );
     }
@@ -4126,7 +4126,7 @@
 #endif
 	    RETURN (retVal);
 	}
-	@global(LastErrorNumber) = __MKSMALLINT(errno);
+	@global(LastErrorNumber) = __mkSmallInteger(errno);
 	RETURN (nil);
     }
     RETURN (nil);
@@ -4203,7 +4203,7 @@
 	} while (ret < 0 && errno == EINTR);
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN (nil);
 	}
 	osSeconds = __MKUINT(buf.st_atime);
@@ -4246,7 +4246,7 @@
 	} while (ret < 0 && errno == EINTR);
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( nil );
 	}
 	osSeconds = __MKUINT(buf.st_mtime);
@@ -4291,7 +4291,7 @@
 	} while (ret < 0 && errno == EINTR);
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( nil );
 	}
 	switch (buf.st_mode & S_IFMT) {
@@ -4411,7 +4411,7 @@
 	    ret = flags;
 	}
 # endif /* !SYSV4 */
-	RETURN ( __MKSMALLINT(ret) );
+	RETURN ( __mkSmallInteger(ret) );
     }
 #endif
 %}.
@@ -4958,7 +4958,7 @@
 %{
     if (__bothSmallInteger(signalNumber, processId)) {
 	if (kill(__intVal(processId), __intVal(signalNumber)) < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( false );
 	}
 	RETURN ( true );
@@ -5154,7 +5154,7 @@
 	fprintf(stderr, "OpenVMSOperatingSystem [warning]: $CREMBX failure");
 	RETURN ( nil );
     }
-    mbxChannel = __MKSMALLINT(channel);
+    mbxChannel = __mkSmallInteger(channel);
 #endif
 %}.
     ^ mbxChannel
@@ -5578,10 +5578,10 @@
 	__AT_PUT_(info, @symbol(negativeSign), val);
     }
     if (intFractDigits >= 0) {
-	__AT_PUT_(info, @symbol(internationalFractionalDigits),  __MKSMALLINT(intFractDigits));
+	__AT_PUT_(info, @symbol(internationalFractionalDigits),  __mkSmallInteger(intFractDigits));
     }
     if (fractDigits >= 0) {
-	__AT_PUT_(info, @symbol(fractionalDigits),  __MKSMALLINT(fractDigits));
+	__AT_PUT_(info, @symbol(fractionalDigits),  __mkSmallInteger(fractDigits));
     }
     if (csPosPrecedes >= 0) {
 	if (csPosPrecedes == 0) {
@@ -5691,7 +5691,7 @@
 #ifdef UNIX_LIKE
     pid = getpid();
 #endif
-    RETURN ( __MKSMALLINT(pid) );
+    RETURN ( __mkSmallInteger(pid) );
 %}
     "
      OperatingSystem getProcessId
@@ -5857,7 +5857,7 @@
      */
 
 #   ifdef __VMS__
-     RETURN ( __MKSMALLINT(38) );
+     RETURN ( __mkSmallInteger(38) );
 #   endif
 %}.
     "unix default"
@@ -5869,7 +5869,7 @@
     "return the max number of characters in a pathName."
 
 %{  /* NOCONTEXT */
-    RETURN ( __MKSMALLINT(MAXPATHLEN) );
+    RETURN ( __mkSmallInteger(MAXPATHLEN) );
 %}
     "
      OperatingSystem maxPathLength
@@ -6044,9 +6044,9 @@
     tt = (TIME_T)t;
 
     tmPtr = localtime(&tt);
-    year = __MKSMALLINT(tmPtr->tm_year + 1900);
-    month = __MKSMALLINT(tmPtr->tm_mon + 1);
-    day = __MKSMALLINT(tmPtr->tm_mday);
+    year = __mkSmallInteger(tmPtr->tm_year + 1900);
+    month = __mkSmallInteger(tmPtr->tm_mon + 1);
+    day = __mkSmallInteger(tmPtr->tm_mday);
 %}.
     aBlock value:year value:month value:day
 
@@ -6117,16 +6117,16 @@
     tt = (TIME_T)t;
 
     tmPtr = localtime(&tt);
-    hours = __MKSMALLINT(tmPtr->tm_hour);
-    minutes = __MKSMALLINT(tmPtr->tm_min);
-    seconds = __MKSMALLINT(tmPtr->tm_sec);
-
-    year = __MKSMALLINT(tmPtr->tm_year + 1900);
-    month = __MKSMALLINT(tmPtr->tm_mon + 1);
-    day = __MKSMALLINT(tmPtr->tm_mday);
-
-    yDay = __MKSMALLINT(tmPtr->tm_yday+1);
-    wDay = __MKSMALLINT(tmPtr->tm_wday == 0 ? 7 : tmPtr->tm_wday);
+    hours = __mkSmallInteger(tmPtr->tm_hour);
+    minutes = __mkSmallInteger(tmPtr->tm_min);
+    seconds = __mkSmallInteger(tmPtr->tm_sec);
+
+    year = __mkSmallInteger(tmPtr->tm_year + 1900);
+    month = __mkSmallInteger(tmPtr->tm_mon + 1);
+    day = __mkSmallInteger(tmPtr->tm_mday);
+
+    yDay = __mkSmallInteger(tmPtr->tm_yday+1);
+    wDay = __mkSmallInteger(tmPtr->tm_wday == 0 ? 7 : tmPtr->tm_wday);
 
     if (tmPtr->tm_isdst == 0) {
 	dst = false;
@@ -6178,9 +6178,9 @@
     tt = (TIME_T)t;
 
     tmPtr = localtime(&tt);
-    hours = __MKSMALLINT(tmPtr->tm_hour);
-    minutes = __MKSMALLINT(tmPtr->tm_min);
-    seconds = __MKSMALLINT(tmPtr->tm_sec);
+    hours = __mkSmallInteger(tmPtr->tm_hour);
+    minutes = __mkSmallInteger(tmPtr->tm_min);
+    seconds = __mkSmallInteger(tmPtr->tm_sec);
 %}.
     aBlock value:hours value:minutes value:seconds value:millis
 
@@ -6211,16 +6211,16 @@
     t = __longIntVal(osSeconds);
 
     tmPtr = gmtime(&t);
-    hours = __MKSMALLINT(tmPtr->tm_hour);
-    minutes = __MKSMALLINT(tmPtr->tm_min);
-    seconds = __MKSMALLINT(tmPtr->tm_sec);
-
-    year = __MKSMALLINT(tmPtr->tm_year + 1900);
-    month = __MKSMALLINT(tmPtr->tm_mon + 1);
-    day = __MKSMALLINT(tmPtr->tm_mday);
-
-    yDay = __MKSMALLINT(tmPtr->tm_yday + 1);
-    wDay = __MKSMALLINT(tmPtr->tm_wday == 0 ? 7 : tmPtr->tm_wday);
+    hours = __mkSmallInteger(tmPtr->tm_hour);
+    minutes = __mkSmallInteger(tmPtr->tm_min);
+    seconds = __mkSmallInteger(tmPtr->tm_sec);
+
+    year = __mkSmallInteger(tmPtr->tm_year + 1900);
+    month = __mkSmallInteger(tmPtr->tm_mon + 1);
+    day = __mkSmallInteger(tmPtr->tm_mday);
+
+    yDay = __mkSmallInteger(tmPtr->tm_yday + 1);
+    wDay = __mkSmallInteger(tmPtr->tm_wday == 0 ? 7 : tmPtr->tm_wday);
 
     if (tmPtr->tm_isdst == 0) {
 	dst = false;
@@ -6270,9 +6270,9 @@
     t = __longIntVal(osSeconds);
 
     tmPtr = gmtime(&t);
-    hours = __MKSMALLINT(tmPtr->tm_hour);
-    minutes = __MKSMALLINT(tmPtr->tm_min);
-    seconds = __MKSMALLINT(tmPtr->tm_sec);
+    hours = __mkSmallInteger(tmPtr->tm_hour);
+    minutes = __mkSmallInteger(tmPtr->tm_min);
+    seconds = __mkSmallInteger(tmPtr->tm_sec);
 %}.
     aBlock value:hours value:minutes value:seconds value:millis
 
@@ -6346,7 +6346,7 @@
 
 #undef HAVE_TIME
 
-    RETURN ( __MKSMALLINT(t & 0x1FFFFFFF) );
+    RETURN ( __mkSmallInteger(t & 0x1FFFFFFF) );
 %}
 !
 
@@ -6394,7 +6394,7 @@
     ticks = times(&tb);
     t = (ticks * 1000) / HZ;
     t = t % 1000;
-    millis = __MKSMALLINT(t);
+    millis = __mkSmallInteger(t);
 #  endif /* OLD SYSV stuff */
 # endif
 
@@ -6560,7 +6560,7 @@
     int uid;
 
     uid = getegid();
-    RETURN ( __MKSMALLINT(uid) );
+    RETURN ( __mkSmallInteger(uid) );
 #endif
     /* --- return same as getGroupID --- */
 %}.
@@ -6584,7 +6584,7 @@
     int uid;
 
     uid = geteuid();
-    RETURN ( __MKSMALLINT(uid) );
+    RETURN ( __mkSmallInteger(uid) );
 #endif
     /* --- return same as getUserID --- */
 %}.
@@ -6635,7 +6635,7 @@
     int uid;
 
     uid = getgid();
-    RETURN ( __MKSMALLINT(uid) );
+    RETURN ( __mkSmallInteger(uid) );
 #else
 # ifdef SYSTEM_HAS_GROUPS
     /* ... */
@@ -6759,7 +6759,7 @@
     int uid;
 
     uid = getuid();
-    RETURN ( __MKSMALLINT(uid) );
+    RETURN ( __mkSmallInteger(uid) );
 #else
 # ifdef SYSTEM_HAS_USERS
     /* ... */
@@ -6855,8 +6855,8 @@
 #  endif
 	shell = __MKSTRING(buf->pw_shell);
 
-	uid = __MKSMALLINT(buf->pw_uid);
-	gid = __MKSMALLINT(buf->pw_gid);
+	uid = __mkSmallInteger(buf->pw_uid);
+	gid = __mkSmallInteger(buf->pw_gid);
     }
 # endif /* has PWD */
 #endif
@@ -7165,7 +7165,7 @@
 		if (FD_ISSET(i, &rset)
 		 || FD_ISSET(i, &wset)
 		 || FD_ISSET(i, &eset)) {
-		    RETURN ( __MKSMALLINT(i) );
+		    RETURN ( __mkSmallInteger(i) );
 		}
 	    }
 	} else {
@@ -7177,7 +7177,7 @@
 		    if (@global(InfoPrinting) == true) {
 			fprintf(stderr, "OS [info]: select errno = %d\n", errno);
 		    }
-		    @global(LastErrorNumber) = __MKSMALLINT(errno);
+		    @global(LastErrorNumber) = __mkSmallInteger(errno);
 		}
 	    } else {
 		@global(LastErrorNumber) = nil;
@@ -7224,7 +7224,7 @@
 	    ret = fcntl(f, F_SETFL, flags | FNDELAY);
 	}
 	if (ret >= 0) ret = flags;
-	RETURN ( __MKSMALLINT(ret) );
+	RETURN ( __mkSmallInteger(ret) );
     }
 # endif
 #endif
@@ -7528,6 +7528,6 @@
 !OpenVMSOperatingSystem class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/OpenVMSOperatingSystem.st,v 1.14 2005-07-07 15:01:52 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/OpenVMSOperatingSystem.st,v 1.15 2005-07-08 17:15:02 cg Exp $'
 ! !
 OpenVMSOperatingSystem initialize!
--- a/Process.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/Process.st	Fri Jul 08 19:15:03 2005 +0200
@@ -376,7 +376,7 @@
 
 %{  /* NOCONTEXT */
 
-    RETURN ( __MKSMALLINT( __defaultThreadMaxStackSize() ));
+    RETURN ( __mkSmallInteger( __defaultThreadMaxStackSize() ));
 %}
 
     "
@@ -398,7 +398,7 @@
 %{  /* NOCONTEXT */
 
     if (__isSmallInteger(numberOfBytes)) {
-	RETURN ( __MKSMALLINT( __threadSetDefaultMaxStackSize(__intVal(numberOfBytes)) ));
+	RETURN ( __mkSmallInteger(__threadSetDefaultMaxStackSize(__intVal(numberOfBytes)) ));
     }
 %}
 
@@ -734,7 +734,7 @@
     OBJ i;
 
     if (__isSmallInteger(i = __INST(id))) {
-	RETURN( __MKSMALLINT(__threadMaxStackSize(__intVal(i))) );
+	RETURN( __mkSmallInteger(__threadMaxStackSize(__intVal(i))) );
     }
 %}.
     ^ nil
@@ -752,7 +752,7 @@
 
     if (__isSmallInteger(i = __INST(id)) 
      && __isSmallInteger(limit) ) {
-	RETURN ( __MKSMALLINT(__threadSetMaxStackSize(__intVal(i), __intVal(limit))) );
+	RETURN ( __mkSmallInteger(__threadSetMaxStackSize(__intVal(i), __intVal(limit))) );
     }
 %}.
     ^ nil
@@ -981,7 +981,7 @@
     if (__isSmallInteger(i = __INST(id))) {
 	n = __threadNumberOfStackBoundaryHits(__intVal(i));
 	n &= 0x3FFFFFFF;
-	RETURN( __MKSMALLINT(n) );
+	RETURN( __mkSmallInteger(n) );
     }
 %}.
     ^ nil
@@ -996,7 +996,7 @@
     OBJ i;
 
     if (__isSmallInteger(i = __INST(id))) {
-	RETURN( __MKSMALLINT(__threadStackSegments(__intVal(i))) );
+	RETURN( __mkSmallInteger((INT)__threadStackSegments(__intVal(i))) );
     }
 %}.
     ^ nil
@@ -1011,7 +1011,7 @@
     OBJ i;
 
     if (__isSmallInteger(i = __INST(id))) {
-	RETURN( __MKSMALLINT(__threadTotalStackSize(__intVal(i))) );
+	RETURN( __mkSmallInteger(__threadTotalStackSize(__intVal(i))) );
     }
 %}.
     ^ nil
@@ -1026,7 +1026,7 @@
     OBJ i;
 
     if (__isSmallInteger(i = __INST(id))) {
-	RETURN( __MKSMALLINT(__threadUsedStackSize(__intVal(i))) );
+	RETURN( __mkSmallInteger(__threadUsedStackSize(__intVal(i))) );
     }
 %}.
     ^ nil
@@ -1988,7 +1988,7 @@
 !Process class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/Process.st,v 1.153 2005-05-11 09:22:10 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/Process.st,v 1.154 2005-07-08 17:15:02 cg Exp $'
 ! !
 
 Process initialize!
--- a/ProcessorScheduler.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/ProcessorScheduler.st	Fri Jul 08 19:15:03 2005 +0200
@@ -362,7 +362,7 @@
 			 __isSmallInteger(id) ? __intVal(id)     /* assign id */
 					      : -1              /* let VM assign one */  );
     if (tid) {
-	RETURN ( __MKSMALLINT(tid));
+	RETURN ( __mkSmallInteger(tid));
     }
 %}
 .
@@ -3315,7 +3315,7 @@
 !ProcessorScheduler class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/ProcessorScheduler.st,v 1.226 2005-01-11 17:05:11 stefan Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/ProcessorScheduler.st,v 1.227 2005-07-08 17:15:02 cg Exp $'
 ! !
 
 ProcessorScheduler initialize!
--- a/ReadStream.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/ReadStream.st	Fri Jul 08 19:15:03 2005 +0200
@@ -153,27 +153,27 @@
                 if (pos <= __stringSize(coll)) {
                     ch = __stringVal(coll)[pos-1];
                     ret = __MKCHARACTER(ch);
-                    __INST(position) = __MKSMALLINT(__intVal(__INST(position)) + 1);
+                    __INST(position) = __mkSmallInteger(__intVal(__INST(position)) + 1);
                     RETURN ( ret );
                 }
             } else if (cls == @global(ByteArray)) {
                 if (pos <= __byteArraySize(coll)) {
                     ch = __ByteArrayInstPtr(coll)->ba_element[pos-1];
-                    ret = __MKSMALLINT(ch);
-                    __INST(position) = __MKSMALLINT(__intVal(__INST(position)) + 1);
+                    ret = __mkSmallInteger(ch);
+                    __INST(position) = __mkSmallInteger(__intVal(__INST(position)) + 1);
                     RETURN ( ret );
                 }
             } else if (cls == @global(Unicode16String)) {
                 if (pos <= __unicode16StringSize(coll)) {
                     ch = __Unicode16StringInstPtr(coll)->s_element[pos-1];
                     ret = __MKUCHARACTER(ch);
-                    __INST(position) = __MKSMALLINT(__intVal(__INST(position)) + 1);
+                    __INST(position) = __mkSmallInteger(__intVal(__INST(position)) + 1);
                     RETURN ( ret );
                 }
             } else if (cls == @global(Array)) {
                 if (pos <= __arraySize(coll)) {
                     ret = __ArrayInstPtr(coll)->a_element[pos-1];
-                    __INST(position) = __MKSMALLINT(__intVal(__INST(position)) + 1);
+                    __INST(position) = __mkSmallInteger(__intVal(__INST(position)) + 1);
                     RETURN ( ret );
                 }
             }
@@ -249,7 +249,7 @@
 
 	/* make ZeroPosition-based */
 	pos = pos - 1 + __intVal( @global(PositionableStream:ZeroPosition));
-	__INST(position) = __MKSMALLINT(pos);
+	__INST(position) = __mkSmallInteger(pos);
 	buffer[len] = '\0';
 	RETURN ( (len != 0) ? __MKSTRING_L(buffer, len) : nil );
     }
@@ -287,21 +287,21 @@
             if (cls == @global(String)) {
                 if (pos <= __stringSize(coll)) {
                     ch = __stringVal(coll)[pos-1];
-                    ret = __MKSMALLINT(ch);
-                    __INST(position) = __MKSMALLINT(__intVal(__INST(position)) + 1);
+                    ret = __mkSmallInteger(ch);
+                    __INST(position) = __mkSmallInteger(__intVal(__INST(position)) + 1);
                     RETURN ( ret );
                 }
             } else if (cls == @global(ByteArray)) {
                 if (pos <= __byteArraySize(coll)) {
                     ch = __ByteArrayInstPtr(coll)->ba_element[pos-1];
-                    ret = __MKSMALLINT(ch);
-                    __INST(position) = __MKSMALLINT(__intVal(__INST(position)) + 1);
+                    ret = __mkSmallInteger(ch);
+                    __INST(position) = __mkSmallInteger(__intVal(__INST(position)) + 1);
                     RETURN ( ret );
                 }
             } else if (cls == @global(Array)) {
                 if (pos <= __arraySize(coll)) {
                     ret = __ArrayInstPtr(coll)->a_element[pos-1];
-                    __INST(position) = __MKSMALLINT(__intVal(__INST(position)) + 1);
+                    __INST(position) = __mkSmallInteger(__intVal(__INST(position)) + 1);
                     RETURN ( ret );
                 }
             }
@@ -391,11 +391,11 @@
 	}
 	/* make ZeroPosition-based */
 	pos = pos - 1 + __intVal( @global(PositionableStream:ZeroPosition));
-	__INST(position) = __MKSMALLINT(pos);
-	RETURN (__MKSMALLINT(val));
+	__INST(position) = __mkSmallInteger(pos);
+	RETURN (__mkSmallInteger(val));
     }
 oops:
-    value = __MKSMALLINT(val);
+    value = __mkSmallInteger(val);
 %}
 .
     "fall-back for non-string streams - we have to continue where
@@ -434,7 +434,7 @@
             ch = __stringVal(coll)[pos-1];
             /* make ZeroPosition-based */
             pos = pos - 1 + __intVal( @global(PositionableStream:ZeroPosition));
-            __INST(position) = __MKSMALLINT(pos);
+            __INST(position) = __mkSmallInteger(pos);
             RETURN ( __MKCHARACTER(ch) );
         }
     }
@@ -493,7 +493,7 @@
 
 	/* make ZeroPosition-based */
 	pos = pos - 1 + __intVal( @global(PositionableStream:ZeroPosition));
-	__INST(position) = __MKSMALLINT(pos);
+	__INST(position) = __mkSmallInteger(pos);
 	buffer[len] = '\0';
 	RETURN ( (len != 0) ? __MKSTRING_L(buffer, len) : nil );
     }
@@ -533,7 +533,7 @@
             } else if (cls == @global(ByteArray)) {
                 if (pos <= __byteArraySize(coll)) {
                     ch = __ByteArrayInstPtr(coll)->ba_element[pos-1];
-                    RETURN ( __MKSMALLINT(ch) );
+                    RETURN ( __mkSmallInteger(ch) );
                 }
             } else if (cls == @global(Array)) {
                 if (pos <= __arraySize(coll)) {
@@ -581,7 +581,7 @@
 	    } else if (cls == @global(ByteArray)) {
 		if (pos <= __byteArraySize(coll)) {
 		    ch = __ByteArrayInstPtr(coll)->ba_element[pos-1];
-		    RETURN ( __MKSMALLINT(ch) );
+		    RETURN ( __mkSmallInteger(ch) );
 		}
 		RETURN ( nil );
 	    } else if (cls == @global(Array)) {
@@ -642,13 +642,13 @@
 		 && (ch != 0x0B))) {
 		/* make ZeroPosition-based */
 		pos = pos - 1 + __intVal( @global(PositionableStream:ZeroPosition));
-		__INST(position) = __MKSMALLINT(pos-1);
+		__INST(position) = __mkSmallInteger(pos-1);
 		RETURN ( __MKCHARACTER(ch) );
 	    }
 	}
 	/* make ZeroPosition-based */
 	pos = pos - 1 + __intVal( @global(PositionableStream:ZeroPosition));
-	__INST(position) = __MKSMALLINT(pos);
+	__INST(position) = __mkSmallInteger(pos);
 	RETURN ( nil );
     }
 %}.
@@ -705,14 +705,14 @@
 		 && (ch != 0x0B))) {
 		/* make ZeroPosition-based */
 		pos = pos - 1 + __intVal( @global(PositionableStream:ZeroPosition));
-		__INST(position) = __MKSMALLINT(pos);
+		__INST(position) = __mkSmallInteger(pos);
 		RETURN ( __MKCHARACTER(ch) );
 	    }
 	    pos++;
 	}
 	/* make ZeroPosition-based */
 	pos = pos - 1 + __intVal( @global(PositionableStream:ZeroPosition));
-	__INST(position) = __MKSMALLINT(pos);
+	__INST(position) = __mkSmallInteger(pos);
 	RETURN ( nil );
     }
 %}
@@ -761,7 +761,7 @@
 		pos++;
 		/* make ZeroPosition-based */
 		pos = pos - 1 + __intVal( @global(PositionableStream:ZeroPosition));
-		__INST(position) = __MKSMALLINT(pos);
+		__INST(position) = __mkSmallInteger(pos);
 		RETURN ( self );
 	    }
 	    chars++;
@@ -769,7 +769,7 @@
 	}
 	/* make ZeroPosition-based */
 	pos = pos - 1 + __intVal( @global(PositionableStream:ZeroPosition));
-	__INST(position) = __MKSMALLINT(pos+1);
+	__INST(position) = __mkSmallInteger(pos+1);
 	RETURN ( nil );
     }
 %}.
@@ -787,5 +787,5 @@
 !ReadStream class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/ReadStream.st,v 1.52 2004-10-01 07:36:12 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/ReadStream.st,v 1.53 2005-07-08 17:15:02 cg Exp $'
 ! !
--- a/ShortFloat.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/ShortFloat.st	Fri Jul 08 19:15:03 2005 +0200
@@ -556,7 +556,7 @@
     double dResult, dVal;
 
     if (__isSmallInteger(aNumber)) {
-        if (aNumber != __MKSMALLINT(0)) {
+        if (aNumber != __mkSmallInteger(0)) {
             result = __shortFloatVal(self) / (float)(__intVal(aNumber));
 retResult:
             __qMKSFLOAT(newFloat, result);
@@ -694,7 +694,7 @@
 #endif
     {
         if ((fVal >= (float)_MIN_INT) && (fVal <= (float)_MAX_INT)) {
-            RETURN ( __MKSMALLINT( (INT)fVal) );
+            RETURN ( __mkSmallInteger( (INT)fVal) );
         }
     }
 %}.
@@ -1098,7 +1098,7 @@
 %{  /* NOCONTEXT */
 
     double frexp();
-    INT exp;
+    int exp;
 
     __threadErrno = 0;
 #if defined(__i386__) && defined(__GNUC__)
@@ -1107,7 +1107,7 @@
     frexp( (double)(__shortFloatVal(self)), &exp);
 #endif
     if (__threadErrno == 0) {
-        RETURN (__MKSMALLINT(exp));
+        RETURN (__mkSmallInteger(exp));
     }
 %}.
     ^ super exponent
@@ -1131,7 +1131,7 @@
      0.5 .. 1.0 and the floats value is mantissa * 2^exp"
 
 %{  /* NOCONTEXT */
-    INT exp;
+    int exp;
 
 #if defined(__i386__) && defined(__GNUC__)
     float frac;
@@ -1258,7 +1258,7 @@
 
 %{  /* NOCONTEXT */
 
-    RETURN (__MKSMALLINT (sizeof(float) * 8));
+    RETURN (__mkSmallInteger (sizeof(float) * 8));
 %}
 
     "
@@ -1305,7 +1305,7 @@
      * ST-80 (and X3J20) returns integer.
      */
     if ((fVal >= (float)_MIN_INT) && (fVal <= (float)_MAX_INT)) {
-        RETURN ( __MKSMALLINT( (INT) fVal ) );
+        RETURN ( __mkSmallInteger( (INT) fVal ) );
     }
     __qMKSFLOAT(val, fVal);
 %}.
@@ -1359,7 +1359,7 @@
      * ST-80 (and X3J20) returns integer.
      */
     if ((fVal >= (float)_MIN_INT) && (fVal <= (float)_MAX_INT)) {
-        RETURN ( __MKSMALLINT( (INT) fVal ) );
+        RETURN ( __mkSmallInteger( (INT) fVal ) );
     }
     __qMKSFLOAT(val, fVal);
 %}.
@@ -1459,7 +1459,7 @@
      * ST-80 (and X3J20) returns integer.
      */
     if ((fVal >= (float)_MIN_INT) && (fVal <= (float)_MAX_INT)) {
-        RETURN ( __MKSMALLINT( (INT) fVal ) );
+        RETURN ( __mkSmallInteger( (INT) fVal ) );
     }
     __qMKSFLOAT(val, fVal);
 %}.
@@ -1546,7 +1546,7 @@
      * ST-80 (and X3J20) returns integer.
      */
     if ((fVal >= (float)_MIN_INT) && (fVal <= (float)_MAX_INT)) {
-        RETURN ( __MKSMALLINT( (INT) fVal ) );
+        RETURN ( __mkSmallInteger( (INT) fVal ) );
     }
     __qMKSFLOAT(val, fVal);
 %}.
@@ -1600,5 +1600,5 @@
 !ShortFloat class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/ShortFloat.st,v 1.88 2005-07-07 15:01:52 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/ShortFloat.st,v 1.89 2005-07-08 17:15:02 cg Exp $'
 ! !
--- a/SmallInteger.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/SmallInteger.st	Fri Jul 08 19:15:03 2005 +0200
@@ -99,7 +99,7 @@
      For very special uses only - not constant across implementations"
 
 %{  /* NOCONTEXT */
-    RETURN ( __MKSMALLINT(N_INT_BITS) );
+    RETURN ( __mkSmallInteger(N_INT_BITS) );
 %}
 
     "SmallInteger maxBits"
@@ -110,7 +110,7 @@
      For very special uses only - not constant across implementations"
 
 %{  /* NOCONTEXT */
-    RETURN ( __MKSMALLINT(N_INT_BITS / 8 + 1) );
+    RETURN ( __mkSmallInteger(N_INT_BITS / 8 + 1) );
 %}
 
     "
@@ -123,7 +123,7 @@
      For very special uses only - not constant across implementations"
 
 %{  /* NOCONTEXT */
-    RETURN ( __MKSMALLINT(_MAX_INT) );
+    RETURN ( __mkSmallInteger(_MAX_INT) );
 %}
 
     "SmallInteger maxVal"
@@ -134,7 +134,7 @@
      For very special uses only - not constant across implementations"
 
 %{  /* NOCONTEXT */
-    RETURN ( __MKSMALLINT(_MIN_INT) );
+    RETURN ( __mkSmallInteger(_MIN_INT) );
 %}
 
     "SmallInteger minVal"
@@ -229,7 +229,7 @@
 	    product = (LONGLONG)myValue * (LONGLONG)otherValue;
 	    if ((product >= (LONGLONG)_MIN_INT)
 	     && (product <= (LONGLONG)_MAX_INT)) {
-		RETURN ( __MKSMALLINT((INT)product) );
+		RETURN ( __mkSmallInteger((INT)product) );
 	    }
 	    if (product < 0) {
 		negative = -1;
@@ -313,9 +313,9 @@
 	     && (pHH == 0)
 	     && ((pLL & LLMASK) == 0)) {
 		if (negative < 0) {
-		    RETURN ( __MKSMALLINT(- ((INT)pLL)) );
+		    RETURN ( __mkSmallInteger(- ((INT)pLL)) );
 		}
-		RETURN ( __MKSMALLINT((INT)pLL) );
+		RETURN ( __mkSmallInteger((INT)pLL) );
 	    }
 
 	    /*
@@ -342,11 +342,11 @@
 	if (productHi == 0) {
 	    if (negative < 0) {
 		if (productLow <= -(_MIN_INT)) {
-		    RETURN ( __MKSMALLINT(-((INT)productLow)) );
+		    RETURN ( __mkSmallInteger(-((INT)productLow)) );
 		}
 	    } else {
 		if (productLow <= _MAX_INT) {
-		    RETURN ( __MKSMALLINT(productLow) );
+		    RETURN ( __mkSmallInteger(productLow) );
 		}
 	    }
 	}
@@ -397,7 +397,7 @@
 
 	sum =  __intVal(self) + __intVal(aNumber);
 	if (__ISVALIDINTEGER(sum)) {
-	    RETURN ( __MKSMALLINT(sum) );
+	    RETURN ( __mkSmallInteger(sum) );
 	}
 	RETURN ( __MKLARGEINT(sum) );
 #endif
@@ -443,7 +443,7 @@
 
 	diff =  __intVal(self) - __intVal(aNumber);
 	if (__ISVALIDINTEGER(diff)) {
-	    RETURN ( __MKSMALLINT(diff) );
+	    RETURN ( __mkSmallInteger(diff) );
 	}
 	RETURN ( __MKLARGEINT(diff) );
 #endif
@@ -502,7 +502,7 @@
 	    */
 	    if ((t * val) == me) {
 #endif
-		RETURN ( __MKSMALLINT(t) );
+		RETURN ( __mkSmallInteger(t) );
 	    }
 	}
     } else {
@@ -596,7 +596,7 @@
 		    }
 		}
 	    }
-	    RETURN ( __MKSMALLINT(rslt) );
+	    RETURN ( __mkSmallInteger(rslt) );
 	}
     } else {
 	if (__isFraction(aNumber)) {
@@ -609,7 +609,7 @@
 		t = __FractionInstPtr(aNumber)->f_denominator;
 		if (__isSmallInteger(t)) {
 		    den = __intVal(t);
-		    RETURN ( __MKSMALLINT(__intVal(self) * den / num ));
+		    RETURN ( __mkSmallInteger(__intVal(self) * den / num ));
 		}
 	    }
 	}
@@ -684,7 +684,7 @@
 		rem = divisor - rem;
 	    }
 	}
-	RETURN ( __MKSMALLINT(rem) );
+	RETURN ( __mkSmallInteger(rem) );
     }
 %}.
     (aNumber = 0) ifTrue:[
@@ -715,7 +715,7 @@
 	RETURN (self);
     }
     if (val != _MIN_INT) {
-	RETURN ( __MKSMALLINT(-val) );
+	RETURN ( __mkSmallInteger(-val) );
     }
     /* only reached for minVal */
     RETURN( __MKLARGEINT(-_MIN_INT));
@@ -732,7 +732,7 @@
     INT val = __intVal(self);
 
     if (val != _MIN_INT) {
-	RETURN ( __MKSMALLINT(- val) );
+	RETURN ( __mkSmallInteger(- val) );
     }
     /* only reached for minVal */
     RETURN (__MKLARGEINT( -_MIN_INT));
@@ -759,7 +759,7 @@
     if (__isSmallInteger(aNumber)) {
 	val = __intVal(aNumber);
 	if (val != 0) {
-	    RETURN ( __MKSMALLINT(__intVal(self) / val) );
+	    RETURN ( __mkSmallInteger(__intVal(self) / val) );
 	}
     } else {
 	if (__isFraction(aNumber)) {
@@ -772,7 +772,7 @@
 		t = __FractionInstPtr(aNumber)->f_denominator;
 		if (__isSmallInteger(t)) {
 		    den = __intVal(t);
-		    RETURN ( __MKSMALLINT(__intVal(self) * den / num ));
+		    RETURN ( __mkSmallInteger(__intVal(self) * den / num ));
 		}
 	    }
 	}
@@ -944,7 +944,7 @@
 		result = (unsigned LONGLONG)bits;
 		result <<= count;
 		if (result <= _MAX_INT) {
-		    RETURN ( __MKSMALLINT(result) );
+		    RETURN ( __mkSmallInteger(result) );
 		}
 		{
 		    RETURN (__MKLARGEINT64(1, (INT)(result >> 32), (INT)(result & 0xFFFFFFFF)));
@@ -956,7 +956,7 @@
 	     */
 	    if (count < (N_INT_BITS-1)) {
 		if (! (bits >> (N_INT_BITS - 1 - count))) {
-		    RETURN ( __MKSMALLINT(bits << count) );
+		    RETURN ( __mkSmallInteger(bits << count) );
 		}
 		/*
 		 * so, there is an overflow ...
@@ -978,10 +978,10 @@
 	     */
 	    count = -count;
 	    if (count > (N_INT_BITS-1)) {
-		RETURN (__MKSMALLINT(0));
+		RETURN (__mkSmallInteger(0));
 	    }
 
-	    RETURN ( __MKSMALLINT(bits >> count) );
+	    RETURN ( __mkSmallInteger(bits >> count) );
 	}
     }
 %}.
@@ -1082,7 +1082,7 @@
 
     bits = __intVal(self);
     if (bits == 0) {
-	RETURN ( __MKSMALLINT(0) );
+	RETURN ( __mkSmallInteger(0) );
     }
 
 #ifdef __BSR
@@ -1118,7 +1118,7 @@
     }
 #endif /* no BSR instruction */
 
-    RETURN ( __MKSMALLINT(index+1) );
+    RETURN ( __mkSmallInteger(index+1) );
 %}
     "
      2r0 highBit
@@ -1228,7 +1228,7 @@
 
     bits = __intVal(self);
     if (bits == 0) {
-	RETURN ( __MKSMALLINT(0) );
+	RETURN ( __mkSmallInteger(0) );
     }
 
 #ifdef __BSF
@@ -1239,7 +1239,7 @@
      * but saves a few code-bytes, though.
      */
     index = __BSF(bits);
-    RETURN ( __MKSMALLINT(index + 1) );
+    RETURN ( __mkSmallInteger(index + 1) );
 #else
 
     index = 1;
@@ -1267,7 +1267,7 @@
     }
 #endif
 
-    RETURN ( __MKSMALLINT(index) );
+    RETURN ( __mkSmallInteger(index) );
 %}
 
     "
@@ -1386,7 +1386,7 @@
     if (__isSmallInteger(shiftCount)) {
 	count = __intVal(shiftCount);
 	if (count >= 32) {
-	    RETURN (__MKSMALLINT(0));
+	    RETURN (__mkSmallInteger(0));
 	}
 
 	bits = __intVal(self);
@@ -1427,7 +1427,7 @@
     if (__isSmallInteger(shiftCount)) {
 	count = __intVal(shiftCount);
 	if (count >= 32) {
-	    RETURN (__MKSMALLINT(0));
+	    RETURN (__mkSmallInteger(0));
 	}
 
 	bits = __intVal(self);
@@ -1499,9 +1499,9 @@
 	    default:
 		if (idx < 1)
 		    goto bad;   /* sorry */
-		RETURN (__MKSMALLINT(0));
+		RETURN (__mkSmallInteger(0));
 	}
-	RETURN ( __MKSMALLINT( val & 0xFF) );
+	RETURN ( __mkSmallInteger( val & 0xFF) );
     }
   bad: ;
 %}.
@@ -1564,11 +1564,11 @@
 		if (idx < 1)
 		    goto bad;   /* sorry */
 		if (val < 0) {
-		    RETURN (__MKSMALLINT(0xFF));
+		    RETURN (__mkSmallInteger(0xFF));
 		}
-		RETURN (__MKSMALLINT(0));
+		RETURN (__mkSmallInteger(0));
 	}
-	RETURN ( __MKSMALLINT( val & 0xFF) );
+	RETURN ( __mkSmallInteger( val & 0xFF) );
     }
   bad: ;
 %}.
@@ -1636,15 +1636,15 @@
     if (val & 0xFFFFFFFF00000000L) {
 	if (val & 0xFFFF000000000000L) {
 	    if (val & 0xFF00000000000000L) {
-		RETURN ( __MKSMALLINT(8));
+		RETURN ( __mkSmallInteger(8));
 	    } else {
-		RETURN ( __MKSMALLINT(7));
+		RETURN ( __mkSmallInteger(7));
 	    }
 	} else {
 	    if (val & 0x0000FF0000000000L) {
-		RETURN ( __MKSMALLINT(6));
+		RETURN ( __mkSmallInteger(6));
 	    } else {
-		RETURN ( __MKSMALLINT(5));
+		RETURN ( __mkSmallInteger(5));
 	    }
 	}
     }
@@ -1652,15 +1652,15 @@
 
     if (val & 0xFFFF0000) {
 	if (val & 0xFF000000) {
-	    RETURN ( __MKSMALLINT(4));
+	    RETURN ( __mkSmallInteger(4));
 	} else {
-	    RETURN ( __MKSMALLINT(3));
+	    RETURN ( __mkSmallInteger(3));
 	}
     } else {
 	if (val & 0x0000FF00) {
-	    RETURN ( __MKSMALLINT(2));
+	    RETURN ( __mkSmallInteger(2));
 	} else {
-	    RETURN ( __MKSMALLINT(1));
+	    RETURN ( __mkSmallInteger(1));
 	}
     }
 
@@ -1788,7 +1788,7 @@
 	i = i & 0x7F;
     }
 
-    RETURN (__MKSMALLINT(i));
+    RETURN (__mkSmallInteger(i));
 %}.
     ^ self primitiveFailed
 
@@ -1811,7 +1811,7 @@
 	i = i & 0x7FFF;
     }
 
-    RETURN (__MKSMALLINT(i));
+    RETURN (__mkSmallInteger(i));
 %}.
     ^ self primitiveFailed
 
@@ -2076,7 +2076,7 @@
     tmp = __intVal(self);
     if (tmp > 0) {
 	if (__isBlockLike(aBlock)
-	 && (__BlockInstPtr(aBlock)->b_nargs == __MKSMALLINT(0))) {
+	 && (__BlockInstPtr(aBlock)->b_nargs == __mkSmallInteger(0))) {
 	    {
 		REGISTER OBJFUNC codeVal;
 
@@ -2265,7 +2265,7 @@
 	step = __intVal(incr);
 
 	if (__isBlockLike(aBlock)
-	 && (__BlockInstPtr(aBlock)->b_nargs == __MKSMALLINT(1))) {
+	 && (__BlockInstPtr(aBlock)->b_nargs == __mkSmallInteger(1))) {
 	    {
 		REGISTER OBJFUNC codeVal;
 
@@ -2296,13 +2296,13 @@
 			    if (step == -1) {
 				while (tmp >= final) {
 				    if (InterruptPending != nil) __interruptL(@line);
-				    (*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp));
+				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
 				    tmp--;
 				}
 			    } else {
 				while (tmp >= final) {
 				    if (InterruptPending != nil) __interruptL(@line);
-				    (*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp));
+				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
 				    tmp += step;
 				}
 			    }
@@ -2310,13 +2310,13 @@
 			    if (step == 1) {
 				while (tmp <= final) {
 				    if (InterruptPending != nil) __interruptL(@line);
-				    (*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp));
+				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
 				    tmp++;
 				}
 			    } else {
 				while (tmp <= final) {
 				    if (InterruptPending != nil) __interruptL(@line);
-				    (*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp));
+				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
 				    tmp += step;
 				}
 			    }
@@ -2352,7 +2352,7 @@
 			 * arg is a compiled block with code -
 			 * directly call it without going through Block>>value
 			 */
-			(*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp));
+			(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
 		    } else {
 			if (__BlockInstPtr(aBlock)->b_bytecodes != nil) {
 			    /*
@@ -2363,18 +2363,18 @@
 			    {
 				OBJ idx;
 
-				idx = __MKSMALLINT(tmp);
+				idx = __mkSmallInteger(tmp);
 				__interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, &idx);
 			    }
 #else
-			    __interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, __MKSMALLINT(tmp));
+			    __interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, __mkSmallInteger(tmp));
 #endif
 
 			} else {
 			    /*
 			     * arg is something else - call it with #value
 			     */
-			    (*blockVal.ilc_func)(aBlock, @symbol(value:), nil, &blockVal, __MKSMALLINT(tmp));
+			    (*blockVal.ilc_func)(aBlock, @symbol(value:), nil, &blockVal, __mkSmallInteger(tmp));
 			}
 		    }
 		    tmp += step;
@@ -2390,7 +2390,7 @@
 			 * arg is a compiled block with code -
 			 * directly call it without going through Block>>value
 			 */
-			(*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp));
+			(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
 		    } else {
 			if (__BlockInstPtr(aBlock)->b_bytecodes != nil) {
 			    /*
@@ -2401,18 +2401,18 @@
 			    {
 				OBJ idx;
 
-				idx = __MKSMALLINT(tmp);
+				idx = __mkSmallInteger(tmp);
 				__interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, &idx);
 			    }
 #else
-			    __interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, __MKSMALLINT(tmp));
+			    __interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, __mkSmallInteger(tmp));
 #endif
 
 			} else {
 			    /*
 			     * arg is something else - call it with #value:
 			     */
-			    (*blockVal.ilc_func)(aBlock, @symbol(value:), nil, &blockVal, __MKSMALLINT(tmp));
+			    (*blockVal.ilc_func)(aBlock, @symbol(value:), nil, &blockVal, __mkSmallInteger(tmp));
 			}
 		    }
 		    tmp += step;
@@ -2433,7 +2433,7 @@
 		    (*blockVal.ilc_func)(aBlock,
 					 @symbol(value:),
 					 nil, &blockVal,
-					 __MKSMALLINT(tmp));
+					 __mkSmallInteger(tmp));
 		    tmp += step;
 		}
 	    } else {
@@ -2443,7 +2443,7 @@
 		    (*blockVal.ilc_func)(aBlock,
 					 @symbol(value:),
 					 nil, &blockVal,
-					 __MKSMALLINT(tmp));
+					 __mkSmallInteger(tmp));
 		    tmp += step;
 		}
 	    }
@@ -2477,7 +2477,7 @@
 	final = __intVal(stop);
 
 	if (__isBlockLike(aBlock)
-	 && (__BlockInstPtr(aBlock)->b_nargs == __MKSMALLINT(1))) {
+	 && (__BlockInstPtr(aBlock)->b_nargs == __mkSmallInteger(1))) {
 	    {
 		/*
 		 * specially tuned version for the most common case,
@@ -2517,9 +2517,9 @@
 			     * you are not supposed to program like this - I know what I do
 			     */
 # if TAG_INT==1
-			    INT t8 = (INT)(__MKSMALLINT(tmp+8));
-			    tmp = (INT)(__MKSMALLINT(tmp));
-			    final = (INT)(__MKSMALLINT(final));
+			    INT t8 = (INT)(__mkSmallInteger(tmp+8));
+			    tmp = (INT)(__mkSmallInteger(tmp));
+			    final = (INT)(__mkSmallInteger(final));
 # else
 			    INT t8 = tmp+8;
 # endif
@@ -2537,56 +2537,56 @@
 # if TAG_INT==1
 				    (*codeVal)(BLOCK_ARG, tmp);
 # else
-				    (*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp));
+				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
 # endif
 				    if (InterruptPending != nil) goto interrupted1;
 	continue1:
 # if TAG_INT==1
 				    (*codeVal)(BLOCK_ARG, tmp+(INT)(__MASKSMALLINT(1)) );
 # else
-				    (*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp+1));
+				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp+1));
 # endif
 				    if (InterruptPending != nil) goto interrupted2;
 	continue2:
 # if TAG_INT==1
 				    (*codeVal)(BLOCK_ARG, tmp+(INT)(__MASKSMALLINT(2)) );
 # else
-				    (*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp+2));
+				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp+2));
 # endif
 				    if (InterruptPending != nil) goto interrupted3;
 	continue3:
 # if TAG_INT==1
 				    (*codeVal)(BLOCK_ARG, tmp+(INT)(__MASKSMALLINT(3)) );
 # else
-				    (*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp+3));
+				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp+3));
 # endif
 				    if (InterruptPending != nil) goto interrupted4;
 	continue4:
 # if TAG_INT==1
 				    (*codeVal)(BLOCK_ARG, tmp+(INT)(__MASKSMALLINT(4)) );
 # else
-				    (*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp+4));
+				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp+4));
 # endif
 				    if (InterruptPending != nil) goto interrupted5;
 	continue5:
 # if TAG_INT==1
 				    (*codeVal)(BLOCK_ARG, tmp+(INT)(__MASKSMALLINT(5)) );
 # else
-				    (*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp+5));
+				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp+5));
 # endif
 				    if (InterruptPending != nil) goto interrupted6;
 	continue6:
 # if TAG_INT==1
 				    (*codeVal)(BLOCK_ARG, tmp+(INT)(__MASKSMALLINT(6)) );
 # else
-				    (*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp+6));
+				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp+6));
 # endif
 				    if (InterruptPending != nil) goto interrupted7;
 	continue7:
 # if TAG_INT==1
 				    (*codeVal)(BLOCK_ARG, tmp+(INT)(__MASKSMALLINT(7)) );
 # else
-				    (*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp+7));
+				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp+7));
 # endif
 
 # if TAG_INT==1
@@ -2602,7 +2602,7 @@
 				    (*codeVal)(BLOCK_ARG, tmp);
 				    tmp += (INT)(__MASKSMALLINT(1));
 # else
-				    (*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp));
+				    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
 				    tmp++;
 # endif
 				}
@@ -2637,7 +2637,7 @@
 #else
 			    while (tmp <= final) {
 				if (InterruptPending != nil) __interruptL(@line);
-				(*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp));
+				(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
 				tmp ++;
 			    }
 			    RETURN (self);
@@ -2651,7 +2651,7 @@
 			while (tmp <= final) {
 			    if (InterruptPending != nil) __interruptL(@line);
 			    if ((codeVal = __BlockInstPtr(aBlock)->b_code) == (OBJFUNC)nil) break;
-			    (*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp));
+			    (*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
 			    tmp ++;
 			}
 
@@ -2687,7 +2687,7 @@
 
 		    /* stay here, while no interrupts are pending ... */
 		    do {
-			(*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp));
+			(*codeVal)(BLOCK_ARG, __mkSmallInteger(tmp));
 			if (InterruptPending != nil) goto outerLoop;
 			tmp++;
 		    } while (tmp <= final);
@@ -2704,18 +2704,18 @@
 			{
 			    OBJ idx;
 
-			    idx = __MKSMALLINT(tmp);
+			    idx = __mkSmallInteger(tmp);
 			    __interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, &idx);
 			}
 #else
-			__interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, __MKSMALLINT(tmp));
+			__interpret(aBlock, 1, nil, IBLOCK_ARG, nil, nil, __mkSmallInteger(tmp));
 #endif
 
 		    } else {
 			/*
 			 * arg is something else - call it with #value:
 			 */
-			(*blockVal.ilc_func)(aBlock, @symbol(value:), nil, &blockVal, __MKSMALLINT(tmp));
+			(*blockVal.ilc_func)(aBlock, @symbol(value:), nil, &blockVal, __mkSmallInteger(tmp));
 		    }
 		}
 	    outerLoop: ;
@@ -2736,7 +2736,7 @@
 	    (*blockVal.ilc_func)(aBlock,
 					 @symbol(value:),
 					 nil, &blockVal,
-					 __MKSMALLINT(tmp));
+					 __mkSmallInteger(tmp));
 	    tmp++;
 	}
 	RETURN ( self );
@@ -2828,8 +2828,8 @@
 	div = mySelf / val;
 	mod = mySelf % val;
 
-	RETURN (__ARRAY_WITH2( __MKSMALLINT(div),
-			       __MKSMALLINT(mod)));
+	RETURN (__ARRAY_WITH2( __mkSmallInteger(div),
+			       __mkSmallInteger(mod)));
     }
 %}.
     ^ super divMod:aNumber
@@ -2872,7 +2872,7 @@
 		/* result should be positive */
 		if (orgSelfInt < 0) selfInt = -selfInt;
 	    }
-	    RETURN ( __MKSMALLINT(selfInt) );
+	    RETURN ( __mkSmallInteger(selfInt) );
 	}
     }
 %}
@@ -2942,7 +2942,7 @@
 	    /* keep the sign */
 	    sum %= _MAX_INT;
 	}
-	RETURN ( __MKSMALLINT(sum));
+	RETURN ( __mkSmallInteger(sum));
     }
 %}.
     self primitiveFailed
@@ -2974,7 +2974,7 @@
 	    /* keep the sign */
 	    diff %= _MAX_INT;
 	}
-	RETURN ( __MKSMALLINT(diff));
+	RETURN ( __mkSmallInteger(diff));
     }
 %}.
     self primitiveFailed
@@ -3037,9 +3037,9 @@
 
 	    product = (LONGLONG)myValue * (LONGLONG)otherValue;
 	    if (product < 0) {
-		RETURN ( __MKSMALLINT(-(INT)(-product & 0x3FFFFFFF)));
+		RETURN ( __mkSmallInteger(-(INT)(-product & 0x3FFFFFFF)));
 	    }
-	    RETURN ( __MKSMALLINT((INT)(product & 0x3FFFFFFF)));
+	    RETURN ( __mkSmallInteger((INT)(product & 0x3FFFFFFF)));
 	}
 #else /* no long-long */
 	negative = 1;
@@ -3114,9 +3114,9 @@
 	     && (pHH == 0)
 	     && ((pLL & LLMASK) == 0)) {
 		if (negative < 0) {
-		    RETURN ( __MKSMALLINT(- ((INT)pLL)) );
+		    RETURN ( __mkSmallInteger(- ((INT)pLL)) );
 		}
-		RETURN ( __MKSMALLINT((INT)pLL) );
+		RETURN ( __mkSmallInteger((INT)pLL) );
 	    }
 
 	    /*
@@ -3141,9 +3141,9 @@
 # endif /* ! (__GNUC__ && __mc68k__) */
 
 	if (negative < 0) {
-	    RETURN ( __MKSMALLINT(-(INT)(productLow & 0x3FFFFFFF)));
+	    RETURN ( __mkSmallInteger(-(INT)(productLow & 0x3FFFFFFF)));
 	}
-	RETURN ( __MKSMALLINT((INT)(productLow & 0x3FFFFFFF)));
+	RETURN ( __mkSmallInteger((INT)(productLow & 0x3FFFFFFF)));
 #endif /* ! USE_LONGLONG */
     }
 %}.
@@ -3555,12 +3555,12 @@
     INT val = __intVal(self);
 
     if (val < 0) {
-	RETURN ( __MKSMALLINT(-1) );
+	RETURN ( __mkSmallInteger(-1) );
     }
     if (val > 0) {
-	RETURN ( __MKSMALLINT(1) );
+	RETURN ( __mkSmallInteger(1) );
     }
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 %}.
     ^ super sign
 !
@@ -3584,5 +3584,5 @@
 !SmallInteger class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/SmallInteger.st,v 1.164 2005-07-08 14:00:04 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/SmallInteger.st,v 1.165 2005-07-08 17:15:02 cg Exp $'
 ! !
--- a/Smalltalk.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/Smalltalk.st	Fri Jul 08 19:15:03 2005 +0200
@@ -6387,18 +6387,17 @@
 
     "return the VMs major version number."
 %{
-    RETURN (__MKSMALLINT(4));
+    RETURN (__mkSmallInteger(4));
 %}.
     ^ 4
 
     "
      Smalltalk vmMajorVersionNr
     "
-
 ! !
 
 !Smalltalk class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/Smalltalk.st,v 1.674 2005-05-30 15:10:13 stefan Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/Smalltalk.st,v 1.675 2005-07-08 17:15:02 cg Exp $'
 ! !
--- a/String.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/String.st	Fri Jul 08 19:15:03 2005 +0200
@@ -719,7 +719,7 @@
     REGISTER unsigned char *cp;
     REGISTER unsigned byteValue;
 #ifndef FAST_MEMCHR
-    REGISTER int index;
+    REGISTER INT index;
     REGISTER int last;
 #endif
     OBJ cls;
@@ -734,19 +734,19 @@
 #ifdef FAST_MEMCHR
 	    cp = (unsigned char *) memchr(cp, byteValue, __stringSize(self));
 	    if (cp) {
-		RETURN ( __MKSMALLINT(cp - __stringVal(self) + 1) );
+		RETURN ( __mkSmallInteger(cp - __stringVal(self) + 1) );
 	    }
 #else
 	    last = __stringSize(self);
 	    for (index=1; index <= last; index++) {
-		if (*cp++ == byteValue) { RETURN ( __MKSMALLINT(index) ); }
+		if (*cp++ == byteValue) { RETURN ( __mkSmallInteger(index) ); }
 	   }
 #endif
 	}
-	RETURN ( __MKSMALLINT(0));
+	RETURN ( __mkSmallInteger(0));
     }
     /* with identity compares, only characters can be in myself */
-    RETURN ( __MKSMALLINT(0));
+    RETURN ( __mkSmallInteger(0));
 %}.
     ^ self primitiveFailed
 
@@ -878,7 +878,7 @@
 
     REGISTER unsigned char *cp;
     REGISTER unsigned byteValue;
-    REGISTER int index;
+    REGISTER INT index;
 #ifndef FAST_MEMCHR
     REGISTER int last;
 #endif
@@ -895,16 +895,16 @@
 #ifdef FAST_MEMCHR
 	    cp = (unsigned char *) memchr(cp, byteValue, __stringSize(self));
 	    if (cp) {
-		RETURN ( __MKSMALLINT(cp - __stringVal(self) + 1) );
+		RETURN ( __mkSmallInteger(cp - __stringVal(self) + 1) );
 	    }
 #else
 	    last = __stringSize(self);
 	    for (index=1; index <= last; index++) {
-		if (*cp++ == byteValue) { RETURN ( __MKSMALLINT(index) ); }
+		if (*cp++ == byteValue) { RETURN ( __mkSmallInteger(index) ); }
 	    }
 #endif
 	}
-	RETURN ( __MKSMALLINT(0));
+	RETURN ( __mkSmallInteger(0));
     }
 %}.
     ^ super indexOf:aCharacter
@@ -925,7 +925,7 @@
 
 %{  /* NOCONTEXT */
     REGISTER unsigned char *cp;
-    REGISTER int index;
+    REGISTER INT index;
     REGISTER unsigned byteValue;
     int len;
     OBJ cls;
@@ -946,17 +946,17 @@
 #ifdef FAST_MEMCHR
 		    cp = (unsigned char *) memchr(cp, byteValue, len+1-index);
 		    if (cp) {
-			RETURN ( __MKSMALLINT(cp - __stringVal(self) + 1) );
+			RETURN ( __mkSmallInteger(cp - __stringVal(self) + 1) );
 		    }
 #else
 		    for (; index <= len; index++) {
-			if (*cp++ == byteValue) { RETURN ( __MKSMALLINT(index) ); }
+			if (*cp++ == byteValue) { RETURN ( __mkSmallInteger(index) ); }
 		    }
 #endif
 		}
 	    }
 	}
-	RETURN ( __MKSMALLINT(0) );
+	RETURN ( __mkSmallInteger(0) );
     }
 %}.
     ^ super indexOf:aCharacter startingAt:start
@@ -980,7 +980,7 @@
 
     REGISTER unsigned char *ccp;
     REGISTER unsigned char *cp;
-    REGISTER int index;
+    REGISTER INT index;
     unsigned char *matchP;
     unsigned char c, min, max;
     int len;
@@ -1000,7 +1000,7 @@
 
 	    if (matchP[0] == 0) {
 		/* matchSet is empty */
-		RETURN ( __MKSMALLINT(0) );
+		RETURN ( __mkSmallInteger(0) );
 	    }
 
 	    if (matchP[1] == 0) {
@@ -1010,17 +1010,17 @@
 #ifdef FAST_MEMCHR
 		cp = (unsigned char *) memchr(cp, m, len-index+1);
 		if (cp) {
-		    RETURN ( __MKSMALLINT(cp - __stringVal(self) + 1) );
+		    RETURN ( __mkSmallInteger(cp - __stringVal(self) + 1) );
 		}
 #else
 		while (c = *cp++) {
 		    if (c == m) {
-			RETURN ( __MKSMALLINT(index) );
+			RETURN ( __mkSmallInteger(index) );
 		    }
 		    index++;
 		}
 #endif
-		RETURN ( __MKSMALLINT(0) );
+		RETURN ( __mkSmallInteger(0) );
 	    }
 
 	    if (matchP[2] == 0) {
@@ -1030,11 +1030,11 @@
 
 		while (c = *cp++) {
 		    if ((c == m1) || (c == m2)) {
-			RETURN ( __MKSMALLINT(index) );
+			RETURN ( __mkSmallInteger(index) );
 		    }
 		    index++;
 		}
-		RETURN ( __MKSMALLINT(0) );
+		RETURN ( __mkSmallInteger(0) );
 	    }
 
 	    min = max = matchP[0];
@@ -1049,14 +1049,14 @@
 		if ((c >= min) && (c <= max)) {
 		    for (ccp = matchP; *ccp ; ccp++) {
 			if (*ccp == c) {
-			    RETURN ( __MKSMALLINT(index) );
+			    RETURN ( __mkSmallInteger(index) );
 			}
 		    }
 		}
 		index++;
 	    }
 	}
-	RETURN ( __MKSMALLINT(0) );
+	RETURN ( __mkSmallInteger(0) );
     }
 %}.
     "/
@@ -1100,10 +1100,10 @@
     if (cp < cpEnd) {
 	while (cp < cpEnd) {
 	    if (*cp++ < ' ') {
-		RETURN ( __MKSMALLINT(cp - __stringVal(self)) );
+		RETURN ( __mkSmallInteger(cp - __stringVal(self)) );
 	    }
 	}
-	RETURN ( __MKSMALLINT(0) );
+	RETURN ( __mkSmallInteger(0) );
     }
 #endif
 %}.
@@ -1135,7 +1135,7 @@
 	index += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
     len = __stringSize(self);
     if (index > len) {
-	RETURN ( __MKSMALLINT(0) );
+	RETURN ( __mkSmallInteger(0) );
     }
     cp = __stringVal(self) + index - 1;
     while (c = *cp++) {
@@ -1144,10 +1144,10 @@
 #endif
 	if ((c != ' ') && (c != '\t') && (c != '\n')
 	 && (c != '\r') && (c != '\f')) {
-	    RETURN ( __MKSMALLINT(cp - __stringVal(self)) );
+	    RETURN ( __mkSmallInteger(cp - __stringVal(self)) );
 	}
     }
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 %}.
     ^ super indexOfNonSeparatorStartingAt:start
 
@@ -1175,7 +1175,7 @@
 	index += __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars));
     len = __stringSize(self);
     if (index > len) {
-	RETURN ( __MKSMALLINT(0) );
+	RETURN ( __mkSmallInteger(0) );
     }
     cp = __stringVal(self) + index - 1;
     while (c = *cp++) {
@@ -1184,10 +1184,10 @@
 #endif
 	if ((c == ' ') || (c == '\t') || (c == '\n')
 	 || (c == '\r') || (c == '\f')) {
-	    RETURN ( __MKSMALLINT(cp - __stringVal(self)) );
+	    RETURN ( __mkSmallInteger(cp - __stringVal(self)) );
 	}
     }
-    RETURN ( __MKSMALLINT(0) );
+    RETURN ( __mkSmallInteger(0) );
 %}.
     ^ super indexOfSeparatorStartingAt:start
 
@@ -1205,7 +1205,7 @@
 
     REGISTER unsigned char *cp;
     REGISTER unsigned byteValue;
-    REGISTER int count, limit;
+    REGISTER INT count, limit;
     OBJ cls;
 
     if (__isCharacter(aCharacter)) {
@@ -1224,7 +1224,7 @@
 		if (*cp++ == byteValue) count++;
 	    }
 	}
-	RETURN ( __MKSMALLINT(count) );
+	RETURN ( __mkSmallInteger(count) );
     }
 %}.
     ^ super occurrencesOf:aCharacter
@@ -1549,12 +1549,12 @@
 #endif
 
 	    if (cmp > 0) {
-		RETURN ( __MKSMALLINT(1) );
+		RETURN ( __mkSmallInteger(1) );
 	    }
 	    if (cmp < 0) {
-		RETURN ( __MKSMALLINT(-1) );
+		RETURN ( __mkSmallInteger(-1) );
 	    }
-	    RETURN ( __MKSMALLINT(0) );
+	    RETURN ( __mkSmallInteger(0) );
 	}
     }
 %}.
@@ -2686,8 +2686,8 @@
 	    RETURN(self);
 	}
 
-	startIndex = __MKSMALLINT(cp - cp0 + 1);
-	endIndex = __MKSMALLINT(ep - cp0 + 1);
+	startIndex = __mkSmallInteger(cp - cp0 + 1);
+	endIndex = __mkSmallInteger(ep - cp0 + 1);
     }
 %}.
     startIndex == 0 ifTrue:[^ super withoutSeparators].
@@ -2756,8 +2756,8 @@
 	    RETURN(self);
 	}
 
-	startIndex = __MKSMALLINT(cp - cp0 + 1);
-	endIndex = __MKSMALLINT(ep - cp0 + 1);
+	startIndex = __mkSmallInteger(cp - cp0 + 1);
+	endIndex = __mkSmallInteger(ep - cp0 + 1);
     }
 %}.
     startIndex == 0 ifTrue:[^ super withoutSpaces].
@@ -2944,9 +2944,9 @@
 
     cls = __qClass(slf);
     if (cls == String) {
-	RETURN ( __MKSMALLINT(__stringSize(slf)) );
+	RETURN ( __mkSmallInteger(__stringSize(slf)) );
     }
-    RETURN ( __MKSMALLINT(__stringSize(slf)
+    RETURN ( __mkSmallInteger(__stringSize(slf)
 			  - __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars))));
 %}.
     ^ super basicSize - 1
@@ -3029,9 +3029,9 @@
     slf = self;
     cls = __qClass(slf);
     if (cls == String) {
-	RETURN ( __MKSMALLINT(__stringSize(slf)) );
+	RETURN ( __mkSmallInteger(__stringSize(slf)) );
     }
-    RETURN ( __MKSMALLINT(__stringSize(slf)
+    RETURN ( __mkSmallInteger(__stringSize(slf)
 			 - __OBJS2BYTES__(__intVal(__ClassInstPtr(cls)->c_ninstvars))));
 %}.
     ^ self basicSize
@@ -3162,7 +3162,8 @@
     int l1, l2;
     REGISTER int sz;
     unsigned char *s1, *s2;
-    int v1, v2, v3, m;
+    int v1, v2, v3;
+    INT m;
     REGISTER unsigned short *dp;
     REGISTER int rowDelta;
     REGISTER int j;
@@ -3391,5 +3392,5 @@
 !String class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/String.st,v 1.214 2005-07-05 14:07:10 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/String.st,v 1.215 2005-07-08 17:15:03 cg Exp $'
 ! !
--- a/Symbol.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/Symbol.st	Fri Jul 08 19:15:03 2005 +0200
@@ -313,7 +313,7 @@
 
 %{  /* NOCONTEXT */
 
-    REGISTER unsigned int g, val;
+    REGISTER unsigned INT g, val;
     REGISTER unsigned char *cp, *ce;
     int l;
 
@@ -372,7 +372,7 @@
 	} else {
 	    val = __MAKE_HASH__(val);
 	}
-	RETURN ( __MKSMALLINT(val) );
+	RETURN ( __mkSmallInteger(val) );
      }
 %}.
      ^ super identityHash
@@ -734,5 +734,5 @@
 !Symbol class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/Symbol.st,v 1.79 2005-04-08 22:48:37 stefan Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/Symbol.st,v 1.80 2005-07-08 17:15:03 cg Exp $'
 ! !
--- a/UninterpretedBytes.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/UninterpretedBytes.st	Fri Jul 08 19:15:03 2005 +0200
@@ -956,7 +956,7 @@
 #endif
                 }
 #if __POINTER_SIZE__ == 8
-                RETURN (__MKSMALLINT(iVal));
+                RETURN (__mkSmallInteger(iVal));
 #else
                 RETURN (__MKUINT(iVal));
 #endif
@@ -1144,7 +1144,7 @@
 		    int iVal = ((int *)cp)[0];
 
 # if __POINTER_SIZE__ == 8
-		    RETURN (__MKSMALLINT(iVal));
+		    RETURN (__mkSmallInteger(iVal));
 # else
 		    RETURN (__MKINT(iVal));
 # endif
@@ -1425,7 +1425,7 @@
 #endif
                 }
 #if __POINTER_SIZE__ == 8
-                RETURN (__MKSMALLINT(iVal));
+                RETURN (__mkSmallInteger(iVal));
 #else
                 RETURN (__MKINT(iVal));
 #endif
@@ -2213,5 +2213,5 @@
 !UninterpretedBytes class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/UninterpretedBytes.st,v 1.56 2005-07-07 15:01:52 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/UninterpretedBytes.st,v 1.57 2005-07-08 17:15:03 cg Exp $'
 ! !
--- a/UnixOperatingSystem.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/UnixOperatingSystem.st	Fri Jul 08 19:15:03 2005 +0200
@@ -1548,229 +1548,229 @@
 %{  /* NOCONTEXT */
 #ifdef SIGABRT
     if (signalName == @symbol(SIGABRT)) {
-	RETURN ( __MKSMALLINT(SIGABRT) );
+	RETURN ( __mkSmallInteger(SIGABRT) );
     }
 #endif
 #ifdef SIGALRM
     if (signalName == @symbol(SIGALRM)) {
-	RETURN ( __MKSMALLINT(SIGALRM) );
+	RETURN ( __mkSmallInteger(SIGALRM) );
     }
 #endif
 #ifdef SIGBREAK
     if (signalName == @symbol(SIGBREAK)) {
-	RETURN ( __MKSMALLINT(SIGBREAK) );
+	RETURN ( __mkSmallInteger(SIGBREAK) );
     }
 #endif
 #ifdef SIGBUS
     if (signalName == @symbol(SIGBUS)) {
-	RETURN ( __MKSMALLINT(SIGBUS) );
+	RETURN ( __mkSmallInteger(SIGBUS) );
     }
 #endif
 #ifdef SIGCHLD
     if ((signalName == @symbol(SIGCHLD))
      || (signalName == @symbol(SIGCLD)) ) {
-	RETURN ( __MKSMALLINT(SIGCHLD) );
+	RETURN ( __mkSmallInteger(SIGCHLD) );
     }
 #else
 # if defined(SIGCLD)
     if ((signalName == @symbol(SIGCHLD))
      || (signalName == @symbol(SIGCLD)) ) {
-	RETURN ( __MKSMALLINT(SIGCLD) );
+	RETURN ( __mkSmallInteger(SIGCLD) );
     }
 # endif
 #endif
 #ifdef SIGCONT
     if (signalName == @symbol(SIGCONT)) {
-	RETURN ( __MKSMALLINT(SIGCONT) );
+	RETURN ( __mkSmallInteger(SIGCONT) );
     }
 #endif
 #ifdef SIGDANGER
     if (signalName == @symbol(SIGDANGER)) {
-	RETURN ( __MKSMALLINT(SIGDANGER) );
+	RETURN ( __mkSmallInteger(SIGDANGER) );
     }
 #endif
 #ifdef SIGEMT
     if (signalName == @symbol(SIGEMT)) {
-	RETURN ( __MKSMALLINT(SIGEMT) );
+	RETURN ( __mkSmallInteger(SIGEMT) );
     }
 #endif
 #ifdef SIGFPE
     if (signalName == @symbol(SIGFPE)) {
-	RETURN ( __MKSMALLINT(SIGFPE) );
+	RETURN ( __mkSmallInteger(SIGFPE) );
     }
 #endif
 #ifdef SIGGRANT
     if (signalName == @symbol(SIGGRANT)) {
-	RETURN ( __MKSMALLINT(SIGGRANT) );
+	RETURN ( __mkSmallInteger(SIGGRANT) );
     }
 #endif
 #ifdef SIGHUP
     if (signalName == @symbol(SIGHUP)) {
-	RETURN ( __MKSMALLINT(SIGHUP) );
+	RETURN ( __mkSmallInteger(SIGHUP) );
     }
 #endif
 #ifdef SIGILL
     if (signalName == @symbol(SIGILL)) {
-	RETURN ( __MKSMALLINT(SIGILL) );
+	RETURN ( __mkSmallInteger(SIGILL) );
     }
 #endif
 #ifdef SIGINT
     if (signalName == @symbol(SIGINT)) {
-	RETURN ( __MKSMALLINT(SIGINT) );
+	RETURN ( __mkSmallInteger(SIGINT) );
     }
 #endif
 #ifdef SIGIO
     if (signalName == @symbol(SIGIO)) {
-	RETURN ( __MKSMALLINT(SIGIO) );
+	RETURN ( __mkSmallInteger(SIGIO) );
     }
 #endif
 #ifdef SIGIOT
     if (signalName == @symbol(SIGIOT)) {
-	RETURN ( __MKSMALLINT(SIGIOT) );
+	RETURN ( __mkSmallInteger(SIGIOT) );
     }
 #endif
 #ifdef SIGKILL
     if (signalName == @symbol(SIGKILL)) {
-	RETURN ( __MKSMALLINT(SIGKILL) );
+	RETURN ( __mkSmallInteger(SIGKILL) );
     }
 #endif
 #ifdef SIGLOST
     if (signalName == @symbol(SIGLOST)) {
-	RETURN ( __MKSMALLINT(SIGLOST) );
+	RETURN ( __mkSmallInteger(SIGLOST) );
     }
 #endif
 #ifdef SIGMIGRATE
     if (signalName == @symbol(SIGMIGRATE)) {
-	RETURN ( __MKSMALLINT(SIGMIGRATE) );
+	RETURN ( __mkSmallInteger(SIGMIGRATE) );
     }
 #endif
 #ifdef SIGMSG
     if (signalName == @symbol(SIGMSG)) {
-	RETURN ( __MKSMALLINT(SIGMSG) );
+	RETURN ( __mkSmallInteger(SIGMSG) );
     }
 #endif
 #ifdef SIGPIPE
     if (signalName == @symbol(SIGPIPE)) {
-	RETURN ( __MKSMALLINT(SIGPIPE) );
+	RETURN ( __mkSmallInteger(SIGPIPE) );
     }
 #endif
 #ifdef SIGPOLL
     if (signalName == @symbol(SIGPOLL)) {
-	RETURN ( __MKSMALLINT(SIGPOLL) );
+	RETURN ( __mkSmallInteger(SIGPOLL) );
     }
 #endif
 #ifdef SIGPRE
     if (signalName == @symbol(SIGPRE)) {
-	RETURN ( __MKSMALLINT(SIGPRE) );
+	RETURN ( __mkSmallInteger(SIGPRE) );
     }
 #endif
 #ifdef SIGPROF
     if (signalName == @symbol(SIGPROF)) {
-	RETURN ( __MKSMALLINT(SIGPROF) );
+	RETURN ( __mkSmallInteger(SIGPROF) );
     }
 #endif
 #ifdef SIGPWR
     if (signalName == @symbol(SIGPWR)) {
-	RETURN ( __MKSMALLINT(SIGPWR) );
+	RETURN ( __mkSmallInteger(SIGPWR) );
     }
 #endif
 #ifdef SIGQUIT
     if (signalName == @symbol(SIGQUIT)) {
-	RETURN ( __MKSMALLINT(SIGQUIT) );
+	RETURN ( __mkSmallInteger(SIGQUIT) );
     }
 #endif
 #ifdef SIGRETRACT
     if (signalName == @symbol(SIGRETRACT)) {
-	RETURN ( __MKSMALLINT(SIGRETRACT) );
+	RETURN ( __mkSmallInteger(SIGRETRACT) );
     }
 #endif
 #ifdef SIGSAK
     if (signalName == @symbol(SIGSAK)) {
-	RETURN ( __MKSMALLINT(SIGSAK) );
+	RETURN ( __mkSmallInteger(SIGSAK) );
     }
 #endif
 #ifdef SIGSEGV
     if (signalName == @symbol(SIGSEGV)) {
-	RETURN ( __MKSMALLINT(SIGSEGV) );
+	RETURN ( __mkSmallInteger(SIGSEGV) );
     }
 #endif
 #ifdef SIGSOUND
     if (signalName == @symbol(SIGSOUND)) {
-	RETURN ( __MKSMALLINT(SIGSOUND) );
+	RETURN ( __mkSmallInteger(SIGSOUND) );
     }
 #endif
 #ifdef SIGSTOP
     if (signalName == @symbol(SIGSTOP)) {
-	RETURN ( __MKSMALLINT(SIGSTOP) );
+	RETURN ( __mkSmallInteger(SIGSTOP) );
     }
 #endif
 #ifdef SIGSYS
     if (signalName == @symbol(SIGSYS)) {
-	RETURN ( __MKSMALLINT(SIGSYS) );
+	RETURN ( __mkSmallInteger(SIGSYS) );
     }
 #endif
 #ifdef SIGTERM
     if (signalName == @symbol(SIGTERM)) {
-	RETURN ( __MKSMALLINT(SIGTERM) );
+	RETURN ( __mkSmallInteger(SIGTERM) );
     }
 #endif
 #ifdef SIGTRAP
     if (signalName == @symbol(SIGTRAP)) {
-	RETURN ( __MKSMALLINT(SIGTRAP) );
+	RETURN ( __mkSmallInteger(SIGTRAP) );
     }
 #endif
 #ifdef SIGTSTP
     if (signalName == @symbol(SIGTSTP)) {
-	RETURN ( __MKSMALLINT(SIGTSTP) );
+	RETURN ( __mkSmallInteger(SIGTSTP) );
     }
 #endif
 #ifdef SIGTTIN
     if (signalName == @symbol(SIGTTIN)) {
-	RETURN ( __MKSMALLINT(SIGTTIN) );
+	RETURN ( __mkSmallInteger(SIGTTIN) );
     }
 #endif
 #ifdef SIGTTOU
     if (signalName == @symbol(SIGTTOU)) {
-	RETURN ( __MKSMALLINT(SIGTTOU) );
+	RETURN ( __mkSmallInteger(SIGTTOU) );
     }
 #endif
 #ifdef SIGURG
     if (signalName == @symbol(SIGURG)) {
-	RETURN ( __MKSMALLINT(SIGURG) );
+	RETURN ( __mkSmallInteger(SIGURG) );
     }
 #endif
 #ifdef SIGUSR1
     if (signalName == @symbol(SIGUSR1)) {
-	RETURN ( __MKSMALLINT(SIGUSR1) );
+	RETURN ( __mkSmallInteger(SIGUSR1) );
     }
 #endif
 #ifdef SIGUSR2
     if (signalName == @symbol(SIGUSR2)) {
-	RETURN ( __MKSMALLINT(SIGUSR2) );
+	RETURN ( __mkSmallInteger(SIGUSR2) );
     }
 #endif
 #ifdef SIGVTALRM
     if (signalName == @symbol(SIGVTALRM)) {
-	RETURN ( __MKSMALLINT(SIGVTALRM) );
+	RETURN ( __mkSmallInteger(SIGVTALRM) );
     }
 #endif
 #ifdef SIGWINCH
     if (signalName == @symbol(SIGWINCH)) {
-	RETURN ( __MKSMALLINT(SIGWINCH) );
+	RETURN ( __mkSmallInteger(SIGWINCH) );
     }
 #endif
 #ifdef SIGXCPU
     if (signalName == @symbol(SIGXCPU)) {
-	RETURN ( __MKSMALLINT(SIGXCPU) );
+	RETURN ( __mkSmallInteger(SIGXCPU) );
     }
 #endif
 #ifdef SIGXFSZ
     if (signalName == @symbol(SIGXFSZ)) {
-	RETURN ( __MKSMALLINT(SIGXFSZ) );
-    }
-#endif
-
-    RETURN ( __MKSMALLINT(0) );
+	RETURN ( __mkSmallInteger(SIGXFSZ) );
+    }
+#endif
+
+    RETURN ( __mkSmallInteger(0) );
 %}
     "
      OperatingSystem signalNamed:#SIGABRT
@@ -1792,7 +1792,7 @@
 
 %{  /* NOCONTEXT */
 
-     RETURN ( __MKSMALLINT(errno) );
+     RETURN ( __mkSmallInteger(errno) );
 %}
      "
       OperatingSystem currentErrorNumber
@@ -2349,229 +2349,229 @@
      */
 #ifdef EPERM
     if (sym == @symbol(EPERM)) {
-	RETURN ( __MKSMALLINT(EPERM) );
+	RETURN ( __mkSmallInteger(EPERM) );
     }
 #endif
 
 #ifdef ENOENT
     if (sym == @symbol(ENOENT)) {
-	RETURN ( __MKSMALLINT(ENOENT) );
+	RETURN ( __mkSmallInteger(ENOENT) );
     }
 #endif
 
 #ifdef ESRCH
     if (sym == @symbol(ESRCH)) {
-	RETURN ( __MKSMALLINT(ESRCH) );
+	RETURN ( __mkSmallInteger(ESRCH) );
     }
 #endif
 
 #ifdef EINTR
     if (sym == @symbol(EINTR)) {
-	RETURN ( __MKSMALLINT(EINTR) );
+	RETURN ( __mkSmallInteger(EINTR) );
     }
 #endif
 
 #ifdef EIO
     if (sym == @symbol(EIO)) {
-	RETURN ( __MKSMALLINT(EIO) );
+	RETURN ( __mkSmallInteger(EIO) );
     }
 #endif
 
 #ifdef ENXIO
     if (sym == @symbol(ENXIO)) {
-	RETURN ( __MKSMALLINT(ENXIO) );
+	RETURN ( __mkSmallInteger(ENXIO) );
     }
 #endif
 
 #ifdef E2BIG
     if (sym == @symbol(E2BIG)) {
-	RETURN ( __MKSMALLINT(E2BIG) );
+	RETURN ( __mkSmallInteger(E2BIG) );
     }
 #endif
 
 #ifdef ENOEXEC
     if (sym == @symbol(ENOEXEC)) {
-	RETURN ( __MKSMALLINT(ENOEXEC) );
+	RETURN ( __mkSmallInteger(ENOEXEC) );
     }
 #endif
 
 #ifdef EBADF
     if (sym == @symbol(EBADF)) {
-	RETURN ( __MKSMALLINT(EBADF) );
+	RETURN ( __mkSmallInteger(EBADF) );
     }
 #endif
 
 #ifdef ECHILD
     if (sym == @symbol(ECHILD)) {
-	RETURN ( __MKSMALLINT(ECHILD) );
+	RETURN ( __mkSmallInteger(ECHILD) );
     }
 #endif
 
 #if defined(EAGAIN)
     if (sym == @symbol(EAGAIN)) {
-	RETURN ( __MKSMALLINT(EAGAIN) );
+	RETURN ( __mkSmallInteger(EAGAIN) );
     }
 #endif
 
 #ifdef ENOMEM
     if (sym == @symbol(ENOMEM)) {
-	RETURN ( __MKSMALLINT(ENOMEM) );
+	RETURN ( __mkSmallInteger(ENOMEM) );
     }
 #endif
 
 #ifdef EACCES
     if (sym == @symbol(EACCES)) {
-	RETURN ( __MKSMALLINT(EACCES) );
+	RETURN ( __mkSmallInteger(EACCES) );
     }
 #endif
 
 #ifdef EFAULT
     if (sym == @symbol(EFAULT)) {
-	RETURN ( __MKSMALLINT(EFAULT) );
+	RETURN ( __mkSmallInteger(EFAULT) );
     }
 #endif
 
 #ifdef EBUSY
     if (sym == @symbol(EBUSY)) {
-	RETURN ( __MKSMALLINT(EBUSY) );
+	RETURN ( __mkSmallInteger(EBUSY) );
     }
 #endif
 
 #ifdef EXDEV
     if (sym == @symbol(EXDEV)) {
-	RETURN ( __MKSMALLINT(EXDEV) );
+	RETURN ( __mkSmallInteger(EXDEV) );
     }
 #endif
 
 #ifdef ENODEV
     if (sym == @symbol(ENODEV)) {
-	RETURN ( __MKSMALLINT(ENODEV) );
+	RETURN ( __mkSmallInteger(ENODEV) );
     }
 #endif
 
 #ifdef ENOTDIR
     if (sym == @symbol(ENOTDIR)) {
-	RETURN ( __MKSMALLINT(ENOTDIR) );
+	RETURN ( __mkSmallInteger(ENOTDIR) );
     }
 #endif
 
 #ifdef EISDIR
     if (sym == @symbol(EISDIR)) {
-	RETURN ( __MKSMALLINT(EISDIR) );
+	RETURN ( __mkSmallInteger(EISDIR) );
     }
 #endif
 
 #ifdef EINVAL
     if (sym == @symbol(EINVAL)) {
-	RETURN ( __MKSMALLINT(EINVAL) );
+	RETURN ( __mkSmallInteger(EINVAL) );
     }
 #endif
 
 #ifdef ENFILE
     if (sym == @symbol(ENFILE)) {
-	RETURN ( __MKSMALLINT(ENFILE) );
+	RETURN ( __mkSmallInteger(ENFILE) );
     }
 #endif
 
 #ifdef EMFILE
     if (sym == @symbol(EMFILE)) {
-	RETURN ( __MKSMALLINT(EMFILE) );
+	RETURN ( __mkSmallInteger(EMFILE) );
     }
 #endif
 
 #ifdef ENOTTY
     if (sym == @symbol(ENOTTY)) {
-	RETURN ( __MKSMALLINT(ENOTTY) );
+	RETURN ( __mkSmallInteger(ENOTTY) );
     }
 #endif
 
 #ifdef EFBIG
     if (sym == @symbol(EFBIG)) {
-	RETURN ( __MKSMALLINT(EFBIG) );
+	RETURN ( __mkSmallInteger(EFBIG) );
     }
 #endif
 
 #ifdef ENOSPC
     if (sym == @symbol(ENOSPC)) {
-	RETURN ( __MKSMALLINT(ENOSPC) );
+	RETURN ( __mkSmallInteger(ENOSPC) );
     }
 #endif
 
 #ifdef ESPIPE
     if (sym == @symbol(ESPIPE)) {
-	RETURN ( __MKSMALLINT(ESPIPE) );
+	RETURN ( __mkSmallInteger(ESPIPE) );
     }
 #endif
 
 #ifdef EROFS
     if (sym == @symbol(EROFS)) {
-	RETURN ( __MKSMALLINT(EROFS) );
+	RETURN ( __mkSmallInteger(EROFS) );
     }
 #endif
 
 #ifdef EMLINK
     if (sym == @symbol(EMLINK)) {
-	RETURN ( __MKSMALLINT(EMLINK) );
+	RETURN ( __mkSmallInteger(EMLINK) );
     }
 #endif
 
 #ifdef EPIPE
     if (sym == @symbol(EPIPE)) {
-	RETURN ( __MKSMALLINT(EPIPE) );
+	RETURN ( __mkSmallInteger(EPIPE) );
     }
 #endif
 
 #ifdef EDOM
     if (sym == @symbol(EDOM)) {
-	RETURN ( __MKSMALLINT(EDOM) );
+	RETURN ( __mkSmallInteger(EDOM) );
     }
 #endif
 
 #ifdef ERANGE
     if (sym == @symbol(ERANGE)) {
-	RETURN ( __MKSMALLINT(ERANGE) );
+	RETURN ( __mkSmallInteger(ERANGE) );
     }
 #endif
 
 #ifdef EDEADLK
     if (sym == @symbol(EDEADLK)) {
-	RETURN ( __MKSMALLINT(EDEADLK) );
+	RETURN ( __mkSmallInteger(EDEADLK) );
     }
 #endif
 
 #ifdef ENAMETOOLONG
     if (sym == @symbol(ENAMETOOLONG)) {
-	RETURN ( __MKSMALLINT(ENAMETOOLONG) );
+	RETURN ( __mkSmallInteger(ENAMETOOLONG) );
     }
 #endif
 
 #ifdef ENOLCK
     if (sym == @symbol(ENOLCK)) {
-	RETURN ( __MKSMALLINT(ENOLCK) );
+	RETURN ( __mkSmallInteger(ENOLCK) );
     }
 #endif
 
 #ifdef ENOSYS
     if (sym == @symbol(ENOSYS)) {
-	RETURN ( __MKSMALLINT(ENOSYS) );
+	RETURN ( __mkSmallInteger(ENOSYS) );
     }
 #endif
 
 #ifdef ENOTEMPTY
     if (sym == @symbol(ENOTEMPTY)) {
-	RETURN ( __MKSMALLINT(ENOTEMPTY) );
+	RETURN ( __mkSmallInteger(ENOTEMPTY) );
     }
 #endif
 
 #ifdef EEXIST
     if (sym == @symbol(EEXIST)) {
-	RETURN ( __MKSMALLINT(EEXIST) );
+	RETURN ( __mkSmallInteger(EEXIST) );
     }
 #endif
 
 #ifdef EILSEQ
     if (sym == @symbol(EILSEQ)) {
-	RETURN ( __MKSMALLINT(EILSEQ) );
+	RETURN ( __mkSmallInteger(EILSEQ) );
     }
 #endif
 
@@ -2580,13 +2580,13 @@
      */
 #ifdef ENOTBLK
     if (sym == @symbol(ENOTBLK)) {
-	RETURN ( __MKSMALLINT(ENOTBLK) );
+	RETURN ( __mkSmallInteger(ENOTBLK) );
     }
 #endif
 
 #ifdef ETXTBSY
     if (sym == @symbol(ETXTBSY)) {
-	RETURN ( __MKSMALLINT(ETXTBSY) );
+	RETURN ( __mkSmallInteger(ETXTBSY) );
     }
 #endif
 
@@ -2595,25 +2595,25 @@
      */
 #ifdef EWOULDBLOCK
     if (sym == @symbol(EWOULDBLOCK)) {
-	RETURN ( __MKSMALLINT(EWOULDBLOCK) );
+	RETURN ( __mkSmallInteger(EWOULDBLOCK) );
     }
 #endif
 
 #ifdef EOVERFLOW
     if (sym == @symbol(EOVERFLOW)) {
-	RETURN ( __MKSMALLINT(EOVERFLOW) );
+	RETURN ( __mkSmallInteger(EOVERFLOW) );
     }
 #endif
 
 #ifdef ENOMSG
     if (sym == @symbol(ENOMSG)) {
-	RETURN ( __MKSMALLINT(ENOMSG) );
+	RETURN ( __mkSmallInteger(ENOMSG) );
     }
 #endif
 
 #ifdef ELOOP
     if (sym == @symbol(ELOOP)) {
-	RETURN ( __MKSMALLINT(ELOOP) );
+	RETURN ( __mkSmallInteger(ELOOP) );
     }
 #endif
 
@@ -2622,31 +2622,31 @@
      */
 #ifdef ETIME
     if (sym == @symbol(ETIME)) {
-	RETURN ( __MKSMALLINT(ETIME) );
+	RETURN ( __mkSmallInteger(ETIME) );
     }
 #endif
 
 #ifdef ENOSR
     if (sym == @symbol(ENOSR)) {
-	RETURN ( __MKSMALLINT(ENOSR) );
+	RETURN ( __mkSmallInteger(ENOSR) );
     }
 #endif
 
 #ifdef ENOSTR
     if (sym == @symbol(ENOSTR)) {
-	RETURN ( __MKSMALLINT(ENOSTR) );
+	RETURN ( __mkSmallInteger(ENOSTR) );
     }
 #endif
 
 #ifdef ECOMM
     if (sym == @symbol(ECOMM)) {
-	RETURN ( __MKSMALLINT(ECOMM) );
+	RETURN ( __mkSmallInteger(ECOMM) );
     }
 #endif
 
 #ifdef EPROTO
     if (sym == @symbol(EPROTO)) {
-	RETURN ( __MKSMALLINT(EPROTO) );
+	RETURN ( __mkSmallInteger(EPROTO) );
     }
 #endif
 
@@ -2655,13 +2655,13 @@
      */
 #ifdef ESTALE
     if (sym == @symbol(ESTALE)) {
-	RETURN ( __MKSMALLINT(ESTALE) );
+	RETURN ( __mkSmallInteger(ESTALE) );
     }
 #endif
 
 #ifdef EREMOTE
     if (sym == @symbol(EREMOTE)) {
-	RETURN ( __MKSMALLINT(EREMOTE) );
+	RETURN ( __mkSmallInteger(EREMOTE) );
     }
 #endif
 
@@ -2670,178 +2670,178 @@
      */
 #ifdef EINPROGRESS
     if (sym == @symbol(EINPROGRESS)) {
-	RETURN ( __MKSMALLINT(EINPROGRESS) );
+	RETURN ( __mkSmallInteger(EINPROGRESS) );
     }
 #endif
 
 #ifdef EALREADY
     if (sym == @symbol(EALREADY)) {
-	RETURN ( __MKSMALLINT(EALREADY) );
+	RETURN ( __mkSmallInteger(EALREADY) );
     }
 #endif
 
 #ifdef ENOTSOCK
     if (sym == @symbol(ENOTSOCK)) {
-	RETURN ( __MKSMALLINT(ENOTSOCK) );
+	RETURN ( __mkSmallInteger(ENOTSOCK) );
     }
 #endif
 
 #ifdef EDESTADDRREQ
     if (sym == @symbol(EDESTADDRREQ)) {
-	RETURN ( __MKSMALLINT(EDESTADDRREQ) );
+	RETURN ( __mkSmallInteger(EDESTADDRREQ) );
     }
 #endif
 
 #ifdef EMSGSIZE
     if (sym == @symbol(EMSGSIZE)) {
-	RETURN ( __MKSMALLINT(EMSGSIZE) );
+	RETURN ( __mkSmallInteger(EMSGSIZE) );
     }
 #endif
 
 #ifdef EPROTOTYPE
     if (sym == @symbol(EPROTOTYPE)) {
-	RETURN ( __MKSMALLINT(EPROTOTYPE) );
+	RETURN ( __mkSmallInteger(EPROTOTYPE) );
     }
 #endif
 
 #ifdef ENOPROTOOPT
     if (sym == @symbol(ENOPROTOOPT)) {
-	RETURN ( __MKSMALLINT(ENOPROTOOPT) );
+	RETURN ( __mkSmallInteger(ENOPROTOOPT) );
     }
 #endif
 
 #ifdef EPROTONOSUPPORT
     if (sym == @symbol(EPROTONOSUPPORT)) {
-	RETURN ( __MKSMALLINT(EPROTONOSUPPORT) );
+	RETURN ( __mkSmallInteger(EPROTONOSUPPORT) );
     }
 #endif
 
 #ifdef ESOCKTNOSUPPORT
     if (sym == @symbol(ESOCKTNOSUPPORT)) {
-	RETURN ( __MKSMALLINT(ESOCKTNOSUPPORT) );
+	RETURN ( __mkSmallInteger(ESOCKTNOSUPPORT) );
     }
 #endif
 
 #ifdef EOPNOTSUPP
     if (sym == @symbol(EOPNOTSUPP)) {
-	RETURN ( __MKSMALLINT(EOPNOTSUPP) );
+	RETURN ( __mkSmallInteger(EOPNOTSUPP) );
     }
 #endif
 
 #ifdef EPFNOSUPPORT
     if (sym == @symbol(EPFNOSUPPORT)) {
-	RETURN ( __MKSMALLINT(EPFNOSUPPORT) );
+	RETURN ( __mkSmallInteger(EPFNOSUPPORT) );
     }
 #endif
 
 #ifdef EAFNOSUPPORT
     if (sym == @symbol(EAFNOSUPPORT)) {
-	RETURN ( __MKSMALLINT(EAFNOSUPPORT) );
+	RETURN ( __mkSmallInteger(EAFNOSUPPORT) );
     }
 #endif
 
 #ifdef EADDRINUSE
     if (sym == @symbol(EADDRINUSE)) {
-	RETURN ( __MKSMALLINT(EADDRINUSE) );
+	RETURN ( __mkSmallInteger(EADDRINUSE) );
     }
 #endif
 
 #ifdef EADDRNOTAVAIL
     if (sym == @symbol(EADDRNOTAVAIL)) {
-	RETURN ( __MKSMALLINT(EADDRNOTAVAIL) );
+	RETURN ( __mkSmallInteger(EADDRNOTAVAIL) );
     }
 #endif
 
 #ifdef ETIMEDOUT
     if (sym == @symbol(ETIMEDOUT)) {
-	RETURN ( __MKSMALLINT(ETIMEDOUT) );
+	RETURN ( __mkSmallInteger(ETIMEDOUT) );
     }
 #endif
 
 #ifdef ECONNREFUSED
     if (sym == @symbol(ECONNREFUSED)) {
-	RETURN ( __MKSMALLINT(ECONNREFUSED) );
+	RETURN ( __mkSmallInteger(ECONNREFUSED) );
     }
 #endif
 
 #ifdef ENETDOWN
     if (sym == @symbol(ENETDOWN)) {
-	RETURN ( __MKSMALLINT(ENETDOWN) );
+	RETURN ( __mkSmallInteger(ENETDOWN) );
     }
 #endif
 
 #ifdef ENETUNREACH
     if (sym == @symbol(ENETUNREACH)) {
-	RETURN ( __MKSMALLINT(ENETUNREACH) );
+	RETURN ( __mkSmallInteger(ENETUNREACH) );
     }
 #endif
 
 #ifdef ENETRESET
     if (sym == @symbol(ENETRESET)) {
-	RETURN ( __MKSMALLINT(ENETRESET) );
+	RETURN ( __mkSmallInteger(ENETRESET) );
     }
 #endif
 
 #ifdef ECONNABORTED
     if (sym == @symbol(ECONNABORTED)) {
-	RETURN ( __MKSMALLINT(ECONNABORTED) );
+	RETURN ( __mkSmallInteger(ECONNABORTED) );
     }
 #endif
 
 #ifdef ECONNRESET
     if (sym == @symbol(ECONNRESET)) {
-	RETURN ( __MKSMALLINT(ECONNRESET) );
+	RETURN ( __mkSmallInteger(ECONNRESET) );
     }
 #endif
 
 #ifdef EISCONN
     if (sym == @symbol(EISCONN)) {
-	RETURN ( __MKSMALLINT(EISCONN) );
+	RETURN ( __mkSmallInteger(EISCONN) );
     }
 #endif
 
 #ifdef ENOTCONN
     if (sym == @symbol(ENOTCONN)) {
-	RETURN ( __MKSMALLINT(ENOTCONN) );
+	RETURN ( __mkSmallInteger(ENOTCONN) );
     }
 #endif
 
 #ifdef ESHUTDOWN
     if (sym == @symbol(ESHUTDOWN)) {
-	RETURN ( __MKSMALLINT(ESHUTDOWN) );
+	RETURN ( __mkSmallInteger(ESHUTDOWN) );
     }
 #endif
 
 #ifdef EHOSTDOWN
     if (sym == @symbol(EHOSTDOWN)) {
-	RETURN ( __MKSMALLINT(EHOSTDOWN) );
+	RETURN ( __mkSmallInteger(EHOSTDOWN) );
     }
 #endif
 
 #ifdef EHOSTUNREACH
     if (sym == @symbol(EHOSTUNREACH)) {
-	RETURN ( __MKSMALLINT(EHOSTUNREACH) );
+	RETURN ( __mkSmallInteger(EHOSTUNREACH) );
     }
 #endif
 
 #ifdef EREMOTEIO
     if (sym == @symbol(EREMOTEIO)) {
-	RETURN ( __MKSMALLINT(EREMOTEIO) );
+	RETURN ( __mkSmallInteger(EREMOTEIO) );
     }
 #endif
 #ifdef EDQUOT
     if (sym == @symbol(EDQUOT)) {
-	RETURN ( __MKSMALLINT(EDQUOT) );
+	RETURN ( __mkSmallInteger(EDQUOT) );
     }
 #endif
 #ifdef ENOMEDIUM
     if (sym == @symbol(ENOMEDIUM)) {
-	RETURN ( __MKSMALLINT(ENOMEDIUM) );
+	RETURN ( __mkSmallInteger(ENOMEDIUM) );
     }
 #endif
 #ifdef EMEDIUMTYPE
     if (sym == @symbol(EMEDIUMTYPE)) {
-	RETURN ( __MKSMALLINT(EMEDIUMTYPE) );
+	RETURN ( __mkSmallInteger(EMEDIUMTYPE) );
     }
 #endif
 
@@ -3134,7 +3134,7 @@
 	    if (id == -1) {
 		RETURN (nil);
 	    } else {
-		RETURN (__MKSMALLINT(id));
+		RETURN (__mkSmallInteger(id));
 	    }
 	}
     }
@@ -3397,9 +3397,9 @@
 
 	nWritten = sendfile(__intVal(outFd), __intVal(inFd), __intVal(startIdx), __intVal(count));
 	if (nWritten < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
-	}
-	RETURN (__MKSMALLINT(nWritten));
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
+	}
+	RETURN (__mkSmallInteger(nWritten));
      }
 #endif
 %}.
@@ -3422,7 +3422,7 @@
 
 	ret = mkdir(__stringVal(aPathName), 0755);
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN (false);
 	}
 	RETURN (true);
@@ -3468,7 +3468,7 @@
 	} while (ret < 0 && errno == EINTR);
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( false );
 	}
 	RETURN (true);
@@ -3500,7 +3500,7 @@
 	} while (ret < 0 && errno == EINTR);
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( false );
 	}
 	RETURN (true);
@@ -3699,7 +3699,7 @@
 	} while (ret < 0 && errno == EINTR);
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( false );
 	}
 	RETURN (true);
@@ -3732,7 +3732,7 @@
 	} while (ret < 0 && errno == EINTR);
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( false );
 	}
 	RETURN (true);
@@ -3771,7 +3771,7 @@
 	}
 #endif
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( false );
 	}
 	RETURN (true);
@@ -3834,7 +3834,7 @@
 	    fd = open((char *) __stringVal(aPathName), 2);
 	} while (fd < 0 && errno == EINTR);
 	if (fd < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( false );
 	}
 
@@ -3844,7 +3844,7 @@
 # endif /* HAS_FTRUNCATE */
 #endif
     if (ret < 0) {
-	@global(LastErrorNumber) = __MKSMALLINT(errno);
+	@global(LastErrorNumber) = __mkSmallInteger(errno);
 	RETURN ( false );
     }
     RETURN (true);
@@ -3879,31 +3879,31 @@
 #   endif
 
     if (aSymbol == @symbol(readUser)) {
-	RETURN ( __MKSMALLINT(S_IRUSR) );
+	RETURN ( __mkSmallInteger(S_IRUSR) );
     }
     if (aSymbol == @symbol(writeUser)) {
-	RETURN ( __MKSMALLINT(S_IWUSR) );
+	RETURN ( __mkSmallInteger(S_IWUSR) );
     }
     if (aSymbol == @symbol(executeUser)) {
-	RETURN ( __MKSMALLINT(S_IXUSR) );
+	RETURN ( __mkSmallInteger(S_IXUSR) );
     }
     if (aSymbol == @symbol(readGroup)) {
-	RETURN ( __MKSMALLINT(S_IRGRP) );
+	RETURN ( __mkSmallInteger(S_IRGRP) );
     }
     if (aSymbol == @symbol(writeGroup)) {
-	RETURN ( __MKSMALLINT(S_IWGRP) );
+	RETURN ( __mkSmallInteger(S_IWGRP) );
     }
     if (aSymbol == @symbol(executeGroup)) {
-	RETURN ( __MKSMALLINT(S_IXGRP) );
+	RETURN ( __mkSmallInteger(S_IXGRP) );
     }
     if (aSymbol == @symbol(readOthers)) {
-	RETURN ( __MKSMALLINT(S_IROTH) );
+	RETURN ( __mkSmallInteger(S_IROTH) );
     }
     if (aSymbol == @symbol(writeOthers)) {
-	RETURN ( __MKSMALLINT(S_IWOTH) );
+	RETURN ( __mkSmallInteger(S_IWOTH) );
     }
     if (aSymbol == @symbol(executeOthers)) {
-	RETURN ( __MKSMALLINT(S_IXOTH) );
+	RETURN ( __mkSmallInteger(S_IXOTH) );
     }
 %}.
     ^ self primitiveFailed
@@ -3940,10 +3940,10 @@
 	__END_INTERRUPTABLE__
 
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( nil );
 	}
-	RETURN ( __MKSMALLINT(buf.st_mode & 0777) );
+	RETURN ( __mkSmallInteger(buf.st_mode & 0777) );
     }
 %}.
    ^ self primitiveFailed
@@ -3969,7 +3969,7 @@
 	} while (ret < 0 && errno == EINTR);
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( false );
 	}
 	RETURN ( true );
@@ -4486,7 +4486,7 @@
     __END_INTERRUPTABLE__
 
     if (ret < 0) {
-	error = __MKSMALLINT(errno);
+	error = __mkSmallInteger(errno);
 	@global(LastErrorNumber) = error;
 	goto out;
     }
@@ -4543,10 +4543,10 @@
     } else {
 	id = __MKUINT(buf.st_ino);
     }
-    mode = __MKSMALLINT(buf.st_mode & 0777);
-    uid = __MKSMALLINT(buf.st_uid);
-    gid = __MKSMALLINT(buf.st_gid);
-    nLink = __MKSMALLINT(buf.st_nlink);
+    mode = __mkSmallInteger(buf.st_mode & 0777);
+    uid = __mkSmallInteger(buf.st_uid);
+    gid = __mkSmallInteger(buf.st_gid);
+    nLink = __mkSmallInteger(buf.st_nlink);
     if (sizeof(buf.st_size) == 8) {
 	size = __MKINT64(&buf.st_size);
     } else {
@@ -4611,7 +4611,7 @@
 	} while ((ret < 0) && (errno == EINTR));
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( false );
 	}
 	RETURN ( ((buf.st_mode & S_IFMT) == S_IFDIR) ? true : false);
@@ -4641,7 +4641,7 @@
 	} while ((ret < 0) && (errno == EINTR));
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	}
 	RETURN ( ((ret == 0) ? true : false) );
     }
@@ -4666,7 +4666,7 @@
 	} while ((ret < 0) && (errno == EINTR));
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	}
 	RETURN ( ((ret == 0) ? true : false) );
     }
@@ -4692,7 +4692,7 @@
 	} while ((ret < 0) && (errno == EINTR));
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN (false);
 	}
 	RETURN ( ret ? false : true );
@@ -4721,7 +4721,7 @@
 	} while ((ret < 0) && (errno == EINTR));
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	}
 	RETURN ( ((ret == 0) ? true : false) );
     }
@@ -4776,7 +4776,7 @@
 	__END_INTERRUPTABLE__
 
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( nil );
 	}
 	switch (buf.st_mode & S_IFMT) {
@@ -4784,7 +4784,7 @@
 	    case S_IFLNK:
 		type = @symbol(symbolicLink);
 		if ((ret = readlink((char *) __stringVal(aPathName), pathBuffer, sizeof(pathBuffer))) < 0) {
-		    @global(LastErrorNumber) = __MKSMALLINT(errno);
+		    @global(LastErrorNumber) = __mkSmallInteger(errno);
 		    RETURN ( nil );
 		}
 		pathBuffer[ret] = '\0';  /* readlink does not 0-terminate */
@@ -4838,10 +4838,10 @@
 	} else {
 	    id = __MKUINT(buf.st_ino);
 	}
-	mode = __MKSMALLINT(buf.st_mode & 0777);
-	uid = __MKSMALLINT(buf.st_uid);
-	gid = __MKSMALLINT(buf.st_gid);
-	nLink = __MKSMALLINT(buf.st_nlink);
+	mode = __mkSmallInteger(buf.st_mode & 0777);
+	uid = __mkSmallInteger(buf.st_uid);
+	gid = __mkSmallInteger(buf.st_gid);
+	nLink = __mkSmallInteger(buf.st_nlink);
 	if (sizeof(buf.st_size) == 8) {
 	    size = __MKINT64(&buf.st_size);
 	} else {
@@ -5005,7 +5005,7 @@
 	    retVal = __MKUINT(ino);
 	    RETURN (retVal);
 	}
-	@global(LastErrorNumber) = __MKSMALLINT(errno);
+	@global(LastErrorNumber) = __mkSmallInteger(errno);
 	RETURN (nil);
     }
     RETURN (nil);
@@ -5088,7 +5088,7 @@
 	} while (ret < 0 && errno == EINTR);
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN (nil);
 	}
 	osSeconds = __MKUINT(buf.st_atime);
@@ -5129,7 +5129,7 @@
 	} while (ret < 0 && errno == EINTR);
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( nil );
 	}
 	osSeconds = __MKUINT(buf.st_mtime);
@@ -5173,7 +5173,7 @@
 	} while (ret < 0 && errno == EINTR);
 	__END_INTERRUPTABLE__
 	if (ret < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( nil );
 	}
 	switch (buf.st_mode & S_IFMT) {
@@ -5289,7 +5289,7 @@
 	    ret = flags;
 	}
 # endif /* !SYSV4 */
-	RETURN ( __MKSMALLINT(ret) );
+	RETURN ( __mkSmallInteger(ret) );
     }
 #endif
 %}.
@@ -5822,7 +5822,7 @@
 %{
     if (__bothSmallInteger(signalNumber, processId)) {
 	if (kill(__intVal(processId), __intVal(signalNumber)) < 0) {
-	    @global(LastErrorNumber) = __MKSMALLINT(errno);
+	    @global(LastErrorNumber) = __mkSmallInteger(errno);
 	    RETURN ( false );
 	}
 	RETURN ( true );
@@ -5961,8 +5961,8 @@
 	_fdM -1;
     }
     if ((_fdM >= 0) && (_fdS >= 0)) {
-	 fdM = __MKSMALLINT(_fdM);
-	 fdS = __MKSMALLINT(_fdS);
+	 fdM = __mkSmallInteger(_fdM);
+	 fdS = __mkSmallInteger(_fdS);
     }
 #   define PTY_IS_IMPLEMENTED 1
 #endif /* IRIX5 */
@@ -6004,8 +6004,8 @@
     }
 
     if ((_fdM >= 0) && (_fdS >= 0)) {
-	 fdM = __MKSMALLINT(_fdM);
-	 fdS = __MKSMALLINT(_fdS);
+	 fdM = __mkSmallInteger(_fdM);
+	 fdS = __mkSmallInteger(_fdS);
     }
 #   define PTY_IS_IMPLEMENTED 1
 #endif /* HAS_UNIX98_PTY */
@@ -6112,8 +6112,8 @@
   getOutOfHere: ;
 
     if ((_fdM >= 0) && (_fdS >= 0)) {
-	 fdM = __MKSMALLINT(_fdM);
-	 fdS = __MKSMALLINT(_fdS);
+	 fdM = __mkSmallInteger(_fdM);
+	 fdS = __mkSmallInteger(_fdS);
     }
 
 #endif /* ! defined(PTY_IS_IMPLEMENTED) */
@@ -6138,12 +6138,12 @@
      int fds[2];
 
      if (pipe(fds) < 0) {
-	@global(LastErrorNumber) = __MKSMALLINT(errno);
+	@global(LastErrorNumber) = __mkSmallInteger(errno);
 	RETURN ( nil );
      }
 
-     fd1 = __MKSMALLINT(fds[0]);
-     fd2 = __MKSMALLINT(fds[1]);
+     fd1 = __mkSmallInteger(fds[0]);
+     fd2 = __mkSmallInteger(fds[1]);
 %}.
     fd1 notNil ifTrue:[
 	^ Array with:fd1 with:fd2.
@@ -6583,10 +6583,10 @@
 	__AT_PUT_(info, @symbol(negativeSign), val);
     }
     if (intFractDigits >= 0) {
-	__AT_PUT_(info, @symbol(internationalFractionalDigits),  __MKSMALLINT(intFractDigits));
+	__AT_PUT_(info, @symbol(internationalFractionalDigits),  __mkSmallInteger(intFractDigits));
     }
     if (fractDigits >= 0) {
-	__AT_PUT_(info, @symbol(fractionalDigits),  __MKSMALLINT(fractDigits));
+	__AT_PUT_(info, @symbol(fractionalDigits),  __mkSmallInteger(fractDigits));
     }
     if (csPosPrecedes >= 0) {
 	if (csPosPrecedes == 0) {
@@ -6805,7 +6805,7 @@
     int pid = 0;
 
     pid = getpid();
-    RETURN ( __MKSMALLINT(pid) );
+    RETURN ( __mkSmallInteger(pid) );
 %}
     "
      OperatingSystem getProcessId
@@ -7595,18 +7595,18 @@
      * TODO: new systems provide a query function for this ... use it
      */
 #   if defined(MAXFILENAMELEN)
-      RETURN ( __MKSMALLINT(MAXFILENAMELEN) );
+      RETURN ( __mkSmallInteger(MAXFILENAMELEN) );
 #   else
 #    if defined(BSD) || defined(SYSV4) || defined(LONGFILENAMES)
-      RETURN ( __MKSMALLINT(255) );
+      RETURN ( __mkSmallInteger(255) );
 #    endif
 
 #    ifdef realIX
-       RETURN ( __MKSMALLINT(127) );
+       RETURN ( __mkSmallInteger(127) );
 #    endif
 
 #    ifdef SYSV
-       RETURN ( __MKSMALLINT(14) );
+       RETURN ( __mkSmallInteger(14) );
 #    endif
 #   endif
 %}.
@@ -7640,7 +7640,7 @@
     "return the max number of characters in a pathName."
 
 %{  /* NOCONTEXT */
-    RETURN ( __MKSMALLINT(MAXPATHLEN) );
+    RETURN ( __mkSmallInteger(MAXPATHLEN) );
 %}
     "
      OperatingSystem maxPathLength
@@ -7999,7 +7999,7 @@
 	if (address != (void *)-1) {
 	    RETURN (__MKEXTERNALBYTES(addr));
 	}
-	@global(LastErrorNumber) = __MKSMALLINT(errno);
+	@global(LastErrorNumber) = __mkSmallInteger(errno);
 	RETURN (nil);
     }
 #endif
@@ -8025,7 +8025,7 @@
 	if (rslt != -1) {
 	    RETURN (true);
 	}
-	@global(LastErrorNumber) = __MKSMALLINT(errno);
+	@global(LastErrorNumber) = __mkSmallInteger(errno);
 	RETURN (false);
     }
 #endif
@@ -8048,9 +8048,9 @@
 
 	rslt = shmget(__intVal(key), __intVal(size), __intVal(flags));
 	if (rslt != -1) {
-	    RETURN (__MKSMALLINT(rslt));
-	}
-	@global(LastErrorNumber) = __MKSMALLINT(errno);
+	    RETURN (__mkSmallInteger(rslt));
+	}
+	@global(LastErrorNumber) = __mkSmallInteger(errno);
 	RETURN (nil);
     }
 #endif
@@ -8286,7 +8286,7 @@
 #endif
 
 out:
-    RETURN ( __MKSMALLINT(t & 0x1FFFFFFF) );
+    RETURN ( __mkSmallInteger(t & 0x1FFFFFFF) );
 
 err:;
 %}.
@@ -8373,7 +8373,7 @@
 	ticks = times(&tb);
 	t = (ticks * 1000) / HZ;
 	t = t % 1000;
-	_millis = __MKSMALLINT(t);
+	_millis = __mkSmallInteger(t);
     }
 #   define HAVE_TIME
 #  endif /* OLD SYSV stuff */
@@ -8524,17 +8524,17 @@
     } else {
 	tmPtr = gmtime(&tt);
     }
-    hours = __MKSMALLINT(tmPtr->tm_hour);
-    minutes = __MKSMALLINT(tmPtr->tm_min);
-    seconds = __MKSMALLINT(tmPtr->tm_sec);
-
-    year = __MKSMALLINT(tmPtr->tm_year + 1900);
-    month = __MKSMALLINT(tmPtr->tm_mon + 1);
-    day = __MKSMALLINT(tmPtr->tm_mday);
-
-    yDay = __MKSMALLINT(tmPtr->tm_yday+1);
-    wDay = __MKSMALLINT(tmPtr->tm_wday == 0 ? 7 : tmPtr->tm_wday);
-    utcOffset = __MKSMALLINT(TIMEZONE(tmPtr));
+    hours = __mkSmallInteger(tmPtr->tm_hour);
+    minutes = __mkSmallInteger(tmPtr->tm_min);
+    seconds = __mkSmallInteger(tmPtr->tm_sec);
+
+    year = __mkSmallInteger(tmPtr->tm_year + 1900);
+    month = __mkSmallInteger(tmPtr->tm_mon + 1);
+    day = __mkSmallInteger(tmPtr->tm_mday);
+
+    yDay = __mkSmallInteger(tmPtr->tm_yday+1);
+    wDay = __mkSmallInteger(tmPtr->tm_wday == 0 ? 7 : tmPtr->tm_wday);
+    utcOffset = __mkSmallInteger(TIMEZONE(tmPtr));
     dst = (tmPtr->tm_isdst == 0 ? false : true);
 %}.
     info := self timeInfoClass new.
@@ -8579,7 +8579,7 @@
     int uid;
 
     uid = getegid();
-    RETURN ( __MKSMALLINT(uid) );
+    RETURN ( __mkSmallInteger(uid) );
 %}
 
     "
@@ -8598,7 +8598,7 @@
     int uid;
 
     uid = geteuid();
-    RETURN ( __MKSMALLINT(uid) );
+    RETURN ( __mkSmallInteger(uid) );
 %}
 
     "
@@ -8645,7 +8645,7 @@
     int uid;
 
     uid = getgid();
-    RETURN ( __MKSMALLINT(uid) );
+    RETURN ( __mkSmallInteger(uid) );
 %}.
     ^ 1 "just a dummy for systems which do not have userIDs"
 
@@ -8751,7 +8751,7 @@
     int uid;
 
     uid = getuid();
-    RETURN ( __MKSMALLINT(uid) );
+    RETURN ( __mkSmallInteger(uid) );
 %}
 
     "
@@ -8835,8 +8835,8 @@
 #  endif
 	shell = __MKSTRING(buf->pw_shell);
 
-	uid = __MKSMALLINT(buf->pw_uid);
-	gid = __MKSMALLINT(buf->pw_gid);
+	uid = __mkSmallInteger(buf->pw_uid);
+	gid = __mkSmallInteger(buf->pw_gid);
     }
 # endif /* has PWD */
 %}.
@@ -8975,17 +8975,17 @@
 	if (errno == ECHILD)
 	    RETURN(nil);
     } else {
-	pid = __MKSMALLINT(p);
+	pid = __mkSmallInteger(p);
 	if (WIFEXITED(s)) {
 	    status = @symbol(exit);
-	    code = __MKSMALLINT(WEXITSTATUS(s));
+	    code = __mkSmallInteger(WEXITSTATUS(s));
 	    core = WCOREDUMP(s) ? true : false;
 	} else if (WIFSIGNALED(s)) {
 	    status = @symbol(signal);
-	    code = __MKSMALLINT(WTERMSIG(s));
+	    code = __mkSmallInteger(WTERMSIG(s));
 	} else if (WIFSTOPPED(s)) {
 	    status = @symbol(stop);
-	    code = __MKSMALLINT(WSTOPSIG(s));
+	    code = __mkSmallInteger(WSTOPSIG(s));
 	}
 #if defined(WIFCONTINUED)
 	else if (WIFCONTINUED(s)) {
@@ -9303,21 +9303,21 @@
 	for (i=0; i <= maxF; i++) {
 	    if (FD_ISSET(i, &rset)) {
 		if (cntR < resultSizeReadable) {
-		    __resultR[cntR] = __MKSMALLINT(i);
+		    __resultR[cntR] = __mkSmallInteger(i);
 		}
 		cntR++;
 	    }
 
 	    if (FD_ISSET(i, &wset)) {
 		if (cntW < resultSizeWritable) {
-		    __resultW[cntW] = __MKSMALLINT(i);
+		    __resultW[cntW] = __mkSmallInteger(i);
 		}
 		cntW++;
 	    }
 
 	    if (FD_ISSET(i, &eset)) {
 		if (cntE < resultSizeException) {
-		    __resultE[cntE] = __MKSMALLINT(i);
+		    __resultE[cntE] = __mkSmallInteger(i);
 		}
 		cntE++;
 	    }
@@ -9333,7 +9333,7 @@
 	    __resultE[cntE] = nil;
 	}
 
-	RETURN (__MKSMALLINT(cntR+cntW+cntE));
+	RETURN (__mkSmallInteger(cntR+cntW+cntE));
     } else {
 	if (ret < 0) {
 	    if (errno == EINTR) {
@@ -9343,7 +9343,7 @@
 		if (@global(InfoPrinting) == true) {
 		    fprintf(stderr, "OS [info]: select errno = %d\n", errno);
 		}
-		@global(LastErrorNumber) = __MKSMALLINT(errno);
+		@global(LastErrorNumber) = __mkSmallInteger(errno);
 	    }
 	} else {
 	    @global(LastErrorNumber) = nil;
@@ -9353,7 +9353,7 @@
     /*
      * Return 0 (no filedescriptor ready)
      */
-    RETURN (__MKSMALLINT(0));
+    RETURN (__mkSmallInteger(0));
 fail: ;
 %}.
     "
@@ -9517,7 +9517,7 @@
 		if (FD_ISSET(i, &rset)
 		 || FD_ISSET(i, &wset)
 		 || FD_ISSET(i, &eset)) {
-		    RETURN ( __MKSMALLINT(i) );
+		    RETURN ( __mkSmallInteger(i) );
 		}
 	    }
 	} else {
@@ -9529,7 +9529,7 @@
 		    if (@global(InfoPrinting) == true) {
 			fprintf(stderr, "OS [info]: select errno = %d\n", errno);
 		    }
-		    @global(LastErrorNumber) = __MKSMALLINT(errno);
+		    @global(LastErrorNumber) = __mkSmallInteger(errno);
 		}
 	    } else {
 		@global(LastErrorNumber) = nil;
@@ -10094,9 +10094,9 @@
 	    ret = fcntl(f, F_SETFL, flags | DELAY_FLAG);
 	}
 	if (ret >= 0) {
-	    RETURN(__MKSMALLINT(flags));
+	    RETURN(__mkSmallInteger(flags));
 	} else {
-	    err = __MKSMALLINT(errno);
+	    err = __mkSmallInteger(errno);
 	}
     }
 # undef DELAY_FLAG
@@ -10847,7 +10847,7 @@
     if (__isString(aNameOrNumber) || __isSymbol(aNameOrNumber)) {
 	protoent = getprotobyname((char *) __stringVal(aNameOrNumber));
 	if (protoent) {
-	    protocolCode = __MKSMALLINT(protoent->p_proto);
+	    protocolCode = __mkSmallInteger(protoent->p_proto);
 	    protocolSymbol = __MKSYMBOL(protoent->p_name, 0);
 	}
     }
@@ -11053,10 +11053,10 @@
 
 	__ArrayInstPtr(result)->a_element[cnt] = resp; __STORE(result, resp);
 
-	__ArrayInstPtr(resp)->a_element[0] = __MKSMALLINT(infop->ai_flags);
-	__ArrayInstPtr(resp)->a_element[1] = __MKSMALLINT(infop->ai_family);
-	__ArrayInstPtr(resp)->a_element[2] = __MKSMALLINT(infop->ai_socktype);
-	__ArrayInstPtr(resp)->a_element[3] = __MKSMALLINT(infop->ai_protocol);
+	__ArrayInstPtr(resp)->a_element[0] = __mkSmallInteger(infop->ai_flags);
+	__ArrayInstPtr(resp)->a_element[1] = __mkSmallInteger(infop->ai_family);
+	__ArrayInstPtr(resp)->a_element[2] = __mkSmallInteger(infop->ai_socktype);
+	__ArrayInstPtr(resp)->a_element[3] = __mkSmallInteger(infop->ai_protocol);
 
 	__PROTECT__(resp);
 	o = __BYTEARRAY_NEW_INT(infop->ai_addrlen);
@@ -11676,7 +11676,7 @@
 		goto again;
 
 	    default:
-		error = __MKSMALLINT(errno);
+		error = __mkSmallInteger(errno);
 		break;
 	}
     }
@@ -11741,7 +11741,7 @@
 # endif
 
     default:
-	error = __MKSMALLINT(errno);
+	error = __mkSmallInteger(errno);
 	break;
     }
 
@@ -11864,7 +11864,7 @@
 	    __HANDLE_INTERRUPTS__;
 	    goto again;
 	} else {
-	    error = __MKSMALLINT(errno);
+	    error = __mkSmallInteger(errno);
 	    goto err;
 	}
     }
@@ -11988,7 +11988,7 @@
 	    __HANDLE_INTERRUPTS__;
 	    goto again;
 	} else {
-	    error = __MKSMALLINT(errno);
+	    error = __mkSmallInteger(errno);
 	    goto err;
 	}
     }
@@ -12303,7 +12303,7 @@
     sock = __smallIntegerVal(__INST(fd));
     ret = getsockname(sock, (struct sockaddr *)__byteArrayVal(socketAddress), &sockaddr_size);
     if (ret < 0) {
-	error = __MKSMALLINT(errno);
+	error = __mkSmallInteger(errno);
     }
 err:;
 #endif /* NO_SOCKET */
@@ -12355,7 +12355,7 @@
 !UnixOperatingSystem class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/UnixOperatingSystem.st,v 1.230 2005-07-07 15:21:37 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/UnixOperatingSystem.st,v 1.231 2005-07-08 17:15:03 cg Exp $'
 ! !
 
 UnixOperatingSystem initialize!
--- a/WeakArray.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/WeakArray.st	Fri Jul 08 19:15:03 2005 +0200
@@ -485,7 +485,7 @@
     nIndex = __BYTES2OBJS__(__qSize(self) - OHDR_SIZE);
 
     if (__isBlockLike(aBlock)
-     && (__BlockInstPtr(aBlock)->b_nargs == __MKSMALLINT(1))) {
+     && (__BlockInstPtr(aBlock)->b_nargs == __mkSmallInteger(1))) {
         {
             /*
              * the most common case: a static compiled block, with home on the stack ...
@@ -649,7 +649,7 @@
     index = __intVal(__ClassInstPtr(__qClass(self))->c_ninstvars);
     nIndex = __BYTES2OBJS__(__qSize(self) - OHDR_SIZE);
     if (__isBlockLike(aBlock)
-     && (__BlockInstPtr(aBlock)->b_nargs == __MKSMALLINT(1))) {
+     && (__BlockInstPtr(aBlock)->b_nargs == __mkSmallInteger(1))) {
         {
             /*
              * the most common case: a static compiled block, with home on the stack ...
@@ -789,7 +789,7 @@
     index = __intVal(__ClassInstPtr(__qClass(self))->c_ninstvars);
     nIndex = __BYTES2OBJS__(__qSize(self) - OHDR_SIZE);
     if (__isBlockLike(aBlock)
-     && (__BlockInstPtr(aBlock)->b_nargs == __MKSMALLINT(1))) {
+     && (__BlockInstPtr(aBlock)->b_nargs == __mkSmallInteger(1))) {
         {
             /*
              * the most common case: a static compiled block, with home on the stack ...
@@ -813,7 +813,7 @@
                         REGISTER OBJ element;
 
                         element = __InstPtr(self)->i_instvars[index];
-                        if (element && (element != __MKSMALLINT(0))) {
+                        if (element && (element != __mkSmallInteger(0))) {
                             if (InterruptPending != nil) {
                                 __interruptL(@line);
                                 element = __InstPtr(self)->i_instvars[index];
@@ -822,7 +822,7 @@
                             if (__isNonNilObject(element)) {
                                 element = __WEAK_READ__(self, element);
                             }
-                            if (element && (element != __MKSMALLINT(0))) {
+                            if (element && (element != __mkSmallInteger(0))) {
                                 (*codeVal)(BLOCK_ARG, element);
                             }
                         }
@@ -850,7 +850,7 @@
             OBJ element;
 
             element = __InstPtr(self)->i_instvars[index];
-            if (element && (element != __MKSMALLINT(0))) {
+            if (element && (element != __mkSmallInteger(0))) {
                 if (InterruptPending != nil) {
                     __interruptL(@line);
                     element = __InstPtr(self)->i_instvars[index];
@@ -858,7 +858,7 @@
                 if (__isNonNilObject(element)) {
                     element = __WEAK_READ__(self, element);
                 }
-                if (element && (element != __MKSMALLINT(0))) {
+                if (element && (element != __mkSmallInteger(0))) {
                     if ((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil) {
                         (*codeVal)(BLOCK_ARG, element);
                     } else {
@@ -895,7 +895,7 @@
         REGISTER OBJ element;
 
         element = __InstPtr(self)->i_instvars[index];
-        if (element && (element != __MKSMALLINT(0))) {
+        if (element && (element != __mkSmallInteger(0))) {
             if (InterruptPending != nil) {
                 __interruptL(@line);
                 element = __InstPtr(self)->i_instvars[index];
@@ -903,7 +903,7 @@
             if (__isNonNilObject(element)) {
                 element = __WEAK_READ__(self, element);
             }
-            if (element && (element != __MKSMALLINT(0))) {
+            if (element && (element != __mkSmallInteger(0))) {
                 (*val.ilc_func)(aBlock, 
                                     @symbol(value:), 
                                     nil, &val, 
@@ -936,7 +936,7 @@
 !WeakArray class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/WeakArray.st,v 1.60 2003-03-02 20:53:06 stefan Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/WeakArray.st,v 1.61 2005-07-08 17:15:03 cg Exp $'
 ! !
 
 WeakArray initialize!
--- a/WriteStream.st	Fri Jul 08 18:41:53 2005 +0200
+++ b/WriteStream.st	Fri Jul 08 19:15:03 2005 +0200
@@ -381,9 +381,9 @@
                     __StringInstPtr(coll)->s_element[pos-1] = ch;
 advancePositionAndReturn: ;            
                     if ((__readLimit >= 0) && (pos >= __readLimit)) {
-                        __INST(readLimit) = __MKSMALLINT(pos);
+                        __INST(readLimit) = __mkSmallInteger(pos);
                     }
-                    __INST(position) = __MKSMALLINT(__intVal(__INST(position)) + 1);
+                    __INST(position) = __mkSmallInteger(__intVal(__INST(position)) + 1);
                     RETURN ( anObject );
                 }
             } else if (cls == @global(ByteArray)) {
@@ -551,9 +551,9 @@
                     __StringInstPtr(coll)->s_element[pos-1] = ch;
     advancePositionAndReturn: ;            
                     if ((__readLimit >= 0) && (pos >= __readLimit)) {
-                        __INST(readLimit) = __MKSMALLINT(pos);
+                        __INST(readLimit) = __mkSmallInteger(pos);
                     }
-                    __INST(position) = __MKSMALLINT(__intVal(__INST(position)) + 1);
+                    __INST(position) = __mkSmallInteger(__intVal(__INST(position)) + 1);
                     RETURN ( anObject );
                 }
             } else if (cls == @global(ByteArray)) {
@@ -589,5 +589,5 @@
 !WriteStream class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/WriteStream.st,v 1.62 2005-04-26 08:41:17 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/WriteStream.st,v 1.63 2005-07-08 17:15:03 cg Exp $'
 ! !