src/libgame/misc.c

   1 /***********************************************************
   2 * Artsoft Retro-Game Library                               *
   3 *----------------------------------------------------------*
   4 * (c) 1994-2006 Artsoft Entertainment                      *
   5 *               Holger Schemel                             *
   6 *               Detmolder Strasse 189                      *
   7 *               33604 Bielefeld                            *
   8 *               Germany                                    *
   9 *               e-mail: info@artsoft.org                   *
  10 *----------------------------------------------------------*
  11 * misc.c                                                   *
  12 ***********************************************************/
  13
  14 #include <time.h>
  15 #include <sys/time.h>
  16 #include <sys/types.h>
  17 #include <sys/stat.h>
  18 #include <stdarg.h>
  19 #include <ctype.h>
  20 #include <string.h>
  21 #include <unistd.h>
  22 #include <errno.h>
  23
  24 #include "platform.h"
  25
  26 #if !defined(PLATFORM_WIN32)
  27 #include <pwd.h>
  28 #include <sys/param.h>
  29 #endif
  30
  31 #include "misc.h"
  32 #include "setup.h"
  33 #include "random.h"
  34 #include "text.h"
  35 #include "image.h"
  36
  37
  38 /* ========================================================================= */
  39 /* some generic helper functions                                             */
  40 /* ========================================================================= */
  41
  42 /* ------------------------------------------------------------------------- */
  43 /* platform independent wrappers for printf() et al. (newline aware)         */
  44 /* ------------------------------------------------------------------------- */
  45
  46 #if defined(PLATFORM_ANDROID)
  47 static int android_log_prio = ANDROID_LOG_INFO;
  48 #endif
  49
  50 #if 0
  51 static void vfPrintLog(FILE *stream, char *format, va_list ap)
  52 {
  53 }
  54
  55 static void vfPrintLog(FILE *stream, char *format, va_list ap)
  56 {
  57 }
  58
  59 static void fPrintLog(FILE *stream, char *format, va_list ap)
  60 {
  61 }
  62
  63 static void fPrintLog(FILE *stream, char *format, va_list ap)
  64 {
  65 }
  66 #endif
  67
  68 static void vfprintf_nonewline(FILE *stream, char *format, va_list ap)
  69 {
  70 #if defined(PLATFORM_ANDROID)
  71   // (prefix text of logging output is currently skipped on Android)
  72   //__android_log_vprint(android_log_prio, program.program_title, format, ap);
  73 #else
  74   va_list ap2;
  75   va_copy(ap2, ap);
  76
  77   vfprintf(stream, format, ap);
  78   vfprintf(stderr, format, ap2);
  79
  80   va_end(ap2);
  81 #endif
  82 }
  83
  84 static void vfprintf_newline(FILE *stream, char *format, va_list ap)
  85 {
  86 #if defined(PLATFORM_ANDROID)
  87   __android_log_vprint(android_log_prio, program.program_title, format, ap);
  88 #else
  89   char *newline = STRING_NEWLINE;
  90
  91   va_list ap2;
  92   va_copy(ap2, ap);
  93
  94   vfprintf(stream, format, ap);
  95   fprintf(stream, "%s", newline);
  96
  97   vfprintf(stderr, format, ap2);
  98   fprintf(stderr, "%s", newline);
  99
 100   va_end(ap2);
 101 #endif
 102 }
 103
 104 static void fprintf_nonewline(FILE *stream, char *format, ...)
 105 {
 106   va_list ap;
 107
 108   va_start(ap, format);
 109   vfprintf_nonewline(stream, format, ap);
 110   va_end(ap);
 111 }
 112
 113 static void fprintf_newline(FILE *stream, char *format, ...)
 114 {
 115   va_list ap;
 116
 117   va_start(ap, format);
 118   vfprintf_newline(stream, format, ap);
 119   va_end(ap);
 120 }
 121
 122 void fprintf_line(FILE *stream, char *line_chars, int line_length)
 123 {
 124   int i;
 125
 126   for (i = 0; i < line_length; i++)
 127     fprintf_nonewline(stream, "%s", line_chars);
 128
 129   fprintf_newline(stream, "");
 130 }
 131
 132 void printf_line(char *line_chars, int line_length)
 133 {
 134   fprintf_line(stdout, line_chars, line_length);
 135 }
 136
 137 void printf_line_with_prefix(char *prefix, char *line_chars, int line_length)
 138 {
 139   fprintf(stdout, "%s", prefix);
 140   fprintf_line(stdout, line_chars, line_length);
 141 }
 142
 143
 144 /* ------------------------------------------------------------------------- */
 145 /* string functions                                                          */
 146 /* ------------------------------------------------------------------------- */
 147
 148 /* int2str() returns a number converted to a string;
 149    the used memory is static, but will be overwritten by later calls,
 150    so if you want to save the result, copy it to a private string buffer;
 151    there can be 10 local calls of int2str() without buffering the result --
 152    the 11th call will then destroy the result from the first call and so on.
 153 */
 154
 155 char *int2str(int number, int size)
 156 {
 157   static char shift_array[10][40];
 158   static int shift_counter = 0;
 159   char *s = shift_array[shift_counter];
 160
 161   shift_counter = (shift_counter + 1) % 10;
 162
 163   if (size > 20)
 164     size = 20;
 165
 166   if (size > 0)
 167   {
 168     sprintf(s, "                    %09d", number);
 169     return &s[strlen(s) - size];
 170   }
 171   else
 172   {
 173     sprintf(s, "%d", number);
 174     return s;
 175   }
 176 }
 177
 178
 179 /* something similar to "int2str()" above, but allocates its own memory
 180    and has a different interface; we cannot use "itoa()", because this
 181    seems to be already defined when cross-compiling to the win32 target */
 182
 183 char *i_to_a(unsigned int i)
 184 {
 185   static char *a = NULL;
 186
 187   checked_free(a);
 188
 189   if (i > 2147483647)   /* yes, this is a kludge */
 190     i = 2147483647;
 191
 192   a = checked_malloc(10 + 1);
 193
 194   sprintf(a, "%d", i);
 195
 196   return a;
 197 }
 198
 199
 200 /* calculate base-2 logarithm of argument (rounded down to integer;
 201    this function returns the number of the highest bit set in argument) */
 202
 203 int log_2(unsigned int x)
 204 {
 205   int e = 0;
 206
 207   while ((1 << e) < x)
 208   {
 209     x -= (1 << e);      /* for rounding down (rounding up: remove this line) */
 210     e++;
 211   }
 212
 213   return e;
 214 }
 215
 216 boolean getTokenValueFromString(char *string, char **token, char **value)
 217 {
 218   return getTokenValueFromSetupLine(string, token, value);
 219 }
 220
 221
 222 /* ------------------------------------------------------------------------- */
 223 /* counter functions                                                         */
 224 /* ------------------------------------------------------------------------- */
 225
 226 /* maximal allowed length of a command line option */
 227 #define MAX_OPTION_LEN          256
 228
 229 #if 1
 230
 231 #if defined(TARGET_SDL)
 232 static unsigned int getCurrentMS()
 233 {
 234   return SDL_GetTicks();
 235 }
 236 #endif
 237
 238 static unsigned int mainCounter(int mode)
 239 {
 240   static unsigned int base_ms = 0;
 241   unsigned int current_ms;
 242
 243   /* get current system milliseconds */
 244   current_ms = getCurrentMS();
 245
 246   /* reset base timestamp in case of counter reset or wrap-around */
 247   if (mode == INIT_COUNTER || current_ms < base_ms)
 248     base_ms = current_ms;
 249
 250   /* return milliseconds since last counter reset */
 251   return current_ms - base_ms;
 252 }
 253
 254 #else
 255
 256 #if defined(TARGET_SDL)
 257 static unsigned int mainCounter(int mode)
 258 {
 259   static unsigned int base_ms = 0;
 260   unsigned int current_ms;
 261   unsigned int counter_ms;
 262
 263   current_ms = SDL_GetTicks();
 264
 265   /* reset base time in case of counter initializing or wrap-around */
 266   if (mode == INIT_COUNTER || current_ms < base_ms)
 267     base_ms = current_ms;
 268
 269   counter_ms = current_ms - base_ms;
 270
 271   return counter_ms;            /* return milliseconds since last init */
 272 }
 273 #endif
 274
 275 #endif
 276
 277 void InitCounter()              /* set counter back to zero */
 278 {
 279   mainCounter(INIT_COUNTER);
 280 }
 281
 282 unsigned int Counter()  /* get milliseconds since last call of InitCounter() */
 283 {
 284   return mainCounter(READ_COUNTER);
 285 }
 286
 287 static void sleep_milliseconds(unsigned int milliseconds_delay)
 288 {
 289   boolean do_busy_waiting = (milliseconds_delay < 5 ? TRUE : FALSE);
 290
 291   if (do_busy_waiting)
 292   {
 293     /* we want to wait only a few ms -- if we assume that we have a
 294        kernel timer resolution of 10 ms, we would wait far to long;
 295        therefore it's better to do a short interval of busy waiting
 296        to get our sleeping time more accurate */
 297
 298     unsigned int base_counter = Counter(), actual_counter = Counter();
 299
 300     while (actual_counter < base_counter + milliseconds_delay &&
 301            actual_counter >= base_counter)
 302       actual_counter = Counter();
 303   }
 304   else
 305   {
 306 #if defined(TARGET_SDL)
 307     SDL_Delay(milliseconds_delay);
 308 #else
 309     struct timeval delay;
 310
 311     delay.tv_sec  = milliseconds_delay / 1000;
 312     delay.tv_usec = 1000 * (milliseconds_delay % 1000);
 313
 314     if (select(0, NULL, NULL, NULL, &delay) != 0)
 315       Error(ERR_WARN, "sleep_milliseconds(): select() failed");
 316 #endif
 317   }
 318 }
 319
 320 void Delay(unsigned int delay)  /* Sleep specified number of milliseconds */
 321 {
 322   sleep_milliseconds(delay);
 323 }
 324
 325 boolean FrameReached(unsigned int *frame_counter_var,
 326                      unsigned int frame_delay)
 327 {
 328   unsigned int actual_frame_counter = FrameCounter;
 329
 330   if (actual_frame_counter >= *frame_counter_var &&
 331       actual_frame_counter < *frame_counter_var + frame_delay)
 332     return FALSE;
 333
 334   *frame_counter_var = actual_frame_counter;
 335
 336   return TRUE;
 337 }
 338
 339 boolean DelayReached(unsigned int *counter_var,
 340                      unsigned int delay)
 341 {
 342   unsigned int actual_counter = Counter();
 343
 344   if (actual_counter >= *counter_var &&
 345       actual_counter < *counter_var + delay)
 346     return FALSE;
 347
 348   *counter_var = actual_counter;
 349
 350   return TRUE;
 351 }
 352
 353 void WaitUntilDelayReached(unsigned int *counter_var, unsigned int delay)
 354 {
 355   unsigned int actual_counter;
 356
 357   while (1)
 358   {
 359     actual_counter = Counter();
 360
 361     if (actual_counter >= *counter_var &&
 362         actual_counter < *counter_var + delay)
 363       sleep_milliseconds((*counter_var + delay - actual_counter) / 2);
 364     else
 365       break;
 366   }
 367
 368   *counter_var = actual_counter;
 369 }
 370
 371
 372 /* ------------------------------------------------------------------------- */
 373 /* random generator functions                                                */
 374 /* ------------------------------------------------------------------------- */
 375
 376 unsigned int init_random_number(int nr, int seed)
 377 {
 378   if (seed == NEW_RANDOMIZE)
 379   {
 380     /* default random seed */
 381     seed = (int)time(NULL);                     // seconds since the epoch
 382
 383 #if !defined(PLATFORM_WIN32)
 384     /* add some more randomness */
 385     struct timeval current_time;
 386
 387     gettimeofday(&current_time, NULL);
 388
 389     seed += (int)current_time.tv_usec;          // microseconds since the epoch
 390 #endif
 391
 392 #if defined(TARGET_SDL)
 393     /* add some more randomness */
 394     seed += (int)SDL_GetTicks();                // milliseconds since SDL init
 395 #endif
 396
 397 #if 1
 398     /* add some more randomness */
 399     seed += GetSimpleRandom(1000000);
 400 #endif
 401   }
 402
 403   srandom_linux_libc(nr, (unsigned int) seed);
 404
 405   return (unsigned int) seed;
 406 }
 407
 408 unsigned int get_random_number(int nr, int max)
 409 {
 410   return (max > 0 ? random_linux_libc(nr) % max : 0);
 411 }
 412
 413
 414 /* ------------------------------------------------------------------------- */
 415 /* system info functions                                                     */
 416 /* ------------------------------------------------------------------------- */
 417
 418 #if !defined(PLATFORM_ANDROID)
 419 static char *get_corrected_real_name(char *real_name)
 420 {
 421   char *real_name_new = checked_malloc(MAX_USERNAME_LEN + 1);
 422   char *from_ptr = real_name;
 423   char *to_ptr   = real_name_new;
 424
 425   /* copy the name string, but not more than MAX_USERNAME_LEN characters */
 426   while (*from_ptr && (int)(to_ptr - real_name_new) < MAX_USERNAME_LEN - 1)
 427   {
 428     /* the name field read from "passwd" file may also contain additional
 429        user information, separated by commas, which will be removed here */
 430     if (*from_ptr == ',')
 431       break;
 432
 433     /* the user's real name may contain 'ß' characters (german sharp s),
 434        which have no equivalent in upper case letters (used by our fonts) */
 435     if (*from_ptr == 'ß')
 436     {
 437       from_ptr++;
 438       *to_ptr++ = 's';
 439       *to_ptr++ = 's';
 440     }
 441     else
 442       *to_ptr++ = *from_ptr++;
 443   }
 444
 445   *to_ptr = '\0';
 446
 447   return real_name_new;
 448 }
 449 #endif
 450
 451 char *getLoginName()
 452 {
 453   static char *login_name = NULL;
 454
 455 #if defined(PLATFORM_WIN32)
 456   if (login_name == NULL)
 457   {
 458     unsigned long buffer_size = MAX_USERNAME_LEN + 1;
 459     login_name = checked_malloc(buffer_size);
 460
 461     if (GetUserName(login_name, &buffer_size) == 0)
 462       strcpy(login_name, ANONYMOUS_NAME);
 463   }
 464 #else
 465   if (login_name == NULL)
 466   {
 467     struct passwd *pwd;
 468
 469     if ((pwd = getpwuid(getuid())) == NULL)
 470       login_name = ANONYMOUS_NAME;
 471     else
 472       login_name = getStringCopy(pwd->pw_name);
 473   }
 474 #endif
 475
 476   return login_name;
 477 }
 478
 479 char *getRealName()
 480 {
 481   static char *real_name = NULL;
 482
 483 #if defined(PLATFORM_WIN32)
 484   if (real_name == NULL)
 485   {
 486     static char buffer[MAX_USERNAME_LEN + 1];
 487     unsigned long buffer_size = MAX_USERNAME_LEN + 1;
 488
 489     if (GetUserName(buffer, &buffer_size) != 0)
 490       real_name = get_corrected_real_name(buffer);
 491     else
 492       real_name = ANONYMOUS_NAME;
 493   }
 494 #elif defined(PLATFORM_UNIX) && !defined(PLATFORM_ANDROID)
 495   if (real_name == NULL)
 496   {
 497     struct passwd *pwd;
 498
 499     if ((pwd = getpwuid(getuid())) != NULL && strlen(pwd->pw_gecos) != 0)
 500       real_name = get_corrected_real_name(pwd->pw_gecos);
 501     else
 502       real_name = ANONYMOUS_NAME;
 503   }
 504 #else
 505   real_name = ANONYMOUS_NAME;
 506 #endif
 507
 508   return real_name;
 509 }
 510
 511 time_t getFileTimestampEpochSeconds(char *filename)
 512 {
 513   struct stat file_status;
 514
 515   if (stat(filename, &file_status) != 0)        /* cannot stat file */
 516     return 0;
 517
 518   return file_status.st_mtime;
 519 }
 520
 521
 522 /* ------------------------------------------------------------------------- */
 523 /* path manipulation functions                                               */
 524 /* ------------------------------------------------------------------------- */
 525
 526 static char *getLastPathSeparatorPtr(char *filename)
 527 {
 528   char *last_separator = strrchr(filename, CHAR_PATH_SEPARATOR_UNIX);
 529
 530   if (last_separator == NULL)   /* also try DOS/Windows variant */
 531     last_separator = strrchr(filename, CHAR_PATH_SEPARATOR_DOS);
 532
 533   return last_separator;
 534 }
 535
 536 char *getBaseNamePtr(char *filename)
 537 {
 538   char *last_separator = getLastPathSeparatorPtr(filename);
 539
 540   if (last_separator != NULL)
 541     return last_separator + 1;  /* separator found: strip base path */
 542   else
 543     return filename;            /* no separator found: filename has no path */
 544 }
 545
 546 char *getBaseName(char *filename)
 547 {
 548   return getStringCopy(getBaseNamePtr(filename));
 549 }
 550
 551 char *getBasePath(char *filename)
 552 {
 553   char *basepath = getStringCopy(filename);
 554   char *last_separator = getLastPathSeparatorPtr(basepath);
 555
 556   if (last_separator != NULL)
 557     *last_separator = '\0';     /* separator found: strip basename */
 558   else
 559     basepath = ".";             /* no separator found: use current path */
 560
 561   return basepath;
 562 }
 563
 564 static char *getProgramMainDataPath()
 565 {
 566   char *main_data_path = getStringCopy(program.command_basepath);
 567
 568 #if defined(PLATFORM_MACOSX)
 569   static char *main_data_binary_subdir = NULL;
 570
 571   if (main_data_binary_subdir == NULL)
 572   {
 573     main_data_binary_subdir = checked_malloc(strlen(program.program_title) + 1 +
 574                                              strlen("app") + 1 +
 575                                              strlen(MAC_APP_BINARY_SUBDIR) + 1);
 576
 577     sprintf(main_data_binary_subdir, "%s.app/%s",
 578             program.program_title, MAC_APP_BINARY_SUBDIR);
 579   }
 580
 581   // cut relative path to Mac OS X application binary directory from path
 582   if (strSuffix(main_data_path, main_data_binary_subdir))
 583     main_data_path[strlen(main_data_path) -
 584                    strlen(main_data_binary_subdir)] = '\0';
 585
 586   // cut trailing path separator from path (but not if path is root directory)
 587   if (strSuffix(main_data_path, "/") && !strEqual(main_data_path, "/"))
 588     main_data_path[strlen(main_data_path) - 1] = '\0';
 589 #endif
 590
 591   return main_data_path;
 592 }
 593
 594
 595 /* ------------------------------------------------------------------------- */
 596 /* various string functions                                                  */
 597 /* ------------------------------------------------------------------------- */
 598
 599 char *getStringCat2WithSeparator(char *s1, char *s2, char *sep)
 600 {
 601   char *complete_string = checked_malloc(strlen(s1) + strlen(sep) +
 602                                          strlen(s2) + 1);
 603
 604   sprintf(complete_string, "%s%s%s", s1, sep, s2);
 605
 606   return complete_string;
 607 }
 608
 609 char *getStringCat3WithSeparator(char *s1, char *s2, char *s3, char *sep)
 610 {
 611   char *complete_string = checked_malloc(strlen(s1) + strlen(sep) +
 612                                          strlen(s2) + strlen(sep) +
 613                                          strlen(s3) + 1);
 614
 615   sprintf(complete_string, "%s%s%s%s%s", s1, sep, s2, sep, s3);
 616
 617   return complete_string;
 618 }
 619
 620 char *getStringCat2(char *s1, char *s2)
 621 {
 622   return getStringCat2WithSeparator(s1, s2, "");
 623 }
 624
 625 char *getStringCat3(char *s1, char *s2, char *s3)
 626 {
 627   return getStringCat3WithSeparator(s1, s2, s3, "");
 628 }
 629
 630 char *getPath2(char *path1, char *path2)
 631 {
 632 #if defined(PLATFORM_ANDROID)
 633   // workaround for reading from APK assets directory -- skip leading "./"
 634   if (strEqual(path1, "."))
 635     return getStringCopy(path2);
 636 #endif
 637
 638   return getStringCat2WithSeparator(path1, path2, STRING_PATH_SEPARATOR);
 639 }
 640
 641 char *getPath3(char *path1, char *path2, char *path3)
 642 {
 643 #if defined(PLATFORM_ANDROID)
 644   // workaround for reading from APK assets directory -- skip leading "./"
 645   if (strEqual(path1, "."))
 646     return getStringCat2WithSeparator(path2, path3, STRING_PATH_SEPARATOR);
 647 #endif
 648
 649   return getStringCat3WithSeparator(path1, path2, path3, STRING_PATH_SEPARATOR);
 650 }
 651
 652 char *getStringCopy(const char *s)
 653 {
 654   char *s_copy;
 655
 656   if (s == NULL)
 657     return NULL;
 658
 659   s_copy = checked_malloc(strlen(s) + 1);
 660   strcpy(s_copy, s);
 661
 662   return s_copy;
 663 }
 664
 665 char *getStringCopyN(const char *s, int n)
 666 {
 667   char *s_copy;
 668   int s_len = MAX(0, n);
 669
 670   if (s == NULL)
 671     return NULL;
 672
 673   s_copy = checked_malloc(s_len + 1);
 674   strncpy(s_copy, s, s_len);
 675   s_copy[s_len] = '\0';
 676
 677   return s_copy;
 678 }
 679
 680 char *getStringCopyNStatic(const char *s, int n)
 681 {
 682   static char *s_copy = NULL;
 683
 684   checked_free(s_copy);
 685
 686   s_copy = getStringCopyN(s, n);
 687
 688   return s_copy;
 689 }
 690
 691 char *getStringToLower(const char *s)
 692 {
 693   char *s_copy = checked_malloc(strlen(s) + 1);
 694   char *s_ptr = s_copy;
 695
 696   while (*s)
 697     *s_ptr++ = tolower(*s++);
 698   *s_ptr = '\0';
 699
 700   return s_copy;
 701 }
 702
 703 void setString(char **old_value, char *new_value)
 704 {
 705   checked_free(*old_value);
 706
 707   *old_value = getStringCopy(new_value);
 708 }
 709
 710 boolean strEqual(char *s1, char *s2)
 711 {
 712   return (s1 == NULL && s2 == NULL ? TRUE  :
 713           s1 == NULL && s2 != NULL ? FALSE :
 714           s1 != NULL && s2 == NULL ? FALSE :
 715           strcmp(s1, s2) == 0);
 716 }
 717
 718 boolean strEqualN(char *s1, char *s2, int n)
 719 {
 720   return (s1 == NULL && s2 == NULL ? TRUE  :
 721           s1 == NULL && s2 != NULL ? FALSE :
 722           s1 != NULL && s2 == NULL ? FALSE :
 723           strncmp(s1, s2, n) == 0);
 724 }
 725
 726 boolean strPrefix(char *s, char *prefix)
 727 {
 728   return (s == NULL && prefix == NULL ? TRUE  :
 729           s == NULL && prefix != NULL ? FALSE :
 730           s != NULL && prefix == NULL ? FALSE :
 731           strncmp(s, prefix, strlen(prefix)) == 0);
 732 }
 733
 734 boolean strSuffix(char *s, char *suffix)
 735 {
 736   return (s == NULL && suffix == NULL ? TRUE  :
 737           s == NULL && suffix != NULL ? FALSE :
 738           s != NULL && suffix == NULL ? FALSE :
 739           strlen(s) < strlen(suffix)  ? FALSE :
 740           strncmp(&s[strlen(s) - strlen(suffix)], suffix, strlen(suffix)) == 0);
 741 }
 742
 743 boolean strPrefixLower(char *s, char *prefix)
 744 {
 745   char *s_lower = getStringToLower(s);
 746   boolean match = strPrefix(s_lower, prefix);
 747
 748   free(s_lower);
 749
 750   return match;
 751 }
 752
 753 boolean strSuffixLower(char *s, char *suffix)
 754 {
 755   char *s_lower = getStringToLower(s);
 756   boolean match = strSuffix(s_lower, suffix);
 757
 758   free(s_lower);
 759
 760   return match;
 761 }
 762
 763
 764 /* ------------------------------------------------------------------------- */
 765 /* command line option handling functions                                    */
 766 /* ------------------------------------------------------------------------- */
 767
 768 void GetOptions(char *argv[],
 769                 void (*print_usage_function)(void),
 770                 void (*print_version_function)(void))
 771 {
 772   char *ro_base_path = RO_BASE_PATH;
 773   char *rw_base_path = RW_BASE_PATH;
 774   char **options_left = &argv[1];
 775
 776 #if 1
 777   /* if the program is configured to start from current directory (default),
 778      determine program package directory from program binary (some versions
 779      of KDE/Konqueror and Mac OS X (especially "Mavericks") apparently do not
 780      set the current working directory to the program package directory) */
 781
 782   if (strEqual(ro_base_path, "."))
 783     ro_base_path = getProgramMainDataPath();
 784   if (strEqual(rw_base_path, "."))
 785     rw_base_path = getProgramMainDataPath();
 786 #else
 787
 788 #if !defined(PLATFORM_MACOSX)
 789   /* if the program is configured to start from current directory (default),
 790      determine program package directory (KDE/Konqueror does not do this by
 791      itself and fails otherwise); on Mac OS X, the program binary is stored
 792      in an application package directory -- do not try to use this directory
 793      as the program data directory (Mac OS X handles this correctly anyway) */
 794
 795   if (strEqual(ro_base_path, "."))
 796     ro_base_path = program.command_basepath;
 797   if (strEqual(rw_base_path, "."))
 798     rw_base_path = program.command_basepath;
 799 #endif
 800
 801 #endif
 802
 803   /* initialize global program options */
 804   options.display_name = NULL;
 805   options.server_host = NULL;
 806   options.server_port = 0;
 807
 808   options.ro_base_directory = ro_base_path;
 809   options.rw_base_directory = rw_base_path;
 810   options.level_directory    = getPath2(ro_base_path, LEVELS_DIRECTORY);
 811   options.graphics_directory = getPath2(ro_base_path, GRAPHICS_DIRECTORY);
 812   options.sounds_directory   = getPath2(ro_base_path, SOUNDS_DIRECTORY);
 813   options.music_directory    = getPath2(ro_base_path, MUSIC_DIRECTORY);
 814   options.docs_directory     = getPath2(ro_base_path, DOCS_DIRECTORY);
 815
 816   options.execute_command = NULL;
 817   options.special_flags = NULL;
 818
 819   options.serveronly = FALSE;
 820   options.network = FALSE;
 821   options.verbose = FALSE;
 822   options.debug = FALSE;
 823   options.debug_x11_sync = FALSE;
 824
 825 #if 1
 826   options.verbose = TRUE;
 827 #else
 828 #if !defined(PLATFORM_UNIX)
 829   if (*options_left == NULL)    /* no options given -- enable verbose mode */
 830     options.verbose = TRUE;
 831 #endif
 832 #endif
 833
 834   while (*options_left)
 835   {
 836     char option_str[MAX_OPTION_LEN];
 837     char *option = options_left[0];
 838     char *next_option = options_left[1];
 839     char *option_arg = NULL;
 840     int option_len = strlen(option);
 841
 842     if (option_len >= MAX_OPTION_LEN)
 843       Error(ERR_EXIT_HELP, "unrecognized option '%s'", option);
 844
 845     strcpy(option_str, option);                 /* copy argument into buffer */
 846     option = option_str;
 847
 848     if (strEqual(option, "--"))                 /* stop scanning arguments */
 849       break;
 850
 851     if (strPrefix(option, "--"))                /* treat '--' like '-' */
 852       option++;
 853
 854     option_arg = strchr(option, '=');
 855     if (option_arg == NULL)                     /* no '=' in option */
 856       option_arg = next_option;
 857     else
 858     {
 859       *option_arg++ = '\0';                     /* cut argument from option */
 860       if (*option_arg == '\0')                  /* no argument after '=' */
 861         Error(ERR_EXIT_HELP, "option '%s' has invalid argument", option_str);
 862     }
 863
 864     option_len = strlen(option);
 865
 866     if (strEqual(option, "-"))
 867     {
 868       Error(ERR_EXIT_HELP, "unrecognized option '%s'", option);
 869     }
 870     else if (strncmp(option, "-help", option_len) == 0)
 871     {
 872       print_usage_function();
 873
 874       exit(0);
 875     }
 876     else if (strncmp(option, "-display", option_len) == 0)
 877     {
 878       if (option_arg == NULL)
 879         Error(ERR_EXIT_HELP, "option '%s' requires an argument", option_str);
 880
 881       options.display_name = option_arg;
 882       if (option_arg == next_option)
 883         options_left++;
 884     }
 885     else if (strncmp(option, "-basepath", option_len) == 0)
 886     {
 887       if (option_arg == NULL)
 888         Error(ERR_EXIT_HELP, "option '%s' requires an argument", option_str);
 889
 890       /* this should be extended to separate options for ro and rw data */
 891       options.ro_base_directory = ro_base_path = option_arg;
 892       options.rw_base_directory = rw_base_path = option_arg;
 893       if (option_arg == next_option)
 894         options_left++;
 895
 896       /* adjust paths for sub-directories in base directory accordingly */
 897       options.level_directory    = getPath2(ro_base_path, LEVELS_DIRECTORY);
 898       options.graphics_directory = getPath2(ro_base_path, GRAPHICS_DIRECTORY);
 899       options.sounds_directory   = getPath2(ro_base_path, SOUNDS_DIRECTORY);
 900       options.music_directory    = getPath2(ro_base_path, MUSIC_DIRECTORY);
 901       options.docs_directory     = getPath2(ro_base_path, DOCS_DIRECTORY);
 902     }
 903     else if (strncmp(option, "-levels", option_len) == 0)
 904     {
 905       if (option_arg == NULL)
 906         Error(ERR_EXIT_HELP, "option '%s' requires an argument", option_str);
 907
 908       options.level_directory = option_arg;
 909       if (option_arg == next_option)
 910         options_left++;
 911     }
 912     else if (strncmp(option, "-graphics", option_len) == 0)
 913     {
 914       if (option_arg == NULL)
 915         Error(ERR_EXIT_HELP, "option '%s' requires an argument", option_str);
 916
 917       options.graphics_directory = option_arg;
 918       if (option_arg == next_option)
 919         options_left++;
 920     }
 921     else if (strncmp(option, "-sounds", option_len) == 0)
 922     {
 923       if (option_arg == NULL)
 924         Error(ERR_EXIT_HELP, "option '%s' requires an argument", option_str);
 925
 926       options.sounds_directory = option_arg;
 927       if (option_arg == next_option)
 928         options_left++;
 929     }
 930     else if (strncmp(option, "-music", option_len) == 0)
 931     {
 932       if (option_arg == NULL)
 933         Error(ERR_EXIT_HELP, "option '%s' requires an argument", option_str);
 934
 935       options.music_directory = option_arg;
 936       if (option_arg == next_option)
 937         options_left++;
 938     }
 939     else if (strncmp(option, "-network", option_len) == 0)
 940     {
 941       options.network = TRUE;
 942     }
 943     else if (strncmp(option, "-serveronly", option_len) == 0)
 944     {
 945       options.serveronly = TRUE;
 946     }
 947     else if (strncmp(option, "-debug", option_len) == 0)
 948     {
 949       options.debug = TRUE;
 950     }
 951     else if (strncmp(option, "-debug-x11-sync", option_len) == 0)
 952     {
 953       options.debug_x11_sync = TRUE;
 954     }
 955     else if (strncmp(option, "-verbose", option_len) == 0)
 956     {
 957       options.verbose = TRUE;
 958     }
 959     else if (strncmp(option, "-version", option_len) == 0 ||
 960              strncmp(option, "-V", option_len) == 0)
 961     {
 962       print_version_function();
 963
 964       exit(0);
 965     }
 966     else if (strPrefix(option, "-D"))
 967     {
 968 #if 1
 969       options.special_flags = getStringCopy(&option[2]);
 970 #else
 971       char *flags_string = &option[2];
 972       unsigned int flags_value;
 973
 974       if (*flags_string == '\0')
 975         Error(ERR_EXIT_HELP, "empty flag ignored");
 976
 977       flags_value = get_special_flags_function(flags_string);
 978
 979       if (flags_value == 0)
 980         Error(ERR_EXIT_HELP, "unknown flag '%s'", flags_string);
 981
 982       options.special_flags |= flags_value;
 983 #endif
 984     }
 985     else if (strncmp(option, "-execute", option_len) == 0)
 986     {
 987       if (option_arg == NULL)
 988         Error(ERR_EXIT_HELP, "option '%s' requires an argument", option_str);
 989
 990       options.execute_command = option_arg;
 991       if (option_arg == next_option)
 992         options_left++;
 993
 994       /* when doing batch processing, always enable verbose mode (warnings) */
 995       options.verbose = TRUE;
 996     }
 997     else if (*option == '-')
 998     {
 999       Error(ERR_EXIT_HELP, "unrecognized option '%s'", option_str);
1000     }
1001     else if (options.server_host == NULL)
1002     {
1003       options.server_host = *options_left;
1004     }
1005     else if (options.server_port == 0)
1006     {
1007       options.server_port = atoi(*options_left);
1008       if (options.server_port < 1024)
1009         Error(ERR_EXIT_HELP, "bad port number '%d'", options.server_port);
1010     }
1011     else
1012       Error(ERR_EXIT_HELP, "too many arguments");
1013
1014     options_left++;
1015   }
1016 }
1017
1018
1019 /* ------------------------------------------------------------------------- */
1020 /* error handling functions                                                  */
1021 /* ------------------------------------------------------------------------- */
1022
1023 #define MAX_INTERNAL_ERROR_SIZE         1024
1024
1025 /* used by SetError() and GetError() to store internal error messages */
1026 static char internal_error[MAX_INTERNAL_ERROR_SIZE];
1027
1028 void SetError(char *format, ...)
1029 {
1030   va_list ap;
1031
1032   va_start(ap, format);
1033   vsnprintf(internal_error, MAX_INTERNAL_ERROR_SIZE, format, ap);
1034   va_end(ap);
1035 }
1036
1037 char *GetError()
1038 {
1039   return internal_error;
1040 }
1041
1042 void Error(int mode, char *format, ...)
1043 {
1044   static boolean last_line_was_separator = FALSE;
1045   char *process_name = "";
1046
1047 #if defined(PLATFORM_ANDROID)
1048   android_log_prio = (mode & ERR_DEBUG ? ANDROID_LOG_DEBUG :
1049                       mode & ERR_INFO ? ANDROID_LOG_INFO :
1050                       mode & ERR_WARN ? ANDROID_LOG_WARN :
1051                       mode & ERR_EXIT ? ANDROID_LOG_FATAL :
1052                       ANDROID_LOG_UNKNOWN);
1053 #endif
1054
1055 #if 1
1056   /* display warnings only when running in verbose mode */
1057   if (mode & ERR_WARN && !options.verbose)
1058     return;
1059 #endif
1060
1061   if (mode == ERR_INFO_LINE)
1062   {
1063     if (!last_line_was_separator)
1064       fprintf_line(program.error_file, format, 79);
1065
1066     last_line_was_separator = TRUE;
1067
1068     return;
1069   }
1070
1071   last_line_was_separator = FALSE;
1072
1073   if (mode & ERR_SOUND_SERVER)
1074     process_name = " sound server";
1075   else if (mode & ERR_NETWORK_SERVER)
1076     process_name = " network server";
1077   else if (mode & ERR_NETWORK_CLIENT)
1078     process_name = " network client **";
1079
1080   if (format)
1081   {
1082     va_list ap;
1083
1084     fprintf_nonewline(program.error_file, "%s%s: ", program.command_basename,
1085                       process_name);
1086
1087     if (mode & ERR_WARN)
1088       fprintf_nonewline(program.error_file, "warning: ");
1089
1090     va_start(ap, format);
1091     vfprintf_newline(program.error_file, format, ap);
1092     va_end(ap);
1093
1094     if ((mode & ERR_EXIT) && !(mode & ERR_FROM_SERVER))
1095     {
1096       va_start(ap, format);
1097       program.exit_message_function(format, ap);
1098       va_end(ap);
1099     }
1100   }
1101
1102   if (mode & ERR_HELP)
1103     fprintf_newline(program.error_file,
1104                     "%s: Try option '--help' for more information.",
1105                     program.command_basename);
1106
1107   if (mode & ERR_EXIT)
1108     fprintf_newline(program.error_file, "%s%s: aborting",
1109                     program.command_basename, process_name);
1110
1111   if (mode & ERR_EXIT)
1112   {
1113     if (mode & ERR_FROM_SERVER)
1114       exit(1);                          /* child process: normal exit */
1115     else
1116       program.exit_function(1);         /* main process: clean up stuff */
1117   }
1118 }
1119
1120
1121 /* ------------------------------------------------------------------------- */
1122 /* checked memory allocation and freeing functions                           */
1123 /* ------------------------------------------------------------------------- */
1124
1125 void *checked_malloc(unsigned int size)
1126 {
1127   void *ptr;
1128
1129   ptr = malloc(size);
1130
1131   if (ptr == NULL)
1132     Error(ERR_EXIT, "cannot allocate %d bytes -- out of memory", size);
1133
1134   return ptr;
1135 }
1136
1137 void *checked_calloc(unsigned int size)
1138 {
1139   void *ptr;
1140
1141   ptr = calloc(1, size);
1142
1143   if (ptr == NULL)
1144     Error(ERR_EXIT, "cannot allocate %d bytes -- out of memory", size);
1145
1146   return ptr;
1147 }
1148
1149 void *checked_realloc(void *ptr, unsigned int size)
1150 {
1151   ptr = realloc(ptr, size);
1152
1153   if (ptr == NULL)
1154     Error(ERR_EXIT, "cannot allocate %d bytes -- out of memory", size);
1155
1156   return ptr;
1157 }
1158
1159 void checked_free(void *ptr)
1160 {
1161   if (ptr != NULL)      /* this check should be done by free() anyway */
1162     free(ptr);
1163 }
1164
1165 void clear_mem(void *ptr, unsigned int size)
1166 {
1167 #if defined(PLATFORM_WIN32)
1168   /* for unknown reason, memset() sometimes crashes when compiled with MinGW */
1169   char *cptr = (char *)ptr;
1170
1171   while (size--)
1172     *cptr++ = 0;
1173 #else
1174   memset(ptr, 0, size);
1175 #endif
1176 }
1177
1178
1179 /* ------------------------------------------------------------------------- */
1180 /* various helper functions                                                  */
1181 /* ------------------------------------------------------------------------- */
1182
1183 inline void swap_numbers(int *i1, int *i2)
1184 {
1185   int help = *i1;
1186
1187   *i1 = *i2;
1188   *i2 = help;
1189 }
1190
1191 inline void swap_number_pairs(int *x1, int *y1, int *x2, int *y2)
1192 {
1193   int help_x = *x1;
1194   int help_y = *y1;
1195
1196   *x1 = *x2;
1197   *x2 = help_x;
1198
1199   *y1 = *y2;
1200   *y2 = help_y;
1201 }
1202
1203 /* the "put" variants of the following file access functions check for the file
1204    pointer being != NULL and return the number of bytes they have or would have
1205    written; this allows for chunk writing functions to first determine the size
1206    of the (not yet written) chunk, write the correct chunk size and finally
1207    write the chunk itself */
1208
1209 #if 1
1210
1211 int getFile8BitInteger(File *file)
1212 {
1213   return getByteFromFile(file);
1214 }
1215
1216 #else
1217
1218 int getFile8BitInteger(FILE *file)
1219 {
1220   return fgetc(file);
1221 }
1222
1223 #endif
1224
1225 int putFile8BitInteger(FILE *file, int value)
1226 {
1227   if (file != NULL)
1228     fputc(value, file);
1229
1230   return 1;
1231 }
1232
1233 #if 1
1234
1235 int getFile16BitInteger(File *file, int byte_order)
1236 {
1237   if (byte_order == BYTE_ORDER_BIG_ENDIAN)
1238     return ((getByteFromFile(file) << 8) |
1239             (getByteFromFile(file) << 0));
1240   else           /* BYTE_ORDER_LITTLE_ENDIAN */
1241     return ((getByteFromFile(file) << 0) |
1242             (getByteFromFile(file) << 8));
1243 }
1244
1245 #else
1246
1247 int getFile16BitInteger(FILE *file, int byte_order)
1248 {
1249   if (byte_order == BYTE_ORDER_BIG_ENDIAN)
1250     return ((fgetc(file) << 8) |
1251             (fgetc(file) << 0));
1252   else           /* BYTE_ORDER_LITTLE_ENDIAN */
1253     return ((fgetc(file) << 0) |
1254             (fgetc(file) << 8));
1255 }
1256
1257 #endif
1258
1259 int putFile16BitInteger(FILE *file, int value, int byte_order)
1260 {
1261   if (file != NULL)
1262   {
1263     if (byte_order == BYTE_ORDER_BIG_ENDIAN)
1264     {
1265       fputc((value >> 8) & 0xff, file);
1266       fputc((value >> 0) & 0xff, file);
1267     }
1268     else           /* BYTE_ORDER_LITTLE_ENDIAN */
1269     {
1270       fputc((value >> 0) & 0xff, file);
1271       fputc((value >> 8) & 0xff, file);
1272     }
1273   }
1274
1275   return 2;
1276 }
1277
1278 #if 1
1279
1280 int getFile32BitInteger(File *file, int byte_order)
1281 {
1282   if (byte_order == BYTE_ORDER_BIG_ENDIAN)
1283     return ((getByteFromFile(file) << 24) |
1284             (getByteFromFile(file) << 16) |
1285             (getByteFromFile(file) <<  8) |
1286             (getByteFromFile(file) <<  0));
1287   else           /* BYTE_ORDER_LITTLE_ENDIAN */
1288     return ((getByteFromFile(file) <<  0) |
1289             (getByteFromFile(file) <<  8) |
1290             (getByteFromFile(file) << 16) |
1291             (getByteFromFile(file) << 24));
1292 }
1293
1294 #else
1295
1296 int getFile32BitInteger(FILE *file, int byte_order)
1297 {
1298   if (byte_order == BYTE_ORDER_BIG_ENDIAN)
1299     return ((fgetc(file) << 24) |
1300             (fgetc(file) << 16) |
1301             (fgetc(file) <<  8) |
1302             (fgetc(file) <<  0));
1303   else           /* BYTE_ORDER_LITTLE_ENDIAN */
1304     return ((fgetc(file) <<  0) |
1305             (fgetc(file) <<  8) |
1306             (fgetc(file) << 16) |
1307             (fgetc(file) << 24));
1308 }
1309
1310 #endif
1311
1312 int putFile32BitInteger(FILE *file, int value, int byte_order)
1313 {
1314   if (file != NULL)
1315   {
1316     if (byte_order == BYTE_ORDER_BIG_ENDIAN)
1317     {
1318       fputc((value >> 24) & 0xff, file);
1319       fputc((value >> 16) & 0xff, file);
1320       fputc((value >>  8) & 0xff, file);
1321       fputc((value >>  0) & 0xff, file);
1322     }
1323     else           /* BYTE_ORDER_LITTLE_ENDIAN */
1324     {
1325       fputc((value >>  0) & 0xff, file);
1326       fputc((value >>  8) & 0xff, file);
1327       fputc((value >> 16) & 0xff, file);
1328       fputc((value >> 24) & 0xff, file);
1329     }
1330   }
1331
1332   return 4;
1333 }
1334
1335 #if 1
1336
1337 boolean getFileChunk(File *file, char *chunk_name, int *chunk_size,
1338                      int byte_order)
1339 {
1340   const int chunk_name_length = 4;
1341
1342   /* read chunk name */
1343   if (getStringFromFile(file, chunk_name, chunk_name_length + 1) == NULL)
1344     return FALSE;
1345
1346   if (chunk_size != NULL)
1347   {
1348     /* read chunk size */
1349     *chunk_size = getFile32BitInteger(file, byte_order);
1350   }
1351
1352   return (checkEndOfFile(file) ? FALSE : TRUE);
1353 }
1354
1355 #else
1356
1357 boolean getFileChunk(FILE *file, char *chunk_name, int *chunk_size,
1358                      int byte_order)
1359 {
1360   const int chunk_name_length = 4;
1361
1362   /* read chunk name */
1363   if (fgets(chunk_name, chunk_name_length + 1, file) == NULL)
1364     return FALSE;
1365
1366   if (chunk_size != NULL)
1367   {
1368     /* read chunk size */
1369     *chunk_size = getFile32BitInteger(file, byte_order);
1370   }
1371
1372   return (feof(file) || ferror(file) ? FALSE : TRUE);
1373 }
1374
1375 #endif
1376
1377 int putFileChunk(FILE *file, char *chunk_name, int chunk_size,
1378                  int byte_order)
1379 {
1380   int num_bytes = 0;
1381
1382   /* write chunk name */
1383   if (file != NULL)
1384     fputs(chunk_name, file);
1385
1386   num_bytes += strlen(chunk_name);
1387
1388   if (chunk_size >= 0)
1389   {
1390     /* write chunk size */
1391     if (file != NULL)
1392       putFile32BitInteger(file, chunk_size, byte_order);
1393
1394     num_bytes += 4;
1395   }
1396
1397   return num_bytes;
1398 }
1399
1400 #if 1
1401
1402 int getFileVersion(File *file)
1403 {
1404   int version_major = getByteFromFile(file);
1405   int version_minor = getByteFromFile(file);
1406   int version_patch = getByteFromFile(file);
1407   int version_build = getByteFromFile(file);
1408
1409   return VERSION_IDENT(version_major, version_minor, version_patch,
1410                        version_build);
1411 }
1412
1413 #else
1414
1415 int getFileVersion(FILE *file)
1416 {
1417   int version_major = fgetc(file);
1418   int version_minor = fgetc(file);
1419   int version_patch = fgetc(file);
1420   int version_build = fgetc(file);
1421
1422   return VERSION_IDENT(version_major, version_minor, version_patch,
1423                        version_build);
1424 }
1425
1426 #endif
1427
1428 int putFileVersion(FILE *file, int version)
1429 {
1430   if (file != NULL)
1431   {
1432     int version_major = VERSION_MAJOR(version);
1433     int version_minor = VERSION_MINOR(version);
1434     int version_patch = VERSION_PATCH(version);
1435     int version_build = VERSION_BUILD(version);
1436
1437     fputc(version_major, file);
1438     fputc(version_minor, file);
1439     fputc(version_patch, file);
1440     fputc(version_build, file);
1441   }
1442
1443   return 4;
1444 }
1445
1446 #if 1
1447
1448 void ReadBytesFromFile(File *file, byte *buffer, unsigned int bytes)
1449 {
1450   int i;
1451
1452   for (i = 0; i < bytes && !checkEndOfFile(file); i++)
1453     buffer[i] = getByteFromFile(file);
1454 }
1455
1456 #else
1457
1458 void ReadBytesFromFile(FILE *file, byte *buffer, unsigned int bytes)
1459 {
1460   int i;
1461
1462   for(i = 0; i < bytes && !feof(file); i++)
1463     buffer[i] = fgetc(file);
1464 }
1465
1466 #endif
1467
1468 void WriteBytesToFile(FILE *file, byte *buffer, unsigned int bytes)
1469 {
1470   int i;
1471
1472   for(i = 0; i < bytes; i++)
1473     fputc(buffer[i], file);
1474 }
1475
1476 #if 1
1477
1478 void ReadUnusedBytesFromFile(File *file, unsigned int bytes)
1479 {
1480   while (bytes-- && !checkEndOfFile(file))
1481     getByteFromFile(file);
1482 }
1483
1484 #else
1485
1486 void ReadUnusedBytesFromFile(FILE *file, unsigned int bytes)
1487 {
1488   while (bytes-- && !feof(file))
1489     fgetc(file);
1490 }
1491
1492 #endif
1493
1494 void WriteUnusedBytesToFile(FILE *file, unsigned int bytes)
1495 {
1496   while (bytes--)
1497     fputc(0, file);
1498 }
1499
1500
1501 /* ------------------------------------------------------------------------- */
1502 /* functions to translate key identifiers between different format           */
1503 /* ------------------------------------------------------------------------- */
1504
1505 #define TRANSLATE_KEYSYM_TO_KEYNAME     0
1506 #define TRANSLATE_KEYSYM_TO_X11KEYNAME  1
1507 #define TRANSLATE_KEYNAME_TO_KEYSYM     2
1508 #define TRANSLATE_X11KEYNAME_TO_KEYSYM  3
1509
1510 void translate_keyname(Key *keysym, char **x11name, char **name, int mode)
1511 {
1512   static struct
1513   {
1514     Key key;
1515     char *x11name;
1516     char *name;
1517   } translate_key[] =
1518   {
1519     /* normal cursor keys */
1520     { KSYM_Left,        "XK_Left",              "cursor left" },
1521     { KSYM_Right,       "XK_Right",             "cursor right" },
1522     { KSYM_Up,          "XK_Up",                "cursor up" },
1523     { KSYM_Down,        "XK_Down",              "cursor down" },
1524
1525     /* keypad cursor keys */
1526 #ifdef KSYM_KP_Left
1527     { KSYM_KP_Left,     "XK_KP_Left",           "keypad left" },
1528     { KSYM_KP_Right,    "XK_KP_Right",          "keypad right" },
1529     { KSYM_KP_Up,       "XK_KP_Up",             "keypad up" },
1530     { KSYM_KP_Down,     "XK_KP_Down",           "keypad down" },
1531 #endif
1532
1533     /* other keypad keys */
1534 #ifdef KSYM_KP_Enter
1535     { KSYM_KP_Enter,    "XK_KP_Enter",          "keypad enter" },
1536     { KSYM_KP_Add,      "XK_KP_Add",            "keypad +" },
1537     { KSYM_KP_Subtract, "XK_KP_Subtract",       "keypad -" },
1538     { KSYM_KP_Multiply, "XK_KP_Multiply",       "keypad mltply" },
1539     { KSYM_KP_Divide,   "XK_KP_Divide",         "keypad /" },
1540     { KSYM_KP_Separator,"XK_KP_Separator",      "keypad ," },
1541 #endif
1542
1543     /* modifier keys */
1544     { KSYM_Shift_L,     "XK_Shift_L",           "left shift" },
1545     { KSYM_Shift_R,     "XK_Shift_R",           "right shift" },
1546     { KSYM_Control_L,   "XK_Control_L",         "left control" },
1547     { KSYM_Control_R,   "XK_Control_R",         "right control" },
1548     { KSYM_Meta_L,      "XK_Meta_L",            "left meta" },
1549     { KSYM_Meta_R,      "XK_Meta_R",            "right meta" },
1550     { KSYM_Alt_L,       "XK_Alt_L",             "left alt" },
1551     { KSYM_Alt_R,       "XK_Alt_R",             "right alt" },
1552 #if !defined(TARGET_SDL2)
1553     { KSYM_Super_L,     "XK_Super_L",           "left super" },  /* Win-L */
1554     { KSYM_Super_R,     "XK_Super_R",           "right super" }, /* Win-R */
1555 #endif
1556     { KSYM_Mode_switch, "XK_Mode_switch",       "mode switch" }, /* Alt-R */
1557     { KSYM_Multi_key,   "XK_Multi_key",         "multi key" },   /* Ctrl-R */
1558
1559     /* some special keys */
1560     { KSYM_BackSpace,   "XK_BackSpace",         "backspace" },
1561     { KSYM_Delete,      "XK_Delete",            "delete" },
1562     { KSYM_Insert,      "XK_Insert",            "insert" },
1563     { KSYM_Tab,         "XK_Tab",               "tab" },
1564     { KSYM_Home,        "XK_Home",              "home" },
1565     { KSYM_End,         "XK_End",               "end" },
1566     { KSYM_Page_Up,     "XK_Page_Up",           "page up" },
1567     { KSYM_Page_Down,   "XK_Page_Down",         "page down" },
1568
1569 #if defined(TARGET_SDL2)
1570     { KSYM_Menu,        "XK_Menu",              "menu" },        /* menu key */
1571     { KSYM_Back,        "XK_Back",              "back" },        /* back key */
1572 #endif
1573
1574     /* ASCII 0x20 to 0x40 keys (except numbers) */
1575     { KSYM_space,       "XK_space",             "space" },
1576     { KSYM_exclam,      "XK_exclam",            "!" },
1577     { KSYM_quotedbl,    "XK_quotedbl",          "\"" },
1578     { KSYM_numbersign,  "XK_numbersign",        "#" },
1579     { KSYM_dollar,      "XK_dollar",            "$" },
1580     { KSYM_percent,     "XK_percent",           "%" },
1581     { KSYM_ampersand,   "XK_ampersand",         "&" },
1582     { KSYM_apostrophe,  "XK_apostrophe",        "'" },
1583     { KSYM_parenleft,   "XK_parenleft",         "(" },
1584     { KSYM_parenright,  "XK_parenright",        ")" },
1585     { KSYM_asterisk,    "XK_asterisk",          "*" },
1586     { KSYM_plus,        "XK_plus",              "+" },
1587     { KSYM_comma,       "XK_comma",             "," },
1588     { KSYM_minus,       "XK_minus",             "-" },
1589     { KSYM_period,      "XK_period",            "." },
1590     { KSYM_slash,       "XK_slash",             "/" },
1591     { KSYM_colon,       "XK_colon",             ":" },
1592     { KSYM_semicolon,   "XK_semicolon",         ";" },
1593     { KSYM_less,        "XK_less",              "<" },
1594     { KSYM_equal,       "XK_equal",             "=" },
1595     { KSYM_greater,     "XK_greater",           ">" },
1596     { KSYM_question,    "XK_question",          "?" },
1597     { KSYM_at,          "XK_at",                "@" },
1598
1599     /* more ASCII keys */
1600     { KSYM_bracketleft, "XK_bracketleft",       "[" },
1601     { KSYM_backslash,   "XK_backslash",         "\\" },
1602     { KSYM_bracketright,"XK_bracketright",      "]" },
1603     { KSYM_asciicircum, "XK_asciicircum",       "^" },
1604     { KSYM_underscore,  "XK_underscore",        "_" },
1605     { KSYM_grave,       "XK_grave",             "grave" },
1606     { KSYM_quoteleft,   "XK_quoteleft",         "quote left" },
1607     { KSYM_braceleft,   "XK_braceleft",         "brace left" },
1608     { KSYM_bar,         "XK_bar",               "bar" },
1609     { KSYM_braceright,  "XK_braceright",        "brace right" },
1610     { KSYM_asciitilde,  "XK_asciitilde",        "~" },
1611
1612     /* special (non-ASCII) keys (ISO-Latin-1) */
1613     { KSYM_degree,      "XK_degree",            "°" },
1614     { KSYM_Adiaeresis,  "XK_Adiaeresis",        "Ä" },
1615     { KSYM_Odiaeresis,  "XK_Odiaeresis",        "Ö" },
1616     { KSYM_Udiaeresis,  "XK_Udiaeresis",        "Ü" },
1617     { KSYM_adiaeresis,  "XK_adiaeresis",        "ä" },
1618     { KSYM_odiaeresis,  "XK_odiaeresis",        "ö" },
1619     { KSYM_udiaeresis,  "XK_udiaeresis",        "ü" },
1620     { KSYM_ssharp,      "XK_ssharp",            "sharp s" },
1621
1622 #if defined(TARGET_SDL2)
1623     /* special (non-ASCII) keys (UTF-8, for reverse mapping only) */
1624     { KSYM_degree,      "XK_degree",            "\xc2\xb0" },
1625     { KSYM_Adiaeresis,  "XK_Adiaeresis",        "\xc3\x84" },
1626     { KSYM_Odiaeresis,  "XK_Odiaeresis",        "\xc3\x96" },
1627     { KSYM_Udiaeresis,  "XK_Udiaeresis",        "\xc3\x9c" },
1628     { KSYM_adiaeresis,  "XK_adiaeresis",        "\xc3\xa4" },
1629     { KSYM_odiaeresis,  "XK_odiaeresis",        "\xc3\xb6" },
1630     { KSYM_udiaeresis,  "XK_udiaeresis",        "\xc3\xbc" },
1631     { KSYM_ssharp,      "XK_ssharp",            "\xc3\x9f" },
1632
1633     /* other keys (for reverse mapping only) */
1634     { KSYM_space,       "XK_space",             " " },
1635 #endif
1636
1637 #if defined(TARGET_SDL2)
1638     /* keypad keys are not in numerical order in SDL2 */
1639     { KSYM_KP_0,        "XK_KP_0",              "keypad 0" },
1640     { KSYM_KP_1,        "XK_KP_1",              "keypad 1" },
1641     { KSYM_KP_2,        "XK_KP_2",              "keypad 2" },
1642     { KSYM_KP_3,        "XK_KP_3",              "keypad 3" },
1643     { KSYM_KP_4,        "XK_KP_4",              "keypad 4" },
1644     { KSYM_KP_5,        "XK_KP_5",              "keypad 5" },
1645     { KSYM_KP_6,        "XK_KP_6",              "keypad 6" },
1646     { KSYM_KP_7,        "XK_KP_7",              "keypad 7" },
1647     { KSYM_KP_8,        "XK_KP_8",              "keypad 8" },
1648     { KSYM_KP_9,        "XK_KP_9",              "keypad 9" },
1649 #endif
1650
1651     /* end-of-array identifier */
1652     { 0,                NULL,                   NULL }
1653   };
1654
1655   int i;
1656
1657   if (mode == TRANSLATE_KEYSYM_TO_KEYNAME)
1658   {
1659     static char name_buffer[30];
1660     Key key = *keysym;
1661
1662     if (key >= KSYM_A && key <= KSYM_Z)
1663       sprintf(name_buffer, "%c", 'A' + (char)(key - KSYM_A));
1664     else if (key >= KSYM_a && key <= KSYM_z)
1665       sprintf(name_buffer, "%c", 'a' + (char)(key - KSYM_a));
1666     else if (key >= KSYM_0 && key <= KSYM_9)
1667       sprintf(name_buffer, "%c", '0' + (char)(key - KSYM_0));
1668 #if !defined(TARGET_SDL2)
1669     else if (key >= KSYM_KP_0 && key <= KSYM_KP_9)
1670       sprintf(name_buffer, "keypad %c", '0' + (char)(key - KSYM_KP_0));
1671 #endif
1672     else if (key >= KSYM_FKEY_FIRST && key <= KSYM_FKEY_LAST)
1673       sprintf(name_buffer, "F%d", (int)(key - KSYM_FKEY_FIRST + 1));
1674     else if (key == KSYM_UNDEFINED)
1675       strcpy(name_buffer, "(undefined)");
1676     else
1677     {
1678       i = 0;
1679
1680       do
1681       {
1682         if (key == translate_key[i].key)
1683         {
1684           strcpy(name_buffer, translate_key[i].name);
1685           break;
1686         }
1687       }
1688       while (translate_key[++i].name);
1689
1690       if (!translate_key[i].name)
1691         strcpy(name_buffer, "(unknown)");
1692     }
1693
1694     *name = name_buffer;
1695   }
1696   else if (mode == TRANSLATE_KEYSYM_TO_X11KEYNAME)
1697   {
1698     static char name_buffer[30];
1699     Key key = *keysym;
1700
1701     if (key >= KSYM_A && key <= KSYM_Z)
1702       sprintf(name_buffer, "XK_%c", 'A' + (char)(key - KSYM_A));
1703     else if (key >= KSYM_a && key <= KSYM_z)
1704       sprintf(name_buffer, "XK_%c", 'a' + (char)(key - KSYM_a));
1705     else if (key >= KSYM_0 && key <= KSYM_9)
1706       sprintf(name_buffer, "XK_%c", '0' + (char)(key - KSYM_0));
1707 #if !defined(TARGET_SDL2)
1708     else if (key >= KSYM_KP_0 && key <= KSYM_KP_9)
1709       sprintf(name_buffer, "XK_KP_%c", '0' + (char)(key - KSYM_KP_0));
1710 #endif
1711     else if (key >= KSYM_FKEY_FIRST && key <= KSYM_FKEY_LAST)
1712       sprintf(name_buffer, "XK_F%d", (int)(key - KSYM_FKEY_FIRST + 1));
1713     else if (key == KSYM_UNDEFINED)
1714       strcpy(name_buffer, "[undefined]");
1715     else
1716     {
1717       i = 0;
1718
1719       do
1720       {
1721         if (key == translate_key[i].key)
1722         {
1723           strcpy(name_buffer, translate_key[i].x11name);
1724           break;
1725         }
1726       }
1727       while (translate_key[++i].x11name);
1728
1729       if (!translate_key[i].x11name)
1730         sprintf(name_buffer, "0x%04x", (unsigned int)key);
1731     }
1732
1733     *x11name = name_buffer;
1734   }
1735   else if (mode == TRANSLATE_KEYNAME_TO_KEYSYM)
1736   {
1737     Key key = KSYM_UNDEFINED;
1738     char *name_ptr = *name;
1739
1740     if (strlen(*name) == 1)
1741     {
1742       char c = name_ptr[0];
1743
1744       if (c >= 'A' && c <= 'Z')
1745         key = KSYM_A + (Key)(c - 'A');
1746       else if (c >= 'a' && c <= 'z')
1747         key = KSYM_a + (Key)(c - 'a');
1748       else if (c >= '0' && c <= '9')
1749         key = KSYM_0 + (Key)(c - '0');
1750     }
1751
1752     if (key == KSYM_UNDEFINED)
1753     {
1754       i = 0;
1755
1756       do
1757       {
1758         if (strEqual(translate_key[i].name, *name))
1759         {
1760           key = translate_key[i].key;
1761           break;
1762         }
1763       }
1764       while (translate_key[++i].x11name);
1765     }
1766
1767     if (key == KSYM_UNDEFINED)
1768       Error(ERR_WARN, "getKeyFromKeyName(): not completely implemented");
1769
1770     *keysym = key;
1771   }
1772   else if (mode == TRANSLATE_X11KEYNAME_TO_KEYSYM)
1773   {
1774     Key key = KSYM_UNDEFINED;
1775     char *name_ptr = *x11name;
1776
1777     if (strPrefix(name_ptr, "XK_") && strlen(name_ptr) == 4)
1778     {
1779       char c = name_ptr[3];
1780
1781       if (c >= 'A' && c <= 'Z')
1782         key = KSYM_A + (Key)(c - 'A');
1783       else if (c >= 'a' && c <= 'z')
1784         key = KSYM_a + (Key)(c - 'a');
1785       else if (c >= '0' && c <= '9')
1786         key = KSYM_0 + (Key)(c - '0');
1787     }
1788 #if !defined(TARGET_SDL2)
1789     else if (strPrefix(name_ptr, "XK_KP_") && strlen(name_ptr) == 7)
1790     {
1791       char c = name_ptr[6];
1792
1793       if (c >= '0' && c <= '9')
1794         key = KSYM_KP_0 + (Key)(c - '0');
1795     }
1796 #endif
1797     else if (strPrefix(name_ptr, "XK_F") && strlen(name_ptr) <= 6)
1798     {
1799       char c1 = name_ptr[4];
1800       char c2 = name_ptr[5];
1801       int d = 0;
1802
1803       if ((c1 >= '0' && c1 <= '9') &&
1804           ((c2 >= '0' && c1 <= '9') || c2 == '\0'))
1805         d = atoi(&name_ptr[4]);
1806
1807       if (d >= 1 && d <= KSYM_NUM_FKEYS)
1808         key = KSYM_F1 + (Key)(d - 1);
1809     }
1810     else if (strPrefix(name_ptr, "XK_"))
1811     {
1812       i = 0;
1813
1814       do
1815       {
1816         if (strEqual(name_ptr, translate_key[i].x11name))
1817         {
1818           key = translate_key[i].key;
1819           break;
1820         }
1821       }
1822       while (translate_key[++i].x11name);
1823     }
1824     else if (strPrefix(name_ptr, "0x"))
1825     {
1826       unsigned int value = 0;
1827
1828       name_ptr += 2;
1829
1830       while (name_ptr)
1831       {
1832         char c = *name_ptr++;
1833         int d = -1;
1834
1835         if (c >= '0' && c <= '9')
1836           d = (int)(c - '0');
1837         else if (c >= 'a' && c <= 'f')
1838           d = (int)(c - 'a' + 10);
1839         else if (c >= 'A' && c <= 'F')
1840           d = (int)(c - 'A' + 10);
1841
1842         if (d == -1)
1843         {
1844           value = -1;
1845           break;
1846         }
1847
1848         value = value * 16 + d;
1849       }
1850
1851       if (value != -1)
1852         key = (Key)value;
1853     }
1854
1855     *keysym = key;
1856   }
1857 }
1858
1859 char *getKeyNameFromKey(Key key)
1860 {
1861   char *name;
1862
1863   translate_keyname(&key, NULL, &name, TRANSLATE_KEYSYM_TO_KEYNAME);
1864   return name;
1865 }
1866
1867 char *getX11KeyNameFromKey(Key key)
1868 {
1869   char *x11name;
1870
1871   translate_keyname(&key, &x11name, NULL, TRANSLATE_KEYSYM_TO_X11KEYNAME);
1872   return x11name;
1873 }
1874
1875 Key getKeyFromKeyName(char *name)
1876 {
1877   Key key;
1878
1879   translate_keyname(&key, NULL, &name, TRANSLATE_KEYNAME_TO_KEYSYM);
1880   return key;
1881 }
1882
1883 Key getKeyFromX11KeyName(char *x11name)
1884 {
1885   Key key;
1886
1887   translate_keyname(&key, &x11name, NULL, TRANSLATE_X11KEYNAME_TO_KEYSYM);
1888   return key;
1889 }
1890
1891 char getCharFromKey(Key key)
1892 {
1893   char *keyname = getKeyNameFromKey(key);
1894   char c = 0;
1895
1896   if (strlen(keyname) == 1)
1897     c = keyname[0];
1898   else if (strEqual(keyname, "space"))
1899     c = ' ';
1900
1901   return c;
1902 }
1903
1904 char getValidConfigValueChar(char c)
1905 {
1906   if (c == '#' ||       /* used to mark comments */
1907       c == '\\')        /* used to mark continued lines */
1908     c = 0;
1909
1910   return c;
1911 }
1912
1913
1914 /* ------------------------------------------------------------------------- */
1915 /* functions to translate string identifiers to integer or boolean value     */
1916 /* ------------------------------------------------------------------------- */
1917
1918 int get_integer_from_string(char *s)
1919 {
1920   static char *number_text[][3] =
1921   {
1922     { "0",      "zero",         "null",         },
1923     { "1",      "one",          "first"         },
1924     { "2",      "two",          "second"        },
1925     { "3",      "three",        "third"         },
1926     { "4",      "four",         "fourth"        },
1927     { "5",      "five",         "fifth"         },
1928     { "6",      "six",          "sixth"         },
1929     { "7",      "seven",        "seventh"       },
1930     { "8",      "eight",        "eighth"        },
1931     { "9",      "nine",         "ninth"         },
1932     { "10",     "ten",          "tenth"         },
1933     { "11",     "eleven",       "eleventh"      },
1934     { "12",     "twelve",       "twelfth"       },
1935
1936     { NULL,     NULL,           NULL            },
1937   };
1938
1939   int i, j;
1940   char *s_lower = getStringToLower(s);
1941   int result = -1;
1942
1943   for (i = 0; number_text[i][0] != NULL; i++)
1944     for (j = 0; j < 3; j++)
1945       if (strEqual(s_lower, number_text[i][j]))
1946         result = i;
1947
1948   if (result == -1)
1949   {
1950     if (strEqual(s_lower, "false") ||
1951         strEqual(s_lower, "no") ||
1952         strEqual(s_lower, "off"))
1953       result = 0;
1954     else if (strEqual(s_lower, "true") ||
1955              strEqual(s_lower, "yes") ||
1956              strEqual(s_lower, "on"))
1957       result = 1;
1958     else
1959       result = atoi(s);
1960   }
1961
1962   free(s_lower);
1963
1964   return result;
1965 }
1966
1967 boolean get_boolean_from_string(char *s)
1968 {
1969   char *s_lower = getStringToLower(s);
1970   boolean result = FALSE;
1971
1972   if (strEqual(s_lower, "true") ||
1973       strEqual(s_lower, "yes") ||
1974       strEqual(s_lower, "on") ||
1975       get_integer_from_string(s) == 1)
1976     result = TRUE;
1977
1978   free(s_lower);
1979
1980   return result;
1981 }
1982
1983 int get_switch3_from_string(char *s)
1984 {
1985   char *s_lower = getStringToLower(s);
1986   int result = FALSE;
1987
1988   if (strEqual(s_lower, "true") ||
1989       strEqual(s_lower, "yes") ||
1990       strEqual(s_lower, "on") ||
1991       get_integer_from_string(s) == 1)
1992     result = TRUE;
1993   else if (strEqual(s_lower, "auto"))
1994     result = AUTO;
1995
1996   free(s_lower);
1997
1998   return result;
1999 }
2000
2001
2002 /* ------------------------------------------------------------------------- */
2003 /* functions for generic lists                                               */
2004 /* ------------------------------------------------------------------------- */
2005
2006 ListNode *newListNode()
2007 {
2008   return checked_calloc(sizeof(ListNode));
2009 }
2010
2011 void addNodeToList(ListNode **node_first, char *key, void *content)
2012 {
2013   ListNode *node_new = newListNode();
2014
2015   node_new->key = getStringCopy(key);
2016   node_new->content = content;
2017   node_new->next = *node_first;
2018   *node_first = node_new;
2019 }
2020
2021 void deleteNodeFromList(ListNode **node_first, char *key,
2022                         void (*destructor_function)(void *))
2023 {
2024   if (node_first == NULL || *node_first == NULL)
2025     return;
2026
2027   if (strEqual((*node_first)->key, key))
2028   {
2029     checked_free((*node_first)->key);
2030     if (destructor_function)
2031       destructor_function((*node_first)->content);
2032     *node_first = (*node_first)->next;
2033   }
2034   else
2035     deleteNodeFromList(&(*node_first)->next, key, destructor_function);
2036 }
2037
2038 ListNode *getNodeFromKey(ListNode *node_first, char *key)
2039 {
2040   if (node_first == NULL)
2041     return NULL;
2042
2043   if (strEqual(node_first->key, key))
2044     return node_first;
2045   else
2046     return getNodeFromKey(node_first->next, key);
2047 }
2048
2049 int getNumNodes(ListNode *node_first)
2050 {
2051   return (node_first ? 1 + getNumNodes(node_first->next) : 0);
2052 }
2053
2054 void dumpList(ListNode *node_first)
2055 {
2056   ListNode *node = node_first;
2057
2058   while (node)
2059   {
2060     printf("['%s' (%d)]\n", node->key,
2061            ((struct ListNodeInfo *)node->content)->num_references);
2062     node = node->next;
2063   }
2064
2065   printf("[%d nodes]\n", getNumNodes(node_first));
2066 }
2067
2068
2069 /* ------------------------------------------------------------------------- */
2070 /* functions for file handling                                               */
2071 /* ------------------------------------------------------------------------- */
2072
2073 File *openFile(char *filename, char *mode)
2074 {
2075   File *file = checked_calloc(sizeof(File));
2076
2077   file->file = fopen(filename, mode);
2078
2079   if (file->file != NULL)
2080   {
2081     file->filename = getStringCopy(filename);
2082
2083     return file;
2084   }
2085
2086 #if defined(PLATFORM_ANDROID)
2087   file->asset_file = SDL_RWFromFile(filename, mode);
2088
2089   if (file->asset_file != NULL)
2090   {
2091     file->file_is_asset = TRUE;
2092     file->filename = getStringCopy(filename);
2093
2094     return file;
2095   }
2096 #endif
2097
2098   checked_free(file);
2099
2100   return NULL;
2101 }
2102
2103 int closeFile(File *file)
2104 {
2105   if (file == NULL)
2106     return -1;
2107
2108   int result = 0;
2109
2110 #if defined(PLATFORM_ANDROID)
2111   if (file->asset_file)
2112     result = SDL_RWclose(file->asset_file);
2113 #endif
2114
2115   if (file->file)
2116     result = fclose(file->file);
2117
2118   checked_free(file->filename);
2119   checked_free(file);
2120
2121   return result;
2122 }
2123
2124 int checkEndOfFile(File *file)
2125 {
2126 #if defined(PLATFORM_ANDROID)
2127   if (file->file_is_asset)
2128     return file->end_of_file;
2129 #endif
2130
2131   return feof(file->file);
2132 }
2133
2134 size_t readFile(File *file, void *buffer, size_t item_size, size_t num_items)
2135 {
2136 #if defined(PLATFORM_ANDROID)
2137   if (file->file_is_asset)
2138   {
2139     if (file->end_of_file)
2140       return 0;
2141
2142     size_t num_items_read =
2143       SDL_RWread(file->asset_file, buffer, item_size, num_items);
2144
2145     if (num_items_read < num_items)
2146       file->end_of_file = TRUE;
2147
2148     return num_items_read;
2149   }
2150 #endif
2151
2152   return fread(buffer, item_size, num_items, file->file);
2153 }
2154
2155 int seekFile(File *file, long offset, int whence)
2156 {
2157 #if defined(PLATFORM_ANDROID)
2158   if (file->file_is_asset)
2159   {
2160     int sdl_whence = (whence == SEEK_SET ? RW_SEEK_SET :
2161                       whence == SEEK_CUR ? RW_SEEK_CUR :
2162                       whence == SEEK_END ? RW_SEEK_END : 0);
2163
2164     return (SDL_RWseek(file->asset_file, offset, sdl_whence) == -1 ? -1 : 0);
2165   }
2166 #endif
2167
2168   return fseek(file->file, offset, whence);
2169 }
2170
2171 int getByteFromFile(File *file)
2172 {
2173 #if defined(PLATFORM_ANDROID)
2174   if (file->file_is_asset)
2175   {
2176     if (file->end_of_file)
2177       return EOF;
2178
2179     byte c;
2180     size_t num_bytes_read = SDL_RWread(file->asset_file, &c, 1, 1);
2181
2182     if (num_bytes_read < 1)
2183       file->end_of_file = TRUE;
2184
2185     return (file->end_of_file ? EOF : (int)c);
2186   }
2187 #endif
2188
2189   return fgetc(file->file);
2190 }
2191
2192 char *getStringFromFile(File *file, char *line, int size)
2193 {
2194 #if defined(PLATFORM_ANDROID)
2195   if (file->file_is_asset)
2196   {
2197     if (file->end_of_file)
2198       return NULL;
2199
2200     char *line_ptr = line;
2201     int num_bytes_read = 0;
2202
2203     while (num_bytes_read < size - 1 &&
2204            SDL_RWread(file->asset_file, line_ptr, 1, 1) == 1 &&
2205            *line_ptr++ != '\n')
2206       num_bytes_read++;
2207
2208     *line_ptr = '\0';
2209
2210     if (strlen(line) == 0)
2211     {
2212       file->end_of_file = TRUE;
2213
2214       return NULL;
2215     }
2216
2217     return line;
2218   }
2219 #endif
2220
2221   return fgets(line, size, file->file);
2222 }
2223
2224
2225 /* ------------------------------------------------------------------------- */
2226 /* functions for directory handling                                          */
2227 /* ------------------------------------------------------------------------- */
2228
2229 Directory *openDirectory(char *dir_name)
2230 {
2231   Directory *dir = checked_calloc(sizeof(Directory));
2232
2233   dir->dir = opendir(dir_name);
2234
2235   if (dir->dir != NULL)
2236   {
2237     dir->filename = getStringCopy(dir_name);
2238
2239     return dir;
2240   }
2241
2242 #if defined(PLATFORM_ANDROID)
2243   char *asset_toc_filename = getPath2(dir_name, ASSET_TOC_BASENAME);
2244
2245   dir->asset_toc_file = SDL_RWFromFile(asset_toc_filename, MODE_READ);
2246
2247   checked_free(asset_toc_filename);
2248
2249   if (dir->asset_toc_file != NULL)
2250   {
2251     dir->directory_is_asset = TRUE;
2252     dir->filename = getStringCopy(dir_name);
2253
2254     return dir;
2255   }
2256 #endif
2257
2258   checked_free(dir);
2259
2260   return NULL;
2261 }
2262
2263 int closeDirectory(Directory *dir)
2264 {
2265   if (dir == NULL)
2266     return -1;
2267
2268   int result = 0;
2269
2270 #if defined(PLATFORM_ANDROID)
2271   if (dir->asset_toc_file)
2272     result = SDL_RWclose(dir->asset_toc_file);
2273 #endif
2274
2275   if (dir->dir)
2276     result = closedir(dir->dir);
2277
2278   if (dir->dir_entry)
2279     freeDirectoryEntry(dir->dir_entry);
2280
2281   checked_free(dir->filename);
2282   checked_free(dir);
2283
2284   return result;
2285 }
2286
2287 DirectoryEntry *readDirectory(Directory *dir)
2288 {
2289   if (dir->dir_entry)
2290     freeDirectoryEntry(dir->dir_entry);
2291
2292   dir->dir_entry = NULL;
2293
2294 #if defined(PLATFORM_ANDROID)
2295   if (dir->directory_is_asset)
2296   {
2297     char line[MAX_LINE_LEN];
2298     char *line_ptr = line;
2299     int num_bytes_read = 0;
2300
2301     while (num_bytes_read < MAX_LINE_LEN - 1 &&
2302            SDL_RWread(dir->asset_toc_file, line_ptr, 1, 1) == 1 &&
2303            *line_ptr != '\n')
2304     {
2305       line_ptr++;
2306       num_bytes_read++;
2307     }
2308
2309     *line_ptr = '\0';
2310
2311     if (strlen(line) == 0)
2312       return NULL;
2313
2314     dir->dir_entry = checked_calloc(sizeof(DirectoryEntry));
2315
2316     dir->dir_entry->is_directory = FALSE;
2317     if (line[strlen(line) - 1] == '/')
2318     {
2319       dir->dir_entry->is_directory = TRUE;
2320
2321       line[strlen(line) - 1] = '\0';
2322     }
2323
2324     dir->dir_entry->basename = getStringCopy(line);
2325     dir->dir_entry->filename = getPath2(dir->filename, line);
2326
2327     return dir->dir_entry;
2328   }
2329 #endif
2330
2331   struct dirent *dir_entry = readdir(dir->dir);
2332
2333   if (dir_entry == NULL)
2334     return NULL;
2335
2336   dir->dir_entry = checked_calloc(sizeof(DirectoryEntry));
2337
2338   dir->dir_entry->basename = getStringCopy(dir_entry->d_name);
2339   dir->dir_entry->filename = getPath2(dir->filename, dir_entry->d_name);
2340
2341   struct stat file_status;
2342
2343   dir->dir_entry->is_directory =
2344     (stat(dir->dir_entry->filename, &file_status) == 0 &&
2345      (file_status.st_mode & S_IFMT) == S_IFDIR);
2346
2347 #if 0
2348   Error(ERR_INFO, "::: '%s' is directory: %d",
2349         dir->dir_entry->basename,
2350         dir->dir_entry->is_directory);
2351 #endif
2352
2353   return dir->dir_entry;
2354 }
2355
2356 void freeDirectoryEntry(DirectoryEntry *dir_entry)
2357 {
2358   if (dir_entry == NULL)
2359     return;
2360
2361   checked_free(dir_entry->basename);
2362   checked_free(dir_entry->filename);
2363   checked_free(dir_entry);
2364 }
2365
2366
2367 /* ------------------------------------------------------------------------- */
2368 /* functions for checking files and filenames                                */
2369 /* ------------------------------------------------------------------------- */
2370
2371 boolean directoryExists(char *dir_name)
2372 {
2373   if (dir_name == NULL)
2374     return FALSE;
2375
2376   boolean success = (access(dir_name, F_OK) == 0);
2377
2378 #if defined(PLATFORM_ANDROID)
2379   if (!success)
2380   {
2381     // this might be an asset directory; check by trying to open toc file
2382     char *asset_toc_filename = getPath2(dir_name, ASSET_TOC_BASENAME);
2383     SDL_RWops *file = SDL_RWFromFile(asset_toc_filename, MODE_READ);
2384
2385     checked_free(asset_toc_filename);
2386
2387     success = (file != NULL);
2388
2389     if (success)
2390       SDL_RWclose(file);
2391   }
2392 #endif
2393
2394   return success;
2395 }
2396
2397 boolean fileExists(char *filename)
2398 {
2399   if (filename == NULL)
2400     return FALSE;
2401
2402   boolean success = (access(filename, F_OK) == 0);
2403
2404 #if defined(PLATFORM_ANDROID)
2405   if (!success)
2406   {
2407     // this might be an asset file; check by trying to open it
2408     SDL_RWops *file = SDL_RWFromFile(filename, MODE_READ);
2409
2410     success = (file != NULL);
2411
2412     if (success)
2413       SDL_RWclose(file);
2414   }
2415 #endif
2416
2417   return success;
2418 }
2419
2420 boolean fileHasPrefix(char *basename, char *prefix)
2421 {
2422   static char *basename_lower = NULL;
2423   int basename_length, prefix_length;
2424
2425   checked_free(basename_lower);
2426
2427   if (basename == NULL || prefix == NULL)
2428     return FALSE;
2429
2430   basename_lower = getStringToLower(basename);
2431   basename_length = strlen(basename_lower);
2432   prefix_length = strlen(prefix);
2433
2434   if (basename_length > prefix_length + 1 &&
2435       basename_lower[prefix_length] == '.' &&
2436       strncmp(basename_lower, prefix, prefix_length) == 0)
2437     return TRUE;
2438
2439   return FALSE;
2440 }
2441
2442 boolean fileHasSuffix(char *basename, char *suffix)
2443 {
2444   static char *basename_lower = NULL;
2445   int basename_length, suffix_length;
2446
2447   checked_free(basename_lower);
2448
2449   if (basename == NULL || suffix == NULL)
2450     return FALSE;
2451
2452   basename_lower = getStringToLower(basename);
2453   basename_length = strlen(basename_lower);
2454   suffix_length = strlen(suffix);
2455
2456   if (basename_length > suffix_length + 1 &&
2457       basename_lower[basename_length - suffix_length - 1] == '.' &&
2458       strEqual(&basename_lower[basename_length - suffix_length], suffix))
2459     return TRUE;
2460
2461   return FALSE;
2462 }
2463
2464 #if defined(TARGET_SDL)
2465 static boolean FileCouldBeArtwork(char *basename)
2466 {
2467   return (!strEqual(basename, ".") &&
2468           !strEqual(basename, "..") &&
2469           !fileHasSuffix(basename, "txt") &&
2470           !fileHasSuffix(basename, "conf"));
2471 }
2472 #endif
2473
2474 boolean FileIsGraphic(char *filename)
2475 {
2476   char *basename = getBaseNamePtr(filename);
2477
2478 #if defined(TARGET_SDL)
2479   return FileCouldBeArtwork(basename);
2480 #else
2481   return fileHasSuffix(basename, "pcx");
2482 #endif
2483 }
2484
2485 boolean FileIsSound(char *filename)
2486 {
2487   char *basename = getBaseNamePtr(filename);
2488
2489 #if defined(TARGET_SDL)
2490   return FileCouldBeArtwork(basename);
2491 #else
2492   return fileHasSuffix(basename, "wav");
2493 #endif
2494 }
2495
2496 boolean FileIsMusic(char *filename)
2497 {
2498   char *basename = getBaseNamePtr(filename);
2499
2500 #if defined(TARGET_SDL)
2501   return FileCouldBeArtwork(basename);
2502 #else
2503   if (FileIsSound(basename))
2504     return TRUE;
2505
2506 #if 0
2507 #if defined(TARGET_SDL)
2508   if ((fileHasPrefix(basename, "mod") && !fileHasSuffix(basename, "txt")) ||
2509       fileHasSuffix(basename, "mod") ||
2510       fileHasSuffix(basename, "s3m") ||
2511       fileHasSuffix(basename, "it") ||
2512       fileHasSuffix(basename, "xm") ||
2513       fileHasSuffix(basename, "midi") ||
2514       fileHasSuffix(basename, "mid") ||
2515       fileHasSuffix(basename, "mp3") ||
2516       fileHasSuffix(basename, "ogg"))
2517     return TRUE;
2518 #endif
2519 #endif
2520
2521   return FALSE;
2522 #endif
2523 }
2524
2525 boolean FileIsArtworkType(char *basename, int type)
2526 {
2527   if ((type == TREE_TYPE_GRAPHICS_DIR && FileIsGraphic(basename)) ||
2528       (type == TREE_TYPE_SOUNDS_DIR && FileIsSound(basename)) ||
2529       (type == TREE_TYPE_MUSIC_DIR && FileIsMusic(basename)))
2530     return TRUE;
2531
2532   return FALSE;
2533 }
2534
2535 /* ------------------------------------------------------------------------- */
2536 /* functions for loading artwork configuration information                   */
2537 /* ------------------------------------------------------------------------- */
2538
2539 char *get_mapped_token(char *token)
2540 {
2541   /* !!! make this dynamically configurable (init.c:InitArtworkConfig) !!! */
2542   static char *map_token_prefix[][2] =
2543   {
2544     { "char_procent",           "char_percent"  },
2545     { NULL,                                     }
2546   };
2547   int i;
2548
2549   for (i = 0; map_token_prefix[i][0] != NULL; i++)
2550   {
2551     int len_token_prefix = strlen(map_token_prefix[i][0]);
2552
2553     if (strncmp(token, map_token_prefix[i][0], len_token_prefix) == 0)
2554       return getStringCat2(map_token_prefix[i][1], &token[len_token_prefix]);
2555   }
2556
2557   return NULL;
2558 }
2559
2560 /* This function checks if a string <s> of the format "string1, string2, ..."
2561    exactly contains a string <s_contained>. */
2562
2563 static boolean string_has_parameter(char *s, char *s_contained)
2564 {
2565   char *substring;
2566
2567   if (s == NULL || s_contained == NULL)
2568     return FALSE;
2569
2570   if (strlen(s_contained) > strlen(s))
2571     return FALSE;
2572
2573   if (strncmp(s, s_contained, strlen(s_contained)) == 0)
2574   {
2575     char next_char = s[strlen(s_contained)];
2576
2577     /* check if next character is delimiter or whitespace */
2578     return (next_char == ',' || next_char == '\0' ||
2579             next_char == ' ' || next_char == '\t' ? TRUE : FALSE);
2580   }
2581
2582   /* check if string contains another parameter string after a comma */
2583   substring = strchr(s, ',');
2584   if (substring == NULL)        /* string does not contain a comma */
2585     return FALSE;
2586
2587   /* advance string pointer to next character after the comma */
2588   substring++;
2589
2590   /* skip potential whitespaces after the comma */
2591   while (*substring == ' ' || *substring == '\t')
2592     substring++;
2593
2594   return string_has_parameter(substring, s_contained);
2595 }
2596
2597 int get_parameter_value(char *value_raw, char *suffix, int type)
2598 {
2599   char *value = getStringToLower(value_raw);
2600   int result = 0;       /* probably a save default value */
2601
2602   if (strEqual(suffix, ".direction"))
2603   {
2604     result = (strEqual(value, "left")  ? MV_LEFT :
2605               strEqual(value, "right") ? MV_RIGHT :
2606               strEqual(value, "up")    ? MV_UP :
2607               strEqual(value, "down")  ? MV_DOWN : MV_NONE);
2608   }
2609   else if (strEqual(suffix, ".align"))
2610   {
2611     result = (strEqual(value, "left")   ? ALIGN_LEFT :
2612               strEqual(value, "right")  ? ALIGN_RIGHT :
2613               strEqual(value, "center") ? ALIGN_CENTER :
2614               strEqual(value, "middle") ? ALIGN_CENTER : ALIGN_DEFAULT);
2615   }
2616   else if (strEqual(suffix, ".valign"))
2617   {
2618     result = (strEqual(value, "top")    ? VALIGN_TOP :
2619               strEqual(value, "bottom") ? VALIGN_BOTTOM :
2620               strEqual(value, "middle") ? VALIGN_MIDDLE :
2621               strEqual(value, "center") ? VALIGN_MIDDLE : VALIGN_DEFAULT);
2622   }
2623   else if (strEqual(suffix, ".anim_mode"))
2624   {
2625     result = (string_has_parameter(value, "none")       ? ANIM_NONE :
2626               string_has_parameter(value, "loop")       ? ANIM_LOOP :
2627               string_has_parameter(value, "linear")     ? ANIM_LINEAR :
2628               string_has_parameter(value, "pingpong")   ? ANIM_PINGPONG :
2629               string_has_parameter(value, "pingpong2")  ? ANIM_PINGPONG2 :
2630               string_has_parameter(value, "random")     ? ANIM_RANDOM :
2631               string_has_parameter(value, "ce_value")   ? ANIM_CE_VALUE :
2632               string_has_parameter(value, "ce_score")   ? ANIM_CE_SCORE :
2633               string_has_parameter(value, "ce_delay")   ? ANIM_CE_DELAY :
2634               string_has_parameter(value, "horizontal") ? ANIM_HORIZONTAL :
2635               string_has_parameter(value, "vertical")   ? ANIM_VERTICAL :
2636               string_has_parameter(value, "centered")   ? ANIM_CENTERED :
2637               ANIM_DEFAULT);
2638
2639     if (string_has_parameter(value, "reverse"))
2640       result |= ANIM_REVERSE;
2641
2642     if (string_has_parameter(value, "opaque_player"))
2643       result |= ANIM_OPAQUE_PLAYER;
2644
2645     if (string_has_parameter(value, "static_panel"))
2646       result |= ANIM_STATIC_PANEL;
2647   }
2648   else if (strEqual(suffix, ".class"))
2649   {
2650     result = get_hash_from_key(value);
2651   }
2652   else if (strEqual(suffix, ".style"))
2653   {
2654     result = STYLE_DEFAULT;
2655
2656     if (string_has_parameter(value, "accurate_borders"))
2657       result |= STYLE_ACCURATE_BORDERS;
2658
2659     if (string_has_parameter(value, "inner_corners"))
2660       result |= STYLE_INNER_CORNERS;
2661   }
2662   else if (strEqual(suffix, ".fade_mode"))
2663   {
2664     result = (string_has_parameter(value, "none")       ? FADE_MODE_NONE :
2665               string_has_parameter(value, "fade")       ? FADE_MODE_FADE :
2666               string_has_parameter(value, "crossfade")  ? FADE_MODE_CROSSFADE :
2667               string_has_parameter(value, "melt")       ? FADE_MODE_MELT :
2668               FADE_MODE_DEFAULT);
2669   }
2670 #if 1
2671   else if (strPrefix(suffix, ".font"))          /* (may also be ".font_xyz") */
2672 #else
2673   else if (strEqualN(suffix, ".font", 5))       /* (may also be ".font_xyz") */
2674 #endif
2675   {
2676     result = gfx.get_font_from_token_function(value);
2677   }
2678   else          /* generic parameter of type integer or boolean */
2679   {
2680     result = (strEqual(value, ARG_UNDEFINED) ? ARG_UNDEFINED_VALUE :
2681               type == TYPE_INTEGER ? get_integer_from_string(value) :
2682               type == TYPE_BOOLEAN ? get_boolean_from_string(value) :
2683               ARG_UNDEFINED_VALUE);
2684   }
2685
2686   free(value);
2687
2688   return result;
2689 }
2690
2691 struct ScreenModeInfo *get_screen_mode_from_string(char *screen_mode_string)
2692 {
2693   static struct ScreenModeInfo screen_mode;
2694   char *screen_mode_string_x = strchr(screen_mode_string, 'x');
2695   char *screen_mode_string_copy;
2696   char *screen_mode_string_pos_w;
2697   char *screen_mode_string_pos_h;
2698
2699   if (screen_mode_string_x == NULL)     /* invalid screen mode format */
2700     return NULL;
2701
2702   screen_mode_string_copy = getStringCopy(screen_mode_string);
2703
2704   screen_mode_string_pos_w = screen_mode_string_copy;
2705   screen_mode_string_pos_h = strchr(screen_mode_string_copy, 'x');
2706   *screen_mode_string_pos_h++ = '\0';
2707
2708   screen_mode.width  = atoi(screen_mode_string_pos_w);
2709   screen_mode.height = atoi(screen_mode_string_pos_h);
2710
2711   return &screen_mode;
2712 }
2713
2714 void get_aspect_ratio_from_screen_mode(struct ScreenModeInfo *screen_mode,
2715                                        int *x, int *y)
2716 {
2717   float aspect_ratio = (float)screen_mode->width / (float)screen_mode->height;
2718   float aspect_ratio_new;
2719   int i = 1;
2720
2721   do
2722   {
2723     *x = i * aspect_ratio + 0.000001;
2724     *y = i;
2725
2726     aspect_ratio_new = (float)*x / (float)*y;
2727
2728     i++;
2729   }
2730   while (aspect_ratio_new != aspect_ratio && *y < screen_mode->height);
2731 }
2732
2733 static void FreeCustomArtworkList(struct ArtworkListInfo *,
2734                                   struct ListNodeInfo ***, int *);
2735
2736 struct FileInfo *getFileListFromConfigList(struct ConfigInfo *config_list,
2737                                            struct ConfigTypeInfo *suffix_list,
2738                                            char **ignore_tokens,
2739                                            int num_file_list_entries)
2740 {
2741   struct FileInfo *file_list;
2742   int num_file_list_entries_found = 0;
2743   int num_suffix_list_entries = 0;
2744   int list_pos;
2745   int i, j;
2746
2747   file_list = checked_calloc(num_file_list_entries * sizeof(struct FileInfo));
2748
2749   for (i = 0; suffix_list[i].token != NULL; i++)
2750     num_suffix_list_entries++;
2751
2752   /* always start with reliable default values */
2753   for (i = 0; i < num_file_list_entries; i++)
2754   {
2755     file_list[i].token = NULL;
2756
2757     file_list[i].default_filename = NULL;
2758     file_list[i].filename = NULL;
2759
2760     if (num_suffix_list_entries > 0)
2761     {
2762       int parameter_array_size = num_suffix_list_entries * sizeof(char *);
2763
2764       file_list[i].default_parameter = checked_calloc(parameter_array_size);
2765       file_list[i].parameter = checked_calloc(parameter_array_size);
2766
2767       for (j = 0; j < num_suffix_list_entries; j++)
2768       {
2769         setString(&file_list[i].default_parameter[j], suffix_list[j].value);
2770         setString(&file_list[i].parameter[j], suffix_list[j].value);
2771       }
2772
2773       file_list[i].redefined = FALSE;
2774       file_list[i].fallback_to_default = FALSE;
2775       file_list[i].default_is_cloned = FALSE;
2776     }
2777   }
2778
2779   list_pos = 0;
2780
2781   for (i = 0; config_list[i].token != NULL; i++)
2782   {
2783     int len_config_token = strlen(config_list[i].token);
2784 #if 0
2785     int len_config_value = strlen(config_list[i].value);
2786 #endif
2787     boolean is_file_entry = TRUE;
2788
2789     for (j = 0; suffix_list[j].token != NULL; j++)
2790     {
2791       int len_suffix = strlen(suffix_list[j].token);
2792
2793       if (len_suffix < len_config_token &&
2794           strEqual(&config_list[i].token[len_config_token - len_suffix],
2795                    suffix_list[j].token))
2796       {
2797         setString(&file_list[list_pos].default_parameter[j],
2798                   config_list[i].value);
2799
2800         is_file_entry = FALSE;
2801
2802         break;
2803       }
2804     }
2805
2806     /* the following tokens are no file definitions, but other config tokens */
2807     for (j = 0; ignore_tokens[j] != NULL; j++)
2808       if (strEqual(config_list[i].token, ignore_tokens[j]))
2809         is_file_entry = FALSE;
2810
2811     if (is_file_entry)
2812     {
2813       if (i > 0)
2814         list_pos++;
2815
2816       if (list_pos >= num_file_list_entries)
2817         break;
2818
2819 #if 0
2820       /* simple sanity check if this is really a file definition */
2821       if (!strEqual(&config_list[i].value[len_config_value - 4], ".pcx") &&
2822           !strEqual(&config_list[i].value[len_config_value - 4], ".wav") &&
2823           !strEqual(config_list[i].value, UNDEFINED_FILENAME))
2824       {
2825         Error(ERR_INFO, "Configuration directive '%s' -> '%s':",
2826               config_list[i].token, config_list[i].value);
2827         Error(ERR_EXIT, "This seems to be no valid definition -- please fix");
2828       }
2829 #endif
2830
2831       file_list[list_pos].token = config_list[i].token;
2832       file_list[list_pos].default_filename = config_list[i].value;
2833
2834 #if 0
2835       printf("::: '%s' => '%s'\n", config_list[i].token, config_list[i].value);
2836 #endif
2837     }
2838
2839     if (strSuffix(config_list[i].token, ".clone_from"))
2840       file_list[list_pos].default_is_cloned = TRUE;
2841   }
2842
2843   num_file_list_entries_found = list_pos + 1;
2844   if (num_file_list_entries_found != num_file_list_entries)
2845   {
2846     Error(ERR_INFO_LINE, "-");
2847     Error(ERR_INFO, "inconsistant config list information:");
2848     Error(ERR_INFO, "- should be:   %d (according to 'src/conf_xxx.h')",
2849           num_file_list_entries);
2850     Error(ERR_INFO, "- found to be: %d (according to 'src/conf_xxx.c')",
2851           num_file_list_entries_found);
2852     Error(ERR_EXIT,   "please fix");
2853   }
2854
2855 #if 0
2856   printf("::: ---------- DONE ----------\n");
2857 #endif
2858
2859   return file_list;
2860 }
2861
2862 static boolean token_suffix_match(char *token, char *suffix, int start_pos)
2863 {
2864   int len_token = strlen(token);
2865   int len_suffix = strlen(suffix);
2866
2867   if (start_pos < 0)    /* compare suffix from end of string */
2868     start_pos += len_token;
2869
2870   if (start_pos < 0 || start_pos + len_suffix > len_token)
2871     return FALSE;
2872
2873   if (strncmp(&token[start_pos], suffix, len_suffix) != 0)
2874     return FALSE;
2875
2876   if (token[start_pos + len_suffix] == '\0')
2877     return TRUE;
2878
2879   if (token[start_pos + len_suffix] == '.')
2880     return TRUE;
2881
2882   return FALSE;
2883 }
2884
2885 #define KNOWN_TOKEN_VALUE       "[KNOWN_TOKEN_VALUE]"
2886
2887 static void read_token_parameters(SetupFileHash *setup_file_hash,
2888                                   struct ConfigTypeInfo *suffix_list,
2889                                   struct FileInfo *file_list_entry)
2890 {
2891   /* check for config token that is the base token without any suffixes */
2892   char *filename = getHashEntry(setup_file_hash, file_list_entry->token);
2893   char *known_token_value = KNOWN_TOKEN_VALUE;
2894   int i;
2895
2896   if (filename != NULL)
2897   {
2898     setString(&file_list_entry->filename, filename);
2899
2900     /* when file definition found, set all parameters to default values */
2901     for (i = 0; suffix_list[i].token != NULL; i++)
2902       setString(&file_list_entry->parameter[i], suffix_list[i].value);
2903
2904     file_list_entry->redefined = TRUE;
2905
2906     /* mark config file token as well known from default config */
2907     setHashEntry(setup_file_hash, file_list_entry->token, known_token_value);
2908   }
2909
2910   /* check for config tokens that can be build by base token and suffixes */
2911   for (i = 0; suffix_list[i].token != NULL; i++)
2912   {
2913     char *token = getStringCat2(file_list_entry->token, suffix_list[i].token);
2914     char *value = getHashEntry(setup_file_hash, token);
2915
2916     if (value != NULL)
2917     {
2918       setString(&file_list_entry->parameter[i], value);
2919
2920       /* mark config file token as well known from default config */
2921       setHashEntry(setup_file_hash, token, known_token_value);
2922     }
2923
2924     free(token);
2925   }
2926 }
2927
2928 static void add_dynamic_file_list_entry(struct FileInfo **list,
2929                                         int *num_list_entries,
2930                                         SetupFileHash *extra_file_hash,
2931                                         struct ConfigTypeInfo *suffix_list,
2932                                         int num_suffix_list_entries,
2933                                         char *token)
2934 {
2935   struct FileInfo *new_list_entry;
2936   int parameter_array_size = num_suffix_list_entries * sizeof(char *);
2937
2938   (*num_list_entries)++;
2939   *list = checked_realloc(*list, *num_list_entries * sizeof(struct FileInfo));
2940   new_list_entry = &(*list)[*num_list_entries - 1];
2941
2942   new_list_entry->token = getStringCopy(token);
2943   new_list_entry->default_filename = NULL;
2944   new_list_entry->filename = NULL;
2945   new_list_entry->parameter = checked_calloc(parameter_array_size);
2946
2947   new_list_entry->redefined = FALSE;
2948   new_list_entry->fallback_to_default = FALSE;
2949   new_list_entry->default_is_cloned = FALSE;
2950
2951   read_token_parameters(extra_file_hash, suffix_list, new_list_entry);
2952 }
2953
2954 static void add_property_mapping(struct PropertyMapping **list,
2955                                  int *num_list_entries,
2956                                  int base_index, int ext1_index,
2957                                  int ext2_index, int ext3_index,
2958                                  int artwork_index)
2959 {
2960   struct PropertyMapping *new_list_entry;
2961
2962   (*num_list_entries)++;
2963   *list = checked_realloc(*list,
2964                           *num_list_entries * sizeof(struct PropertyMapping));
2965   new_list_entry = &(*list)[*num_list_entries - 1];
2966
2967   new_list_entry->base_index = base_index;
2968   new_list_entry->ext1_index = ext1_index;
2969   new_list_entry->ext2_index = ext2_index;
2970   new_list_entry->ext3_index = ext3_index;
2971
2972   new_list_entry->artwork_index = artwork_index;
2973 }
2974
2975 static void LoadArtworkConfigFromFilename(struct ArtworkListInfo *artwork_info,
2976                                           char *filename)
2977 {
2978   struct FileInfo *file_list = artwork_info->file_list;
2979   struct ConfigTypeInfo *suffix_list = artwork_info->suffix_list;
2980   char **base_prefixes = artwork_info->base_prefixes;
2981   char **ext1_suffixes = artwork_info->ext1_suffixes;
2982   char **ext2_suffixes = artwork_info->ext2_suffixes;
2983   char **ext3_suffixes = artwork_info->ext3_suffixes;
2984   char **ignore_tokens = artwork_info->ignore_tokens;
2985   int num_file_list_entries = artwork_info->num_file_list_entries;
2986   int num_suffix_list_entries = artwork_info->num_suffix_list_entries;
2987   int num_base_prefixes = artwork_info->num_base_prefixes;
2988   int num_ext1_suffixes = artwork_info->num_ext1_suffixes;
2989   int num_ext2_suffixes = artwork_info->num_ext2_suffixes;
2990   int num_ext3_suffixes = artwork_info->num_ext3_suffixes;
2991   int num_ignore_tokens = artwork_info->num_ignore_tokens;
2992   SetupFileHash *setup_file_hash, *valid_file_hash;
2993   SetupFileHash *extra_file_hash, *empty_file_hash;
2994   char *known_token_value = KNOWN_TOKEN_VALUE;
2995   int i, j, k, l;
2996
2997   if (filename == NULL)
2998     return;
2999
3000 #if 0
3001   printf("LoadArtworkConfigFromFilename '%s' ...\n", filename);
3002 #endif
3003
3004   if ((setup_file_hash = loadSetupFileHash(filename)) == NULL)
3005     return;
3006
3007   /* separate valid (defined) from empty (undefined) config token values */
3008   valid_file_hash = newSetupFileHash();
3009   empty_file_hash = newSetupFileHash();
3010   BEGIN_HASH_ITERATION(setup_file_hash, itr)
3011   {
3012     char *value = HASH_ITERATION_VALUE(itr);
3013
3014     setHashEntry(*value ? valid_file_hash : empty_file_hash,
3015                  HASH_ITERATION_TOKEN(itr), value);
3016   }
3017   END_HASH_ITERATION(setup_file_hash, itr)
3018
3019   /* at this point, we do not need the setup file hash anymore -- free it */
3020   freeSetupFileHash(setup_file_hash);
3021
3022   /* map deprecated to current tokens (using prefix match and replace) */
3023   BEGIN_HASH_ITERATION(valid_file_hash, itr)
3024   {
3025     char *token = HASH_ITERATION_TOKEN(itr);
3026     char *mapped_token = get_mapped_token(token);
3027
3028     if (mapped_token != NULL)
3029     {
3030       char *value = HASH_ITERATION_VALUE(itr);
3031
3032       /* add mapped token */
3033       setHashEntry(valid_file_hash, mapped_token, value);
3034
3035       /* ignore old token (by setting it to "known" keyword) */
3036       setHashEntry(valid_file_hash, token, known_token_value);
3037
3038       free(mapped_token);
3039     }
3040   }
3041   END_HASH_ITERATION(valid_file_hash, itr)
3042
3043   /* read parameters for all known config file tokens */
3044   for (i = 0; i < num_file_list_entries; i++)
3045     read_token_parameters(valid_file_hash, suffix_list, &file_list[i]);
3046
3047   /* set all tokens that can be ignored here to "known" keyword */
3048   for (i = 0; i < num_ignore_tokens; i++)
3049     setHashEntry(valid_file_hash, ignore_tokens[i], known_token_value);
3050
3051   /* copy all unknown config file tokens to extra config hash */
3052   extra_file_hash = newSetupFileHash();
3053   BEGIN_HASH_ITERATION(valid_file_hash, itr)
3054   {
3055     char *value = HASH_ITERATION_VALUE(itr);
3056
3057     if (!strEqual(value, known_token_value))
3058       setHashEntry(extra_file_hash, HASH_ITERATION_TOKEN(itr), value);
3059   }
3060   END_HASH_ITERATION(valid_file_hash, itr)
3061
3062   /* at this point, we do not need the valid file hash anymore -- free it */
3063   freeSetupFileHash(valid_file_hash);
3064
3065   /* now try to determine valid, dynamically defined config tokens */
3066
3067   BEGIN_HASH_ITERATION(extra_file_hash, itr)
3068   {
3069     struct FileInfo **dynamic_file_list =
3070       &artwork_info->dynamic_file_list;
3071     int *num_dynamic_file_list_entries =
3072       &artwork_info->num_dynamic_file_list_entries;
3073     struct PropertyMapping **property_mapping =
3074       &artwork_info->property_mapping;
3075     int *num_property_mapping_entries =
3076       &artwork_info->num_property_mapping_entries;
3077     int current_summarized_file_list_entry =
3078       artwork_info->num_file_list_entries +
3079       artwork_info->num_dynamic_file_list_entries;
3080     char *token = HASH_ITERATION_TOKEN(itr);
3081     int len_token = strlen(token);
3082     int start_pos;
3083     boolean base_prefix_found = FALSE;
3084     boolean parameter_suffix_found = FALSE;
3085
3086 #if 0
3087     printf("::: examining '%s' -> '%s'\n", token, HASH_ITERATION_VALUE(itr));
3088 #endif
3089
3090     /* skip all parameter definitions (handled by read_token_parameters()) */
3091     for (i = 0; i < num_suffix_list_entries && !parameter_suffix_found; i++)
3092     {
3093       int len_suffix = strlen(suffix_list[i].token);
3094
3095       if (token_suffix_match(token, suffix_list[i].token, -len_suffix))
3096         parameter_suffix_found = TRUE;
3097     }
3098
3099     if (parameter_suffix_found)
3100       continue;
3101
3102     /* ---------- step 0: search for matching base prefix ---------- */
3103
3104     start_pos = 0;
3105     for (i = 0; i < num_base_prefixes && !base_prefix_found; i++)
3106     {
3107       char *base_prefix = base_prefixes[i];
3108       int len_base_prefix = strlen(base_prefix);
3109       boolean ext1_suffix_found = FALSE;
3110       boolean ext2_suffix_found = FALSE;
3111       boolean ext3_suffix_found = FALSE;
3112       boolean exact_match = FALSE;
3113       int base_index = -1;
3114       int ext1_index = -1;
3115       int ext2_index = -1;
3116       int ext3_index = -1;
3117
3118       base_prefix_found = token_suffix_match(token, base_prefix, start_pos);
3119
3120       if (!base_prefix_found)
3121         continue;
3122
3123       base_index = i;
3124
3125 #if 0
3126       if (IS_PARENT_PROCESS())
3127         printf("===> MATCH: '%s', '%s'\n", token, base_prefix);
3128 #endif
3129
3130       if (start_pos + len_base_prefix == len_token)     /* exact match */
3131       {
3132         exact_match = TRUE;
3133
3134 #if 0
3135         if (IS_PARENT_PROCESS())
3136           printf("===> EXACT MATCH: '%s', '%s'\n", token, base_prefix);
3137 #endif
3138
3139         add_dynamic_file_list_entry(dynamic_file_list,
3140                                     num_dynamic_file_list_entries,
3141                                     extra_file_hash,
3142                                     suffix_list,
3143                                     num_suffix_list_entries,
3144                                     token);
3145         add_property_mapping(property_mapping,
3146                              num_property_mapping_entries,
3147                              base_index, -1, -1, -1,
3148                              current_summarized_file_list_entry);
3149         continue;
3150       }
3151
3152 #if 0
3153       if (IS_PARENT_PROCESS())
3154         printf("---> examining token '%s': search 1st suffix ...\n", token);
3155 #endif
3156
3157       /* ---------- step 1: search for matching first suffix ---------- */
3158
3159       start_pos += len_base_prefix;
3160       for (j = 0; j < num_ext1_suffixes && !ext1_suffix_found; j++)
3161       {
3162         char *ext1_suffix = ext1_suffixes[j];
3163         int len_ext1_suffix = strlen(ext1_suffix);
3164
3165         ext1_suffix_found = token_suffix_match(token, ext1_suffix, start_pos);
3166
3167         if (!ext1_suffix_found)
3168           continue;
3169
3170         ext1_index = j;
3171
3172 #if 0
3173         if (IS_PARENT_PROCESS())
3174           printf("===> MATCH: '%s', '%s'\n", token, ext1_suffix);
3175 #endif
3176
3177         if (start_pos + len_ext1_suffix == len_token)   /* exact match */
3178         {
3179           exact_match = TRUE;
3180
3181 #if 0
3182         if (IS_PARENT_PROCESS())
3183           printf("===> EXACT MATCH: '%s', '%s'\n", token, ext1_suffix);
3184 #endif
3185
3186           add_dynamic_file_list_entry(dynamic_file_list,
3187                                       num_dynamic_file_list_entries,
3188                                       extra_file_hash,
3189                                       suffix_list,
3190                                       num_suffix_list_entries,
3191                                       token);
3192           add_property_mapping(property_mapping,
3193                                num_property_mapping_entries,
3194                                base_index, ext1_index, -1, -1,
3195                                current_summarized_file_list_entry);
3196           continue;
3197         }
3198
3199         start_pos += len_ext1_suffix;
3200       }
3201
3202       if (exact_match)
3203         break;
3204
3205 #if 0
3206       if (IS_PARENT_PROCESS())
3207         printf("---> examining token '%s': search 2nd suffix ...\n", token);
3208 #endif
3209
3210       /* ---------- step 2: search for matching second suffix ---------- */
3211
3212       for (k = 0; k < num_ext2_suffixes && !ext2_suffix_found; k++)
3213       {
3214         char *ext2_suffix = ext2_suffixes[k];
3215         int len_ext2_suffix = strlen(ext2_suffix);
3216
3217         ext2_suffix_found = token_suffix_match(token, ext2_suffix, start_pos);
3218
3219         if (!ext2_suffix_found)
3220           continue;
3221
3222         ext2_index = k;
3223
3224 #if 0
3225         if (IS_PARENT_PROCESS())
3226           printf("===> MATCH: '%s', '%s'\n", token, ext2_suffix);
3227 #endif
3228
3229         if (start_pos + len_ext2_suffix == len_token)   /* exact match */
3230         {
3231           exact_match = TRUE;
3232
3233 #if 0
3234           if (IS_PARENT_PROCESS())
3235             printf("===> EXACT MATCH: '%s', '%s'\n", token, ext2_suffix);
3236 #endif
3237
3238           add_dynamic_file_list_entry(dynamic_file_list,
3239                                       num_dynamic_file_list_entries,
3240                                       extra_file_hash,
3241                                       suffix_list,
3242                                       num_suffix_list_entries,
3243                                       token);
3244           add_property_mapping(property_mapping,
3245                                num_property_mapping_entries,
3246                                base_index, ext1_index, ext2_index, -1,
3247                                current_summarized_file_list_entry);
3248           continue;
3249         }
3250
3251         start_pos += len_ext2_suffix;
3252       }
3253
3254       if (exact_match)
3255         break;
3256
3257 #if 0
3258       if (IS_PARENT_PROCESS())
3259         printf("---> examining token '%s': search 3rd suffix ...\n",token);
3260 #endif
3261
3262       /* ---------- step 3: search for matching third suffix ---------- */
3263
3264       for (l = 0; l < num_ext3_suffixes && !ext3_suffix_found; l++)
3265       {
3266         char *ext3_suffix = ext3_suffixes[l];
3267         int len_ext3_suffix = strlen(ext3_suffix);
3268
3269         ext3_suffix_found = token_suffix_match(token, ext3_suffix, start_pos);
3270
3271         if (!ext3_suffix_found)
3272           continue;
3273
3274         ext3_index = l;
3275
3276 #if 0
3277         if (IS_PARENT_PROCESS())
3278           printf("===> MATCH: '%s', '%s'\n", token, ext3_suffix);
3279 #endif
3280
3281         if (start_pos + len_ext3_suffix == len_token) /* exact match */
3282         {
3283           exact_match = TRUE;
3284
3285 #if 0
3286           if (IS_PARENT_PROCESS())
3287             printf("===> EXACT MATCH: '%s', '%s'\n", token, ext3_suffix);
3288 #endif
3289
3290           add_dynamic_file_list_entry(dynamic_file_list,
3291                                       num_dynamic_file_list_entries,
3292                                       extra_file_hash,
3293                                       suffix_list,
3294                                       num_suffix_list_entries,
3295                                       token);
3296           add_property_mapping(property_mapping,
3297                                num_property_mapping_entries,
3298                                base_index, ext1_index, ext2_index, ext3_index,
3299                                current_summarized_file_list_entry);
3300           continue;
3301         }
3302       }
3303     }
3304   }
3305   END_HASH_ITERATION(extra_file_hash, itr)
3306
3307   if (artwork_info->num_dynamic_file_list_entries > 0)
3308   {
3309     artwork_info->dynamic_artwork_list =
3310       checked_calloc(artwork_info->num_dynamic_file_list_entries *
3311                      artwork_info->sizeof_artwork_list_entry);
3312   }
3313
3314   if (options.verbose && IS_PARENT_PROCESS())
3315   {
3316     SetupFileList *setup_file_list, *list;
3317     boolean dynamic_tokens_found = FALSE;
3318     boolean unknown_tokens_found = FALSE;
3319     boolean undefined_values_found = (hashtable_count(empty_file_hash) != 0);
3320
3321     if ((setup_file_list = loadSetupFileList(filename)) == NULL)
3322       Error(ERR_EXIT, "loadSetupFileHash works, but loadSetupFileList fails");
3323
3324     BEGIN_HASH_ITERATION(extra_file_hash, itr)
3325     {
3326       if (strEqual(HASH_ITERATION_VALUE(itr), known_token_value))
3327         dynamic_tokens_found = TRUE;
3328       else
3329         unknown_tokens_found = TRUE;
3330     }
3331     END_HASH_ITERATION(extra_file_hash, itr)
3332
3333     if (options.debug && dynamic_tokens_found)
3334     {
3335       Error(ERR_INFO_LINE, "-");
3336       Error(ERR_INFO, "dynamic token(s) found in config file:");
3337       Error(ERR_INFO, "- config file: '%s'", filename);
3338
3339       for (list = setup_file_list; list != NULL; list = list->next)
3340       {
3341         char *value = getHashEntry(extra_file_hash, list->token);
3342
3343         if (value != NULL && strEqual(value, known_token_value))
3344           Error(ERR_INFO, "- dynamic token: '%s'", list->token);
3345       }
3346
3347       Error(ERR_INFO_LINE, "-");
3348     }
3349
3350     if (unknown_tokens_found)
3351     {
3352       Error(ERR_INFO_LINE, "-");
3353       Error(ERR_INFO, "warning: unknown token(s) found in config file:");
3354       Error(ERR_INFO, "- config file: '%s'", filename);
3355
3356       for (list = setup_file_list; list != NULL; list = list->next)
3357       {
3358         char *value = getHashEntry(extra_file_hash, list->token);
3359
3360         if (value != NULL && !strEqual(value, known_token_value))
3361           Error(ERR_INFO, "- dynamic token: '%s'", list->token);
3362       }
3363
3364       Error(ERR_INFO_LINE, "-");
3365     }
3366
3367     if (undefined_values_found)
3368     {
3369       Error(ERR_INFO_LINE, "-");
3370       Error(ERR_INFO, "warning: undefined values found in config file:");
3371       Error(ERR_INFO, "- config file: '%s'", filename);
3372
3373       for (list = setup_file_list; list != NULL; list = list->next)
3374       {
3375         char *value = getHashEntry(empty_file_hash, list->token);
3376
3377         if (value != NULL)
3378           Error(ERR_INFO, "- undefined value for token: '%s'", list->token);
3379       }
3380
3381       Error(ERR_INFO_LINE, "-");
3382     }
3383
3384     freeSetupFileList(setup_file_list);
3385   }
3386
3387   freeSetupFileHash(extra_file_hash);
3388   freeSetupFileHash(empty_file_hash);
3389
3390 #if 0
3391   for (i = 0; i < num_file_list_entries; i++)
3392   {
3393     printf("'%s' ", file_list[i].token);
3394     if (file_list[i].filename)
3395       printf("-> '%s'\n", file_list[i].filename);
3396     else
3397       printf("-> UNDEFINED [-> '%s']\n", file_list[i].default_filename);
3398   }
3399 #endif
3400 }
3401
3402 void LoadArtworkConfig(struct ArtworkListInfo *artwork_info)
3403 {
3404   struct FileInfo *file_list = artwork_info->file_list;
3405   int num_file_list_entries = artwork_info->num_file_list_entries;
3406   int num_suffix_list_entries = artwork_info->num_suffix_list_entries;
3407   char *filename_base = UNDEFINED_FILENAME, *filename_local;
3408   int i, j;
3409
3410   DrawInitText("Loading artwork config", 120, FC_GREEN);
3411   DrawInitText(ARTWORKINFO_FILENAME(artwork_info->type), 150, FC_YELLOW);
3412
3413   /* always start with reliable default values */
3414   for (i = 0; i < num_file_list_entries; i++)
3415   {
3416     setString(&file_list[i].filename, file_list[i].default_filename);
3417
3418     for (j = 0; j < num_suffix_list_entries; j++)
3419       setString(&file_list[i].parameter[j], file_list[i].default_parameter[j]);
3420
3421     file_list[i].redefined = FALSE;
3422     file_list[i].fallback_to_default = FALSE;
3423   }
3424
3425   /* free previous dynamic artwork file array */
3426   if (artwork_info->dynamic_file_list != NULL)
3427   {
3428     for (i = 0; i < artwork_info->num_dynamic_file_list_entries; i++)
3429     {
3430       free(artwork_info->dynamic_file_list[i].token);
3431       free(artwork_info->dynamic_file_list[i].filename);
3432       free(artwork_info->dynamic_file_list[i].parameter);
3433     }
3434
3435     free(artwork_info->dynamic_file_list);
3436     artwork_info->dynamic_file_list = NULL;
3437
3438     FreeCustomArtworkList(artwork_info, &artwork_info->dynamic_artwork_list,
3439                           &artwork_info->num_dynamic_file_list_entries);
3440   }
3441
3442   /* free previous property mapping */
3443   if (artwork_info->property_mapping != NULL)
3444   {
3445     free(artwork_info->property_mapping);
3446
3447     artwork_info->property_mapping = NULL;
3448     artwork_info->num_property_mapping_entries = 0;
3449   }
3450
3451 #if 1
3452   if (!GFX_OVERRIDE_ARTWORK(artwork_info->type))
3453 #else
3454   if (!SETUP_OVERRIDE_ARTWORK(setup, artwork_info->type))
3455 #endif
3456   {
3457     /* first look for special artwork configured in level series config */
3458     filename_base = getCustomArtworkLevelConfigFilename(artwork_info->type);
3459
3460 #if 0
3461     printf("::: filename_base == '%s' [%s, %s]\n", filename_base,
3462            leveldir_current->graphics_set,
3463            leveldir_current->graphics_path);
3464 #endif
3465
3466     if (fileExists(filename_base))
3467       LoadArtworkConfigFromFilename(artwork_info, filename_base);
3468   }
3469
3470   filename_local = getCustomArtworkConfigFilename(artwork_info->type);
3471
3472   if (filename_local != NULL && !strEqual(filename_base, filename_local))
3473     LoadArtworkConfigFromFilename(artwork_info, filename_local);
3474 }
3475
3476 static void deleteArtworkListEntry(struct ArtworkListInfo *artwork_info,
3477                                    struct ListNodeInfo **listnode)
3478 {
3479   if (*listnode)
3480   {
3481     char *filename = (*listnode)->source_filename;
3482
3483     if (--(*listnode)->num_references <= 0)
3484       deleteNodeFromList(&artwork_info->content_list, filename,
3485                          artwork_info->free_artwork);
3486
3487     *listnode = NULL;
3488   }
3489 }
3490
3491 static void replaceArtworkListEntry(struct ArtworkListInfo *artwork_info,
3492                                     struct ListNodeInfo **listnode,
3493                                     struct FileInfo *file_list_entry)
3494 {
3495   char *init_text[] =
3496   {
3497     "Loading graphics",
3498     "Loading sounds",
3499     "Loading music"
3500   };
3501
3502   ListNode *node;
3503   char *basename = file_list_entry->filename;
3504   char *filename = getCustomArtworkFilename(basename, artwork_info->type);
3505
3506   if (filename == NULL)
3507   {
3508     Error(ERR_WARN, "cannot find artwork file '%s'", basename);
3509
3510     basename = file_list_entry->default_filename;
3511
3512     /* fail for cloned default artwork that has no default filename defined */
3513     if (file_list_entry->default_is_cloned &&
3514         strEqual(basename, UNDEFINED_FILENAME))
3515     {
3516       int error_mode = ERR_WARN;
3517
3518       /* we can get away without sounds and music, but not without graphics */
3519       if (*listnode == NULL && artwork_info->type == ARTWORK_TYPE_GRAPHICS)
3520         error_mode = ERR_EXIT;
3521
3522       Error(error_mode, "token '%s' was cloned and has no default filename",
3523             file_list_entry->token);
3524
3525       return;
3526     }
3527
3528     /* dynamic artwork has no default filename / skip empty default artwork */
3529     if (basename == NULL || strEqual(basename, UNDEFINED_FILENAME))
3530       return;
3531
3532     file_list_entry->fallback_to_default = TRUE;
3533
3534     Error(ERR_WARN, "trying default artwork file '%s'", basename);
3535
3536     filename = getCustomArtworkFilename(basename, artwork_info->type);
3537
3538     if (filename == NULL)
3539     {
3540       int error_mode = ERR_WARN;
3541
3542       /* we can get away without sounds and music, but not without graphics */
3543       if (*listnode == NULL && artwork_info->type == ARTWORK_TYPE_GRAPHICS)
3544         error_mode = ERR_EXIT;
3545
3546       Error(error_mode, "cannot find default artwork file '%s'", basename);
3547
3548       return;
3549     }
3550   }
3551
3552   /* check if the old and the new artwork file are the same */
3553   if (*listnode && strEqual((*listnode)->source_filename, filename))
3554   {
3555     /* The old and new artwork are the same (have the same filename and path).
3556        This usually means that this artwork does not exist in this artwork set
3557        and a fallback to the existing artwork is done. */
3558
3559 #if 0
3560     printf("[artwork '%s' already exists (same list entry)]\n", filename);
3561 #endif
3562
3563     return;
3564   }
3565
3566   /* delete existing artwork file entry */
3567   deleteArtworkListEntry(artwork_info, listnode);
3568
3569   /* check if the new artwork file already exists in the list of artworks */
3570   if ((node = getNodeFromKey(artwork_info->content_list, filename)) != NULL)
3571   {
3572 #if 0
3573       printf("[artwork '%s' already exists (other list entry)]\n", filename);
3574 #endif
3575
3576       *listnode = (struct ListNodeInfo *)node->content;
3577       (*listnode)->num_references++;
3578
3579       return;
3580   }
3581
3582   DrawInitText(init_text[artwork_info->type], 120, FC_GREEN);
3583   DrawInitText(basename, 150, FC_YELLOW);
3584
3585   if ((*listnode = artwork_info->load_artwork(filename)) != NULL)
3586   {
3587 #if 0
3588       printf("[adding new artwork '%s']\n", filename);
3589 #endif
3590
3591     (*listnode)->num_references = 1;
3592     addNodeToList(&artwork_info->content_list, (*listnode)->source_filename,
3593                   *listnode);
3594   }
3595   else
3596   {
3597     int error_mode = ERR_WARN;
3598
3599     /* we can get away without sounds and music, but not without graphics */
3600     if (artwork_info->type == ARTWORK_TYPE_GRAPHICS)
3601       error_mode = ERR_EXIT;
3602
3603     Error(error_mode, "cannot load artwork file '%s'", basename);
3604
3605     return;
3606   }
3607 }
3608
3609 static void LoadCustomArtwork(struct ArtworkListInfo *artwork_info,
3610                               struct ListNodeInfo **listnode,
3611                               struct FileInfo *file_list_entry)
3612 {
3613 #if 0
3614   printf("GOT CUSTOM ARTWORK FILE '%s'\n", file_list_entry->filename);
3615 #endif
3616
3617   if (strEqual(file_list_entry->filename, UNDEFINED_FILENAME))
3618   {
3619     deleteArtworkListEntry(artwork_info, listnode);
3620
3621     return;
3622   }
3623
3624   replaceArtworkListEntry(artwork_info, listnode, file_list_entry);
3625 }
3626
3627 void ReloadCustomArtworkList(struct ArtworkListInfo *artwork_info)
3628 {
3629   struct FileInfo *file_list = artwork_info->file_list;
3630   struct FileInfo *dynamic_file_list = artwork_info->dynamic_file_list;
3631   int num_file_list_entries = artwork_info->num_file_list_entries;
3632   int num_dynamic_file_list_entries =
3633     artwork_info->num_dynamic_file_list_entries;
3634   int i;
3635
3636   print_timestamp_init("ReloadCustomArtworkList");
3637
3638   for (i = 0; i < num_file_list_entries; i++)
3639     LoadCustomArtwork(artwork_info, &artwork_info->artwork_list[i],
3640                       &file_list[i]);
3641
3642   for (i = 0; i < num_dynamic_file_list_entries; i++)
3643     LoadCustomArtwork(artwork_info, &artwork_info->dynamic_artwork_list[i],
3644                       &dynamic_file_list[i]);
3645
3646   print_timestamp_done("ReloadCustomArtworkList");
3647
3648 #if 0
3649   dumpList(artwork_info->content_list);
3650 #endif
3651 }
3652
3653 static void FreeCustomArtworkList(struct ArtworkListInfo *artwork_info,
3654                                   struct ListNodeInfo ***list,
3655                                   int *num_list_entries)
3656 {
3657   int i;
3658
3659   if (*list == NULL)
3660     return;
3661
3662   for (i = 0; i < *num_list_entries; i++)
3663     deleteArtworkListEntry(artwork_info, &(*list)[i]);
3664   free(*list);
3665
3666   *list = NULL;
3667   *num_list_entries = 0;
3668 }
3669
3670 void FreeCustomArtworkLists(struct ArtworkListInfo *artwork_info)
3671 {
3672   if (artwork_info == NULL)
3673     return;
3674
3675   FreeCustomArtworkList(artwork_info, &artwork_info->artwork_list,
3676                         &artwork_info->num_file_list_entries);
3677
3678   FreeCustomArtworkList(artwork_info, &artwork_info->dynamic_artwork_list,
3679                         &artwork_info->num_dynamic_file_list_entries);
3680 }
3681
3682
3683 /* ------------------------------------------------------------------------- */
3684 /* functions only needed for non-Unix (non-command-line) systems             */
3685 /* (MS-DOS only; SDL/Windows creates files "stdout.txt" and "stderr.txt")    */
3686 /* (now also added for Windows, to create files in user data directory)      */
3687 /* ------------------------------------------------------------------------- */
3688
3689 char *getErrorFilename(char *basename)
3690 {
3691   return getPath2(getUserGameDataDir(), basename);
3692 }
3693
3694 void openErrorFile()
3695 {
3696   InitUserDataDirectory();
3697
3698   if ((program.error_file = fopen(program.error_filename, MODE_WRITE)) == NULL)
3699   {
3700     program.error_file = stderr;
3701
3702     Error(ERR_WARN, "cannot open file '%s' for writing: %s",
3703           program.error_filename, strerror(errno));
3704   }
3705
3706   /* error output should be unbuffered so it is not truncated in a crash */
3707   setbuf(program.error_file, NULL);
3708 }
3709
3710 void closeErrorFile()
3711 {
3712   if (program.error_file != stderr)     /* do not close stream 'stderr' */
3713     fclose(program.error_file);
3714 }
3715
3716 void dumpErrorFile()
3717 {
3718   FILE *error_file = fopen(program.error_filename, MODE_READ);
3719
3720   if (error_file != NULL)
3721   {
3722     while (!feof(error_file))
3723       fputc(fgetc(error_file), stderr);
3724
3725     fclose(error_file);
3726   }
3727 }
3728
3729 void NotifyUserAboutErrorFile()
3730 {
3731 #if defined(PLATFORM_WIN32)
3732   char *title_text = getStringCat2(program.program_title, " Error Message");
3733   char *error_text = getStringCat2("The program was aborted due to an error; "
3734                                    "for details, see the following error file:"
3735                                    STRING_NEWLINE, program.error_filename);
3736
3737   MessageBox(NULL, error_text, title_text, MB_OK);
3738 #endif
3739 }
3740
3741
3742 /* ------------------------------------------------------------------------- */
3743 /* the following is only for debugging purpose and normally not used         */
3744 /* ------------------------------------------------------------------------- */
3745
3746 #if DEBUG
3747
3748 #define DEBUG_PRINT_INIT_TIMESTAMPS             FALSE
3749 #define DEBUG_PRINT_INIT_TIMESTAMPS_DEPTH       10
3750
3751 #define DEBUG_NUM_TIMESTAMPS                    10
3752 #define DEBUG_TIME_IN_MICROSECONDS              0
3753
3754 #if DEBUG_TIME_IN_MICROSECONDS
3755 static double Counter_Microseconds()
3756 {
3757   static struct timeval base_time = { 0, 0 };
3758   struct timeval current_time;
3759   double counter;
3760
3761   gettimeofday(&current_time, NULL);
3762
3763   /* reset base time in case of wrap-around */
3764   if (current_time.tv_sec < base_time.tv_sec)
3765     base_time = current_time;
3766
3767   counter =
3768     ((double)(current_time.tv_sec  - base_time.tv_sec)) * 1000000 +
3769     ((double)(current_time.tv_usec - base_time.tv_usec));
3770
3771   return counter;               /* return microseconds since last init */
3772 }
3773 #endif
3774
3775 char *debug_print_timestamp_get_padding(int padding_size)
3776 {
3777   static char *padding = NULL;
3778   int max_padding_size = 100;
3779
3780   if (padding == NULL)
3781   {
3782     padding = checked_calloc(max_padding_size + 1);
3783     memset(padding, ' ', max_padding_size);
3784   }
3785
3786   return &padding[MAX(0, max_padding_size - padding_size)];
3787 }
3788
3789 void debug_print_timestamp(int counter_nr, char *message)
3790 {
3791   int indent_size = 8;
3792   int padding_size = 40;
3793   float timestamp_interval;
3794
3795   if (counter_nr < 0)
3796     Error(ERR_EXIT, "debugging: invalid negative counter");
3797   else if (counter_nr >= DEBUG_NUM_TIMESTAMPS)
3798     Error(ERR_EXIT, "debugging: increase DEBUG_NUM_TIMESTAMPS in misc.c");
3799
3800 #if DEBUG_TIME_IN_MICROSECONDS
3801   static double counter[DEBUG_NUM_TIMESTAMPS][2];
3802   char *unit = "ms";
3803
3804   counter[counter_nr][0] = Counter_Microseconds();
3805 #else
3806   static int counter[DEBUG_NUM_TIMESTAMPS][2];
3807   char *unit = "s";
3808
3809   counter[counter_nr][0] = Counter();
3810 #endif
3811
3812   timestamp_interval = counter[counter_nr][0] - counter[counter_nr][1];
3813   counter[counter_nr][1] = counter[counter_nr][0];
3814
3815   if (message)
3816 #if 1
3817     Error(ERR_DEBUG, "%s%s%s %.3f %s",
3818 #else
3819     printf("%s%s%s %.3f %s\n",
3820 #endif
3821            debug_print_timestamp_get_padding(counter_nr * indent_size),
3822            message,
3823            debug_print_timestamp_get_padding(padding_size - strlen(message)),
3824            timestamp_interval / 1000,
3825            unit);
3826 }
3827
3828 void debug_print_parent_only(char *format, ...)
3829 {
3830   if (!IS_PARENT_PROCESS())
3831     return;
3832
3833   if (format)
3834   {
3835     va_list ap;
3836
3837     va_start(ap, format);
3838     vprintf(format, ap);
3839     va_end(ap);
3840
3841     printf("\n");
3842   }
3843 }
3844
3845 #endif  /* DEBUG */
3846
3847 void print_timestamp_ext(char *message, char *mode)
3848 {
3849 #if DEBUG_PRINT_INIT_TIMESTAMPS
3850   static char *debug_message = NULL;
3851   static char *last_message = NULL;
3852   static int counter_nr = 0;
3853   int max_depth = DEBUG_PRINT_INIT_TIMESTAMPS_DEPTH;
3854
3855   checked_free(debug_message);
3856   debug_message = getStringCat3(mode, " ", message);
3857
3858   if (strEqual(mode, "INIT"))
3859   {
3860     debug_print_timestamp(counter_nr, NULL);
3861
3862     if (counter_nr + 1 < max_depth)
3863       debug_print_timestamp(counter_nr, debug_message);
3864
3865     counter_nr++;
3866
3867     debug_print_timestamp(counter_nr, NULL);
3868   }
3869   else if (strEqual(mode, "DONE"))
3870   {
3871     counter_nr--;
3872
3873     if (counter_nr + 1 < max_depth ||
3874         (counter_nr == 0 && max_depth == 1))
3875     {
3876       last_message = message;
3877
3878       if (counter_nr == 0 && max_depth == 1)
3879       {
3880         checked_free(debug_message);
3881         debug_message = getStringCat3("TIME", " ", message);
3882       }
3883
3884       debug_print_timestamp(counter_nr, debug_message);
3885     }
3886   }
3887   else if (!strEqual(mode, "TIME") ||
3888            !strEqual(message, last_message))
3889   {
3890     if (counter_nr < max_depth)
3891       debug_print_timestamp(counter_nr, debug_message);
3892   }
3893 #endif
3894 }
3895
3896 void print_timestamp_init(char *message)
3897 {
3898   print_timestamp_ext(message, "INIT");
3899 }
3900
3901 void print_timestamp_time(char *message)
3902 {
3903   print_timestamp_ext(message, "TIME");
3904 }
3905
3906 void print_timestamp_done(char *message)
3907 {
3908   print_timestamp_ext(message, "DONE");
3909 }