SDL - Revision history

Martini at 20:13, 3 April 2017

2017-04-03T20:13:52Z

← Older revision		Revision as of 22:13, 3 April 2017
Line 2:		Line 2:

	Moved to [http://www.edm2.com/index.php/SDL]		Moved to [http://www.edm2.com/index.php/SDL]

			[[Category:Delete]]

Prokushev at 10:10, 20 May 2005

2005-05-20T10:10:22Z

← Older revision		Revision as of 12:10, 20 May 2005
Line 1:		Line 1:
	== Porting SDL applications to OS/2 ==		== Porting SDL applications to OS/2 ==

	~~=== Requirements ===~~		Moved to [http://www.edm2.com/index.php/SDL]

	~~To port SDL applications~~ to ~~OS/2, you'll need the latest SDL binaries~~
	~~and header files from netlabs.org. Currently the OpenWatcom compiler is~~
	~~<b>the<~~/~~b> compiler for the OS~~/~~2 port of SDL, but it should also work~~
	~~with GCC.~~

	~~=== Using the OpenWatcom compiler ===~~

	~~There are some requirements and tricks with using the OpenWatcom compiler~~
	~~to port SDL applications. You should note the followings things.~~

	~~==== Use the -ei switch for the OpenWatcom C compiler ====~~

	~~You have to use the <i>-ei</i> switch for the OpenWatcom C compiler to~~
	~~have the size of enums equal to the size of ints. This is a requirement of~~
	~~SDL itself.~~

	~~==== Wrapping the SDL_Quit() function ====~~

	~~The OS/2 version of SDL is compiled into a DLL file. This DLL file has all~~
	~~the SDL functions exported by name. In order to be able to use this DLL from~~
	~~most of the available compilers, these exports are using the <i>_Syscall</i>~~
	~~calling convention. This leads to problems with some SDL apps, where they assume~~
	~~that the calling convention of the API is the same as the calling convention of~~
	~~their runtime library. For example, the following line is very usual in SDL~~
	~~applications:~~

	...
	~~atexit(SDL_Quit);~~
	...

	~~This should be worked around by creating a wrapper function for SDL_Quit, and~~
	~~using that one, this way:~~

	~~#ifdef __WATCOMC__~~
	~~void SDL_Quit_Wrapper()~~
	{
	~~SDL_Quit();~~
	}
	~~#endif~~
	~~...~~
	~~#ifdef __WATCOMC__~~
	~~atexit(SDL_Quit_Wrapper);~~
	~~#else~~
	~~atexit(SDL_Quit);~~
	~~#endif;~~

	~~=== Using the GNU C Compiler ===~~

	~~It was reported that some (or maybe all) of the GNU C compilers~~
	~~(GCC) available for OS~~/~~2 can not handle the SDL~~.~~LIB file included in~~
	~~the SDL DevPack. The problem is that the SDL.LIB file was created~~
	~~directly from the SDL.DLL file, using the IMPLIB.EXE tool from the~~
	OS/~~2 Developer's Toolkit, and the GCC does not recognize it to be a~~
	~~valid library file.~~

	~~There is a workaround, which is reported to work in this case. One has~~
	~~to create a GCC-compatible library file (.a), using the EMXIMP tool,~~
	~~and link against that file:~~

	~~emximp -o sdl.imp sdl.lib~~
	~~emximp -o sdl.a sdl.imp~~

	~~If you plan on using~~ SDL~~'s multithreading capabilities (e.g. if you want~~
	~~to include "SDL_thread.h"), be sure that enable multithreading with -Zmt~~
	~~on your GCC commandline, otherwise you'll get an error because _beginthread()~~
	~~and _endthread() will not be defined.~~

	~~=== General tips and tricks ===~~

	~~==== Morph your program to a PM program at runtime ====~~

	~~Most SDL applications assume that they can write to STDOUT, and the user will~~
	~~see it. In OS/2, you have to compile your application to a PM application in~~
	~~order to be able to have a PM Window, but the STDOUT will go to NULL in this~~
	~~case. The solution is to compile your code to a VIO application, and morph the~~
	~~application to a PM one dynamically, at runtime, before calling SDL_Init().~~

	~~Once you have your text output back, you might use it for showing debug messages.~~
	~~If you do so, it's a good idea to make the STDOUT and STDERR unbuffered, so~~
	~~the debug messages will be shown right at the time when the printf() is called,~~
	~~so every message will be visible even in case of a crash.~~

	~~Here is an example code on how to morph your VIO application to a PM one~~
	~~dynamically, at runtime, and how to set STDOUT and STDERR unbuffered:~~

	~~#define INCL_DOS~~
	~~#include <os2.h>~~
	~~#include <stdio.h>~~

	~~...~~

	~~void MorphToPM()~~
	{
	~~PPIB pib;~~
	~~PTIB tib;~~

	~~DosGetInfoBlocks(&tib, &pib);~~

	~~// Change flag from VIO to PM:~~
	~~if (pib->pib_ultype==2) pib->pib_ultype = 3;~~
	}

	~~...~~

	~~int main(int argc, char *argv[~~])
	{
	~~MorphToPM(); // Morph the VIO application to a PM one to be able to use Win* functions~~

	~~// Make stdout and stderr unbuffered~~
	~~setbuf( stdout, NULL );~~
	~~setbuf( stderr, NULL );~~

	~~/* Initialize SDL */~~
	~~if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {~~
	~~fprintf(stderr, "Couldn't initialize SDL: %s\n",SDL_GetError());~~
	~~exit(1);~~
	}

	~~...~~

213.134.8.180: /* Morph your program to a PM program at runtime */

2004-10-05T07:36:53Z

Morph your program to a PM program at runtime

← Older revision		Revision as of 09:36, 5 October 2004
Line 79:		Line 79:
	case. The solution is to compile your code to a VIO application, and morph the		case. The solution is to compile your code to a VIO application, and morph the
	application to a PM one dynamically, at runtime, before calling SDL_Init().		application to a PM one dynamically, at runtime, before calling SDL_Init().

			Once you have your text output back, you might use it for showing debug messages.
			If you do so, it's a good idea to make the STDOUT and STDERR unbuffered, so
			the debug messages will be shown right at the time when the printf() is called,
			so every message will be visible even in case of a crash.

			Here is an example code on how to morph your VIO application to a PM one
			dynamically, at runtime, and how to set STDOUT and STDERR unbuffered:

			#define INCL_DOS
			#include <os2.h>
			#include <stdio.h>

			...

			void MorphToPM()
			{
			PPIB pib;
			PTIB tib;

			DosGetInfoBlocks(&tib, &pib);

			// Change flag from VIO to PM:
			if (pib->pib_ultype==2) pib->pib_ultype = 3;
			}

			...

			int main(int argc, char *argv[])
			{
			MorphToPM(); // Morph the VIO application to a PM one to be able to use Win* functions

			// Make stdout and stderr unbuffered
			setbuf( stdout, NULL );
			setbuf( stderr, NULL );

			/* Initialize SDL */
			if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
			fprintf(stderr, "Couldn't initialize SDL: %s\n",SDL_GetError());
			exit(1);
			}

			...

158.222.226.172: /* Using the GNU C Compiler */

2004-08-29T22:36:02Z

Using the GNU C Compiler

← Older revision		Revision as of 00:36, 30 August 2004
Line 64:		Line 64:
	emximp -o sdl.imp sdl.lib		emximp -o sdl.imp sdl.lib
	emximp -o sdl.a sdl.imp		emximp -o sdl.a sdl.imp

			If you plan on using SDL's multithreading capabilities (e.g. if you want
			to include "SDL_thread.h"), be sure that enable multithreading with -Zmt
			on your GCC commandline, otherwise you'll get an error because _beginthread()
			and _endthread() will not be defined.

	=== General tips and tricks ===		=== General tips and tricks ===

213.134.8.180: /* Using the GNU C Compiler */

2004-07-29T09:29:00Z

Using the GNU C Compiler

@@ Line 51: / Line 51: @@
 === Using the GNU C Compiler ===
-Hmm, needs somebody who has experiences with it. :)
+It was reported that some (or maybe all) of the GNU C compilers
 === General tips and tricks ===

