repos/blastem: util.c annotate

annotate util.c @ 2032:441d5d6cea2f

Make KDEBUG functionality play nice with gdb remote debugging

author	Michael Pavone <pavone@retrodev.com>
date	Sat, 20 Feb 2021 14:52:32 -0800
parents	cd163b230cf9
children	237068a25523

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 3eced113081c Pre-release cleanup Michael Pavone <pavone@retrodev.com> parents: 799 diff changeset	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 eda8df5bc74c Minor cleanup Michael Pavone <pavone@retrodev.com> parents: 1693 diff changeset	191 uint8_t startswith(const char haystack, const char prefix)
eda8df5bc74c Minor cleanup Michael Pavone <pavone@retrodev.com> parents: 1693 diff changeset	192 {
eda8df5bc74c Minor cleanup Michael Pavone <pavone@retrodev.com> parents: 1693 diff changeset	193 return !strncmp(haystack, prefix, strlen(prefix));
eda8df5bc74c Minor cleanup Michael Pavone <pavone@retrodev.com> parents: 1693 diff changeset	194 }
eda8df5bc74c Minor cleanup Michael Pavone <pavone@retrodev.com> parents: 1693 diff changeset	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
2032 441d5d6cea2f Make KDEBUG functionality play nice with gdb remote debugging Michael Pavone <pavone@retrodev.com> parents: 1973 diff changeset	537 uint8_t is_stdout_enabled(void)
441d5d6cea2f Make KDEBUG functionality play nice with gdb remote debugging Michael Pavone <pavone@retrodev.com> parents: 1973 diff changeset	538 {
441d5d6cea2f Make KDEBUG functionality play nice with gdb remote debugging Michael Pavone <pavone@retrodev.com> parents: 1973 diff changeset	539 return output_enabled;
441d5d6cea2f Make KDEBUG functionality play nice with gdb remote debugging Michael Pavone <pavone@retrodev.com> parents: 1973 diff changeset	540 }
441d5d6cea2f Make KDEBUG functionality play nice with gdb remote debugging Michael Pavone <pavone@retrodev.com> parents: 1973 diff changeset	541
742 2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	542 #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	543 #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	544 #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	545 #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	546 #include <shlobj.h>
742 2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	547
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	548 char * get_home_dir()
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 static char path[MAX_PATH];
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	551 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	552 return path;
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	553 }
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	554
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	555 char * get_exe_dir()
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	556 {
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	557 static char path[MAX_PATH];
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	558 HMODULE module = GetModuleHandleA(NULL);
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	559 GetModuleFileNameA(module, path, MAX_PATH);
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	560
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	561 int pathsize = strlen(path);
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	562 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	563 {
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	564 if (*cur == '\\') {
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	565 *cur = 0;
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	566 break;
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	567 }
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	568 }
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	569 return path;
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	570 }
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	571
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	572 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	573 {
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	574 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	575 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	576 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	577 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	578 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	579 {
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 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	581 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	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 }
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 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	585 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	586 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	587 {
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 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	589 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	590 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	591 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	592 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	593 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	594 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	595 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	596 }
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 }
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	598 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	599 *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	600 }
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	601 } 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	602 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	603 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	604 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	605 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	606 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	607 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	608 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	609 *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	610 }
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 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	612 }
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	613
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 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	615 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	616 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	617
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 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	619 //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	620 //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	621 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	622 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	623 }
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 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	626 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	627 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	628 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	629 }
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 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	631 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	632 } 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	633
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	634 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	635 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	636 *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	637 }
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	638 }
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	639 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	640 }
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	641
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	642 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	643 {
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	644 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	645 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	646 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	647 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	648 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	649 }
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	650 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	651 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	652 //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	653 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	654 //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	655 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	656 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	657 }
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
1540 e94cff9cb625 Make sure config directory exists before trying to save config file Michael Pavone <pavone@retrodev.com> parents: 1527 diff changeset	659 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	660 {
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 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	662 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	663 }
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 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	665 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	666 }
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	667 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	668 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	669 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	670 }
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	671 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	672 //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	673 //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	674 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	675 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	676 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	677 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	678 }
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	679 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	680 //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	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 *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	684 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	685 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	686 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	687 }
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	688 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	689 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	690 }
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	691
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	692 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	693 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	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 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	696 }
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
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 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	699 {
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 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	701 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	702 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	703 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	704 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	705 }
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 }
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
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 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	709 {
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 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	711 if (ioctlsocket(sock, FIONBIO, &param)) {
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 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	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 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	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 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	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 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	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_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	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();
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
5a76a7373823 Get WIP net play code compiling on Windows and cleanup some unistd.h includes Michael Pavone <pavone@retrodev.com> parents: 1852 diff changeset	727 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	728 {
5a76a7373823 Get WIP net play code compiling on Windows and cleanup some unistd.h includes Michael Pavone <pavone@retrodev.com> parents: 1852 diff changeset	729 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	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
742 2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	732 #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	733 #include <fcntl.h>
1973 cd163b230cf9 Fix handling of remote disconnects Michael Pavone <pavone@retrodev.com> parents: 1950 diff changeset	734 #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	735
5a76a7373823 Get WIP net play code compiling on Windows and cleanup some unistd.h includes Michael Pavone <pavone@retrodev.com> parents: 1852 diff changeset	736 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	737 {
1973 cd163b230cf9 Fix handling of remote disconnects Michael Pavone <pavone@retrodev.com> parents: 1950 diff changeset	738 //SIGPIPE on network sockets is not desired
cd163b230cf9 Fix handling of remote disconnects Michael Pavone <pavone@retrodev.com> parents: 1950 diff changeset	739 //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	740 //but the alternatives are not portable
cd163b230cf9 Fix handling of remote disconnects Michael Pavone <pavone@retrodev.com> parents: 1950 diff changeset	741 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	742 }
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 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	745 {
1950 417e0fc958cc Fix non-Windows build break from Windows compat changes Michael Pavone <pavone@retrodev.com> parents: 1949 diff changeset	746 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	747 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	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 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	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 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	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 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	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_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	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;
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 }
5a76a7373823 Get WIP net play code compiling on Windows and cleanup some unistd.h includes Michael Pavone <pavone@retrodev.com> parents: 1852 diff changeset	761
5a76a7373823 Get WIP net play code compiling on Windows and cleanup some unistd.h includes Michael Pavone <pavone@retrodev.com> parents: 1852 diff changeset	762 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	763 {
5a76a7373823 Get WIP net play code compiling on Windows and cleanup some unistd.h includes Michael Pavone <pavone@retrodev.com> parents: 1852 diff changeset	764 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	765 }
742 2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	766
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	767 char * get_home_dir()
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	768 {
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	769 return getenv("HOME");
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	770 }
2e1b3b258523 Make Windows port a little less half-assed Michael Pavone <pavone@retrodev.com> parents: 741 diff changeset	771
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	772 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	773 {
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 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	775 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	776 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	777 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	778 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	779 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	780 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	781 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	782 }
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 }
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	784 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	785 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	786 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	787 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	788 free(linktext);
559 6b248602ab84 blastem builds and almost works on OS X now Mike Pavone <pavone@retrodev.com> parents: 549 diff changeset	789 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	790 }
549 32da1e0d5e55 Properly null terminate string returned by readlink in util.c Michael Pavone <pavone@retrodev.com> parents: 496 diff changeset	791 } while ((linksize+1) > cursize);
32da1e0d5e55 Properly null terminate string returned by readlink in util.c Michael Pavone <pavone@retrodev.com> parents: 496 diff changeset	792 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	793 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	794 }
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	795
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	796 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	797 {
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 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	799 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	800 char * cur;
763 2a25ea5d94f7 Fix sense of HAS_PROC check Michael Pavone <pavone@retrodev.com> parents: 762 diff changeset	801 #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	802 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	803 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	804 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	805 }
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 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	807 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	808 {
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	809 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	810 *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	811 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	812 }
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 }
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 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	815 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	816 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	817 #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	818 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	819 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	820 }
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 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	822 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	823 {
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	824 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	825 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	826 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	827 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	828 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	829 }
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	830 }
763 2a25ea5d94f7 Fix sense of HAS_PROC check Michael Pavone <pavone@retrodev.com> parents: 762 diff changeset	831 #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	832 } 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	833 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	834 }
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	835 #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	836 }
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	837 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	838 }
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	839 #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	840
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 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	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 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	844 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	845 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	846 *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	847 }
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 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	849 }
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 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	851 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	852 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	853 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	854 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	855 {
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 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	857 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	858 }
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 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	860 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	861 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	862 }
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 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	864 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	865 }
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 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	867 *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	868 }
1592 31effaadf877 Fix some memory errors (mostly leaks) identified by valgrind Michael Pavone <pavone@retrodev.com> parents: 1581 diff changeset	869 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	870 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	871 }
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	872
957 1618d3676a35 Save state menu WIP Michael Pavone <pavone@retrodev.com> parents: 955 diff changeset	873 time_t get_modification_time(char *path)
1618d3676a35 Save state menu WIP Michael Pavone <pavone@retrodev.com> parents: 955 diff changeset	874 {
1618d3676a35 Save state menu WIP Michael Pavone <pavone@retrodev.com> parents: 955 diff changeset	875 struct stat st;
1618d3676a35 Save state menu WIP Michael Pavone <pavone@retrodev.com> parents: 955 diff changeset	876 if (stat(path, &st)) {
1618d3676a35 Save state menu WIP Michael Pavone <pavone@retrodev.com> parents: 955 diff changeset	877 return 0;
1618d3676a35 Save state menu WIP Michael Pavone <pavone@retrodev.com> parents: 955 diff changeset	878 }
1021 4a92889e2889 Fix OS X build Michael Pavone <pavone@retrodev.com> parents: 1008 diff changeset	879 #ifdef __APPLE__
4a92889e2889 Fix OS X build Michael Pavone <pavone@retrodev.com> parents: 1008 diff changeset	880 return st.st_mtimespec.tv_sec;
4a92889e2889 Fix OS X build Michael Pavone <pavone@retrodev.com> parents: 1008 diff changeset	881 #else
1139 160e3f597cec Old uncommitted fix for Android build Michael Pavone <pavone@retrodev.com> parents: 1103 diff changeset	882 //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	883 return st.st_mtime;
1021 4a92889e2889 Fix OS X build Michael Pavone <pavone@retrodev.com> parents: 1008 diff changeset	884 #endif
957 1618d3676a35 Save state menu WIP Michael Pavone <pavone@retrodev.com> parents: 955 diff changeset	885 }
1618d3676a35 Save state menu WIP Michael Pavone <pavone@retrodev.com> parents: 955 diff changeset	886
1540 e94cff9cb625 Make sure config directory exists before trying to save config file Michael Pavone <pavone@retrodev.com> parents: 1527 diff changeset	887 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	888 {
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 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	890 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	891 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	892 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	893 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	894 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	895 *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	896 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	897 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	898 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	899 }
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 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	901 }
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 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	903 } 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	904 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	905 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	906 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	907 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	908 }
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	909 }
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	910 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	911 }
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	912
741 80a67be1770b Initial work on Windows port Michael Pavone <pavone@retrodev.com> parents: 549 diff changeset	913 #endif
875 54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	914
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	915 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	916 {
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 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	918 {
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	919 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	920 }
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	921 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	922 }
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	923
1484 d82af64c94d2 Sort directory listing in Nuklear UI file browser Michael Pavone <pavone@retrodev.com> parents: 1438 diff changeset	924 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	925 {
d82af64c94d2 Sort directory listing in Nuklear UI file browser Michael Pavone <pavone@retrodev.com> parents: 1438 diff changeset	926 const dir_entry da, db;
d82af64c94d2 Sort directory listing in Nuklear UI file browser Michael Pavone <pavone@retrodev.com> parents: 1438 diff changeset	927 da = a;
d82af64c94d2 Sort directory listing in Nuklear UI file browser Michael Pavone <pavone@retrodev.com> parents: 1438 diff changeset	928 db = b;
d82af64c94d2 Sort directory listing in Nuklear UI file browser Michael Pavone <pavone@retrodev.com> parents: 1438 diff changeset	929 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	930 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	931 }
d82af64c94d2 Sort directory listing in Nuklear UI file browser Michael Pavone <pavone@retrodev.com> parents: 1438 diff changeset	932 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	933 }
d82af64c94d2 Sort directory listing in Nuklear UI file browser Michael Pavone <pavone@retrodev.com> parents: 1438 diff changeset	934
d82af64c94d2 Sort directory listing in Nuklear UI file browser Michael Pavone <pavone@retrodev.com> parents: 1438 diff changeset	935 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	936 {
d82af64c94d2 Sort directory listing in Nuklear UI file browser Michael Pavone <pavone@retrodev.com> parents: 1438 diff changeset	937 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	938 }
d82af64c94d2 Sort directory listing in Nuklear UI file browser Michael Pavone <pavone@retrodev.com> parents: 1438 diff changeset	939
1852 a4cae960fd08 Allow config file to be saved with executable for "portable" setups Michael Pavone <pavone@retrodev.com> parents: 1850 diff changeset	940 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	941 {
a4cae960fd08 Allow config file to be saved with executable for "portable" setups Michael Pavone <pavone@retrodev.com> parents: 1850 diff changeset	942 #ifdef _WIN32
a4cae960fd08 Allow config file to be saved with executable for "portable" setups Michael Pavone <pavone@retrodev.com> parents: 1850 diff changeset	943 //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	944 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	945 #else
a4cae960fd08 Allow config file to be saved with executable for "portable" setups Michael Pavone <pavone@retrodev.com> parents: 1850 diff changeset	946 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	947 #endif
a4cae960fd08 Allow config file to be saved with executable for "portable" setups Michael Pavone <pavone@retrodev.com> parents: 1850 diff changeset	948 }
a4cae960fd08 Allow config file to be saved with executable for "portable" setups Michael Pavone <pavone@retrodev.com> parents: 1850 diff changeset	949
875 54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	950 #ifdef __ANDROID__
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	951
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	952 #include <SDL.h>
1818 243f3a7247f9 Include ROM DB in library binary for libretro target Mike Pavone <pavone@retrodev.com> parents: 1792 diff changeset	953 #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	954 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	955 {
876 540cc4a7d626 Fix Android build breakage Michael Pavone <pavone@retrodev.com> parents: 875 diff changeset	956 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	957 if (!rw) {
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	958 if (sizeret) {
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	959 *sizeret = -1;
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	960 }
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	961 return NULL;
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
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	964 long fsize = rw->size(rw);
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	965 if (sizeret) {
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	966 *sizeret = fsize;
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	967 }
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	968 char *ret;
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	969 if (fsize) {
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	970 ret = malloc(fsize);
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	971 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	972 free(ret);
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	973 ret = NULL;
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	974 }
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	975 } else {
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	976 ret = NULL;
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	977 }
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	978 SDL_RWclose(rw);
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	979 return ret;
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	980 }
1818 243f3a7247f9 Include ROM DB in library binary for libretro target Mike Pavone <pavone@retrodev.com> parents: 1792 diff changeset	981 #endif
875 54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	982
876 540cc4a7d626 Fix Android build breakage Michael Pavone <pavone@retrodev.com> parents: 875 diff changeset	983 char const *get_config_dir()
875 54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	984 {
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	985 return SDL_AndroidGetInternalStoragePath();
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	986 }
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	987
1295 96ad1b9bbb3a Make save directory configurable. Satisfies ticket:4 Michael Pavone <pavone@retrodev.com> parents: 1292 diff changeset	988 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	989 {
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	990 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	991 }
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	992
875 54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	993 #else
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	994
1818 243f3a7247f9 Include ROM DB in library binary for libretro target Mike Pavone <pavone@retrodev.com> parents: 1792 diff changeset	995 #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	996 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	997 {
1693 ba3fb7a3be6b Added some Makefile options to build a packaging friendly executable Michael Pavone <pavone@retrodev.com> parents: 1674 diff changeset	998 #ifdef DATA_PATH
ba3fb7a3be6b Added some Makefile options to build a packaging friendly executable Michael Pavone <pavone@retrodev.com> parents: 1674 diff changeset	999 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	1000 #else
ba3fb7a3be6b Added some Makefile options to build a packaging friendly executable Michael Pavone <pavone@retrodev.com> parents: 1674 diff changeset	1001 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	1002 if (!data_dir) {
875 54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1003 if (sizeret) {
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1004 *sizeret = -1;
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1005 }
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1006 return NULL;
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1007 }
1693 ba3fb7a3be6b Added some Makefile options to build a packaging friendly executable Michael Pavone <pavone@retrodev.com> parents: 1674 diff changeset	1008 #endif
ba3fb7a3be6b Added some Makefile options to build a packaging friendly executable Michael Pavone <pavone@retrodev.com> parents: 1674 diff changeset	1009 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	1010 char *path = alloc_concat_m(3, pieces);
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1011 FILE *f = fopen(path, "rb");
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1012 free(path);
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1013 if (!f) {
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1014 if (sizeret) {
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1015 *sizeret = -1;
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1016 }
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1017 return NULL;
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
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1020 long fsize = file_size(f);
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1021 if (sizeret) {
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1022 *sizeret = fsize;
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1023 }
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1024 char *ret;
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1025 if (fsize) {
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1026 //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	1027 //to null terminate the data
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1028 ret = malloc(fsize+1);
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1029 if (fread(ret, 1, fsize, f) != fsize) {
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1030 free(ret);
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1031 ret = NULL;
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1032 }
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1033 } else {
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1034 ret = NULL;
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1035 }
1594 137dbd05ceab Fix some issues identified by cppcheck Michael Pavone <pavone@retrodev.com> parents: 1592 diff changeset	1036 fclose(f);
875 54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1037 return ret;
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1038 }
1852 a4cae960fd08 Allow config file to be saved with executable for "portable" setups Michael Pavone <pavone@retrodev.com> parents: 1850 diff changeset	1039 #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	1040
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 #ifdef _WIN32
1295 96ad1b9bbb3a Make save directory configurable. Satisfies ticket:4 Michael Pavone <pavone@retrodev.com> parents: 1292 diff changeset	1042 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	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 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	1045 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	1046 {
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	1047 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	1048 }
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	1049 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	1050 }
1295 96ad1b9bbb3a Make save directory configurable. Satisfies ticket:4 Michael Pavone <pavone@retrodev.com> parents: 1292 diff changeset	1051
96ad1b9bbb3a Make save directory configurable. Satisfies ticket:4 Michael Pavone <pavone@retrodev.com> parents: 1292 diff changeset	1052 char const *get_config_dir()
96ad1b9bbb3a Make save directory configurable. Satisfies ticket:4 Michael Pavone <pavone@retrodev.com> parents: 1292 diff changeset	1053 {
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	1054 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	1055 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	1056 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	1057 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	1058 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	1059 }
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	1060 }
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	1061 return confdir;
1295 96ad1b9bbb3a Make save directory configurable. Satisfies ticket:4 Michael Pavone <pavone@retrodev.com> parents: 1292 diff changeset	1062 }
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	1063 #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	1064 #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	1065
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	1066 #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	1067
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	1068 #define CONFIG_PREFIX "/.config"
1295 96ad1b9bbb3a Make save directory configurable. Satisfies ticket:4 Michael Pavone <pavone@retrodev.com> parents: 1292 diff changeset	1069 #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	1070
876 540cc4a7d626 Fix Android build breakage Michael Pavone <pavone@retrodev.com> parents: 875 diff changeset	1071 char const *get_config_dir()
875 54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1072 {
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1073 static char* confdir;
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1074 if (!confdir) {
1295 96ad1b9bbb3a Make save directory configurable. Satisfies ticket:4 Michael Pavone <pavone@retrodev.com> parents: 1292 diff changeset	1075 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	1076 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	1077 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	1078 }
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1079 }
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1080 return confdir;
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1081 }
54ffba3768d6 Make menu stuff work on Android (theoretically) Michael Pavone <pavone@retrodev.com> parents: 866 diff changeset	1082
1295 96ad1b9bbb3a Make save directory configurable. Satisfies ticket:4 Michael Pavone <pavone@retrodev.com> parents: 1292 diff changeset	1083 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	1084 {
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 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	1086 if (!savedir) {
1295 96ad1b9bbb3a Make save directory configurable. Satisfies ticket:4 Michael Pavone <pavone@retrodev.com> parents: 1292 diff changeset	1087 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	1088 if (base) {
1295 96ad1b9bbb3a Make save directory configurable. Satisfies ticket:4 Michael Pavone <pavone@retrodev.com> parents: 1292 diff changeset	1089 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	1090 }
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	1091 }
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	1092 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	1093 }
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	1094
1295 96ad1b9bbb3a Make save directory configurable. Satisfies ticket:4 Michael Pavone <pavone@retrodev.com> parents: 1292 diff changeset	1095
1852 a4cae960fd08 Allow config file to be saved with executable for "portable" setups Michael Pavone <pavone@retrodev.com> parents: 1850 diff changeset	1096 #endif //_WIN32
a4cae960fd08 Allow config file to be saved with executable for "portable" setups Michael Pavone <pavone@retrodev.com> parents: 1850 diff changeset	1097 #endif //__ANDROID__
1295 96ad1b9bbb3a Make save directory configurable. Satisfies ticket:4 Michael Pavone <pavone@retrodev.com> parents: 1292 diff changeset	1098

Mercurial > repos > blastem

annotate util.c @ 2032:441d5d6cea2f