/* system info functions */
/* ------------------------------------------------------------------------- */
-#if !defined(PLATFORM_MSDOS)
+#if !defined(PLATFORM_MSDOS) && !defined(PLATFORM_ANDROID)
static char *get_corrected_real_name(char *real_name)
{
char *real_name_new = checked_malloc(MAX_USERNAME_LEN + 1);
char *process_name = "";
#if defined(PLATFORM_ANDROID)
- android_log_prio = (mode & ERR_WARN ? ANDROID_LOG_WARN :
- mode & ERR_EXIT ? ANDROID_LOG_FATAL : ANDROID_LOG_INFO);
+ android_log_prio = (mode & ERR_DEBUG ? ANDROID_LOG_DEBUG :
+ mode & ERR_INFO ? ANDROID_LOG_INFO :
+ mode & ERR_WARN ? ANDROID_LOG_WARN :
+ mode & ERR_EXIT ? ANDROID_LOG_FATAL :
+ ANDROID_LOG_UNKNOWN);
#endif
#if 1
of the (not yet written) chunk, write the correct chunk size and finally
write the chunk itself */
+#if 1
+
+int getFile8BitInteger(File *file)
+{
+ return getByteFromFile(file);
+}
+
+#else
+
int getFile8BitInteger(FILE *file)
{
return fgetc(file);
}
+#endif
+
int putFile8BitInteger(FILE *file, int value)
{
if (file != NULL)
return 1;
}
+#if 1
+
+int getFile16BitInteger(File *file, int byte_order)
+{
+ if (byte_order == BYTE_ORDER_BIG_ENDIAN)
+ return ((getByteFromFile(file) << 8) |
+ (getByteFromFile(file) << 0));
+ else /* BYTE_ORDER_LITTLE_ENDIAN */
+ return ((getByteFromFile(file) << 0) |
+ (getByteFromFile(file) << 8));
+}
+
+#else
+
int getFile16BitInteger(FILE *file, int byte_order)
{
if (byte_order == BYTE_ORDER_BIG_ENDIAN)
(fgetc(file) << 8));
}
+#endif
+
int putFile16BitInteger(FILE *file, int value, int byte_order)
{
if (file != NULL)
return 2;
}
+#if 1
+
+int getFile32BitInteger(File *file, int byte_order)
+{
+ if (byte_order == BYTE_ORDER_BIG_ENDIAN)
+ return ((getByteFromFile(file) << 24) |
+ (getByteFromFile(file) << 16) |
+ (getByteFromFile(file) << 8) |
+ (getByteFromFile(file) << 0));
+ else /* BYTE_ORDER_LITTLE_ENDIAN */
+ return ((getByteFromFile(file) << 0) |
+ (getByteFromFile(file) << 8) |
+ (getByteFromFile(file) << 16) |
+ (getByteFromFile(file) << 24));
+}
+
+#else
+
int getFile32BitInteger(FILE *file, int byte_order)
{
if (byte_order == BYTE_ORDER_BIG_ENDIAN)
(fgetc(file) << 24));
}
+#endif
+
int putFile32BitInteger(FILE *file, int value, int byte_order)
{
if (file != NULL)
return 4;
}
+#if 1
+
+boolean getFileChunk(File *file, char *chunk_name, int *chunk_size,
+ int byte_order)
+{
+ const int chunk_name_length = 4;
+
+ /* read chunk name */
+ if (getStringFromFile(file, chunk_name, chunk_name_length + 1) == NULL)
+ return FALSE;
+
+ if (chunk_size != NULL)
+ {
+ /* read chunk size */
+ *chunk_size = getFile32BitInteger(file, byte_order);
+ }
+
+ return (checkEndOfFile(file) ? FALSE : TRUE);
+}
+
+#else
+
boolean getFileChunk(FILE *file, char *chunk_name, int *chunk_size,
int byte_order)
{
return (feof(file) || ferror(file) ? FALSE : TRUE);
}
+#endif
+
int putFileChunk(FILE *file, char *chunk_name, int chunk_size,
int byte_order)
{
return num_bytes;
}
+#if 1
+
+int getFileVersion(File *file)
+{
+ int version_major = getByteFromFile(file);
+ int version_minor = getByteFromFile(file);
+ int version_patch = getByteFromFile(file);
+ int version_build = getByteFromFile(file);
+
+ return VERSION_IDENT(version_major, version_minor, version_patch,
+ version_build);
+}
+
+#else
+
int getFileVersion(FILE *file)
{
int version_major = fgetc(file);
version_build);
}
+#endif
+
int putFileVersion(FILE *file, int version)
{
if (file != NULL)
return 4;
}
+#if 1
+
+void ReadBytesFromFile(File *file, byte *buffer, unsigned int bytes)
+{
+ int i;
+
+ for (i = 0; i < bytes && !checkEndOfFile(file); i++)
+ buffer[i] = getByteFromFile(file);
+}
+
+#else
+
void ReadBytesFromFile(FILE *file, byte *buffer, unsigned int bytes)
{
int i;
buffer[i] = fgetc(file);
}
+#endif
+
void WriteBytesToFile(FILE *file, byte *buffer, unsigned int bytes)
{
int i;
fputc(buffer[i], file);
}
+#if 1
+
+void ReadUnusedBytesFromFile(File *file, unsigned int bytes)
+{
+ while (bytes-- && !checkEndOfFile(file))
+ getByteFromFile(file);
+}
+
+#else
+
void ReadUnusedBytesFromFile(FILE *file, unsigned int bytes)
{
while (bytes-- && !feof(file))
fgetc(file);
}
+#endif
+
void WriteUnusedBytesToFile(FILE *file, unsigned int bytes)
{
while (bytes--)
{ KSYM_End, "XK_End", "end" },
{ KSYM_Page_Up, "XK_Page_Up", "page up" },
{ KSYM_Page_Down, "XK_Page_Down", "page down" },
- { KSYM_Menu, "XK_Menu", "menu" }, /* Win-Menu */
+
+ { KSYM_Menu, "XK_Menu", "menu" }, /* menu key */
+ { KSYM_Back, "XK_Back", "back" }, /* back key */
/* ASCII 0x20 to 0x40 keys (except numbers) */
{ KSYM_space, "XK_space", "space" },
return feof(file->file);
}
+size_t readFile(File *file, void *buffer, size_t item_size, size_t num_items)
+{
+#if defined(PLATFORM_ANDROID)
+ if (file->file_is_asset)
+ {
+ if (file->end_of_file)
+ return 0;
+
+ size_t num_items_read =
+ SDL_RWread(file->asset_file, buffer, item_size, num_items);
+
+ if (num_items_read < num_items)
+ file->end_of_file = TRUE;
+
+ return num_items_read;
+ }
+#endif
+
+ return fread(buffer, item_size, num_items, file->file);
+}
+
+int seekFile(File *file, long offset, int whence)
+{
+#if defined(PLATFORM_ANDROID)
+ if (file->file_is_asset)
+ {
+ int sdl_whence = (whence == SEEK_SET ? RW_SEEK_SET :
+ whence == SEEK_CUR ? RW_SEEK_CUR :
+ whence == SEEK_END ? RW_SEEK_END : 0);
+
+ return (SDL_RWseek(file->asset_file, offset, sdl_whence) == -1 ? -1 : 0);
+ }
+#endif
+
+ return fseek(file->file, offset, whence);
+}
+
+int getByteFromFile(File *file)
+{
+#if defined(PLATFORM_ANDROID)
+ if (file->file_is_asset)
+ {
+ if (file->end_of_file)
+ return EOF;
+
+ byte c;
+ size_t num_bytes_read = SDL_RWread(file->asset_file, &c, 1, 1);
+
+ if (num_bytes_read < 1)
+ file->end_of_file = TRUE;
+
+ return (file->end_of_file ? EOF : (int)c);
+ }
+#endif
+
+ return fgetc(file->file);
+}
+
char *getStringFromFile(File *file, char *line, int size)
{
#if defined(PLATFORM_ANDROID)
dir->dir_entry = checked_calloc(sizeof(DirectoryEntry));
dir->dir_entry->is_directory = FALSE;
- if (line[strlen(line) - 1] = '/')
+ if (line[strlen(line) - 1] == '/')
{
dir->dir_entry->is_directory = TRUE;
dir->dir_entry->is_directory =
(stat(dir->dir_entry->filename, &file_status) == 0 &&
- (file_status.st_mode & S_IFMT) != S_IFDIR);
+ (file_status.st_mode & S_IFMT) == S_IFDIR);
+
+#if 0
+ Error(ERR_INFO, "::: '%s' is directory: %d",
+ dir->dir_entry->basename,
+ dir->dir_entry->is_directory);
+#endif
return dir->dir_entry;
}
/* functions for checking files and filenames */
/* ------------------------------------------------------------------------- */
+boolean directoryExists(char *dir_name)
+{
+ if (dir_name == NULL)
+ return FALSE;
+
+ boolean success = (access(dir_name, F_OK) == 0);
+
+#if defined(PLATFORM_ANDROID)
+ if (!success)
+ {
+ // this might be an asset directory; check by trying to open toc file
+ char *asset_toc_filename = getPath2(dir_name, ASSET_TOC_BASENAME);
+ SDL_RWops *file = SDL_RWFromFile(asset_toc_filename, MODE_READ);
+
+ checked_free(asset_toc_filename);
+
+ success = (file != NULL);
+
+ if (success)
+ SDL_RWclose(file);
+ }
+#endif
+
+ return success;
+}
+
boolean fileExists(char *filename)
{
if (filename == NULL)
return FALSE;
+ boolean success = (access(filename, F_OK) == 0);
+
#if defined(PLATFORM_ANDROID)
- // workaround: check if file exists by opening and closing it
- SDL_RWops *file = SDL_RWFromFile(filename, MODE_READ);
- boolean success = (file != NULL);
+ if (!success)
+ {
+ // this might be an asset file; check by trying to open it
+ SDL_RWops *file = SDL_RWFromFile(filename, MODE_READ);
- if (success)
- SDL_RWclose(file);
+ success = (file != NULL);
- return success;
-#else
- return (access(filename, F_OK) == 0);
+ if (success)
+ SDL_RWclose(file);
+ }
#endif
+
+ return success;
}
boolean fileHasPrefix(char *basename, char *prefix)
{
char *basename = getBaseNamePtr(filename);
+#if defined(TARGET_SDL)
+ return (!fileHasSuffix(basename, "txt") &&
+ !fileHasSuffix(basename, "conf"));
+#else
return fileHasSuffix(basename, "pcx");
+#endif
}
boolean FileIsSound(char *filename)
{
char *basename = getBaseNamePtr(filename);
+#if defined(TARGET_SDL)
+ return (!fileHasSuffix(basename, "txt") &&
+ !fileHasSuffix(basename, "conf"));
+#else
return fileHasSuffix(basename, "wav");
+#endif
}
boolean FileIsMusic(char *filename)
{
char *basename = getBaseNamePtr(filename);
+#if defined(TARGET_SDL)
+ return (!fileHasSuffix(basename, "txt") &&
+ !fileHasSuffix(basename, "conf"));
+#else
if (FileIsSound(basename))
return TRUE;
+#if 0
#if defined(TARGET_SDL)
if ((fileHasPrefix(basename, "mod") && !fileHasSuffix(basename, "txt")) ||
fileHasSuffix(basename, "mod") ||
fileHasSuffix(basename, "mp3") ||
fileHasSuffix(basename, "ogg"))
return TRUE;
+#endif
#endif
return FALSE;
+#endif
}
boolean FileIsArtworkType(char *basename, int type)
}
list_pos = 0;
+
for (i = 0; config_list[i].token != NULL; i++)
{
int len_config_token = strlen(config_list[i].token);
+#if 0
int len_config_value = strlen(config_list[i].value);
+#endif
boolean is_file_entry = TRUE;
for (j = 0; suffix_list[j].token != NULL; j++)
config_list[i].value);
is_file_entry = FALSE;
+
break;
}
}
if (list_pos >= num_file_list_entries)
break;
+#if 0
/* simple sanity check if this is really a file definition */
if (!strEqual(&config_list[i].value[len_config_value - 4], ".pcx") &&
!strEqual(&config_list[i].value[len_config_value - 4], ".wav") &&
config_list[i].token, config_list[i].value);
Error(ERR_EXIT, "This seems to be no valid definition -- please fix");
}
+#endif
file_list[list_pos].token = config_list[i].token;
file_list[list_pos].default_filename = config_list[i].value;
if (strEqual(file_list_entry->filename, UNDEFINED_FILENAME))
{
deleteArtworkListEntry(artwork_info, listnode);
+
return;
}
artwork_info->num_dynamic_file_list_entries;
int i;
+ print_timestamp_init("ReloadCustomArtworkList");
+
for (i = 0; i < num_file_list_entries; i++)
LoadCustomArtwork(artwork_info, &artwork_info->artwork_list[i],
&file_list[i]);
LoadCustomArtwork(artwork_info, &artwork_info->dynamic_artwork_list[i],
&dynamic_file_list[i]);
+ print_timestamp_done("ReloadCustomArtworkList");
+
#if 0
dumpList(artwork_info->content_list);
#endif
#if DEBUG
-#define DEBUG_NUM_TIMESTAMPS 5
-#define DEBUG_TIME_IN_MICROSECONDS 0
+#define DEBUG_PRINT_INIT_TIMESTAMPS TRUE
+#define DEBUG_PRINT_INIT_TIMESTAMPS_DEPTH 10
+
+#define DEBUG_NUM_TIMESTAMPS 10
+#define DEBUG_TIME_IN_MICROSECONDS 0
#if DEBUG_TIME_IN_MICROSECONDS
static double Counter_Microseconds()
counter[counter_nr][1] = counter[counter_nr][0];
if (message)
+#if 1
+ Error(ERR_DEBUG, "%s%s%s %.3f %s",
+#else
printf("%s%s%s %.3f %s\n",
+#endif
debug_print_timestamp_get_padding(counter_nr * indent_size),
message,
debug_print_timestamp_get_padding(padding_size - strlen(message)),
printf("\n");
}
}
+
+void print_timestamp_ext(char *message, char *mode)
+{
+#if DEBUG_PRINT_INIT_TIMESTAMPS
+ static char *debug_message = NULL;
+ static char *last_message = NULL;
+ static int counter_nr = 0;
+ int max_depth = DEBUG_PRINT_INIT_TIMESTAMPS_DEPTH;
+
+ checked_free(debug_message);
+ debug_message = getStringCat3(mode, " ", message);
+
+ if (strEqual(mode, "INIT"))
+ {
+ debug_print_timestamp(counter_nr, NULL);
+
+ if (counter_nr + 1 < max_depth)
+ debug_print_timestamp(counter_nr, debug_message);
+
+ counter_nr++;
+
+ debug_print_timestamp(counter_nr, NULL);
+ }
+ else if (strEqual(mode, "DONE"))
+ {
+ counter_nr--;
+
+ if (counter_nr + 1 < max_depth ||
+ (counter_nr == 0 && max_depth == 1))
+ {
+ last_message = message;
+
+ if (counter_nr == 0 && max_depth == 1)
+ {
+ checked_free(debug_message);
+ debug_message = getStringCat3("TIME", " ", message);
+ }
+
+ debug_print_timestamp(counter_nr, debug_message);
+ }
+ }
+ else if (!strEqual(mode, "TIME") ||
+ !strEqual(message, last_message))
+ {
+ if (counter_nr < max_depth)
+ debug_print_timestamp(counter_nr, debug_message);
+ }
#endif
+}
+
+void print_timestamp_init(char *message)
+{
+ print_timestamp_ext(message, "INIT");
+}
+
+void print_timestamp_time(char *message)
+{
+ print_timestamp_ext(message, "TIME");
+}
+
+void print_timestamp_done(char *message)
+{
+ print_timestamp_ext(message, "DONE");
+}
+
+#endif /* DEBUG */
projects / rocksndiamonds.git / blobdiff