213.134.8.180 at 15:57, 6 July 2004

2004-07-06T15:57:14Z

← Older revision		Revision as of 17:57, 6 July 2004
Line 23:		Line 23:
	The OS/2 version of SDL is compiled into a DLL file. This DLL file has all		The OS/2 version of SDL is compiled into a DLL file. This DLL file has all
	the SDL functions exported by name. In order to be able to use this DLL from		the SDL functions exported by name. In order to be able to use this DLL from
	the ~~most~~ compilers, these exports are using the <i>_Syscall</i> calling		most of the available compilers, these exports are using the <i>_Syscall</i>
	convention. This leads to problems with some SDL apps, where they assume that		calling convention. This leads to problems with some SDL apps, where they assume
	the calling convention of the API is the same as the calling convention of		that the calling convention of the API is the same as the calling convention of
	their runtime library. For example, the following line is very usual in SDL		their runtime library. For example, the following line is very usual in SDL
	applications:		applications:

	...		...
	~~exit~~(SDL_Quit);		atexit(SDL_Quit);
	...		...

Line 44:		Line 44:
	...		...
	#ifdef __WATCOMC__		#ifdef __WATCOMC__
	~~exit~~(SDL_Quit_Wrapper);		atexit(SDL_Quit_Wrapper);
	#else		#else
	~~exit~~(SDL_Quit);		atexit(SDL_Quit);
	#endif;		#endif;

