diff options
author | Franklin Wei <git@fwei.tk> | 2018-02-07 20:04:46 -0500 |
---|---|---|
committer | Franklin Wei <git@fwei.tk> | 2018-03-12 20:52:01 -0400 |
commit | 6039eb05ba6d82ef56f2868c96654c552d117bf9 (patch) | |
tree | 9db7016bcbf66cfdf7b9bc998d84c6eaff9c8378 /apps/plugins/sdl/src/main/win32/SDL_win32_main.c | |
parent | ef373c03b96b0be08babca581d9f10bccfd4931f (diff) | |
download | rockbox-6039eb05ba6d82ef56f2868c96654c552d117bf9.tar.gz rockbox-6039eb05ba6d82ef56f2868c96654c552d117bf9.zip |
sdl: remove non-rockbox drivers
We never use any of these other drivers, so having them around just takes
up space.
Change-Id: Iced812162df1fef3fd55522b7e700acb6c3bcd41
Diffstat (limited to 'apps/plugins/sdl/src/main/win32/SDL_win32_main.c')
-rw-r--r-- | apps/plugins/sdl/src/main/win32/SDL_win32_main.c | 402 |
1 files changed, 0 insertions, 402 deletions
diff --git a/apps/plugins/sdl/src/main/win32/SDL_win32_main.c b/apps/plugins/sdl/src/main/win32/SDL_win32_main.c deleted file mode 100644 index 672b48c12e..0000000000 --- a/apps/plugins/sdl/src/main/win32/SDL_win32_main.c +++ /dev/null | |||
@@ -1,402 +0,0 @@ | |||
1 | /* | ||
2 | SDL_main.c, placed in the public domain by Sam Lantinga 4/13/98 | ||
3 | |||
4 | The WinMain function -- calls your program's main() function | ||
5 | */ | ||
6 | |||
7 | #include <stdio.h> | ||
8 | #include <stdlib.h> | ||
9 | |||
10 | #define WIN32_LEAN_AND_MEAN | ||
11 | #include <windows.h> | ||
12 | |||
13 | #ifdef _WIN32_WCE | ||
14 | # define DIR_SEPERATOR TEXT("\\") | ||
15 | # undef _getcwd | ||
16 | # define _getcwd(str,len) wcscpy(str,TEXT("")) | ||
17 | # define setbuf(f,b) | ||
18 | # define setvbuf(w,x,y,z) | ||
19 | # define fopen _wfopen | ||
20 | # define freopen _wfreopen | ||
21 | # define remove(x) DeleteFile(x) | ||
22 | #else | ||
23 | # define DIR_SEPERATOR TEXT("/") | ||
24 | # include <direct.h> | ||
25 | #endif | ||
26 | |||
27 | /* Include the SDL main definition header */ | ||
28 | #include "SDL.h" | ||
29 | #include "SDL_main.h" | ||
30 | |||
31 | #ifdef main | ||
32 | # ifndef _WIN32_WCE_EMULATION | ||
33 | # undef main | ||
34 | # endif /* _WIN32_WCE_EMULATION */ | ||
35 | #endif /* main */ | ||
36 | |||
37 | /* The standard output files */ | ||
38 | #define STDOUT_FILE TEXT("stdout.txt") | ||
39 | #define STDERR_FILE TEXT("stderr.txt") | ||
40 | |||
41 | /* Set a variable to tell if the stdio redirect has been enabled. */ | ||
42 | static int stdioRedirectEnabled = 0; | ||
43 | |||
44 | #ifdef _WIN32_WCE | ||
45 | static wchar_t stdoutPath[MAX_PATH]; | ||
46 | static wchar_t stderrPath[MAX_PATH]; | ||
47 | #else | ||
48 | static char stdoutPath[MAX_PATH]; | ||
49 | static char stderrPath[MAX_PATH]; | ||
50 | #endif | ||
51 | |||
52 | #if defined(_WIN32_WCE) && _WIN32_WCE < 300 | ||
53 | /* seems to be undefined in Win CE although in online help */ | ||
54 | #define isspace(a) (((CHAR)a == ' ') || ((CHAR)a == '\t')) | ||
55 | #endif /* _WIN32_WCE < 300 */ | ||
56 | |||
57 | static void UnEscapeQuotes( char *arg ) | ||
58 | { | ||
59 | char *last = NULL; | ||
60 | |||
61 | while( *arg ) { | ||
62 | if( *arg == '"' && *last == '\\' ) { | ||
63 | char *c_curr = arg; | ||
64 | char *c_last = last; | ||
65 | |||
66 | while( *c_curr ) { | ||
67 | *c_last = *c_curr; | ||
68 | c_last = c_curr; | ||
69 | c_curr++; | ||
70 | } | ||
71 | *c_last = '\0'; | ||
72 | } | ||
73 | last = arg; | ||
74 | arg++; | ||
75 | } | ||
76 | } | ||
77 | |||
78 | /* Parse a command line buffer into arguments */ | ||
79 | static int ParseCommandLine(char *cmdline, char **argv) | ||
80 | { | ||
81 | char *bufp; | ||
82 | char *lastp = NULL; | ||
83 | int argc, last_argc; | ||
84 | |||
85 | argc = last_argc = 0; | ||
86 | for ( bufp = cmdline; *bufp; ) { | ||
87 | /* Skip leading whitespace */ | ||
88 | while ( isspace(*bufp) ) { | ||
89 | ++bufp; | ||
90 | } | ||
91 | /* Skip over argument */ | ||
92 | if ( *bufp == '"' ) { | ||
93 | ++bufp; | ||
94 | if ( *bufp ) { | ||
95 | if ( argv ) { | ||
96 | argv[argc] = bufp; | ||
97 | } | ||
98 | ++argc; | ||
99 | } | ||
100 | /* Skip over word */ | ||
101 | while ( *bufp && ( *bufp != '"' || (lastp && *lastp == '\\') ) ) { | ||
102 | lastp = bufp; | ||
103 | ++bufp; | ||
104 | } | ||
105 | } else { | ||
106 | if ( *bufp ) { | ||
107 | if ( argv ) { | ||
108 | argv[argc] = bufp; | ||
109 | } | ||
110 | ++argc; | ||
111 | } | ||
112 | /* Skip over word */ | ||
113 | while ( *bufp && ! isspace(*bufp) ) { | ||
114 | ++bufp; | ||
115 | } | ||
116 | } | ||
117 | if ( *bufp ) { | ||
118 | if ( argv ) { | ||
119 | *bufp = '\0'; | ||
120 | } | ||
121 | ++bufp; | ||
122 | } | ||
123 | |||
124 | /* Strip out \ from \" sequences */ | ||
125 | if( argv && last_argc != argc ) { | ||
126 | UnEscapeQuotes( argv[last_argc] ); | ||
127 | } | ||
128 | last_argc = argc; | ||
129 | } | ||
130 | if ( argv ) { | ||
131 | argv[argc] = NULL; | ||
132 | } | ||
133 | return(argc); | ||
134 | } | ||
135 | |||
136 | /* Show an error message */ | ||
137 | static void ShowError(const char *title, const char *message) | ||
138 | { | ||
139 | /* If USE_MESSAGEBOX is defined, you need to link with user32.lib */ | ||
140 | #ifdef USE_MESSAGEBOX | ||
141 | MessageBox(NULL, message, title, MB_ICONEXCLAMATION|MB_OK); | ||
142 | #else | ||
143 | fprintf(stderr, "%s: %s\n", title, message); | ||
144 | #endif | ||
145 | } | ||
146 | |||
147 | /* Pop up an out of memory message, returns to Windows */ | ||
148 | static BOOL OutOfMemory(void) | ||
149 | { | ||
150 | ShowError("Fatal Error", "Out of memory - aborting"); | ||
151 | return FALSE; | ||
152 | } | ||
153 | |||
154 | /* SDL_Quit() shouldn't be used with atexit() directly because | ||
155 | calling conventions may differ... */ | ||
156 | static void cleanup(void) | ||
157 | { | ||
158 | SDL_Quit(); | ||
159 | } | ||
160 | |||
161 | /* Remove the output files if there was no output written */ | ||
162 | static void cleanup_output(void) { | ||
163 | FILE *file; | ||
164 | int empty; | ||
165 | |||
166 | /* Flush the output in case anything is queued */ | ||
167 | fclose(stdout); | ||
168 | fclose(stderr); | ||
169 | |||
170 | /* Without redirection we're done */ | ||
171 | if (!stdioRedirectEnabled) { | ||
172 | return; | ||
173 | } | ||
174 | |||
175 | /* See if the files have any output in them */ | ||
176 | if ( stdoutPath[0] ) { | ||
177 | file = fopen(stdoutPath, TEXT("rb")); | ||
178 | if ( file ) { | ||
179 | empty = (fgetc(file) == EOF) ? 1 : 0; | ||
180 | fclose(file); | ||
181 | if ( empty ) { | ||
182 | remove(stdoutPath); | ||
183 | } | ||
184 | } | ||
185 | } | ||
186 | if ( stderrPath[0] ) { | ||
187 | file = fopen(stderrPath, TEXT("rb")); | ||
188 | if ( file ) { | ||
189 | empty = (fgetc(file) == EOF) ? 1 : 0; | ||
190 | fclose(file); | ||
191 | if ( empty ) { | ||
192 | remove(stderrPath); | ||
193 | } | ||
194 | } | ||
195 | } | ||
196 | } | ||
197 | |||
198 | /* Redirect the output (stdout and stderr) to a file */ | ||
199 | static void redirect_output(void) | ||
200 | { | ||
201 | DWORD pathlen; | ||
202 | #ifdef _WIN32_WCE | ||
203 | wchar_t path[MAX_PATH]; | ||
204 | #else | ||
205 | char path[MAX_PATH]; | ||
206 | #endif | ||
207 | FILE *newfp; | ||
208 | |||
209 | pathlen = GetModuleFileName(NULL, path, SDL_arraysize(path)); | ||
210 | while ( pathlen > 0 && path[pathlen] != '\\' ) { | ||
211 | --pathlen; | ||
212 | } | ||
213 | path[pathlen] = '\0'; | ||
214 | |||
215 | #ifdef _WIN32_WCE | ||
216 | wcsncpy( stdoutPath, path, SDL_arraysize(stdoutPath) ); | ||
217 | wcsncat( stdoutPath, DIR_SEPERATOR STDOUT_FILE, SDL_arraysize(stdoutPath) ); | ||
218 | #else | ||
219 | SDL_strlcpy( stdoutPath, path, SDL_arraysize(stdoutPath) ); | ||
220 | SDL_strlcat( stdoutPath, DIR_SEPERATOR STDOUT_FILE, SDL_arraysize(stdoutPath) ); | ||
221 | #endif | ||
222 | |||
223 | /* Redirect standard input and standard output */ | ||
224 | newfp = freopen(stdoutPath, TEXT("w"), stdout); | ||
225 | |||
226 | #ifndef _WIN32_WCE | ||
227 | if ( newfp == NULL ) { /* This happens on NT */ | ||
228 | #if !defined(stdout) | ||
229 | stdout = fopen(stdoutPath, TEXT("w")); | ||
230 | #else | ||
231 | newfp = fopen(stdoutPath, TEXT("w")); | ||
232 | if ( newfp ) { | ||
233 | *stdout = *newfp; | ||
234 | } | ||
235 | #endif | ||
236 | } | ||
237 | #endif /* _WIN32_WCE */ | ||
238 | |||
239 | #ifdef _WIN32_WCE | ||
240 | wcsncpy( stderrPath, path, SDL_arraysize(stdoutPath) ); | ||
241 | wcsncat( stderrPath, DIR_SEPERATOR STDOUT_FILE, SDL_arraysize(stdoutPath) ); | ||
242 | #else | ||
243 | SDL_strlcpy( stderrPath, path, SDL_arraysize(stderrPath) ); | ||
244 | SDL_strlcat( stderrPath, DIR_SEPERATOR STDERR_FILE, SDL_arraysize(stderrPath) ); | ||
245 | #endif | ||
246 | |||
247 | newfp = freopen(stderrPath, TEXT("w"), stderr); | ||
248 | #ifndef _WIN32_WCE | ||
249 | if ( newfp == NULL ) { /* This happens on NT */ | ||
250 | #if !defined(stderr) | ||
251 | stderr = fopen(stderrPath, TEXT("w")); | ||
252 | #else | ||
253 | newfp = fopen(stderrPath, TEXT("w")); | ||
254 | if ( newfp ) { | ||
255 | *stderr = *newfp; | ||
256 | } | ||
257 | #endif | ||
258 | } | ||
259 | #endif /* _WIN32_WCE */ | ||
260 | |||
261 | setvbuf(stdout, NULL, _IOLBF, BUFSIZ); /* Line buffered */ | ||
262 | setbuf(stderr, NULL); /* No buffering */ | ||
263 | stdioRedirectEnabled = 1; | ||
264 | } | ||
265 | |||
266 | #if defined(_MSC_VER) && !defined(_WIN32_WCE) | ||
267 | /* The VC++ compiler needs main defined */ | ||
268 | #define console_main main | ||
269 | #endif | ||
270 | |||
271 | /* This is where execution begins [console apps] */ | ||
272 | int console_main(int argc, char *argv[]) | ||
273 | { | ||
274 | size_t n; | ||
275 | char *bufp, *appname; | ||
276 | int status; | ||
277 | |||
278 | /* Get the class name from argv[0] */ | ||
279 | appname = argv[0]; | ||
280 | if ( (bufp=SDL_strrchr(argv[0], '\\')) != NULL ) { | ||
281 | appname = bufp+1; | ||
282 | } else | ||
283 | if ( (bufp=SDL_strrchr(argv[0], '/')) != NULL ) { | ||
284 | appname = bufp+1; | ||
285 | } | ||
286 | |||
287 | if ( (bufp=SDL_strrchr(appname, '.')) == NULL ) | ||
288 | n = SDL_strlen(appname); | ||
289 | else | ||
290 | n = (bufp-appname); | ||
291 | |||
292 | bufp = SDL_stack_alloc(char, n+1); | ||
293 | if ( bufp == NULL ) { | ||
294 | return OutOfMemory(); | ||
295 | } | ||
296 | SDL_strlcpy(bufp, appname, n+1); | ||
297 | appname = bufp; | ||
298 | |||
299 | /* Load SDL dynamic link library */ | ||
300 | if ( SDL_Init(SDL_INIT_NOPARACHUTE) < 0 ) { | ||
301 | ShowError("WinMain() error", SDL_GetError()); | ||
302 | return(FALSE); | ||
303 | } | ||
304 | atexit(cleanup_output); | ||
305 | atexit(cleanup); | ||
306 | |||
307 | /* Sam: | ||
308 | We still need to pass in the application handle so that | ||
309 | DirectInput will initialize properly when SDL_RegisterApp() | ||
310 | is called later in the video initialization. | ||
311 | */ | ||
312 | SDL_SetModuleHandle(GetModuleHandle(NULL)); | ||
313 | |||
314 | /* Run the application main() code */ | ||
315 | status = SDL_main(argc, argv); | ||
316 | |||
317 | /* Exit cleanly, calling atexit() functions */ | ||
318 | exit(status); | ||
319 | |||
320 | /* Hush little compiler, don't you cry... */ | ||
321 | return 0; | ||
322 | } | ||
323 | |||
324 | /* This is where execution begins [windowed apps] */ | ||
325 | #ifdef _WIN32_WCE | ||
326 | int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPWSTR szCmdLine, int sw) | ||
327 | #else | ||
328 | int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int sw) | ||
329 | #endif | ||
330 | { | ||
331 | HMODULE handle; | ||
332 | char **argv; | ||
333 | int argc; | ||
334 | char *cmdline; | ||
335 | char *env_str; | ||
336 | #ifdef _WIN32_WCE | ||
337 | wchar_t *bufp; | ||
338 | int nLen; | ||
339 | #else | ||
340 | char *bufp; | ||
341 | size_t nLen; | ||
342 | #endif | ||
343 | |||
344 | /* Start up DDHELP.EXE before opening any files, so DDHELP doesn't | ||
345 | keep them open. This is a hack.. hopefully it will be fixed | ||
346 | someday. DDHELP.EXE starts up the first time DDRAW.DLL is loaded. | ||
347 | */ | ||
348 | handle = LoadLibrary(TEXT("DDRAW.DLL")); | ||
349 | if ( handle != NULL ) { | ||
350 | FreeLibrary(handle); | ||
351 | } | ||
352 | |||
353 | /* Check for stdio redirect settings and do the redirection */ | ||
354 | if ((env_str = SDL_getenv("SDL_STDIO_REDIRECT"))) { | ||
355 | if (SDL_atoi(env_str)) { | ||
356 | redirect_output(); | ||
357 | } | ||
358 | } | ||
359 | #ifndef NO_STDIO_REDIRECT | ||
360 | else { | ||
361 | redirect_output(); | ||
362 | } | ||
363 | #endif | ||
364 | |||
365 | #ifdef _WIN32_WCE | ||
366 | nLen = wcslen(szCmdLine)+128+1; | ||
367 | bufp = SDL_stack_alloc(wchar_t, nLen*2); | ||
368 | wcscpy (bufp, TEXT("\"")); | ||
369 | GetModuleFileName(NULL, bufp+1, 128-3); | ||
370 | wcscpy (bufp+wcslen(bufp), TEXT("\" ")); | ||
371 | wcsncpy(bufp+wcslen(bufp), szCmdLine,nLen-wcslen(bufp)); | ||
372 | nLen = wcslen(bufp)+1; | ||
373 | cmdline = SDL_stack_alloc(char, nLen); | ||
374 | if ( cmdline == NULL ) { | ||
375 | return OutOfMemory(); | ||
376 | } | ||
377 | WideCharToMultiByte(CP_ACP, 0, bufp, -1, cmdline, nLen, NULL, NULL); | ||
378 | #else | ||
379 | /* Grab the command line */ | ||
380 | bufp = GetCommandLine(); | ||
381 | nLen = SDL_strlen(bufp)+1; | ||
382 | cmdline = SDL_stack_alloc(char, nLen); | ||
383 | if ( cmdline == NULL ) { | ||
384 | return OutOfMemory(); | ||
385 | } | ||
386 | SDL_strlcpy(cmdline, bufp, nLen); | ||
387 | #endif | ||
388 | |||
389 | /* Parse it into argv and argc */ | ||
390 | argc = ParseCommandLine(cmdline, NULL); | ||
391 | argv = SDL_stack_alloc(char*, argc+1); | ||
392 | if ( argv == NULL ) { | ||
393 | return OutOfMemory(); | ||
394 | } | ||
395 | ParseCommandLine(cmdline, argv); | ||
396 | |||
397 | /* Run the main program (after a little SDL initialization) */ | ||
398 | console_main(argc, argv); | ||
399 | |||
400 | /* Hush little compiler, don't you cry... */ | ||
401 | return 0; | ||
402 | } | ||