hg/stx-libbasic: comparison AbstractOperatingSystem.st

equal deleted inserted replaced

-:3d1947a79cf3
+:b9498d27a554
 	RETURN (aSymbolOrInteger);
 }
 #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
 %}.
 ^ domainCode.
 	RETURN (aSymbolOrInteger);
 }
 #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
 %}.
 ^ protocolCode.
 %{
 if (__isSmallInteger(domainCode)) {
 	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
 	}
 }
 %}.
 	typeCode = aSymbolOrInteger;
 }
 #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
 %}.
 ^ typeCode.
 "this returns the maximum delta supported by millisecondCounter
 based methods. The returned value is half the value at which the
 timer wraps."
 %{  /* NOCONTEXT */
-RETURN ( __MKSMALLINT(0x0FFFFFFF) );
+RETURN ( __mkSmallInteger(0x0FFFFFFF) );
 %}
 !
 millisecondDelay:millis
 "delay execution for millis milliseconds or until the next event arrives.
 ! !
 !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!

changeset 8913	b9498d27a554
parent 8901	824a89d0b5c7
child 8967	30dcf961185d