#include "platform.h"
-#if !defined(PLATFORM_WIN32)
+#if defined(PLATFORM_UNIX)
#include <pwd.h>
#include <sys/param.h>
#endif
// logging functions
// ----------------------------------------------------------------------------
-#define DUPLICATE_LOG_OUT_TO_STDOUT TRUE
-#define DUPLICATE_LOG_ERR_TO_STDERR TRUE
+#define DUPLICATE_LOGGING_TO_STDOUT TRUE
#if defined(PLATFORM_ANDROID)
static void vprintf_log_nonewline(char *format, va_list ap)
{
- FILE *file = program.log_file[LOG_ERR_ID];
+ FILE *file = program.log_file;
-#if DUPLICATE_LOG_ERR_TO_STDERR
- if (file != program.log_file_default[LOG_ERR_ID])
+#if DUPLICATE_LOGGING_TO_STDOUT
+ if (file != program.log_file_default)
{
va_list ap2;
va_copy(ap2, ap);
- vfprintf(program.log_file_default[LOG_ERR_ID], format, ap2);
+ vfprintf(program.log_file_default, format, ap2);
va_end(ap2);
}
static void vprintf_log(char *format, va_list ap)
{
- FILE *file = program.log_file[LOG_ERR_ID];
+ FILE *file = program.log_file;
char *newline = STRING_NEWLINE;
-#if DUPLICATE_LOG_ERR_TO_STDERR
- if (file != program.log_file_default[LOG_ERR_ID])
+#if DUPLICATE_LOGGING_TO_STDOUT
+ if (file != program.log_file_default)
{
va_list ap2;
va_copy(ap2, ap);
- vfprintf(program.log_file_default[LOG_ERR_ID], format, ap2);
- fprintf(program.log_file_default[LOG_ERR_ID], "%s", newline);
+ vfprintf(program.log_file_default, format, ap2);
+ fprintf(program.log_file_default, "%s", newline);
va_end(ap2);
}
static void vPrint(char *format, va_list ap)
{
- FILE *file = program.log_file[LOG_OUT_ID];
+ FILE *file = program.log_file;
-#if DUPLICATE_LOG_OUT_TO_STDOUT
- if (file != program.log_file_default[LOG_OUT_ID])
+#if DUPLICATE_LOGGING_TO_STDOUT
+ if (file != program.log_file_default)
{
va_list ap2;
va_copy(ap2, ap);
- vfprintf(program.log_file_default[LOG_OUT_ID], format, ap2);
+ vfprintf(program.log_file_default, format, ap2);
va_end(ap2);
}
void PrintNoLog(char *format, ...)
{
- FILE *file = program.log_file_default[LOG_OUT_ID];
+ FILE *file = program.log_file_default;
va_list ap;
va_start(ap, format);
}
+// ----------------------------------------------------------------------------
+// UUID functions
+// ----------------------------------------------------------------------------
+
+#define UUID_BYTES 16
+#define UUID_CHARS (UUID_BYTES * 2)
+#define UUID_LENGTH (UUID_CHARS + 4)
+
+static unsigned int uuid_random_function(int max)
+{
+ return GetBetterRandom(max);
+}
+
+char *getUUIDExt(unsigned int (*random_function)(int max))
+{
+ static char uuid[UUID_LENGTH + 1];
+ int data[UUID_BYTES];
+ int count = 0;
+ int i;
+
+ for (i = 0; i < UUID_BYTES; i++)
+ data[i] = random_function(256);
+
+ data[6] = 0x40 | (data[6] & 0x0f);
+ data[8] = 0x80 | (data[8] & 0x3f);
+
+ for (i = 0; i < UUID_BYTES; i++)
+ {
+ sprintf(&uuid[count], "%02x", data[i]);
+ count += 2;
+
+ if (i == 3 || i == 5 || i == 7 || i == 9)
+ strcat(&uuid[count++], "-");
+ }
+
+ return uuid;
+}
+
+char *getUUID(void)
+{
+ return getUUIDExt(uuid_random_function);
+}
+
+
// ----------------------------------------------------------------------------
// counter functions
// ----------------------------------------------------------------------------
sleep_milliseconds(delay);
}
-boolean DelayReachedExt(unsigned int *counter_var, unsigned int delay,
- unsigned int actual_counter)
+boolean DelayReachedExt2(unsigned int *counter_var, unsigned int delay,
+ unsigned int actual_counter)
{
if (actual_counter >= *counter_var &&
actual_counter < *counter_var + delay)
return TRUE;
}
-boolean FrameReached(unsigned int *frame_counter_var, unsigned int frame_delay)
+boolean DelayReachedExt(DelayCounter *counter, unsigned int actual_counter)
{
- return DelayReachedExt(frame_counter_var, frame_delay, FrameCounter);
+ return DelayReachedExt2(&counter->count, counter->value, actual_counter);
}
-boolean DelayReached(unsigned int *counter_var, unsigned int delay)
+boolean FrameReached(DelayCounter *counter)
{
- return DelayReachedExt(counter_var, delay, Counter());
+ return DelayReachedExt(counter, FrameCounter);
}
-void ResetDelayCounterExt(unsigned int *counter_var,
- unsigned int actual_counter)
+boolean DelayReached(DelayCounter *counter)
{
- DelayReachedExt(counter_var, 0, actual_counter);
+ return DelayReachedExt(counter, Counter());
}
-void ResetFrameCounter(unsigned int *frame_counter_var)
+void ResetDelayCounterExt(DelayCounter *counter, unsigned int actual_counter)
{
- FrameReached(frame_counter_var, 0);
+ DelayReachedExt2(&counter->count, 0, actual_counter);
}
-void ResetDelayCounter(unsigned int *counter_var)
+void ResetFrameCounter(DelayCounter *counter)
{
- DelayReached(counter_var, 0);
+ ResetDelayCounterExt(counter, FrameCounter);
}
-int WaitUntilDelayReached(unsigned int *counter_var, unsigned int delay)
+void ResetDelayCounter(DelayCounter *counter)
{
+ ResetDelayCounterExt(counter, Counter());
+}
+
+int WaitUntilDelayReached(DelayCounter *counter)
+{
+ unsigned int *counter_var = &counter->count;
+ unsigned int delay = counter->value;
unsigned int actual_counter;
int skip_frames = 0;
return skip_frames;
}
-void SkipUntilDelayReached(unsigned int *counter_var, unsigned int delay,
+void SkipUntilDelayReached(DelayCounter *counter,
int *loop_var, int last_loop_value)
{
- int skip_frames = WaitUntilDelayReached(counter_var, delay);
+ int skip_frames = WaitUntilDelayReached(counter);
#if 0
#if DEBUG
if (skip_frames)
Debug("internal:SkipUntilDelayReached",
"%d: %d ms -> SKIP %d FRAME(S) [%d ms]",
- *loop_var, delay,
- skip_frames, skip_frames * delay);
+ *loop_var, counter->value,
+ skip_frames, skip_frames * counter->value);
else
Debug("internal:SkipUntilDelayReached",
"%d: %d ms",
- *loop_var, delay);
+ *loop_var, counter->value);
#endif
#endif
// random generator functions
// ----------------------------------------------------------------------------
-unsigned int init_random_number(int nr, int seed)
+static unsigned int init_random_number_ext(int nr, int seed)
{
if (seed == NEW_RANDOMIZE)
{
// default random seed
seed = (int)time(NULL); // seconds since the epoch
-#if !defined(PLATFORM_WIN32)
+#if !defined(PLATFORM_WINDOWS)
// add some more randomness
struct timeval current_time;
return (unsigned int) seed;
}
+static unsigned int prng_seed_gettimeofday(void)
+{
+ struct timeval current_time;
+
+ gettimeofday(¤t_time, NULL);
+
+ prng_seed_bytes(¤t_time, sizeof(current_time));
+
+ return 0;
+}
+
+unsigned int init_random_number(int nr, int seed)
+{
+ return (nr == RANDOM_BETTER ? prng_seed_gettimeofday() :
+ init_random_number_ext(nr, seed));
+}
+
+static unsigned int get_random_number_ext(int nr)
+{
+ return (nr == RANDOM_BETTER ? prng_get_uint() :
+ random_linux_libc(nr));
+}
+
unsigned int get_random_number(int nr, int max)
{
- return (max > 0 ? random_linux_libc(nr) % max : 0);
+ return (max > 0 ? get_random_number_ext(nr) % max : 0);
}
}
#endif
+#if defined(PLATFORM_UNIX)
+static struct passwd *getPasswdEntry(void)
+{
+#if defined(PLATFORM_EMSCRIPTEN)
+ // currently not fully supported; force fallback to default values
+ return NULL;
+#else
+ return getpwuid(getuid());
+#endif
+}
+
+char *getUnixLoginName(void)
+{
+ struct passwd *pwd = getPasswdEntry();
+
+ if (pwd != NULL && strlen(pwd->pw_name) != 0)
+ return pwd->pw_name;
+
+ return NULL;
+}
+
+char *getUnixRealName(void)
+{
+ struct passwd *pwd = getPasswdEntry();
+
+ if (pwd != NULL && strlen(pwd->pw_gecos) != 0)
+ return pwd->pw_gecos;
+
+ return NULL;
+}
+
+char *getUnixHomeDir(void)
+{
+ struct passwd *pwd = getPasswdEntry();
+
+ if (pwd != NULL && strlen(pwd->pw_dir) != 0)
+ return pwd->pw_dir;
+
+ return NULL;
+}
+#endif
+
char *getLoginName(void)
{
static char *login_name = NULL;
-#if defined(PLATFORM_WIN32)
+#if defined(PLATFORM_WINDOWS)
if (login_name == NULL)
{
unsigned long buffer_size = MAX_USERNAME_LEN + 1;
+
login_name = checked_malloc(buffer_size);
if (GetUserName(login_name, &buffer_size) == 0)
#elif defined(PLATFORM_UNIX) && !defined(PLATFORM_ANDROID)
if (login_name == NULL)
{
- struct passwd *pwd;
+ char *name = getUnixLoginName();
- if ((pwd = getpwuid(getuid())) == NULL)
- login_name = ANONYMOUS_NAME;
+ if (name != NULL)
+ login_name = getStringCopy(name);
else
- login_name = getStringCopy(pwd->pw_name);
+ login_name = ANONYMOUS_NAME;
}
#else
login_name = ANONYMOUS_NAME;
{
static char *real_name = NULL;
-#if defined(PLATFORM_WIN32)
+#if defined(PLATFORM_WINDOWS)
if (real_name == NULL)
{
static char buffer[MAX_USERNAME_LEN + 1];
#elif defined(PLATFORM_UNIX) && !defined(PLATFORM_ANDROID)
if (real_name == NULL)
{
- struct passwd *pwd;
+ char *name = getUnixRealName();
- if ((pwd = getpwuid(getuid())) != NULL && strlen(pwd->pw_gecos) != 0)
- real_name = get_corrected_real_name(pwd->pw_gecos);
+ if (name != NULL)
+ real_name = get_corrected_real_name(name);
else
real_name = ANONYMOUS_NAME;
}
return real_name;
}
+char *getFixedUserName(char *name)
+{
+ // needed because player name must be a fixed length string
+ char *name_new = checked_malloc(MAX_PLAYER_NAME_LEN + 1);
+
+ strncpy(name_new, name, MAX_PLAYER_NAME_LEN);
+ name_new[MAX_PLAYER_NAME_LEN] = '\0';
+
+ if (strlen(name) > MAX_PLAYER_NAME_LEN) // name has been cut
+ if (strchr(name_new, ' '))
+ *strchr(name_new, ' ') = '\0';
+
+ return name_new;
+}
+
+char *getDefaultUserName(int nr)
+{
+ static char *user_name[MAX_PLAYER_NAMES] = { NULL };
+
+ nr = MIN(MAX(0, nr), MAX_PLAYER_NAMES - 1);
+
+ if (user_name[nr] == NULL)
+ {
+ user_name[nr] = (nr == 0 ? getLoginName() : EMPTY_PLAYER_NAME);
+ user_name[nr] = getFixedUserName(user_name[nr]);
+ }
+
+ return user_name[nr];
+}
+
+char *getTimestampFromEpoch(time_t epoch_seconds)
+{
+ struct tm *now = localtime(&epoch_seconds);
+ static char timestamp[20];
+
+ sprintf(timestamp, "%04d%02d%02d-%02d%02d%02d",
+ now->tm_year + 1900, now->tm_mon + 1, now->tm_mday,
+ now->tm_hour, now->tm_min, now->tm_sec);
+
+ return timestamp;
+}
+
+char *getCurrentTimestamp(void)
+{
+ return getTimestampFromEpoch(time(NULL));
+}
+
time_t getFileTimestampEpochSeconds(char *filename)
{
struct stat file_status;
// various string functions
// ----------------------------------------------------------------------------
-char *getStringCat2WithSeparator(char *s1, char *s2, char *sep)
+char *getStringCat2WithSeparator(const char *s1,
+ const char *s2,
+ const char *sep)
{
if (s1 == NULL || s2 == NULL || sep == NULL)
return NULL;
return complete_string;
}
-char *getStringCat3WithSeparator(char *s1, char *s2, char *s3, char *sep)
+char *getStringCat3WithSeparator(const char *s1,
+ const char *s2,
+ const char *s3,
+ const char *sep)
{
if (s1 == NULL || s2 == NULL || s3 == NULL || sep == NULL)
return NULL;
return complete_string;
}
-char *getStringCat2(char *s1, char *s2)
+char *getStringCat2(const char *s1, const char *s2)
{
return getStringCat2WithSeparator(s1, s2, "");
}
-char *getStringCat3(char *s1, char *s2, char *s3)
+char *getStringCat3(const char *s1, const char *s2, const char *s3)
{
return getStringCat3WithSeparator(s1, s2, s3, "");
}
-char *getPath2(char *path1, char *path2)
+char *getPath2(const char *path1, const char *path2)
{
#if defined(PLATFORM_ANDROID)
// workaround for reading from assets directory -- skip "." subdirs in path
return getStringCat2WithSeparator(path1, path2, STRING_PATH_SEPARATOR);
}
-char *getPath3(char *path1, char *path2, char *path3)
+char *getPath3(const char *path1, const char *path2, const char *path3)
{
#if defined(PLATFORM_ANDROID)
// workaround for reading from assets directory -- skip "." subdirs in path
return filename;
}
-char *getImg2(char *path1, char *path2)
+char *getImg2(const char *path1, const char *path2)
{
return getPngOrPcxIfNotExists(getPath2(path1, path2));
}
-char *getImg3(char *path1, char *path2, char *path3)
+char *getImg3(const char *path1, const char *path2, const char *path3)
{
return getPngOrPcxIfNotExists(getPath3(path1, path2, path3));
}
return s_copy;
}
-void setString(char **old_value, char *new_value)
+void setString(char **old_value, const char *new_value)
{
checked_free(*old_value);
*old_value = getStringCopy(new_value);
}
-boolean strEqual(char *s1, char *s2)
+boolean strEqual(const char *s1, const char *s2)
{
return (s1 == NULL && s2 == NULL ? TRUE :
s1 == NULL && s2 != NULL ? FALSE :
strcmp(s1, s2) == 0);
}
-boolean strEqualN(char *s1, char *s2, int n)
+boolean strEqualN(const char *s1, const char *s2, int n)
{
return (s1 == NULL && s2 == NULL ? TRUE :
s1 == NULL && s2 != NULL ? FALSE :
strncmp(s1, s2, n) == 0);
}
-boolean strPrefix(char *s, char *prefix)
+boolean strEqualCase(const char *s1, const char *s2)
+{
+ return (s1 == NULL && s2 == NULL ? TRUE :
+ s1 == NULL && s2 != NULL ? FALSE :
+ s1 != NULL && s2 == NULL ? FALSE :
+ strcasecmp(s1, s2) == 0);
+}
+
+boolean strEqualCaseN(const char *s1, const char *s2, int n)
+{
+ return (s1 == NULL && s2 == NULL ? TRUE :
+ s1 == NULL && s2 != NULL ? FALSE :
+ s1 != NULL && s2 == NULL ? FALSE :
+ strncasecmp(s1, s2, n) == 0);
+}
+
+boolean strPrefix(const char *s, const char *prefix)
{
return (s == NULL && prefix == NULL ? TRUE :
s == NULL && prefix != NULL ? FALSE :
strncmp(s, prefix, strlen(prefix)) == 0);
}
-boolean strSuffix(char *s, char *suffix)
+boolean strSuffix(const char *s, const char *suffix)
{
return (s == NULL && suffix == NULL ? TRUE :
s == NULL && suffix != NULL ? FALSE :
strcmp(&s[strlen(s) - strlen(suffix)], suffix) == 0);
}
-boolean strPrefixLower(char *s, char *prefix)
+boolean strPrefixLower(const char *s, const char *prefix)
{
char *s_lower = getStringToLower(s);
boolean match = strPrefix(s_lower, prefix);
return match;
}
-boolean strSuffixLower(char *s, char *suffix)
+boolean strSuffixLower(const char *s, const char *suffix)
{
char *s_lower = getStringToLower(s);
boolean match = strSuffix(s_lower, suffix);
return match;
}
+boolean isURL(const char *s)
+{
+ while (*s && *s >= 'a' && *s <= 'z')
+ s++;
+
+ return strPrefix(s, "://");
+}
+
// ----------------------------------------------------------------------------
// command line option handling functions
void (*print_usage_function)(void),
void (*print_version_function)(void))
{
- char *ro_base_path = getProgramMainDataPath(argv[0], RO_BASE_PATH);
- char *rw_base_path = getProgramMainDataPath(argv[0], RW_BASE_PATH);
+ char *base_path = getProgramMainDataPath(argv[0], BASE_PATH);
char **argvplus = checked_calloc((argc + 1) * sizeof(char **));
char **options_left = &argvplus[1];
options.server_host = NULL;
options.server_port = 0;
- options.ro_base_directory = ro_base_path;
- options.rw_base_directory = rw_base_path;
- options.level_directory = getPath2(ro_base_path, LEVELS_DIRECTORY);
- options.graphics_directory = getPath2(ro_base_path, GRAPHICS_DIRECTORY);
- options.sounds_directory = getPath2(ro_base_path, SOUNDS_DIRECTORY);
- options.music_directory = getPath2(ro_base_path, MUSIC_DIRECTORY);
- options.docs_directory = getPath2(ro_base_path, DOCS_DIRECTORY);
- options.conf_directory = getPath2(ro_base_path, CONF_DIRECTORY);
+ options.base_directory = base_path;
+
+ options.level_directory = getPath2(base_path, LEVELS_DIRECTORY);
+ options.graphics_directory = getPath2(base_path, GRAPHICS_DIRECTORY);
+ options.sounds_directory = getPath2(base_path, SOUNDS_DIRECTORY);
+ options.music_directory = getPath2(base_path, MUSIC_DIRECTORY);
+ options.docs_directory = getPath2(base_path, DOCS_DIRECTORY);
+ options.conf_directory = getPath2(base_path, CONF_DIRECTORY);
options.execute_command = NULL;
+ options.tape_log_filename = NULL;
options.special_flags = NULL;
options.debug_mode = NULL;
+ options.player_name = NULL;
+ options.identifier = NULL;
+ options.level_nr = NULL;
+
+ options.display_nr = 0;
options.mytapes = FALSE;
options.serveronly = FALSE;
if (option_arg == NULL)
FailWithHelp("option '%s' requires an argument", option_str);
- // this should be extended to separate options for ro and rw data
- options.ro_base_directory = ro_base_path = getStringCopy(option_arg);
- options.rw_base_directory = rw_base_path = getStringCopy(option_arg);
+ options.base_directory = base_path = getStringCopy(option_arg);
if (option_arg == next_option)
options_left++;
// adjust paths for sub-directories in base directory accordingly
- options.level_directory = getPath2(ro_base_path, LEVELS_DIRECTORY);
- options.graphics_directory = getPath2(ro_base_path, GRAPHICS_DIRECTORY);
- options.sounds_directory = getPath2(ro_base_path, SOUNDS_DIRECTORY);
- options.music_directory = getPath2(ro_base_path, MUSIC_DIRECTORY);
- options.docs_directory = getPath2(ro_base_path, DOCS_DIRECTORY);
- options.conf_directory = getPath2(ro_base_path, CONF_DIRECTORY);
+ options.level_directory = getPath2(base_path, LEVELS_DIRECTORY);
+ options.graphics_directory = getPath2(base_path, GRAPHICS_DIRECTORY);
+ options.sounds_directory = getPath2(base_path, SOUNDS_DIRECTORY);
+ options.music_directory = getPath2(base_path, MUSIC_DIRECTORY);
+ options.docs_directory = getPath2(base_path, DOCS_DIRECTORY);
+ options.conf_directory = getPath2(base_path, CONF_DIRECTORY);
}
else if (strncmp(option, "-levels", option_len) == 0)
{
if (option_arg != next_option)
options.debug_mode = getStringCopy(option_arg);
}
+ else if (strncmp(option, "-player-name", option_len) == 0)
+ {
+ if (option_arg == NULL)
+ FailWithHelp("option '%s' requires an argument", option_str);
+
+ options.player_name = getStringCopy(option_arg);
+ if (option_arg == next_option)
+ options_left++;
+ }
+ else if (strncmp(option, "-identifier", option_len) == 0)
+ {
+ if (option_arg == NULL)
+ FailWithHelp("option '%s' requires an argument", option_str);
+
+ options.identifier = getStringCopy(option_arg);
+ if (option_arg == next_option)
+ options_left++;
+ }
+ else if (strncmp(option, "-level-nr", option_len) == 0)
+ {
+ if (option_arg == NULL)
+ FailWithHelp("option '%s' requires an argument", option_str);
+
+ options.level_nr = getStringCopy(option_arg);
+ if (option_arg == next_option)
+ options_left++;
+ }
else if (strncmp(option, "-verbose", option_len) == 0)
{
options.verbose = TRUE;
// when doing batch processing, always enable verbose mode (warnings)
options.verbose = TRUE;
}
-#if defined(PLATFORM_MACOSX)
+ else if (strncmp(option, "-tape_logfile", option_len) == 0)
+ {
+ if (option_arg == NULL)
+ FailWithHelp("option '%s' requires an argument", option_str);
+
+ options.tape_log_filename = getStringCopy(option_arg);
+ if (option_arg == next_option)
+ options_left++;
+ }
+ else if (strncmp(option, "-display", option_len) == 0)
+ {
+ if (option_arg == NULL)
+ FailWithHelp("option '%s' requires an argument", option_str);
+
+ if (option_arg == next_option)
+ options_left++;
+
+ int display_nr = atoi(option_arg);
+
+#if 1
+ // dirty hack: SDL_GetNumVideoDisplays() seems broken on some systems
+ options.display_nr = display_nr;
+#else
+ options.display_nr =
+ MAX(0, MIN(display_nr, SDL_GetNumVideoDisplays() - 1));
+
+ if (display_nr != options.display_nr)
+ Warn("invalid display %d -- using display %d",
+ display_nr, options.display_nr);
+#endif
+ }
+#if defined(PLATFORM_MAC)
else if (strPrefix(option, "-psn"))
{
// ignore process serial number when launched via GUI on Mac OS X
void clear_mem(void *ptr, unsigned int size)
{
-#if defined(PLATFORM_WIN32)
+#if defined(PLATFORM_WINDOWS)
// for unknown reason, memset() sometimes crashes when compiled with MinGW
char *cptr = (char *)ptr;
*y2 = help_y;
}
+int get_number_of_bits(int bits)
+{
+ /*
+ Counting bits set, Brian Kernighan's way
+
+ Brian Kernighan's method goes through as many iterations as there are set
+ bits. So if we have a 32-bit word with only the high bit set, then it will
+ only go once through the loop.
+
+ Published in 1988, the C Programming Language 2nd Ed. (by Brian W. Kernighan
+ and Dennis M. Ritchie) mentions this in exercise 2-9.
+ First published by Peter Wegner in CACM 3 (1960), 322.
+ */
+
+ int num_bits = 0;
+
+ while (bits)
+ {
+ bits &= bits - 1; // clear the least significant bit set
+ num_bits++;
+ }
+
+ return num_bits;
+}
+
/* the "put" variants of the following file access functions check for the file
pointer being != NULL and return the number of bytes they have or would have
written; this allows for chunk writing functions to first determine the size
}
+// ----------------------------------------------------------------------------
+// functions to convert between ISO-8859-1 and UTF-8
+// ----------------------------------------------------------------------------
+
+char *getUTF8FromLatin1(char *latin1)
+{
+ int max_utf8_size = 2 * strlen(latin1) + 1;
+ char *utf8 = checked_calloc(max_utf8_size);
+ unsigned char *src = (unsigned char *)latin1;
+ unsigned char *dst = (unsigned char *)utf8;
+
+ while (*src)
+ {
+ if (*src < 128) // pure 7-bit ASCII
+ {
+ *dst++ = *src;
+ }
+ else if (*src >= 160) // non-ASCII characters
+ {
+ *dst++ = 194 + (*src >= 192);
+ *dst++ = 128 + (*src & 63);
+ }
+ else // undefined in ISO-8859-1
+ {
+ *dst++ = '?';
+ }
+
+ src++;
+ }
+
+ // only use the smallest possible string buffer size
+ utf8 = checked_realloc(utf8, strlen(utf8) + 1);
+
+ return utf8;
+}
+
+char *getLatin1FromUTF8(char *utf8)
+{
+ int max_latin1_size = strlen(utf8) + 1;
+ char *latin1 = checked_calloc(max_latin1_size);
+ unsigned char *src = (unsigned char *)utf8;
+ unsigned char *dst = (unsigned char *)latin1;
+
+ while (*src)
+ {
+ if (*src < 128) // pure 7-bit ASCII
+ {
+ *dst++ = *src++;
+ }
+ else if (src[0] == 194 &&
+ src[1] >= 128 && src[1] < 192) // non-ASCII characters
+ {
+ *dst++ = src[1];
+ src += 2;
+ }
+ else if (src[0] == 195 &&
+ src[1] >= 128 && src[1] < 192) // non-ASCII characters
+ {
+ *dst++ = src[1] + 64;
+ src += 2;
+ }
+
+ // all other UTF-8 characters are undefined in ISO-8859-1
+
+ else if (src[0] >= 192 && src[0] < 224 &&
+ src[1] >= 128 && src[1] < 192)
+ {
+ *dst++ = '?';
+ src += 2;
+ }
+ else if (src[0] >= 224 && src[0] < 240 &&
+ src[1] >= 128 && src[1] < 192 &&
+ src[2] >= 128 && src[2] < 192)
+ {
+ *dst++ = '?';
+ src += 3;
+ }
+ else if (src[0] >= 240 && src[0] < 248 &&
+ src[1] >= 128 && src[1] < 192 &&
+ src[2] >= 128 && src[2] < 192 &&
+ src[3] >= 128 && src[3] < 192)
+ {
+ *dst++ = '?';
+ src += 4;
+ }
+ else if (src[0] >= 248 && src[0] < 252 &&
+ src[1] >= 128 && src[1] < 192 &&
+ src[2] >= 128 && src[2] < 192 &&
+ src[3] >= 128 && src[3] < 192 &&
+ src[4] >= 128 && src[4] < 192)
+ {
+ *dst++ = '?';
+ src += 5;
+ }
+ else if (src[0] >= 252 && src[0] < 254 &&
+ src[1] >= 128 && src[1] < 192 &&
+ src[2] >= 128 && src[2] < 192 &&
+ src[3] >= 128 && src[3] < 192 &&
+ src[4] >= 128 && src[4] < 192 &&
+ src[5] >= 128 && src[5] < 192)
+ {
+ *dst++ = '?';
+ src += 6;
+ }
+ else
+ {
+ *dst++ = '?';
+ src++;
+ }
+ }
+
+ // only use the smallest possible string buffer size
+ latin1 = checked_realloc(latin1, strlen(latin1) + 1);
+
+ return latin1;
+}
+
+int getTextEncoding(char *text)
+{
+ unsigned char *src = (unsigned char *)text;
+ int encoding = TEXT_ENCODING_ASCII; // default: assume encoding is ASCII
+
+ while (*src)
+ {
+ if (*src >= 128)
+ encoding = TEXT_ENCODING_UTF_8; // non-ASCII character: assume UTF-8
+
+ if (*src < 128)
+ {
+ src++;
+ }
+ else if (src[0] >= 192 && src[0] < 224 &&
+ src[1] >= 128 && src[1] < 192)
+ {
+ src += 2;
+ }
+ else if (src[0] >= 224 && src[0] < 240 &&
+ src[1] >= 128 && src[1] < 192 &&
+ src[2] >= 128 && src[2] < 192)
+ {
+ src += 3;
+ }
+ else if (src[0] >= 240 && src[0] < 248 &&
+ src[1] >= 128 && src[1] < 192 &&
+ src[2] >= 128 && src[2] < 192 &&
+ src[3] >= 128 && src[3] < 192)
+ {
+ src += 4;
+ }
+ else if (src[0] >= 248 && src[0] < 252 &&
+ src[1] >= 128 && src[1] < 192 &&
+ src[2] >= 128 && src[2] < 192 &&
+ src[3] >= 128 && src[3] < 192 &&
+ src[4] >= 128 && src[4] < 192)
+ {
+ src += 5;
+ }
+ else if (src[0] >= 252 && src[0] < 254 &&
+ src[1] >= 128 && src[1] < 192 &&
+ src[2] >= 128 && src[2] < 192 &&
+ src[3] >= 128 && src[3] < 192 &&
+ src[4] >= 128 && src[4] < 192 &&
+ src[5] >= 128 && src[5] < 192)
+ {
+ src += 6;
+ }
+ else
+ {
+ return TEXT_ENCODING_UNKNOWN; // non-UTF-8 character: unknown encoding
+ }
+ }
+
+ return encoding;
+}
+
+
+// ----------------------------------------------------------------------------
+// functions for JSON handling
+// ----------------------------------------------------------------------------
+
+char *getEscapedJSON(char *s)
+{
+ int max_json_size = 2 * strlen(s) + 1;
+ char *json = checked_calloc(max_json_size);
+ unsigned char *src = (unsigned char *)s;
+ unsigned char *dst = (unsigned char *)json;
+ char *escaped[256] =
+ {
+ ['\b'] = "\\b",
+ ['\f'] = "\\f",
+ ['\n'] = "\\n",
+ ['\r'] = "\\r",
+ ['\t'] = "\\t",
+ ['\"'] = "\\\"",
+ ['\\'] = "\\\\",
+ };
+
+ while (*src)
+ {
+ if (escaped[*src] != NULL)
+ {
+ char *esc = escaped[*src++];
+
+ while (*esc)
+ *dst++ = *esc++;
+ }
+ else
+ {
+ *dst++ = *src++;
+ }
+ }
+
+ // only use the smallest possible string buffer size
+ json = checked_realloc(json, strlen(json) + 1);
+
+ return json;
+}
+
+
// ----------------------------------------------------------------------------
// functions to translate key identifiers between different format
// ----------------------------------------------------------------------------
int get_integer_from_string(char *s)
{
- static char *number_text[][3] =
- {
- { "0", "zero", "null", },
- { "1", "one", "first" },
- { "2", "two", "second" },
- { "3", "three", "third" },
- { "4", "four", "fourth" },
- { "5", "five", "fifth" },
- { "6", "six", "sixth" },
- { "7", "seven", "seventh" },
- { "8", "eight", "eighth" },
- { "9", "nine", "ninth" },
- { "10", "ten", "tenth" },
- { "11", "eleven", "eleventh" },
- { "12", "twelve", "twelfth" },
-
- { NULL, NULL, NULL },
- };
+ // check for the most common case first
+ if (s[0] >= '0' && s[0] <= '9')
+ return atoi(s);
- int i, j;
char *s_lower = getStringToLower(s);
int result = -1;
- for (i = 0; number_text[i][0] != NULL; i++)
- for (j = 0; j < 3; j++)
- if (strEqual(s_lower, number_text[i][j]))
- result = i;
-
- if (result == -1)
- {
- if (strEqual(s_lower, "false") ||
- strEqual(s_lower, "no") ||
- strEqual(s_lower, "off"))
- result = 0;
- else if (strEqual(s_lower, "true") ||
- strEqual(s_lower, "yes") ||
- strEqual(s_lower, "on"))
- result = 1;
- else
- result = atoi(s);
- }
+ if (strEqual(s_lower, "false") ||
+ strEqual(s_lower, "no") ||
+ strEqual(s_lower, "off"))
+ result = 0;
+ else if (strEqual(s_lower, "true") ||
+ strEqual(s_lower, "yes") ||
+ strEqual(s_lower, "on"))
+ result = 1;
+ else
+ result = atoi(s);
free(s_lower);
return 0;
}
+boolean touchFile(char *filename)
+{
+ FILE *file;
+
+ if (!(file = fopen(filename, MODE_WRITE)))
+ {
+ Warn("cannot touch file '%s'", filename);
+
+ return FALSE;
+ }
+
+ fclose(file);
+
+ return TRUE;
+}
+
// ----------------------------------------------------------------------------
// functions for directory handling
// functions for checking files and filenames
// ----------------------------------------------------------------------------
-boolean directoryExists(char *dir_name)
+boolean directoryExists(const char *dir_name)
{
if (dir_name == NULL)
return FALSE;
return success;
}
-boolean fileExists(char *filename)
+boolean fileExists(const char *filename)
{
if (filename == NULL)
return FALSE;
}
#if 0
-static boolean fileHasPrefix(char *basename, char *prefix)
+static boolean fileHasPrefix(const char *basename, const char *prefix)
{
static char *basename_lower = NULL;
int basename_length, prefix_length;
}
#endif
-static boolean fileHasSuffix(char *basename, char *suffix)
+static boolean fileHasSuffix(const char *basename, const char *suffix)
{
static char *basename_lower = NULL;
int basename_length, suffix_length;
char *filename_base = UNDEFINED_FILENAME, *filename_local;
int i, j;
- DrawInitText("Loading artwork config", 120, FC_GREEN);
- DrawInitText(ARTWORKINFO_FILENAME(artwork_info->type), 150, FC_YELLOW);
+ DrawInitTextHead("Loading artwork config");
+ DrawInitTextItem(ARTWORKINFO_FILENAME(artwork_info->type));
// always start with reliable default values
for (i = 0; i < num_file_list_entries; i++)
char *basename = file_list_entry->filename;
char *filename = getCustomArtworkFilename(basename, artwork_info->type);
+ // mark all images from non-default graphics directory as "redefined"
+ if (artwork_info->type == ARTWORK_TYPE_GRAPHICS &&
+ !strPrefix(filename, options.graphics_directory))
+ file_list_entry->redefined = TRUE;
+
if (filename == NULL)
{
Warn("cannot find artwork file '%s'", basename);
return;
}
- DrawInitText(init_text[artwork_info->type], 120, FC_GREEN);
- DrawInitText(basename, 150, FC_YELLOW);
+ DrawInitTextHead(init_text[artwork_info->type]);
+ DrawInitTextItem(basename);
if ((*listnode = artwork_info->load_artwork(filename)) != NULL)
{
// (now also added for Windows, to create files in user data directory)
// ----------------------------------------------------------------------------
-char *getLogFilename(char *basename)
+char *getLogBasename(char *basename)
{
- return getPath2(getUserGameDataDir(), basename);
+ return getStringCat2(basename, ".log");
}
-void OpenLogFiles(void)
+char *getLogFilename(char *basename)
{
- int i;
+ return getPath2(getMainUserGameDataDir(), basename);
+}
- InitUserDataDirectory();
+void OpenLogFile(void)
+{
+ InitMainUserDataDirectory();
- for (i = 0; i < NUM_LOGS; i++)
+ if ((program.log_file = fopen(program.log_filename, MODE_WRITE)) == NULL)
{
- if ((program.log_file[i] = fopen(program.log_filename[i], MODE_WRITE))
- == NULL)
- {
- program.log_file[i] = program.log_file_default[i]; // reset to default
-
- Warn("cannot open file '%s' for writing: %s",
- program.log_filename[i], strerror(errno));
- }
+ program.log_file = program.log_file_default; // reset to default
- // output should be unbuffered so it is not truncated in a crash
- setbuf(program.log_file[i], NULL);
+ Warn("cannot open file '%s' for writing: %s",
+ program.log_filename, strerror(errno));
}
+
+ // output should be unbuffered so it is not truncated in a crash
+ setbuf(program.log_file, NULL);
}
-void CloseLogFiles(void)
+void CloseLogFile(void)
{
- int i;
-
- for (i = 0; i < NUM_LOGS; i++)
- if (program.log_file[i] != program.log_file_default[i])
- fclose(program.log_file[i]);
+ if (program.log_file != program.log_file_default)
+ fclose(program.log_file);
}
-void DumpLogFile(int nr)
+void DumpLogFile(void)
{
- FILE *log_file = fopen(program.log_filename[nr], MODE_READ);
+ FILE *log_file = fopen(program.log_filename, MODE_READ);
if (log_file == NULL)
return;
void NotifyUserAboutErrorFile(void)
{
-#if defined(PLATFORM_WIN32)
+#if defined(PLATFORM_WINDOWS)
char *title_text = getStringCat2(program.program_title, " Error Message");
char *error_text = getStringCat2("The program was aborted due to an error; "
"for details, see the following error file:"
STRING_NEWLINE,
- program.log_filename[LOG_ERR_ID]);
+ program.log_filename);
MessageBox(NULL, error_text, title_text, MB_OK);
#endif
#if DEBUG
-#define DEBUG_PRINT_INIT_TIMESTAMPS FALSE
+#define DEBUG_PRINT_INIT_TIMESTAMPS TRUE
#define DEBUG_PRINT_INIT_TIMESTAMPS_DEPTH 10
#define DEBUG_NUM_TIMESTAMPS 10
counter[counter_nr][1] = counter[counter_nr][0];
if (message)
- Debug("time", "%s%s%s %.3f %s",
+ Debug("time:init", "%s%s%s %.3f %s",
debug_print_timestamp_get_padding(counter_nr * indent_size),
message,
debug_print_timestamp_get_padding(padding_size - strlen(message)),