Ktk at 15:56, 6 July 2004

2004-07-06T15:56:20Z

← Older revision		Revision as of 17:56, 6 July 2004
Line 4:		Line 4:

	To port SDL applications to OS/2, you'll need the latest SDL binaries		To port SDL applications to OS/2, you'll need the latest SDL binaries
	and header files from ~~Netlabs~~. Currently the OpenWatcom compiler is		and header files from netlabs.org. Currently the OpenWatcom compiler is
	<b>the</b> compiler for the OS/2 port of SDL, but it should also work		<b>the</b> compiler for the OS/2 port of SDL, but it should also work
	with GCC.		with GCC.

213.134.8.180 at 15:53, 6 July 2004

2004-07-06T15:53:33Z

New page

== Porting SDL applications to OS/2 ==

=== Requirements ===

To port SDL applications to OS/2, you'll need the latest SDL binaries
and header files from Netlabs. Currently the OpenWatcom compiler is
the compiler for the OS/2 port of SDL, but it should also work
with GCC.

=== Using the OpenWatcom compiler ===

There are some requirements and tricks with using the OpenWatcom compiler
to port SDL applications. You should note the followings things.

==== Use the -ei switch for the OpenWatcom C compiler ====

You have to use the -ei switch for the OpenWatcom C compiler to
have the size of enums equal to the size of ints. This is a requirement of
SDL itself.

==== Wrapping the SDL_Quit() function ====

The OS/2 version of SDL is compiled into a DLL file. This DLL file has all
the SDL functions exported by name. In order to be able to use this DLL from
the most compilers, these exports are using the _Syscall calling
convention. This leads to problems with some SDL apps, where they assume that
the calling convention of the API is the same as the calling convention of
their runtime library. For example, the following line is very usual in SDL
applications:

...
exit(SDL_Quit);
...

This should be worked around by creating a wrapper function for SDL_Quit, and
using that one, this way:

#ifdef __WATCOMC__
void SDL_Quit_Wrapper()
{
SDL_Quit();
}
#endif
...
#ifdef __WATCOMC__
exit(SDL_Quit_Wrapper);
#else
exit(SDL_Quit);
#endif;

=== Using the GNU C Compiler ===

Hmm, needs somebody who has experiences with it. :)

=== General tips and tricks ===

==== Morph your program to a PM program at runtime ====

Most SDL applications assume that they can write to STDOUT, and the user will
see it. In OS/2, you have to compile your application to a PM application in
order to be able to have a PM Window, but the STDOUT will go to NULL in this
case. The solution is to compile your code to a VIO application, and morph the
application to a PM one dynamically, at runtime, before calling SDL_Init().