Mercurial > repos > blastem
annotate util.c @ 2005:3ce38692a3f2
Set initial pan bits in YM2612 register array and not just the separate lr field of the channel. This fixes an issue in which some channels would be silent in VGM log output
author | Michael Pavone <pavone@retrodev.com> |
---|---|
date | Sun, 11 Oct 2020 22:42:10 -0700 |
parents | cd163b230cf9 |
children | 441d5d6cea2f |
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> |
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
|
10 #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
|
11 |
879
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
12 #ifdef __ANDROID__ |
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
13 #include <android/log.h> |
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
14 #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
|
15 #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
|
16 #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
|
17 |
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
18 #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
|
19 #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
|
20 #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
|
21 #else |
884
252dfd29831d
Selecting a second game from the menu now works
Michael Pavone <pavone@retrodev.com>
parents:
883
diff
changeset
|
22 #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
|
23 #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
|
24 #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
|
25 |
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
|
26 #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
|
27 #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
|
28 #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
|
29 #endif |
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
30 |
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
|
31 #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
|
32 #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
|
33 #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
|
34 |
876
540cc4a7d626
Fix Android build breakage
Michael Pavone <pavone@retrodev.com>
parents:
875
diff
changeset
|
35 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
|
36 { |
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 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
|
38 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
|
39 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
|
40 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
|
41 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
|
42 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
|
43 } |
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 |
876
540cc4a7d626
Fix Android build breakage
Michael Pavone <pavone@retrodev.com>
parents:
875
diff
changeset
|
45 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
|
46 { |
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 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
|
48 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
|
49 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
|
50 } |
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 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
|
52 *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
|
53 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
|
54 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
|
55 } |
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 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
|
57 } |
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 |
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
|
59 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
|
60 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
|
61 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
|
62 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
|
63 } 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
|
64 |
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 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
|
66 { |
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 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
|
68 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
|
69 { |
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 //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
|
71 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
|
72 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
|
73 } |
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 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
|
76 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
|
77 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
|
78 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
|
79 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
|
80 { |
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 if (in_var) { |
1850
30f2821ffd65
Allow rom directory and rom name in screenshot path. Allow rom name in screenshot name. Remove ability for path variables to contain underscores
Michael Pavone <pavone@retrodev.com>
parents:
1818
diff
changeset
|
82 if (!isalnum(*cur)) { |
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
|
83 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
|
84 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
|
85 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
|
86 } |
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 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
|
88 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
|
89 } |
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 } 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
|
91 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
|
92 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
|
93 } |
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 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
|
96 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
|
97 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
|
98 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
|
99 } |
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 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
|
101 } |
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 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
|
103 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
|
104 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
|
105 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
|
106 { |
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 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
|
108 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
|
109 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
|
110 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
|
111 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
|
112 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
|
113 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
|
114 } |
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 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
|
116 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
|
117 } |
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 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
|
120 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
|
121 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
|
122 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
|
123 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
|
124 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
|
125 { |
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 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
|
127 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
|
128 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
|
129 } |
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 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
|
131 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
|
132 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
|
133 } |
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 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
|
135 }; |
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 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
|
137 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
|
138 } 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
|
139 *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
|
140 } |
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 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
|
142 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
|
143 } |
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 |
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
|
145 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
|
146 { |
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 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
|
148 { |
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 *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
|
150 } |
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 |
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
|
154 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
|
155 { |
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 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
|
157 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
|
158 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
|
159 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
|
160 } |
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 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
|
163 { |
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 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
|
165 { |
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 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
|
167 } |
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 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
|
169 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
|
170 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
|
171 { |
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 *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
|
173 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
|
174 } |
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 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
|
176 } |
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 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
|
179 { |
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 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
|
181 { |
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 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
|
183 } |
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 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
|
185 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
|
186 } |
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 *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
|
188 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
|
189 } |
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
|
190 |
1783 | 191 uint8_t startswith(const char *haystack, const char *prefix) |
192 { | |
193 return !strncmp(haystack, prefix, strlen(prefix)); | |
194 } | |
195 | |
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
|
196 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
|
197 { |
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 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
|
199 { |
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 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
|
201 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
|
202 *(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
|
203 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
|
204 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
|
205 *(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
|
206 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
|
207 } |
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
|
208 *(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
|
209 } |
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
|
210 |
1527
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
211 char *utf16be_to_utf8(uint8_t *buf, uint32_t max_size) |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
212 { |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
213 uint8_t *cur = buf; |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
214 uint32_t converted_size = 0; |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
215 for (uint32_t i = 0; i < max_size; i++, cur+=2) |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
216 { |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
217 uint16_t code = *cur << 16 | cur[1]; |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
218 if (!code) { |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
219 break; |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
220 } |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
221 if (code < 0x80) { |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
222 converted_size++; |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
223 } else if (code < 0x800) { |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
224 converted_size += 2; |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
225 } else { |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
226 //TODO: Deal with surrogate pairs |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
227 converted_size += 3; |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
228 } |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
229 } |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
230 char *out = malloc(converted_size + 1); |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
231 char *cur_out = out; |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
232 cur = buf; |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
233 for (uint32_t i = 0; i < max_size; i++, cur+=2) |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
234 { |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
235 uint16_t code = *cur << 16 | cur[1]; |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
236 if (!code) { |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
237 break; |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
238 } |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
239 if (code < 0x80) { |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
240 *(cur_out++) = code; |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
241 } else if (code < 0x800) { |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
242 *(cur_out++) = 0xC0 | code >> 6; |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
243 *(cur_out++) = 0x80 | (code & 0x3F); |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
244 } else { |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
245 //TODO: Deal with surrogate pairs |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
246 *(cur_out++) = 0xF0 | code >> 12; |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
247 *(cur_out++) = 0x80 | (code >> 6 & 0x3F); |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
248 *(cur_out++) = 0x80 | (code & 0x3F); |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
249 } |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
250 } |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
251 *cur_out = 0; |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
252 return out; |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
253 } |
4f6e8acd7b6a
Added support for TTC and dfont format true type fonts. More robust font selection on Windows
Michael Pavone <pavone@retrodev.com>
parents:
1523
diff
changeset
|
254 |
1572
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
255 int utf8_codepoint(const char **text) |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
256 { |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
257 uint8_t initial = **text; |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
258 (*text)++; |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
259 if (initial < 0x80) { |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
260 return initial; |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
261 } |
1594
137dbd05ceab
Fix some issues identified by cppcheck
Michael Pavone <pavone@retrodev.com>
parents:
1592
diff
changeset
|
262 int base = 0; |
137dbd05ceab
Fix some issues identified by cppcheck
Michael Pavone <pavone@retrodev.com>
parents:
1592
diff
changeset
|
263 uint8_t extended_bytes = 0; |
1572
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
264 if ((initial & 0xE0) == 0xC0) { |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
265 base = 0x80; |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
266 initial &= 0x1F; |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
267 extended_bytes = 1; |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
268 } else if ((initial & 0xF0) == 0xE0) { |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
269 base = 0x800; |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
270 initial &= 0xF; |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
271 extended_bytes = 2; |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
272 } else if ((initial & 0xF8) == 0xF0) { |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
273 base = 0x10000; |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
274 initial &= 0x7; |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
275 extended_bytes = 3; |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
276 } |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
277 int value = initial; |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
278 for (uint8_t i = 0; i < extended_bytes; i++) |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
279 { |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
280 if ((**text & 0xC0) != 0x80) { |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
281 return -1; |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
282 } |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
283 value = value << 6; |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
284 value |= (**text) & 0x3F; |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
285 (*text)++; |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
286 } |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
287 return value + base; |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
288 } |
5efeca06d942
Scale UI font size based on window size and start basing widget sizes based on font size
Michael Pavone <pavone@retrodev.com>
parents:
1540
diff
changeset
|
289 |
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
|
290 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
|
291 { |
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
|
292 #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
|
293 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
|
294 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
|
295 } |
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
|
296 #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
|
297 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
|
298 } |
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
|
299 |
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
|
300 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
|
301 { |
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
|
302 #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
|
303 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
|
304 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
|
305 } |
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
|
306 #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
|
307 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
|
308 } |
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
|
309 |
1581
7121daaa48c2
Fix drag and drop when using Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1572
diff
changeset
|
310 char * basename_no_extension(const char *path) |
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
|
311 { |
1581
7121daaa48c2
Fix drag and drop when using Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1572
diff
changeset
|
312 const char *lastdot = NULL; |
7121daaa48c2
Fix drag and drop when using Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1572
diff
changeset
|
313 const char *lastslash = NULL; |
7121daaa48c2
Fix drag and drop when using Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1572
diff
changeset
|
314 const char *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
|
315 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
|
316 { |
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
|
317 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
|
318 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
|
319 } 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
|
320 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
|
321 } |
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
|
322 } |
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
|
323 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
|
324 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
|
325 } |
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
|
326 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
|
327 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
|
328 } |
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
|
329 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
|
330 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
|
331 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
|
332 |
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
|
333 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
|
334 } |
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
|
335 |
1523
c416ace65ff1
Fix const correctness for path_extension
Michael Pavone <pavone@retrodev.com>
parents:
1485
diff
changeset
|
336 char *path_extension(char const *path) |
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
|
337 { |
1523
c416ace65ff1
Fix const correctness for path_extension
Michael Pavone <pavone@retrodev.com>
parents:
1485
diff
changeset
|
338 char const *lastdot = NULL; |
c416ace65ff1
Fix const correctness for path_extension
Michael Pavone <pavone@retrodev.com>
parents:
1485
diff
changeset
|
339 char const *lastslash = NULL; |
c416ace65ff1
Fix const correctness for path_extension
Michael Pavone <pavone@retrodev.com>
parents:
1485
diff
changeset
|
340 char const *cur; |
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
|
341 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
|
342 { |
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
|
343 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
|
344 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
|
345 } 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
|
346 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
|
347 } |
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
|
348 } |
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
|
349 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
|
350 //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
|
351 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
|
352 } |
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
|
353 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
|
354 } |
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
|
355 |
1485
369da70ee2c2
Filter file list in Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1484
diff
changeset
|
356 uint8_t path_matches_extensions(char *path, char **ext_list, uint32_t num_exts) |
369da70ee2c2
Filter file list in Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1484
diff
changeset
|
357 { |
369da70ee2c2
Filter file list in Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1484
diff
changeset
|
358 char *ext = path_extension(path); |
369da70ee2c2
Filter file list in Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1484
diff
changeset
|
359 if (!ext) { |
369da70ee2c2
Filter file list in Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1484
diff
changeset
|
360 return 0; |
369da70ee2c2
Filter file list in Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1484
diff
changeset
|
361 } |
369da70ee2c2
Filter file list in Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1484
diff
changeset
|
362 uint32_t extidx; |
369da70ee2c2
Filter file list in Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1484
diff
changeset
|
363 for (extidx = 0; extidx < num_exts; extidx++) |
369da70ee2c2
Filter file list in Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1484
diff
changeset
|
364 { |
369da70ee2c2
Filter file list in Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1484
diff
changeset
|
365 if (!strcasecmp(ext, ext_list[extidx])) { |
1592
31effaadf877
Fix some memory errors (mostly leaks) identified by valgrind
Michael Pavone <pavone@retrodev.com>
parents:
1581
diff
changeset
|
366 free(ext); |
1485
369da70ee2c2
Filter file list in Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1484
diff
changeset
|
367 return 1; |
369da70ee2c2
Filter file list in Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1484
diff
changeset
|
368 } |
369da70ee2c2
Filter file list in Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1484
diff
changeset
|
369 } |
1592
31effaadf877
Fix some memory errors (mostly leaks) identified by valgrind
Michael Pavone <pavone@retrodev.com>
parents:
1581
diff
changeset
|
370 free(ext); |
1485
369da70ee2c2
Filter file list in Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1484
diff
changeset
|
371 return 0; |
369da70ee2c2
Filter file list in Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1484
diff
changeset
|
372 } |
369da70ee2c2
Filter file list in Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1484
diff
changeset
|
373 |
1581
7121daaa48c2
Fix drag and drop when using Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1572
diff
changeset
|
374 char * path_dirname(const char *path) |
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
|
375 { |
1581
7121daaa48c2
Fix drag and drop when using Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1572
diff
changeset
|
376 const char *lastslash = NULL; |
7121daaa48c2
Fix drag and drop when using Nuklear UI
Michael Pavone <pavone@retrodev.com>
parents:
1572
diff
changeset
|
377 const char *cur; |
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
|
378 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
|
379 { |
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
|
380 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
|
381 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
|
382 } |
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
|
383 } |
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
|
384 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
|
385 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
|
386 } |
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
|
387 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
|
388 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
|
389 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
|
390 |
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
|
391 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
|
392 } |
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
|
393 |
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
|
394 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
|
395 { |
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
|
396 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
|
397 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
|
398 { |
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
|
399 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
|
400 } |
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
|
401 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
|
402 } |
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
|
403 |
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
|
404 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
|
405 |
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
|
406 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
|
407 { |
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
|
408 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
|
409 } |
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
|
410 |
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
|
411 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
|
412 { |
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
|
413 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
|
414 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
|
415 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
|
416 //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
|
417 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
|
418 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
|
419 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
|
420 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
|
421 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
|
422 //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
|
423 //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
|
424 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
|
425 } 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
|
426 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
|
427 } |
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
|
428 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
|
429 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
|
430 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
|
431 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
|
432 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
|
433 } |
879
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
434 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
|
435 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
|
436 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
|
437 } else { |
879
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
438 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
|
439 } |
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
|
440 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
|
441 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
|
442 } |
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
|
443 |
1950
417e0fc958cc
Fix non-Windows build break from Windows compat changes
Michael Pavone <pavone@retrodev.com>
parents:
1949
diff
changeset
|
444 #ifndef _WIN32 |
417e0fc958cc
Fix non-Windows build break from Windows compat changes
Michael Pavone <pavone@retrodev.com>
parents:
1949
diff
changeset
|
445 #include <unistd.h> |
417e0fc958cc
Fix non-Windows build break from Windows compat changes
Michael Pavone <pavone@retrodev.com>
parents:
1949
diff
changeset
|
446 #endif |
417e0fc958cc
Fix non-Windows build break from Windows compat changes
Michael Pavone <pavone@retrodev.com>
parents:
1949
diff
changeset
|
447 |
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
|
448 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
|
449 { |
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
|
450 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
|
451 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
|
452 #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
|
453 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
|
454 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
|
455 } 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
|
456 #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
|
457 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
|
458 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
|
459 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
|
460 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
|
461 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
|
462 //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
|
463 //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
|
464 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
|
465 } 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
|
466 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
|
467 } |
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
|
468 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
|
469 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
|
470 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
|
471 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
|
472 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
|
473 } |
879
a77670cd178d
Send info/warning/fatal messages to logcat on Android
Michael Pavone <pavone@retrodev.com>
parents:
876
diff
changeset
|
474 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
|
475 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
|
476 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
|
477 #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
|
478 } |
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
|
479 #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
|
480 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
|
481 } |
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
|
482 |
1792
52a47611a273
Avoid printing a bunch of junk to stdout when GDB remote debugging is enabled as this can confuse GDB
Michael Pavone <pavone@retrodev.com>
parents:
1783
diff
changeset
|
483 static uint8_t output_enabled = 1; |
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
|
484 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
|
485 { |
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
|
486 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
|
487 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
|
488 #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
|
489 if (headless || (isatty(STDOUT_FILENO) && isatty(STDIN_FILENO))) { |
1792
52a47611a273
Avoid printing a bunch of junk to stdout when GDB remote debugging is enabled as this can confuse GDB
Michael Pavone <pavone@retrodev.com>
parents:
1783
diff
changeset
|
490 if (output_enabled) { |
52a47611a273
Avoid printing a bunch of junk to stdout when GDB remote debugging is enabled as this can confuse GDB
Michael Pavone <pavone@retrodev.com>
parents:
1783
diff
changeset
|
491 info_printf(format, args); |
52a47611a273
Avoid printing a bunch of junk to stdout when GDB remote debugging is enabled as this can confuse GDB
Michael Pavone <pavone@retrodev.com>
parents:
1783
diff
changeset
|
492 } |
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
|
493 } 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
|
494 #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
|
495 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
|
496 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
|
497 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
|
498 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
|
499 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
|
500 //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
|
501 //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
|
502 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
|
503 } 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
|
504 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
|
505 } |
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
|
506 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
|
507 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
|
508 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
|
509 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
|
510 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
|
511 } |
1792
52a47611a273
Avoid printing a bunch of junk to stdout when GDB remote debugging is enabled as this can confuse GDB
Michael Pavone <pavone@retrodev.com>
parents:
1783
diff
changeset
|
512 if (output_enabled) { |
52a47611a273
Avoid printing a bunch of junk to stdout when GDB remote debugging is enabled as this can confuse GDB
Michael Pavone <pavone@retrodev.com>
parents:
1783
diff
changeset
|
513 info_puts(buf); |
52a47611a273
Avoid printing a bunch of junk to stdout when GDB remote debugging is enabled as this can confuse GDB
Michael Pavone <pavone@retrodev.com>
parents:
1783
diff
changeset
|
514 } |
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
|
515 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
|
516 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
|
517 #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
|
518 } |
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
|
519 #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
|
520 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
|
521 } |
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
|
522 |
1792
52a47611a273
Avoid printing a bunch of junk to stdout when GDB remote debugging is enabled as this can confuse GDB
Michael Pavone <pavone@retrodev.com>
parents:
1783
diff
changeset
|
523 void debug_message(char *format, ...) |
52a47611a273
Avoid printing a bunch of junk to stdout when GDB remote debugging is enabled as this can confuse GDB
Michael Pavone <pavone@retrodev.com>
parents:
1783
diff
changeset
|
524 { |
52a47611a273
Avoid printing a bunch of junk to stdout when GDB remote debugging is enabled as this can confuse GDB
Michael Pavone <pavone@retrodev.com>
parents:
1783
diff
changeset
|
525 va_list args; |
52a47611a273
Avoid printing a bunch of junk to stdout when GDB remote debugging is enabled as this can confuse GDB
Michael Pavone <pavone@retrodev.com>
parents:
1783
diff
changeset
|
526 va_start(args, format); |
52a47611a273
Avoid printing a bunch of junk to stdout when GDB remote debugging is enabled as this can confuse GDB
Michael Pavone <pavone@retrodev.com>
parents:
1783
diff
changeset
|
527 if (output_enabled) { |
52a47611a273
Avoid printing a bunch of junk to stdout when GDB remote debugging is enabled as this can confuse GDB
Michael Pavone <pavone@retrodev.com>
parents:
1783
diff
changeset
|
528 info_printf(format, args); |
52a47611a273
Avoid printing a bunch of junk to stdout when GDB remote debugging is enabled as this can confuse GDB
Michael Pavone <pavone@retrodev.com>
parents:
1783
diff
changeset
|
529 } |
52a47611a273
Avoid printing a bunch of junk to stdout when GDB remote debugging is enabled as this can confuse GDB
Michael Pavone <pavone@retrodev.com>
parents:
1783
diff
changeset
|
530 } |
52a47611a273
Avoid printing a bunch of junk to stdout when GDB remote debugging is enabled as this can confuse GDB
Michael Pavone <pavone@retrodev.com>
parents:
1783
diff
changeset
|
531 |
52a47611a273
Avoid printing a bunch of junk to stdout when GDB remote debugging is enabled as this can confuse GDB
Michael Pavone <pavone@retrodev.com>
parents:
1783
diff
changeset
|
532 void disable_stdout_messages(void) |
52a47611a273
Avoid printing a bunch of junk to stdout when GDB remote debugging is enabled as this can confuse GDB
Michael Pavone <pavone@retrodev.com>
parents:
1783
diff
changeset
|
533 { |
52a47611a273
Avoid printing a bunch of junk to stdout when GDB remote debugging is enabled as this can confuse GDB
Michael Pavone <pavone@retrodev.com>
parents:
1783
diff
changeset
|
534 output_enabled = 0; |
52a47611a273
Avoid printing a bunch of junk to stdout when GDB remote debugging is enabled as this can confuse GDB
Michael Pavone <pavone@retrodev.com>
parents:
1783
diff
changeset
|
535 } |
52a47611a273
Avoid printing a bunch of junk to stdout when GDB remote debugging is enabled as this can confuse GDB
Michael Pavone <pavone@retrodev.com>
parents:
1783
diff
changeset
|
536 |
742
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
537 #ifdef _WIN32 |
1949
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
538 #define WINVER 0x501 |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
539 #include <winsock2.h> |
795
bce97fc0bb8a
Fix mingw-w64 build and cross-compilation
=?UTF-8?q?Higor=20Eur=C3=ADpedes?= <heuripedes@gmail.com>
parents:
773
diff
changeset
|
540 #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
|
541 #include <shlobj.h> |
742
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
542 |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
543 char * get_home_dir() |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
544 { |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
545 static char path[MAX_PATH]; |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
546 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
|
547 return path; |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
548 } |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
549 |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
550 char * get_exe_dir() |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
551 { |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
552 static char path[MAX_PATH]; |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
553 HMODULE module = GetModuleHandleA(NULL); |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
554 GetModuleFileNameA(module, path, MAX_PATH); |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
555 |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
556 int pathsize = strlen(path); |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
557 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
|
558 { |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
559 if (*cur == '\\') { |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
560 *cur = 0; |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
561 break; |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
562 } |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
563 } |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
564 return path; |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
565 } |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
566 |
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
|
567 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
|
568 { |
1674
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
569 dir_entry *ret; |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
570 if (path[0] == PATH_SEP[0] && !path[1]) { |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
571 int drives = GetLogicalDrives(); |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
572 size_t count = 0; |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
573 for (int i = 0; i < 26; i++) |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
574 { |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
575 if (drives & (1 << i)) { |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
576 count++; |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
577 } |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
578 } |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
579 ret = calloc(count, sizeof(dir_entry)); |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
580 dir_entry *cur = ret; |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
581 for (int i = 0; i < 26; i++) |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
582 { |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
583 if (drives & (1 << i)) { |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
584 cur->name = malloc(4); |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
585 cur->name[0] = 'A' + i; |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
586 cur->name[1] = ':'; |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
587 cur->name[2] = PATH_SEP[0]; |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
588 cur->name[3] = 0; |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
589 cur->is_dir = 1; |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
590 cur++; |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
591 } |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
592 } |
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
|
593 if (numret) { |
1674
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
594 *numret = count; |
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
|
595 } |
1674
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
596 } else { |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
597 HANDLE dir; |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
598 WIN32_FIND_DATA file; |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
599 char *pattern = alloc_concat(path, "/*.*"); |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
600 dir = FindFirstFile(pattern, &file); |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
601 free(pattern); |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
602 if (dir == INVALID_HANDLE_VALUE) { |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
603 if (numret) { |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
604 *numret = 0; |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
605 } |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
606 return NULL; |
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
|
607 } |
1674
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
608 |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
609 size_t storage = 64; |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
610 ret = malloc(sizeof(dir_entry) * storage); |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
611 size_t pos = 0; |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
612 |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
613 if (path[1] == ':' && (!path[2] || (path[2] == PATH_SEP[0] && !path[3]))) { |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
614 //we are in the root of a drive, add a virtual .. entry |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
615 //for navigating to the virtual root directory |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
616 ret[pos].name = strdup(".."); |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
617 ret[pos++].is_dir = 1; |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
618 } |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
619 |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
620 do { |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
621 if (pos == storage) { |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
622 storage = storage * 2; |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
623 ret = realloc(ret, sizeof(dir_entry) * storage); |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
624 } |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
625 ret[pos].name = strdup(file.cFileName); |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
626 ret[pos++].is_dir = (file.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0; |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
627 } while (FindNextFile(dir, &file)); |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
628 |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
629 FindClose(dir); |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
630 if (numret) { |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
631 *numret = pos; |
c362f2c7766a
Moved fake virtual root stuff to get_dir_list from legacy menu so it can be used in new UI
Michael Pavone <pavone@retrodev.com>
parents:
1673
diff
changeset
|
632 } |
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
|
633 } |
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
|
634 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
|
635 } |
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
|
636 |
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
|
637 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
|
638 { |
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
|
639 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
|
640 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
|
641 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
|
642 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
|
643 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
|
644 } |
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
|
645 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
|
646 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
|
647 //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
|
648 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
|
649 //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
|
650 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
|
651 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
|
652 } |
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
|
653 |
1540
e94cff9cb625
Make sure config directory exists before trying to save config file
Michael Pavone <pavone@retrodev.com>
parents:
1527
diff
changeset
|
654 int ensure_dir_exists(const char *path) |
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
|
655 { |
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
|
656 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
|
657 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
|
658 } |
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
|
659 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
|
660 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
|
661 } |
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
|
662 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
|
663 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
|
664 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
|
665 } |
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
|
666 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
|
667 //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
|
668 //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
|
669 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
|
670 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
|
671 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
|
672 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
|
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 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
|
675 //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
|
676 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
|
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 *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
|
679 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
|
680 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
|
681 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
|
682 } |
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
|
683 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
|
684 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
|
685 } |
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
|
686 |
1949
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
687 static WSADATA wsa_data; |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
688 static void socket_cleanup(void) |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
689 { |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
690 WSACleanup(); |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
691 } |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
692 |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
693 void socket_init(void) |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
694 { |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
695 static uint8_t started; |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
696 if (!started) { |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
697 started = 1; |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
698 WSAStartup(MAKEWORD(2,2), &wsa_data); |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
699 atexit(socket_cleanup); |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
700 } |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
701 } |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
702 |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
703 int socket_blocking(int sock, int should_block) |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
704 { |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
705 u_long param = !should_block; |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
706 if (ioctlsocket(sock, FIONBIO, ¶m)) { |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
707 return WSAGetLastError(); |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
708 } |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
709 return 0; |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
710 } |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
711 |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
712 void socket_close(int sock) |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
713 { |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
714 closesocket(sock); |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
715 } |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
716 |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
717 int socket_last_error(void) |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
718 { |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
719 return WSAGetLastError(); |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
720 } |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
721 |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
722 int socket_error_is_wouldblock(void) |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
723 { |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
724 return WSAGetLastError() == WSAEWOULDBLOCK; |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
725 } |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
726 |
742
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
727 #else |
1949
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
728 #include <fcntl.h> |
1973
cd163b230cf9
Fix handling of remote disconnects
Michael Pavone <pavone@retrodev.com>
parents:
1950
diff
changeset
|
729 #include <signal.h> |
1949
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
730 |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
731 void socket_init(void) |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
732 { |
1973
cd163b230cf9
Fix handling of remote disconnects
Michael Pavone <pavone@retrodev.com>
parents:
1950
diff
changeset
|
733 //SIGPIPE on network sockets is not desired |
cd163b230cf9
Fix handling of remote disconnects
Michael Pavone <pavone@retrodev.com>
parents:
1950
diff
changeset
|
734 //would be better to do this in a more limited way, |
cd163b230cf9
Fix handling of remote disconnects
Michael Pavone <pavone@retrodev.com>
parents:
1950
diff
changeset
|
735 //but the alternatives are not portable |
cd163b230cf9
Fix handling of remote disconnects
Michael Pavone <pavone@retrodev.com>
parents:
1950
diff
changeset
|
736 signal(SIGPIPE, SIG_IGN); |
1949
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
737 } |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
738 |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
739 int socket_blocking(int sock, int should_block) |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
740 { |
1950
417e0fc958cc
Fix non-Windows build break from Windows compat changes
Michael Pavone <pavone@retrodev.com>
parents:
1949
diff
changeset
|
741 if (fcntl(sock, F_SETFL, should_block ? 0 : O_NONBLOCK)) { |
1949
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
742 return errno; |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
743 } |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
744 return 0; |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
745 } |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
746 |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
747 void socket_close(int sock) |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
748 { |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
749 close(sock); |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
750 } |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
751 |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
752 int socket_last_error(void) |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
753 { |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
754 return errno; |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
755 } |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
756 |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
757 int socket_error_is_wouldblock(void) |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
758 { |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
759 return errno == EAGAIN || errno == EWOULDBLOCK; |
5a76a7373823
Get WIP net play code compiling on Windows and cleanup some unistd.h includes
Michael Pavone <pavone@retrodev.com>
parents:
1852
diff
changeset
|
760 } |
742
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
761 |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
762 char * get_home_dir() |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
763 { |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
764 return getenv("HOME"); |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
765 } |
2e1b3b258523
Make Windows port a little less half-assed
Michael Pavone <pavone@retrodev.com>
parents:
741
diff
changeset
|
766 |
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
|
767 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
|
768 { |
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
|
769 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
|
770 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
|
771 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
|
772 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
|
773 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
|
774 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
|
775 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
|
776 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
|
777 } |
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
|
778 } |
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
|
779 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
|
780 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
|
781 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
|
782 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
|
783 free(linktext); |
559
6b248602ab84
blastem builds and almost works on OS X now
Mike Pavone <pavone@retrodev.com>
parents:
549
diff
changeset
|
784 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
|
785 } |
549
32da1e0d5e55
Properly null terminate string returned by readlink in util.c
Michael Pavone <pavone@retrodev.com>
parents:
496
diff
changeset
|
786 } while ((linksize+1) > cursize); |
32da1e0d5e55
Properly null terminate string returned by readlink in util.c
Michael Pavone <pavone@retrodev.com>
parents:
496
diff
changeset
|
787 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
|
788 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
|
789 } |
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
|
790 |
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
|
791 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
|
792 { |
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
|
793 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
|
794 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
|
795 char * cur; |
763
2a25ea5d94f7
Fix sense of HAS_PROC check
Michael Pavone <pavone@retrodev.com>
parents:
762
diff
changeset
|
796 #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
|
797 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
|
798 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
|
799 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
|
800 } |
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
|
801 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
|
802 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
|
803 { |
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
|
804 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
|
805 *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
|
806 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
|
807 } |
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
|
808 } |
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
|
809 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
|
810 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
|
811 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
|
812 #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
|
813 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
|
814 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
|
815 } |
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
|
816 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
|
817 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
|
818 { |
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
|
819 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
|
820 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
|
821 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
|
822 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
|
823 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
|
824 } |
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
|
825 } |
763
2a25ea5d94f7
Fix sense of HAS_PROC check
Michael Pavone <pavone@retrodev.com>
parents:
762
diff
changeset
|
826 #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
|
827 } 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
|
828 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
|
829 } |
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
|
830 #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
|
831 } |
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
|
832 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
|
833 } |
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
|
834 #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
|
835 |
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
|
836 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
|
837 { |
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
|
838 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
|
839 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
|
840 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
|
841 *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
|
842 } |
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
|
843 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
|
844 } |
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
|
845 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
|
846 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
|
847 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
|
848 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
|
849 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
|
850 { |
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
|
851 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
|
852 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
|
853 } |
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
|
854 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
|
855 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
|
856 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
|
857 } |
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
|
858 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
|
859 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
|
860 } |
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
|
861 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
|
862 *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
|
863 } |
1592
31effaadf877
Fix some memory errors (mostly leaks) identified by valgrind
Michael Pavone <pavone@retrodev.com>
parents:
1581
diff
changeset
|
864 closedir(d); |
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
|
865 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
|
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
|
867 |
957 | 868 time_t get_modification_time(char *path) |
869 { | |
870 struct stat st; | |
871 if (stat(path, &st)) { | |
872 return 0; | |
873 } | |
1021 | 874 #ifdef __APPLE__ |
875 return st.st_mtimespec.tv_sec; | |
876 #else | |
1139
160e3f597cec
Old uncommitted fix for Android build
Michael Pavone <pavone@retrodev.com>
parents:
1103
diff
changeset
|
877 //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
|
878 return st.st_mtime; |
1021 | 879 #endif |
957 | 880 } |
881 | |
1540
e94cff9cb625
Make sure config directory exists before trying to save config file
Michael Pavone <pavone@retrodev.com>
parents:
1527
diff
changeset
|
882 int ensure_dir_exists(const char *path) |
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
|
883 { |
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
|
884 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
|
885 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
|
886 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
|
887 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
|
888 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
|
889 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
|
890 *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
|
891 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
|
892 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
|
893 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
|
894 } |
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
|
895 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
|
896 } |
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
|
897 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
|
898 } 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
|
899 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
|
900 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
|
901 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
|
902 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
|
903 } |
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
|
904 } |
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
|
905 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
|
906 } |
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
|
907 |
741
80a67be1770b
Initial work on Windows port
Michael Pavone <pavone@retrodev.com>
parents:
549
diff
changeset
|
908 #endif |
875
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
909 |
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
|
910 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
|
911 { |
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
|
912 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
|
913 { |
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
|
914 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
|
915 } |
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
|
916 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
|
917 } |
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
|
918 |
1484
d82af64c94d2
Sort directory listing in Nuklear UI file browser
Michael Pavone <pavone@retrodev.com>
parents:
1438
diff
changeset
|
919 static int sort_dir_alpha(const void *a, const void *b) |
d82af64c94d2
Sort directory listing in Nuklear UI file browser
Michael Pavone <pavone@retrodev.com>
parents:
1438
diff
changeset
|
920 { |
d82af64c94d2
Sort directory listing in Nuklear UI file browser
Michael Pavone <pavone@retrodev.com>
parents:
1438
diff
changeset
|
921 const dir_entry *da, *db; |
d82af64c94d2
Sort directory listing in Nuklear UI file browser
Michael Pavone <pavone@retrodev.com>
parents:
1438
diff
changeset
|
922 da = a; |
d82af64c94d2
Sort directory listing in Nuklear UI file browser
Michael Pavone <pavone@retrodev.com>
parents:
1438
diff
changeset
|
923 db = b; |
d82af64c94d2
Sort directory listing in Nuklear UI file browser
Michael Pavone <pavone@retrodev.com>
parents:
1438
diff
changeset
|
924 if (da->is_dir != db->is_dir) { |
d82af64c94d2
Sort directory listing in Nuklear UI file browser
Michael Pavone <pavone@retrodev.com>
parents:
1438
diff
changeset
|
925 return db->is_dir - da->is_dir; |
d82af64c94d2
Sort directory listing in Nuklear UI file browser
Michael Pavone <pavone@retrodev.com>
parents:
1438
diff
changeset
|
926 } |
d82af64c94d2
Sort directory listing in Nuklear UI file browser
Michael Pavone <pavone@retrodev.com>
parents:
1438
diff
changeset
|
927 return strcasecmp(((dir_entry *)a)->name, ((dir_entry *)b)->name); |
d82af64c94d2
Sort directory listing in Nuklear UI file browser
Michael Pavone <pavone@retrodev.com>
parents:
1438
diff
changeset
|
928 } |
d82af64c94d2
Sort directory listing in Nuklear UI file browser
Michael Pavone <pavone@retrodev.com>
parents:
1438
diff
changeset
|
929 |
d82af64c94d2
Sort directory listing in Nuklear UI file browser
Michael Pavone <pavone@retrodev.com>
parents:
1438
diff
changeset
|
930 void sort_dir_list(dir_entry *list, size_t num_entries) |
d82af64c94d2
Sort directory listing in Nuklear UI file browser
Michael Pavone <pavone@retrodev.com>
parents:
1438
diff
changeset
|
931 { |
d82af64c94d2
Sort directory listing in Nuklear UI file browser
Michael Pavone <pavone@retrodev.com>
parents:
1438
diff
changeset
|
932 qsort(list, num_entries, sizeof(dir_entry), sort_dir_alpha); |
d82af64c94d2
Sort directory listing in Nuklear UI file browser
Michael Pavone <pavone@retrodev.com>
parents:
1438
diff
changeset
|
933 } |
d82af64c94d2
Sort directory listing in Nuklear UI file browser
Michael Pavone <pavone@retrodev.com>
parents:
1438
diff
changeset
|
934 |
1852
a4cae960fd08
Allow config file to be saved with executable for "portable" setups
Michael Pavone <pavone@retrodev.com>
parents:
1850
diff
changeset
|
935 uint8_t delete_file(char *path) |
a4cae960fd08
Allow config file to be saved with executable for "portable" setups
Michael Pavone <pavone@retrodev.com>
parents:
1850
diff
changeset
|
936 { |
a4cae960fd08
Allow config file to be saved with executable for "portable" setups
Michael Pavone <pavone@retrodev.com>
parents:
1850
diff
changeset
|
937 #ifdef _WIN32 |
a4cae960fd08
Allow config file to be saved with executable for "portable" setups
Michael Pavone <pavone@retrodev.com>
parents:
1850
diff
changeset
|
938 //TODO: Call Unicode version and prepend special string to remove max path limitation |
a4cae960fd08
Allow config file to be saved with executable for "portable" setups
Michael Pavone <pavone@retrodev.com>
parents:
1850
diff
changeset
|
939 return 0 != DeleteFileA(path); |
a4cae960fd08
Allow config file to be saved with executable for "portable" setups
Michael Pavone <pavone@retrodev.com>
parents:
1850
diff
changeset
|
940 #else |
a4cae960fd08
Allow config file to be saved with executable for "portable" setups
Michael Pavone <pavone@retrodev.com>
parents:
1850
diff
changeset
|
941 return 0 == unlink(path); |
a4cae960fd08
Allow config file to be saved with executable for "portable" setups
Michael Pavone <pavone@retrodev.com>
parents:
1850
diff
changeset
|
942 #endif |
a4cae960fd08
Allow config file to be saved with executable for "portable" setups
Michael Pavone <pavone@retrodev.com>
parents:
1850
diff
changeset
|
943 } |
a4cae960fd08
Allow config file to be saved with executable for "portable" setups
Michael Pavone <pavone@retrodev.com>
parents:
1850
diff
changeset
|
944 |
875
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
945 #ifdef __ANDROID__ |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
946 |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
947 #include <SDL.h> |
1818
243f3a7247f9
Include ROM DB in library binary for libretro target
Mike Pavone <pavone@retrodev.com>
parents:
1792
diff
changeset
|
948 #ifndef IS_LIB |
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
|
949 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
|
950 { |
876
540cc4a7d626
Fix Android build breakage
Michael Pavone <pavone@retrodev.com>
parents:
875
diff
changeset
|
951 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
|
952 if (!rw) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
953 if (sizeret) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
954 *sizeret = -1; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
955 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
956 return NULL; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
957 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
958 |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
959 long fsize = rw->size(rw); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
960 if (sizeret) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
961 *sizeret = fsize; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
962 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
963 char *ret; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
964 if (fsize) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
965 ret = malloc(fsize); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
966 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
|
967 free(ret); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
968 ret = NULL; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
969 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
970 } else { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
971 ret = NULL; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
972 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
973 SDL_RWclose(rw); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
974 return ret; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
975 } |
1818
243f3a7247f9
Include ROM DB in library binary for libretro target
Mike Pavone <pavone@retrodev.com>
parents:
1792
diff
changeset
|
976 #endif |
875
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
977 |
876
540cc4a7d626
Fix Android build breakage
Michael Pavone <pavone@retrodev.com>
parents:
875
diff
changeset
|
978 char const *get_config_dir() |
875
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
979 { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
980 return SDL_AndroidGetInternalStoragePath(); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
981 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
982 |
1295
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
983 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
|
984 { |
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
|
985 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
|
986 } |
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
|
987 |
875
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
988 #else |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
989 |
1818
243f3a7247f9
Include ROM DB in library binary for libretro target
Mike Pavone <pavone@retrodev.com>
parents:
1792
diff
changeset
|
990 #ifndef IS_LIB |
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
|
991 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
|
992 { |
1693
ba3fb7a3be6b
Added some Makefile options to build a packaging friendly executable
Michael Pavone <pavone@retrodev.com>
parents:
1674
diff
changeset
|
993 #ifdef DATA_PATH |
ba3fb7a3be6b
Added some Makefile options to build a packaging friendly executable
Michael Pavone <pavone@retrodev.com>
parents:
1674
diff
changeset
|
994 char *data_dir = DATA_PATH; |
ba3fb7a3be6b
Added some Makefile options to build a packaging friendly executable
Michael Pavone <pavone@retrodev.com>
parents:
1674
diff
changeset
|
995 #else |
ba3fb7a3be6b
Added some Makefile options to build a packaging friendly executable
Michael Pavone <pavone@retrodev.com>
parents:
1674
diff
changeset
|
996 char *data_dir = get_exe_dir(); |
ba3fb7a3be6b
Added some Makefile options to build a packaging friendly executable
Michael Pavone <pavone@retrodev.com>
parents:
1674
diff
changeset
|
997 if (!data_dir) { |
875
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
998 if (sizeret) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
999 *sizeret = -1; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1000 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1001 return NULL; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1002 } |
1693
ba3fb7a3be6b
Added some Makefile options to build a packaging friendly executable
Michael Pavone <pavone@retrodev.com>
parents:
1674
diff
changeset
|
1003 #endif |
ba3fb7a3be6b
Added some Makefile options to build a packaging friendly executable
Michael Pavone <pavone@retrodev.com>
parents:
1674
diff
changeset
|
1004 char const *pieces[] = {data_dir, PATH_SEP, name}; |
875
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1005 char *path = alloc_concat_m(3, pieces); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1006 FILE *f = fopen(path, "rb"); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1007 free(path); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1008 if (!f) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1009 if (sizeret) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1010 *sizeret = -1; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1011 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1012 return NULL; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1013 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1014 |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1015 long fsize = file_size(f); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1016 if (sizeret) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1017 *sizeret = fsize; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1018 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1019 char *ret; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1020 if (fsize) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1021 //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
|
1022 //to null terminate the data |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1023 ret = malloc(fsize+1); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1024 if (fread(ret, 1, fsize, f) != fsize) { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1025 free(ret); |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1026 ret = NULL; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1027 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1028 } else { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1029 ret = NULL; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1030 } |
1594
137dbd05ceab
Fix some issues identified by cppcheck
Michael Pavone <pavone@retrodev.com>
parents:
1592
diff
changeset
|
1031 fclose(f); |
875
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1032 return ret; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1033 } |
1852
a4cae960fd08
Allow config file to be saved with executable for "portable" setups
Michael Pavone <pavone@retrodev.com>
parents:
1850
diff
changeset
|
1034 #endif //ISLIB |
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
|
1035 |
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
|
1036 #ifdef _WIN32 |
1295
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
1037 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
|
1038 { |
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
|
1039 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
|
1040 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
|
1041 { |
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
|
1042 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
|
1043 } |
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
|
1044 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
|
1045 } |
1295
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
1046 |
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
1047 char const *get_config_dir() |
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
1048 { |
1673
ab3b465c052c
Fix Windows implentation of get_config_dir() so config file gets saved to the right place. Fix location for sticky_path file on all platforms
Michael Pavone <pavone@retrodev.com>
parents:
1594
diff
changeset
|
1049 static char* confdir; |
ab3b465c052c
Fix Windows implentation of get_config_dir() so config file gets saved to the right place. Fix location for sticky_path file on all platforms
Michael Pavone <pavone@retrodev.com>
parents:
1594
diff
changeset
|
1050 if (!confdir) { |
ab3b465c052c
Fix Windows implentation of get_config_dir() so config file gets saved to the right place. Fix location for sticky_path file on all platforms
Michael Pavone <pavone@retrodev.com>
parents:
1594
diff
changeset
|
1051 char const *base = get_userdata_dir(); |
ab3b465c052c
Fix Windows implentation of get_config_dir() so config file gets saved to the right place. Fix location for sticky_path file on all platforms
Michael Pavone <pavone@retrodev.com>
parents:
1594
diff
changeset
|
1052 if (base) { |
ab3b465c052c
Fix Windows implentation of get_config_dir() so config file gets saved to the right place. Fix location for sticky_path file on all platforms
Michael Pavone <pavone@retrodev.com>
parents:
1594
diff
changeset
|
1053 confdir = alloc_concat(base, PATH_SEP "blastem"); |
ab3b465c052c
Fix Windows implentation of get_config_dir() so config file gets saved to the right place. Fix location for sticky_path file on all platforms
Michael Pavone <pavone@retrodev.com>
parents:
1594
diff
changeset
|
1054 } |
ab3b465c052c
Fix Windows implentation of get_config_dir() so config file gets saved to the right place. Fix location for sticky_path file on all platforms
Michael Pavone <pavone@retrodev.com>
parents:
1594
diff
changeset
|
1055 } |
ab3b465c052c
Fix Windows implentation of get_config_dir() so config file gets saved to the right place. Fix location for sticky_path file on all platforms
Michael Pavone <pavone@retrodev.com>
parents:
1594
diff
changeset
|
1056 return confdir; |
1295
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
1057 } |
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
|
1058 #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
|
1059 #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
|
1060 |
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
|
1061 #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
|
1062 |
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
|
1063 #define CONFIG_PREFIX "/.config" |
1295
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
1064 #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
|
1065 |
876
540cc4a7d626
Fix Android build breakage
Michael Pavone <pavone@retrodev.com>
parents:
875
diff
changeset
|
1066 char const *get_config_dir() |
875
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1067 { |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1068 static char* confdir; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1069 if (!confdir) { |
1295
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
1070 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
|
1071 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
|
1072 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
|
1073 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1074 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1075 return confdir; |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1076 } |
54ffba3768d6
Make menu stuff work on Android (theoretically)
Michael Pavone <pavone@retrodev.com>
parents:
866
diff
changeset
|
1077 |
1295
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
1078 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
|
1079 { |
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
|
1080 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
|
1081 if (!savedir) { |
1295
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
1082 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
|
1083 if (base) { |
1295
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
1084 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
|
1085 } |
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
|
1086 } |
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
|
1087 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
|
1088 } |
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
|
1089 |
1295
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
1090 |
1852
a4cae960fd08
Allow config file to be saved with executable for "portable" setups
Michael Pavone <pavone@retrodev.com>
parents:
1850
diff
changeset
|
1091 #endif //_WIN32 |
a4cae960fd08
Allow config file to be saved with executable for "portable" setups
Michael Pavone <pavone@retrodev.com>
parents:
1850
diff
changeset
|
1092 #endif //__ANDROID__ |
1295
96ad1b9bbb3a
Make save directory configurable. Satisfies ticket:4
Michael Pavone <pavone@retrodev.com>
parents:
1292
diff
changeset
|
1093 |