hedgewars: comparison misc/winutils/include/SDL

equal deleted inserted replaced

-:4feced261c68
+:de822cd3df3a
 extern "C" {
 #endif
 /* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL
 */
-#define SDL_NET_MAJOR_VERSION	1
+#define SDL_NET_MAJOR_VERSION   1
-#define SDL_NET_MINOR_VERSION	2
+#define SDL_NET_MINOR_VERSION   2
-#define SDL_NET_PATCHLEVEL	8
+#define SDL_NET_PATCHLEVEL  8
 /* This macro can be used to fill a version structure with the compile-time
 * version of the SDL_net library.
 */
-#define SDL_NET_VERSION(X)						\
+#define SDL_NET_VERSION(X)                      \
-{									\
+{                                   \
-	(X)->major = SDL_NET_MAJOR_VERSION;				\
+(X)->major = SDL_NET_MAJOR_VERSION;             \
-	(X)->minor = SDL_NET_MINOR_VERSION;				\
+(X)->minor = SDL_NET_MINOR_VERSION;             \
-	(X)->patch = SDL_NET_PATCHLEVEL;				\
+(X)->patch = SDL_NET_PATCHLEVEL;                \
 }
 /* This function gets the version of the dynamically linked SDL_net library.
 it should NOT be used to fill a version structure, instead you should
 use the SDL_NET_VERSION() macro.
 /***********************************************************************/
 /* IPv4 hostname resolution API                                        */
 /***********************************************************************/
 typedef struct {
-	Uint32 host;			/* 32-bit IPv4 host address */
+Uint32 host;            /* 32-bit IPv4 host address */
-	Uint16 port;			/* 16-bit protocol port */
+Uint16 port;            /* 16-bit protocol port */
 } IPaddress;
 /* Resolve a host name and port to an IP address in network form.
 If the function succeeds, it will return 0.
 If the host couldn't be resolved, the host portion of the returned
 address will be INADDR_NONE, and the function will return -1.
 If 'host' is NULL, the resolved host will be set to INADDR_ANY.
 */
 #ifndef INADDR_ANY
-#define INADDR_ANY		0x00000000
+#define INADDR_ANY      0x00000000
 #endif
 #ifndef INADDR_NONE
-#define INADDR_NONE		0xFFFFFFFF
+#define INADDR_NONE     0xFFFFFFFF
 #endif
 #ifndef INADDR_BROADCAST
-#define INADDR_BROADCAST	0xFFFFFFFF
+#define INADDR_BROADCAST    0xFFFFFFFF
 #endif
 extern DECLSPEC int SDLCALL SDLNet_ResolveHost(IPaddress *address, const char *host, Uint16 port);
 /* Resolve an ip address to a host name in canonical form.
 If the ip couldn't be resolved, this function returns NULL,
 /* Open a TCP network socket
 If ip.host is INADDR_NONE or INADDR_ANY, this creates a local server
 socket on the given port, otherwise a TCP connection to the remote
 host and port is attempted. The address passed in should already be
 swapped to network byte order (addresses returned from
 SDLNet_ResolveHost() are already in the correct form).
 The newly created socket is returned, or NULL if there was an error.
 */
 extern DECLSPEC TCPsocket SDLCALL SDLNet_TCP_Open(IPaddress *ip);
 This function returns the actual amount of data sent.  If the return value
 is less than the amount of data sent, then either the remote connection was
 closed, or an unknown socket error occurred.
 */
 extern DECLSPEC int SDLCALL SDLNet_TCP_Send(TCPsocket sock, const void *data,
-		int len);
+int len);
 /* Receive up to 'maxlen' bytes of data over the non-server socket 'sock',
 and store them in the buffer pointed to by 'data'.
 This function returns the actual amount of data received.  If the return
 value is less than or equal to zero, then either the remote connection was
 /***********************************************************************/
 /* UDP network API                                                     */
 /***********************************************************************/
 /* The maximum channels on a a UDP socket */
-#define SDLNET_MAX_UDPCHANNELS	32
+#define SDLNET_MAX_UDPCHANNELS  32
 /* The maximum addresses bound to a single UDP socket channel */
-#define SDLNET_MAX_UDPADDRESSES	4
+#define SDLNET_MAX_UDPADDRESSES 4
 typedef struct _UDPsocket *UDPsocket;
 typedef struct {
-	int channel;		/* The src/dst channel of the packet */
+int channel;        /* The src/dst channel of the packet */
-	Uint8 *data;		/* The packet data */
+Uint8 *data;        /* The packet data */
-	int len;		/* The length of the packet data */
+int len;        /* The length of the packet data */
-	int maxlen;		/* The size of the data buffer */
+int maxlen;     /* The size of the data buffer */
-	int status;		/* packet status after sending */
+int status;     /* packet status after sending */
-	IPaddress address;		/* The source/dest address of an incoming/outgoing packet */
+IPaddress address;      /* The source/dest address of an incoming/outgoing packet */
 } UDPpacket;
 /* Allocate/resize/free a single UDP packet 'size' bytes long.
 The new packet is returned, or NULL if the function ran out of memory.
 */
 extern DECLSPEC int SDLCALL SDLNet_UDP_Bind(UDPsocket sock, int channel, const IPaddress *address);
 /* Unbind all addresses from the given channel */
 extern DECLSPEC void SDLCALL SDLNet_UDP_Unbind(UDPsocket sock, int channel);
 /* Get the primary IP address of the remote system associated with the
 socket and channel.  If the channel is -1, then the primary IP port
 of the UDP socket is returned -- this is only meaningful for sockets
 opened with a specific port.
 If the channel is not bound and not -1, this function returns NULL.
 */
 extern DECLSPEC IPaddress * SDLCALL SDLNet_UDP_GetPeerAddress(UDPsocket sock, int channel);
 /* Send a vector of packets to the the channels specified within the packet.
 If the channel specified in the packet is -1, the packet will be sent to
 the address in the 'src' member of the packet.
 Each packet will be updated with the status of the packet after it has
 been sent, -1 if the packet send failed.
 This function returns the number of packets sent.
 */
 extern DECLSPEC int SDLCALL SDLNet_UDP_SendV(UDPsocket sock, UDPpacket **packets, int npackets);
 typedef struct _SDLNet_SocketSet *SDLNet_SocketSet;
 /* Any network socket can be safely cast to this socket type */
 typedef struct _SDLNet_GenericSocket {
-	int ready;
+int ready;
 } *SDLNet_GenericSocket;
 /* Allocate a socket set for use with SDLNet_CheckSockets()
 This returns a socket set for up to 'maxsockets' sockets, or NULL if
 the function ran out of memory.
 */
 extern DECLSPEC SDLNet_SocketSet SDLCALL SDLNet_AllocSocketSet(int maxsockets);
 /* Add a socket to a set of sockets to be checked for available data */
 #define SDLNet_TCP_AddSocket(set, sock) \
-			SDLNet_AddSocket(set, SDL_reinterpret_cast(SDLNet_GenericSocket, sock))
+SDLNet_AddSocket(set, SDL_reinterpret_cast(SDLNet_GenericSocket, sock))
 #define SDLNet_UDP_AddSocket(set, sock) \
-			SDLNet_AddSocket(set, SDL_reinterpret_cast(SDLNet_GenericSocket, sock))
+SDLNet_AddSocket(set, SDL_reinterpret_cast(SDLNet_GenericSocket, sock))
 extern DECLSPEC int SDLCALL SDLNet_AddSocket(SDLNet_SocketSet set, SDLNet_GenericSocket sock);
 /* Remove a socket from a set of sockets to be checked for available data */
 #define SDLNet_TCP_DelSocket(set, sock) \
-			SDLNet_DelSocket(set, SDL_reinterpret_cast(SDLNet_GenericSocket, sock))
+SDLNet_DelSocket(set, SDL_reinterpret_cast(SDLNet_GenericSocket, sock))
 #define SDLNet_UDP_DelSocket(set, sock) \
-			SDLNet_DelSocket(set, SDL_reinterpret_cast(SDLNet_GenericSocket, sock))
+SDLNet_DelSocket(set, SDL_reinterpret_cast(SDLNet_GenericSocket, sock))
 extern DECLSPEC int SDLCALL SDLNet_DelSocket(SDLNet_SocketSet set, SDLNet_GenericSocket sock);
 /* This function checks to see if data is available for reading on the
 given set of sockets.  If 'timeout' is 0, it performs a quick poll,
 otherwise the function returns when either data is available for
 reading, or the timeout in milliseconds has elapsed, which ever occurs
 first.  This function returns the number of sockets ready for reading,
 or -1 if there was an error with the select() system call.
 */
 extern DECLSPEC int SDLCALL SDLNet_CheckSockets(SDLNet_SocketSet set, Uint32 timeout);
 /* After calling SDLNet_CheckSockets(), you can use this function on a
 socket that was in the socket set, to find out if data is available
 for reading.
 */
 #define SDLNet_SocketReady(sock) \
-		((sock != NULL) && SDL_reinterpret_cast(SDLNet_GenericSocket, sock)->ready)
+((sock != NULL) && SDL_reinterpret_cast(SDLNet_GenericSocket, sock)->ready)
 /* Free a set of sockets allocated by SDL_NetAllocSocketSet() */
 extern DECLSPEC void SDLCALL SDLNet_FreeSocketSet(SDLNet_SocketSet set);
 /***********************************************************************/
 /* Error reporting functions                                           */
 /***********************************************************************/
 /* We'll use SDL's functions for error reporting */
-#define SDLNet_SetError	SDL_SetError
+#define SDLNet_SetError SDL_SetError
-#define SDLNet_GetError	SDL_GetError
+#define SDLNet_GetError SDL_GetError
 /* I'm eventually going to try to disentangle SDL_net from SDL, thus making
 SDL_net an independent X-platform networking toolkit.  Not today though....
 extern no_parse_DECLSPEC void SDLCALL SDLNet_SetError(const char *fmt, ...);
 /* Inline macro functions to read/write network data */
 /* Warning, some systems have data access alignment restrictions */
 #if defined(sparc) || defined(mips)
-#define SDL_DATA_ALIGNED	1
+#define SDL_DATA_ALIGNED    1
 #endif
 #ifndef SDL_DATA_ALIGNED
-#define SDL_DATA_ALIGNED	0
+#define SDL_DATA_ALIGNED    0
 #endif
 /* Write a 16 bit value to network packet buffer */
 #if !SDL_DATA_ALIGNED
-#define SDLNet_Write16(value, areap)	\
+#define SDLNet_Write16(value, areap)    \
-	(*SDL_reinterpret_cast(Uint16 *, areap) = SDL_SwapBE16(value))
+(*SDL_reinterpret_cast(Uint16 *, areap) = SDL_SwapBE16(value))
 #else
 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-#define SDLNet_Write16(value, areap)	\
+#define SDLNet_Write16(value, areap)    \
-do 					\
+do                  \
-{					\
+{                   \
-	Uint8 *area = SDL_reinterpret_cast(Uint8 *, areap);	\
+Uint8 *area = SDL_reinterpret_cast(Uint8 *, areap); \
-	area[0] = (value >>  8) & 0xFF;	\
+area[0] = (value >>  8) & 0xFF; \
-	area[1] =  value        & 0xFF;	\
+area[1] =  value        & 0xFF; \
 } while ( 0 )
 #else
-#define SDLNet_Write16(value, areap)	\
+#define SDLNet_Write16(value, areap)    \
-do 					\
+do                  \
-{					\
+{                   \
-	Uint8 *area = SDL_reinterpret_cast(Uint8 *, areap);	\
+Uint8 *area = SDL_reinterpret_cast(Uint8 *, areap); \
-	area[1] = (value >>  8) & 0xFF;	\
+area[1] = (value >>  8) & 0xFF; \
-	area[0] =  value        & 0xFF;	\
+area[0] =  value        & 0xFF; \
 } while ( 0 )
 #endif
 #endif /* !SDL_DATA_ALIGNED */
 /* Write a 32 bit value to network packet buffer */
 #if !SDL_DATA_ALIGNED
-#define SDLNet_Write32(value, areap) 	\
+#define SDLNet_Write32(value, areap)    \
-	*SDL_reinterpret_cast(Uint32 *, areap) = SDL_SwapBE32(value);
+*SDL_reinterpret_cast(Uint32 *, areap) = SDL_SwapBE32(value);
 #else
 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-#define SDLNet_Write32(value, areap) 	\
+#define SDLNet_Write32(value, areap)    \
-do					\
+do                  \
-{					\
+{                   \
-	Uint8 *area = SDL_reinterpret_cast(Uint8 *, areap);	\
+Uint8 *area = SDL_reinterpret_cast(Uint8 *, areap); \
-	area[0] = (value >> 24) & 0xFF;	\
+area[0] = (value >> 24) & 0xFF; \
-	area[1] = (value >> 16) & 0xFF;	\
+area[1] = (value >> 16) & 0xFF; \
-	area[2] = (value >>  8) & 0xFF;	\
+area[2] = (value >>  8) & 0xFF; \
-	area[3] =  value       & 0xFF;	\
+area[3] =  value       & 0xFF;  \
 } while ( 0 )
 #else
-#define SDLNet_Write32(value, areap) 	\
+#define SDLNet_Write32(value, areap)    \
-do					\
+do                  \
-{					\
+{                   \
-	Uint8 *area = SDL_reinterpret_cast(Uint8 *, areap);	\
+Uint8 *area = SDL_reinterpret_cast(Uint8 *, areap); \
-	area[3] = (value >> 24) & 0xFF;	\
+area[3] = (value >> 24) & 0xFF; \
-	area[2] = (value >> 16) & 0xFF;	\
+area[2] = (value >> 16) & 0xFF; \
-	area[1] = (value >>  8) & 0xFF;	\
+area[1] = (value >>  8) & 0xFF; \
-	area[0] =  value       & 0xFF;	\
+area[0] =  value       & 0xFF;  \
 } while ( 0 )
 #endif
 #endif /* !SDL_DATA_ALIGNED */
 /* Read a 16 bit value from network packet buffer */
 #if !SDL_DATA_ALIGNED
-#define SDLNet_Read16(areap) 		\
+#define SDLNet_Read16(areap)        \
-	(SDL_SwapBE16(*SDL_reinterpret_cast(Uint16 *, areap)))
+(SDL_SwapBE16(*SDL_reinterpret_cast(Uint16 *, areap)))
 #else
 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-#define SDLNet_Read16(areap) 		\
+#define SDLNet_Read16(areap)        \
-	(((SDL_reinterpret_cast(Uint8 *, areap))[0] <<  8) | (SDL_reinterpret_cast(Uint8 *, areap))[1] <<  0)
+(((SDL_reinterpret_cast(Uint8 *, areap))[0] <<  8) | (SDL_reinterpret_cast(Uint8 *, areap))[1] <<  0)
 #else
-#define SDLNet_Read16(areap) 		\
+#define SDLNet_Read16(areap)        \
-	(((SDL_reinterpret_cast(Uint8 *, areap))[1] <<  8) | (SDL_reinterpret_cast(Uint8 *, areap))[0] <<  0)
+(((SDL_reinterpret_cast(Uint8 *, areap))[1] <<  8) | (SDL_reinterpret_cast(Uint8 *, areap))[0] <<  0)
 #endif
 #endif /* !SDL_DATA_ALIGNED */
 /* Read a 32 bit value from network packet buffer */
 #if !SDL_DATA_ALIGNED
-#define SDLNet_Read32(areap) 		\
+#define SDLNet_Read32(areap)        \
-	(SDL_SwapBE32(*SDL_reinterpret_cast(Uint32 *, areap)))
+(SDL_SwapBE32(*SDL_reinterpret_cast(Uint32 *, areap)))
 #else
 #if SDL_BYTEORDER == SDL_BIG_ENDIAN
-#define SDLNet_Read32(areap) 		\
+#define SDLNet_Read32(areap)        \
-	(((SDL_reinterpret_cast(Uint8 *, areap))[0] << 24) | ((SDL_reinterpret_cast(Uint8 *, areap))[1] << 16) | \
+(((SDL_reinterpret_cast(Uint8 *, areap))[0] << 24) | ((SDL_reinterpret_cast(Uint8 *, areap))[1] << 16) | \
-	 ((SDL_reinterpret_cast(Uint8 *, areap))[2] <<  8) |  (SDL_reinterpret_cast(Uint8 *, areap))[3] <<  0)
+((SDL_reinterpret_cast(Uint8 *, areap))[2] <<  8) |  (SDL_reinterpret_cast(Uint8 *, areap))[3] <<  0)
 #else
-#define SDLNet_Read32(areap) 		\
+#define SDLNet_Read32(areap)        \
-	(((SDL_reinterpret_cast(Uint8 *, areap))[3] << 24) | ((SDL_reinterpret_cast(Uint8 *, areap))[2] << 16) | \
+(((SDL_reinterpret_cast(Uint8 *, areap))[3] << 24) | ((SDL_reinterpret_cast(Uint8 *, areap))[2] << 16) | \
-	 ((SDL_reinterpret_cast(Uint8 *, areap))[1] <<  8) |  (SDL_reinterpret_cast(Uint8 *, areap))[0] <<  0)
+((SDL_reinterpret_cast(Uint8 *, areap))[1] <<  8) |  (SDL_reinterpret_cast(Uint8 *, areap))[0] <<  0)
 #endif
 #endif /* !SDL_DATA_ALIGNED */
 /* Ends C function definitions when using C++ */
 #ifdef __cplusplus

changeset 10017	de822cd3df3a
parent 8083	2edbd01a04a0