Mercurial > repos > blastem
annotate util.c @ 1483:001120e91fed nuklear_ui
Skip loading menu ROM if Nuklear UI is enabled. Allow disabling Nuklear UI in favor of old menu ROM both at compile time and in config. Fall back to ROM UI if GL is unavailable
author | Michael Pavone <pavone@retrodev.com> |
---|---|
date | Sat, 25 Nov 2017 20:43:20 -0800 |
parents | e2bd03ed3190 |
children | d82af64c94d2 |
rev | line source |
---|---|
495
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
1 #include <string.h> |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
2 #include <stdlib.h> |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
3 #include <stdio.h> |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
4 #include <ctype.h> |
768
2f48a3c187c6
Add support for reading cartridge memory map from ROM database, though without EEPROM support for now
Michael Pavone <pavone@retrodev.com>
parents:
762
diff
changeset
|
5 #include <stdint.h> |
805 | 6 #include <stdarg.h> |
495
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
7 |
496
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
8 #include <sys/types.h> |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
9 #include <sys/stat.h> |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
10 #include <unistd.h> |
955
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
11 #include <errno.h> |
496
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
12 |
879
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
13 #ifdef __ANDROID__ |
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
14 #include <android/log.h> |
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
15 #define info_puts(msg) __android_log_write(ANDROID_LOG_INFO, "BlastEm", msg) |
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
16 #define warning_puts(msg) __android_log_write(ANDROID_LOG_WARN, "BlastEm", msg) |
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
17 #define fatal_puts(msg) __android_log_write(ANDROID_LOG_FATAL, "BlastEm", msg) |
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
18 |
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
19 #define info_printf(msg, args) __android_log_vprint(ANDROID_LOG_INFO, "BlastEm", msg, args) |
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
20 #define warning_printf(msg, args) __android_log_vprint(ANDROID_LOG_WARN, "BlastEm", msg, args) |
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
21 #define fatal_printf(msg, args) __android_log_vprint(ANDROID_LOG_FATAL, "BlastEm", msg, args) |
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
22 #else |
884
252dfd29831d
Selecting a second game from the menu now works
Michael Pavone <pavone@retrodev.com>
parents:
883
diff
changeset
|
23 #define info_puts(msg) fputs(msg, stdout); |
252dfd29831d
Selecting a second game from the menu now works
Michael Pavone <pavone@retrodev.com>
parents:
883
diff
changeset
|
24 #define warning_puts(msg) fputs(msg, stderr); |
252dfd29831d
Selecting a second game from the menu now works
Michael Pavone <pavone@retrodev.com>
parents:
883
diff
changeset
|
25 #define fatal_puts(msg) fputs(msg, stderr); |
879
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
26 |
883
9f149f0e98b7
It is now possible to switch back and forth between the menu ROM and the game
Michael Pavone <pavone@retrodev.com>
parents:
879
diff
changeset
|
27 #define info_printf(msg, args) vprintf(msg, args) |
9f149f0e98b7
It is now possible to switch back and forth between the menu ROM and the game
Michael Pavone <pavone@retrodev.com>
parents:
879
diff
changeset
|
28 #define warning_printf(msg, args) vfprintf(stderr, msg, args) |
9f149f0e98b7
It is now possible to switch back and forth between the menu ROM and the game
Michael Pavone <pavone@retrodev.com>
parents:
879
diff
changeset
|
29 #define fatal_printf(msg, args) vfprintf(stderr, msg, args) |
879
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
30 #endif |
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
31 |
792
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
32 #include "blastem.h" //for headless global |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
33 #include "render.h" //for render_errorbox |
866
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
34 #include "util.h" |
792
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
35 |
876
540cc4a7d626
Fix Android build breakage
Michael Pavone <pavone@retrodev.com>
parents:
875
diff
changeset
|
36 char * alloc_concat(char const * first, char const * second) |
495
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
37 { |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
38 int flen = strlen(first); |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
39 int slen = strlen(second); |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
40 char * ret = malloc(flen + slen + 1); |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
41 memcpy(ret, first, flen); |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
42 memcpy(ret+flen, second, slen+1); |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
43 return ret; |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
44 } |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
45 |
876
540cc4a7d626
Fix Android build breakage
Michael Pavone <pavone@retrodev.com>
parents:
875
diff
changeset
|
46 char * alloc_concat_m(int num_parts, char const ** parts) |
495
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
47 { |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
48 int total = 0; |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
49 for (int i = 0; i < num_parts; i++) { |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
50 total += strlen(parts[i]); |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
51 } |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
52 char * ret = malloc(total + 1); |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
53 *ret = 0; |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
54 for (int i = 0; i < num_parts; i++) { |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
55 strcat(ret, parts[i]); |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
56 } |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
57 return ret; |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
58 } |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
59 |
1292
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
60 typedef struct { |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
61 uint32_t start; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
62 uint32_t end; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
63 char *value; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
64 } var_pos; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
65 |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
66 char *replace_vars(char *base, tern_node *vars, uint8_t allow_env) |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
67 { |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
68 uint32_t num_vars = 0; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
69 for (char *cur = base; *cur; ++cur) |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
70 { |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
71 //TODO: Support escaping $ and allow brace syntax |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
72 if (*cur == '$') { |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
73 num_vars++; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
74 } |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
75 } |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
76 var_pos *positions = calloc(num_vars, sizeof(var_pos)); |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
77 num_vars = 0; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
78 uint8_t in_var = 0; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
79 uint32_t max_var_len = 0; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
80 for (char *cur = base; *cur; ++cur) |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
81 { |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
82 if (in_var) { |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
83 if (!(*cur == '_' || isalnum(*cur))) { |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
84 positions[num_vars].end = cur-base; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
85 if (positions[num_vars].end - positions[num_vars].start > max_var_len) { |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
86 max_var_len = positions[num_vars].end - positions[num_vars].start; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
87 } |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
88 num_vars++; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
89 in_var = 0; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
90 } |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
91 } else if (*cur == '$') { |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
92 positions[num_vars].start = cur-base+1; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
93 in_var = 1; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
94 } |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
95 } |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
96 if (in_var) { |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
97 positions[num_vars].end = strlen(base); |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
98 if (positions[num_vars].end - positions[num_vars].start > max_var_len) { |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
99 max_var_len = positions[num_vars].end - positions[num_vars].start; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
100 } |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
101 num_vars++; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
102 } |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
103 char *varname = malloc(max_var_len+1); |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
104 uint32_t total_len = 0; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
105 uint32_t cur = 0; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
106 for (uint32_t i = 0; i < num_vars; i++) |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
107 { |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
108 total_len += (positions[i].start - 1) - cur; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
109 cur = positions[i].start; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
110 memcpy(varname, base + positions[i].start, positions[i].end-positions[i].start); |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
111 varname[positions[i].end-positions[i].start] = 0; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
112 positions[i].value = tern_find_ptr(vars, varname); |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
113 if (!positions[i].value && allow_env) { |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
114 positions[i].value = getenv(varname); |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
115 } |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
116 if (positions[i].value) { |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
117 total_len += strlen(positions[i].value); |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
118 } |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
119 } |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
120 total_len += strlen(base+cur); |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
121 free(varname); |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
122 char *output = malloc(total_len+1); |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
123 cur = 0; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
124 char *curout = output; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
125 for (uint32_t i = 0; i < num_vars; i++) |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
126 { |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
127 if (positions[i].start-1 > cur) { |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
128 memcpy(curout, base + cur, (positions[i].start-1) - cur); |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
129 curout += (positions[i].start-1) - cur; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
130 } |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
131 if (positions[i].value) { |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
132 strcpy(curout, positions[i].value); |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
133 curout += strlen(curout); |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
134 } |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
135 cur = positions[i].end; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
136 }; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
137 if (base[cur]) { |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
138 strcpy(curout, base+cur); |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
139 } else { |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
140 *curout = 0; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
141 } |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
142 free(positions); |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
143 return output; |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
144 } |
5905593d6828
Allow initial_path to contain variable references which allows the default value to be actually specified in the default config file
Michael Pavone <pavone@retrodev.com>
parents:
1265
diff
changeset
|
145 |
1103
22e87b739ad6
WIP split of ROM loading/argument parsing from Genesis emulation code. Compiles and doesn't crash, but nothing works. Still a few too many globals as well.
Michael Pavone <pavone@retrodev.com>
parents:
1058
diff
changeset
|
146 void byteswap_rom(int filesize, uint16_t *cart) |
22e87b739ad6
WIP split of ROM loading/argument parsing from Genesis emulation code. Compiles and doesn't crash, but nothing works. Still a few too many globals as well.
Michael Pavone <pavone@retrodev.com>
parents:
1058
diff
changeset
|
147 { |
22e87b739ad6
WIP split of ROM loading/argument parsing from Genesis emulation code. Compiles and doesn't crash, but nothing works. Still a few too many globals as well.
Michael Pavone <pavone@retrodev.com>
parents:
1058
diff
changeset
|
148 for(uint16_t *cur = cart; cur - cart < filesize/2; ++cur) |
22e87b739ad6
WIP split of ROM loading/argument parsing from Genesis emulation code. Compiles and doesn't crash, but nothing works. Still a few too many globals as well.
Michael Pavone <pavone@retrodev.com>
parents:
1058
diff
changeset
|
149 { |
22e87b739ad6
WIP split of ROM loading/argument parsing from Genesis emulation code. Compiles and doesn't crash, but nothing works. Still a few too many globals as well.
Michael Pavone <pavone@retrodev.com>
parents:
1058
diff
changeset
|
150 *cur = (*cur >> 8) | (*cur << 8); |
22e87b739ad6
WIP split of ROM loading/argument parsing from Genesis emulation code. Compiles and doesn't crash, but nothing works. Still a few too many globals as well.
Michael Pavone <pavone@retrodev.com>
parents:
1058
diff
changeset
|
151 } |
22e87b739ad6
WIP split of ROM loading/argument parsing from Genesis emulation code. Compiles and doesn't crash, but nothing works. Still a few too many globals as well.
Michael Pavone <pavone@retrodev.com>
parents:
1058
diff
changeset
|
152 } |
22e87b739ad6
WIP split of ROM loading/argument parsing from Genesis emulation code. Compiles and doesn't crash, but nothing works. Still a few too many globals as well.
Michael Pavone <pavone@retrodev.com>
parents:
1058
diff
changeset
|
153 |
22e87b739ad6
WIP split of ROM loading/argument parsing from Genesis emulation code. Compiles and doesn't crash, but nothing works. Still a few too many globals as well.
Michael Pavone <pavone@retrodev.com>
parents:
1058
diff
changeset
|
154 |
495
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
155 long file_size(FILE * f) |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
156 { |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
157 fseek(f, 0, SEEK_END); |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
158 long fsize = ftell(f); |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
159 fseek(f, 0, SEEK_SET); |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
160 return fsize; |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
161 } |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
162 |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
163 char * strip_ws(char * text) |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
164 { |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
165 while (*text && (!isprint(*text) || isblank(*text))) |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
166 { |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
167 text++; |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
168 } |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
169 char * ret = text; |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
170 text = ret + strlen(ret) - 1; |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
171 while (text > ret && (!isprint(*text) || isblank(*text))) |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
172 { |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
173 *text = 0; |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
174 text--; |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
175 } |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
176 return ret; |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
177 } |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
178 |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
179 char * split_keyval(char * text) |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
180 { |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
181 while (*text && !isblank(*text)) |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
182 { |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
183 text++; |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
184 } |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
185 if (!*text) { |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
186 return text; |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
187 } |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
188 *text = 0; |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
189 return text+1; |
39cad98d2789
Allow OpenGL support to be disabled at compile time. Move generic utility functions out of config.c
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
190 } |
496
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
191 |
1305
5ceb316c479a
Allow games to be specified in ROM DB via sha1 instead of product ID. Added a new ROM DB memory map device type fixed for emulating simple fixed value copy protection registers. Used those two features to support Ya Se Chuan Shuo via a ROM DB entry.
Michael Pavone <pavone@retrodev.com>
parents:
1295
diff
changeset
|
192 void bin_to_hex(uint8_t *output, uint8_t *input, uint64_t size) |
5ceb316c479a
Allow games to be specified in ROM DB via sha1 instead of product ID. Added a new ROM DB memory map device type fixed for emulating simple fixed value copy protection registers. Used those two features to support Ya Se Chuan Shuo via a ROM DB entry.
Michael Pavone <pavone@retrodev.com>
parents:
1295
diff
changeset
|
193 { |
5ceb316c479a
Allow games to be specified in ROM DB via sha1 instead of product ID. Added a new ROM DB memory map device type fixed for emulating simple fixed value copy protection registers. Used those two features to support Ya Se Chuan Shuo via a ROM DB entry.
Michael Pavone <pavone@retrodev.com>
parents:
1295
diff
changeset
|
194 while (size) |
5ceb316c479a
Allow games to be specified in ROM DB via sha1 instead of product ID. Added a new ROM DB memory map device type fixed for emulating simple fixed value copy protection registers. Used those two features to support Ya Se Chuan Shuo via a ROM DB entry.
Michael Pavone <pavone@retrodev.com>
parents:
1295
diff
changeset
|
195 { |
5ceb316c479a
Allow games to be specified in ROM DB via sha1 instead of product ID. Added a new ROM DB memory map device type fixed for emulating simple fixed value copy protection registers. Used those two features to support Ya Se Chuan Shuo via a ROM DB entry.
Michael Pavone <pavone@retrodev.com>
parents:
1295
diff
changeset
|
196 uint8_t digit = *input >> 4; |
5ceb316c479a
Allow games to be specified in ROM DB via sha1 instead of product ID. Added a new ROM DB memory map device type fixed for emulating simple fixed value copy protection registers. Used those two features to support Ya Se Chuan Shuo via a ROM DB entry.
Michael Pavone <pavone@retrodev.com>
parents:
1295
diff
changeset
|
197 digit += digit > 9 ? 'a' - 0xa : '0'; |
5ceb316c479a
Allow games to be specified in ROM DB via sha1 instead of product ID. Added a new ROM DB memory map device type fixed for emulating simple fixed value copy protection registers. Used those two features to support Ya Se Chuan Shuo via a ROM DB entry.
Michael Pavone <pavone@retrodev.com>
parents:
1295
diff
changeset
|
198 *(output++) = digit; |
5ceb316c479a
Allow games to be specified in ROM DB via sha1 instead of product ID. Added a new ROM DB memory map device type fixed for emulating simple fixed value copy protection registers. Used those two features to support Ya Se Chuan Shuo via a ROM DB entry.
Michael Pavone <pavone@retrodev.com>
parents:
1295
diff
changeset
|
199 digit = *(input++) & 0xF; |
5ceb316c479a
Allow games to be specified in ROM DB via sha1 instead of product ID. Added a new ROM DB memory map device type fixed for emulating simple fixed value copy protection registers. Used those two features to support Ya Se Chuan Shuo via a ROM DB entry.
Michael Pavone <pavone@retrodev.com>
parents:
1295
diff
changeset
|
200 digit += digit > 9 ? 'a' - 0xa : '0'; |
5ceb316c479a
Allow games to be specified in ROM DB via sha1 instead of product ID. Added a new ROM DB memory map device type fixed for emulating simple fixed value copy protection registers. Used those two features to support Ya Se Chuan Shuo via a ROM DB entry.
Michael Pavone <pavone@retrodev.com>
parents:
1295
diff
changeset
|
201 *(output++) = digit; |
5ceb316c479a
Allow games to be specified in ROM DB via sha1 instead of product ID. Added a new ROM DB memory map device type fixed for emulating simple fixed value copy protection registers. Used those two features to support Ya Se Chuan Shuo via a ROM DB entry.
Michael Pavone <pavone@retrodev.com>
parents:
1295
diff
changeset
|
202 size--; |
5ceb316c479a
Allow games to be specified in ROM DB via sha1 instead of product ID. Added a new ROM DB memory map device type fixed for emulating simple fixed value copy protection registers. Used those two features to support Ya Se Chuan Shuo via a ROM DB entry.
Michael Pavone <pavone@retrodev.com>
parents:
1295
diff
changeset
|
203 } |
5ceb316c479a
Allow games to be specified in ROM DB via sha1 instead of product ID. Added a new ROM DB memory map device type fixed for emulating simple fixed value copy protection registers. Used those two features to support Ya Se Chuan Shuo via a ROM DB entry.
Michael Pavone <pavone@retrodev.com>
parents:
1295
diff
changeset
|
204 *(output++) = 0; |
5ceb316c479a
Allow games to be specified in ROM DB via sha1 instead of product ID. Added a new ROM DB memory map device type fixed for emulating simple fixed value copy protection registers. Used those two features to support Ya Se Chuan Shuo via a ROM DB entry.
Michael Pavone <pavone@retrodev.com>
parents:
1295
diff
changeset
|
205 } |
5ceb316c479a
Allow games to be specified in ROM DB via sha1 instead of product ID. Added a new ROM DB memory map device type fixed for emulating simple fixed value copy protection registers. Used those two features to support Ya Se Chuan Shuo via a ROM DB entry.
Michael Pavone <pavone@retrodev.com>
parents:
1295
diff
changeset
|
206 |
1008
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
207 char is_path_sep(char c) |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
208 { |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
209 #ifdef _WIN32 |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
210 if (c == '\\') { |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
211 return 1; |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
212 } |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
213 #endif |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
214 return c == '/'; |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
215 } |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
216 |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
217 char is_absolute_path(char *path) |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
218 { |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
219 #ifdef _WIN32 |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
220 if (path[1] == ':' && is_path_sep(path[2]) && isalpha(path[0])) { |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
221 return 1; |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
222 } |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
223 #endif |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
224 return is_path_sep(path[0]); |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
225 } |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
226 |
955
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
227 char * basename_no_extension(char *path) |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
228 { |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
229 char *lastdot = NULL; |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
230 char *lastslash = NULL; |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
231 char *cur; |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
232 for (cur = path; *cur; cur++) |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
233 { |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
234 if (*cur == '.') { |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
235 lastdot = cur; |
1008
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
236 } else if (is_path_sep(*cur)) { |
955
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
237 lastslash = cur + 1; |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
238 } |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
239 } |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
240 if (!lastdot) { |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
241 lastdot = cur; |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
242 } |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
243 if (!lastslash) { |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
244 lastslash = path; |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
245 } |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
246 char *barename = malloc(lastdot-lastslash+1); |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
247 memcpy(barename, lastslash, lastdot-lastslash); |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
248 barename[lastdot-lastslash] = 0; |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
249 |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
250 return barename; |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
251 } |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
252 |
1140
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
253 char *path_extension(char *path) |
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
254 { |
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
255 char *lastdot = NULL; |
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
256 char *lastslash = NULL; |
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
257 char *cur; |
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
258 for (cur = path; *cur; cur++) |
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
259 { |
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
260 if (*cur == '.') { |
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
261 lastdot = cur; |
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
262 } else if (is_path_sep(*cur)) { |
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
263 lastslash = cur + 1; |
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
264 } |
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
265 } |
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
266 if (!lastdot || (lastslash && lastslash > lastdot)) { |
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
267 //no extension |
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
268 return NULL; |
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
269 } |
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
270 return strdup(lastdot+1); |
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
271 } |
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
272 |
1438
e2bd03ed3190
Allow reloading current ROM with a hotkey (default F5) and allow locking on a cartridge via menu
Michael Pavone <pavone@retrodev.com>
parents:
1305
diff
changeset
|
273 char * path_dirname(char *path) |
e2bd03ed3190
Allow reloading current ROM with a hotkey (default F5) and allow locking on a cartridge via menu
Michael Pavone <pavone@retrodev.com>
parents:
1305
diff
changeset
|
274 { |
e2bd03ed3190
Allow reloading current ROM with a hotkey (default F5) and allow locking on a cartridge via menu
Michael Pavone <pavone@retrodev.com>
parents:
1305
diff
changeset
|
275 char *lastslash = NULL; |
e2bd03ed3190
Allow reloading current ROM with a hotkey (default F5) and allow locking on a cartridge via menu
Michael Pavone <pavone@retrodev.com>
parents:
1305
diff
changeset
|
276 char *cur; |
e2bd03ed3190
Allow reloading current ROM with a hotkey (default F5) and allow locking on a cartridge via menu
Michael Pavone <pavone@retrodev.com>
parents:
1305
diff
changeset
|
277 for (cur = path; *cur; cur++) |
e2bd03ed3190
Allow reloading current ROM with a hotkey (default F5) and allow locking on a cartridge via menu
Michael Pavone <pavone@retrodev.com>
parents:
1305
diff
changeset
|
278 { |
e2bd03ed3190
Allow reloading current ROM with a hotkey (default F5) and allow locking on a cartridge via menu
Michael Pavone <pavone@retrodev.com>
parents:
1305
diff
changeset
|
279 if (is_path_sep(*cur)) { |
e2bd03ed3190
Allow reloading current ROM with a hotkey (default F5) and allow locking on a cartridge via menu
Michael Pavone <pavone@retrodev.com>
parents:
1305
diff
changeset
|
280 lastslash = cur; |
e2bd03ed3190
Allow reloading current ROM with a hotkey (default F5) and allow locking on a cartridge via menu
Michael Pavone <pavone@retrodev.com>
parents:
1305
diff
changeset
|
281 } |
e2bd03ed3190
Allow reloading current ROM with a hotkey (default F5) and allow locking on a cartridge via menu
Michael Pavone <pavone@retrodev.com>
parents:
1305
diff
changeset
|
282 } |
e2bd03ed3190
Allow reloading current ROM with a hotkey (default F5) and allow locking on a cartridge via menu
Michael Pavone <pavone@retrodev.com>
parents:
1305
diff
changeset
|
283 if (!lastslash) { |
e2bd03ed3190
Allow reloading current ROM with a hotkey (default F5) and allow locking on a cartridge via menu
Michael Pavone <pavone@retrodev.com>
parents:
1305
diff
changeset
|
284 return NULL; |
e2bd03ed3190
Allow reloading current ROM with a hotkey (default F5) and allow locking on a cartridge via menu
Michael Pavone <pavone@retrodev.com>
parents:
1305
diff
changeset
|
285 } |
e2bd03ed3190
Allow reloading current ROM with a hotkey (default F5) and allow locking on a cartridge via menu
Michael Pavone <pavone@retrodev.com>
parents:
1305
diff
changeset
|
286 char *dir = malloc(lastslash-path+1); |
e2bd03ed3190
Allow reloading current ROM with a hotkey (default F5) and allow locking on a cartridge via menu
Michael Pavone <pavone@retrodev.com>
parents:
1305
diff
changeset
|
287 memcpy(dir, path, lastslash-path); |
e2bd03ed3190
Allow reloading current ROM with a hotkey (default F5) and allow locking on a cartridge via menu
Michael Pavone <pavone@retrodev.com>
parents:
1305
diff
changeset
|
288 dir[lastslash-path] = 0; |
e2bd03ed3190
Allow reloading current ROM with a hotkey (default F5) and allow locking on a cartridge via menu
Michael Pavone <pavone@retrodev.com>
parents:
1305
diff
changeset
|
289 |
e2bd03ed3190
Allow reloading current ROM with a hotkey (default F5) and allow locking on a cartridge via menu
Michael Pavone <pavone@retrodev.com>
parents:
1305
diff
changeset
|
290 return dir; |
e2bd03ed3190
Allow reloading current ROM with a hotkey (default F5) and allow locking on a cartridge via menu
Michael Pavone <pavone@retrodev.com>
parents:
1305
diff
changeset
|
291 } |
e2bd03ed3190
Allow reloading current ROM with a hotkey (default F5) and allow locking on a cartridge via menu
Michael Pavone <pavone@retrodev.com>
parents:
1305
diff
changeset
|
292 |
768
2f48a3c187c6
Add support for reading cartridge memory map from ROM database, though without EEPROM support for now
Michael Pavone <pavone@retrodev.com>
parents:
762
diff
changeset
|
293 uint32_t nearest_pow2(uint32_t val) |
2f48a3c187c6
Add support for reading cartridge memory map from ROM database, though without EEPROM support for now
Michael Pavone <pavone@retrodev.com>
parents:
762
diff
changeset
|
294 { |
2f48a3c187c6
Add support for reading cartridge memory map from ROM database, though without EEPROM support for now
Michael Pavone <pavone@retrodev.com>
parents:
762
diff
changeset
|
295 uint32_t ret = 1; |
2f48a3c187c6
Add support for reading cartridge memory map from ROM database, though without EEPROM support for now
Michael Pavone <pavone@retrodev.com>
parents:
762
diff
changeset
|
296 while (ret < val) |
2f48a3c187c6
Add support for reading cartridge memory map from ROM database, though without EEPROM support for now
Michael Pavone <pavone@retrodev.com>
parents:
762
diff
changeset
|
297 { |
2f48a3c187c6
Add support for reading cartridge memory map from ROM database, though without EEPROM support for now
Michael Pavone <pavone@retrodev.com>
parents:
762
diff
changeset
|
298 ret = ret << 1; |
2f48a3c187c6
Add support for reading cartridge memory map from ROM database, though without EEPROM support for now
Michael Pavone <pavone@retrodev.com>
parents:
762
diff
changeset
|
299 } |
2f48a3c187c6
Add support for reading cartridge memory map from ROM database, though without EEPROM support for now
Michael Pavone <pavone@retrodev.com>
parents:
762
diff
changeset
|
300 return ret; |
2f48a3c187c6
Add support for reading cartridge memory map from ROM database, though without EEPROM support for now
Michael Pavone <pavone@retrodev.com>
parents:
762
diff
changeset
|
301 } |
2f48a3c187c6
Add support for reading cartridge memory map from ROM database, though without EEPROM support for now
Michael Pavone <pavone@retrodev.com>
parents:
762
diff
changeset
|
302 |
496
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
303 static char * exe_str; |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
304 |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
305 void set_exe_str(char * str) |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
306 { |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
307 exe_str = str; |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
308 } |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
309 |
792
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
310 void fatal_error(char *format, ...) |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
311 { |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
312 va_list args; |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
313 va_start(args, format); |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
314 if (!headless) { |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
315 //take a guess at the final size |
1265
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
316 int32_t size = strlen(format) * 2; |
792
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
317 char *buf = malloc(size); |
1265
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
318 int32_t actual = vsnprintf(buf, size, format, args); |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
319 if (actual >= size || actual < 0) { |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
320 if (actual < 0) { |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
321 //seems on windows, vsnprintf is returning -1 when the buffer is too small |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
322 //since we don't know the proper size, a generous multiplier will hopefully suffice |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
323 actual = size * 4; |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
324 } else { |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
325 actual++; |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
326 } |
792
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
327 free(buf); |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
328 buf = malloc(actual); |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
329 va_end(args); |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
330 va_start(args, format); |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
331 vsnprintf(buf, actual, format, args); |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
332 } |
879
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
333 fatal_puts(buf); |
792
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
334 render_errorbox("Fatal Error", buf); |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
335 free(buf); |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
336 } else { |
879
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
337 fatal_printf(format, args); |
792
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
338 } |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
339 va_end(args); |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
340 exit(1); |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
341 } |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
342 |
794
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
343 void warning(char *format, ...) |
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
344 { |
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
345 va_list args; |
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
346 va_start(args, format); |
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
347 #ifndef _WIN32 |
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
348 if (headless || (isatty(STDERR_FILENO) && isatty(STDIN_FILENO))) { |
879
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
349 warning_printf(format, args); |
794
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
350 } else { |
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
351 #endif |
1265
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
352 int32_t size = strlen(format) * 2; |
794
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
353 char *buf = malloc(size); |
1265
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
354 int32_t actual = vsnprintf(buf, size, format, args); |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
355 if (actual >= size || actual < 0) { |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
356 if (actual < 0) { |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
357 //seems on windows, vsnprintf is returning -1 when the buffer is too small |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
358 //since we don't know the proper size, a generous multiplier will hopefully suffice |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
359 actual = size * 4; |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
360 } else { |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
361 actual++; |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
362 } |
794
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
363 free(buf); |
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
364 buf = malloc(actual); |
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
365 va_end(args); |
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
366 va_start(args, format); |
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
367 vsnprintf(buf, actual, format, args); |
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
368 } |
879
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
369 warning_puts(buf); |
794
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
370 render_infobox("BlastEm Info", buf); |
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
371 free(buf); |
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
372 #ifndef _WIN32 |
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
373 } |
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
374 #endif |
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
375 va_end(args); |
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
376 } |
792be135d3af
Spawn a terminal for the debugger when needed if we are not already attached to one
Michael Pavone <pavone@retrodev.com>
parents:
792
diff
changeset
|
377 |
792
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
378 void info_message(char *format, ...) |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
379 { |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
380 va_list args; |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
381 va_start(args, format); |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
382 #ifndef _WIN32 |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
383 if (headless || (isatty(STDOUT_FILENO) && isatty(STDIN_FILENO))) { |
879
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
384 info_printf(format, args); |
792
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
385 } else { |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
386 #endif |
1265
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
387 int32_t size = strlen(format) * 2; |
792
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
388 char *buf = malloc(size); |
1265
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
389 int32_t actual = vsnprintf(buf, size, format, args); |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
390 if (actual >= size || actual < 0) { |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
391 if (actual < 0) { |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
392 //seems on windows, vsnprintf is returning -1 when the buffer is too small |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
393 //since we don't know the proper size, a generous multiplier will hopefully suffice |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
394 actual = size * 4; |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
395 } else { |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
396 actual++; |
a344885e7c79
Fix info_message/warning/error functions to deal with limitations of vsnprintf on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1140
diff
changeset
|
397 } |
792
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
398 free(buf); |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
399 buf = malloc(actual); |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
400 va_end(args); |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
401 va_start(args, format); |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
402 vsnprintf(buf, actual, format, args); |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
403 } |
879
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
404 info_puts(buf); |
792
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
405 render_infobox("BlastEm Info", buf); |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
406 free(buf); |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
407 #ifndef _WIN32 |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
408 } |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
409 #endif |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
410 va_end(args); |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
411 } |
724bbec47f86
Use a new fatal_error function instead of calling fprintf and exit for fatal errors. This new function more gracefully handles the case in which BlastEm was not started from a terminal or disconnected from ther terminal (Windows).
Michael Pavone <pavone@retrodev.com>
parents:
773
diff
changeset
|
412 |
742
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
413 #ifdef _WIN32 |
795
bce97fc0bb8a
Fix mingw-w64 build and cross-compilation
=?UTF-8?q?Higor=20Eur=C3=ADpedes?= <heuripedes@gmail.com>
parents:
773
diff
changeset
|
414 #include <windows.h> |
bce97fc0bb8a
Fix mingw-w64 build and cross-compilation
=?UTF-8?q?Higor=20Eur=C3=ADpedes?= <heuripedes@gmail.com>
parents:
773
diff
changeset
|
415 #include <shlobj.h> |
742
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
416 |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
417 char * get_home_dir() |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
418 { |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
419 static char path[MAX_PATH]; |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
420 SHGetFolderPathA(NULL, CSIDL_PROFILE, NULL, 0, path); |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
421 return path; |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
422 } |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
423 |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
424 char * get_exe_dir() |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
425 { |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
426 static char path[MAX_PATH]; |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
427 HMODULE module = GetModuleHandleA(NULL); |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
428 GetModuleFileNameA(module, path, MAX_PATH); |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
429 |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
430 int pathsize = strlen(path); |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
431 for(char * cur = path + pathsize - 1; cur != path; cur--) |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
432 { |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
433 if (*cur == '\\') { |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
434 *cur = 0; |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
435 break; |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
436 } |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
437 } |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
438 return path; |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
439 } |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
440 |
972
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
441 dir_entry *get_dir_list(char *path, size_t *numret) |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
442 { |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
443 HANDLE dir; |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
444 WIN32_FIND_DATA file; |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
445 char *pattern = alloc_concat(path, "/*.*"); |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
446 dir = FindFirstFile(pattern, &file); |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
447 free(pattern); |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
448 if (dir == INVALID_HANDLE_VALUE) { |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
449 if (numret) { |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
450 *numret = 0; |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
451 } |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
452 return NULL; |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
453 } |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
454 |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
455 size_t storage = 64; |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
456 dir_entry *ret = malloc(sizeof(dir_entry) * storage); |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
457 size_t pos = 0; |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
458 |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
459 do { |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
460 if (pos == storage) { |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
461 storage = storage * 2; |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
462 ret = realloc(ret, sizeof(dir_entry) * storage); |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
463 } |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
464 ret[pos].name = strdup(file.cFileName); |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
465 ret[pos++].is_dir = (file.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0; |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
466 } while (FindNextFile(dir, &file)); |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
467 |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
468 FindClose(dir); |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
469 if (numret) { |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
470 *numret = pos; |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
471 } |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
472 return ret; |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
473 } |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
474 |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
475 time_t get_modification_time(char *path) |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
476 { |
974
fd7702bcc034
FindFirstFile makes more sense for getting modification times of a path than using CreateFile and GetFileTimes
Michael Pavone <pavone@retrodev.com>
parents:
972
diff
changeset
|
477 HANDLE results; |
fd7702bcc034
FindFirstFile makes more sense for getting modification times of a path than using CreateFile and GetFileTimes
Michael Pavone <pavone@retrodev.com>
parents:
972
diff
changeset
|
478 WIN32_FIND_DATA file; |
fd7702bcc034
FindFirstFile makes more sense for getting modification times of a path than using CreateFile and GetFileTimes
Michael Pavone <pavone@retrodev.com>
parents:
972
diff
changeset
|
479 results = FindFirstFile(path, &file); |
fd7702bcc034
FindFirstFile makes more sense for getting modification times of a path than using CreateFile and GetFileTimes
Michael Pavone <pavone@retrodev.com>
parents:
972
diff
changeset
|
480 if (results == INVALID_HANDLE_VALUE) { |
972
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
481 return 0; |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
482 } |
974
fd7702bcc034
FindFirstFile makes more sense for getting modification times of a path than using CreateFile and GetFileTimes
Michael Pavone <pavone@retrodev.com>
parents:
972
diff
changeset
|
483 FindClose(results); |
fd7702bcc034
FindFirstFile makes more sense for getting modification times of a path than using CreateFile and GetFileTimes
Michael Pavone <pavone@retrodev.com>
parents:
972
diff
changeset
|
484 uint64_t wintime = ((uint64_t)file.ftLastWriteTime.dwHighDateTime) << 32 | file.ftLastWriteTime.dwLowDateTime; |
fd7702bcc034
FindFirstFile makes more sense for getting modification times of a path than using CreateFile and GetFileTimes
Michael Pavone <pavone@retrodev.com>
parents:
972
diff
changeset
|
485 //convert to seconds |
fd7702bcc034
FindFirstFile makes more sense for getting modification times of a path than using CreateFile and GetFileTimes
Michael Pavone <pavone@retrodev.com>
parents:
972
diff
changeset
|
486 wintime /= 10000000; |
fd7702bcc034
FindFirstFile makes more sense for getting modification times of a path than using CreateFile and GetFileTimes
Michael Pavone <pavone@retrodev.com>
parents:
972
diff
changeset
|
487 //adjust for difference between Windows and Unix Epoch |
fd7702bcc034
FindFirstFile makes more sense for getting modification times of a path than using CreateFile and GetFileTimes
Michael Pavone <pavone@retrodev.com>
parents:
972
diff
changeset
|
488 wintime -= 11644473600LL; |
fd7702bcc034
FindFirstFile makes more sense for getting modification times of a path than using CreateFile and GetFileTimes
Michael Pavone <pavone@retrodev.com>
parents:
972
diff
changeset
|
489 return (time_t)wintime; |
972
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
490 } |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
491 |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
492 int ensure_dir_exists(char *path) |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
493 { |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
494 if (CreateDirectory(path, NULL)) { |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
495 return 1; |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
496 } |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
497 if (GetLastError() == ERROR_ALREADY_EXISTS) { |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
498 return 1; |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
499 } |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
500 if (GetLastError() != ERROR_PATH_NOT_FOUND) { |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
501 warning("CreateDirectory failed with unexpected error code %X\n", GetLastError()); |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
502 return 0; |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
503 } |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
504 char *parent = strdup(path); |
1008
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
505 //Windows technically supports both native and Unix-style path separators |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
506 //so search for both |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
507 char *sep = strrchr(parent, '\\'); |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
508 char *osep = strrchr(parent, '/'); |
1039
86ed81bb574f
Fix bug in ensure_dir_exists that would cause it to fail when mixed path separators were used
Michael Pavone <pavone@retrodev.com>
parents:
1021
diff
changeset
|
509 if (osep && (!sep || osep > sep)) { |
1008
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
510 sep = osep; |
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
511 } |
972
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
512 if (!sep || sep == parent) { |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
513 //relative path, but for some reason we failed |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
514 return 0; |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
515 } |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
516 *sep = 0; |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
517 if (!ensure_dir_exists(parent)) { |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
518 free(parent); |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
519 return 0; |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
520 } |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
521 free(parent); |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
522 return CreateDirectory(path, NULL); |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
523 } |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
524 |
742
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
525 #else |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
526 |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
527 char * get_home_dir() |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
528 { |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
529 return getenv("HOME"); |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
530 } |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
531 |
496
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
532 char * readlink_alloc(char * path) |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
533 { |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
534 char * linktext = NULL; |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
535 ssize_t linksize = 512; |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
536 ssize_t cursize = 0; |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
537 do { |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
538 if (linksize > cursize) { |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
539 cursize = linksize; |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
540 if (linktext) { |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
541 free(linktext); |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
542 } |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
543 } |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
544 linktext = malloc(cursize); |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
545 linksize = readlink(path, linktext, cursize-1); |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
546 if (linksize == -1) { |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
547 perror("readlink"); |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
548 free(linktext); |
559
6b248602ab84
blastem builds and almost works on OS X now
Mike Pavone <pavone@retrodev.com>
parents:
549
diff
changeset
|
549 return NULL; |
496
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
550 } |
549
32da1e0d5e55
Properly null terminate string returned by readlink in util.c
Michael Pavone <pavone@retrodev.com>
parents:
496
diff
changeset
|
551 } while ((linksize+1) > cursize); |
32da1e0d5e55
Properly null terminate string returned by readlink in util.c
Michael Pavone <pavone@retrodev.com>
parents:
496
diff
changeset
|
552 linktext[linksize] = 0; |
496
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
553 return linktext; |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
554 } |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
555 |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
556 char * get_exe_dir() |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
557 { |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
558 static char * exe_dir; |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
559 if (!exe_dir) { |
762
206c449eaa81
Get "portable" builds working on Linux and add a build time check for whether /proc exists
Michael Pavone <pavone@retrodev.com>
parents:
744
diff
changeset
|
560 char * cur; |
763
2a25ea5d94f7
Fix sense of HAS_PROC check
Michael Pavone <pavone@retrodev.com>
parents:
762
diff
changeset
|
561 #ifdef HAS_PROC |
496
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
562 char * linktext = readlink_alloc("/proc/self/exe"); |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
563 if (!linktext) { |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
564 goto fallback; |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
565 } |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
566 int linksize = strlen(linktext); |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
567 for(cur = linktext + linksize - 1; cur != linktext; cur--) |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
568 { |
1008
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
569 if (is_path_sep(*cur)) { |
496
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
570 *cur = 0; |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
571 break; |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
572 } |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
573 } |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
574 if (cur == linktext) { |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
575 free(linktext); |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
576 fallback: |
762
206c449eaa81
Get "portable" builds working on Linux and add a build time check for whether /proc exists
Michael Pavone <pavone@retrodev.com>
parents:
744
diff
changeset
|
577 #endif |
496
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
578 if (!exe_str) { |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
579 fputs("/proc/self/exe is not available and set_exe_str was not called!", stderr); |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
580 } |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
581 int pathsize = strlen(exe_str); |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
582 for(cur = exe_str + pathsize - 1; cur != exe_str; cur--) |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
583 { |
1008
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
584 if (is_path_sep(*cur)) { |
496
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
585 exe_dir = malloc(cur-exe_str+1); |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
586 memcpy(exe_dir, exe_str, cur-exe_str); |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
587 exe_dir[cur-exe_str] = 0; |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
588 break; |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
589 } |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
590 } |
763
2a25ea5d94f7
Fix sense of HAS_PROC check
Michael Pavone <pavone@retrodev.com>
parents:
762
diff
changeset
|
591 #ifdef HAS_PROC |
496
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
592 } else { |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
593 exe_dir = linktext; |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
594 } |
762
206c449eaa81
Get "portable" builds working on Linux and add a build time check for whether /proc exists
Michael Pavone <pavone@retrodev.com>
parents:
744
diff
changeset
|
595 #endif |
496
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
596 } |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
597 return exe_dir; |
6fc71114d145
Extract function to determine executable directory from load_config so it can be used elsewhere
Mike Pavone <pavone@retrodev.com>
parents:
495
diff
changeset
|
598 } |
866
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
599 #include <dirent.h> |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
600 |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
601 dir_entry *get_dir_list(char *path, size_t *numret) |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
602 { |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
603 DIR *d = opendir(path); |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
604 if (!d) { |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
605 if (numret) { |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
606 *numret = 0; |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
607 } |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
608 return NULL; |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
609 } |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
610 size_t storage = 64; |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
611 dir_entry *ret = malloc(sizeof(dir_entry) * storage); |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
612 size_t pos = 0; |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
613 struct dirent* entry; |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
614 while (entry = readdir(d)) |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
615 { |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
616 if (entry->d_type != DT_REG && entry->d_type != DT_LNK && entry->d_type != DT_DIR) { |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
617 continue; |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
618 } |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
619 if (pos == storage) { |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
620 storage = storage * 2; |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
621 ret = realloc(ret, sizeof(dir_entry) * storage); |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
622 } |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
623 ret[pos].name = strdup(entry->d_name); |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
624 ret[pos++].is_dir = entry->d_type == DT_DIR; |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
625 } |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
626 if (numret) { |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
627 *numret = pos; |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
628 } |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
629 return ret; |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
630 } |
69a6ec208111
Menu ROM now pulls real file names from the OS rather than using a fake list
Michael Pavone <pavone@retrodev.com>
parents:
805
diff
changeset
|
631 |
957 | 632 time_t get_modification_time(char *path) |
633 { | |
634 struct stat st; | |
635 if (stat(path, &st)) { | |
636 return 0; | |
637 } | |
1021 | 638 #ifdef __APPLE__ |
639 return st.st_mtimespec.tv_sec; | |
640 #else | |
1139
160e3f597cec
Old uncommitted fix for Android build
Michael Pavone <pavone@retrodev.com>
parents:
1103
diff
changeset
|
641 //Android's Bionic doesn't support the new style so we'll use the old one instead |
160e3f597cec
Old uncommitted fix for Android build
Michael Pavone <pavone@retrodev.com>
parents:
1103
diff
changeset
|
642 return st.st_mtime; |
1021 | 643 #endif |
957 | 644 } |
645 | |
955
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
646 int ensure_dir_exists(char *path) |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
647 { |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
648 struct stat st; |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
649 if (stat(path, &st)) { |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
650 if (errno == ENOENT) { |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
651 char *parent = strdup(path); |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
652 char *sep = strrchr(parent, '/'); |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
653 if (sep && sep != parent) { |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
654 *sep = 0; |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
655 if (!ensure_dir_exists(parent)) { |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
656 free(parent); |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
657 return 0; |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
658 } |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
659 free(parent); |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
660 } |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
661 return mkdir(path, 0777) == 0; |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
662 } else { |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
663 char buf[80]; |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
664 strerror_r(errno, buf, sizeof(buf)); |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
665 warning("stat failed with error: %s", buf); |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
666 return 0; |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
667 } |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
668 } |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
669 return S_ISDIR(st.st_mode); |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
670 } |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
671 |
741
80a67be1770b
Initial work on Windows port
Michael Pavone <pavone@retrodev.com>
parents:
549
diff
changeset
|
672 #endif |
875
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
673 |
972
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
674 void free_dir_list(dir_entry *list, size_t numentries) |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
675 { |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
676 for (size_t i = 0; i < numentries; i++) |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
677 { |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
678 free(list[i].name); |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
679 } |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
680 free(list); |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
681 } |
4899d3ae37b3
Implement Windows versions of recently added functions in util.c and get the Windows build working again
Michael Pavone <pavone@retrodev.com>
parents:
957
diff
changeset
|
682 |
875
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
683 #ifdef __ANDROID__ |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
684 |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
685 #include <SDL.h> |
1140
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
686 char *read_bundled_file(char *name, uint32_t *sizeret) |
875
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
687 { |
876
540cc4a7d626
Fix Android build breakage
Michael Pavone <pavone@retrodev.com>
parents:
875
diff
changeset
|
688 SDL_RWops *rw = SDL_RWFromFile(name, "rb"); |
875
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
689 if (!rw) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
690 if (sizeret) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
691 *sizeret = -1; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
692 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
693 return NULL; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
694 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
695 |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
696 long fsize = rw->size(rw); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
697 if (sizeret) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
698 *sizeret = fsize; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
699 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
700 char *ret; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
701 if (fsize) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
702 ret = malloc(fsize); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
703 if (SDL_RWread(rw, ret, 1, fsize) != fsize) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
704 free(ret); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
705 ret = NULL; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
706 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
707 } else { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
708 ret = NULL; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
709 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
710 SDL_RWclose(rw); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
711 return ret; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
712 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
713 |
876
540cc4a7d626
Fix Android build breakage
Michael Pavone <pavone@retrodev.com>
parents:
875
diff
changeset
|
714 char const *get_config_dir() |
875
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
715 { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
716 return SDL_AndroidGetInternalStoragePath(); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
717 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
718 |
1295
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
719 char const *get_userdata_dir() |
955
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
720 { |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
721 return SDL_AndroidGetInternalStoragePath(); |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
722 } |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
723 |
875
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
724 #else |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
725 |
1140
4490c9c12272
Detect system type from filename if header based methods fail. Allow overriding system type from command line.
Michael Pavone <pavone@retrodev.com>
parents:
1139
diff
changeset
|
726 char *read_bundled_file(char *name, uint32_t *sizeret) |
875
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
727 { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
728 char *exe_dir = get_exe_dir(); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
729 if (!exe_dir) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
730 if (sizeret) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
731 *sizeret = -1; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
732 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
733 return NULL; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
734 } |
1008
51885857c019
Removed assumptions that path separators are Unix style outside of Unix-only verions of functions
Michael Pavone <pavone@retrodev.com>
parents:
974
diff
changeset
|
735 char const *pieces[] = {exe_dir, PATH_SEP, name}; |
875
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
736 char *path = alloc_concat_m(3, pieces); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
737 FILE *f = fopen(path, "rb"); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
738 free(path); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
739 if (!f) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
740 if (sizeret) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
741 *sizeret = -1; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
742 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
743 return NULL; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
744 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
745 |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
746 long fsize = file_size(f); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
747 if (sizeret) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
748 *sizeret = fsize; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
749 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
750 char *ret; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
751 if (fsize) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
752 //reserve an extra byte in case caller wants |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
753 //to null terminate the data |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
754 ret = malloc(fsize+1); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
755 if (fread(ret, 1, fsize, f) != fsize) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
756 free(ret); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
757 ret = NULL; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
758 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
759 } else { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
760 ret = NULL; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
761 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
762 return ret; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
763 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
764 |
1058
266dc3f31f35
Use more appropriate paths for save directories and config files on Windows. Got rid of what should be the last vestiges of hard-coded path separators
Michael Pavone <pavone@retrodev.com>
parents:
1039
diff
changeset
|
765 |
266dc3f31f35
Use more appropriate paths for save directories and config files on Windows. Got rid of what should be the last vestiges of hard-coded path separators
Michael Pavone <pavone@retrodev.com>
parents:
1039
diff
changeset
|
766 #ifdef _WIN32 |
1295
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
767 char const *get_userdata_dir() |
1058
266dc3f31f35
Use more appropriate paths for save directories and config files on Windows. Got rid of what should be the last vestiges of hard-coded path separators
Michael Pavone <pavone@retrodev.com>
parents:
1039
diff
changeset
|
768 { |
266dc3f31f35
Use more appropriate paths for save directories and config files on Windows. Got rid of what should be the last vestiges of hard-coded path separators
Michael Pavone <pavone@retrodev.com>
parents:
1039
diff
changeset
|
769 static char path[MAX_PATH]; |
266dc3f31f35
Use more appropriate paths for save directories and config files on Windows. Got rid of what should be the last vestiges of hard-coded path separators
Michael Pavone <pavone@retrodev.com>
parents:
1039
diff
changeset
|
770 if (S_OK == SHGetFolderPath(NULL, CSIDL_LOCAL_APPDATA | CSIDL_FLAG_CREATE, NULL, 0, path)) |
266dc3f31f35
Use more appropriate paths for save directories and config files on Windows. Got rid of what should be the last vestiges of hard-coded path separators
Michael Pavone <pavone@retrodev.com>
parents:
1039
diff
changeset
|
771 { |
266dc3f31f35
Use more appropriate paths for save directories and config files on Windows. Got rid of what should be the last vestiges of hard-coded path separators
Michael Pavone <pavone@retrodev.com>
parents:
1039
diff
changeset
|
772 return path; |
266dc3f31f35
Use more appropriate paths for save directories and config files on Windows. Got rid of what should be the last vestiges of hard-coded path separators
Michael Pavone <pavone@retrodev.com>
parents:
1039
diff
changeset
|
773 } |
266dc3f31f35
Use more appropriate paths for save directories and config files on Windows. Got rid of what should be the last vestiges of hard-coded path separators
Michael Pavone <pavone@retrodev.com>
parents:
1039
diff
changeset
|
774 return NULL; |
266dc3f31f35
Use more appropriate paths for save directories and config files on Windows. Got rid of what should be the last vestiges of hard-coded path separators
Michael Pavone <pavone@retrodev.com>
parents:
1039
diff
changeset
|
775 } |
1295
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
776 |
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
777 char const *get_config_dir() |
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
778 { |
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
779 return get_userdata_dir(); |
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
780 } |
1058
266dc3f31f35
Use more appropriate paths for save directories and config files on Windows. Got rid of what should be the last vestiges of hard-coded path separators
Michael Pavone <pavone@retrodev.com>
parents:
1039
diff
changeset
|
781 #define CONFIG_PREFIX "" |
266dc3f31f35
Use more appropriate paths for save directories and config files on Windows. Got rid of what should be the last vestiges of hard-coded path separators
Michael Pavone <pavone@retrodev.com>
parents:
1039
diff
changeset
|
782 #define SAVE_PREFIX "" |
266dc3f31f35
Use more appropriate paths for save directories and config files on Windows. Got rid of what should be the last vestiges of hard-coded path separators
Michael Pavone <pavone@retrodev.com>
parents:
1039
diff
changeset
|
783 |
266dc3f31f35
Use more appropriate paths for save directories and config files on Windows. Got rid of what should be the last vestiges of hard-coded path separators
Michael Pavone <pavone@retrodev.com>
parents:
1039
diff
changeset
|
784 #else |
266dc3f31f35
Use more appropriate paths for save directories and config files on Windows. Got rid of what should be the last vestiges of hard-coded path separators
Michael Pavone <pavone@retrodev.com>
parents:
1039
diff
changeset
|
785 |
266dc3f31f35
Use more appropriate paths for save directories and config files on Windows. Got rid of what should be the last vestiges of hard-coded path separators
Michael Pavone <pavone@retrodev.com>
parents:
1039
diff
changeset
|
786 #define CONFIG_PREFIX "/.config" |
1295
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
787 #define USERDATA_SUFFIX "/.local/share" |
1058
266dc3f31f35
Use more appropriate paths for save directories and config files on Windows. Got rid of what should be the last vestiges of hard-coded path separators
Michael Pavone <pavone@retrodev.com>
parents:
1039
diff
changeset
|
788 |
876
540cc4a7d626
Fix Android build breakage
Michael Pavone <pavone@retrodev.com>
parents:
875
diff
changeset
|
789 char const *get_config_dir() |
875
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
790 { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
791 static char* confdir; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
792 if (!confdir) { |
1295
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
793 char const *base = get_home_dir(); |
1058
266dc3f31f35
Use more appropriate paths for save directories and config files on Windows. Got rid of what should be the last vestiges of hard-coded path separators
Michael Pavone <pavone@retrodev.com>
parents:
1039
diff
changeset
|
794 if (base) { |
266dc3f31f35
Use more appropriate paths for save directories and config files on Windows. Got rid of what should be the last vestiges of hard-coded path separators
Michael Pavone <pavone@retrodev.com>
parents:
1039
diff
changeset
|
795 confdir = alloc_concat(base, CONFIG_PREFIX PATH_SEP "blastem"); |
875
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
796 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
797 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
798 return confdir; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
799 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
800 |
1295
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
801 char const *get_userdata_dir() |
955
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
802 { |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
803 static char* savedir; |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
804 if (!savedir) { |
1295
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
805 char const *base = get_home_dir(); |
1058
266dc3f31f35
Use more appropriate paths for save directories and config files on Windows. Got rid of what should be the last vestiges of hard-coded path separators
Michael Pavone <pavone@retrodev.com>
parents:
1039
diff
changeset
|
806 if (base) { |
1295
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
807 savedir = alloc_concat(base, USERDATA_SUFFIX); |
955
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
808 } |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
809 } |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
810 return savedir; |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
811 } |
229c23b3ab73
Switch to storing SRAM/EEPROM and save states in a per-game directory rather than next to the ROM (for SRAM/EEPROM) or in the current working directory (for save states)
Michael Pavone <pavone@retrodev.com>
parents:
884
diff
changeset
|
812 |
1295
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
813 |
875
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
814 #endif |
1295
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
815 |
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
816 |
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
817 |
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
818 #endif |